流畅的python学习笔记-第7章扩展内容

第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 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等于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 = "私有字段"

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__)  # 

被其他文件引用：
可以看到__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 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 
# 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 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")