Python 面向对象的三大特征

单继承的传递性可以描述为：如果类 C 继承自类 B，而类 B 又继承自类 A，那么类 C 不仅会继承类 B 中定义的属性和方法，还会继承类 A 中定义的属性和方法。这种传递性可以一直延续下去，无论继承层次有多深，子类都能获取到其所有祖先类的非私有属性和方法。

class C(object):
     def func(self):
     print('我是C类中的相关⽅法func')
class B(C):
     def funb(self):
     print('我是B类中的相关⽅法funb')
class A(B):
     def funA(self):
     print('我是A类中的相关⽅法funa')

a = A()
a.funa()
b = B()
b.funb()
c = C()
c.func()

2.5 object：

在 Python 中，object 是所有类的基类，在 Python 面向对象编程体系里扮演着非常基础且重要的角色，所有类默认都会隐式继承自 object 类。也就是说，即使你定义类时没有显式指定基类，它实际上也是 object 类的子类。

# 定义一个没有显式指定基类的类
class MyClass:
    pass

# 检查 MyClass 是否是 object 的子类
print(issubclass(MyClass, object))  # 输出: True

2.6 多继承：

多继承是指一个子类可以同时继承多个父类的特性。也就是说，子类可以拥有多个父类所定义的属性和方法，从而可以复用多个不同父类的代码。

# 定义第一个父类
class Parent1:
    def method1(self):
        print("This is method1 from Parent1")

# 定义第二个父类
class Parent2:
    def method2(self):
        print("This is method2 from Parent2")

# 定义子类，继承自 Parent1 和 Parent2
class Child(Parent1, Parent2):
    pass

# 创建子类的实例
child = Child()

# 调用从 Parent1 继承的方法
child.method1()

# 调用从 Parent2 继承的方法
child.method2()

2.7 重写：

子类重写父类中的属性与方法，子类可以重写父类的方法，即子类定义一个与父类同名的方法，这样在调用该方法时，会优先使用子类的方法。

基本语法：

class Father(object):
    属性
    ⽅法
class Son(Father):
    ⽗类属性和⽅法
    ⾃⼰的属性和⽅法（如果⼦类中的属性和⽅法与⽗类中的属性或⽅法同名，则⼦类中的属性或⽅法会对⽗类中同名的属性或⽅法进⾏覆盖（重写））

示例代码：

class Animal(object):
     def eat(self):
         print('i can eat')
     # 公共⽅法
     def call(self):
         print('i can call')
class Dog(Animal):
     # 重写⽗类的call⽅法
     def call(self):
         print('i can 汪汪汪')
class Cat(Animal):
     # 重写⽗类的call⽅法
     def call(self):
         print('i can 喵喵喵')
wangcai = Dog()
wangcai.eat()
wangcai.call()
miaomiao = Cat()
miaomiao.eat()
miaomiao.call()

2.8 super：

在 Python 面向对象编程的继承机制里，super() 是一个非常实用的内置函数，它主要用于调用父类（超类）的方法。super() 函数返回一个代理对象，该对象会将方法调用委托给父类或兄弟类，从而可以方便地调用父类的方法。

调用父类的构造方法

在子类的构造方法中，经常需要调用父类的构造方法来初始化从父类继承的属性。

class Animal:
    def __init__(self, name):
        self.name = name
        print(f"Animal 的构造方法被调用，名字是 {self.name}")

class Dog(Animal):
    def __init__(self, name, breed):
        # 调用父类的构造方法
        super().__init__(name)
        self.breed = breed
        print(f"Dog 的构造方法被调用，品种是 {self.breed}")

# 创建 Dog 类的实例
dog = Dog("旺财", "金毛寻回犬")

在上述代码中，Dog 类继承自 Animal 类。在 Dog 类的构造方法 __init__ 中，使用 super().__init__(name) 调用了父类 Animal 的构造方法，先完成父类属性的初始化，再初始化子类特有的属性。

调用父类的其他方法

除了构造方法，super() 还可以用于调用父类的其他普通方法。当子类重写了父类的某个方法，但又需要在子类方法中使用父类方法的功能时，就可以使用 super() 来调用父类的方法。

class Animal:
    def speak(self):
        return "动物发出声音"

class Dog(Animal):
    def speak(self):
        # 调用父类的 speak 方法
        parent_speak = super().speak()
        return f"{parent_speak}，具体来说是汪汪叫"

# 创建 Dog 类的实例
dog = Dog()
print(dog.speak())

super() 函数的工作原理与 Python 的方法解析顺序（Method Resolution Order，MRO）有关。MRO 定义了在多继承情况下，Python 查找方法的顺序。super() 会根据 MRO 来确定要调用的父类方法。可以通过类的 __mro__ 属性查看类的 MRO。

2.9 方法解析顺序（MRO）

当多个父类中存在同名方法时，Python 需要确定调用哪个父类的方法，这就涉及到方法解析顺序（Method Resolution Order，MRO）。可以通过类的 __mro__ 属性查看方法解析顺序。

class A:
    def method(self):
        print("Method from A")

class B(A):
    def method(self):
        print("Method from B")

class C(A):
    def method(self):
        print("Method from C")

class D(B, C):
    pass

# 查看 D 类的方法解析顺序
print(D.__mro__)

# 创建 D 类的实例
d = D()
# 调用 method 方法
d.method()

在上述代码中，D 类继承自 B 和 C，而 B 和 C 又都继承自 A。D.__mro__ 会输出一个元组，显示方法解析的顺序。当调用 d.method() 时，Python 会按照 MRO 的顺序查找 method 方法，找到后就会调用该方法。

多态

3.1 概念：

好处：调用灵活，有了多态，更容易编写出通用的代码，做出通用的编程，以适应需求的不断变化！

3.2 基本语法：

'''
⾸先定义⼀个⽗类，其可能拥有多个⼦类对象。当我们调⽤⼀个公共⽅法（接⼝）时，传递的对象不
同，则返回的结果不同。
'''
class Fruit(object): # ⽗类Fruit
     def makejuice(self):
         print('i can make juice')
class Apple(Fruit): # ⼦类：苹果
     # 重写⽗类⽅法
     def makejuice(self):
         print('i can make apple juice')
class Banana(Fruit): # ⼦类：⾹蕉
     # 重写⽗类⽅法
     def makejuice(self):
         print('i can make banana juice')
class Orange(Fruit): # ⼦类：橘⼦
     # 重写⽗类⽅法
     def makejuice(self):
         print('i can make orange juice')
# 定义⼀个公共接⼝（专⻔⽤于实现榨汁操作）
def service(obj):
     # obj要求是⼀个实例化对象，可以传⼊苹果对象/⾹蕉对象
     obj.makejuice()
# 调⽤公共⽅法
service(Orange())

如果加号的两边都是数值类型的数据，则加号代表运算符

如果加号的两边传入的是字符串类型的数据，则加号代表合并操作，返回合并后的字符串

'a' + 'b' = 'ab'

如果加号的两边出入序列类型的数据，则加号代表合并操作，返回合并后的序列

[1, 2, 3] + [4, 5, 6] = [1, 2, 3, 4, 5, 6]

类属性

类属性是一种重要的概念，它与实例属性共同构成了类的数据部分。类属性是属于类本身的属性，它被该类的所有实例对象所共享。类属性在类定义中直接声明，不依赖于某个具体的实例对象。

4.1 特点：

• 共享性：所有由该类创建的实例对象都可以访问类属性，类属性只有一份拷贝，存储在类的命名空间中。
• 独立性：类属性独立于实例属性，即使没有创建任何实例对象，类属性依然存在于类中。

4.2 基本语法：

class Car:
    # 定义类属性
    wheels = 4

    def __init__(self, brand):
        self.brand = brand

# 通过类名访问类属性
print(Car.wheels)  # 输出: 4

# 创建类的实例
my_car = Car("宝马")
# 通过实例对象访问类属性
print(my_car.wheels)  # 输出: 4

在上述代码中，wheels 是 Car 类的类属性，既可以通过类名 Car 直接访问，也可以通过类的实例对象 my_car 进行访问。

4.3 修改类属性

类属性可以通过类名进行修改，修改后所有实例对象访问该类属性时都会得到新的值。

class Car:
    wheels = 4

    def __init__(self, brand):
        self.brand = brand

# 修改类属性
Car.wheels = 6

# 创建类的实例
my_car = Car("宝马")
# 通过实例对象访问修改后的类属性
print(my_car.wheels)  # 输出: 6

需要注意的是，如果通过实例对象去修改类属性，实际上会为该实例创建一个同名的实例属性，而不会影响类属性本身。

4.4 类属性与实例属性的对比：

• 存储位置：类属性存储在类的命名空间中，而实例属性存储在每个实例对象的命名空间中。
• 访问方式：类属性可以通过类名和实例对象访问，实例属性只能通过实例对象访问。
• 数据共享性：类属性被所有实例对象共享，一个实例对类属性的修改会影响其他实例；实例属性是每个实例独有的，修改一个实例的属性不会影响其他实例。

4.5 综上所述

类属性是类定义中声明的属性，被所有实例共享。可通过类或实例访问修改，用于存储类级别的数据和状态。

类方法

类方法是绑定到类而不是实例的方法。在 Python 中，使用 @classmethod 装饰器来定义类方法。类方法的第一个参数通常命名为 cls，它代表类本身，通过 cls 可以访问和操作类的属性和调用类的其他方法。

5.1 基本语法

class MyClass:
    class_attribute = "这是类属性"

    @classmethod
    def class_method(cls):
        return cls.class_attribute

# 调用类方法
result = MyClass.class_method()
print(result)  # 输出: 这是类属性

5.2 访问和修改类属性

类方法可以直接访问和修改类属性，因为它的第一个参数 cls 代表类本身。

class Student:
    total_students = 0

    def __init__(self, name):
        self.name = name
        Student.total_students += 1

    @classmethod
    def get_total_students(cls):
        return cls.total_students

# 创建 Student 类的实例
s1 = Student("Alice")
s2 = Student("Bob")

# 调用类方法获取学生总数
total = Student.get_total_students()
print(total)  # 输出: 2

在上述代码中，get_total_students 是一个类方法，通过 cls.total_students 访问了类属性 total_students。

5.3 调用方式

类方法可以通过类名直接调用，也可以通过实例对象调用，但推荐使用类名调用，因为类方法的主要作用是操作类本身。

class MyClass:
    @classmethod
    def class_method(cls):
        print("这是类方法")

# 通过类名调用
MyClass.class_method()
# 通过实例调用
obj = MyClass()
obj.class_method()

5.4 与实例方法和静态方法的对比

与实例方法对比

• 参数不同：实例方法的第一个参数是 self，代表实例对象本身，通过 self 可以访问和操作实例属性；类方法的第一个参数是 cls，代表类本身，通过 cls 可以访问和操作类属性。
• 调用方式不同：实例方法必须通过实例对象调用；类方法可以通过类名或实例对象调用。
• 用途不同：实例方法主要用于操作实例对象的属性和实现实例对象的行为；类方法主要用于操作类属性和创建工厂方法等与类本身相关的操作。

与静态方法对比

• 参数不同：静态方法没有特殊的第一个参数，它不与类或实例有直接的绑定关系；类方法有第一个参数 cls，代表类本身。
• 功能用途不同：静态方法通常用于执行一些与类和实例的状态无关的通用操作，例如数学计算、字符串处理等；类方法主要用于操作类属性、创建工厂方法等与类本身相关的操作。

5.5 综上所述

不需要创建类的对象，通过 类名. 的⽅式就可以访问类的属性或者调用类的方法 。

1. 用@classmethod 修饰的方法为类方法；

2. 类方法的参数为 cls，在类方法内部通过 cls.类属性 或者 cls.类方法 来访问同一个类中的其他类属性和类方法；

3. 类方法不需要实例化就可以调用，类方法只能访问同一个类中的类属性和类方法

静态方法

静态方法是属于类的方法，但它既不依赖于类本身（即类属性和类方法），也不依赖于类的实例对象（即实例属性和实例方法）。在 Python 中，使用 @staticmethod 装饰器来定义静态方法，静态方法没有类似 self（代表实例对象）或 cls（代表类本身）这样的特殊第一个参数。

既不需要访问实例属性或者调用实例方法

也不需要访问类属性或者调用类方法

这个时候，可以把这个方法封装成一个静态方法

# 开发⼀款游戏
class Game(object):
     # 开始游戏，打印游戏功能菜单
     @staticmethod # 修饰符,声明为静态⽅法,⽆需传递self参数，直接使⽤类名即可，⽆需
     实例化对象
     def menu(): # 静态⽅法
         print('1、开始游戏')
         print('2、游戏暂停')
         print('3、退出游戏')
# 开始游戏、打印菜单
Game.menu() # 调⽤静态⽅法，⽆需实例化对象，直接使⽤类名即可