Python⾯试题之Python⾯向对象编程汇总
⾯向对象的设计思想是从⾃然界中来的，因为在⾃然界中，类（Class）和实例（Instance）的概念是很⾃然的。Class是⼀种抽象概念，⽐如我们定义的Class——Student，是指学⽣这个概念，⽽实例（Instance）则是⼀个个具体的Student，⽐如，Bart Simpson和Lisa Simpson是两个具体的Student。
⾯向对象的抽象程度⼜⽐函数要⾼，因为⼀个Class既包含数据，⼜包含操作数据的⽅法。
数据封装、继承和多态是⾯向对象的三⼤特点，我们后⾯会详细讲解。
类和实例
类(Class)和实例(Instance)是⾯向对象最重要的概念。
类是指抽象出的模板。实例则是根据类创建出来的具体的“对象”，每个对象都拥有从类中继承的相同的⽅法，但各⾃的数据可能不同。
在python中定义⼀个类:
classStudent(object):
pass
关键字class后⾯跟着类名，类名通常是⼤写字母开头的单词，紧接着是(object)，表⽰该类是从哪个类继承下来的。通常，如果没有合适的继承类，就使⽤object类，这是所有类最终都会继承下来的类。
定义好了类，就可以根据Student类创建实例：
>>> classStudent(object):
... pass
...
>>> bart = Student() # bart是Student()的实例
>>> bart
<__main__.Student object at 0x101be77f0>
>>> Student # Student 本⾝是⼀个类
<class'__main__.Student'>
可以⾃由地给⼀个实例变量绑定属性，⽐如，给实例bart绑定⼀个name属性：
>>> bart.name = "diggzhang"
>>> bart.name
'diggzhang'
类同时也可以起到模板的作⽤，我们可以在创建⼀个类的时候，把⼀些认为公共的东西写进类定义中去，在python中通过⼀个特殊的__init__⽅法实现：
classStudent(object):
"""__init__ sample."""
def__init__(lf,name,score):
lf.name = name
lf.score = score
__init__⽅法的第⼀个参数永远都是lf，表⽰创建实例本⾝，在__init__⽅法内部，可以把各种属性绑定到lf，因为lf指向创建的实例本⾝。
有了__init__⽅法，在创建实例的时候，就不能传⼊空的参数了，必须传⼊与__init__⽅法匹配的参数，但lf不需要传，Python解释器⾃⼰会把实例变量传进去。如下⾯的类，在新建实例的时候，需要把name和score属性捆绑上去：
classStudent(object):
"""example for __init__ function passin args."""
def__init__(lf,name,score):
lf.name = name
lf.score = score
我们直接看个实例，如果我们⽼⽼实实传name和score进去的时候，成功声明了这个实例，但是只传⼀个值的时候，报错：
In [1]: class Student(object):
...: def__init__(lf, name, score):
...: lf.name = name
...: lf.score = score
...:
In [2]: bart = Student('diggzhang', 99)
In [3]: bart.name
Out[3]: 'diggzhang'
In [4]: bart.score
Out[4]: 99
In [5]: bart_test = Student('max')
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-6-97f4e2f67951> in <module>()
----> 1 bart_test = Student('max')
TypeError: __init__() takes exactly 3 arguments (2 given)
和普通函数相⽐，在类中定义的函数只有⼀点不同，就是第⼀个参数永远是实例变量lf，并且，调⽤时，不⽤传递该参数。除此之外，类的⽅法和普通函数没有什么区别。
⾯向对象编程的⼀个重要特点就是数据封装。在上⾯的Student类中，每个实例就拥有各⾃的name和score这些数据。我们可以通过函数来访问这些数据，⽐如打印⼀个学⽣的成绩：
defprint_socre(std):
print("%s: %s" % (std.name, std.score))
print_socre(bart)
# 实际执⾏效果
In [7]: defprint_socre(std):
...: print("%s: %s" % (std.name, std.score))
...:
In [8]: print_socre(bart)
diggzhang: 99
既然我们创建的实例⾥有⾃⾝的数据，如果想访问这些数据，就没必要从外⾯的函数去访问，可以在Student类内部去定义这样⼀个访问数据的函数，这样就把“数据”给封装起来了。这些封装数据的函数和Student类本⾝关联起来的，我们称之为类的⽅法：
classStudent(object):
def__init__(lf,name,score):
lf.name = name
lf.score = score
defprint_socre(lf):
邮政储蓄利率print("%s: %s" % (lf.name, lf.score))
要定义⼀个类的⽅法，除了传⼊的第⼀个参数是lf外，其它和普通函数⼀样。如果想调⽤这个⽅法，直接在实例变量上调⽤，除了lf不⽤传递，其余参数正常传⼊:
>>> bart.print_score()
田兵
Bart Simpson: 59
实际代码，需要在Python3环境中测试，Python2.7会报错(NameError: global name 'name' is not defined)
$ python3
Python 3.5.1 (v3.5.1:37a07cee5969, Dec 5 2015, 21:12:44)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits"or"licen"for more information.
>>> classStudent(object):
... def__init__(lf,name,score):
... lf.name = name
... lf.score = score
... defprint_score(lf):
... print("%s: %s" % (lf.name, lf.score))
...
>>> bart = Student('zhang', 99)
>>> bart.print_score()
zhang: 99
>>>
数据和逻辑都被封装起来，直接调⽤⽅法即可，但却可以不⽤知道内部的细节。
总结⼀下。
类是创建实例的模板，⽽实例则是⼀个⼀个具体的对象，各个实例拥有的数据都互相独⽴，互不影响；
⽅法就是与实例绑定的函数，和普通函数不同，⽅法可以直接访问实例的数据；
通过在实例上调⽤⽅法，我们就直接操作了对象内部的数据，但⽆需知道⽅法内部的实现细节。
和静态语⾔不同，Python允许对实例变量绑定任何数据，也就是说，对于两个实例变量，虽然它们都是同⼀个类的不同实例，但拥有的变量名称都可能不同：
# ⽤相同类创建了两个不同实例
>>> bart = Student('Bart Simpson', 59)
>>> lisa = Student('Lisa Simpson', 87)
# 给其中⼀个实例绑定了⼀个变量名age
>>> bart.age = 8
>>> bart.age
8
# 另⼀个同类实例中是没有age的
>>> lisa.age
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute 'age'
>>>
⾄此，总算搞明⽩了什么是类，什么是对象。如何定义类，如何定义类内的⽅法。同类创建出的不同实例的相同和不同。
封装
在Class内部，可以有属性和⽅法，⽽外部代码可以通过直接调⽤实例变量的⽅法来操作数据，这样，就隐藏了内部的复杂逻辑。
但是，从前⾯Student类的定义来看，外部代码还是可以⾃由地修改⼀个实例的name、score属性：
>>> bart = Student('Bart Simpson', 98)
>>> bart.score
98
>>> bart.score = 59
>>> bart.score
59
如果想让内部属性不被外部访问，可以把属性的名称前加上两个下划线__，在Python中，实例的变量名如果以双下划线开头，就变成了⼀个私有变量(private)，只有内部可以访问，外部不能访问：
classStudent(object):
def__init__(lf,name,score):
lf.__name = name
lf.__score = score
defprint_score(lf):
print('%s: %s' % (lf.__name, lf.__score))
改完后，对于外部代码来说，没有什么变动，但是已经⽆法从外部访问到实例变量.__name和实例变量：
>>> bart = Student('Bart Simpson', 98)
>>> bart.__name
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute '__name'
这样就确保了外部代码不能随意修改对象内部的状态，这样通过访问限制的保护，代码更加健壮。
如果外部还需要访问到这两个内部状态的话，可以给Student类增加get_name和get_score这样的⽅法。如果外部还有修改需求的话，就给该类再增加t_score或t_name⽅法。⽤这样的⽅式去get t ⼀个内部保护量：
classStudent(object):
defget_name(lf):
return lf.__name
defget_score(lf):
return lf.__score
deft_name(lf,name):
lf.__name = name
deft_score(lf,score):
lf.__score = score抱德炀和
# 对于t_score(lf, score)我们可以借由t⽅法顺便做参数检查，提⾼代码安全性
deft_safe_score(lf,score):
if score >= 0 and score <= 100:
lf.__score = score
el:
rai ValueError('bad score')
需要注意的是，Python中如果变量名以双下划线开头和结尾的，是特殊变量__XXX__。特殊变量是可以直接从类内部访问的。
有些时候，你会看到以⼀个下划线开头的实例变量名，⽐如_name，这样的实例变量外部是可以访问的，但是，按照约定俗成的规定，当你看到这样的变量时，意思就是，“虽然我可以被访问，但是，请把我视为私有变量，不要随意访问”。
双下划线开头的实例变量是不是⼀定不能从外部访问呢？其实也不是。不能直接访问__name是因为Python解释器对外把__name变量改成了_Student__name，所以，仍然可以通
过_Student__name来访问__name变量：
>>> bart._Student__name
'Bart Simpson'
但是强烈建议你不要这么⼲，因为不同版本的Python解释器可能会把__name改成不同的变量名。
Python的访问限制其实并不严格，主要靠⾃觉。
继承和多态
在OOP程序设计中，当我们定义⼀个class的时候，可以从某个现有的class继承，新的class称为⼦类（Subclass），⽽被继承的class称为基类、⽗类或超类（Ba class、Super class）。
⽐如，我们已经编写了⼀个名为Animal的class，有⼀个run()⽅法可以直接打印⼀句话，然后新建⼀个叫Dog的类，继承了Animal类：
classStudent(object):
defget_name(lf):
return lf.__name
defget_score(lf):
return lf.__score
deft_name(lf,name):
lf.__name = name
deft_score(lf,score):
苦瓜烧排骨lf.__score = score
# 对于t_score(lf, score)我们可以借由t⽅法顺便做参数检查，提⾼代码安全性
deft_safe_score(lf,score):
if score >= 0 and score <= 100:
lf.__score = score
el:
rai ValueError('bad score')
对于Dog来说，Animal就是它的⽗类，对于Animal来说，Dog就是它的⼦类。
⼦类获得了⽗类的全部功能。Dog()⾥继承了run()函数，可以给⾃⼰的实例⾥直接⽤。
那么问题来了，⼦类和⽗类如果定义的时候都有个run()，会发⽣什么？
classAnimal(object):
雨的谜语defrun(lf):
print('')
classDog(Animal):
defrun(lf):
print("")
classCat(Animal):
defrun(lf):
print("")
# 结果如下
Dog
Cat
⼦类的的⽅法如果和⽗类的⽅法重名，⼦类会覆盖掉⽗类。因为这个特性，就获得了⼀个继承的好处”多态”。
当我们定义⼀个class的时候，实际上也就是定义了⼀种数据类型。跟list str dict⼀个意思。使⽤isinstance(待判断值, 数据类型)可以做数据类型判定。
5万左右买什么车好>>> a = list()
>>> b = Animal()
>>> c = Dog()
>>> isinstance(a, list)
True
>>> isinstance(a, dict)
Fal
>>> isinstance(b, Animal)
True
>>> isinstance(c, Dog)
True
有意思的是，Dog继承⾃Animal，那么Dog的实例同事也是Animal数据类型：
>>>isinstance(c, Animal)
True
# 但是如果继承⾃⽗类，想跟⼦类去做判断的话返回Fal
>>>isinstance(b, Dog)
Fal
要理解多态的好处，我们还需要再编写⼀个函数，这个函数接受⼀个Animal类型的变量：
"""
run_twice() 函数接收了⼀个`Animal`类型的变量
"""
defrun_twice(animal):
animal.run()
animal.run()
>>>defrun_twice(animal):
... animal.run()
... animal.run()
...
"""
当我们将Animal()的实例传⼊run_twice中...
"""
>>>run_twice(Animal())
<
盗号木马生成器
<
"""
当我们将Dog()的实例传⼊run_twice中...
"""
>>>run_twice(Dog())
<
<
>>>
看上去没啥意思，但是仔细想想，现在，如果我们再定义⼀个Tortoi类型，也从Animal派⽣：
>>>classTortoi(Animal):
... defrun(lf):
.
.. print("Tortoi is ")
...
"""
当我们调⽤run_twice()时，传⼊Tortoi的实例
"""
>>>run_twice(Tortoi())
Tortoi is
Tortoi is
>>>
Tortoi作为Animal的⼦类，不必对run_twice()做任何修改。实际上，任何依赖Animal作为参数的函数或者⽅法都可以不加修改地正常运⾏，原因在于多态。
多态的好处就是，当我们需要传⼊Dog、Cat、Tortoi……时，我们只需要接收Animal类型就可以了，因为Dog、Cat、Tortoi……都是Animal类型，然后，按照Animal类型进⾏操作即可。由于Animal类型有run()⽅法，因此，传⼊的任意类型，只要是Animal类或者⼦类，就会⾃动调⽤实际类型的run()⽅法，这就是多态的意思：
对于⼀个变量，我们只需要知道它是Animal类型，⽆需确切地知道它的⼦类型，就可以放⼼地调⽤run()⽅法，⽽具体调⽤的run()⽅法是作⽤在Animal、Dog、Cat还是Tortoi对
象上，由运⾏时该对象的确切类型决定，这就是多态真正的威⼒：调⽤⽅只管调⽤，不管细节，⽽当我们新增⼀种Animal的⼦类时，只要确保run()⽅法编写正确，不⽤管原来的
代码是如何调⽤的。这就是著名的“开闭”原则：
对扩展开放：允许新增Animal⼦类；
对修改封闭：不需要修改依赖Animal类型的run_twice()等函数。
对于静态语⾔（例如Java）来说，如果需要传⼊Animal类型，则传⼊的对象必须是Animal类型或者它的⼦类，否则，将⽆法调⽤run()⽅法。
对于Python这样的动态语⾔来说，则不⼀定需要传⼊Animal类型。我们只需要保证传⼊的对象有⼀个run()⽅法就可以了：
classTimer(object):
defrun(lf):
print('')
这就是动态语⾔的“鸭⼦类型”，它并不要求严格的继承体系，⼀个对象只要“看起来像鸭⼦，⾛起路来像鸭⼦”，那它就可以被看做是鸭⼦。
Python的“file-like object“就是⼀种鸭⼦类型。对真正的⽂件对象，它有⼀个read()⽅法，返回其内容。但是，许多对象，只要有read()⽅法，都被视为“file-like object“。许多函数
接收的参数就是“file-like object“，你不⼀定要传⼊真正的⽂件对象，完全可以传⼊任何实现了read()⽅法的对象。
总结⼀下：
继承可以把⽗类的所有功能都直接拿过来，这样就不必重零做起，⼦类只需要新增⾃⼰特有的⽅法，也可以把⽗类不适合的⽅法覆盖重写。
动态语⾔的鸭⼦类型特点决定了继承不像静态语⾔那样是必须的。
获取对象信息
当我们拿到⼀个对象的引⽤时，如何知道这个对象是什么类型、有哪些⽅法呢？
type()可以检查类型。⽤法超级简单：
>>> type(123)
<class'int'>>>> type('helloworld')<class'str'>>>> type(None)<class'NoneType'>>>> type(abs)<class'builtin_function_or_method'>>>> type(a)<class'list'>>>> type(Animal)<class'type'>>>> type(Dog)<class'type'>>>> type(Dog())< type()经常被⽤来做类型⽐较：
>>>type(123) == type(456)
True
>>>type(123) == int
True
>>>type(123) == type('123')
Fal
判断基本数据类型可以直接写int，str等，但如果要判断⼀个对象是否是函数怎么办？可以使⽤types模块中定义的常量：
>>>import types
>>>deffn():
... pass
...
>>>type(fn) == types.FunctionType
True
>>>type(abs) == types.BuiltinFunctionType
True
>>>type(lambda x: x)==types.LambdaType
True
>>>type((x for x in range(10)))==types.GeneratorType
True
还有⼤杀器isinstance()。
对于class的继承关系来说，使⽤type()就很不⽅便。我们要判断class的类型，可以使⽤isinstance()函数。
我们回顾上次的例⼦，如果继承关系是：
object -> Animal -> Dog -> Husky
那么，isinstance()就可以告诉我们，⼀个对象是否是某种类型。这玩意⼉也是上⼿熟系列：
>>> a = Animal()
>>> b = Dog()
>>> isinstance(c, Animal)
True
>>> isinstance(c, Dog)
True
>>> isinstance(a, Animal)
True
>>> isinstance(a, Dog)
Fal
还可以判断⼀个变量是否是某些类型中的⼀种，⽐如下⾯的代码就可以判断是否是list或者tuple：
>>>isinstance([1, 2, 3], (list, tuple))
True
>>>isinstance((1, 2, 3), (list, tuple))
True
>>>isinstance((1, 2, 3), (tuple))
True
>>>isinstance((1, 2, 3), (list))
Fal
最后⼀个⼤杀器dir()。
如果要获得⼀个对象的所有属性和⽅法，可以使⽤dir()函数，它返回⼀个包含字符串的list，⽐如，获得⼀个str对象的所有属性和⽅法：
dir('ABC')
[........,'__add__',.....,'__len__',...,'lower','upper'...]
类似__xxx__的属性和⽅法在Python中都是有特殊⽤途的，⽐如__len__⽅法返回长度。在Python中，如果你调⽤len()函数试图获取⼀个对象的长度，实际上，在len()函数内
部，它⾃动去调⽤该对象的__len__()⽅法，所以，下⾯的代码是等价的：
>>> len('ABC')
3
>>> 'ABC'.__len__()
3
我们⾃⼰写的类，如果也想⽤len(myObj)的话，就⾃⼰写⼀个__len__()⽅法：
>>> classMyDog(object):
... def__len__(lf):
... return 100
...
>>> dog = MyDog()
>>> len(dog)
100
dir()返回的⾮双下划线样⼦的，都是普通属性或⽅法，⽐如lower:
>>> 'ABC'.lower()
'abc'
当然既然能列出这属性和⽅法，也可以相应的修改。python准备了getattr()、tattr()、hasattr()，可以直接操作⼀个对象的状态：
>>> classMyObject(object):
... def__init__(lf):
... lf.x = 9
... defpower(lf):
... return lf.x + lf.x
...
>>> obj = MyObject()
>>> hasattr(obj, 'x') # 有属性'x'吗？
True
>>> obj.x
9
>>> hasattr(obj, 'y') # 有属性'y'吗？
Fal
>>> tattr(obj, 'y', 19) # 设置⼀个属性'y'
>>> hasattr(obj, 'y') # 有属性'y'吗？
True
>>> getattr(obj, 'y') # 获取属性'y'
19
>>> obj.y # 获取属性'y'
19
>>> hasattr(obj, 'power') # 有属性'power'吗？
True
>>> getattr(obj, 'power') # 获取属性'power'
<bound method MyObject.power of <__main__.MyObject object at 0x10077a6a0>>>>> fn = getattr(obj, 'power') # 获取属性'power'并赋值到变量fn
>>> fn # fn指向obj.power
<bound method MyObject.power of <__main__.MyObject object at 0x10077a6a0>>>>> fn() # 调⽤fn()与调⽤obj.power()是⼀样的
81
实际编码过程中，可以设置⼀个default值，如果属性不存在，就返回默认值：
>>> getattr(obj, 'k', 404)
404
摧毁的英文通过内置的⼀系列函数，我们可以对任意⼀个Python对象进⾏剖析，拿到其内部的数据。要注意的是，只有在不知道对象信息的时候，我们才会去获取对象信息。如果可以直接写：
>>> getattr(obj, 'k', 404)
404
就不要写：
sum = getattr(obj, 'x') + getattr(obj, 'y')
⼀个正确的⽤法如下：
defreadImage(fp):
if hasattr(fp, 'read'):
return readData(fp)
return None
假设我们希望从⽂件流fp中读取图像，我们⾸先要判断该fp对象是否存在read⽅法，如果存在，则该对象是⼀个流，如果不存在，则⽆法读取。hasattr()就派上了⽤场。
请注意，在Python这类动态语⾔中，根据鸭⼦类型，有read()⽅法，不代表该fp对象就是⼀个⽂件流，它也可能是⽹络流，也可能是内存中的⼀个字节流，但只要read()⽅法返回的是有效的图像数据，就不影响读取图像的功能。
如果你成功看到这部分，你可以跟⾃⼰说：“来了，这份感觉终于来了，我的⼈⽣开始赢了。”
实例属性和类属性
由于Python是动态语⾔，根据类创建的实例可以任意绑定属性。那就会有这种情况：
classStudent(object):
name = 'Student'
类的名字是Student，类⾥的属性也叫Student。这会导致⿊⼈问号脸。
>>> classStudent(object):
... name = 'Student'
...
>>> s = Student() # 创建实例s
>>> print(s.name) # 打印name属性，因为实例并没有name属性，所以会继续查找class的name属性
Student
>>> print(Student.name) # 打印类的name属性
Student
>>> s.name = 'Michael'# 给实例绑定name属性
>>> print(s.name) # 由于实例属性优先级⽐类属性⾼，因此，它会屏蔽掉类的name属性
Michael
>>> print(Student.name) # 但是类属性并未消失，⽤Student.name仍然可以访问
Student
>>> del s.name # 如果删除实例的name属性
>>> print(s.name) # 再次调⽤s.name，由于实例的name属性没有找到，类的name属性就显⽰出来了
Student
从上⾯的例⼦可以看出，在编写程序的时候，千万不要把实例属性和类属性使⽤相同的名字，因为相同名称的实例属性将屏蔽掉类属性，但是当你删除实例属性后，再使⽤相同的名称，访问到的将是类属性
数据封装、继承和多态只是⾯向对象程序设计中最基础的3个概念。在Python中，⾯向对象还有很多⾼级特性，允许我们写出⾮常强⼤的功能。
接下来我们会讨论多重继承、定制类、元类等概念。
使⽤ slots
正常情况下，当我们定义了⼀个class，创建了⼀个class的实例后，我们可以给该实例绑定任何属性和⽅法。但是，如果我们想要限制实例的属性怎么办？
为了达到限制的⽬的，Python允许在定义class的时候，定义⼀个特殊的__slots__变量，来限制该class实例能添加的属性：
classStudent(object):
__slots__ = ('name', 'age') # ⽤tuple定义允许绑定的属性名称
