标签：等等 OAO x11 mod demo upd conf strong asa
继承指的是类与类之间的关系，是一种什么“是”什么的关系，继承的功能之一就是用来解决代码重用问题。
继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类，父类又可以成为基类或超类，新建的类称为派生类或子类。
1 # 父类/基类/超生类 2 # 子类/派生类（继承父类） 3 # _bases_则是查看所有继承的父类
代码示例如下：
1 class ParentClass1: 2 pass 3 class ParentClass2: 4 pass 5 class SubClass1(ParentClass1): 6 pass 7 class SubClass2(ParentClass1,ParentClass2): 8 pass 9 10 print(SubClass1.__bases__) 11 print(SubClass2.__bases__) 12 13 ### 14 (<class ‘__main__.ParentClass1‘>,) 15 (<class ‘__main__.ParentClass1‘>, <class ‘__main__.ParentClass2‘>)
抽象即抽取类似或者说比较像的部分。
抽象分成两个层次：
1.将奥巴马和梅西这俩对象比较像的部分抽取成类；
2.将人，猪，狗这三个类比较像的部分抽取成父类。
抽象最主要的作用是划分类别（可以隔离关注点，降低复杂度）
继承：是基于抽象的结果，通过编程语言去实现它，肯定是先经历抽象这个过程，才能通过继承的方式去表达出抽象的结构。
抽象只是分析和设计的过程中，一个动作或者说一种技巧，通过抽象可以得到类
在开发程序的过程中，如果我们定义了一个类A，然后又想新建立另外一个类B，但是类B的大部分内容与类A的相同时
我们不可能从头开始写一个类B，这就用到了类的继承的概念。
通过继承的方式新建类B，让B继承A，B会‘遗传’A的所有属性(数据属性和函数属性)，实现代码重用
1 class Hero: 2 def __init__(self, nickname, life_value, aggressivity): 3 self.nickname = nickname 4 self.life_value = life_value 5 self.aggressivity = aggressivity 6 def attack(self, enemy): 7 enemy.life_value -= self.aggressivity 8 9 class Gailen(Hero): 10 pass 11 12 class Riven(Hero): 13 pass 14 15 gailen = Gailen(‘草丛伦‘, 120, 40) 16 print(gailen.nickname, gailen.life_value, gailen.aggressivity) # 这里能实现，说明了它是继承了Hero的属性
提示：用已经有的类建立一个新的类，这样就重用了已经有的软件中的一部分设置大部分，大大节省了编程工作量，这就是常说的软件重用，不仅可以重用自己的类，也可以继承别人的，比如标准库，来定制新的数据类型，这样就是大大缩短了软件开发周期，对大型软件开发来说，意义重大.
查找顺序：对象自己 → 对象自己的类 → 父类
1 # 查找顺序：对象自己 → 对象自己的类 → 父类 2 class Foo: 3 def f1(self): 4 print(‘Foo.f1‘) 5 6 def f2(self): 7 print(‘Foo.f2‘) 8 self.f1() # b.f1() 9 10 class Bar(Foo): 11 def f1(self): 12 print(‘Bar.f1‘) 13 14 b = Bar() 15 b.f2() 16 ###Foo.f2 17 ###Bar.f1
当然子类也可以添加自己新的属性或者在自己这里重新定义这些属性（不会影响到父类），需要注意的是，一旦重新定义了自己的属性且与父类重名，那么调用新增的属性时，就以自己为准了。
1 class Hero: 2 def __init__(self, nickname, life_value, aggressivity): 3 self.nickname = nickname 4 self.life_value = life_value 5 self.aggressivity = aggressivity 6 def attack(self, enemy): 7 enemy.life_value -= self.aggressivity 8 9 class Riven(Hero): 10 camp=‘Noxus‘ 11 def attack(self,enemy): #在自己这里定义新的attack,不再使用父类的attack,且不会影响父类 12 print(‘from riven‘) 13 def fly(self): #在自己这里定义新的 14 print(‘%s is flying‘ % self.nickname)
在子类中，新建的重名的函数属性，在编辑函数内功能的时候，有可能需要重用父类中重名的那个函数功能，应该是用调用普通函数的方式，即：类名.func()，此时就与调用普通函数无异了，因此即便是self参数也要其传值。
1 class Riven(Hero): 2 camp=‘Noxus‘ 3 def __init__(self,nickname,aggressivity,life_value,skin): 4 Hero.__init__(self,nickname,aggressivity,life_value) #调用父类功能 5 self.skin=skin #新属性 6 def attack(self,enemy): #在自己这里定义新的attack,不再使用父类的attack,且不会影响父类 7 Hero.attack(self,enemy) #调用功能 8 print(‘from riven‘) 9 def fly(self): #在自己这里定义新的 10 print(‘%s is flying‘ %self.nickname) 11 12 r1=Riven(‘锐雯雯‘,57,200,‘比基尼‘) 13 r1.fly() 14 print(r1.skin) 15 16 ‘‘‘ 17 运行结果 18 锐雯雯 is flying 19 比基尼 20 21 ‘‘‘
python到底是如何实现继承的，对于你定义的每一个类，python会计算出一个方法解析顺序(MRO)列表，这个MRO列表就是一个简单的所有基类的线性顺序列表，例如
1 class A(object): 2 def test(self): 3 print(‘from A‘) 4 5 class B(A): 6 def test(self): 7 print(‘from B‘) 8 9 class C(A): 10 def test(self): 11 print(‘from C‘) 12 13 class D(B): 14 def test(self): 15 print(‘from D‘) 16 17 class E(C): 18 def test(self): 19 print(‘from E‘) 20 21 class F(D,E): 22 # def test(self): 23 # print(‘from F‘) 24 pass 25 f1=F() 26 f1.test() 27 print(F.__mro__) #只有新式才有这个属性可以查看线性列表，经典类没有这个属性 28 29 """ 30 from D 31 (<class ‘__main__.F‘>, <class ‘__main__.D‘>, <class ‘__main__.B‘>, <class ‘__main__.E‘>, <class ‘__main__.C‘>, <class ‘__main__.A‘>, <class ‘object‘>) 32 """
1 # 在python2中-->经典类：没有继承object的类，以及它的子类都称经典类 2 class Foo: 3 pass 4 class Bar(Foo): 5 pass 6 7 # 在python2中-->新式类：继承object的类，以及它的子类都称之为新式类 8 class Foo(object): 9 pass 10 class Bar(Foo): 11 pass 12 13 # 在python3中-->新式类：一个类没有继承object类，默认就继承了object 14 class Foo(): # --> class Foo(object): 15 pass 16 print(Foo.__bases__) 17 18 ### 19 (<class ‘object‘>,)
从左边开始就一直走到底，然后后面再这样一直轮下去
新式类不会走到头，快要到头的时候折返回来往另外一个找，最后一个爹一条路走到底
代码示例
1 class A(object): 2 def test(self): 3 print(‘from A‘) 4 5 class B(A): 6 def test(self): 7 print(‘from B‘) 8 9 class C(A): 10 def test(self): 11 print(‘from C‘) 12 13 class D(B): 14 def test(self): 15 print(‘from D‘) 16 17 class E(C): 18 def test(self): 19 print(‘from E‘) 20 21 class F(D,E): 22 # def test(self): 23 # print(‘from F‘) 24 pass 25 f1=F() 26 f1.test() 27 print(F.__mro__) #只有新式才有这个属性可以查看线性列表，经典类没有这个属性 28 29 #新式类继承顺序:F->D->B->E->C->A 30 #经典类继承顺序:F->D->B->A->E->C 31 #python3中统一都是新式类 32 #pyhon2中才分新式类与经典类 33 ‘‘‘ 34 print(F._mro_)执行结果 35 36 1 37 (<class ‘__main__.F‘>, <class ‘__main__.D‘>, <class ‘__main__.B‘>, <class ‘__main__.E‘>, <class ‘__main__.C‘>, <class ‘__main__.A‘>, <class ‘object‘>) 38 ‘‘‘
在子类派生出的新方法中，往往需要重用父类的方法，我们有两种方式实现
1 class Hero: 2 def __init__(self, nickname, life_value, aggressivity): 3 self.nickname = nickname 4 self.life_value = life_value 5 self.aggressivity = aggressivity 6 def attack(self, enemy): 7 enemy.life_value -= self.aggressivity 8 9 class Gailen(Hero): 10 camp = ‘Demacia‘ 11 def attack(self, enemy): 12 Hero.attack(self, enemy) # 指名道姓 13 print(‘from Gailen Class‘) 14 15 class Riven(Hero): 16 camp = ‘Noxus‘ 17 18 gailen = Gailen(‘草丛伦‘, 100, 30) 19 riven = Riven(‘锐雯雯‘, 80, 50) 20 print(riven.life_value) 21 gailen.attack(riven) 22 print(riven.life_value) 23 24 """ 25 80 26 from Gailen Class 27 50 28 """
1 class Hero: 2 def __init__(self, nickname, life_value, aggressivity): 3 self.nickname = nickname 4 self.life_value = life_value 5 self.aggressivity = aggressivity 6 def attack(self, enemy): 7 enemy.life_value -= self.aggressivity 8 9 class Gailen(Hero): 10 camp = ‘Demacia‘ 11 def __init__(self, nickname, life_value, aggressivity, weapon): 12 # self.nickname = nickname 13 # self.life_value = life_value 14 # self.aggressivity = aggressivity 15 Hero.__init__(self, nickname, life_value, aggressivity) 16 17 self.weapon = weapon 18 def attack(self, enemy): 19 Hero.attack(self, enemy) # 指名道姓 20 print(‘from Gailen Class‘) 21 22 gailen = Gailen(‘草丛伦‘, 100, 30, ‘大宝剑‘) 23 print(gailen.__dict__) 24 25 """ 26 {‘nickname‘: ‘草丛伦‘, ‘life_value‘: 100, ‘aggressivity‘: 30, ‘weapon‘: ‘大宝剑‘} 27 """
1 # 方式二 2 class Hero: 3 def __init__(self, nickname, life_value, aggressivity): 4 self.nickname = nickname 5 self.life_value = life_value 6 self.aggressivity = aggressivity 7 def attack(self, enemy): 8 enemy.life_value -= self.aggressivity 9 10 class Gailen(Hero): 11 camp = ‘Demacia‘ 12 def attack(self, enemy): 13 super(Gailen, self).attack(enemy) # 依赖继承,super(自己的类名，self) 14 print(‘from Gailen Class‘) 15 16 class Riven(Hero): 17 camp = ‘Noxus‘ 18 19 gailen = Gailen(‘草丛伦‘, 100, 30) 20 riven = Riven(‘锐雯雯‘, 80, 50) 21 22 print(riven.life_value) 23 gailen.attack(riven) 24 print(riven.life_value) 25 26 """ 27 80 28 from Gailen Class 29 50 30 """
在python3中super()中已经默认传入参数，可以不用传参数
1 class Hero: 2 def __init__(self, nickname, life_value, aggressivity): 3 self.nickname = nickname 4 self.life_value = life_value 5 self.aggressivity = aggressivity 6 def attack(self, enemy): 7 enemy.life_value -= self.aggressivity 8 9 class Gailen(Hero): 10 camp = ‘Demacia‘ 11 def __init__(self, nickname, life_value, aggressivity, weapon): 12 # self.nickname = nickname 13 # self.life_value = life_value 14 # self.aggressivity = aggressivity 15 super().__init__(nickname, life_value, aggressivity) # 在python3中默认可以不用在super中写入参数 16 17 self.weapon = weapon 18 def attack(self, enemy): 19 Hero.attack(self, enemy) # 指名道姓 20 print(‘from Gailen Class‘) 21 22 gailen = Gailen(‘草丛伦‘, 100, 30, ‘大宝剑‘) 23 print(gailen.__dict__) 24 25 """ 26 {‘nickname‘: ‘草丛伦‘, ‘life_value‘: 100, ‘aggressivity‘: 30, ‘weapon‘: ‘大宝剑‘} 27 """
这两种方式的区别是：方式一是跟继承没有关系的，而方式二的super()是依赖于继承的，并且即使没有直接继承关系，super仍然会按照mro继续往后查找。
1 # A没有继承B,但是A内super会基于C.mro()继续往后找 2 class A: 3 def f1(self): 4 print(‘from A‘) 5 super().f1() 6 class B: 7 def f1(self): 8 print(‘from B‘) 9 class C(A,B): 10 pass 11 12 print(C.mro()) 13 c = C() 14 c.f1() # 打印结果:from B 15 16 """ 17 [<class ‘__main__.C‘>, <class ‘__main__.A‘>, <class ‘__main__.B‘>, <class ‘object‘>] 18 from A 19 from B 20 """
软件重用的重要方式除了继承之外还有另外一种方式，即：组合
组合指的是，在一个类中以另外一个类的对象作为数据属性，称为类的组合
组合与继承都是有效地利用已有类的资源的重要方式。但是二者的概念和使用场景皆不同。
当类之间有显著不同，并且较小的类是较大的类所需要的组件时，这时用组合比较好。
1 class People: 2 def __init__(self, name, age, sex): 3 self.name = name 4 self.age = age 5 self.sex = sex 6 7 class Teacher(People): 8 def __init__(self, name, age, sex, level, salary): 9 super().__init__(name, age, sex) 10 self.level = level 11 self.salary = salary 12 13 class Student(People): 14 def __init__(self, name, age, sex, class_time): 15 super().__init__(name, age, sex) 16 self.class_time = class_time 17 18 class Course: 19 def __init__(self, course_name, course_price, course_period): 20 self.course_name = course_name 21 self.course_price = course_price 22 self.course_period = course_period 23 def tell_info(self): 24 print(‘课程名为<%s> 课程价钱为<%s> 课程周期为<%s>‘ % (self.course_name, self.course_price, self.course_period)) 25 26 class Date: 27 def __init__(self, year, mon, day): 28 self.year = year 29 self.mon = mon 30 self.day = day 31 def tell_info(self): 32 print(‘I was born in %s年%s月%s日‘ % (self.year, self.mon, self.day)) 33 34 teacher1 = Teacher(‘luoma‘, 28, ‘male‘, 10, 3000) 35 teacher2 = Teacher(‘laoluo‘, 38, ‘male‘, 30, 3000) 36 python = Course(‘python‘, 3000, ‘3mons‘) 37 linux = Course(‘linux‘, 2000, ‘4mons‘) 38 39 teacher1.course = python 40 teacher2.course = python 41 42 43 print(python) 44 print(teacher1.course) # teacher1.course == python 45 print(teacher2.course) 46 print(teacher1.course.course_name) # teacher1.course.course_name == Course.course_name 47 48 teacher1.course.tell_info() 49 50 student1 = Student(‘laoqiu‘, 18, ‘male‘, 8) 51 52 # 给老师这个对象定制了课程属性，让这个属性指向另一个对象，将老师类和课程类组合到一起 53 student1.course1 = python 54 student1.course2 = linux 55 student1.course1.tell_info() 56 student1.course2.tell_info() 57 58 student1.courses = [] 59 student1.courses.append(python) 60 student1.courses.append(linux) 61 print(student1.courses) 62 63 # 创建一个学生对象和一个时间类，可以达到这种效果 64 d = Date(1999, 4, 20) 65 student1.birth = d 66 print(student1.birth.tell_info()) 67 print(student1.course1.tell_info()) 68 69 """ 70 <__main__.Course object at 0x02CECCF0> 71 <__main__.Course object at 0x02CECCF0> 72 <__main__.Course object at 0x02CECCF0> 73 python 74 课程名为<python> 课程价钱为<3000> 课程周期为<3mons> 75 课程名为<python> 课程价钱为<3000> 课程周期为<3mons> 76 课程名为<linux> 课程价钱为<2000> 课程周期为<4mons> 77 [<__main__.Course object at 0x02CECCF0>, <__main__.Course object at 0x02CECD10>] 78 I was born in 1999年4月20日 79 None 80 课程名为<python> 课程价钱为<3000> 课程周期为<3mons> 81 None 82 """
你好，给我开个查询接口>>>此时的接口指的是：自己提供给使用者来调用自己功能的方式\方法\入口，java中的interface使用如下
java中的interface：
1 =================第一部分：Java 语言中的接口很好的展现了接口的含义: IAnimal.java 2 /* 3 * Java的Interface接口的特征: 4 * 1)是一组功能的集合,而不是一个功能 5 * 2)接口的功能用于交互,所有的功能都是public,即别的对象可操作 6 * 3)接口只定义函数,但不涉及函数实现 7 * 4)这些功能是相关的,都是动物相关的功能,但光合作用就不适宜放到IAnimal里面了 */ 8 9 package com.oo.demo; 10 public interface IAnimal { 11 public void eat(); 12 public void run(); 13 public void sleep(); 14 public void speak(); 15 } 16 17 =================第二部分：Pig.java：猪”的类设计,实现了IAnnimal接口 18 package com.oo.demo; 19 public class Pig implements IAnimal{ //如下每个函数都需要详细实现 20 public void eat(){ 21 System.out.println("Pig like to eat grass"); 22 } 23 24 public void run(){ 25 System.out.println("Pig run: front legs, back legs"); 26 } 27 28 public void sleep(){ 29 System.out.println("Pig sleep 16 hours every day"); 30 } 31 32 public void speak(){ 33 System.out.println("Pig can not speak"); } 34 } 35 36 =================第三部分：Person2.java 37 /* 38 *实现了IAnimal的“人”,有几点说明一下: 39 * 1)同样都实现了IAnimal的接口,但“人”和“猪”的实现不一样,为了避免太多代码导致影响阅读,这里的代码简化成一行,<br>但输出的内容不一样,实际项目中同一接口的同一功能点,不同的类实现完全不一样 40 * 2)这里同样是“人”这个类,但和前面介绍类时给的类“Person”完全不一样,<br>这是因为同样的逻辑概念,在不同的应用场景下,具备的属性和功能是完全不一样的 */ 41 42 package com.oo.demo; 43 public class Person2 implements IAnimal { 44 public void eat(){ 45 System.out.println("Person like to eat meat"); 46 } 47 48 public void run(){ 49 System.out.println("Person run: left leg, right leg"); 50 } 51 52 public void sleep(){ 53 System.out.println("Person sleep 8 hours every dat"); 54 } 55 56 public void speak(){ 57 System.out.println("Hellow world, I am a person"); 58 } 59 } 60 61 =================第四部分：Tester03.java 62 package com.oo.demo; 63 64 public class Tester03 { 65 public static void main(String[] args) { 66 System.out.println("===This is a person==="); 67 IAnimal person = new Person2(); 68 person.eat(); 69 person.run(); 70 person.sleep(); 71 person.speak(); 72 73 System.out.println("\n===This is a pig==="); 74 IAnimal pig = new Pig(); 75 pig.eat(); 76 pig.run(); 77 pig.sleep(); 78 pig.speak(); 79 } 80 } 81 82 java中的interface
接口提取了一群类共同的函数，可以把接口当做一个函数的集合。
然后让子类去实现接口中的函数。
这么做的意义在于归一化，什么叫归一化，就是只要是基于同一个接口实现的类，那么所有的这些类产生的对象在使用时，从用法上来说都一样。
归一化的好处在于：
1，归一化让使用者无需关心对象的类是什么，只需要的知道这些对象都具备某些功能就可以了，这极大地降低了使用者的使用难度。
2，归一化使得高层的外部使用者可以不加区分的处理所有接口兼容的对象集合
①就好象linux的泛文件概念一样，所有东西都可以当文件处理，不必关心它是内存、磁盘、网络还是屏幕（当然，对底层设计者，当然也可以区分出“字符设备”和“块设备”，然后做出针对性的设计：细致到什么程度，视需求而定）。
②再比如：我们有一个汽车接口，里面定义了汽车所有的功能，然后由本田汽车的类，奥迪汽车的类，大众汽车的类，他们都实现了汽车接口，这样就好办了，大家只需要学会了怎么开汽车，那么无论是本田，还是奥迪，还是大众我们都会开了，开的时候根本无需关心我开的是哪一类车，操作手法（函数调用）都一样
在python中根本就没有一个叫做interface的关键字，如果非要去模仿接口的概念
可以借助第三方模块：http://pypi.python.org/pypi/zope.interface
也可以使用继承，其实继承有两种用途
一：继承基类的方法，并且做出自己的改变或者扩展（代码重用）：实践中，继承的这种用途意义并不很大，甚至常常是有害的。因为它使得子类与基类出现强耦合。
二：声明某个子类兼容于某基类，定义一个接口类（模仿java的Interface），接口类中定义了一些接口名（就是函数名）且并未实现接口的功能，子类继承接口类，并且实现接口中的功能
1 class Interface:#定义接口Interface类来模仿接口的概念，python中压根就没有interface关键字来定义一个接口。 2 def read(self): #定接口函数read 3 pass 4 5 def write(self): #定义接口函数write 6 pass 7 8 9 class Txt(Interface): #文本，具体实现read和write 10 def read(self): 11 print(‘文本数据的读取方法‘) 12 13 def write(self): 14 print(‘文本数据的读取方法‘) 15 16 class Sata(Interface): #磁盘，具体实现read和write 17 def read(self): 18 print(‘硬盘数据的读取方法‘) 19 20 def write(self): 21 print(‘硬盘数据的读取方法‘) 22 23 class Process(Interface): 24 def read(self): 25 print(‘进程数据的读取方法‘) 26 27 def write(self): 28 print(‘进程数据的读取方法‘)
与java一样，python也有抽象类的概念但是同样需要借助模块实现，抽象类是一个特殊的类，它的特殊之处在于只能被继承，不能被实例化
如果说类是从一堆对象中抽取相同的内容而来的，那么抽象类就是从一堆类中抽取相同的内容而来的，内容包括数据属性和函数属性。
比如我们有香蕉的类，有苹果的类，有桃子的类，从这些类抽取相同的内容就是水果这个抽象的类，你吃水果时，要么是吃一个具体的香蕉，要么是吃一个具体的桃子。。。。。。你永远无法吃到一个叫做水果的东西。
从设计角度去看，如果类是从现实对象抽象而来的，那么抽象类就是基于类抽象而来的。
从实现角度来看，抽象类与普通类的不同之处在于：抽象类中只能有抽象方法（没有实现功能），该类不能被实例化，只能被继承，且子类必须实现抽象方法。这一点与接口有点类似，但其实是不同的，即将揭晓答案
1 #一切皆文件 2 import abc #利用abc模块实现抽象类 3 4 class All_file(metaclass=abc.ABCMeta): 5 all_type=‘file‘ 6 @abc.abstractmethod #定义抽象方法，无需实现功能 7 def read(self): 8 ‘子类必须定义读功能‘ 9 pass 10 11 @abc.abstractmethod #定义抽象方法，无需实现功能 12 def write(self): 13 ‘子类必须定义写功能‘ 14 pass 15 16 # class Txt(All_file): 17 # pass 18 # 19 # t1=Txt() #报错,子类没有定义抽象方法 20 21 class Txt(All_file): #子类继承抽象类，但是必须定义read和write方法 22 def read(self): 23 print(‘文本数据的读取方法‘) 24 25 def write(self): 26 print(‘文本数据的读取方法‘) 27 28 class Sata(All_file): #子类继承抽象类，但是必须定义read和write方法 29 def read(self): 30 print(‘硬盘数据的读取方法‘) 31 32 def write(self): 33 print(‘硬盘数据的读取方法‘) 34 35 class Process(All_file): #子类继承抽象类，但是必须定义read和write方法 36 def read(self): 37 print(‘进程数据的读取方法‘) 38 39 def write(self): 40 print(‘进程数据的读取方法‘) 41 42 wenbenwenjian=Txt() 43 44 yingpanwenjian=Sata() 45 46 jinchengwenjian=Process() 47 48 #这样大家都是被归一化了,也就是一切皆文件的思想 49 wenbenwenjian.read() 50 yingpanwenjian.write() 51 jinchengwenjian.read() 52 53 print(wenbenwenjian.all_type) 54 print(yingpanwenjian.all_type) 55 print(jinchengwenjian.all_type)
再来通过另外一个例子看看其中的差别和演变
先来看看原代码
1 class People: 2 def walk(self): 3 print(‘is walking‘) 4 5 class Pig: 6 def run(self): 7 print(‘is running‘) 8 9 class Dog: 10 def jump(self): 11 print(‘is jumping‘) 12 13 people1 = People() 14 pig1 = Pig() 15 dog1 = Dog() 16 17 # 下面每个对象都有相应的走的功能，但是需要调用不用的方法。需要找个类把所有的方法统一起来。 18 people1.walk() 19 pig1.run() 20 dog1.jump()
但是，这样会造成的困扰就是会增加后面使用者的使用难度，同样是走的动作，但是却有不同的表达
这时，我们可以使用抽象类，达到归一化
1 # 通过调用模块，装饰器等，可以实现后面的调用一定要调用Animal里面的方法，否则会报错 2 import abc 3 class Animal(metaclass=abc.ABCMeta): # 抽象类只能被继承，不能被实例化，功能是指规范子类 4 all_type = ‘animal‘ 5 @abc.abstractmethod 6 def run(self): 7 pass 8 @abc.abstractmethod 9 def eat(self): 10 pass 11 12 # 抽象类不能被实例化，否则会报错 13 # animal = Animal() # Can‘t instantiate abstract class Animal with abstract methods eat, run 14 15 class People(Animal): 16 def run(self): 17 print(‘people is running‘) 18 def eat(self): 19 print(‘people is eating‘) 20 21 class Pig(Animal): 22 def run(self): 23 print(‘pig is running‘) 24 def eat(self): 25 print(‘pig is eating‘) 26 27 class Dog(Animal): 28 29 def run(self): 30 print(‘dog is running‘) 31 def eat(self): 32 print(‘dog is eating‘) 33 34 people1 = People() 35 pig1 = Pig() 36 dog1 = Dog() 37 38 people1.run() 39 pig1.run() 40 dog1.run() 41 print(people1.all_type) # 虽然Animal是抽象类，但本质上还是一个类。
抽象类的本质还是类，指的是一组类的相似性，包括数据属性（如all_type）和函数属性（如read、write），而接口只强调函数属性的相似性。
抽象类是一个介于类和接口直接的一个概念，同时具备类和接口的部分特性，可以用来实现归一化设计
多态指的是一类事物有多种形态，比如动物有多种形态：人，狗，猪
1 import abc 2 class Animal(metaclass=abc.ABCMeta): #同一类事物:动物 3 @abc.abstractmethod 4 def talk(self): 5 pass 6 7 class People(Animal): #动物的形态之一:人 8 def talk(self): 9 print(‘say hello‘) 10 11 class Dog(Animal): #动物的形态之二:狗 12 def talk(self): 13 print(‘say wangwang‘) 14 15 class Pig(Animal): #动物的形态之三:猪 16 def talk(self): 17 print(‘say aoao‘)
多态性是指在不考虑实例类型的情况下使用实例，多态性分为静态多态性和动态多态性
静态多态性：如任何类型都可以用运算符 + 进行运算，1+2=3。
动态多态性：如下
1 peo=People() 2 dog=Dog() 3 pig=Pig() 4 5 #peo、dog、pig都是动物,只要是动物肯定有talk方法 6 #于是我们可以不用考虑它们三者的具体是什么类型,而直接使用 7 peo.talk() 8 dog.talk() 9 pig.talk() 10 11 #更进一步,我们可以定义一个统一的接口来使用 12 def func(obj): 13 obj.talk()
其实大家从上面多态性的例子可以看出，我们并没有增加什么新的知识，也就是说python本身就是支持多态性的，这么做的好处是什么呢？
1.增加了程序的灵活性
以不变应万变，不论对象千变万化，使用者都是同一种形式去调用，如func(animal)
2.增加了程序额可扩展性
通过继承animal类创建了一个新的类，使用者无需更改自己的代码，还是用func(animal)去调用
1 >>> class Cat(Animal): #属于动物的另外一种形态：猫 2 ... def talk(self): 3 ... print(‘say miao‘) 4 ... 5 >>> def func(animal): #对于使用者来说，自己的代码根本无需改动 6 ... animal.talk() 7 ... 8 >>> cat1=Cat() #实例出一只猫 9 >>> func(cat1) #甚至连调用方式也无需改变，就能调用猫的talk功能 10 say miao 11 12 ‘‘‘ 13 这样我们新增了一个形态Cat，由Cat类产生的实例cat1，使用者可以在完全不需要修改自己代码的情况下。使用和人、狗、猪一样的方式调用cat1的talk方法，即func(cat1)
逗比时刻：
Python崇尚鸭子类型，即‘如果看起来像、叫声像而且走起路来像鸭子，那么它就是鸭子’
python程序员通常根据这种行为来编写程序。例如，如果想编写现有对象的自定义版本，可以继承该对象
也可以创建一个外观和行为像，但与它无任何关系的全新对象，后者通常用于保存程序组件的松耦合度。
例1：利用标准库中定义的各种‘与文件类似’的对象，尽管这些对象的工作方式像文件，但他们没有继承内置文件对象的方法
1 #二者都像鸭子,二者看起来都像文件,因而就可以当文件一样去用 2 class TxtFile: 3 def read(self): 4 pass 5 6 def write(self): 7 pass 8 9 class DiskFile: 10 def read(self): 11 pass 12 def write(self): 13 pass
例2：序列类型有多种形态：字符串，列表，元组，但他们直接没有直接的继承关系
1 #str,list,tuple都是序列类型 2 s=str(‘hello‘) 3 l=list([1,2,3]) 4 t=tuple((4,5,6)) 5 6 #我们可以在不考虑三者类型的前提下使用s,l,t 7 s.__len__() 8 l.__len__() 9 t.__len__() 10 11 len(s) 12 len(l) 13 len(t)
封装有点像拿一个麻袋，把一个东西给装起来，然后封上口子，照这种逻辑来看，封装=‘隐藏’，这种理解还是有点片面
在python中用双下划线开头的方式将属性隐藏起来（设置成私有的）
1 # 其实这仅仅这是一种变形操作 2 # 类中所有双下划线开头的名称如__x都会自动变形成：_类名__x的形式： 3 4 class A: 5 6 __x = 1 # _A__x = 1 # 类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N 7 8 def __init__(self, name): 9 self.__X = 10 # 变形为self._A__X 10 self.name = name # self._A__name = name 11 12 def __foo(self): # def _A__foo(self): 13 print(‘from _foo‘) 14 15 def bar(self): 16 self.__foo() # self._A__foo() # 只有在类内部才可以通过__foo的形式访问到,在类定义的时候，就已经形成了这种格式了 17 print(‘from bar‘) 18 19 a = A(‘egon‘) 20 21 print(a.__dict__) 22 print(A.__dict__) 23 print(a.bar()) 24 # A._A__N是可以访问到的，即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形 25 26 """ 27 执行结果 28 {‘_A__X‘: 10, ‘name‘: ‘egon‘} 29 {‘__module__‘: ‘__main__‘, ‘_A__x‘: 1, ‘__init__‘: <function A.__init__ at 0x02C1A390>, <br>‘_A__foo‘: <function A.__foo at 0x02C1A3D8>, ‘bar‘: <function A.bar at 0x02C1A420>, <br>‘__dict__‘: <attribute ‘__dict__‘ of ‘A‘ objects>, <br>‘__weakref__‘: <attribute ‘__weakref__‘ of ‘A‘ objects>, ‘__doc__‘: None} 30 from _foo 31 from bar 32 None 33 """
1，在类外部无法直接 obj.__AttrName
2，在类内部是可以直接使用： obj.__AttrName
3，子类无法覆盖父类__开头的属性
1 # 子类无法覆盖父类__开头的属性。 2 class Foo: 3 def __func(self): # _Foo__func 4 print(‘from foo‘) 5 6 class Bar(Foo): 7 def __func(self): # _Bar__func # 子类定义的和父类定义的表面上看起来一样，但是却实质上不一样，根本就不是一个名字 8 print(‘from bar‘)
1、这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如a._A__N
2、变形的过程只在类的定义时发生一次，在定义后的赋值操作，不会变形
1 class B: 2 def __init__(self, name): 3 self.__name = name 4 b = B(‘egon‘) 5 print(b.__dict__) 6 b.__age = 18 7 print(b.__dict__)<br>print(b.__age) 8 9 ### 10 {‘_B__name‘: ‘qiuma‘} 11 {‘_B__name‘: ‘qiuma‘, ‘__age‘: 18}<br>18
3、在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的
1 # 正常情况 2 class A: 3 def foo(self): 4 print(‘A.foo‘) 5 def bar(self): 6 print(‘A.bar‘) 7 self.foo() # b.foo()，访问顺序，先访问自己，然后类，再到父类。self.foo()，父类中存在，先访问父类里面的 8 9 class B(A): 10 def foo(self): 11 print(‘B.foo‘) 12 13 b = B() 14 b.bar() 15 16 ### 17 A.bar 18 B.foo 19 20 # 定义私有，通过这种方法，调用只能访问类本身里面的变量 21 class A: 22 def __foo(self): # _A__foo,看上去和子类的__foo长得一样，实则在定义的时候，名称就已经发生了改变了 23 print(‘A.foo‘) 24 def bar(self): 25 print(‘A.bar‘) 26 self.__foo() # self._A__foo() 27 28 class B(A): 29 def __foo(self): # _B__foo 30 print(‘B.foo‘) 31 32 b = B() 33 b.bar() 34 35 ### 36 A.bar 37 A.foo
1 # 封装数据属性：明确的区分内外,控制外部对隐藏属性的操作。 2 class People: 3 def __init__(self, name, age): 4 self.__name = name 5 self.__age = age 6 def tell_info(self): 7 print(‘Name:%s Age:%s‘ % (self.__name, self.__age)) 8 def set_info(self, name, age): 9 if not isinstance(name, str): # isinstance 什么必须是什么的实例，这里name必须是str 10 print(‘名字必须是字符串类型‘) 11 return 12 if not isinstance(age, int): 13 print(‘年龄必须是整数类型‘) 14 return 15 self.__name = name 16 self.__age = age 17 18 19 p = People(‘xiong‘, 18) 20 print(p._People__name) # 硬要访问 21 p.tell_info() 22 p.set_info(‘xiong‘, 17) 23 p.tell_info() 24 25 ### 26 xiong 27 Name:xiong Age:18 28 Name:xiong Age:17
1 # 封装方法：隔离复杂度 2 # 取款是功能,而这个功能有很多功能组成:插卡、密码认证、输入金额、打印账单、取钱 3 # 对使用者来说,只需要知道取款这个功能即可,其余功能我们都可以隐藏起来,很明显这么做 4 # 隔离了复杂度,同时也提升了安全性 5 6 class ATM: 7 def __card(self): 8 print(‘插卡‘) 9 def __auth(self): 10 print(‘用户认证‘) 11 def __input(self): 12 print(‘输入取款金额‘) 13 def __print_bill(self): 14 print(‘打印账单‘) 15 def __take_money(self): 16 print(‘取款‘) 17 18 def withdraw(self): 19 self.__card() 20 self.__auth() 21 self.__input() 22 self.__print_bill() 23 self.__take_money() 24 25 a = ATM() 26 a.withdraw()
封装方法的其他举例：
提示：在编程语言里，对外提供的接口（接口可理解为了一个入口），可以是函数，称为接口函数，这与接口的概念还不一样，接口代表一组接口函数的集合体。
封装在于明确区分内外，使得类实现者可以修改封装内的东西而不影响外部调用者的代码；而外部使用用者只知道一个接口(函数)，只要接口（函数）名、参数不变，使用者的代码永远无需改变。这就提供一个良好的合作基础——或者说，只要接口这个基础约定不变，则代码改变不足为虑
1 class Room: 2 def __init__(self, name, owner, weight, length): 3 self.name = name 4 self.owner = owner 5 6 self.__length = length 7 self.__weight = weight 8 def tell_area(self): 9 return self.__weight * self.__length 10 def room_type(self): 11 12 print("%s lives in the %s, the squre is %s" % (self.owner, self.name, self.tell_area())) 13 14 r = Room(‘豪华公寓‘, ‘qiuma‘, 50, 50) 15 print(r.tell_area()) 16 print(r.room_type())
什么是特性property
property是一种特殊的属性，访问它时会执行一段功能（函数）然后返回值
例一：
BMI指数（bmi是计算而来的，但很明显它听起来像是一个属性而非方法，如果我们将其做成一个属性，更便于理解）
成人的BMI数值：
过轻：低于18.5
正常：18.5-23.9
过重：24-27
肥胖：28-32
非常肥胖, 高于32
体质指数（BMI）=体重（kg）÷身高^2（m）
EX：70kg÷（1.75×1.75）=22.86
1 # 方式一： 2 class People: 3 def __init__(self, name, weight, height): 4 self.name = name 5 self.weight = weight 6 self.height = height 7 8 p = People(‘xiong‘,70,1.75) 9 p.bmi = p.weight/(p.height ** 2) 10 print(p.bmi) 11 12 # 方式二：通过函数，有括号，容易给使用者造成误解 13 class People: 14 def __init__(self, name, weight, height): 15 self.name = name 16 self.weight = weight 17 self.height = height 18 def bmi(self): 19 return self.weight / (self.height**2) 20 21 p1 = People(‘xiong‘,70,1.75) 22 print(p1.bmi())
1 # 方式三：使用property装饰器特性实现功能 2 # 实现统一访问，将方法伪装起来，bmi不能赋值(报错)，且只能return返回。 3 class People: 4 def __init__(self, name, weight, height): 5 self.name = name 6 self.weight = weight 7 self.height = height 8 @property 9 def bmi(self): 10 return self.weight / (self.height**2) 11 12 p1 = People(‘qiuma‘,75,1.8) 13 print(p1.bmi) 14 # p1.bmi = 1 # AttributeError: can‘t set attribute
例二：
将一个要通过计算的属性，封装成一个用户访问就像访问一个数据属性就可以的类型，伪装成一个更简单的方法，方便用户使用
class People: def __init__(self, name): self.__name = name def get_name(self): return self.__name p = People(‘xiong‘) print(p.get_name()) ### xiong
通过property进行封装:
1 class People: 2 def __init__(self, name): 3 self.__name = name 4 @property # 访问，查看，将一个要通过计算的属性，封装成一个用户访问就像访问一个数据属性就可以了，伪装 5 def name(self): 6 return self.__name 7 @name.setter # 修改 8 def name(self, val): 9 if not isinstance(val, str): 10 print(‘名字必须是字符串类型‘) 11 return 12 self.__name = val 13 14 @name.deleter # 删除 15 def name(self): 16 print("deleter") 17 print(‘不允许删除‘) 18 p = People(‘qiuma‘) 19 print(p.name) # 访问行为 20 21 p.name = ‘Qiuma‘ # 修改行为 22 print(p.name) 23 24 del p.name 25 26 ### 27 qiuma 28 Qiuma 29 deleter 30 不允许删除
1 class People: 2 def __init__(self, name): 3 self.__name = name 4 @property # 访问，查看，将一个要通过计算的属性，封装成一个用户访问就像访问一个数据属性就可以了，伪装 5 def name(self): 6 return self.__name 7 @name.setter # 修改 8 def name(self, val): 9 if not isinstance(val, str): 10 print(‘名字必须是字符串类型‘) 11 return 12 self.__name = val 13 14 @name.deleter # 删除 15 def name(self): 16 print("deleter") 17 print(‘不允许删除‘) 18 p = People(‘xiong‘) 19 print(p.name) # 访问行为 20 21 p.name = ‘XIONG‘ # 修改行为 22 print(p.name) 23 24 del p.name 25 26 ### 27 xiong28 XIONG29 deleter 30 不允许删除
为什么要用property
将一个类的函数定义成特性以后，对象再去使用的时候obj.name,根本无法察觉自己的name是执行了一个函数然后计算出来的，这种特性的使用方式遵循了统一访问的原则，不需要添加多余的括号什么的，直接访问就可以了。
1 class Foo: 2 def __init__(self, name): 3 self.name = name 4 def tell(self): # 绑定对象的方法 5 print(‘名字是 %s ‘% self.name) 6 7 @classmethod # 绑定到类的方法，绑定给谁，就应该由谁来调用，谁调用，就把谁当第一个参数传入 8 def func(cls): # cls = Foo 9 print(cls) 10 11 @staticmethod # 非绑定方法，就是一个普通的函数，谁都能用，无自动传进 12 def func1(x, y): 13 print(x + y) 14 15 f = Foo(‘xiong‘) 16 print(Foo.tell) 17 print(f.tell) 18 19 f.tell() 20 21 Foo.func() 22 print(Foo) 23 24 print(Foo.func1) # 这里证明Foo.func1和f.func1都是普通函数 25 print(f.func1) 26 print(Foo.func1(3, 4)) 27 print(f.func1(3, 4)) 28 29 ### 30 <function Foo.tell at 0x03679420> 31 <bound method Foo.tell of <__main__.Foo object at 0x036FC910>> 32 名字是 xiong 33 <class ‘__main__.Foo‘> 34 <class ‘__main__.Foo‘> 35 <function Foo.func1 at 0x036794B0> 36 <function Foo.func1 at 0x036794B0> 37 7 38 None 39 7 40 None
一：绑定方法（绑定给谁，谁来调用就自动将它本身当作第一个参数传入）：
1，绑定到类的方法：用classmethod装饰器装饰的方法。
为类量身定制
类.boud_method(),自动将类当作第一个参数传入
（其实对象也可调用，但仍将类当作第一个参数传入）2，绑定到对象的方法：没有被任何装饰器装饰的方法。
为对象量身定制
对象.boud_method(),自动将对象当作第一个参数传入
（属于类的函数，类可以调用，但是必须按照函数的规则来，没有自动传值那么一说）二：非绑定方法：用 staticmethod 装饰器装饰的方法，实际上就是一个普通函数
不与类或对象绑定，类和对象都可以调用，但是没有自动传值那么一说。就是一个普通工具而已，对象和类都可以使用
注意：与绑定到对象方法区分开，在类中直接定义的函数，没有被任何装饰器装饰的，都是绑定到对象的方法，可不是普通函数，对象调用该方法会自动传值，而staticmethod装饰的方法，不管谁来调用，都没有自动传值一说
1 import hashlib 2 import time 3 import settings 4 5 class People: 6 def __init__(self, name, age, sex): 7 8 self.name = name 9 self.age = age 10 self.sex = sex 11 12 def tell_info(self): # 绑定到对象的方法 13 print(‘Name:%s Age:%s Sex:%s‘ % (self.name, self.age, self.sex)) 14 15 @classmethod # 绑定到类的方法 16 def from_conf(cls): 17 obj = cls( 18 settings.name, 19 settings.age, 20 settings.sex 21 ) 22 return obj 23 24 p = People(‘qiuma‘, 18, ‘male‘) 25 26 # 绑定给对象，就应该由对象来调用，自动将对象本身当做第一个参数传入 27 # People.tell_info(p) 28 p.tell_info() 29 30 # 绑定到类，就应该有类来调用,自动将类本身当做第一个参数传入 31 p = People.from_conf() # from_conf(People) # 从配置文件里面读取配置进行实例化 32 # 等价于 p = People(‘qiumawu‘, 19, ‘female‘) 33 34 p.tell_info() 35 36 37 # name = ‘xionghao‘ 38 # age = 19 39 # sex = ‘female‘ 40 41 ### 42 Name:xiong Age:18 Sex:male 43 Name:xionghao Age:19 Sex:female
1 import hashlib 2 import time 3 import settings 4 5 class People: 6 def __init__(self, name, age, gender): 7 self.name = name 8 self.age = age 9 self.gender = gender 10 11 self.id = self.create_id() 12 13 def tell_info(self): # 绑定到对象的方法 14 print(‘Name:%s Age:%s Gender:%s‘ % (self.name, self.age, self.gender)) 15 16 @classmethod 17 def from_conf(cls): 18 obj = cls( 19 settings.name, 20 settings.age, 21 settings.gender 22 ) 23 return obj 24 25 @staticmethod 26 def create_id(): 27 m = hashlib.md5() 28 m.update(str(time.time()).encode(‘utf-8‘)) 29 return m.hexdigest() 30 31 32 p = People(‘xiong‘, 18, ‘男‘) 33 p1 = People(‘xiongh‘, 19, ‘男‘) 34 p2 = People(‘xionghao‘, 20, ‘男‘) 35 36 # 非绑定方法，不与类或对象绑定，谁都可以调用，没有自动传值一说 37 print(p.id,‘111‘) 38 print(p1.id,‘2221‘) 39 print(p2.id,‘331‘) 40 41 ### 42 7871d235ee8ea3e25f16178004e00eb3 111 43 7871d235ee8ea3e25f16178004e00eb3 2221 44 7871d235ee8ea3e25f16178004e00eb3 331 45 7871d235ee8ea3e25f16178004e00eb3 111 46 4e16523b5ec7f189d45d1b9cda5da01e 2221 47 4e16523b5ec7f189d45d1b9cda5da01e 331
以下代码可以说明没有反射不具备的功能。
1 class People: 2 def __init__(self, name, age): 3 self.name = name 4 self.age = age 5 6 def talk(self): 7 print(‘%s is talking‘ % self.name) 8 9 obj = People(‘xiong‘, 18) 10 11 print(obj.name) # 本质obj.__dict__[‘name‘] # 访问数据属性,点后面是一个属性，而不是字符串 12 print(obj.talk) # 访问绑定方法 13 14 ### 15 xiong 16 <bound method People.talk of <__main__.People object at 0x0117EE70>>
注意：
不能直接调用input里面的内容，它仅仅只是一个字符串
choice = input(‘>>>: ‘) # choice = ‘name‘ # 这个name仅仅只是一个字符串
print(obj.choice) # print(obj.‘name‘) # 后面要是一个属性名，不能为字符串
需要解决的问题：
能够让用户通过字符串去映射到对象的一个属性身上，所以我们学习python的解决方式
四个可以实现自省的函数 下列方法适用于类和对象（一切皆对象，类本身也是一个对象）
第一个参数为对象，第二个参数是字符串hasattr(o, name:str)
判断object中有没有一个name字符串对应的方法或属性
得到对象的属性
修改对象的属性
删除对象的属性
1 class People: 2 def __init__(self, name, age): 3 self.name = name 4 self.age = age 5 6 def talk(self): 7 print(‘%s is talking‘ % self.name) 8 9 obj = People(‘xiong‘, 18) 10 11 print(obj.name) # 本质obj.__dict__[‘name‘] # 访问数据属性,点后面是一个属性，而不是字符串 12 print(obj.talk) # 访问绑定方法 13 14 15 # 查 16 print(hasattr(obj, ‘name‘)) # obj.name # 实质 obj.__dict__ [‘name‘] 17 print(hasattr(obj, ‘talk‘)) 18 19 # 取得 20 print(getattr(obj, ‘name‘, None)) # 得到对象的属性 21 print(getattr(obj, ‘talk‘, None)) # 得到方法的属性 22 23 # 修改 24 setattr(obj, ‘sex‘, ‘male‘) # 本质：obj.sex = ‘male‘ 25 print(obj.sex) 26 27 # 删除 28 delattr(obj, ‘age‘) # del obj.age 29 print(obj.__dict__) 30 31 ### 32 xiong 33 <bound method People.talk of <__main__.People object at 0x00F2DD30>> 34 True 35 True 36 qiuma 37 <bound method People.talk of <__main__.People object at 0x00F2DD30>> 38 male 39 {‘name‘: ‘xiong‘, ‘sex‘: ‘male‘}
1 # 反射的应用 2 class Service: 3 def run(self): 4 while True: 5 inp = input(‘>>>: ‘).strip() # get a.txt 6 cmds = inp.split() # cmds = [‘get‘, ‘a.txt‘] 7 8 # print(cmds) 9 if hasattr(self, cmds[0]): 10 func = getattr(self, cmds[0]) 11 func(cmds) 12 13 def get(self, cmds): 14 print(‘get..............‘, cmds) 15 16 def put(self, cmds): 17 print(‘put..............‘, cmds) 18 19 20 obj = Service() 21 obj.run() 22 23 ###输入get a.txt或者put a.txt 24 >>>: get a.txt 25 get.............. [‘get‘, ‘a.txt‘] 26 >>>: put a.txt 27 put.............. [‘put‘, ‘a.txt‘]
isinstance(obj,cls)检查是否obj是否是类 cls 的对象或实例
1 # isinstance 2 class Foo(object): 3 pass 4 obj = Foo() 5 print(isinstance(obj, Foo)) 6 7 ### 8 True
检查sub类是否是 super 类的派生类（子类是不是父类的儿子）
1 # issubclass 2 class Foo(object): 3 pass 4 class Bar(Foo): 5 pass 6 print(issubclass(Bar, Foo)) 7 8 ### 9 True
item系列，把对象做成像字典一样的东西，然后像字典一样去操作
1 # item系列,把对象做成像字典一样的东西，然后像字典一样去操作 2 class Foo: # 将Foo模拟成Dict系列 3 def __init__(self, name): 4 self.name = name 5 def __getitem__(self, item): # item = ‘name‘ 6 return self.__dict__.get(item) # 这里使用self.__dict__[item]，如果找不到这个key，就会报错。 7 8 def __setitem__(self, key, value): 9 print(‘setitem...‘) 10 print(key, value) 11 self.__dict__[key] = value 12 13 def __delitem__(self, key): 14 print(‘delitem...‘) 15 print(key) 16 del self.__dict__[key] 17 18 obj = Foo(‘qiuma‘) 19 20 # 查看属性 21 # obj.属性名 # 一般或许对象属性的方法 22 print(obj[‘name‘]) # 完成obj.name的取值效果 23 24 # 设置属性 25 # obj.sex = ‘male‘ 26 obj[‘sex‘] = ‘male‘ 27 # print(obj.__dict__) 28 # print(obj.sex) 29 30 # 删除属性 31 # del obj.name 32 del obj[‘name‘] 33 print(obj.__dict__) 34 35 ### 36 qiuma 37 setitem... 38 sex male 39 delitem... 40 name 41 {‘sex‘: ‘male‘}
改变对象的字符串显示__str__,__repr__
自定制格式化字符串__format__
__str__方法定义完以后，会在打印对象的时候触发对象下面的__str__方法，将返回的结果（字符串）作为打印的结果，达到返回的不是说明obj是一个对象，而是得到更多有用的信息。
1 d = dict({‘name‘: ‘qiuma‘}) # 本质是调dict这个类，然后将参数传进来进行实例化 2 print(isinstance(d, dict)) # dict就是d的一个对象 3 # 数据类型就是类 4 print(d) 5 6 class People(): 7 def __init__(self, name, age): 8 self.name = name 9 self.age = age 10 obj = People 11 print(obj) 12 # 上面两个print，python自带的类专门定制了打印的效果，打印出来的更加有用 13 # 为People类定制一个方法，在print对象的时候自动触发对象的一个绑定方法，来返回有用的信息。<br><br> 14 class People(): 15 def __init__(self, name, age): 16 self.name = name 17 self.age = age 18 19 def __str__(self): 20 print(‘===>str‘) 21 return ‘<name:%s,age:%s>‘ % (self.name, self.age) # 打印obj直接触发__str__，并且打印返回值 22 23 obj = People(‘qiuma‘, 18) 24 print(obj) # 触发并打印 obj.__str__() 25 26 ### 27 True 28 {‘name‘: ‘qiuma‘} 29 <class ‘__main__.People‘> 30 ===>str 31 <name:qiuma,age:18>
析构方法，当对象在内存中被释放时，自动触发执行。
注：如果产生的对象仅仅只是python程序级别的（用户级），那么无需定义__del__,如果产生的对象的同时还会向操作系统发起系统调用，即一个对象有用户级与内核级两种资源，比如（打开一个文件，创建一个数据库链接），则必须在清除对象的同时回收系统资源，这就用到了__del__
来比较下下面两个程序的运行顺序
1 # 程序1 2 class Foo: 3 4 def __del__(self): 5 print(‘执行我啦‘) 6 7 f1=Foo() 8 del f1 9 print(‘------->‘) 10 11 #输出结果 12 执行我啦 13 -------> 14 15 # 程序2 16 class Foo: 17 18 def __del__(self): 19 print(‘执行我啦‘) 20 21 f1=Foo() 22 # del f1 23 print(‘------->‘) 24 25 #输出结果 26 -------> 27 执行我啦 28 29 30 # 对比这两个程序的执行顺序，可以发现如果未执行程序del f1，则对象中的__del__是在最后执行的，这就是因为若没有手动执行del f1，方法__del__会自动帮你在程序结束的时候自动回收空间，而del f1则是自己手动执行空间的回收
典型的应用场景：
创建数据库类，用该类实例化出数据库链接对象，对象本身是存放于用户空间内存中，而链接则是由操作系统管理的，存放于内核空间内存中
当程序结束时，python只会回收自己的内存空间，即用户态内存，而操作系统的资源则没有被回收，这就需要我们定制__del__，在对象被删除前向操作系统发起关闭数据库链接的系统调用，回收资源
这与文件处理是一个道理：
1 # __del__ 2 f = open(‘settings.py‘) # 做了两件事，在用户空间拿到一个f变量，在操作系统内核空间打开一个文件 3 del f # 只回收用户空间的f，操作系统的文件还处于打开状态 4 5 # 所以我们应该在del f之前保证f.close()执行,即便是没有del，程序执行完毕也会自动del清理资源，于是文件操作的正确用法应该是 6 f = open(‘settings.py‘) 7 # 读写... 8 f.close() # 回收操作系统的资源 9 # 很多情况下大家都容易忽略f.close,这就用到了with上下文管理 10 11 12 # 模拟打开文件操作过程 13 class Open: 14 def __init__(self, filename): 15 print(‘open file...‘) 16 self.filename = filename 17 18 def __del__(self): # 在对象被删除的时候会先自动触发这个方法的执行，再把对象删掉 19 # 这里还可以写跟资源回收相关的操作 20 print(‘回收操作系统的资源，类似于self.close()操作‘) 21 22 f = Open(‘settings.py‘) 23 # del f # 手动回收 24 print(‘-------end--------‘) # 触发了 del f # f.__del__()
1 # 储备知识 exec 2 # 参数1：字符串形式的命令 3 # 参数2：全局作用域(字典形式)，如果不指定默认就使用globals() 4 # 参数3：局部作用域(字典形式)，如果不指定默认就使用locals() 5 # 可以把exec命令的执行当成是一个函数的执行，会将执行期间产生的名字存放于局部名称空间中 6 7 g = { 8 ‘x‘: 1, 9 ‘y‘: 2 10 } 11 l = {} 12 exec(""" 13 global x,m 14 x = 10 15 m = 100 16 17 z = 3 18 """, g, l) 19 print(g) 20 print(l)
python中一切皆对象，对象可以怎么用？
1，都可以被引用，赋值给一个变量，x = obj
2，都可以当作函数的参数传入
3，都可以当作函数的返回值
4，都可以当作容器类的元素，l = [func, time, obj, l]
# 类也是对象
1 class Foo: 2 pass 3 obj = Foo() 4 print(type(obj)) 5 print(type(Foo))<br><br>###<br><class ‘__main__.Foo‘><br><class ‘type‘>
所有的对象都是实例化或者说调用类而得到的（调用类的过程称为类的实例化），比如对象obj是调用类Foo得到的，如果一切皆为对象，那么类Foo本质也是一个对象，既然所有的对象都是调用类得到的，那么Foo必然也是调用了一个类得到的，这个类称为元类。
产生类的类称之为元类，默认所有用class定义的类，他们的元类就是type。
元类type ===实例化===> 类Foo ===实例化===> 对象obj
1 # 方式一：class关键字 2 class Chinese: # Cinese = type(...) 3 country = ‘China‘ 4 def __init__(self,name, age): 5 self.name = name 6 self.age = age 7 8 def talk(self): 9 print(‘%s is talking ‘ % self.name) 10 # print(Chinese) 11 obj = Chinese(‘qiuma‘,18) 12 print(obj, obj.name, obj.age) 13 14 ### 15 <__main__.Chinese object at 0x0150C490> qiuma 18
就是手动模拟class创建类的过程：将创建类的步骤拆分开，手动去创建
定义类的三要素
类名 class_name = ‘Chinese‘
基类们class_bases = (object, )
类的名称空间class_dic，类的名称空间是执行类体代码而得到的
调用type时会依次传入以上三个参数++++
1 #准备工作： 2 3 #创建类主要分为三部分 4 1 类名 5 2 类的父类 6 3 类体 7 8 #类名 9 class_name=‘Chinese‘ 10 11 #类的父类 12 class_bases=(object,) 13 14 #类体 15 class_body=""" 16 country=‘China‘ 17 def __init__(self,name,age): 18 self.name=name 19 self.age=age 20 def talk(self): 21 print(‘%s is talking‘ %self.name) 22 """
# A没有继承B,但是A内super会基于C.mro()继续往后找class A: def f1(self): print(‘from A‘) super().f1()class B: def f1(self): print(‘from B‘)class C(A,B): passprint(C.mro())c = C()c.f1() # 打印结果:from B"""[<class ‘__main__.C‘>, <class ‘__main__.A‘>, <class ‘__main__.B‘>, <class ‘object‘>]from Afrom B"""标签：等等 OAO x11 mod demo upd conf strong asa
原文地址：https://www.cnblogs.com/herosyuan/p/10068450.html
