面向对象2
一.面向对象编程的三大特性
（一）继承
1.继承：子类继承父类的所有属性，若子类中有与父类属性相同的，由于作用域的影响，当调用该属性时会得到子类的该属性值。
用一句话总结继承：给了类（子类）一个特权，能去别的类（父类）的属性字典里找其属性。
2.继承分为单继承和多继承。
class Foo: 单继承 name = "cwt" class Bar(Foo): age = 20 print(Bar.name)>>>>cwt
class Foo: name = "cwt
class Bar: 多继承 age = 20 class People(Foo,Bar): gender = "male" print(People.name) >>>>cwt print(People.age) >>>>20
3.继承的含义：
（1）继承基类的方法，且做出自己的改变或扩展（减少代码重用）。即把有相同属性的属性整合，做成一个基类。
class Animal: def eat: print("需要吃东西") def sleep: print("需要睡觉") class Cat(Animal): def feature: print("我是猫，我会抓老鼠") class Bid(Animal): def feature: print("我是鸟，我会飞")
（2）声明某个子类兼容于某基类，定义一个接口类，子类继承接口类，并且实现。也称为借口继承。
例子：在python中，文件的共有属性就是都可读可写，所以定义下面的基类来声明，每个都要有读和写的功能
class All_file: def read(self): pass def write(self): pass
上面的例子并不能达到声明的功能，当你没有读功能或写功能时，并不会有什么反应。所以完善如下图
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): pass d1 = Disk() 》》》》》》报错（由于所创建的类中少了一个write功能，所以实例化时就会报错） class Disk(All_file): def read(self): pass def write(self): pass d1 = Disk() 》》》》》正常运行
上面这种接口继承也称为归一化设计。这种才是继承的主要用处。
4.继承顺序：
（1.）深度优先：经典类都用该方法
（2.）广度优先：新式类都用该方法
在python3中d都是用这种方法，且可以调用 类名.__mor__的方法查看继承顺。
总结：在python2中父类是什么类型的，子类就是什么类型。
5。在子类中调用父类属性的方法
（1）就是在父类的属性字典里找。（这不是一种好的方法，一般别用）
class People: def __init__(self,name,age): self.name = name self.age = age def run(self): pass class Foo(People): def __init__(self, name, age, gender ): self.name = name self.age = age self.gender = gender 子类中__init__中有几个是跟父类一样的，这样就是在写重复代码。 所以可以应用在子类中调用父类的方法 class Foo(People): def __init__(self, name, age, gender): People.__init__(self,name,age) self.gender = gender
（2）用super来调用父类的属性。
class People: def __init__(self,name,age): self.name = name self.age = age def run(self): pass class Foo(People): def __init__(self, name, age, gender): super().__init__(name, age) self.gender = gender
(二).多态
1.含义：对象通过他们共同的属性和动作来操作及访问，而不需要考虑他们具体的类
2.多态是一种绑定关系，只有运行时才成为多态。
class People: def __init__(self,name,age): self.name = name self.age = age def run(self): pass class L(People): pass class K(People): pass l1 = L("cwt",20) k1 = K("ccc",18) l1.run() 》》》》 k1.run() 》》》》这两步操作就称为多态（两个来
（三）封装：
1.含义：明确区分内外，内部实现逻辑，外部只能调用其方法，无法访问其内部逻辑。
2.第一种简单意义的封装：如在执行文件中调用另一个文件中定义的类（People），那么你只能调用到People中的方法，但你不知道People这个类中的逻辑，这就是简单意的封装。
3.python中的两种约定：
（1）以 _xxx 命名的属性，使用者不应该去调用（这只是一种约定，看你自己尊不遵守）
（2）以 _ _xxx 命名的属性，内部可以调用，但使用者无法调用到该属性。当是，这并不是python不让你调用，本质上是python的内在系统帮你把这个重命名了。 自动帮你改成 _类名_ _ xxx 。
class Foo: def __init__(self,x): self.__x = x def tell(self)
print(__x)
f1 = Foo(1) print(f1.__x) 》》》》报错 print(f1._Foo__x) >>>>>1
tell() >>>>>>1 内部能调用
4.真正意义的封装：把你不想别人知道的逻辑封装起来，但后期若是很多人需要用，你需要设接口，让使用者能调用到该东西。
class Foo: def __init__(self,x): self.__x = x def tell(self): print(__x) tell函数就是一个接口，本质上是利用在 内部能调用到
二。其它小知识点：
1.反射（自省）：指程序可以访问，检测和修改它本身状态或行为的一种能力。有以attr4种方法
（1）hasattr(object, name) >>检测object中是否含有name属性
（2）getattr(object,name,default = None) >>访问object的属性name，有该属性就会返回其值，若没有则会报错，但当你为default赋值时，没有就会输出default的值。
（3）setattr(object,x,y) >>为object添加属性 "x" = "y"
（4）delattr(object,x) >>删除object中的属性x
用途：当在写一个软件时，不同功能由不同的人写的，当你 需要用到别人写的功能时，你并不知道对方代码是否都写好了，这是你就可以用反射。
文件名：test.py class Room: def __init__(self,width,leight,height): self.width = width self.leight = leight self.height = height def area(self): room_area = self.width * self.leight return room_area
from test.py import Roomdef volume(height): r1 = Room(20,20) if hasattr(Room, "area"): room_volume = height * r1.area() return room_volume else: setattr(r1,"new_area", lambda width,leight:width *leight) room_volume = height * r1.new_area(20,20) return room_volume
.补充：
1.导入动态模块：有时，我们得到的模块路径是一个字符串，所以不能直接用from "xxxx" import xxx 这样只会报错
（1）__import__("文件名")
（2）用模块来解决
模块路径：kk.t import importlib m = importlib.import_module("kk.t") m.test()
2.如何把当前文件当作模块导入当前文件中：
import sys obj = sys.modules[__name__]
2.类的内置 attr 方法（注意：类的内置方法自己不设置时，是由默认的，当你设置后，就会按你自己设置的输出）
（1）_getattr_ ,访问的属性不存在时就会触发该函数
（2）_setattr_，设置属性时就会触发该函数，如实例化会触发__init__，__init__函数下有如 self.name = name的就会触发__serattr__
（3）_delattr_,删除属性时就会触发该函数。
这3个内置函数，与类都无关，只与实例有关：
class Foo: x = 1 y = 2 def __setattr__(self, key, value): print("触发setattr") def __getattr__(self, item): print("触发getattr") def __delattr__(self, item): print("触发delattr") print(Foo.x) 不会触发__getattr__ Foo.z = 3 不会触发__setattr__ del Foo.y 不会触发__delattr__
class Foo: x = 1 y = 2 def __init__(self,name): self.name = name def __setattr__(self, key, value): print("触发setattr") def __getattr__(self, item): print("触发getattr") def __delattr__(self, item): print("触发delattr") f1 = Foo("cwt") 》》》。触发__setattr__ f1.z = 3 》》》》触发__setattr__ del f1.y 》》》》触发_delattr__ print(f1.age) >>>由于f1中没有该属性所以触发__getattr__
如果在类中自己写了这3个函数，而没有写东西的话，实例后，实例的属性字典是空的。简单模拟系统的默认操作
class Foo: def __init__(self,name): self.name = name def __setattr__(self, key, value): self.__dict__ [key] = value def __getattr__(self, item): print("没有该属性") def __delattr__(self, item): self.__dict__ .pop(item) 只能用字典的操作来进行操作，如果用点的方式来进行操作，会进入死循环。 因为用点的方法总会触发_setattr_
这几个方法可以用来对属性的格式进行设置。如不让使用者删除：_delattr_函数下什么都不写，只写个提示
def __delattr__(self, item): print("不可删除")
3.item系列的方法
（1）_getitem_ 访问属性时，无论属性是否存在，都会触发该函数
（2）_setitem_ 创建属性时触发
（3）_delitem_ 删除属性时触发
以上3种方法的操作都必须是用字典的操作方法才会触发
class Foo: def __init__(self,name): self.name =name def __getitem__(self, item): print("触发getitem") def __setitem__(self, key, value): print("触发setitem") def __delitem__(self, key): print("触发delitem") f1 = Foo("cwt") f1["name"] 》》》触发_getitem__ f1["age"]=20 》》》触发__setitem__ f1["name"] 》》》触发__delitem__
4.包装标准类型：可以定制自己需要的数据类型
（1）包装的一个特性，继承。
class List(list): def append(self, val): print("不可对该列表进行增值") l1 = List("abc") print(l1) 》》》》["a","b","c"] l1.append(2) >>>>不可对该列表进行增值
上述代码，定义了一个不能添加元素的列表类，其它功能与原来一模一样。
（2）包装的另一特性：授权
import time class Open: def __init__(self, file_name, mode="r", encoding="utf8"): self.file = open(file_name, mode=mode, encoding=encoding) self.mode = mode self.encoding = encoding def __getattr__(self, item): return getattr(self.file, item) def write(self,line): t = time.strftime("%Y:%m:%d %X") self.file.write("%s %s" % (t, line)) f = Open("test", "r", encoding="utf8") f.write("hello world\n") f.write("hello world") print(f.read())
授权简单来说其实 就是，把本来就有的类实例化后，作为一个属性值，赋给某个属性。如上图中，把open实例化后，赋给file,这个file就有原来open这个类所有的功能。
5.isinstence(obj,cls)和issubclass(sub,super)
(1)isinstence 用来判断obl是否是类cls的实例化
（2）issubclass 用来判断sub 是否是super的子类
6.__getattribute__和__getattr__
(1)__getattribute__ 无论属性是否存在都会触发该函数执行。
（2）__getattr__ 当访问的属性不存在时会触发该函数。
class Foo: def __init__(self,name): self.name = name def __getattribute__(self, item): print("getattribute") def __getattr__(self, item): print("getattr") p1 = Foo("cwt") p1.name 》》》》》getattribute p1.age >>>>>>>getattribute 可见若两个函数同时存在，则永远只会触发__getattribute__
class Foo: def __init__(self, name, age): self.name = name self.age = age def __getattribute__(self, item): print("getattribute") p1.age >>>>属性不存在的话会报错，若该操作以下还有代码得话则不会执行了
.
. 这些代码都不会执行了。所以，一般 __getattribute__和__getattr__都是一起用的，但同时存在不是不会执行__getattr__吗？请往下继续看
.
class Foo: def __init__(self, name, age): self.name = name self.age = age def __getattribute__(self, item): print("getattribute") raise AttributeError ("属性不存在") def __getattr__(self, item): print("getattr") p1 = Foo("cwt",20)
》》》》getattribute 》》》》属性不存在
》》》》getattr
p1.age >>>首先触发__getattribute__，由于该属性不存在，所以会执行__getattribute_函数下的raise，实行了raise后，raise会传给__getattr__一个执行的指示。所以触发__getattr__
7.改变对象的字符串显示
（1.）假如类Foo实例化后得到实例f1，print（f1）>>>会得到<__main__.Foo object at 0x02C6EDD0> 得到的这个就是对象的字符串显示。
若你不设置，系统就会以默认值输出即类似于<__main__.Foo object at 0x02C6EDD0>。
（2）两个方法
①__str__:在pycharm等的环境下使用的。
②__repr__:这个是在python的解释器中应用的，但如果不是再解释器的环境下设置该属性时，你只写了__repr__那么系统会自动以这个来代替__repr__.若两个都有，那么只会调用__str__
class Foo: def __str__(self): return "我是一个实例" def __repr__(self): return "我是一个对象" f1 = Foo() print(f1) >>>我是一个实例
class Foo: def __repr__(self): return "我是一个对象" f1 = Foo() print(f1) >>>我是一个对像
8.format（）本质上是在调用类中的__format__函数属性。即自己不设置，系统会以默认形式输出。
（1）自定制格式化（format方法）
class Data: def __init__(self,year,mon,day): self.year = year self.mon = mon self.day = day def __format__(self, form): form_dict = {"ymd":"{0.year}{0.mon}{0.day}", "y:m:d":"{0.year}:{0.mon}:{0.day}", "y-m-d":"{0.year}-{0.mon}-{0.day}"} if not form or form not in form_dict: form = "ymd" f = form_dict[form] return f.format(self) d1 = Data(2019,8,15) print(d1.__format__("y:m:d"))
9._slots_属性，该属性为一个类变量。
类的属性字典是共享的，不过实例的属性字典是独享的，即你每创建一个实例，就会生成一个实例的属性字典。
假如有一个只有一两个属性的类，不过需要实例很多次，那么就会生成很多属性字典，就会占用很多内存，这时可以用_slots_来代替属性字典
即不设__init__函数，因为这个本质上就是在创建属性字典。而改成_slots_
class Foo: __slots__ = "name" f1=Foo() 》》》实例化后并不会产生属性字典，而是于类公用一个__slots__ f1.name = "cwt"
print(f1.name)
print（f1.__dict__）>>>会报错，没有这个
>>>cwt
有多个属性可以用列表存放，且实例过程，只能设跟类的__slots__里有的属性
class Foo: __slots__ = ["name","age"] f1=Foo() f1.name = "cwt" f1.age=20
f1.gender="male >>>>>报错
10.其它内置函数
（1）__del__，也称为析构方法。
作用：当对象在内存中被释放时，会自动触发该函数。（即当代码全部读完后，就会触发该函数）
class Foo: def __del__(self): print("清除完毕") f1=Foo() print("123") 》》》123 》》》清除完毕
（2）__doc__属性：查看类的文档字符串。
class Foo: "我是一个类" def __init__(self,x): self.x = x f1=Foo(1) print(f1.__doc__ ) 》》》我是一个类
注意：该属性不能被继承，因为每定义一个新类，系统会自动将__doc__=None设置进属性字典里
class Bar: "我是一个类" pass class Foo(Bar): def __init__(self,x): self.x = x f1=Foo(1) print(f1.__doc__ ) >>>None
(3)__call__属性：对象后加个（）就会触发该函数。
class Foo: def __init__(self,x): self.x = x def __call__(self, *args, **kwargs): print("我执行了") f1 = Foo(1) f1() 》》我执行了
11.迭代器协议
（1）迭代器协议是由类中的__iter__和__next__构成的
（2）执行next（）操作时，本质上就是触发__next__
（3）解释for循环：我们知道数据类型如 list 本身并不是可迭代对象，但却能进行for循环。原理：
for i in f1 ①f1 变成 iter(f1) 然后触发__iter__，将 f1 变成可迭代对象 ②自动触发next（）进而触发__next__
例子
class Feibo: def __init__(self): self._a = 1 self._b = 1 def __iter__(self): return self def __next__(self): # 1 1 2 3 5 self._a, self._b = self._b, self._a + self._b return self._a f1 = Feibo() print(f1.__next__()) 1 print(f1.__next__()) 2 print(f1.__next__()) 3 print(f1.__next__()) 5 print(f1.__next__()) 8
12.描述符
（1）含义：就是一个新式类，这个类至少要实现__get__ , __set__ , _delete__中的一个。
（2）数据描述符：实现了__set__和__get__ 的称为数据描述符，其它称为非数据描述符。
（3）基本的形式及参数
class Foo: def __get__(self, instance, owner): pass def __set__(self, instance, value): pass def __delete__(self, instance): pass class Bar: x = Foo() def __init__(self,n): self.x = n b1 = Bar(2) Foo即为一个描述符 instance = b1 owner = Bar self = x
class Foo: def __init__(self,key): self.key = key def __get__(self, instance, owner): return instance.__dict__[key] def __set__(self, instance, value): instance.__dict__ [self.key] = value def __delete__(self, instance): return instance.__dict__.pop(self.key) class Bar: x = Foo("name") def __init__(self,n): self.x = n b1 = Bar("cwt") print(b1.name) >>>>触发__get__ b1.age = 20 >>>>触发__set__ del b1.age >>>>触发__delete__
(4)优先级
类属性 > 数据描述符
数据描述符 > 实例属性
实例属性 > 非数据描述符
13.类的装饰器。与函数的装饰器是一样的。
def Foo(obj) : obj.x=1 obj.y=2 return obj @Foo class Bar: pass
14.上下文管理协议：
（1）含义：能符合with的操作 如 with open ("file_name") as f
(2)方法：__enter__(self) 和__exit__(self, exc_type,exc_val,exc_tb)
class Open: def __init__(self,name): self.name = name def __enter__(self): print("进入") return self def __exit__(self, exc_type, exc_val, exc_tb): print("已经退出") with Open("file") as f: ①左边的 with Open 会触发__enter__并把返回值传给f print(123) ②当with 语句下的代码都执行完了之后就会自动触发__exit__ print(222) >>> 进入 123 222 已经退出
class Open: def __init__(self,name): self.name = name def __enter__(self): print("进入") return self def __exit__(self, exc_type, exc_val, exc_tb): print("已经退出") with Open("file") as f: print(123) print(x) 当with以下的代码有发生错误，则会报错并执行__exit__ print(1111) 从错误的代码块开始，以下的都不会执行
print（33333） >>> 进入 Traceback (most recent call last): 123 已经退出 File "E:/PycharmProjects/untitled/untitled2/study-python/pracrer.py", line 259, in <module> print(x) NameError: name 'x' is not defined
class Open: def __init__(self,name): self.name = name def __enter__(self): print("进入") return self def __exit__(self, exc_type, exc_val, exc_tb): print("已经退出") return True》》》》》》》》》》》》》》》》》》》》加上这一步，当with中的代码发生错误时，自动执行__exit__，但不会报错，所以不会影响with之外的外码 》》》》》》》》》 with Open("file") as f: print(123) print(x) print(1111) print(123) 》》》 进入 123 已经退出 123
