1 谈谈你对面向对象的理解？
面向对象的编程---object oriented programming，简称：OOP，是一种编程的思想。OOP把对象当成一个程序的基本单元，一个对象包含了数据和操作数据的函数。面向对象的出现极大的提高了编程的效率，使其编程的重用性增高。
python面向对象的重要术语：
多态（polymorphism）：一个函数有多种表现形式，调用一个方法有多种形式，但是表现出的方法是不一样的。
继承（inheritance）子项继承父项的某些功能，在程序中表现某种联系
封装（encapsulation）把需要重用的函数或者功能封装，方便其他程序直接调用
类：对具有相同数据或者方法的一组对象的集合
对象：对象是一个类的具体事例
实例化：是一个对象事例话的实现
标识：每个对象的事例都需要一个可以唯一标识这个事例的标记
python中的类与对象
class Person(object):
def __init__(self,name): #————————>初始化函数
self.name = name
print "------>create:",name
def say_name(self):
print "my name is %s" %self.name
p1 = Person("gf1") # --------->类的实例化
p2 = Person("gf2")
p1.say_name()
p2.say_name()以上程序是类的一个基本写法，理解如下：
person就是一个类，在这个类中是很多的方法集合。例如类中包含sayname等，还可以按照程序要求灵活添加各种类的方法。
类中self其实就是类的对象，是一个具体的实例。多种的实例通过类中的self表现出来。
程序中的p1、p2是具体的实例，实体。（学名叫：对象。）。一个对象就是一个实体。实体通过调用属性、方法在类中体现相应的功能。
python中的继承
承就是子类继承了父类相应的功能和方法。
如下代码说明了子类继承父类：
class firsttest:
def __init__(self,name):
self._name = name
def sayfirst(self):
print("hello {0}".format(self._name))
class secondtest(firsttest): #子类继承父类（firsttest）的方法
def __init__(self,name):
firsttest.__init__(self,name)
def saysecond(self):
print("good {0}").format(self._name)
s = secondtest("gf1") #类的具体实例。
s.sayfirst()
s.saysecond()函数和面向对象编程的区别
相同点：都是把程序进行封装、方便重复利用，提高效率。
不同点：函数重点是用于整体调用，一般用于一段不可更改的程序。仅仅是解决代码重用性的问题。
而面向对象出来代码重用性。还包括继承、多态等。使用上更加灵活。2 面向对象中super的作用？
Python中对象方法的定义很怪异，第一个参数一般都命名为self（相当于其它语言的this，比如：C#），用于传递对象本身，而在调用的时候则不
必显式传递，系统会自动传递。
今天我们介绍的主角是super(), 在类的继承里面super()非常常用， 它解决了子类调用父类方法的一些问题， 父类多次被调用时只执行一次， 优化了执行逻辑，下面我们就来详细看一下。
举一个例子：
class Foo:
def bar(self, message):
print(message)
>>> Foo().bar("Hello, Python.")
Hello, Python当存在继承关系的时候，有时候需要在子类中调用父类的方法，此时最简单的方法是把对象调用转换成类调用，需要注意的是这时self参数需要显式传递，例如：
class FooParent:
def bar(self, message):
print(message)
class FooChild(FooParent):
def bar(self, message):
FooParent.bar(self, message)
>>> FooChild().bar("Hello, Python.")
Hello, Python.这样做有一些缺点，比如说如果修改了父类名称，那么在子类中会涉及多处修改，另外，Python是允许多继承的语言，如上所示的方法在多继承时就需要重复写多次，显得累赘。为了解决这些问题，Python引入了super()机制，例子代码如下：
class FooParent:
def bar(self, message):
print(message)
class FooChild(FooParent):
def bar(self, message):
super(FooChild, self).bar(message)
>>> FooChild().bar("Hello, Python.")
Hello, Python表面上看 super(FooChild, self).bar(message)方法和FooParent.bar(self, message)方法的结果是一致的，实际上这两种方法的内部处理机制大大不同，当涉及多继承情况时，就会表现出明显的差异来，直接给例子： 代码一：
class A:
def __init__(self):
print("Enter A")
print("Leave A")
class B(A):
def __init__(self):
print("Enter B")
A.__init__(self)
print("Leave B")
class C(A):
def __init__(self):
print("Enter C")
A.__init__(self)
print("Leave C")
class D(A):
def __init__(self):
print("Enter D")
A.__init__(self)
print("Leave D")
class E(B, C, D):
def __init__(self):
print("Enter E")
B.__init__(self)
C.__init__(self)
D.__init__(self)
print("Leave E")
E()结果：
Enter E
Enter B
Enter A
Leave A
Leave B
Enter C
Enter A
Leave A
Leave C
Enter D
Enter A
Leave A
Leave D
Leave E执行顺序很好理解，唯一需要注意的是公共父类A被执行了多次。
代码二：
class A:
def __init__(self):
print("Enter A")
print("Leave A")
class B(A):
def __init__(self):
print("Enter B")
super(B, self).__init__()
print("Leave B")
class C(A):
def __init__(self):
print("Enter C")
super(C, self).__init__()
print("Leave C")
class D(A):
def __init__(self):
print("Enter D")
super(D, self).__init__()
print("Leave D")
class E(B, C, D):
def __init__(self):
print("Enter E")
super(E, self).__init__()
print("Leave E")
E()
print("MRO:", [x.__name__ for x in E.__mro__])Enter E
Enter B
Enter C
Enter D
Enter A
Leave A
Leave D
Leave C
Leave B
Leave E
MRO: ['E', 'B', 'C', 'D', 'A', 'object']在super机制里可以保证公共父类仅被执行一次，至于执行的顺序，是按照MRO（Method Resolution Order）：方法解析顺序 进行的。
3 MRO 多继承属性查找机制
最近在写代码的时候遇到了一个问题，直接实例上代码
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, arg):
print "C","arg=",arg
super(C, self).__init__()
class D(B):
def __init__(self, arg):
print "D", "arg=",arg
super(D, self).__init__()
class E(C,D):
def __init__(self, arg):
print "E", "arg=",arg
super(E, self).__init__(arg)
#print "MRO:", [x.__name__ for x in E.__mro__]
E(10)对于这段代码，我们可能期望输出像这样：
E arg= 10
C arg= 10
A
D arg= 10
B但事实上，这段代码会引发错误，因为python没有像我们想的那样调用正确的函数。
E arg= 10
C arg= 10
A
Traceback (most recent call last):
File "C:/Users/Administrator/Desktop/example1-2.py", line 27, in <module>
E(10)
File "C:/Users/Administrator/Desktop/example1-2.py", line 24, in __init__
super(E, self).__init__(arg)
File "C:/Users/Administrator/Desktop/example1-2.py", line 14, in __init__
super(C, self).__init__()
File "C:/Users/Administrator/Desktop/example1-2.py", line 4, in __init__
super(A, self).__init__()
TypeError: __init__() takes exactly 2 arguments (1 given)我们先给出上面的代码中注释掉的输出mro的语句的输出：
MRO: ['E', 'C', 'A', 'D', 'B', 'object']出错的原因是因为调用继续到A.__init__时，我们调用了super(A,self).__init__。记得上面我们说过super类似于next函数，是调用mro中下一个类型的方法。
这里我们给出的类型是A，那么mro中下一个类型就是D，很显然，super将会调用D.__init__(self)。可是，D.__init__却接受一个额外的参数arg，所以调用错误。
super并不像它的名字那样，只调用父类的方法，而是调用MRO中，下一个类型的方法。
4 是否使用过functools中的函数？其作用是什么？
partial
首先是partial函数，它可以重新绑定函数的可选参数，生成一个callable的partial对象：
>>> int('10') # 实际上等同于int('10', base=10)和int('10', 10)
10
>>> int('10', 2) # 实际上是int('10', base=2)的缩写
2
>>> from functools import partial
>>> int2 = partial(int, 2) # 这里我没写base，结果就出错了
>>> int2('10')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: an integer is required
>>> int2 = partial(int, base=2) # 把base参数绑定在int2这个函数里
>>> int2('10') # 现在缺省参数base被设为2了
2
>>> int2('10', 3) # 没加base，结果又出错了
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: keyword parameter 'base' was given by position and by name
>>> int2('10', base=3)
3
>>> type(int2)
<type 'functools.partial'>从中可以看出，唯一要注意的是可选参数必须写出参数名。
update_wrapper
接着是update_wrapper函数，它可以把被封装函数的__name__、__module__、__doc__和 __dict__都复制到封装函数去：
def thisIsliving(fun):
def living(*args, **kw):
return fun(*args, **kw) + '活着就是吃嘛。'
return living
@thisIsliving
def whatIsLiving():
"什么是活着"
return '对啊，怎样才算活着呢？'
print（whatIsLiving() ）
print（whatIsLiving.__doc__ ）
from functools import update_wrapper
def thisIsliving(fun):
def living(*args, **kw):
return fun(*args, **kw) + '活着就是吃嘛。'
return update_wrapper(living, fun)
@thisIsliving
def whatIsLiving():
"什么是活着"
return '对啊，怎样才算活着呢？'
print（whatIsLiving() ）
print（whatIsLiving.__doc__ ）结果：
对啊，怎样才算活着呢？活着就是吃嘛。
None
对啊，怎样才算活着呢？活着就是吃嘛。
什么是活着不过也没多大用处，毕竟只是少写了4行赋值语句而已。
wraps
再有是wraps函数，它将update_wrapper也封装了进来：
from functools import wraps
def thisIsliving(fun):
@wraps(fun)
def living(*args, **kw):
return fun(*args, **kw) + '活着就是吃嘛。'
return living
@thisIsliving
def whatIsLiving():
"什么是活着"
return '对啊，怎样才算活着呢？'
print（whatIsLiving() ）
print（whatIsLiving.__doc__ ）结果还是一样的：
对啊，怎样才算活着呢？活着就是吃嘛。
什么是活着total_ordering
最后至于total_ordering函数则给予类丰富的排序方法，使用装饰器简化了操作。如果使用必须在类里面定义一个__lt__(),__le__(), __gt__(), 或__ge__()。应该给类添加一个__eq__() 方法。
from functools import total_ordering
@total_ordering
class Student(object):
def __init__(self, name):
self.name = name
def __eq__(self, other):
return self.name.lower() == other.name.lower()
def __lt__(self, other):
return self.name.lower() < other.name.lower()
a = Student('dan')
b = Student('mink')
print（a > b）
print （a）
print （sorted([b, a])）打印结果
False
<__main__.Student object at 0x7f16ecb194d0>
[<__main__.Student object at 0x7f16ecb194d0>, <__main__.Student object at 0x7f16ecb195d0>]5 列举面向对象中带爽下划线的特殊方法，如：__new__、__init__
类的特殊成员方法
__doc__ ：打印类的描述信息
class Foo:
""" 描述类信息，这是用于看片的神奇 """
def func(self):
pass
print(Foo.__doc__)
#输出：类的描述信息__module__:表示当前操作的对象在那个模块
__class__：表示当前操作的对象的类是什么
from lib.aa import C
obj = C()
print(obj.__module__) # 输出 lib.aa，即：输出模块
print(obj.__class__) # 输出 lib.aa.C，即：输出类__init__ ：构造方法，通过类创建对象时，自动触发执行
class Role(object):
#初始化函数，在生成一个角色时要 初始化的一些属性就填写在这里
def __init__(self,name,role,weapon,life_value=100,money=15000):
#__init__中的第一个参数self,和这里的self都 是什么意思？ 看下面解释
self.name = name
self.role = role__del__:析构方法，当对象在内存中被释放时，自动触发执行
class Role(object):
def __init__(self,name,role,weapon:
self.name = name
self.role = role
self.weapon = weapon
def __del__(self): #析构函数
print("del.....run...")
r1 = Role('A','police','AK47') #生成一个角色__call__:对象后面加括号，触发执行
#注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
class Foo:
def __init__(self):
pass
def __call__(self, *args, **kwargs):
print('__call__')
obj = Foo() # 执行 __init__
obj() # 执行 __call____dict__:查看类或对象中的所有成员
print(类.__dict__) # 打印类里所有属性，不包括实例属性
print(实例.__dict__) #打印实例所有属性，不包括类属性__str__：如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值
class Foo:
def __str__(self):
return 'a li'
obj = Foo()
print(obj)
# 输出：a li