1、 多态
多态，最浅显的意识就是同一事物具有多种形态，这很好理解，动物是一个大类，猫类属于动物类，狗类属于动物类，人也是属于动物类，那能理解成，猫、狗、人是一样的吗？当然不是，还有，水，分为液体、固体、气体，但它们都是H20构成的，这也是多态。意味着对于不同的类的对象，可以执行相同的操作，
多态是面向对象语言的一个基本特性，多态就意味着变量不需要知道引用的对象是什么，通过一个统一的接口，对引入的不同对象表现出不同的行为方式。
下面这个例子
1 import abc 2 class Animal(metaclass=abc.ABCMeta): 3 @abc.abstractmethod 4 def yell(self): 5 pass 6 class Dog(Animal): 7 def yell(self): 8 print("汪汪汪~") 9 class Cat(Animal): 10 def yell(self): 11 print("喵喵喵")
在上面这段代码中，类Animal作为一个大类，定义了yell方法，但对于Animal来说，有很多不同的形态表示，猫，狗、人等等都属于Animal类，而每个类都有不同的叫声，这就是同一类，多种形态的表示方式。
2、 封装
面向对象的程序设计中，某个类把所需要的数据（也可以说是类的属性）和对数据的操作（也可以说是类的行为）全部都封装在类中，分别称为类的成员变量和方法（或成员函数）。这种把成员变量和成员函数封装在一起的编程特性称为封装。封装，其实就是为了对外部隐藏对象的代码逻辑。
封装在概念上和多态很相似，但是不等同于多态。多态可以让实例对不知道是什么的类的对象进行属性、方法的调用，而封装是可以不同关心对象是如何构建就可以直接调用的。
在python中用双下划线开头的方式，将属性隐藏起来。双下划线+属性名就是私有的标识符，会自动变形为_类名__属性名的形式，即__x都会变形成_类名__x的形式，可以从类的属性字典中很明显的看到这种变形。这种变换不会关注标识符的语法位置，因此可以用来定义类私有的实例和类变量、方法、全局变量。
看下面这个例子：创建一个类Person，类变量，全局变量，和方法都有通过双下划线__设置的私有变量
1 class Person: 2 __skin = "yellow" #设置类的数据属性为私有的 3 hair = "black" 4 def __init__(self,name,age,height): 5 self.__name = name #变形为self._Person_name的形式 6 self.age = age 7 self.height = height 8 def __dance(self): #变形为_Person__dance的形式 9 print("%s正在跳舞"%self.name) 10 def sing(self): 11 print("%s正在唱歌"%self.name) 12 p_1 = Person("Tony",18,160)
在这个例子中，__skin、__self.name、__dance都是私有变量，外部的实例是无法直接访问的，通过实例p_1.属性\方法的形式，是无法调用这3个属性的，这就是私有变量的意义所在。
但其实，这只是一种python的约定，如果非想在外部的实例调用其私有变量，也并不是不可能。如果知道了类名和想调用的私有属性名，就可以调用。
即p_1._Person__skin这种方式，（注意：类名前是一个下划线，私有属性前是双下划线），调用方法p_1._Person__dance()
封装并不仅仅是为了将类中的属性隐藏起来，更多的需求是将私有属性作为外部调用的一个接口，用来对传入的数据做相应的限制，如下面这个例子：
1 class Person: 2 def __init__(self,name,age): 3 self.__name = name 4 self.__age = age 5 def person_info(self): 6 print("My name is %s，My age is %s"%(self.__name,self.__age)) 7 def set_person_info(self,name,age): 8 if not isinstance(name,str): 9 raise TypeError("名字必须是字符串类型") 10 if not isinstance(age,int): 11 raise TypeError("年龄必须是整数类型") 12 self.__name = name 13 self.__age = age 14 p_1 = Person("Tony",23) 15 p_1.person_info() 16 p_1.set_person_info(11,"An") 17 p_1.person_info()
在上面这个例子中，想要调用person_info()这个方法来显示出一个人的姓名和年龄，但是如果想要限制用户输入的姓名和年龄的数据类型，就要通过set_person_info（）这个方法来作为用户输入的一个接口。
单下划线定义的模块名，不用from..import..的方式导入
授权是封装的一个特性，
3、 反射
反射（或自省）主要是指程序可以访问、检测、和修改它本身状态或行为的一种能力，在python中，通过字符串的形式操作对象相关的属性，python中的一切事物都是对象，即都可以使用反射。
hasattr、getattr、setattr、delattr
四个可以实现自省的函数：
| hasattr(object,name) | 判断对象是否包含对应的属性。 object -- 对象 name -- 字符串，属性名 |
| getattr(object,name,[default]) | getattr() 函数用于返回一个对象属性值。 object -- 对象。 name -- 字符串，对象属性。 default -- 默认返回值，如果不提供该参数，在没有对应属性时，将触发 AttributeError。 |
| setattr(object,name,value) | setattr 函数对应函数 getatt()，用于设置属性值，该属性必须存在。 object – 对象 name - 字符串，属性名 value - 属性值
|
| delattr(object, name) | delattr 函数用于删除属性。 delattr(x, 'foobar') 相等于 del x.foobar。 object -- 对象。 name -- 必须是对象的属性。 |
通过下面这个实例，来演示一下4个函数的使用方法：
1 class Person: 2 skin = "yellow" 3 hair = "black" 4 def __init__(self,name,age): 5 self.name = name 6 self.age = age 7 def dance(self): 8 print("%s正在跳舞"%self.name) 9 p_1 = Person("Tony",18) 10 #判断Person类中是否含有dance属性， 11 print(hasattr(Person,"dance")) 12 #得到Person类中的skin属性的值，如果传入的是方法名，返回的就是方法的内存地址 13 print(getattr(Person,"skin")) 14 print(getattr(Person,"skin11")) #属性不存在，程序报错 15 #修改Person类中skin属性的值，类属性字典中也会做相应改变，通过Person.__dict__查看 16 setattr(Person,"skin","black") 17 print(getattr(Person,"skin")) 18 #删除Person类中hair这个属性，类的属性字典中也会删除 19 delattr(Person,"hair") 20 delattr(Person,"hair11") #属性不存在，报错
反射有什么好处？反射就可以事先定义好接口，这意味这什么呢？就是可以先写好主要的逻辑，然后再去后期实现实现的功能。
__getattr__、__setattr__、__delattr__
1 class Attr: 2 def __init__(self,x): 3 self.x = x 4 def __getattr__(self, item): 5 print("--->getter") 6 def __setattr__(self, key, value): 7 print("--->setattr") 8 def __delattr__(self, item): 9 print("--->delattr")
在这个例子中，重写了__getattr__、__setattr__、__delattr__这三个方法。这三个方法的存在会对类发生什么改变呢？
-
__getattr__：
只有在实例调用属性且调用的属性不存在才会运行
1 print(a_1.x) 2 运行结果： 3 --->setattr #只要赋值操作，就会触发__setattr__方法 4 6 5 print(a_1.y) 6 运行结果： 7 --->setattr 8 --->getter 9 None
还有一个__getattribute__方法，无论调用的属性是否存在，都会触发__getattribute__方法。当__getattribute__和__getattr__同时存在的话，只会执行__getattribute__，除非__getattribute__在执行的过程中抛出异常
- __setattr__：
1 a_1 = Attr(6) 2 print(a_1.__dict__) 3 运行结果： 4 {'x': 6} 5 删除注释，再次执行： 6 运行结果： 7 --->setattr 8 {}
先将这两行注销，然后创建一个实例并打印这个实例的属性字典：
创建了实例，但是属性确没有写进属性字典中，这是为什么？
这是因为，凡是赋值的操作，都会触发__setter__（）方法的运行，而在上面代码中，重写了__setattr__方法，代码逻辑仅仅有打印“--> setattr”操作，根本就没有将属性值写入实例属性的字典的操作，自然不会被写入，除非直接操作属性字典，否则根本无法往里面写入值。那么就需要进行如下修改：
1 class Attr: 2 def __init__(self,x): 3 self.x = x 4 def __getattr__(self, item): 5 print("--->getter") 6 self.__dict__[key]=value 7 def __setattr__(self, key, value): 8 print("--->setattr") 9 def __delattr__(self, item): 10 print("--->delattr")
直接将实例化传入的值，写入实例的属性字典，有些人很容易将这步操作写成
self.key = value ，这条语句是错误的，会导致程序无限递归。
- __delattr__
与__setattr__实质相同，在重写了__delattr__方法后，也需要定义相应的代码来从实例的属性字典中删除。即：
1 class Attr: 2 def __init__(self,x): 3 self.x = x 4 def __getattr__(self, item): 5 print("--->getter") 6 self.__dict__[key]=value 7 def __setattr__(self, key, value): 8 print("--->setattr") 9 def __delattr__(self, item): 10 print("--->delattr") 11 self.__dict__.pop(item)
可以先通过a_1.__dict__["a"]=1在实例的属性字典中添加属性a，进行删除测试，同样的，不可以在__delattr__()后通过del self.item的方式来删除，这样同样会引起无限递归。
4、 描述符
描述符是Python语言中很深奥也很重要的一个概念，简而言之，描述符也是一个对象，该对象代表了一个属性的值，这就意味着，如果一个类中有一个属性name，如果给该类添加了描述符，那么描述符就是另一个能代表属性name的对象。描述符协议中定义了_get_、_set_、_del_这些特殊的方法，描述符是实现其中的一个或多个方法的对象。这样说大家可能没有办法理解，还是通过代码讲解吧。
__get__():调用一个属性时,触发
__set__():为一个属性赋值时,触发
__delete__():采用del删除属性时,触发
定义一个描述符：
1 class Descriptor: 2 def __get__(self, instance, owner): 3 pass 4 def __set__(self, instance, value): 5 pass 6 def __delete__(self, instance): 7 pass
前面说过了，描述符就是一个类，如果一个类中定义了这三个方法，这个类就被称为一个描述符。
在前面讲过了__getattr__、__setattr__、__delattr__、方法，在由类产生实例的过程中会相应的触发这三个方法，而对_get_、_set_、_delete_来说，并不会被触发，那么触发这三个函数的条件又是什么？
1 class Descriptor: #创建描述符Descriptor 2 def __get__(self, instance, owner): 3 print("--->get") 4 def __set__(self, instance, value): 5 print("--->set") 6 def __delete__(self, instance): 7 print("--->delete") 8 9 10 class Person: 11 name = Descriptor() #属性name被Descriptor描述符描述 12 def __init__(self,name): 13 self.name = name
首先，描述符对描述符自身是没有用的，显而易见，之所以叫描述符，是用来描述其他对象的（类也是对象），从上段程序的运行结果可以明显的看出，name属性被描述符代理后，通过实例调用、设置、删除该属性，实质上执行的都是描述符Descriptor中的逻辑。描述符不可以被定义到构造函数中，必须赋值给类属性。这样写有什么意义呢？
1 p_1 = Person("Tony") 2 print(p_1.__dict__) 3 p_1.name = "An" 4 print(p_1.__dict__) 5 p_1.age = 18 6 print(p_1.__dict__) 7 运行结果： 8 --->set 9 {} 10 --->set 11 {} 12 {'age': 18}
创建了一个Person类的实例p_1,首先会触发_set_()方法，但是p_1的name=Tony这个属性并没有写入到它的属性字典中，修改name的属性为An，同样没有写入。这是因为，将Person类中的name这个属性通过name = Descriptor() 的方式被描述符代理了，所以调用该属性的时候，实质上就会去触发描述符Descriptor中的_set_方法，所以就无法写入。在最后添加了一个属性age，成功的写入到了实例p_1的属性字典中，是因为age这个属性没有被其他描述符代理，使用的就是类默认的逻辑来执行。
如果想要自定义的描述中也具备属性写入的功能，可以将Descriptor中的_set_()修改如下：
1 def __set__(self, instance, value): 2 print("--->set") 3 instance.__dict__["name"]=value
通过这个例子，可以看到描述符的强大之处，有很多时候，我们需要控制某些变量属性，就可以通过描述符来自定义想要的功能。
描述符分为两种：
数据描述符：至少实现了_get_()方法和_set_()方法。
非数据描述符：没有实现_set_()方法。
在调用的时候，应遵循以下优先级：类属性-->数据描述符-->实例属性-->非数据描述符-->__getattr__()方法（如果找不到属性的时候触发）
__str__()和__repr__()方法：
1 class Person: 2 def __init__(self,name): 3 self.name = name 4 def __str__(self): 5 return ("my name is %s"%self.name) 6 p_1 = Person("An") 7 print(p_1)
__str__发放就是可以自定义对象的字符串返回形式，如果不自定义__str__()方法，返回结果是：An,定义后，会按照定义的形式输出结果，即：my name is An。
__repr__()方法可以理解为__str__()方法的替代品，如果__str__没有被定义，就会使用__repr__()方法来代替输出。
__slots__属性：
__slots__其实是一个类变量，访问类或实例的时候，实质上就是在访问类和实例的属性字典__dict__,（类的属性字典是共享的，即所有所属该类的实例都可以访问，实例的属性字典是是独立的）。
1 p_1 = Person() 2 p_1.name = "Tony" 3 #p_1.age = 18 #报错 4 #print(p_1.__dict__) #报错，定义了__slots__,就不再有dict 5 print(p_1.__slots__) 6 运行结果： 7 name
但是字典是很占用计算机内存的，当类的属性很少，但是需要很多所属该类的实例的时候，就可以用__slots__来代替__dict__,__slots__中定义的变量就变成了类的描述符，类的实例只能拥有这些变量，但是不会拥有属于自己的属性字典，因此也就是不能增加新的变量。
通过__slots__,可以限制实例的属性，即减小的占用的内存空间，也会大大提升属性的访问速度。
5、 迭代器协议
__next__和__iter__实现迭代器协议。
1 class Iterator(): 2 def __init__(self,x): 3 self.x = x 4 def __iter__(self): 5 return self 6 def __next__(self): 7 8 self.x+=1 9 return self.x 10 i_1 = Iterator(1) 11 for i in i_1: 12 print(i)
这样就通过__iter__和__next__方法实现了迭代器。
斐波那契数列：
1 class Fibo(): 2 def __init__(self,x,y): 3 self.x = x 4 self.y = y 5 def __iter__(self): 6 return self 7 def __next__(self): 8 if self.x > 20: 9 raise StopIteration("超出终止") 10 self.x = self.y 11 self.y = self.x + self.y 12 return self.x 13 f_1= Fibo(0,1) 14 for i in f_1: 15 print(i)
6、 上下文管理协议：__enter__和__exit__
在管理文件操作的时候，可以通过with..open的方式来自动释放文件的内存，在类中，如果想让对象兼容with语句，必须在这个类中声明__enter__和__exit__方法
1 class File: 2 def __init__(self,x): 3 self.x = x 4 def __enter__(self): 5 print("--->enter") 6 def __exit__(self, exc_type, exc_val, exc_tb): 7 print("--->exit") 8 with File("test.txt") as f: 9 print("对象兼容with语句") 10 运行结果： 11 --->enter
对象兼容with语句
--->exit
从结果可以看出，文件操作流程中，首先触发__enter__方法，然后执行代码块中的内容，最后触发__exit__方法来释放文件内存。
__exit__()中的三个参数分别代表异常类型，异常值和追溯信息,with语句中代码块出现异常，则with后的代码都无法执行。
__call__:__call__方法的执行是通过对象名或类名后加（）来执行的。
1575
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
