面向对象-总结练习题

1.面向对象三大特性，各有什么用处，说说你的理解。
    继承：解决代码重用问题
    多态：多态性，可以在不考虑对象类型的情况下而直接使用对象
    封装：明确的区分内外，控制外部对隐藏属性的操作行为，隔离复杂度
2.类的属性和对象的属性有什么区别?
    类的属性：数据属性和函数属性，数据属性是所有对象共有的，函数属性是绑定给对象使用的
    对象的属性：对象是类的实例化
3.面向过程编程与面向对象编程的区别与应用场景?
    面向过程：复杂的问题流程化，简单化      应用场景：不在需要扩展了，监控脚本，自动部署脚本，软件解压安装
    面向对象：特征与技能的结合体 一切皆对象  应用场景：用户需求经常变化，互联网应用，游戏，企业内部应用
4.类和对象在内存中是如何保存的。
    类和对象的属性：以字典的形式保存的。
5.什么是绑定到对象的方法、绑定到类的方法、解除绑定的函数、如何定义，如何调用，给谁用？有什么特性
    绑定到对象的方法：就应该由对象来调用，def tell_info(self):...  obj.tell_info()
    绑定到类的方法：就应该由类来调用，@classmethod def from_conf(cls):... class.from_conf()
    非绑定方法：不与类或对象绑定，谁都可以调用，@staticmethod def create_id():... obj.create_if()/class.create_id()
6.使用实例进行 获取、设置、删除 数据, 分别会触发类的什么私有方法

class A(object):
    def __setitem__(self, key, value):
        self.__dict__[key] = value

    def __getitem__(self, item):
        # return self.__dict__[item]
        return self.__dict__.get(item)

    def __delitem__(self, key):
        del self.__dict__[key]

a = A()
a["key"] = "val"
print(a.__dict__)
# a = a["key"]
# print(a)
del a["key"]
print(a.__dict__)

7.python中经典类和新式类的区别
    经典类:py2 没有继承object的类,以及它的子类都称之为经典类 -->深度优先     
    新式类:py3 继承object的类,以及它的子类都称之为新式类 -->广度优先

8.如下示例, 请用面向对象的形式优化以下代码

# 1、在没有学习类这个概念时，数据与功能是分离的
def exc1(host,port,db,charset):
    conn=connect(host,port,db,charset)
    conn.execute(sql)
    return xxx
def exc2(host,port,db,charset,proc_name)
    conn=connect(host,port,db,charset)
    conn.call_proc(sql)
    return xxx
# # 每次调用都需要重复传入一堆参数
exc1('127.0.0.1',3306,'db1','utf8','select * from tb1;')
exc2('127.0.0.1',3306,'db1','utf8','存储过程的名字')

class exec:
    def __init__(self,proc_name):
        self.host='127.0.0.1'
        self.port=3306
        self.db='db1'
        self.charset='utf-8'
        self.proc_name=proc_name

ex=exec('存储名称')
ex2=exec('存储名称2')
print(ex.__dict__)
print(ex2.__dict__)

9.示例1, 现有如下代码， 会输出什么：

class People(object):
    __name = "luffy"
    __age = 18


p1 = People()
# print(p1.__name, p1.__age)
'''
AttributeError: 'People' object has no attribute '__name'
'''
#__name被转化为了_People__name
'''

10.示例2, 现有如下代码，会输出什么：

class People(object):

   def __init__(self,name):
       print("__init__")

   def __new__(cls, *args, **kwargs):
       print("__new__")
       print(args,kwargs)
       return object.__new__(cls)

# People('alice')
'''
__new__
__init__

__new__是在__init__之前被调用的特殊方法
__new__是用来创建对象并返回的方法
而__init__只是用来将传入的参数初始化给对象
你很少用到__new__,除非你希望能够控制对象的创建

'''

11.请简单解释Python中 staticmethod（静态方法）和 classmethod（类方法）, 并分别补充代码执行下列方法。
　　　　静态方法：非绑定方法，类和对象都可调用
　　　　类方法：绑定给类的方法，类调用

class A(object):
    def __init__(self,name):
        self.name=name

    def foo(self, x):
        print("executing foo(%s, %s)" % (self,x))

    @classmethod
    def class_foo(cls, x):
        print("executing class_foo(%s, %s)" % (cls,x))

    @staticmethod
    def static_foo(x):
        print("executing static_foo(%s)" % (x))

# a = A('alice')
# a.foo('alice')
# A.class_foo('alice')
# a.static_foo('alice')
# A.static_foo('alice')
'''
executing foo(<__main__.A object at 0x000002A5FED12AC8>, alice)
executing class_foo(<class '__main__.A'>, alice)
executing static_foo(alice)
executing static_foo(alice)
'''

12.请执行以下代码，解释错误原因，并修正错误。
    　错误原因：@property 可将函数属性转化为数据属性

class Dog(object):
   def __init__(self,name):
       self.name = name

   @property
   def eat(self):
       print(" %s is eating" %self.name)

d = Dog("ChenRonghua")
# d.eat() 错误的
# d.eat 正确的

13.下面这段代码的输出结果将是什么？请解释。

class Parent(object):
   x = 1

class Child1(Parent):
   pass

class Child2(Parent):
   pass

# print(Parent.x, Child1.x, Child2.x)
# Child1.x = 2
# print(Parent.x, Child1.x, Child2.x)
# Parent.x = 3
# print(Parent.x, Child1.x, Child2.x)

# 1 1 1 继承自父类的类属性x，所以都一样，指向同一块内存地址
# 1 2 1 更改Child1，Child1的x指向了新的内存地址
# 3 2 3 更改Parent，Parent的x指向了新的内存地址

14.多重继承的执行顺序，请解答以下输出结果是什么？并解释。
super()表示的是子类的mro()列表中的下一个
print(G.mro())
[<class '__main__.G'>, <class '__main__.D'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]
print(F.mro())
[<class '__main__.F'>, <class '__main__.C'>, <class '__main__.B'>, <class '__main__.D'>, <class '__main__.A'>, <class 'object'>]

class A(object):
   def __init__(self):
       print('A')
       super(A, self).__init__()

class B(object):
   def __init__(self):
       print('B')
       super(B, self).__init__()

class C(A):
   def __init__(self):
       print('C')
       super(C, self).__init__()

class D(A):
   def __init__(self):
       print('D')
       super(D, self).__init__()

class E(B, C):
   def __init__(self):
       print('E')
       super(E, self).__init__()

class F(C, B, D):
   def __init__(self):
       print('F')
       super(F, self).__init__()

class G(D, B):
   def __init__(self):
       print('G')
       super(G, self).__init__()

# if __name__ == '__main__':
   # g = G()
   # f = F()
   # print(G.mro())
   # print(F.mro())

# G
# D
# A
# B
#
# F
# C
# B
# D
# A
# [<class '__main__.G'>, <class '__main__.D'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]
# [<class '__main__.F'>, <class '__main__.C'>, <class '__main__.B'>, <class '__main__.D'>, <class '__main__.A'>, <class 'object'>]

面向对象-总结练习题

猜你喜欢