Python面向对象

面向对象是一种以对象为中心的编程方式，强调将事物的属性和方法封装到一起，核心思想是将世界中的万事万物抽象为对象，并通过类来定义这些对象的模版。核心特征包括封装、继承、多态，封装是指将数据和行为包装在一个类里面，隐藏实现的细节，只暴露必要的接口。继承是指一个类可以从另一个类继承属性或者方法，实现代码的复用，多态是指同一个接口有不同实现的方式，面向过程则是将问题分成多个步骤，按照步骤实现最终的目的

二、概念

1.类、对象、实例

类是抽象的，封装对象和属性，类是对象的模版，定义了属性和方法

对象是类的实例，实现了类定义的属性和方法，在Python中，可以认为一切皆是对象，如一个字符转，一个常量等，

实例是类的具体化，根据类创建出的对象

class Animal:
    # 类属性
    species = "哺乳动物"

    def __init__(self, name, age):
        # 实例属性
        self.name = name
        self.age = age

    # 实例方法
    def description(self):
        return f"{self.name} is {self.age} years old"

# 实例化对象
dog = Animal("Buddy", 5)
print(dog.description())

2.三大特性

1.封装

把数据和数据操作方法封装在一个类中

class T:
    def __init__(self,w,h):

        self.w = w
        self.h = h
#这里封装了宽和高的数据

    def get_perimeter(self):
        return (self.w + self.h) * 2

    def get_ares(self):
        return self.h * self.w

2.继承

2.1.单继承

子类继承父类时，可以使用父类中的属性和方法，也可以重写父类中的方法

class Dog(Animal):
    #调用父类初始化函数
    def __init__(self,age,height):
        super().__init__(age)#继承父类方法，子类的功能越来越完善
        self.heiht = height
    "Dog"
    def speak(self):
        #方法重写
        # super().speak()
        print("汪汪汪")
class Aq1(Dog):
    def __init__(self, age, height):
        super().__init__(age, height)
    def swimming(self):
        print("狗狗在游泳")

2.2.多继承

当子类继承多个父类时，遵循MRO原则，首先使用第一个父类的方法和属性

class Dog(Animal):
    #调用父类初始化函数
    def __init__(self,age,height):
        super().__init__(age)#继承父类方法，子类的功能越来越完善
        self.heiht = height
    "Dog"
    def speak(self):
        #方法重写
        # super().speak()
        print("汪汪汪")
class Person:
    def __init__(self,person):
        print('我是人类')
        self.person= person
    def do(self):
        print('做饭')
class Aq2(Dog,Person):
    def __init__(self, age, height):
        super().__init__(age, height)

3多态

多态通过方法重写和鸭子类型实现，无序显示继承接口和抽象类

3.1.方法重写

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

def animal_sound(animal: Animal):
    print(animal.speak())

# 多态调用
animal_sound(Dog())  # 输出: Woof!
animal_sound(Cat())  # 输出: Meow!

3.2鸭子类型

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

def animal_sound(animal: Animal):
    print(animal.speak())

# 多态调用
animal_sound(Dog())  # 输出: Woof!
animal_sound(Cat())  # 输出: Meow!

三、类的成员

1.实例属性

通过self关键字在类的方法中定义和访问。
每个实例拥有独立的属性值
通常在_init_中初始化

class MyClass:
    def __init__(self, value):
        self.instance_attr = value  # 实例属性

2.实例方法

第一个参数是self,指向实例本身
通过实例调用方法时自动传递self。

def instance_method(self, arg):
    print(f"实例方法访问属性: {self.instance_attr}")

3类属性、数据

直接定义在类作用域中的变量，属于类本身

class MyClass:
    class_attr = "类属性"  # 类属性

4.类方法

使用@classmethod装饰器声明。
第一个参数为cls，指向类本身。
用于操作类级别的数据或工厂模式

from datetime import date

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    @classmethod
    def from_birth_year(cls, name, birth_year):
        current_year = date.today().year
        age = current_year - birth_year
        return cls(name, age)

# 使用类方法创建对象
p1 = Person("Alice", 30)
p2 = Person.from_birth_year("Bob", 1990)

print(p2.name, p2.age)  # Bob 35（根据当前年份变化）

5.静态方法

需要使用@staticmethod装饰器声明。
无序self和cls参数，
一般用于工具类

class Utils:
    @staticmethod
    def add(a,b):
        return a + b
    @staticmethod
    def max(a,b):
        return a if a > b else b


print(Utils.max(2, 4))

四、数据访问级别

1.公有访问级别

普通格式，类内可以通过self访问，类外可以通过方法访问，没有访问限制，任何代码都可以修改和调用

2.私有访问级别

私有访问级别以双下划线 __ 开头，只能在类内部访问，外部无法直接访问或修改。这种设计可以防止类外数据设置不合理或意外修改。
保护关键数据，避免外部直接操作。

3.保护访问级别

保护访问级别以单下划线 _ 开头，专门为子类设计。虽然外部仍可访问，但约定俗成表示仅供子类或内部使用。

class Person:
    def __init__(self,name,age,sex):
        self.name = name
        self.age  = age
        self.__sex = sex
        self._id = 23
    def __str__(self):
        return f'name:{self.name},age{self.age}，__speak{self.__speak(),}id:{self._id}'


    def __speak(self):
        return "私有"
# p = Person('黄本贵',23)
# print(p)
# p.age()
# p.sex()#不能访问
# p.__speak()#不能访问
class Son(Person):
    def __init__(self, name, age, sex):
        super().__init__(name, age, sex)
        self._play = '游戏'
    def get_play(self):
        return self._play
    def get_id(self):
        return self._id
    def __str__(self):
        return f'name:{self.name},age{self.age}，__speak{self.__speak(),}id:{self._play}'
s = Son('哈哈',23,'男')
print(s.get_id())
print(s._play)
print(s._id)

五、魔法函数

1.`init`

__init__ 是类的初始化方法，在创建类的实例时自动调用。它用于初始化实例的属性，确保每个实例都有对应的属性，避免遗漏重要属性。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

2.str

__str__ 返回对象的字符串表示形式，通常用于用户友好的输出。当使用 print(obj) 或 str(obj) 时会调用此方法。

class Person:
    def __str__(self):
        return f"Person(name={self.name}, age={self.age})"

3.数学比较

__gt__(self, other)：实现大于比较（>）。
__ge__(self, other)：实现大于等于比较（>=）。
__lt__(self, other)：实现小于比较（<）。
__le__(self, other)：实现小于等于比较（<=）。
__eq__(self, other)：实现等于比较（==）。
__ne__(self, other)：实现不等于比较（!=）。

class Person:
    def __eq__(self, other):
        return self.age == other.age

4.len

__len__ 返回对象的长度表示，通常用于容器类（如列表、字典）。当调用 len(obj) 时会调用此方法。

class MyList:
    def __len__(self):
        return len(self.items)

5.del

__del__ 是析构函数，用于在对象被销毁时释放资源。当对象的引用计数为 0 时，Python 的垃圾回收机制会调用此方法。

class Resource:
    def __del__(self):
        print("Resource released")

6.new

负责创建并返回类的实例，他在__init__被调用之前执行

class MyClass:
    def __new__(cls, *args, **kwargs):
        instance = super().__new__(cls)  # 调用父类的__new__方法
        return instance

六、动态语言

Python 是一门动态语言（Dynamic Language），这意味着你可以在程序运行时动态地为对象、类添加属性和方法。、

1.动态添加类属性

class Person:
    pass

# 动态添加类属性
Person.name = '哈哈哈'

print(Person.name)  # 输出: 哈哈哈

2.动态添加实例方法

2.1直接绑定实例函数

def get_doc1(self):
    return self.__doc__

class Person:
    """这是 Person 类的文档字符串"""
    pass

p = Person()

# 动态绑定方法（需要手动传入 self）
p.get_doc = get_doc1
print(p.get_doc(p))  # 输出: 这是 Person 类的文档字符串

2.2通过MethodType正确绑定方法

import types

def get_doc1(self):
    return self.__doc__

class Person:
    """这是 Person 类的文档字符串"""
    pass

p = Person()

# 使用 MethodType 正确绑定方法
p.get_doc = types.MethodType(get_doc1, p)

print(p.get_doc())  # 输出: 这是 Person 类的文档字符串

3.动态添加类方法

@classmethod
def get_class1(cls):
    return cls.__doc__

class Person:
    """这是 Person 类的文档字符串"""
    pass

# 动态添加类方法
Person.get_class = get_class1

print(Person.get_class())  # 输出: 这是 Person 类的文档字符串

4.动态添加静态方法

def add1(a, b):
    return a + b

class Person:
    pass

# 动态添加静态方法
Person.add = staticmethod(add1)

print(Person.add(2, 4))  # 输出: 6