python面向对象

Python面向对象

（oop）面向对象编程是使用“对象”来完成的编程，对象包含数据（属性）和代码（方法或函数），就是将现实世界的事务用类与实例来模拟，

类：类是抽象的，约定了未来实例该有的内容，是实例的模板，使用class关键字定义一个类

class Person:#定义一个人类
    pass

对象：对象是类的实例， 调用类产生实例， self出现在类内代表未来的实例

class Person:
    def __init__(self, name): #self , name为实例
        self.name = name

#p是通过调用类得到的对象
p = Person("小帅")
p.name
print(p.get_name())

属性：属性是对象的状态信息，通常是变量，用来存储数据

class Person:
    def __init__(self, name):
        self.name = name  #self构造函数模板，实例属性
        print(f"我叫{self.name}")

p = Person("小帅")
p.name

方法：方法是对象的行为，是类中定义的函数，可以访问和修改对象的属性

class Person:
    def __init__(self, name):
        self.name = name
        print(f"我叫{self.name}")

    #在类中定义了一个函数get_name为类方法
    def get_name(self):
        return f"我是类的方法"

p = Person("小帅")
p.name
print(p.get_name())

面向对象的三大特性，封装，继承和多态

封装：是在不改变原来的实现结果的同时，将对象的数据（属性）和行为（方法）组合在一起，提高代码的可维护性

def add(num1, num2):
    #函数内部封装了求和代码块
    sum = num1+num2
    #返回计算结果
    return sum

#调用函数打印结果
result = add(10,20)
print(result)

继承：允许一个子类继承父类的属性和方法，同时子类也可以扩展父类没有的行为，或者修改父类的行为，继承支持代码复用

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        return f"位置:{self.x} {self.y}"

#继承父类中的属性和方法，同时扩展了半径r
class Circle(Point):
    def __init__(self, x, y, r):
        super().__init__(x, y) 
        self.r = r #初始化
    
    #类中的方法
    def __str__(self):
        return f"{super().__str__()} 半径:{self.r}"
     
    #类中求面积的方法
    def get_area(self):
        return f"圆的面积为:{math.pi*self.r**2}"

c = Circle(10,10, 10)
print(c)
print(f"圆的面积为：{c.get_area()}")

多态：多态的两种形式

1：函数同名不同参数，通过*args实现

def my_fun(*args):
    print(args)
"""
函数同名。但参数是多种多样的
"""

print(1)
print(1, 2)
print(1, 2, 3)

2：父子类多态，函数名参数都相同，但实现不同，拥有多种实现， python还支持多继承，就是一个子类可以继承多个父类的

class Animal:
    def walk(self, speed):
        print(f"走一走")
    """
    函数名相同，参数也相同，但是有不同的实现
    """

class Dog(Animal):
    def walk(self, speed):
        print(f"夹着尾巴跑")


class Cat(Animal):
    def walk(self, speed):
        print(f"钻来钻去")

魔法函数：

class Person:
    def __init__(self, name, age):
        # 初始化self，设置实例属性
        self.name = name
        self.age = age

    def __str__(self):
        # 返回实例的字符串表示
        return f"Person(name={self.name}, age={self.age})"

    def __len__(self):
        # 返回实例的"长度"，这里我们简单地返回年龄
        return self.age

    def __eq__(self, other):
        # 比较两个Person实例是否相等，基于年龄
        return self.age == other.age

    def __lt__(self, other):
        # 比较两个Person实例，年龄小的为"小于"
        return self.age < other.age

    def __add__(self, other):
        # 假设Person实例可以相加，返回年龄之和
        if isinstance(other, Person):
            return Person(self.name, self.age + other.age)
        else:
            raise TypeError("Age must be of Person instance")

# 使用魔法方法
p1 = Person("Alice", 30)
p2 = Person("Bob", 40)

print(p1)  # 使用 __str__
print(len(p1))  # 使用 __len__
print(p1 == p2)  # 使用 __eq__
print(p1 < p2)  # 使用 __lt__

# 假设Person实例可以相加
p3 = p1 + p2
print(p3)  # 使用 __add__

抽象类：父类可以强制子类实现某些特定的功能

from abc import ABC, abstractmethod


class Animal:
    """
    抽象类：拥有抽象方法，不能直接实例化
    通过装饰器abstractmethod 把walk 变为抽象方法
    """

    @abstractmethod
    def walk(self):
        pass


# 通过子类实例化
class Dog(Animal):
    def walk(self):
        print(f"跑来跑去")


class Cat(Animal):
    def walk(self):
        print(f"跳来跳去")


dog = Dog()
dog.walk()
cat = Cat()
cat.walk()

单例类：单例类确保了一个类只能有一个实例，单例类有两种实现方法

class Manage:
    instance = None

    def __new__(cls, *args, **kwargs):
        if not cls.instance:
            cls.instance = super().__new__(cls)
        return cls.instance

    def __init__(self):
        print("欧克了")


m = Manage()


#第二种

class Manage:
    def __new__(cls, *args, **kwargs):
        if not hasattr(Manage, "instance"):
            obj = super().__new__(cls)
            setattr(Manage, "instance", obj)
        return getattr(Manage,"instance")


m = Manage()
m1 = Manage()
print(m is m1)