面向对象

• 一、静态属性（就是数据属性）

首先，有一个需求：计算主人房间的面积

class Room:
    def __init__(self,name,owner,length,width,high):
        self.room_name = name
        self.owner = owner
        self.length = length
        self.width = width
        self.high = high

r1 = Room('别墅','alex',30,20,10)

r2 = Room('天桥下','wupeiqi',1,1,1)

print('%s 住的 %s 面积是 %s平方米'%(r1.owner,r1.room_name,int(r1.width)*int(r1.high)))      ##  alex 住的 别墅 面积是 200平方米
print('%s 住的 %s 面积是 %s平方米'%(r2.owner,r2.room_name,int(r2.width)*int(r2.high)))      ##  wupeiqi 住的 天桥下 面积是 1平方米

但是这样子代码可读性比较差，我们可以把计算面积这个方法定义成一个函数，放在类里面

class Room:
    def __init__(self,name,owner,length,width,high):
        self.room_name = name
        self.owner = owner
        self.length = length
        self.width = width
        self.high = high

    def room_area(self):
        return '%s 住的 %s 面积是 %s平方米'%(self.owner,self.room_name,int(self.width)*int(self.high))

##  下面就直接调用类里面的 room_area() 方法就可以了
r1 = Room('别墅','alex',30,20,10)
r2 = Room('天桥下','wupeiqi',1,1,1)

print(r1.room_area())       ##  alex 住的 别墅 面积是 200平方米
print(r2.room_area())       ##  wupeiqi 住的 天桥下 面积是 1平方米

我们再进行改动

class Room:
    def __init__(self,name,owner,length,width,high):
        self.room_name = name
        self.owner = owner
        self.length = length
        self.width = width
        self.high = high

    @property       ##  把room_area()这个方法封装起来，让调用者调用的时候感受不到调用的过程
    def room_area(self):
        return '%s 住的 %s 面积是 %s平方米'%(self.owner,self.room_name,int(self.width)*int(self.high))

r1 = Room('别墅','alex',30,20,10)
r2 = Room('天桥下','wupeiqi',1,1,1)

print(r1.room_area)       ##  alex 住的 别墅 面积是 200平方米     ##  注意，这里是不是感觉到像是在调用一个类的数据属性一样，实际上这就是一个静态属性
print(r2.room_area)       ##  wupeiqi 住的 天桥下 面积是 1平方米

这里面的 p1.room_area 就是静态属性，就是数据属性，而 @property 就把room_area() 这个函数封装起来，让调用者感觉不到调用的过程。

property补充：

一个静态属性property本质就是实现了get，set，delete三种方法

class Test:
    @property
    def AAA(self):
        print('----------->property')

    @AAA.setter
    def AAA(self,value):
        print('------------>setter',value)

    @AAA.deleter
    def AAA(self):
        print('------------>delter')

t1 = Test()
t1.AAA      ##  ----------->property
t1.AAA = 1      ##  ------------>setter 1
del t1.AAA      ##  ------------>delter

class Test:
    def AAA__get(self):
        print('----------->property')

    def AAA__set(self,value):
        print('------------>setter',value)

    def AAA__delete(self):
        print('------------>delter')
    AAA = property(AAA__get,AAA__set,AAA__delete)

t1 = Test()
t1.AAA      ##  ----------->property
t1.AAA = 1      ##  ------------>setter 1
del t1.AAA      ##  ------------>delter

应用：

class Good:
    def __init__(self):
        self.price = 100
        self.discount = 0.8

    def get_price(self):
        return self.price*self.discount

    def set_price(self,value):
        self.price = value

    def del_price(self):
        del self.price

    good_price = property(get_price,set_price,del_price)

good1 = Good()
print(good1.good_price)     ##  80.0
good1.good_price = 10
print(good1.good_price)     ##  8.0
del good1.good_price

• 二、类方法

假设有一个需求：不创建一个对象，直接用类调用类的函数属性

class Room:
    def __init__(self,name,owner,length,width,high):
        self.room_name = name
        self.owner = owner
        self.length = length
        self.width = width
        self.high = high

    def func(self):
        print('——————》类直接调用')

Room.func()
# 运行结果：Traceback (most recent call last):
#   File "F:/PycharmProjects/复习/面向对象/面向对象思想.py", line 333, in <module>
#     Room.func()
# TypeError: func() missing 1 required positional argument: 'self'

这里报错的原因很容易看出来，func()缺少一个参数，而我们要运行这个函数就必须实例化一个对象，这又与我们的需求想违背。这个时候就衍生出了类方法出来

class Room:
    def __init__(self,name,owner,length,width,high):
        self.room_name = name
        self.owner = owner
        self.length = length
        self.width = width
        self.high = high

    @classmethod
    def func(cls):      ##  这里的cls 就是类自己，相当于把类本身作为参数传进去了
        print(cls)
        print('——————》类直接调用')

Room.func()
# <class '__main__.Room'>
# ——————》类直接调用

 只要加了 @classmethod 就是一个类方法，这里注意一点：对象同样也可以调用到这个类方法

• 三、静态方法

下面我们想在类里创建一个函数，既不和类绑定，有不和对象绑定

class Room:
    def __init__(self,name,owner,length,width,high):
        self.room_name = name
        self.owner = owner
        self.length = length
        self.width = width
        self.high = high

    def test():
        print('这是test函数')

Room.test()     ##  这是test函数

r1 = Room('别墅','alex',30,20,10)
r1.test()
#  运行结果： Traceback (most recent call last):
#   File "F:/PycharmProjects/复习/面向对象/面向对象思想.py", line 372, in <module>
#     r1.test()
# TypeError: test() takes 0 positional arguments but 1 was given

但是这里报错了，原因是test（）这个函数还是一个类的函数，而对象调用这个函数会自动将对象传进去，由于test）这个函数没有接收参数，所以就报错了

所以这里就引出了静态方法

class Room:
    def __init__(self,name,owner,length,width,high):
        self.room_name = name
        self.owner = owner
        self.length = length
        self.width = width
        self.high = high

    @staticmethod       ##  这里staticmethod就是一个静态方法，这个函数不跟类和对象联系，就是一个普通的函数
    def test():
        print('这是test函数')

r1 = Room('别墅','alex',30,20,10)
r1.test()       ##  这是test函数

这时test（）就是一个普通的函数了，类和对象都可以直接调用了。静态方法是类里面的一个工具包

• 小结：

静态属性既可以访问对象属性，也可以访问类属性

类方法只能访问类的属性，不能访问对象属性

静态方法既不能访问对象属性，也不能访问类的属性

• 四、组合

顾名思义，组合就是用多个类组合起来，类与类之间存在联系

什么时候用到组合呢？

当类与类之间没有共同点的时候，但是类与类之间存在联系的时候，这个时候就可以用到组合了

我们先来看一个简单的组合

我们都知道人有手（hand），脚（foot），头（head），躯干（trunk），这些部分都和人体有联系，但是又互相没有共同点，那我们用组合来表示。

class Hand:
    pass
class Foot:
    pass
class Head:
    pass
class Trunk:
    pass
class People:
    def __init__(self,name,age):
        self.name = name
        self.age = age
        self.hand = Hand()      ##  这里实际就是多个类组合起来了
        self.foot = Foot()
        self.head = Head()
        self.trunk = Trunk()
        
p1 = People('alex','18')

下面我们来用组合来完成一个学校选课系统：

需求：

　　　　有不同的校区（School），课程（Course），老师（Teacher）。课程和校区关联，老师和课程关联

class Teacher:
    def __init__(self,teacher_name,teacher_age,teacher_gender):
        self.teacher_name = teacher_name
        self.teacher_age = teacher_age
        self.teacher_gender = teacher_gender

class Course:
    def __init__(self,course_name,course_price,course_period,teacher):
        self.course_name = course_name
        self.course_price = course_price
        self.course_period = course_period
        self.teacher = teacher

class School:
    def __init__(self,school_name,school_addr,course,teacher):
        self.school_name = school_name
        self.school_addr = school_addr
        self.teacher = teacher
        self.course = course

school_list = {
    '1':'老男孩',
    '2':'北大青鸟',
    '3':'泽林'
}
addr_list = {
    '1':'北京',
    '2':'深圳',
    '3':'上海'
}
course_list = {
    '1':'python',
    '2':'c++',
    '3':'java'
}
while True:
    print('学校有：%s'%school_list)
    school_choice = input('请输入学校编号：')
    print('校区有%s'%addr_list)
    addr_choice = input('请选择校区地址：')
    print('学校课程有%s'%course_list)
    course_choice = input('请选择学校课程编号：')
    school_name = school_list[school_choice]
    school_addr = addr_list[addr_choice]
    course_name = course_list[course_choice]
    course_price = input('请输入课程价格：')
    course_period = input('请输入课程周期：')
    teacher_name = input('请输入老师名字：')
    teacher_age = input('请输入老师年龄：')
    teacher_gender = input('请输入老师性别：')

    teacher = Teacher(teacher_name, teacher_age, teacher_gender)
    course = Course(course_name,course_price,course_period,teacher)
    school = School(school_name, school_addr, course, teacher)

    print('恭喜您选课成功！下面是您的课程信息：')
    print('校区名字：%s'%school.school_name)
    print('校区地址：%s'%school.school_addr)
    print('选择的课程：%s'%school.course.course_name)
    print('教授的老师：%s'%school.teacher.teacher_name)
    
    ##  恭喜您选课成功！下面是您的课程信息：
    # 校区名字：老男孩
    # 校区地址：深圳
    # 选择的课程：python

• 五、面向对象的三大特性

面向对象三大特性：继承　　多态　　封装

• （一）继承

 1、继承分为两种：单继承和多继承

##  继承
##  单继承
class Dad:
    pass
class Son(Dad):
    pass

##  多继承
class GrandDad:
    pass
class Dad:
    pass
class Son(GrandDad,Dad):
    pass

2、继承了哪些属性？

继承父类会将父类的所有属性继承过来。首先子类会在自己的属性里面去找，如果没有才会去父类找属性

class Dad:
    money = 10
    def __init__(self,name):
        self.name = name
    def hit_son(self):
        print('%s正在打儿子'%self.name)

class Son(Dad):
    money = 10000

son1 = Son('alex')
print(son1.money)       #   10000
son1.hit_son()          #   alex正在打儿子

3、什么时候用继承？

（1）、当类之间有显著不同，并且较小的类是较大的类所需要的组件时，用组合比较好
例如：描述一个机器人类，机器人这个大类是由很多互不相关的小类组成，如胳膊、腿、身体类等
（2）、当类之间有很多相同的功能，提取这些共同的功能做成基类，用继承比较好
例如：
猫可以：喵喵叫、吃喝拉撒
狗可以：汪汪叫、吃喝拉撒
如果我们要分别为猫和狗创建一个类，那么就需要为猫和狗实现他们所有的功能

我们可以发现狗和猫都有共同点，那我们就可以写一个动物类，然后再让猫和狗分别继承动物类

4、继承同时具有两种含义
含义一：继承基类的方法，并且做出自己的改变或扩展（代码重用）
含义二：声明某个子类兼容于某基类，定义一个接口类，子类继承接口类，并且实现接口中定义的方法

import abc
class   All_file(metaclass=abc.ABCMeta):    ##  定义一个接口
    @abc.abstractmethod     ##  只要继承了这个接口，必须要定义一个函数来描述这个信息
    def read(self):
        pass
    @abc.abstractmethod
    def write(self):
        pass
    
class   Disk(All_file):
    def read(self):         ##  必须要有一个详细的函数来描述信息
        print('disk read')
    def write(self):
        print('disk write')
        
class   Cd(All_file):
    def read(self):
        print('CD read')
    def write(self):
        print('CD write')
        
class   Mem(All_file):
    def read(self):
        print('mem read')
    def write(self):
        print('mem write')
        
disk = Disk()
disk.write()

实践中，继承的第一种含义意义不大，甚至常常都是有害的。因为它使得子类与基类出现强耦合。
继承的第二种含义非常重要，它又叫“接口继承”。
接口继承实质上是要求“做出一个良好的抽象，这个抽象规定了一个兼容接口，使得外部调用者无需关心具体细节，可一视同仁的处理实现了特定接口的所有对象”--- 这在程序设计上，叫归一化。
归一化使得高层的外部使用者可以不加区分的处理所有接口兼容的对象集合——就好像Linux的范文件概念一样，所有东西都可以当文件处理，不必关心它是内存、磁盘还是屏幕。

接口继承的原则是，基类定义了一些方法，而基类不具体实现这些方法，但是规定了继承这个基类的子类必须要具体实现这些方法。

5、继承的顺序

在Java和C#中子类只能继承一个父类，而Python中子类可以同时继承多个父类，如A(B,C,D)

如果继承关系为非菱形结构，则会按照先找B这一条分支，然后再找C这一条分支，最后找D这一条分支的顺序直到找到我们想要的属性

如果继承关系为菱形结构，那么属性的查找方式有两种，分别是：深度优先和广度优先

#  新式类：基类有继承关系，pytho3都是
#  经典类：基类没有继承关系
class A:
    def test(self):
        print('A')
    # pass
class B(A):
    def test(self):
        print('B')
    # pass
    # pass
class C(A):
    def test(self):
        print('C')
    # pass
class D(B):
    def test(self):
        print('D')
    # pass
class E(C):
    def test(self):
        print('E')
    # pass
class F(D,E):
    def test(self):
        print('F')
    # pass
f = F()     ##  继承顺序：F-->D-->B-->E-->C-->A
f.test()
print(F.__mro__)  ##  只有新式类才有这个方法      ##  继承顺序：(<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)
#新式类继承顺序:F->D->B->E->C->A
#经典类继承顺序:F->D->B->A->E->C
#python3中统一都是新式类
#pyhon2中才分新式类与经典类

• （二）多态

什么是多态：

(以封装和继承为前提)不同的子类调用相同的方法，执行的过程（逻辑）是不同的，最后产生了不同的结果

注意，要产生了不同的对象并且调用了相同的方法才叫多态，这个类就是一个多态。多态反映的是多个对象调用同一个父类的同一个方法，实现的过程以及最后产生的结果是不一样的。Python本身就是一个多态

class H20:
    def __init__(self,statu,temp):
        self.statu = statu
        self.temp = temp
    def water_turn(self):
        if self.temp <= 0:
            print('水温度太低变成了%s'%self.statu)
        elif self.temp < 100:
            print('水还是%s'%self.statu)
        else:
            print('水温度太高蒸发变成了%s'%self.statu)
class Water(H20):
    pass
class Ice(H20):
    pass
class Steam(H20):
    pass
ice = Water('ice',-20)      ##  不同对象产生了并且调用了相同的方法，那就体现了多态的思想了
water = Ice('water',25)
steam = Steam('steam',120)
def turn(statu):
    statu.water_turn()
turn(ice)   ##  水温度太低变成了ice
turn(water)     ##  水还是water
turn(steam)     ##  水温度太高蒸发变成了steam

##  不同的对象调用同一个父类的同一个方法，最后的结果是不一样的

• 总结：

类的继承有两层意义：1、改变 2、扩展
多态就是类的这两层意义的一个具体的实现机制
即，调用不同的类实例化得到对象下的相同的方法，实现的过程不一样
Python中的标准类型就是多态概念的一个很好的示范

• （三）封装（内部能调用，外部不能调用）

封装分为两部分：封和装，顾名思义，装就是把一些数据属性和函数属性装到属性字典里，封就是把类里面的数据属性还有函数属性封起来，只提供类名这个接口给调用者调用，调用者感受不到具体的实现逻辑。

封装是面向对象的一种思想

（1）第一层面的封装

这就是一个麻袋，这本身就是一个封装

（2）第二层面的封装

类中定义私有的，只能在内部中使用，外部不能使用

__id = 'linhaifeng'
class Package:
    _star = '地球'        ##  Python约定了封装用这个格式，但是外部还是能够访问到的
    __star = 'earth'        ##  Python会把__star 改名为'_Package__star',还是能够访问到的
    def __init__(self,name,money,id):
        self.name = name
        self.money = money
        self.id = id

p = Package('alex',10000000,__id)
print(p._star)      ##  地球      虽然能访问得到_star 这个数据属性，但是Python约定了只要是 _ 开头的，外部就不应该调用这个数据属性
# print(p.__star)     ##  AttributeError: 'Package' object has no attribute '__star'
print(p._Package__star)       ##   earth  用这一个格式还是能够访问到，但是不应该调用

Python约定了，只要类里面的 数据属性用了下划线（_）开头，或者双下划线（__）开头，那么这个属性就只能内容用，外部不能直接调用，当然外部想调用还是可以的，但是不应该这么做。

（3）第三层面的封装

第三个层面的封装：明确区分内外，内部的实现逻辑，外部无法知晓，并且为封装到内部的逻辑提供一个访问接口给外部使用（这才是真正意义上的封装）

__id = 'linhaifeng'
class Package:
    _star = '地球'        ##  Python约定了封装用这个格式，但是外部还是能够访问到的
    __star = 'earth'        ##  Python会把__star 改名为'_Package__star',还是能够访问到的
    def __init__(self,name,money,id):
        self.name = name
        self.money = money
        self.id = id
    def get_id(self):       ##  访问函数
        return self.__star      ##  提供一个接口外部可以访问到封装的数据
p = Package('alex',10000000,__id)

print(p.get_id())       ##  外部可以调用这个接口

• 六、反射（自省）

（1）什么是反射？
反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力（自省）。

（2）四个可以实现自省的函数（系统自带的）
下列方法适用于类和对象

# hasattr(object,name)
# 判断对象里有没有name这个属性
class People:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def run(self):
        print('%s开始跑起来了'%self.name)

p1 = People('alex',18)
print(p1.__dict__)  ##  {'name': 'alex', 'age': 18}
print(hasattr(p1,'name'))       ##  True    ##    这里实质上就是在操作p1的字典属性

# getattr(object,name,default=None)
##  查找对象的属性，如果没有则默认报错，default可以修改
class People:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def run(self):
        print('%s开始跑起来了'%self.name)

p1 = People('alex',18)
print(p1.name)      ##  alex
print(getattr(p1,'name'))       ##  alex
print(getattr(p1,'gender','查不到就报这条信息'))     ##  查不到就报这条信息

# setattr(object,name,value)
class People:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def run(self):
        print('%s开始跑起来了'%self.name)

p1 = People('alex',18)
# p1.gender = '男'
setattr(p1,'gender','男')        ##  等同于上面
print(p1.gender)      ##    男

# delattr(object,name)
class People:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def run(self):
        print('%s开始跑起来了'%self.name)

p1 = People('alex',18)
# del p1.name
# print(p1.__dict__)      ##  {'age': 18}
delattr(p1,'name')      ##  等同于上面操作
print(p1.__dict__)      ##  {'age': 18}

四个方法都是对实例的字典属性进行操作，注意里面的参数name应该传入一个字符串形式。

（3）什么时候用反射？

为什么用反射呢？例子：有两个程序员A和B，两个程序员在完成一个项目，B在写程序的时候需要用到A的类，

但是A去跟女朋友度蜜月了，还没完成他写的类，B想到了反射，用反射机制B利益完成自己的代码，等A回来后再继续完成类的定义并且去实现B想要的功能

class A:
    def run(self):
        print('A的程序开始运行')

f1 = A()
if hasattr(f1,'run'):
    f1.run()
else:
    print('A的代码还没写好，执行下面的程序')

总之反射的好处就是，可以先定义好接口，接口只有在被完成后才会真正执行，这实现了即插即用，这其实就是一种“后期绑定”，什么意识？即你可以事先把主要的逻辑写好（只定义接口），后期再去实现接口的功能。

补充：动态导入模块

#############################       模块导入补充：
# import 多态      ##  第一种形式
# m = __import__('多态')         ##   第二种形式，导入的模块名是字符串形式,注意这个时候就不能用第一种形式了，注意导入的是顶级文件
# import importlib
# m = importlib.import_module('多态')       ##  第三种形式，导入的是底级文件

（4）类的三个内置 __attr__属性

class Foo:
    def __init__(self,x):
        self.x = x
    def __getattr__(self, item):      ##  item就是传入不存在的值
        print('执行__getattr__%s'%item)
f = Foo(5)
f.y    ##   执行__getattr__y      ##  没有这个方法或者属性的时候会调用__getattr__方法

class Foo:
    def __init__(self,x):
        self.x = x
    def __delattr__(self, item):
        print('执行__delattr__')
f = Foo(5)
del f.x     ##  执行__delattr__  ##  删除操作会调用__delattr__方法，删除的本质就是在操作底层的属性字典
print(f.__dict__)

class Foo:
    def __init__(self,x):
        self.x = x
    def __setattr__(self, key, value):      ##  操作属性字典
        print('执行__setattr__')      ##  如果只执行这个打印操作，属性字典就不会加入值
        # self.key = value    ##  执行会触发递归，因为self.key = value就是在触发 __setattr__
        # self.__dict__[key] = value      ##  直接加入类的属性字典中
f = Foo(5)      #   执行__setattr__
print(f.__dict__)

（5）继承的方式来完成包装

每个数据类型都有自己的函数，但是有时候这些内置函数不能满足我们的需求，那我们就必须要重写这些内置函数

我们下面有需求：

需求：修改list中的append操作，只能添加字符串类型

class List(list):
    def append(self,name):
        if type(name) is str:
            super().append(name)
        else:
            print('请输入一个字符串类型')

l = List()
l.append(123)       ##  请输入一个字符串类型
print(l)        ##  []

（6）组合的方式完成授权

授权：授权是包装的一个特性，包装一个类型通常是对已存在的类型的一些定制，这种做法可以新建、修改或删除原有产品的功能。其它的则保持原样。

授权的过程，即是所有更新的功能都是由新类的某部分来处理，但已存在的功能就授权给对象的默认属性。

实现授权的关键点就是覆盖__getattr__方法

import time
class Open:
    def __init__(self,filename,way='r+',encoding = 'utf-8'):
        self.file = open(filename, way, encoding=encoding)      ##  用组合的方法把类的功能全部调用过来
        self.filename = filename
        self.way = way
        self.encourding = encoding
    def write(self,line):
        t = time.strftime('%Y-%m-%d %X')
        self.file.write('%s %s
'%(t,line))
        
    def __getattr__(self, item):
        return getattr(self.file,item)      ##  没有找到则把open这个类里面的方法返回
    
f = Open('a.txt','w+')
f.write('123456789')
f.write('cpu超载负荷')
f.write('U盘修复')
f.seek(0)
a = f.read()
print(a)

• 七、isinstance和issubclass

isinstance(obj,cls) 判断obj是否是类cls的实例化

class Foo:
    pass
obj = Foo()
print(isinstance(obj,Foo))      ##  True

issubclass(Cls,Foo) 判断类Cls是否继承了 类Foo

class Foo:
    pass
class Cls(Foo):
    pass
print(issubclass(Cls,Foo))      ##  True

• 八、getattribute

先来看一下getattribute 的用法：

class Foo:
    def __init__(self,x):
        self.x = x
    def __getattr__(self, item):      ##  item就是传入不存在的值
        print('执行__getattr__%s'%item)
    def __getattribute__(self, item):   ##  无论查找的值有还是没有都会触发getattribute，可以加入异常抛出让getattr触发
        print('执行的是getattribute')
        raise AttributeError('错误啦')
f = Foo(5)      ##  执行的是getattribute
f.y   ##    执行的是getattribute      ##  没有这个方法或者属性的时候会调用__getattr__方法

简单来说，__getattribute__（）就是就是__getattr__（）的大哥，无论赋的值是否存在，都会触发getattribute，当不存在时，会先触发getattribute，getattribute在抛出一个

AttributeError异常给getattr，执行getattr语句。

• 九、__item__系列方法

class   Foo:
    def __getitem__(self, item):
        print('---->getitem')
        return self.__dict__[item]

    def __setitem__(self, key, value):
        print('--->setitem')
        self.__dict__[key] = value

    def __delitem__(self, key):
        print('--->delitem')
        self.__dict__.pop(key)

f = Foo()
f['name'] = 'alex'      ##  --->setitem    ##  注意：要用字典的形式来调用setitem
f['age'] = 18           ##  --->setitem
print(f.__dict__)       ##  {'name': 'alex', 'age': 18}
print(f['name'])        ##  ---->getitem        alex
del f['name']           ##  --->delitem
print(f.__dict__)       ##  {'age': 18}

总结：

__item__和__attr__的区别：

item方法和attr方法的效果是一样的，只不过调用方式不一样，item要用f[]这种形式来调用，而attr要用f.name这种形式来调用。

• 十、__str__ 和 __repr__、自定制__format__方法

class Foo:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __str__(self):
        return '名字是%s，年龄是%s'%(self.name,self.age)       ##  自定制str
f = Foo('agen',18)
print(f)    ##  名字是agen，年龄是18    ##  print实质上就是 print(str(f)) 或者 print(f.__str__())

class Foo:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __str__(self):
        return '这是str'      ##  自定制str
    def __repr__(self):
        return '名字是%s，年龄是%s'%(self.name,self.age)       ## 这个作用的是解释器
f = Foo('agen',18)
print(f)        ##  这是str
    ##  print找的顺序是：str(f)——》f.__str__()---->repr(f)

__str__ 和 __repr__都是用来控制屏幕输出的，控制实例化出来的例子是一个什么类型的（显示方式）。

print找的顺序是：str(f)——》f.__str__()---->repr(f)

##  format的用法：
# s = '{0}{0}{0}'.format('%')
# print(s)

##  自定制format方法：
formate_dic = {
    'ymd':'{0.year}{0.mon}{0.day}',
    'm-d-y':'{0.mon}-{0.day}-{0.year}',
    'y;m;d':'{0.year}:{0.mon}:{0.day}'
}
class Foo:
    def __init__(self,year,mon,day):
        self.year = year
        self.mon = mon
        self.day = day
    def __format__(self, format_spec):
        if not format_spec or format_spec not in formate_dic:
            format_spec = 'ymd'
        fm = formate_dic[format_spec]
        return fm.format(self)
day1 = Foo(2019,5,9)
print(format(day1,'m-d-y'))

• 十一、__slots__ 方法

1.__slots__是什么:是一个类变量,变量值可以是列表,元祖,或者可迭代对象,也可以是一个字符串(意味着所有实例只有一个数据属性)

2、什么时候使用 __slots__ 呢？

当你的类里面的属性很少时，而这个类产生的对象有很多的时候，那么这个时候就会用到 __slots__ 来代替类中的 __dict__属性字典，这样可以减少内存占用

当然__slots__ 也有缺点，就是产生的对象只能调用类中定义的 __slots__ 属性，而不能定义类中没有的属性

3、slots 的优点：可以节省内存，使用slots后创建的对象不再有自己的字典属性，而且不能添加slots里面没有的变量。

class Foo:
    __slots__ = ['name','age']  ##  {'name':None,'age':None}
p1 = Foo()
p1.name = 'agen'
p1.age = 18
print(p1.name,p1.age)
#print(p1.__dict__)      ##  AttributeError: 'Foo' object has no attribute '__dict__'    ##  使用__slots__之后实例就没有__dict__了
print(p1.__slots__)     ##  ['name', 'age']

• 十二、__call__（）方法

对象加 （）就可以触发类中的 __call__ 方法

class Foo:
    def __init__(self,name):
        self.name = name
    def __call__(self, *args, **kwargs):
        print('这是call方法执行的-->')
f = Foo('alex')
f()     ##  这是call方法执行的-->    ##  对象加()触发类的__call__方法

• 十三、__next__和 __iter__ 实现迭代器协议

class Foo:
    def __init__(self,n):
        self.n = n
    def __iter__(self):
        return self
    def __next__(self):
        if self.n > 5:
            raise StopIteration('迭代器结束了')
        self.n += 1
        return self.n
f1 = Foo(1)
print(f1.__next__())
print(f1.__next__())
print(f1.__next__())
for i in f1:
    print(i)

class Fib:
    def __init__(self):
        self.a = 1
        self.b = 1
    def __iter__(self):
        return self
    def __next__(self):
        self.a,self.b = self.b,self.a + self.b
        if self.a >100:
            raise StopIteration('迭代器结束了')
        return self.a
f1 = Fib()
print(f1.__next__())
for i in f1:
    print(i)

• 十四、描述符（__get__,__set__,__delete__）

1 描述符是什么:

描述符本质就是一个新式类,在这个新式类中,至少实现了__get__(),__set__(),__delete__()中的一个,这也被称为描述符协议
__get__():调用一个属性时,触发
__set__():为一个属性赋值时,触发
__delete__():采用del删除属性时,触发

class Foo: #在python3中Foo是新式类,它实现了三种方法,这个类就被称作一个描述符
    def __get__(self, instance, owner):
        pass
    def __set__(self, instance, value):
        pass
    def __delete__(self, instance):
        pass

2 描述符是干什么的:

描述符的作用是用来代理另外一个类的属性的(必须把描述符定义成这个类的类属性，不能定义到构造函数中)

class Foo:
    def __get__(self, instance, owner):
        print('触发get')
    def __set__(self, instance, value):
        print('触发set')
    def __delete__(self, instance):
        print('触发delete')

#包含这三个方法的新式类称为描述符,由这个类产生的实例进行属性的调用/赋值/删除,并不会触发这三个方法
f1=Foo()
f1.name='egon'
f1.name
del f1.name
#疑问:何时,何地,会触发这三个方法的执行

#描述符Str
class Str:
    def __get__(self, instance, owner):
        print('Str调用')
    def __set__(self, instance, value):
        print('Str设置...')
    def __delete__(self, instance):
        print('Str删除...')

#描述符Int
class Int:
    def __get__(self, instance, owner):
        print('Int调用')
    def __set__(self, instance, value):
        print('Int设置...')
    def __delete__(self, instance):
        print('Int删除...')

class People:
    name=Str()
    age=Int()
    def __init__(self,name,age): #name被Str类代理,age被Int类代理,
        self.name=name
        self.age=age

#何地？：定义成另外一个类的类属性

#何时？：且看下列演示

p1=People('alex',18)

#描述符Str的使用
p1.name
p1.name='egon'
del p1.name

#描述符Int的使用
p1.age
p1.age=18
del p1.age

#我们来瞅瞅到底发生了什么
print(p1.__dict__)
print(People.__dict__)

#补充
print(type(p1) == People) #type(obj)其实是查看obj是由哪个类实例化来的
print(type(p1).__dict__ == People.__dict__)

3 描述符分两种
一 数据描述符:至少实现了__get__()和__set__()

1 class Foo:
2     def __set__(self, instance, value):
3         print('set')
4     def __get__(self, instance, owner):
5         print('get')

二 非数据描述符:没有实现__set__()

1 class Foo:
2     def __get__(self, instance, owner):
3         print('get')

 4 注意事项:优先级顺序
一 描述符本身应该定义成新式类,被代理的类也应该是新式类
二 必须把描述符定义成这个类的类属性，不能为定义到构造函数中
三 要严格遵循该优先级,优先级由高到底分别是
1.类属性
2.数据描述符
3.实例属性
4.非数据描述符
5.找不到的属性触发__getattr__()

class Foo:
    def __get__(self):
        print('触发__get__方法')
    def __set__(self):
        print('触发__set__方法')
    def __delete(self):
        print('触发__delete__方法')

class Test:
    x = Foo()

Test.x = 10     ##  类属性 > 数据描述符
print(Test.x)   ## 10

class Foo:
    def __get__(self,instance, owner):
        print('触发__get__方法')
    def __set__(self,instance, value):
        print('触发__set__方法')
    def __delete__(self,instance):
        print('触发__delete__方法')

class Test:
    x = Foo()

test = Test()
test.x          ##  触发__get__方法     ##  数据描述符 > 实例属性
test.x = 10     ##  触发__set__方法
del test.x      ##  触发__delete__方法

class Foo:
    def __get__(self,instance, owner):
        print('触发__get__方法')

class Test:
    x = Foo()
    def __init__(self):
        self.x = 100

test = Test()
print(test.x)   ##  100     ##  实例属性 > 非数据描述符
test.x = 10
print(test.x)     ##    10

class Foo:
    def func(self):
        print('我胡汉三又回来了')

    def __getattr__(self, item):
        print('找不到了当然是来找我啦',item)
f1=Foo()

f1.xxxxxxxxxxx

5 描述符使用

众所周知，python是弱类型语言，即参数的赋值没有类型限制，下面我们通过描述符机制来实现类型限制功能

class Miaoshu:
    def __get__(self, instance, owner):
        print('执行get')
        print(instance)
        print(owner)        ##  Foo这个类
    def __set__(self, instance, value): ##  这里的self 是类 Miaoshu 的对象
        print('执行set')
        print(instance)     ##  实例的地址值
        print(value)        ##  实例的值
    def __delete__(self, instance):
        print('执行delete')
        print(instance)

class Foo:
    name = Miaoshu()        ##-------------->   此时name就是数据描述符的代理
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
p1 = Foo('alex',18,'男')

class Typed:
    def __init__(self,key):
        self.key = key
    def __get__(self,instance,owner):
        print('get方法')
        # print('instance-->',instance)
        # print('owner-->',owner)         ##  ##  owner--> <class '__main__.Foo'>     指的就是 Foo这个类
        return instance.__dict__[self.key]      ##  将实例里是属性字典的key返回

    def __set__(self,instance,value):
        print('set方法')
        # print('instance-->',instance)       #    ##  instance--> <__main__.Foo object at 0x00000000021911D0>  指的就是实例
        # print('value-->',value)         ##   value--> alex
        instance.__dict__[self.key] = value     ##  真正实现了赋值操作

    def __delete__(self,instance):
        print('delete方法')
        instance.__dict__.pop(self.key)

class Foo:
    name = Typed('name')
    age = Typed('age')
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender

f1 = Foo('alex',18,'男')
print(f1.name)    ##  alex
print(f1.__dict__)      ##  {'name': 'alex', 'age': 18, 'gender': '男'}
del f1.name
print(f1.__dict__)      ##  {'age': 18, 'gender': '男'}

class Typed:
    def __init__(self,key):
        self.key = key
    def __get__(self,instance,owner):
        print('get方法')
        return instance.__dict__[self.key]      ##  将实例里是属性字典的key返回

    def __set__(self,instance,value):
        print('set方法')
        if type(value) is not str:      ##  判断传入的值是否是一个字符串
            raise TypeError('你传入的不是一个数据类型，类型错误！')
        instance.__dict__[self.key] = value     ##  真正实现了赋值操作

    def __delete__(self,instance):
        print('delete方法')
        instance.__dict__.pop(self.key)

class Foo:
    name = Typed('name')
    age = Typed('age')
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender

f1 = Foo('alex',18,'男')
print(f1.__dict__)      ##  {'name': 'alex', 'age': 18, 'gender': '男'}
f1.name = 123       ##  TypeError: 你传入的不是一个数据类型，类型错误！

class Typed:
    def __init__(self,key,expect_type):
        self.key = key
        self.expect_type = expect_type
    def __get__(self,instance,owner):
        print('get方法')
        return instance.__dict__[self.key]      ##  将实例里是属性字典的key返回

    def __set__(self,instance,value):
        print('set方法')
        if type(value) is not self.expect_type:      ##  判断传入的值是否是一个字符串
            raise TypeError('%s传入的不是一个%s！'%(self.key,self.expect_type))
        instance.__dict__[self.key] = value     ##  真正实现了赋值操作

    def __delete__(self,instance):
        print('delete方法')
        instance.__dict__.pop(self.key)

class Foo:
    name = Typed('name',str)        ##  这里多加一个参数（判断类型）
    age = Typed('age',int)
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender

f1 = Foo('alex',18,'男')
f2 = Foo('agon','12','男')       ##  TypeError: age传入的不是一个<class 'int'>！

 6、类的装饰器

def func(obj):
    print('-------->',obj)      ##  --------> <class '__main__.Foo'>
    obj.x = 1
    obj.z = 2
    obj.y = 3
    return obj

@func  ##  Foo = func(Foo)
class Foo:
    pass
print(Foo.__dict__)     ##  {'__module__': '__main__', '__dict__': <attribute '__dict__' of 'Foo' objects>, '__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__doc__': None, 'x': 1, 'z': 2, 'y': 3}

def Deco(**kwargs):
    def func(obj):
        print('------->',obj)
        for key,val in kwargs.items():
            setattr(obj,key,val)
        return obj
    return func

@Deco(x=1,y=2,z=3)     ##   1、先运行 Deco(x=1,y=2,z=3) ---> func    2、再 @func
class Foo:
    pass
print(Foo.__dict__)     ##  {'__module__': '__main__', '__dict__': <attribute '__dict__' of 'Foo' objects>, '__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__doc__': None, 'x': 1, 'y': 2, 'z': 3}

@Deco(name='alex')
class Test:
    pass
print(Test.__dict__)

##{'__module__': '__main__', '__dict__': <attribute '__dict__' of 'Test' objects>, '__weakref__': <attribute '__weakref__' of 'Test' objects>, '__doc__': None, 'name': 'alex'}

 终极版

class Typed:
    def __init__(self,key,expect_type):
        self.key = key
        self.expect_type = expect_type
    def __get__(self,instance,owner):
        print('get方法')
        return instance.__dict__[self.key]      ##  将实例里是属性字典的key返回

    def __set__(self,instance,value):
        print('set方法')
        if type(value) is not self.expect_type:      ##  判断传入的值是否是一个字符串
            raise TypeError('%s传入的不是一个%s！'%(self.key,self.expect_type))
        instance.__dict__[self.key] = value     ##  真正实现了赋值操作

    def __delete__(self,instance):
        print('delete方法')
        instance.__dict__.pop(self.key)

def Deco(**kwargs):    ##   {'name':str,'age':int}
    def func(obj):
        for key,val in kwargs.items():
            setattr(obj,key,Typed(key,val))     ##  这里实际上就是给类Foo增加描述符
        return obj
    return func

@Deco(name=str,age=int)     ##  `Deco(name=str,age=int) --->    @func(Foo)
class Foo:
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender

f1 = Foo('alex',18,'男')
print(Foo.__dict__)     ##  'name': <__main__.Typed object at 0x00000000027F1EF0>, 'age': <__main__.Typed object at 0x00000000027F1F98>
print(f1.__dict__)      ##  {'name': 'alex', 'age': 18, 'gender': '男'}

描述符总结

描述符是可以实现大部分python类特性中的底层魔法,包括@classmethod,@staticmethd,@property甚至是__slots__属性

描述符是很多高级库和框架的重要工具之一,描述符通常是使用到装饰器或者元类的大型框架中的一个组件.

7 利用描述符原理完成一个自定制@property,实现延迟计算（本质就是把一个函数属性利用装饰器原理做成一个描述符：类的属性字典中函数名为key，value为描述符类产生的对象）

class Room:
    def __init__(self,name,owner,length,width,highth):
        self.房间名 = name
        self.主人 = owner
        self.长 = length
        self.宽 = width
        self.高 = highth

    @property     ##  把函数封装起来，让调用者调用的时候感受不到调用的过程
    def room_area(self):
        return '%s 住的 %s 面积是 %s平方米'%(self.主人,self.房间名,self.长 *self.宽)

r1 = Room('别墅','alex',30,20,10)
print(r1.room_area)     ##  alex 住的 别墅 面积是 600平方米

class CrazyProperty:
    def __init__(self,func):
        self.func = func

    def __get__(self,instance,owner):   ##  instance--> 实例 ， owner--> 类Room
        if instance is None:        ##  如果类调用 room_area ，这里返回一个CrazyProperty对象
            return self
        res = self.func(instance)
        return res

class Room:
    def __init__(self,name,owner,length,width,highth):
        self.房间名 = name
        self.主人 = owner
        self.长 = length
        self.宽 = width
        self.高 = highth

    @CrazyProperty      ##  room_area = CrazyProperty(room_area)    ##  定义类装饰器，实际上也是CrazyProperty给类Room添加描述符
    def room_area(self):
        return '%s 住的 %s 面积是 %s平方米'%(self.主人,self.房间名,self.长 *self.宽)

r1 = Room('别墅','alex',30,20,10)
print(r1.room_area)     ##  alex 住的 别墅 面积是 600平方米

print(Room.room_area)       ##  <__main__.CrazyProperty object at 0x00000000021B1F98>

但是这样子就有疑问了，类本身就给你提供了一个property方法，你还非得自己整了一个一模一样的，不是闲着蛋疼吗？

下面就完成一个property完成不了的功能：实现延迟计算（也就是说，实例第一次调用完room_area之后，会将room_area存到自己的属性字典里，下次调用就直接在实例属性字典里找，大大缩减时间）

class CrazyProperty:
    def __init__(self,func):
        self.func = func

    def __get__(self,instance,owner):   ##  instance--> 实例 ， owner--> 类Room
        print('---------->get')
        if instance is None:        ##  如果类调用 room_area ，这里返回一个CrazyProperty对象
            return self
        res = self.func(instance)
        setattr(instance,self.func.__name__,res)
        return res

class Room:
    def __init__(self,name,owner,length,width,highth):
        self.房间名 = name
        self.主人 = owner
        self.长 = length
        self.宽 = width
        self.高 = highth

    @CrazyProperty      ##  room_area = CrazyProperty(room_area)    ##  定义类装饰器，实际上也是CrazyProperty给类Room添加描述符
    def room_area(self):
        return '%s 住的 %s 面积是 %s平方米'%(self.主人,self.房间名,self.长 *self.宽)

r1 = Room('别墅','alex',30,20,10)
print(r1.room_area)     ##  alex 住的 别墅 面积是 600平方米
print(r1.__dict__)      ##  {'房间名': '别墅', '主人': 'alex', '长': 30, '宽': 20, '高': 10, 'room_area': 'alex 住的 别墅 面积是 600平方米'}

解释一下实现的机制：第一次实例调用room_area，由于实例属性没有，就会找非数据描述符，进行__get__后，get方法将room_area存到实例属性里，下次实例就直接在自己的属性字典里找room_area。

• 十五、__enter__ 和 __exit__

我们知道在操作文件对象可以这么写

with open('a.txt') as t:
    '代码块'

上述叫做上下文管理协议，即with语句，为了让一个对象兼容with语句，必须在这个对象的类中声明 __enter__ 和 __exit__ 方法

class Open:
    def __init__(self,name):
        self.name = name
    def __enter__(self):
        print('执行enter')
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):      ##  open逻辑结束后会执行这个方法    ##  实际上就类似于 f.close（）
        print('执行exit')

with Open('a.txt') as f:  ##    执行enter      ##  实例化，执行类Open下的enter方法，并把返回值赋值给f
    print(f)        ##  <__main__.Open object at 0x0000000002142FD0>
    print('---------------------')
    ##      执行exit

class Open:
    def __init__(self,name):
        self.name = name
    def __enter__(self):
        print('执行enter')
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        print('执行exit')
        print(exc_type)         ##  异常类
        print(exc_val)          ##  异常值
        print(exc_tb)           ##  异常追踪信息
        return True           ##  吞掉异常，程序不会报错
with Open('a.txt') as f:        ##  实例化，执行类Open下的enter方法，并把返回值赋值给f
    print(f)
    print(abcdefg)      ##  此时这里有异常
    print(f.name)       ##  此时上面有异常，直接执行__exit__,执行完毕with语句也就执行完毕，不会执行到这一句以及接下来的语句
    print('---------------------')
print('****************************')

总结：

一、没有异常的情况下，整个代码块运行完毕后去触发__exit__,它的三个参数都为None
二、有异常的情况下，从异常出现的位置直接触发 __exit__
a、如果 __exit__ 的返回值为True，代表吞掉了异常
b、如果 __exit__ 的返回值不是True，代表吞出了异常
c、__exit__ 的语句运行完毕代表了整个with语句的执行完毕

用途与好处：

1、使用with语句的目的就是把代码块放入with中执行，with结束后，自动完成清理工作，无需手动干预
2、在需要管理一下资源比如文件，网络连接和锁的编程环境中，可以在 __exit__ 中定制自动释放资源的机制，你无须再去关心这个问题，这将大有用处

• 十六、元类

我们都知道一切皆对象，类的对象是实例，那本质上类也是一个对象，也是另一个类产生的，这个类就是元类（type）。

class Foo:  ##  第一种创建类的方式
    pass
print(type(Foo))

def __init__(self,name):    ##添加构造函数
    self.name = name
def test(self):     ##  添加函数
    print('执行test')
    
Ffo = type('Ffo',(object,),{'x':1,'__init__':__init__,'test':test})     ##等同于Foo    ##  第二种创建类的方式

f1 = Ffo('alex')
print(f1.name)
f1.test()

 下面自定制一个元类

class MyType(type):
    def __init__(cls,a,b,c):
        print('元类构造函数开始执行')

    def __call__(cls,*args,**kwargs):       ##  Foo() 执行就会调用call方法
        obj = object().__new__(cls)    ##  <__main__.Foo object at 0x00000000027B1128>
        cls.__init__(obj,*args,**kwargs)
        return obj      ##  重新把Foo产生的对象返回

class Foo(metaclass=MyType):
    def __init__(self,name):
        self.name = name

# print(Foo)      ##  <class '__main__.Foo'>
f1 = Foo('alex')
print(f1.__dict__)      ##  {'name': 'alex'}