面向对象之类和对象面向过程和面向对象面向过程编程Procedural Programming和面向对象编程OOP是两种不同的编程范式Python是一种混合型的语言既支持面向过程的编程也支持面向对象的编程。面向过程的编程是一种以过程为中心的编程方式主要关注解决问题的步骤并将这些步骤写成函数或方法。面向对象的编程是一种以对象为中心的编程方式主要关注在解决问题的过程中涉及哪些对象以及这些对象如何交互类和对象类Class类描述了所创建的对象共同的属性是什么和方法能做什么属性和方法统称为类的成员。类是对大量对象共性的抽象类是创建对象的模板类是客观事物在人脑中的主观反映对象Object在自然界中只要是客观存在的事物都是对象类是抽象的对象是类的实例Instance是具体的。一个对象有自己的状态属性、行为方法和唯一的标识本质上指内存中所创建的对象的地址。定义类语法class 类名: 类说明文档 类体类名一般使用大驼峰命名法。类体中可以包含类属性也叫类变量、方法、实例属性也叫实例变量等。案例定义一个人的类包含__init__()方法、eat()方法和drink()方法。class Person: 人的类 home earth def __init__(self): self.age 0 def eat(self): print(eating...) def drink(self): print(drinking...)类的操作类支持两种操作成员引用和实例化。成员引用语法类名.成员名案例class Person: 人的类 home earth def __init__(self): self.age 0 def eat(self): print(eating...) def drink(self): print(drinking...) home Person.home # 获取一个字符串 eat_function Person.eat # 获取一个函数对象 doc Person.__doc__ # 获取类的说明文档 print(home) # earth print(eat_function) # function Person.eat at 0x00000232C8230F40 print(doc) # 人的类实例化语法变量名 类名()案例class Person: 人的类 home earth def __init__(self): self.age 0 def eat(self): print(eating...) def drink(self): print(drinking...) p Person() # 创建一个对象 print(p.home) # earth print(p.age) # 0 p.eat() # eating... p.drink() # drinking...__init()__方法__init__() 是一个特殊的方法也被称作构造函数。__init__() 方法的主要作用是在创建类的对象时对对象的属性进行初始化。当你使用类名创建一个新的对象时Python 会自动调用 __init__() 方法并将新创建的对象作为第一个参数通常命名为 self传递给它。注意self这是一个约定俗成的参数名它代表类的实例对象本身。在方法内部通过 self 可以访问和修改对象的属性。__init__() 方法不是必需的。如果类中没有定义 __init__() 方法Python 会使用默认的构造函数该构造函数不执行任何操作。__init__() 方法只能返回 None不能返回其他值。如果尝试返回其他值会引发 TypeError 异常class Person: 人的类 home earth def __init__(self, name): self.name name p Person(张三) # 创建一个对象 print(p.name) # 张三selfself作为实例传参self代表类的实例自身。调用实例方法时实例对象会作为第一个参数被传入。因此我们调用p.eat()时就相当于调用了Person.eat(p)。class Person: 人的类 home earth def __init__(self, name): self.name name def eat(self): print(eating...) def drink(self): print(drinking...) p Person(张三) # 创建一个对象 p.eat() # eating... Person.eat(p) # eating...通过self在类中调用类的实例属性和实例方法class Person: 人的类 home earth def __init__(self, name): self.name name def eat(self): print(eating...) def drink(self): print(drinking...) def eat_and_drink(self): print(self.name) # 在类中调用name self.eat() # 在类中调用eat()方法 self.drink() # 在类中调用drink()方法 p Person(张三) # 创建一个对象 p.eat_and_drink()属性类属性也叫类变量。在类中方法外定义的属性。通过类名.属性名或实例名.属性名访问class Person: 人的类 home earth # 定义类属性 print(Person.home) # 通过类名访问类属性 p1 Person() # 创建一个实例对象 print(p1.home) # 通过实例名访问类属性(如果实例没有覆盖这个类属性的值)通过类名.属性名添加与修改类属性class Person: 人的类 Person.home earth # 添加类属性 print(Person.home) # earth Person.home mars # 修改类属性 print(Person.home) # mars若使用实例名.属性名则会创建或修改实例属性因此不建议类属性和实例属性同名。class Person: 人的类 home earth p1 Person() p2 Person() print(Person.home) # earth print(p1.home) # earth print(p2.home) # earth print(通过 类名.属性名 修改 类属性) Person.home mars print(Person.home) # mars print(p1.home) # mars print(p2.home) # mars print(通过 实例名.属性名 会创建 实例属性) p1.home venus print(Person.home) # mars print(p1.home) # venus print(p2.home) # mars所有该类的实例共享同一个类属性class Person: 人的类 home earth # 定义类属性所有实例共享 p1 Person() # 创建一个实例对象 p2 Person() # 创建另一个实例对象 print(p1.home) # earth print(p2.home) # earth Person.home mars # 修改类属性 print(p1.home) # mars print(p2.home) # mars实例属性也叫实例变量。在类__init__方法中定义的属性。通过self.属性名定义。通过实例名.属性名访问class Person: 人的类 def __init__(self, name, age): self.name name # 定义实例属性 self.age age # 定义实例属性 p1 Person(张三, 18) # 创建一个实例对象 print(p1.name, p1.age) # 张三 18 p2 Person(李四, 81) # 创建一个实例对象 print(p2.name, p2.age) # 李四 81 print(Person.name) # 报错通过实例名.属性名添加与修改实例属性class Person: 人的类 pass p1 Person() # 创建一个实例对象 p1.name 张三 # 添加实例属性 p1.age 18 # 添加实例属性 print(p1.name, p1.age) # 张三 18 p1.age 25 # 修改实例属性 print(p1.name, p1.age) # 张三 25每个实例独有一份实例属性class Person: 人的类 def __init__(self, name): self.name name # 定义实例属性 self.age 0 # 定义实例属性 p1 Person(张三) # 创建一个实例对象 print(p1.name, p1.age) # 张三 0 p1.age 18 # 修改p1的age属性 print(p1.name, p1.age) # 张三 18 p2 Person(李四) # 创建另一个实例对象 print(p2.name, p2.age) # 李四 0方法Python的类中有三种方法实例方法、静态方法、类方法。实例方法实例方法在类中定义第一个参数为self代表实例本身。实例方法只能被实例对象调用。可以访问实例属性、类属性、类方法。class Person: 人的类 home earth def __init__(self, name): self.name name def instance_method(self): print(self.name, self.home, Person.home) p Person(张三) p.instance_method() # 张三 earth earth此时p中没有home实例属性会去查找home类属性 Person.home venus # 修改类属性 p.home mars # 定义实例属性 p.instance_method() # 张三 mars venus类方法类方法在类中通过classmethod定义第一个参数为cls代表类本身。类方法可以被类和实例对象调用。可以访问类属性。在不创建实例的情况下调用通过类名直接调用非常方便适合一些和类整体相关的操作。class Person: 人的类 home earth # 定义类属性 classmethod def class_method(cls): print(cls.home) Person.class_method() # 通过类调用类方法 p1 Person() # 创建一个实例对象 p1.class_method() # 通过实例对象调用类方法静态方法静态方法在类中通过staticmethod定义不访问实例属性或类属性只依赖于传入的参数可以通过类名或实例调用但它不会访问类或实例的内部信息更像是一个工具函数只是为了方便组织代码把它放在了类里面。class Person: 人的类 home earth # 定义类属性 staticmethod def static_method(): print(static method) Person.static_method() # 通过类调用静态方法 p1 Person() # 创建一个实例对象 p1.static_method() # 通过实例对象调用静态方法在类外定义方法并非必须在类定义中进行方法定义也可以将一个函数对象赋值给一个类内局部变量。# 在类外定义的函数 def f1(self, x, y): print(x y) class C: f f1 C().f(6, 13) # 4特殊方法-魔法方法方法名中有两个前缀下划线和两个后缀下划线的方法为特殊方法也叫魔法方法。上文提到的__init__()就是一个特殊方法。这些方法会在进行特定的操作时自动被调用。几个常见的特殊方法__new__()对象实例化时第一个调用的方法。__init__()类的初始化方法。__del__()对象的销毁器定义了当对象被垃圾回收时的行为。使用del xxx时不会主动调用__del__()除非此时引用计数0。__str__()定义了对类的实例调用str()时的行为。__repr__()定义对类的实例调用repr()时的行为。str()和repr()最主要的差别在于目标用户。repr()的作用是产生机器可读的输出大部分情况下其输出可以作为有效的Python代码而str()则产生人类可读的输出。__getattribute__()属性访问拦截器定义了属性被访问前的操作。动态添加属性与方法动态给对象添加属性class Person: def __init__(self, nameNone): self.name name p Person(张三) print(p.name) # 张三 p.age 18 print(p.age) # 18动态给类添加属性class Person: def __init__(self, nameNone): self.name name p Person(张三) print(p.name) # 张三 Person.age 0 print(p.age) # 0动态给实例添加方法添加普通方法class Person: def __init__(self, nameNone): self.name name def eat(): print(吃饭) p Person(张三) p.eat eat p.eat() # 吃饭添加实例方法给对象添加的实例方法只绑定在当前对象上不对其他对象生效而且需要传入 self 参数。需要使用 types.MethodType(方法名实例对象) 来添加实例方法。import types class Person: def __init__(self, nameNone): self.name name def eat(self): print(f{self.name}在吃饭) p Person(张三) p.eat types.MethodType(eat, p) p.eat() # 张三在吃饭动态给类添加方法给类添加的方法对它的所有对象都生效添加类方法需要传入 cls 参数添加静态方法则不需要。class Person: home earth def __init__(self, nameNone): self.name name # 定义类方法 classmethod def come_from(cls): print(f来自{cls.home}) # 定义静态方法 staticmethod def static_function(): print(static function) Person.come_from come_from Person.come_from() # 来自earth Person.static_function static_function Person.static_function() # static function动态删除属性与方法del对象.属性名delattr(对象属性名)__slots__限制实例属性与实例方法Python允许在定义类的时候定义一个特殊的__slots__变量来限制该类的实例能添加的属性。使用__slots__可以限制添加实例属性和实例方法但类属性、类方法和静态方法还可以添加。__slots__仅对当前类生效对其子类无效。import types class Person: __slots__ (name, age, eat) def __init__(self, nameNone): self.name name def eat(self): print(f{self.name}在吃饭) def drink(self): print(f{self.name}在喝水) p Person(张三) # 添加实例属性 p.age 10 print(p.age) # 10 # 添加实例方法 p.eat types.MethodType(eat, p) p.eat() # 张三在吃饭 # 添加实例属性 p.weight 100 # AttributeError: Person object has no attribute weight # 添加实例方法 p.drink types.MethodType(drink, p) # AttributeError: Person object has no attribute drink面向对象之三大特性封装将变量和函数写入类中的操作即为封装即类中封装了属性和方法。私有化有时为了限制属性和方法只能在类内访问外部无法访问或父类中某些属性和方法不希望被子类继承。可以将其私有化。单下划线非公开API大多数Python代码都遵循这样一个约定有一个前缀下划线的变量或方法应被视为非公开的API例如_var1。这种约定不具有强制力。双下划线名称改写有两个前缀下划线并至多一个后缀下划线的标识符例如__x会被改写为_类名__x。只有在类内部可以通过__x访问其他地方无法访问或只能通过_类名__x访问。私有属性通过双下划线定义私有属性。class Person: def __init__(self, name): self.__name name def get_name(self): return self.__name p Person(张三) print(p.get_name()) # 张三 print(p._Person__name) # 张三 实际真实的改写后的名称 print(p.__name) # 报错私有方法通过双下划线定义私有方法。class Person: # 定义私有方法 def __private_method(self): print(private method) # 定义实例方法调用私有方法 def do_something(self): self.__private_method() p Person() p.do_something() # private method p._Person__private_method() # private method p.__private_method() # 报错property-方法转换为属性可通过property装饰器将一个方法转换为属性来调用。转换后可直接使用.方法名来使用而无需使用.方法名() 。class Person: def __init__(self, name): self.name name property def eat(self): print(f{self.name} is eating...) p Person(张三) p.eat # 张三 is eating...只读属性将方法名设置为去掉双下划线的私有属性名方法中返回私有属性。class Person: def __init__(self, name): self.__name name property def name(self): return self.__name p Person(张三) print(p.name) # 张三 p.name 李四 # 报错setter读写属性将方法名设置为去掉双下划线的私有属性名使用属性名.setter装饰。class Person: def __init__(self, name): self.__name name property def name(self): return self.__name name.setter def name(self, name): self.__name name p Person(张三) print(p.name) # 张三 p.name 李四 print(p.name) # 李四注意property装饰的方法不要和变量重名否则可能导致无限递归。class Person: property def name(self): return self.name p Person() p.name # 报错RecursionError: maximum recursion depth exceeded继承子类派生类继承父类基类中的属性和方法实现代码重用。子类可以新增自己特有的方法也可以重写父类的方法。子类不能继承父类的私有属性和私有方法因为存在名称改写但是可以通过改写后的名称直接访问父类的私有成员不过这种做法违背了封装原则不建议使用。单继承语法-在类名后括号内指定要继承的父类。class 类名(父类): 类体案例class Person: 人的类 home earth # 定义类属性 def __init__(self, name): self.name name # 定义实例属性 def eat(self): print(eating...) class YellowRace(Person): 黄种人 color yellow # 定义类属性 class WhiteRace(Person): 白种人 color white # 定义类属性 class BlackRace(Person): 黑种人 color black # 定义类属性 y1 YellowRace(张三) print(y1.home) # earth print(y1.color) # yellow print(y1.name) # 张三 y1.eat() # eating... w1 WhiteRace(李四) print(w1.home) # earth print(w1.color) # white print(w1.name) # 李四 w1.eat() # eating... b1 BlackRace(王五) print(b1.home) # earth print(b1.color) # black print(b1.name) # 王五 b1.eat() # eating...多继承调用方法时先在子类中查找若不存在则从左到右依次查找父类中是否包含方法。语法class 类名(父类1, 父类2, ...): 类体案例class Person: 人的类 home earth def __init__(self, name): self.name name def eat(self): print(eating...) class YellowRace(Person): 黄种人 color yellow def run(self): print(runing...) class Student(Person): 学生 def __init__(self, name, grade): self.name name self.grade grade def study(self): print(studying...) class ChineseStudent(Student, YellowRace): # 继承了Student和YellowRace 中国学生 country 中国 y1 ChineseStudent(张三, 三年级) print(y1.home, y1.color, y1.country, y1.name, y1.grade) y1.eat() y1.run() y1.study()复用父类方法子类可以在类中使用super().方法名()或父类名.方法名()来调用父类的方法。super().方法名()class Person: 人的类 home earth def __init__(self, name): self.name name def eat(self): print(eating...) class YellowRace(Person): 黄种人 color yellow def run(self): print(runing...) class Student(Person): 学生 def __init__(self, name, grade): self.name name self.grade grade def study(self): print(先吃再学) super().eat() # 子类中调用父类的方法 print(studying...) class ChineseStudent(Student, YellowRace): # 继承了Student和YellowRace 中国学生 country 中国 y1 ChineseStudent(张三, 三年级) print(y1.home, y1.color, y1.country, y1.name, y1.grade) y1.study()父类名.方法名()class Person: 人的类 home earth def __init__(self, name): self.name name def eat(self): print(eating...) class YellowRace(Person): 黄种人 color yellow def run(self): print(runing...) class Student(Person): 学生 def __init__(self, name, grade): self.name name self.grade grade def study(self): print(先吃再学) Person.eat(self) # 子类中调用父类的方法 print(studying...) class ChineseStudent(Student, YellowRace): # 继承了Student和YellowRace 中国学生 country 中国 y1 ChineseStudent(张三, 三年级) print(y1.home, y1.color, y1.country, y1.name, y1.grade) y1.study()方法解析顺序方法解析顺序mro—Method Resolution Order。可使用类名.__mro__访问类的继承链来查看方法解析顺序。class Person: 人的类 home earth def __init__(self, name): self.name name def eat(self): print(eating...) class YellowRace(Person): 黄种人 color yellow def run(self): print(runing...) class Student(Person): 学生 def __init__(self, name, grade): self.name name self.grade grade def study(self): print(先吃再学) Person.eat(self) print(studying...) class ChineseStudent(Student, YellowRace): 中国学生 country 中国 y1 ChineseStudent(张三, 三年级) print(ChineseStudent.__mro__) # (class __main__.ChineseStudent, class __main__.Student, class __main__.YellowRace, class __main__.Person, class object)MRO顺序说明说明 class A: def __init__(self, a,b,c): self.a a self.b b self.c c class B: def __init__(self, d,e,f): self.d d self.e e self.f f class C(A,B): def __init__(self, a,b,c,d,e,f): # super().__init__(a,b,c) # A.__init__(self,a,b,c) # B.__init__(self,d,e,f) # super(A,self).__init__(d,e,f) class Parent1: def __init__(self, value1): print(Initializing Parent1) self.value1 value1 class Parent2: def __init__(self, value2): print(Initializing Parent2) self.value2 value2 class Child(Parent1, Parent2): def __init__(self, value1, value2): print(Initializing Child) # 调用 Parent1 的 __init__ 方法 super().__init__(value1) # 调用 Parent2 的 __init__ 方法 Parent1 之后开始查找 MRO 链调用下一个父类即 Parent2的 __init__ 方法把 value2 传递进去。 # super(Parent1, self).__init__(value2) super().__init__(value2) child Child(value from Parent1, value from Parent2) print(child.value1) print(child.value2) class Parent1: def __init__(self, value1, **kwargs): print(Initializing Parent1) super().__init__(**kwargs) self.value1 value1 class Parent2: def __init__(self, value2, **kwargs): print(Initializing Parent2) super().__init__(**kwargs) self.value2 value2 class Child(Parent1, Parent2): def __init__(self, value1, value2): print(Initializing Child) super().__init__(value1value1, value2value2) child Child(value from Parent1, value from Parent2) print(child.value1) # 输出: value from Parent1 print(child.value2) # 输出: value from Parent2 class Parent1: def __init__(self, value1): print(Initializing Parent1) self.value1 value1 class Parent2: def __init__(self, value2): print(Initializing Parent2) self.value2 value2 class Child(Parent1, Parent2): def __init__(self, value1, value2): print(Initializing Child) # 直接调用 Parent1 的 __init__ 方法 Parent1.__init__(self, value1) # 直接调用 Parent2 的 __init__ 方法 Parent2.__init__(self, value2) child Child(value from Parent1, value from Parent2) print(child.value1) print(child.value2) # 使用 super()适用于遵循 MRO 顺序的场景代码可维护性和扩展性较好特别是在复杂的多重继承结构中。 # 直接调用父类方法代码逻辑较为直观但在多重继承结构发生变化时可能需要手动调整调用顺序可维护性较差。方法重写在子类中定义与父类方法重名的方法调用时会调用子类中重写的方法。class Person: home earth def __init__(self, name): self.name name def eat(self): print(eating...) class Chinese(Person): color yellow # 重写父类方法 def eat(self): print(用筷子吃) y1 Chinese(张三) y1.eat()注意子类重写__init__()并调用时不会执行父类的__init__()方法。如有必要需在子类__init__()中使用super().__init__()来调用父类的__init__()方法。class Person: def __init__(self, name): self.name name class Chinese(Person): def __init__(self, name, area): super().__init__(name) # 调用父类的__init__() self.area area y1 Chinese(张三, 北京) print(y1.name, y1.area)多态同一事物在不同场景下呈现不同状态。class Animal: def go(self): pass class Dog(Animal): def go(self): print(跑) class Fish(Animal): def go(self): print(游) class Bird(Animal): def go(self): print(飞) def go(animal): animal.go() # 将不同的实例传入执行不同的方法 dog Dog() fish Fish() bird Bird() go(dog) go(fish) go(bird)