第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创建对象obj
obj = 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>
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等于obj
obj = 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 - MRO
print(A.__mro__)
# (, , , , )
执行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) # 1
class 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_bar
obj.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 += 7
print(A.x) # 7
print(foo.x) # 14
print("####")
A.x = A.x + 1
print(A.x) # 8
print(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 = "私有字段"
静态字段
公有静态字段：类可以访问；类内部可以访问；派生类中可以访问
私有静态字段：仅类内部可以访问
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__) #
被其他文件引用：
可以看到__module__表示的demo模块，__class__表示demo模块中的Test类
from demo import Test
obj = Test()
print(obj.__module__) # demo
print(obj.__class__) #
__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>
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>
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
# init
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>
# 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")
285
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
