python 面向对象

# 使用 class 关键字创建一个电脑类
class  computer:
	# 初始化方法
    def __init__(self, cpu, ram, hdd):
        self.cpu = cpu
        self.ram = ram
        self.hdd = hdd
    # 品牌标记方法
    def brand(self, brand_name:str): 
        self.brand_name = brand_name
        print(f"Brand: {self.brand_name}")
	# 输出电脑配置
    def config(self):
        print("Configuration of the computer:")
        print(f"CPU: {self.cpu}")
        print(f"RAM: {self.ram} GB")
        print(f"HDD: {self.hdd} TB")
	
    def __add__(self, other):
        total_ram = self.ram + other.ram
        total_hdd = self.hdd + other.hdd
        return computer("Combined CPU", total_ram, total_hdd)

# 创建两个计算机对象
# 台式电脑
comp1 = computer("desktop","Intel i5", 8, 1)
# 笔记本电脑
comp2 = computer("laptop","AMD Ryzen 5", 16, 2)
# 品牌标记
comp1.brand("Dell")
# 输出配置
comp1.config()
# 品牌标记
comp2.brand("HP")
# 输出配置
comp2.config()  

# 创建两个计算机对象
comp1 = computer("desktop","Intel i5", 8, 1)
comp2 = computer("laptop","AMD Ryzen 5", 16, 2)
comp1.brand("Dell")
comp1.config()
comp2.brand("HP")
comp2.config()  

# 1. 学校储物柜系统（模块/全局命名空间）
class_shelves = {}  # 每个班级的储物柜架
global_items = {"学校名": "阳光中学", "校长": "张老师"}

# 2. 班级储物柜架（类命名空间）
class Class7A:
    # 班级公共储物柜（类属性）
    classroom = "301"
    teacher = "王老师"
    class_items = ["地图", "地球仪", "粉笔"]  # 所有学生共享
  
    def __init__(self, student_name):
        # 学生个人储物柜（实例属性）
        self.student_name = student_name
        self.personal_items = []  # 每个学生自己的物品
  
    def add_item(self, item):
        # 往个人储物柜放东西
        self.personal_items.append(item)
  
    @classmethod
    def change_classroom(cls, new_room):
        # 修改班级公共储物柜位置
        cls.classroom = new_room

# 3. 实际使用
zhang = Class7A("张三")
li = Class7A("李四")

# 类属性访问（班级公共储物柜）
print(zhang.classroom)     # 301
print(li.classroom)        # 301
print(Class7A.classroom)   # 301

# 修改类属性（移动班级）
Class7A.classroom = "302"
print(zhang.classroom)     # 302（所有实例都变了）
print(li.classroom)        # 302

# 实例属性（个人储物柜）
zhang.add_item("数学书")
li.add_item("语文书")

print(zhang.personal_items)  # ['数学书']
print(li.personal_items)     # ['语文书']（互不影响）

class Car:
    # 类命名空间中的内容
    wheels = 4  # 类属性
    engine_type = None  # 类属性

    def __init__(self, brand):
        # 实例命名空间中的内容
        self.brand = brand  # 实例属性
        self.speed = 0  # 实例属性

    @classmethod
    def set_default_wheels(cls, num):
        # 操作类命名空间
        cls.wheels = num

    def accelerate(self):
        # 操作实例命名空间
        self.speed += 10

# 创建实例
BYD = Car("比亚迪")
BBA = Car("宝马")
# 查看实例属性
print("查看各个实例中属性值")
print(f"BYD 中的实例属性值：{BYD.__dict__}") # 暑促：BYD 中的实例属性值：{'brand': '比亚迪', 'speed': 0}
print(f"BBA 中的实例属性值：{BBA.__dict__}") # 输出：BBA 中的实例属性值：{'brand': '宝马', 'speed': 0}

# 修改类属性（影响所有实例）
Car.set_default_wheels(6)
print("BYD 轮胎数量：",BYD.wheels) # 输出： 6
print("BBA 轮胎数量：",BBA.wheels) # 输出： 6

# 尝试通过实例修改类属性：
BBA.wheels = 4
print("类属性",Car.wheels) # 6 （类属性不受影响）
print("BYD 轮胎：",BYD.wheels) # 6 （BYD 实例不受影响）
print("BBA 轮胎数量：",BBA.wheels) # 4 （BBA 修改自己实例中的内容，只租用与当前的实例，其他实例不受影响。）

'''
动态操作命名空间
'''
print("动态操作命名空间")

class DynamicClass:
    """演示动态操作命名空间"""

    def __init__(self):
        self.data = {}

# 查看当前实例命名空间。
obj = DynamicClass()
print("obj 当前实例空间：",obj.__dict__) # 输出：obj 当前实例空间： {'data': {}}

# 动态添加实例属性
obj.new_attribute = "动态添加的属性"
print("obj 动态添加属性后的命名空间：",obj.__dict__) # 输出：{'data': {}, 'new_attribute': '动态添加的属性'}

# 动态添加方法：
def dynamic_mathod(self):
    return f"动态方法，动态属性 new_attribute 值为：{self.new_attribute}"

# 绑定动态方法到实例
import types
# 使用 types.MethodType 将动态方法和实例绑定。
obj.show_info = types.MethodType(dynamic_mathod,obj)
print("调用动态方法：",obj.show_info() )
# 输出： 调用动态方法： 动态方法，动态属性 new_attribute 值为：动态添加的属性

# 动态添加类属性：
DynamicClass.clasVerion = "1.0"
print(f"动态添加的雷属性{DynamicClass.clasVerion}")
# 输出：动态添加的雷属性1.0

# 动态删除属性：
del obj.new_attribute
try:
    print("obj 动态属性：",obj.new_attribute)
except Exception as e:
    print(f"发现错误{e}，obj 的当前状态：{obj.__dict__}")
    # 输出：发现错误'DynamicClass' object has no attribute 'new_attribute'，obj 的当前状态：{'data': {}, 'show_info': <bound method dynamic_mathod of <__main__.DynamicClass object at 0x000001E553CA6BA0>>}

class Animal:
    # 2. 属性（Attributes）- 特征
    def __init__(self, name, age):
        self.name = name  # 名字属性
        self.age = age    # 年龄属性
	
	# 3. 方法（Methods）- 行为
    def eat(self):
        print(f"{self.name}正在吃东西")
  
    def make_sound(self):
        print(f"{self.name}发出声音")

lion = Animal("辛巴", 5)  # 狮子辛巴
elephant = Animal("小飞象", 10)  # 大象小飞象

class Class:
    def method(self):
        print("我有一个 swlf 参数。")

def function():
    print("我啥也没有")

# 创建父类/基类 Animal 所有动物都继承自 Animal
class Animal:
    def __init__(self, name):
        self.name = name
    def eat(self):
        print(f"{self.name}吃东西")

# dog 类，继承至 Animal 类
class Dog(Animal):
    def __init__(self, name):
        Animal.__init__(self, name)
    # 子类可以新增方法。
    def woof(self):
        print(F"{self.name} 汪汪叫")
    # 重写父类的方法。
    def eat(self):
        print(f"{self.name} 吃狗粮")

class Cat(Animal):
    def __init__(self, name):
        Animal.__init__(self, name)
    def maomao(self):
        print(f"{self.name} 喵喵叫")

# 创建实例 dog
dog = Dog("球球")
dog.eat() # 输出：球球 吃狗粮
dog.woof() # 输出：球球 汪汪叫
# 创建实例 cat
cat = Cat("芝麻团")
cat.eat() # 输出：芝麻团吃东西
cat.maomao() # 输出：芝麻团 喵喵叫

class Filter:
    def __init__(self, name = None):
        self.name = name

    def  filter(self, sequence):
        return [item for item in sequence if self.name not in item]
# 创建一个子类 SubFilter，继承自 Filter
# 子类可以继承父类的属性和方法 
# 也可以重写父类的方法
# 还可以使用 super() 函数调用父类的方法
class SubFilter(Filter):
    def __init__(self, name):
        super().__init__(name)

filter2 = SubFilter("spam")
# 使用子类对象调用继承自父类的方法
print(filter2.filter(["spam","eggs","harn"]))# 输出 ['eggs', 'harn']

# 查看某个类是否为另一个类的子类
print(issubclass(SubFilter,Filter)) # 输出 True
print(issubclass (Filter,SubFilter))    # 输出 False

# 查看对象是否为某个类的实例，可以使用 isinstance() 函数
print(isinstance(filter2,SubFilter))# 输出 True
print(isinstance(filter2,Filter))# 输出 True
print(isinstance(filter2,object))# 输出 True

# 通常更好的方法是使用 type() 函数
print(type(filter2) == SubFilter) # 输出 True

# 多重继承
class Calb:
    value = 0
    def  cabl(self,expressions):
        self.value = eval(expressions)
    # 测试多同名方法
    def takeing(self):
        print(f"I think the  expressions result is {self.value} —— Calb")
class Take:
    def takeing(self):
        print(f"En... I think the  expressions result is {self.value} —— Take")
class TakeCable(Calb,Take):
    pass

takecable = TakeCable()
takecable.cabl("2 * 8 + 1")
# 调用父类的方法
takecable.takeing() # 输出 En... I think the  expressions result is 17

class Seretive:
    # 私有方法
    def __intarnal_mathod(self,x:int,y:int):
        return x + y
    # 公共方法
    def  public_method(self,a,b):
           return self.__intarnal_mathod(a,b)
    # 受保护方法
    def _prodected_method(self):
        print("This is a protected method")
# 创建 Seretive 对象
obj = Seretive()
# 尝试调用私有方法
# obj.__intarnal_mathod(3,4)  # 这将引发 AttributeErr
# 正确的调用方式是通过公共方法
result = obj.public_method(1,3)
print(result)  # 输出 4

# 多态代码演示，用户解释什么是多态。

# 创建 dog 类
class Dog:
    # 实现 说话方法
    def speak(self):
        print("汪汪汪")

# 创建 cat 类
class Cat:
    # 实现说话方法
    def speak(self):
        print("喵喵喵")

# 创建 dock 类
class Duck:
    # 实现说话方法
    def speak(self ):
        print("嘎嘎噶")

animals = [Dog(),Cat(),Duck()]

# 使用多态。
for animal in animals:
    # 调用统一接口
    animal.speak()
    # 输出：汪汪汪
    # 喵喵喵
    # 嘎嘎噶

# 编写 add() 函数

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

# 测四字符相加
print("字符相加",add("inter","nation"))	# 输出：internation
# 测试数字相加
print("数字相加",add(20,10)) # 输出：30

def length_message(x):
    print(f"The length of {repr(x)} is {len(x)}")


length_message("internation")
length_message([2,4,6,8,10])

# 此代码用于解释抽象类。
from abc import ABC, abstractmethod
from idlelib.debugobj import ClassTreeItem

# python 中，所有抽象类必须继承自  ABC 抽象基类不能被实例化，只能由
class Computer(ABC):
    # 抽象类中的抽象方法必须有 @abstractmethod 修饰符。
  
    # 创建 CPU 抽象方法（CPU 包括运算器和控制器）
    @abstractmethod
    def CPU(self):
        pass

    # 创建存储抽象类
    @abstractmethod
    def Storage(self):
        pass

    # 创建 输入设备抽象类
    @abstractmethod
    def InputDriver(self):
        pass

    # 输出设备：屏幕。抽象类可以包含已经实现的方法。
    def OutputDriver(self):
        print("输出设备为：Screen")

# 继承 Computer 抽象类，具体实现。
class Production(Computer):
    def __init__(self,CPU,Storage,InputDriver):
        self.CPU = CPU
        self.Storage = Storage
        self.InputDriver = InputDriver
  
    # 实现抽象基类 Computer 中的抽象方法。
    def CPU(self):
        print(f"该机器使用的 CPU 为：{self.CPU}")

    def Storage(self):
        print(f"该机器使用的内存为：{self.Storage}")

    def InputDriver(self):
        print(f"该机器使用的输入设备为：{self.InputDriver}")

    def get_config(self):
        Production.CPU(self)
        Production.Storage(self)
        Production.InputDriver(self)
        super().OutputDriver()


# 实例化子类。
# 创建一个 Dell 实例，定义电脑配置
Dell = Production("intel i7-10520","DDR5：32G，SSD：1TB","keyboard")
# 输出配置
Dell.get_config()
输出：

# 创建一个 Lenovo 实例，定义电脑配置
Lenovo = Production("AMD Ryzen 9700x3D","DDR5:64G,SSD：2TB","keyboard")
# 输出配置。
Lenovo.get_config()

# 该程序用演示 python 中接口的定义。
from  abc import ABC, abstractmethod

# 支出接口，需要子类继承实现
class PaymantMathd(ABC):

    # 支付方法，子类必须要实现
    @abstractmethod
    def process_payment(self,amount):
        pass

    # 图款方法，子类必须实现
    @abstractmethod
    def refund(self,amount):
        pass

# 物流接口，需要子类实现。
class ShipingService(ABC):

    @abstractmethod
    def ship(self):
        # 发货方法。
        pass

    @abstractmethod
    def track_package(self):
        # 追踪包裹方法。
        pass

# 实现支付接口
class Alipay(PaymantMathd):

    def process_payment(self,amount):
        print(f"请支付，因为扫描二维码，支付 {amount} 元")
        return f"支付成功，支付 {amount}"

    def refund(self,amount):
        print(f"退款中，原路返回 {amount} 元")

class CreateCard(PaymantMathd):

    def process_payment(self,amount):
        print(F"信用卡支付，支付 {amount} 元")
        return f"支付成功，支付 {amount} 元"

    def refund(self,amount):
        print(f"退款中，原路返回 {amount} 元")

# 使用接口，不关心具体实现方法。
def checkout(payment_Mathed:PaymantMathd,amount):
    return payment_Mathed.process_payment(amount)

alipay = Alipay()
card = CreateCard()

checkout(alipay,10) # 输出：请支付，因为扫描二维码，支付 10 元

checkout(card,30) # 输出：信用卡支付，支付 30 元

# 我们先创建一个示例类
class Car:
    def __init__(self, brand, model, year):
        self.brand = brand
        self.model = model 
        self.year = year
        self.__serial_number = "ABC123"  # 私有属性
  
    def start_engine(self):
        print(f"{self.brand} {self.model}引擎启动！")
  
    def drive(self, distance):
        print(f"行驶了{distance}公里")

# 创建对象
my_car = Car("Tesla", "Model 3", 2023)

# 使用 type() 方法查看对象类型
# 类示例
print(type(my_car)) # 输出：<class '__main__.Car'>
# 布尔类型
print(type(True)) # 输出：<class 'bool'>

# 使用 isinstance() 方法判断对是否属于某个类型，也可用户判断继承。
print(isinstance(my_car, Car))  # 输出: True
print(isinstance(my_car, object))   # 输出：True (所有对象都继承自 object )
print(isinstance(my_car, int))  # 输出：False
print(isinstance(my_car, (Car,str,int))) # 输出 True （只要包含其中一个就返回 True）

# 查看对象所有可用的属性或者方法：
print(dir(my_car))
# 输出：['_Car__serial_number', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'brand', 'drive', 'model', 'start_engine', 'year']
# 查看仅字节有的属性和方法
print([ atter for  atter in dir(my_car) if not atter.startswith("__")])
# 输出：['_Car__serial_number', 'brand', 'drive', 'model', 'start_engine', 'year']

# 使用 hasattr() 查看是否有属性或者方法
print(hasattr(my_car,"brand"))  #  输出：True
print(hasattr(my_car,"color"))  #  输出：False
print(hasattr(my_car,"start_engine"))   # 输出：True 

# getattr() 获取对象属性 安全方式
brand = getattr(my_car,"brand")
print(brand) # 输出：Tesla

# 获取不存在的 属性
color = getattr(my_car,"color","unknown")
print(color) # 输出：unknown 

# 相当于：
# if hasattr(my_car, 'color'):
#     color = my_car.color
# else:
#     color = 'unknown'

# 使用 `setattr()` 函数，动态设置对象属性。
print(hasattr(my_car,"color")) # 输出: True
setattr(my_car,"color","red")
print(getattr(my_car,"color")) # 输出： red
print(hasattr(my_car,"color")) # 输出：True

# 修改已有的属性
setattr(my_car,"brand","Mac")
print(getattr(my_car,"brand")) # 输出：Mac

# 使用 callable() 函数查看对象可调用。
print(callable(my_car.brand)) # 输出：False  属性不可调用
print(callable(my_car.start_engine)) # 输出：True,属性方法可调用
print(callable(Car)) # 类可调用。

# __clss__ 和 __name__ 方法，查看对象所属类
print(my_car.__class__) # 输出：<class '__main__.Car'>
print(my_car.__class__.__name__) # 输出：Car

# 获取类的父类
print(Car.__bases__) # 输出：(<class 'object'>,)

# 获取方法解析顺序（MRO）
print(Car.__mro__) # 输出：(<class 'object'>,)

# 查看对象的所有实例属性.
print(my_car.__dict__)
# 输出：{'brand': 'Mac', 'model': 'Model 3', 'year': 2023, '_Car__serial_number': 'ABC123', 'color': 'red'}
# 查看类的属性：
print(my_car.__dict__.keys())
# 输出：dict_keys(['brand', 'model', 'year', '_Car__serial_number', 'color'])

# 查看函数的具体参数：
def calculate_price(car, tax_rate=0.1, discount=0):
    """计算汽车价格"""
    base_price = 30000
    return base_price * (1 + tax_rate - discount)

print(calculate_price.__name__) # 输出：calculate_price
print(calculate_price.__doc__) # 输出：计算汽车价格
print(calculate_price.__module__) # 输出：__main__

# 查看参数值
import inspect

sig = inspect.signature(calculate_price)
print(sig)  # 输出：(car, tax_rate=0.1, discount=0)

# 查看参数写。
params = inspect.signature(calculate_price).parameters
for name,params in params.items():
    print(f"{name}:{params.default}")
    # 输出：
    # car:<class 'inspect._empty'>
    # tax_rate:0.1
    # discount:0