第7章-扩展内容
[toc]
python面向对象
基础篇
三种编程方式
面向过程：根据业务逻辑从上到下写垒代码 函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可 面向对象：对函数进行分类和封装，让开发“更快更好更强…”
面向过程编程最易被初学者接受，其往往用一长段代码来实现指定功能，开发过程中最常见的操作就是粘贴复制，即：将之前实现的代码块复制到现需功能处。
while True: if cpu利用率 > 90%: # 发送邮件提醒 连接邮箱服务器 发送邮件 关闭连接
if 硬盘使用空间 > 90%: # 发送邮件提醒 连接邮箱服务器 发送邮件 关闭连接
if 内存占用 > 80%: # 发送邮件提醒 连接邮箱服务器 发送邮件 关闭连接随着时间的推移，开始使用了函数式编程，增强代码的重用性和可读性，就变成了这样：
def 发送邮件(内容) #发送邮件提醒 连接邮箱服务器 发送邮件 关闭连接
while True：
if cpu利用率 > 90%: 发送邮件('CPU报警')
if 硬盘使用空间 > 90%: 发送邮件('硬盘报警')
if 内存占用 > 80%: 发送邮件('内存报警')今天我们来学习一种新的编程方式：面向对象编程（Object Oriented Programming，OOP，面向对象程序设计）。
创建类和对象
面向对象编程是一种编程方式，此编程方式的落地需要使用 “类” 和 “对象” 来实现， 所以面向对象编程其实就是对 “类” 和 “对象” 的使用。
- 类就是一个模板，模板里可以包含多个函数，函数里实现一些功能
- 对象则是根据模板创建的实例，通过实例对象可以执行类中的函数
# 创建Test类,python3 初始类都继承object类class Test(object): # 类中定义的函数也叫方法 def demo(self): # 类中的函数第一个参数必须是self print("self=", self) print("Method=", dir(self)) print("Hello")
# 根据类Test创建对象objobj = Test() # 类名加括号obj.demo() # 执行demo方法
# 获取一个实例的类名print(obj.__class__.__name__)
# 判断一个对象是否拥有某个属性if hasattr(obj, 'demo'): print("it has demo method")else: print("have no method")返回结果：
self= <__main__.Test object at 0x00000224F3539A58>Method= ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'demo']Hello结论：
方法的第一个参数是调用这个方法的实例对象本身. 从上面结果可以看出来self对于代码不是特殊的，只是另一个对象.
面向对象三大特性
1.封装
封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。 所以，在使用面向对象的封装特性时，需要：
- 将内容封装到某处
- 从某处调用被封装的内容
# 1. 将内容封装到某处class Test(object): # __init__方法成为构造方法，根据类创建对象时自动执行 def __init__(self, name): self.name = name
def detail(self): print(self.name)
# 自动执行__init__方法# 将tony封装到obj self的name属性中# 当执行obj,self等于objobj = Test('tony')
# 2.从某处调用封装的内容# 通过对象直接调用, 格式:对象.属性名print(obj.name)
# 通过self调用# python默认会将obj传给self参数，即obj.detail(obj)# 此时方法内部的self=obj,所以 self.name='tony'print(obj.detail())综上所述，对于面向对象的封装来说，其实就是使用构造方法将内容封装到 对象 中，然后通过对象直接或者self间接获取被封装的内容。
#####2.继承 继承，面向对象中的继承和现实生活中的继承相同，即：子可以继承父的内容。
例如： 猫可以：喵喵叫、吃、喝、拉、撒 狗可以：汪汪叫、吃、喝、拉、撒
如果我们要分别为猫和狗创建一个类，那么就需要为 猫 和 狗 实现他们所有的功能
class 猫： def 喵喵叫(self): print '喵喵叫' def 吃(self): # do something def 喝(self): # do something def 拉(self): # do something def 撒(self): # do something
class 狗： def 汪汪叫(self): print '喵喵叫' def 吃(self): # do something def 喝(self): # do something def 拉(self): # do something def 撒(self): # do something上述代码不难看出，吃、喝、拉、撒是猫和狗都具有的功能，而我们却分别的猫和狗的类中编写了两次。如果使用 继承 的思想，如下实现：
动物：吃、喝、拉、撒 猫：喵喵叫（猫继承动物的功能） 狗：汪汪叫（狗继承动物的功能）
class 动物:
def 吃(self): # do something
def 喝(self): # do something
def 拉(self): # do something
def 撒(self): # do something
# 在类后面括号中写入另外一个类名，表示当前类继承另外一个类class 猫(动物)：
def 喵喵叫(self): print '喵喵叫'
# 在类后面括号中写入另外一个类名，表示当前类继承另外一个类class 狗(动物)：
def 汪汪叫(self): print '喵喵叫'所以，对于面向对象的继承来说，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法。
class Animal(object): def eat(self): print("%s 吃 " % self.name)
def drink(self): print("%s 喝 " % self.name)
def shit(self): print("%s 拉 " % self.name)
def pee(self): print("%s 撒 " % self.name)
class Cat(Animal): def __init__(self, name): self.name = name self.breed = '猫'
def cry(self): print('喵喵叫')
class Dog(Animal): def __init__(self, name): self.name = name self.breed = '狗'
def cry(self): print('汪汪叫')
c1 = Cat('小白家的小黑猫')c1.eat()
c2 = Cat('小黑的小白猫')c2.drink()
d1 = Dog('胖子家的小瘦狗')d1.eat()那么问题又来了，多继承呢？
- 是否可以继承多个类
- 如果继承的多个类每个类中都定了相同的函数，那么那一个会被使用呢？
1、Python的类可以继承多个类，Java和C#中则只能继承一个类 2、Python的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先和广度优先
新式类与经典类
注意：
当类是经典类时，多继承情况下，会按照深度优先方式查找 -
找到第一个当类是新式类时，多继承情况下，会按照广度优先方式查找 -找到最后一个
经典类和新式类，从字面上可以看出一个老一个新，新的必然包含了跟多的功能，也是之后推荐的写法
从写法上区分的话，如果 当前类或者父类继承了object类，那么该类便是新式类，否则便是经典类。
经典类 -python2.7测试
class D: def bar(self): print 'D.bar'
class C(D): def bar(self): print 'C.bar'
class B(D): def bar(self): print 'hhhhh' print 'B.bar'
class A(B, C): pass # def bar(self): # print 'A.bar'
a = A()a.bar()
print A.__mro__ # 报错 ,__mro__只对新式类有效执行bar方法时 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错
所以，查找顺序：A —> B —> D —> C
在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
新式类-python3.6+
class D(object): def bar(self): print('D.bar')
class C(D): def bar(self): print('C.bar')
class B(D): def bar(self): print('B.bar')
class A(B, C): pass # print('A.bar')
a = A()a.bar()
# 方法解析顺序Method Resolution Order - MROprint(A.__mro__)# (<class '__main__.A'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.D'>, <class 'object'>)执行bar方法时 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错
所以，查找顺序：A —> B —> C —> D
在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
再看一个例子：
class D: def __init__(self): self.a = 1
class B(D): pass
class C(B): def __init__(self): self.a = 2
class A(B,C): pass
a = A()print (a.a) # 1class D(object): def __init__(self): self.a = 1
class B(D): pass
class C(D): def __init__(self): self.a = 2
class A(B,C): pass
a = A()print (a.a) # 2#####3.多态
Pyhon不支持Java和C#这一类强类型语言中多态的写法，但是原生多态，其Python崇尚“鸭子类型”。
class Animal(object): def run(self): print('Animal is running...')
class Dog(Animal): pass
class Cat(Animal): pass
c = Dog()b = Animal()
isok = isinstance(c, Animal)print(isok)
isok = isinstance(b, Dog)print(isok)
def run_twice(animal): animal.run() animal.run()
class Tortoise(Animal): def run(self): print('Tortoise is running slowly...')
class people(object): def run(self): print("People run...")
isok = run_twice(Tortoise())print(isok)
# people这个类却和animal没有任何关系，但是其中却有run这个方法# 鸭子类型isok = run_twice(people())print(isok)进阶篇
类的成员
类的成员可以分为三大类：字段、方法和属性
字段
字段包括：普通字段和静态字段，他们在定义和使用中有所区别，而最本质的区别是内存中保存的位置不同，
普通字段属于对象静态字段属于类
class Province: # 静态字段 country = '中国'
def __init__(self, name): # 普通字段 self.name = name
# 直接访问普通字段obj = Province('河北省')print(obj.name)
# 直接访问静态字段print(Province.country)方法
属性
如果你已经了解Python类中的方法，那么属性就非常简单了，因为Python中的属性其实是普通方法的变种。 对于属性，有以下三个知识点：
- 属性的基本使用
- 属性的两种定义方式
class Goods(object): @property def price(self): print("100")
obj = Goods()obj.price由属性的定义和调用要注意一下几点：
-
定义时，在普通方法的基础上添加 @property 装饰器；
-
定义时，属性仅有一个self参数
-
调用时，无需括号 方法：foo_obj.func() 属性：foo_obj.prop
注意：属性存在意义是：访问属性时可以制造出和访问字段完全相同的假象
属性由方法变种而来，如果Python中没有属性，方法完全可以代替其功能
1.特殊的类属性
class.__class__ 类的类型
class.__bases__ 父类名称
class.__dict__ 类所有属性
class.__module__ 类所在的模块
2.特殊的实例属性
__class__ 实例所对应的类
__dict__ 实例的属性
######属性的两种定义方式
属性的定义有两种方式：
- 装饰器 即：在方法上应用装饰器
- 静态字段 即：在类中定义值为property对象的静态字段
装饰器方式：在类的普通方法上应用@property装饰器
静态字段方式，创建值为property对象的静态字段 当使用静态字段的方式创建属性时，经典类和新式类无区别
class Foo(object): def get_bar(self): return 'hello'
BAR = property(get_bar)
obj = Foo()reuslt = obj.BAR # 自动调用get_bar方法，并获取方法的返回值print(reuslt)property的构造方法中有个四个参数
- 第一个参数是方法名，调用 对象.属性 时自动触发执行方法
- 第二个参数是方法名，调用 对象.属性 ＝ XXX 时自动触发执行方法
- 第三个参数是方法名，调用 del 对象.属性 时自动触发执行方法
- 第四个参数是字符串，调用 对象.属性.
__doc__，此参数是该属性的描述信息
class Foo(object): def get_bar(self): return 'hello'
# 必须两个参数 def set_bar(self, value): return 'set value' + value
def del_bar(self): return 'hello'
BAR = property(get_bar, set_bar, del_bar, 'description...')
obj = Foo()
print(obj.BAR) # 自动调用第一个参数中定义的方法：get_barobj.BAR = "alex" # 自动调用第二个参数中定义的方法：set_bar方法，并将“alex”当作参数传入print(obj.BAR)
print(obj.BAR.__doc__) # 自动获取第四个参数中设置的值：description...del Foo.BAR # 自动调用第三个参数中定义的方法：del_bar方法实例属性和类属性关系
记住：
实例属性不能左右类属性 但是类属性可以左右实例属性
class A(object): x = 7
foo = A()foo.x += 7print(A.x) # 7print(foo.x) # 14
print("####")A.x = A.x + 1print(A.x) # 8print(foo.x) # 14也有特例：
class B(object): y = [1, 2, 3]
bar = B()bar.y.append(4)
print(bar.y) # [1, 2, 3, 4]print(B.y) # [1, 2, 3, 4]##### 公有成员和私有成员
公有成员，在任何地方都能访问私有成员，只有在类的内部才能方法
私有成员和公有成员的定义不同：私有成员命名时，前两个字符是下划线。
（特殊成员除外，例如：__init__、__call__、__dict__等）
class C(object): def __init__(self): self.name = '公有字段' self.__foo = "私有字段"1. 静态字段
公有静态字段：类可以访问；类内部可以访问；派生类中可以访问私有静态字段：仅类内部可以访问
class C(object):
name = "公有静态字段"
def func(self): print(C.name)
class D(C): def show(self): print(C.name)
C.name # 类访问
obj = C()obj.func() # 类内部可以访问
obj_son = D()obj_son.show() # 派生类中可以访问class C(object):
__name = "公有静态字段"
def func(self): print(C.__name)
class D(C): def show(self): print(C.__name)
C.__name # 类访问 ==> 错误
obj = C()obj.func() # 类内部可以访问 ==> 正确
obj_son = D()obj_son.show() # 派生类中可以访问 ==> 错误2.普通字段
公有普通字段：对象可以访问；类内部可以访问；派生类中可以访问私有普通字段：仅类内部可以访问
class C(object): def __init__(self): self.foo = "公有字段"
def func(self): print(self.foo) # 类内部访问
class D(C): def show(self): print(self.foo) # 派生类中访问
obj = C()
obj.foo # 通过对象访问obj.func() # 类内部访问
obj_son = D()obj_son.show() # 派生类中访问class C: def __init__(self): self.__foo = "私有字段"
def func(self): print(self.foo) # 类内部访问
def __doSomething(self): print("do something")
class D(C): def show(self): print(self.foo) # 派生类中访问
obj = C()
obj.__foo # 通过对象访问 ==> 错误obj.func() # 类内部访问 ==> 正确
obj_son = D()obj_son.show() # 派生类中访问 ==> 错误
# 强制访问私有字段-不建议这样使用print(obj._C__foo)
# 访问私有方法print(obj._C__doSomething())总结： > 在python里，标识符有字母、数字、下划线组成。 >在python中，所有标识符可以包括英文、数字以及下划线（_），但不能以数字开头。 >python中的标识符是**区分大小写**的。
以下划线开头的标识符是有特殊意义的。以**单下划线开头（
_foo）**的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用”from xxx import *“而导入；
以双下划线开头的（
__foo）代表类的私有成员
以双下划线开头和结尾的（
__foo__）代表python里特殊方法专用的标识，如__init__（）代表类的构造函数。
特殊的类的成员
__module__ 和 __class__
__module__表示当前操作的对象在那个模块__class__表示当前操作的对象的类是什么
demo.py 单独访问：
可以看到__module__表示的main模块，__class__表示main模块中的Test类
class Test(object): def __init__(self): self.name = "tony"
obj = Test()print(obj.__module__) # __main__print(obj.__class__) # <class '__main__.Test'>被其他文件引用： 可以看到`__module__`表示的demo模块，`__class__`表示demo模块中的Test类
from demo import Test
obj = Test()print(obj.__module__) # demo
print(obj.__class__) # <class 'demo.Test'>__init__
构造方法，通过类创建对象时，自动触发执行。
class Test(object): def __init__(self, name): self.name = name
test = Test("tony") # 自动执行类中的__init__方法
这里要注意：
class Test(object): def __init__(self, name): self.name = name # return "111" # 问题：能不能给它加个返回值？ # 默认的返回值 # <__main__.Test object at 0x000001E27BA18518>
test = Test("tony") # 自动执行类中的__init__方法print(test)# TypeError: __init__() should return None, not 'str'__del__
析构方法，当对象在内存中被释放时，自动触发执行。
此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行
所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。
class Test(object): def __del__(self): print("I am deleted...")
test = Test()del test # I am deleted...__call__
对象后面加括号，触发执行。
构造方法的执行是由创建对象触发的，即：对象 = 类名() 而对于
__call__方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
class Foo(object): def __init__(self): print('init')
def __call__(self): print('call')
obj = Foo()print(obj) # 执行__init__方法# init# <__main__.Foo object at 0x000001EC6ACC8470>
print(obj()) # 执行__call__方法__dict__
类或对象中的所有成员
class Province:
country = 'China'
def __init__(self, name, count): self.name = name self.count = count
def func(self, *args, **kwargs): print('func')
# 获取类的成员，即：静态字段、方法、print(Province.__dict__)
obj1 = Province('HeBei', 10000)print(obj1.__dict__)# 获取 对象obj1 的成员# 输出：{'count': 10000, 'name': 'HeBei'}
obj2 = Province('HeNan', 3888)print(obj2.__dict__)# 获取 对象obj2 的成员# 输出：{'count': 3888, 'name': 'HeNan'} __getitem__&__setitem__&__delitem__
用于索引操作，如字典。以上分别表示获取、设置、删除数据
class Foo(object): def __getitem__(self, key): print('__getitem__', key)
def __setitem__(self, key, value): print('__setitem__', key, value)
def __delitem__(self, key): print('__delitem__', key)
obj = Foo()
result = obj['k1'] # 自动触发执行 __getitem__obj['k1'] = 'tony' # 自动触发执行 __setitem__del obj['k1'] # 自动触发执行 __delitem__
print(obj['k1']) # 自动触发执行 __getitem__ __getslice__&__setslice__&__delslice__
该三个方法用于分片操作，如：列表
仅限于python2.6+
python3已废弃这些方法
python3 已经变成__getitem__&__setitem__&__delitem__
__iter__
用于迭代器，之所以列表、字典、元组可以进行for循环，是因为类型内部定义了 __iter__
class Foo(object): pass
# obj = Foo()
# for i in obj:# print(i) # TypeError: 'Foo' object is not iterable
class FooX(object): def __iter__(self): pass
objx = FooX()
# for i in objx:# print(i) # TypeError: iter() returned non-iterator of type 'NoneType'
class FooY(object): def __init__(self, sq): self.sq = sq
def __iter__(self): return iter(self.sq)
objy = FooY([11, 22, 33, 44])
for i in objy: print(i)
# 11# 22# 33# 44
# 也可也写成bj = iter([11, 22, 33, 44])
for i in bj: print(i) __new__
__new__(): 构造方法
1.如果有__new__和__init__都存在， 优先找__new__
这两个方法是用来创建object的子类对象，静态方法__new__()用来创建类的实例，
然后再调用__init__()来初始化实例。
class A(object): def __init__(self, *args, **kwargs): print("init %s" % self.__class__)
def __new__(cls, *args, **kwargs): print("new %s" % cls) return object.__new__(cls, *args, **kwargs)
a = A()a
# new <class '__main__.A'># init <class '__main__.A'>**`2.其他区别`**
__new__方法默认返回实例对象供__init__方法、实例方法使用。
class Foo(object): price = 50
def __new__(cls, *agrs, **kwds): inst = object.__new__(cls, *agrs, **kwds) return inst
def how_much_of_book(self, n): print(self) return self.price * n
foo = Foo()print(foo.how_much_of_book(8))# Foo类中重载了__new__方法，它的返回值为Foo类的实例对象# <__main__.Foo object at 0x0000017BF8678630># 400`__init__ `方法为初始化方法，为类的实例提供一些属性或完成一些动作
class Foo(object): def __new__(cls, *agrs, **kwds): inst = object.__new__(cls, *agrs, **kwds) return inst
def __init__(self, price=50): self.price = price
def how_much_of_book(self, n): print(self) return self.price * n
foo = Foo()print(foo.how_much_of_book(8))**3.几点注意事项**
__new__ 方法创建实例对象供__init__ 方法使用，__init__方法定制实例对象。
__new__ 方法必须返回值，__init__方法不需要返回值。(如果返回非None值就报错)
**4. 一般用不上`__new__`方法**
__new__方法可以用在下面二种情况。
1> 继承不可变数据类型时需要用到__new__方法(like int, str, or tuple） 。
class Inch(float): def __new__(cls, arg=0.0): return float.__new__(cls, arg * 0.0254)
print(Inch(12))2>用在元类，定制创建类对象
元类：
当我们定义了类以后，就可以根据这个类创建出实例，所以：先定义类，然后创建实例。
但是如果我们想创建出类呢？那就必须根据metaclass创建出类，所以：先定义metaclass，然后创建类。
连接起来就是：先定义metaclass，就可以创建类，最后创建实例。
# metaclass是类的模板，所以必须从`type`类型派生：class MetaClass(type): """ 参数必须是这四个 cls：当前准备创建的类 name：类的名字 bases：类的父类集合 attrs：类的属性和方法，是一个字典 """ def __new__(cls, name, bases, attrs): print("Allocating memory for class", name) print("new cls=", cls) print("new name=", name) print("new bases=", bases) print("new attrs=", attrs) return super(MetaClass, cls).__new__(cls, name, bases, attrs)
def __init__(cls, name, bases, attrs): print("Initializing class", name) print("int cls=", cls) print("int name=", name) print("int bases=", bases) print("int attrs=", attrs) super(MetaClass, cls).__init__(name, bases, attrs)
class Myclass(metaclass=MetaClass): def foo(self, param): print(param)
p = Myclass()p.foo("hello")