## 不使用对象的方式
hero_work = 'soldier'
hero_name = '盖伦'
hero_atk = 165
hero_speed = 475

def hero_info():
    print(f'我的名字是{hero_name},职业是{hero_work},攻击力是{hero_atk},移动速度是{hero_speed}')

def hero_atk_up(atk):
    global hero_atk
    hero_atk += atk

## 第二个英雄
hero_work2 = 'ADC'
hero_name2 = '后裔'
hero_atk2 = 150
hero_speed2 = 450

def hero_info2():
    print(f'我的名字是{hero_name2},职业是{hero_work2},攻击力是{hero_atk2},移动速度是{hero_speed2}')

def hero_atk_up2(atk):
    global hero_atk2
    hero_atk2 += atk

def hero_info(hero_obj):
    print(f'我的名字是{hero_obj["name"]},职业是{hero_obj["work"]},攻击力是{hero_obj["atk"]}'
          f',移动速度是{hero_obj["speed"]}')

def hero_atk_up(hero_obj, atk):
   hero_obj["atk"] += atk

hero_obj = {
    'name': '盖伦',
    'work': 'soldier',
    'atk': 165,
    'speed': 475,
    'info': hero_info,
    'atk_up': hero_atk_up
}

class Hero:
    work = 'ADC'
    def hero_info(hero_obj):
        print(f'我的名字是{hero_obj["name"]},职业是{hero_obj["work"]},攻击力是{hero_obj["atk"]}'
              f',移动速度是{hero_obj["speed"]}')

    def hero_atk_up(hero_obj,atk):
       hero_obj["atk"] += atk
    print('xxx') # 在程序运行时，类的子代码会被运行，也就代表类在定义阶段就已经创建好了名称空间
# 在python里面类的名称空间中，会默认创建一个__dict__的字典属性
print('='*50)
print(Hero.__dict__)
print('='*50)
# {'__module__': '__main__', 'work': 'ADC', 'hero_info': <function Hero.hero_info at 0x00000226DA7B8C10>, 'hero_atk_up': <function Hero.hero_atk_up at 0x00000226DA7B9820>, '__dict__': <attribute '__dict__' of 'Hero' objects>, '__weakref__': <attribute '__weakref__' of 'Hero' objects>, '__doc__': None}
# 所以想要拿到类的属性，实际上访问的是类名称空间中的__dict__字典属性
print(Hero.__dict__['work']) # ADC
print('='*50)

# python提供了一个更简便的语法，也就是通过类名.属性名来访问的
print(Hero.work) # ADC
print('='*50)
# 每次调用一个类就会产生一个对象，此时这个对象里面的Dict是空的，需要添加值
hero_obj = Hero()
hero_obj2 = Hero()
hero_obj3 = Hero()
print(hero_obj.__dict__) # {}
print('='*50)
print(hero_obj2.__dict__) # {}
print('='*50)
print(hero_obj3.__dict__) # {}
print('='*50)
# 给对象添加属性
hero_obj.__dict__['name'] = '亚瑟'
hero_obj.__dict__['work'] = 'tank'
hero_obj.__dict__['atk'] = 100
hero_obj.__dict__['speed'] = 300
# 可是通过这种方式过于复杂，python也提供了简便的语法
hero_obj2.name = '妲己'
hero_obj2.work = 'mage'
hero_obj2.atk = 120
hero_obj2.speed = 350

hero_obj3.name = '后裔'
hero_obj3.work = 'ADC'
hero_obj3.atk = 150
hero_obj3.speed = 450


print(hero_obj.__dict__) # {'name': '亚瑟', 'work': 'tank', 'atk': 100, 'speed': 300}
print('='*50)
print(hero_obj2.__dict__) # {'name': '妲己', 'work': 'mage', 'atk': 120, 'speed': 350}
print('='*50)
print(hero_obj3.__dict__) # {'name': '后裔', 'work': 'ADC', 'atk': 150, 'speed': 450}
print('='*50)

class Hero:
    work = 'ADC'
    def hero_info(hero_obj):
        print(f'我的名字是{hero_obj["name"]},职业是{hero_obj["work"]},攻击力是{hero_obj["atk"]}'
              f',移动速度是{hero_obj["speed"]}')

    def hero_atk_up(hero_obj,atk):
       hero_obj["atk"] += atk
    print('xxx') # 在程序运行时，类的子代码会被运行，也就代表类在定义阶段就已经创建好了名称空间

hero1_obj = Hero()
hero2_obj = Hero()
hero3_obj = Hero()
def init(hero_obj,name,work,atk,speed):
    hero_obj.name = name
    hero_obj.work = work
    hero_obj.atk = atk
    hero_obj.speed = speed

init(hero1_obj,'后裔','ADC',150,450)
init(hero2_obj,'程咬金','ADC',150,450)
init(hero3_obj,'妲己','ADC',150,450)

print(hero1_obj.__dict__) # {'name': '后裔', 'work': 'ADC', 'atk': 150, 'speed': 450}
print(hero2_obj.__dict__) # {'name': '程咬金', 'work': 'ADC', 'atk': 150, 'speed': 450}
print(hero3_obj.__dict__) # {'name': '妲己', 'work': 'ADC', 'atk': 150, 'speed': 450}

class Hero:
    work = 'ADC'

    def __init__(hero_obj, name, work, atk, speed):
        hero_obj.name = name
        hero_obj.work = work
        hero_obj.atk = atk
        hero_obj.speed = speed

    def hero_info(hero_obj):
        print(f'我的名字是{hero_obj.__dict__["name"]},职业是{hero_obj.__dict__["work"]},攻击力是{hero_obj.__dict__["atk"]}'
              f',移动速度是{hero_obj.__dict__["speed"]}')

    def hero_atk_up(hero_obj,atk):
       hero_obj.__dict__["atk"] += atk
    print('xxx') # 在程序运行时，类的子代码会被运行，也就代表类在定义阶段就已经创建好了名称空间


# 在我们调用类自动创建对象的时候,python内部会自动调用类下面的__init__方法并传入一个空对象，所以在实际传值时仅需要传入四个参数即可
hero1_obj = Hero('后裔','ADC',150,450) # Hero.__init__(空对象,name,work,atk,speed)
hero2_obj = Hero('程咬金','ADC',150,450)
hero3_obj = Hero('妲己','ADC',150,450)

print(hero1_obj.__dict__) # {'name': '后裔', 'work': 'ADC', 'atk': 150, 'speed': 450}
print(hero2_obj.__dict__) # {'name': '程咬金', 'work': 'ADC', 'atk': 150, 'speed': 450}
print(hero3_obj.__dict__) # {'name': '妲己', 'work': 'ADC', 'atk': 150, 'speed': 450}

hero1_obj.hero_info() # 我的名字是后裔,职业是ADC,攻击力是150,移动速度是450
hero2_obj.hero_info() # 我的名字是程咬金,职业是ADC,攻击力是150,移动速度是450
hero3_obj.hero_info() # 我的名字是妲己,职业是ADC,攻击力是150,移动速度是450

class Hero:
    work = 'ADC'

    def __init__(hero_obj, name, work, atk, speed):
        hero_obj.name = name
        hero_obj.work = work
        hero_obj.atk = atk
        hero_obj.speed = speed

    def hero_info(hero_obj):
        print(f'我的名字是{hero_obj.name},职业是{hero_obj.work},攻击力是{hero_obj.atk}'
              f',移动速度是{hero_obj.speed}')

    def hero_atk_up(hero_obj,atk):
       hero_obj.atk += atk
    print('xxx') # 在程序运行时，类的子代码会被运行，也就代表类在定义阶段就已经创建好了名称空间


# 在我们调用类自动创建对象的时候,python内部会自动调用类下面的__init__方法并传入一个空对象，所以在实际传值时仅需要传入四个参数即可
hero1_obj = Hero('后裔','ADC',150,450) # Hero.__init__(空对象,name,work,atk,speed)
hero2_obj = Hero('程咬金','ADC',150,450)
hero3_obj = Hero('妲己','ADC',150,450)



# 绑定方法
print(Hero.hero_info) # <function Hero.hero_info at 0x0000019021E39820>
print(hero1_obj.hero_info)
# <bound method Hero.hero_info of <__main__.Hero object at 0x0000019021F13BE0>>
print(hero2_obj.hero_info)
# <bound method Hero.hero_info of <__main__.Hero object at 0x0000019021F13DC0>>
print(hero3_obj.hero_info)
# <bound method Hero.hero_info of <__main__.Hero object at 0x0000019021F4F940>>

hero1_obj.hero_atk_up(50000)
hero1_obj.hero_info()
hero2_obj.hero_info()
hero3_obj.hero_info()

# 三个内存地址不一样并不代表代码就存了三份，代码本身只存了一份，因为类的作用就是为了减少计算机资源的浪费
# 可以理解为类的属性绑定给对象之后，这个函数的内存地址，就会被包装成一个绑定方法，或者也可以理解为
# 是一个装饰器，当通过对象访问这些函数的时候，访问的也是这个绑定方法的内存地址，而他在给函数传入值时
# 也会像init方法一样自动传入一个对象进去

class Hero:
    work = 'ADC'

    def __init__(self, name, work, atk, speed):
        self.name = name
        self.work = work
        self.atk = atk
        self.speed = speed
        self.equipment = []

    def hero_info(self):
        print(f'我的名字是{self.name},职业是{self.work},攻击力是{self.atk}'
              f',移动速度是{self.speed}')

    def hero_atk_up(self,atk):
       self.atk += atk


    def buy_equipment(self,equipment):
        self.equipment.append(equipment)
        print(f'{self.name}购买了{equipment}')


hero1_obj = Hero('后裔','ADC',150,450)
hero2_obj = Hero('程咬金','ADC',150,450)
hero3_obj = Hero('妲己','ADC',150,450)


hero1_obj.buy_equipment('屠龙宝刀966666')
hero2_obj.buy_equipment('屠龙宝刀966666')
print(hero3_obj.equipment) # []

class Hero:
    def __init__(self, name, work, atk, speed):
        self.name = name
         self.work = work
        self.__atk = atk  # 私有属性
        self.speed = speed
        
    def __buy_equipment(self, equipment):  # 私有方法
        print(f'{self.name}购买了{equipment}')
        
hero = Hero('后裔', 'ADC', 150, 450)
## print(hero.__atk)  # AttributeError: 'Hero' object has no attribute '__atk'
## hero.__buy_equipment('无尽战刃')  # AttributeError

## 但这只是名称修饰，仍然可以通过修饰后的名称访问
print(hero._Hero__atk)  # 150
hero._Hero__buy_equipment('无尽战刃')  # 后裔购买了无尽战刃

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

    def get_name(self):
        return self.__name

    def get_age(self):
        return self.__age

    def set_age(self, age):
        if not isinstance(age, int):
            print('年龄必须为整数')
            return
        self.__age = age
    # 相当于Java的toString()方法
    def __str__(self):
        return 'Person(name={}, age={})'.format(self.__name, self.__age)

p = Person('Alice', 25)
print(p.get_name()) # Alice
print(p.get_age()) # 25
p.set_age(30)  # 设置年龄为 30
print(p.get_age()) # 30

# 这段代码展示了Python中的属性装饰器(@property)的使用，它有以下意义：
# 1. 封装性：通过私有变量(__age)和属性装饰器，实现了对数据的封装和保护
# 2. 数据验证：在setter方法中可以对输入数据进行验证，确保数据的有效性
# 3. 接口一致性：虽然内部使用了方法，但对外提供了类似直接访问属性的简洁接口
# 4. 控制访问：可以分别控制属性的读取、修改和删除行为

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

    @property
    def age(self):
        """获取年龄"""
        return self.__age

    @age.setter
    def age(self, age):
        """设置年龄"""
        if not isinstance(age, int):
            print('年龄必须为整数')
            return
        self.__age = age

    @age.deleter
    def age(self):
        """删除年龄属性"""
        del self.__age


person = Person(25)
print(person.age)  # 使用getter
person.age = 30  # 使用setter
del person.age  # 使用deleter

class Animal:
    def eat(self):
        print("吃")

class Dog(Animal):  # 单继承
    def bark(self):
        print("汪汪叫")
        
class Bird(Animal):
    def fly(self):
        print("飞翔")
        
class FlyingDog(Dog, Bird):  # 多继承
    pass
    
dog = Dog()
dog.eat()  # 吃 (继承自Animal)
dog.bark()  # 汪汪叫

flying_dog = FlyingDog()
flying_dog.eat()    # 吃 (继承自Animal)
flying_dog.bark()   # 汪汪叫 (继承自Dog)
flying_dog.fly()    # 飞翔 (继承自Bird)

## 查看继承关系
print(Dog.__bases__)  # (<class '__main__.Animal'>,)
print(FlyingDog.__bases__)  # (<class '__main__.Dog'>, <class '__main__.Bird'>)

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

    def info(self):
        print(f"我是{self.name}，今年{self.age}岁了")




class Dog(Animal):
    def __init__(self,name,age,breed):
        super().__init__(name,age)
        self.breed = breed


    def info(self):
        super().info() # 这里调用父类的info方法
        print(f"我是{self.name}，我今年{self.age}岁了，我是属于{self.breed}品种的狗")

dog = Dog("旺财",2,"哈士奇")
dog.info()
# 输出：
# 我是旺财，今年2岁了 # 调用了父类的info方法
# 我是旺财，我今年2岁了，我是属于哈士奇品种的狗 # 重写了父类的info方法

class BaseClass:
    def display_info(self):
        print("基类的Info方法")
        
class FirstChild(BaseClass):
    def display_info(self):
        print("第一个子类的info方法")
        
class SecondChild(BaseClass):
    def display_info(self):
        print("第二个子类的info方法")
        
class MultipleInheritance(FirstChild, SecondChild):
    pass
    
print(MultipleInheritance.mro())
## 输出: [<class '__main__.MultipleInheritance'>, <class '__main__.FirstChild'>, <class '__main__.SecondChild'>, <class '__main__.BaseClass'>, <class 'object'>]
# 先是自己=>再是第一个传入的类，第二个传入的类，最后是基类，最后是object
instance = MultipleInheritance()
instance.display_info()  # FirstChild.display_info (按MRO顺序查找)

class Animal:
    def make_sound(self):
        print("Animal.make_sound")
        
class Dog(Animal):
    def make_sound(self):
        print("Dog.make_sound")
        super().make_sound()
        
class Cat(Animal):
    def make_sound(self):
        print("Cat.make_sound")
        super().make_sound()
        
class CatDog(Dog, Cat):
    def make_sound(self):
        print("CatDog.make_sound")
        super().make_sound()
        
# 菱形继承结构:
#       Animal
#      /      \
#    Dog      Cat
#      \      /
#       CatDog

catdog = CatDog()
catdog.make_sound()
## 输出:
## CatDog.make_sound
## Dog.make_sound
## Cat.make_sound
## Animal.make_sound

class SwimMixin:
    def swim(self):
        print("I can swim")
        
class FlyMixin:
    def fly(self):
        print("I can fly")
        
class Animal:
    def eat(self):
        print("I can eat")
        
class Duck(Animal, SwimMixin, FlyMixin):
    pass
    
duck = Duck()
duck.eat()   # I can eat
duck.swim()  # I can swim
duck.fly()   # I can fly

class Car:
    def run(self):
        print('开始跑', end=' ')

class Benz(Car):
    def run(self):
        super().run()
        print('奔驰跑起来好快哦!')

class BMW(Car):
    def run(self):
        super().run()
        print('宝马跑起来好稳哦!')

class Auto(Car):
    def run(self):
        super().run()
        print('奥拓跑起来好省油哦!')

## 多态性示例
cars = [Benz(), BMW(), Auto()]
for car in cars:
    car.run()  # 同一方法调用，不同行为

class Duck:
    def quack(self):
        print("呱呱呱!")
    def swim(self):
        print("鸭子游泳!")

class Person:
    def quack(self):
        print("人类模仿鸭叫!")
    def swim(self):
        print("人类游泳!")

def make_it_quack_and_swim(thing):
    thing.quack()
    thing.swim()

duck = Duck()
person = Person()

make_it_quack_and_swim(duck)
make_it_quack_and_swim(person)  # 人类没有继承Duck类，但可以表现得像鸭子

import abc

class Car(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def run(self):
        pass
        
    @abc.abstractmethod
    def stop(self):
        pass
        
class Benz(Car):
    def run(self):
        print("奔驰开始跑")
        
    def stop(self):
        print("奔驰停止")
        
## benz = Benz()  # 如果没有实现所有抽象方法，会抛出TypeError

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

    def greet(self):
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")

# 创建实例并调用实例方法
person = Person("Alice", 30)
person.greet()  # 输出：Hello, my name is Alice and I am 30 years old.

class DataBase:
    IP = "127.0.0.1"
    PORT = 8080

    def __init__(self, ip, port):
        self.ip = ip
        self.port = port

    def connect(self):
        print(f"连接数据库成功！IP地址：{self.ip}, 端口号：{self.port}")

    @classmethod
    def instance_from_setting(cls):
        # 从配置文件（如setting模块）或环境变量中读取IP和PORT并实例化对象
        obj = cls(cls.IP, cls.PORT)
        return obj

# 使用类方法来创建实例
db = DataBase.instance_from_setting()  
print(db.__dict__)  # 输出：{'ip': '127.0.0.1', 'port': 8080}
db.connect()  # 输出：连接数据库成功！IP地址：127.0.0.1, 端口号：8080

class MathTools:
    
    @staticmethod
    def add(a, b):
        return a + b
    
    @staticmethod
    def multiply(a, b):
        return a * b

# 调用静态方法，无需实例化类
print(MathTools.add(5, 3))  # 输出：8
print(MathTools.multiply(4, 2))  # 输出：8

if hasattr(p, 'name'):  # 检查 Person 对象是否有 'name' 属性
    print(getattr(p, 'name'))  # 输出: Alice

name = getattr(p, 'name')  # 获取属性 'name' 的值
print(name)  # 输出: Alice

# 如果属性不存在，使用默认值
age = getattr(p, 'age', 0)  # 属性 'age' 存在，返回 30
print(age)  # 输出: 30

setattr(p, 'city', 'New York')  # 动态设置新的属性 'city'
print(p.city)  # 输出: New York

delattr(p, 'city')  # 删除属性 'city'
# print(p.city)  # 会抛出 AttributeError: 'Person' object has no attribute 'city'

print(dir(p))  # 列出 Person 对象的所有属性

print(type(p))  # 输出: <class '__main__.Person'>

if isinstance(p, Person):  # 检查 p 是否是 Person 类的实例
    print("p 是 Person 类的实例")  # 输出: p 是 Person 类的实例

class Animal:
    pass

class Dog(Animal):
    pass

print(issubclass(Dog, Animal))  # 输出: True

def greet():
    return "Hello"

print(callable(greet))  # 输出: True
print(callable(p))      # 输出: False，因为 Person 对象不可调用

print(vars(p))  # 输出: {'name': 'Alice', 'age': 30}

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        
    def greet(self):
        return f"Hello, I'm {self.name}"
        
p = Person("Alice", 30)

## 检查和获取属性
if hasattr(p, 'name'):  # 检查 p 对象是否有 'name' 属性
    name = getattr(p, 'name')  # 获取 'name' 属性的值
    print(name)  # 输出: Alice
    
## 设置新属性
setattr(p, 'city', 'New York')  # 动态为 p 对象设置 'city' 属性
print(p.city)  # 输出: New York

## 删除属性
delattr(p, 'city')  # 删除 'city' 属性
# print(p.city)  # 如果取消注释，会抛出 AttributeError: 'Person' object has no attribute 'city'

## 动态调用方法
if hasattr(p, 'greet') and callable(getattr(p, 'greet')):  # 检查 greet 方法是否可调用
    method = getattr(p, 'greet')  # 获取 greet 方法
    print(method())  # 输出: Hello, I'm Alice

## 获取所有属性
print(dir(p))  # 输出：['name', 'age', 'greet', ...]，列出所有属性和方法

## 通过字符串获取类
class_name = 'Person'
if class_name in globals():  # 检查 Person 类是否在全局命名空间中
    cls = globals()[class_name]  # 动态获取 Person 类
    new_person = cls('Bob', 25)  # 使用动态获取的类实例化对象
    print(new_person.name)  # 输出: Bob

from print_utils import *
from enum import Enum, IntEnum, Flag, auto, unique
from typing import Any # 用于类型注解

## =============================================================
## 0. enum 模块演示准备
## =============================================================
print_header("enum 模块功能演示")

## =============================================================
## 1. 基本枚举 (Enum)
## =============================================================
print_subheader("1. 基本枚举 (Enum)")

class Color(Enum):
    RED = 1
    GREEN = 2
    BLUE = 3
#    # YELLOW = 1 # 如果没有 @unique，这不会报错，但可能不是期望的行为
    
print_info(f"枚举成员 Color.RED: {Color.RED}")
print_info(f"  Color.RED 的名称 (name): '{Color.RED.name}'")
print_info(f"  Color.RED 的值 (value): {Color.RED.value}")
print_info(f"  通过值获取成员 Color(2): {Color(2)}")
print_info(f"  通过名称获取成员 Color['GREEN']: {Color['GREEN']}")
print_info(f"  Color.RED is Color.GREEN: {Color.RED is Color.GREEN}")
print_info(f"  Color.RED == Color(1): {Color.RED == Color(1)}")
print_info(f"  遍历枚举 Color:")
for color_member in Color:
    print(f"    - {color_member.name} -> {color_member.value}")

## =============================================================
## 2. 使用 auto() 自动分配值 和 @unique 确保值唯一
## =============================================================
print_subheader("2. 使用 auto() 和 @unique")

@unique # 确保枚举成员的值是唯一的
class Weekday(Enum):
    MONDAY = auto()    # 值通常从 1 开始递增
    TUESDAY = auto()
    WEDNESDAY = auto()
    THURSDAY = auto()
    FRIDAY = auto()
    SATURDAY = auto()
    SUNDAY = auto()

print_info("使用 auto() 和 @unique 的 Weekday 枚举:")
for day in Weekday:
    print(f"  - {day.name}: {day.value}")

print_info(f"Weekday['MONDAY'].value: {Weekday.MONDAY.value}")


## =============================================================
## 3. 整数枚举 (IntEnum)
## =============================================================
print_subheader("3. 整数枚举 (IntEnum)")
class ErrorCode(IntEnum): # 成员可以直接与整数比较
    OK = 0
    NOT_FOUND = 404
    SERVER_ERROR = 500

print_info(f"ErrorCode.NOT_FOUND: {ErrorCode.NOT_FOUND}")
print_info(f"  ErrorCode.NOT_FOUND == 404: {ErrorCode.NOT_FOUND == 404}") # True
print_info(f"  ErrorCode.OK < ErrorCode.SERVER_ERROR: {ErrorCode.OK < ErrorCode.SERVER_ERROR}") # True
print_info(f"  int(ErrorCode.SERVER_ERROR): {int(ErrorCode.SERVER_ERROR)}") # 500

## =============================================================
## 4. 标志枚举 (Flag 和 IntFlag) - 支持位运算
## =============================================================
print_subheader("4. 标志枚举 (Flag 和 IntFlag)")

class Permissions(Flag): # Flag 成员的值通常是 2 的幂
    NONE = 0 # 通常定义一个 "无" 或 "空" 标志
    READ = auto()    # 1
    WRITE = auto()   # 2
    EXECUTE = auto() # 4
    READ_WRITE = READ | WRITE # 组合标志
    ALL = READ | WRITE | EXECUTE

user1_perms: Permissions = Permissions.READ | Permissions.WRITE
user2_perms: Permissions = Permissions.READ
admin_perms: Permissions = Permissions.ALL

print_info(f"User1 权限 (READ | WRITE): {user1_perms} (值为: {user1_perms.value})")
print_info(f"  User1 是否有 READ 权限: {Permissions.READ in user1_perms}")   # True
print_info(f"  User1 是否有 EXECUTE 权限: {Permissions.EXECUTE in user1_perms}") # False
print_info(f"  User1 是否只有 READ_WRITE 权限: {user1_perms == Permissions.READ_WRITE}") # True

print_info(f"Admin 权限 (ALL): {admin_perms} (值为: {admin_perms.value})")
print_info(f"  Admin 是否包含所有权限 (READ|WRITE|EXECUTE): {admin_perms == (Permissions.READ | Permissions.WRITE | Permissions.EXECUTE)}")

## IntFlag 类似，但其成员也是整数
class FileAccess(IntFlag):
    R_OK = os.R_OK # 使用 os 模块的常量 (通常是 4)
    W_OK = os.W_OK # (通常是 2)
    X_OK = os.X_OK # (通常是 1)
    RW_OK = R_OK | W_OK

file_mode: FileAccess = FileAccess.R_OK | FileAccess.W_OK
print_info(f"\nFileAccess 模式 (R_OK | W_OK): {file_mode} (值为: {file_mode.value})")
print_info(f"  文件是否可读 (R_OK in file_mode): {FileAccess.R_OK in file_mode}")

from print_utils import * # 假设 print_utils.py 可用
from abc import ABC, abstractmethod, abstractproperty # Python 3.3+ for abstractproperty
from typing import Tuple, Type, Any # 用于类型注解

## =============================================================
## 0. abc 模块演示准备
## =============================================================
print_header("abc 模块 (抽象基类) 功能演示")

## =============================================================
## 1. 定义一个抽象基类 Shape
## =============================================================
print_subheader("1. 定义抽象基类 Shape")

class Shape(ABC): # 继承自 ABC，表明这是一个抽象基类
    """一个表示几何形状的抽象基类。"""

    @abstractmethod # 标记 area() 为抽象方法
    def area(self) -> float:
        """计算并返回形状的面积。子类必须实现此方法。"""
        pass # 抽象方法通常只有 pass 或 raise NotImplementedError()

    @abstractmethod # 标记 perimeter() 为抽象方法
    def perimeter(self) -> float:
        """计算并返回形状的周长。子类必须实现此方法。"""
        raise NotImplementedError("子类必须实现 perimeter 方法")

    @abstractproperty # Python 3.3+ (旧版本用 @property + @abstractmethod)
    def shape_type(self) -> str:
        """返回形状的类型名称 (例如 'Circle', 'Rectangle')。子类必须实现此属性。"""
        pass
        
#    # 这是一个具体方法，子类可以直接继承或重写
    def describe(self) -> str:
        """返回对形状的描述。"""
        return f"这是一个 '{self.shape_type}'，面积为 {self.area():.2f}，周长为 {self.perimeter():.2f}。"

print_info("抽象基类 Shape 已定义。")

## 尝试实例化抽象基类 (会失败)
try:
    s = Shape()
    print_error("错误：抽象基类 Shape 被实例化了！(不应发生)")
except TypeError as e:
    print_success(f"尝试实例化 Shape 时捕获到预期的 TypeError: {e}")


## =============================================================
## 2. 创建具体子类 Circle 和 Rectangle
## =============================================================
print_subheader("2. 创建具体子类 Circle 和 Rectangle")

class Circle(Shape):
    """表示圆形的具体类。"""
    PI: float = 3.1415926535

    def __init__(self, radius: float):
        if radius <= 0:
            raise ValueError("半径必须为正数。")
        self._radius: float = radius

    def area(self) -> float: # 实现抽象方法
        return self.PI * (self._radius ** 2)

    def perimeter(self) -> float: # 实现抽象方法
        return 2 * self.PI * self._radius

    @property # 实现抽象属性
    def shape_type(self) -> str:
        return "圆形"

class Rectangle(Shape):
    """表示矩形的具体类。"""
    def __init__(self, width: float, height: float):
        if width <= 0 or height <= 0:
            raise ValueError("宽度和高度必须为正数。")
        self._width: float = width
        self._height: float = height

    def area(self) -> float:
        return self._width * self._height

    def perimeter(self) -> float:
        return 2 * (self._width + self._height)
    
    @property
    def shape_type(self) -> str:
        return "矩形"

print_info("具体子类 Circle 和 Rectangle 已定义。")

## 实例化具体子类
circle_instance = Circle(radius=5.0)
rectangle_instance = Rectangle(width=4.0, height=6.0)

print_success(f"圆的描述: {circle_instance.describe()}")
print_success(f"矩形的描述: {rectangle_instance.describe()}")

## =============================================================
## 3. 演示未完全实现抽象方法的子类
## =============================================================
print_subheader("3. 演示未完全实现抽象方法的子类")
class IncompleteSquare(Shape): # Square 应该也实现 perimeter 和 shape_type
    def __init__(self, side: float):
        self._side: float = side
    
    def area(self) -> float:
        return self._side ** 2
    
#    # 故意不实现 perimeter 和 shape_type
#    # @property
#    # def shape_type(self) -> str:
#    #     return "不完整的正方形"

print_info("定义了一个未完全实现抽象方法的 IncompleteSquare 类。")
try:
    incomplete_sq = IncompleteSquare(side=3)
    print_error("错误：不完整的抽象子类 IncompleteSquare 被实例化了！(不应发生)")
#    # incomplete_sq.describe() # 如果能实例化，这里调用 perimeter() 会出错
except TypeError as e:
    print_success(f"尝试实例化 IncompleteSquare 时捕获到预期的 TypeError: {e}")


if __name__ == '__main__':
    pass # 演示已在各节内进行
print_header("abc 模块演示结束。")

# 1.定义类名
class_name = "Human"

#2.定义基类
class_bases = (object,)

# 3.执行子类代码，产生名称空间
class_dic = {}
class_body = """
def __init__(self, name, age):
    self.name = name
    self.age = age

def say_hello(self):
    print(f"你好，我是{self.name}，今年{self.age}岁")
"""
# exec函数语法：exec(object[, globals[, locals]])
# object: 要执行的Python代码字符串或代码对象
# globals: 可选参数，指定代码执行时的全局命名空间，默认为当前全局命名空间
# locals: 可选参数，指定代码执行时的局部命名空间，默认与globals相同

# 这里传入三个参数：
# 1. class_body: 包含类方法定义的Python代码字符串
# 2. {}: 空字典作为全局命名空间，避免访问外部全局变量
# 3. class_dic: 作为局部命名空间，执行后class_body中定义的方法会存储在这个字典中

# 这样做的目的是隔离执行环境，并将执行结果(类的方法定义)收集到class_dic字典中，
# 之后可以将这个字典传给type函数来动态创建类
exec(class_body, {}, class_dic)

# 4.调用原类
Human = type(class_name,class_bases,class_dic)


# 5. 创建实例对象
person = Human("张三", 25)
# 6. 调用实例方法
person.say_hello() # 你好，我是张三，今年25岁

class MyType(type):
    def __init__(self, class_name, class_bases, class_attrs):
        if "_" in class_name:
            raise NameError("类名不能包含下划线")

        if not class_attrs.get("__doc__"):
            raise ValueError("类必须有文档注释")
        
        # 检查类属性名是否符合规范
        for attr_name in class_attrs:
            if attr_name.startswith("__") and attr_name.endswith("__"):
                continue
            if not attr_name.islower():
                raise NameError("属性名必须全部小写")
        
        # 检查是否有必要的方法
        if "info" not in class_attrs:
            raise ValueError("类必须实现info方法")
        
        # 检查类的基类
        if not class_bases:
            raise TypeError("类必须继承至少一个父类")



class Human(object, metaclass=MyType):
    """人类的基本信息类，如果没有这个注释会报错"""
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def info(self):
        print(f"name:{self.name},age:{self.age}")

class MyType(type):
    def __init__(self, class_name, class_bases, class_attrs):
        print(self.__bases__) # (<class 'object'>,)
        # 检查类的基类
        if not class_bases:
            raise TypeError("类必须继承至少一个父类")




class Human(metaclass=MyType):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def info(self):
        print(f"name:{self.name},age:{self.age}")

class MyType(type):
    def __init__(self, class_name, class_bases, class_attrs):
        print(self.__bases__)  # (<class 'object'>,)
        # 检查类的基类
        if not class_bases:
            raise TypeError("类必须继承至少一个父类")

    def __new__(cls, *args, **kwargs):
        print("cls==========>", cls) # <class '__main__.MyType'>
        print("args=========>", args)  # ('Human', (), {'__module__': '__main__', '__qualname__': 'Human', '__init__': <function Human.__init__ at 0x000001D726C02CA0>, 'info': <function Human.info at 0x000001D726B9BEE0>})
        print("kwargs=========>", kwargs)  # {}
        return super().__new__(cls, *args, **kwargs) # 通过调用父类的__new__方法,他会在底层帮我们继承object对象,存放__()__属性等


class Human(metaclass=MyType):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def info(self):
        print(f"name:{self.name},age:{self.age}")

class SingletonMeta(type):
    _instances = {}
    
    def __call__(cls, *args, **kwargs):
        """控制类实例化过程"""
        if cls not in cls._instances:
            print(f"创建 {cls.__name__} 的新实例")
            # 正常的实例化过程：创建实例并初始化
            instance = super().__call__(*args, **kwargs)
            cls._instances[cls] = instance
        else:
            print(f"返回 {cls.__name__} 的现有实例")
        return cls._instances[cls]
        
class Database(metaclass=SingletonMeta):
    def __init__(self, host, port):
        self.host = host
        self.port = port
        
## 第一次调用，创建新实例
db1 = Database("localhost", 5432)
print(f"DB1: {db1.host}:{db1.port}")

## 第二次调用，返回现有实例
db2 = Database("example.com", 8080)  # 参数被忽略！
print(f"DB2: {db2.host}:{db2.port}")  # 仍然是localhost:5432

## 验证是同一个实例
print(db1 is db2)  # True

class TraceMeta(type):
    def __new__(mcs, name, bases, attrs):
        print(f"[元类__new__] 创建类 {name}")
        return super().__new__(mcs, name, bases, attrs)
        
    def __init__(cls, name, bases, attrs):
        print(f"[元类__init__] 初始化类 {name}")
        super().__init__(name, bases, attrs)
        
    def __call__(cls, *args, **kwargs):
        print(f"[元类__call__] 调用类 {cls.__name__}")
        
        # 1. 创建实例（调用类的__new__）
        instance = cls.__new__(cls, *args, **kwargs)
        
        # 2. 初始化实例（调用类的__init__）
        if isinstance(instance, cls):
            print(f"[元类__call__] 初始化 {cls.__name__} 实例")
            cls.__init__(instance, *args, **kwargs)
            
        return instance
        
class MyClass(metaclass=TraceMeta):
    def __new__(cls, *args, **kwargs):
        print(f"[类__new__] 创建 {cls.__name__} 实例")
        return super().__new__(cls)
        
    def __init__(self, x=None):
        print(f"[类__init__] 初始化 {self.__class__.__name__} 实例，x={x}")
        self.x = x
        
print("定义完成，开始创建实例...")
obj = MyClass(42)

class DatabaseConnection:
    _instance = None  # 类变量用于存储单例实例

    def __new__(cls, *args, **kwargs):  # 这里的cls，也就是我们当前的类DatabaseConnection
        # 实现单例模式，确保只创建一个数据库连接实例
        if cls._instance is None:  # 若我们的类里面的_instance变量没有被初始化，则创建一个新的实例
            cls._instance = super().__new__(cls)  # 调用父类的__new__方法，创建实例
            print("创建新的数据库连接实例")  # 打印日志
        return cls._instance  # 返回单例实例

    def __init__(self, host, user, password):
        if not hasattr(self,"initialized"): # 如果类对象身上
            self.host = host
            self.user = user
            self.password = password
            self.initialized = True  # 初始化完成
            self.connection = None  # 数据库连接对象

    def connect(self):
        # 模拟数据库连接
        if not self.connection:
            print(f"连接到数据库{self.host} 成功 \n 用户名：{self.user} \n 密码：{self.password}")
            self.connection = True  # 连接成功
        return self.connection

    def __del__(self):
        # 对象销毁时关闭连接
        if self.connection:
            print(f"关闭数据库连接：{self.host}")
            self.connection = None


# 使用示例
db1 = DatabaseConnection("localhost", "admin", "password")
db2 = DatabaseConnection("localhost", "admin", "newpassword")  # 不会创建新实例
# 判断两者是否为同一个实例
print(db1 is db2)  # True
db1.connect()  # 连接到数据库

class Product:
    def __init__(self, id, name, price):
        self.id = id
        self.name = name
        self.price = price

    def __str__(self):
        # 返回用户友好的描述
        return f"{self.name} (¥{self.price:.2f})"

    def __repr__(self):
        # 返回可重新创建此对象的代码
        return f"Product(id={self.id!r}, name={self.name!r}, price={self.price!r})"


# 使用示例
apple = Product(1, "苹果", 5.99)
print(apple)  # 输出: 苹果 (¥5.99)
print(repr(apple))  # 输出: Product(id=1, name='苹果', price=5.99)

# 在调试中的价值
products = [
    Product(1, "苹果", 5.99),
    Product(2, "香蕉", 3.50)
]
print(products)  # 会显示完整的repr信息，有助于调试

class Product:
    def __init__(self, id, name, price):
        self.id = id
        self.name = name
        self.price = price

    def __str__(self):
        """返回用户友好的描述"""
        return f"{self.name} (¥{self.price:.2f})"

    def __repr__(self):
        """返回可重新创建此对象的代码"""
        return f"Product(id={self.id!r}, name={self.name!r}, price={self.price!r})"


class ShoppingCart:
    """
    购物车类：管理用户选择的商品及其数量
    """
    def __init__(self):
        """初始化空购物车"""
        self.items = {}  # 商品ID -> (商品, 数量)的映射

    def add_item(self, product, quantity=1):
        """
        增加商品到购物车
        
        参数:
            product (Product): 要添加的商品
            quantity (int): 添加的数量，默认为1
        """
        if product.id in self.items:
            # 如果商品已经在购物车中，更新数量
            self.items[product.id] = (product, self.items[product.id][1] + quantity)
        else:
            # 如果商品不在购物车中，直接添加
            self.items[product.id] = (product, quantity)

    def __getitem__(self, product_id):
        """
        支持通过索引访问: cart[product_id]
        返回商品和数量的元组
        """
        if product_id not in self.items:
            raise KeyError(f"商品ID {product_id} 不在购物车中")
        return self.items[product_id]

    def __setitem__(self, product_id, quantity):
        """
        支持通过索引设置数量: cart[product_id] = quantity
        """
        if product_id not in self.items:
            raise KeyError(f"商品ID {product_id} 不在购物车中")
        product = self.items[product_id][0]
        self.items[product_id] = (product, quantity)

    def __delitem__(self, product_id):
        """
        支持通过del删除商品: del cart[product_id]
        """
        if product_id not in self.items:
            raise KeyError(f"商品ID {product_id} 不在购物车中")
        del self.items[product_id]

    def __len__(self):
        """返回购物车中的商品种类数量"""
        return len(self.items)

    def __iter__(self):
        """使购物车可迭代，返回商品和数量"""
        for product_id in self.items:
            yield self.items[product_id]

    def __contains__(self, product_id):
        """支持成员检查: product_id in cart"""
        print("__contains__被调用")
        return product_id in self.items

    def total_price(self):
        """计算购物车中所有商品的总价"""
        return sum(product.price * quantity for product, quantity in self.items.values())

    def __str__(self):
        """用户友好的购物车展示"""
        if not self.items:
            return "购物车为空"

        cart_str = "购物车内容:\n"
        for product, quantity in self.items.values():
            cart_str += f"  {product.name} x {quantity}: ¥{product.price * quantity:.2f}\n"
        cart_str += f"总计: ¥{self.total_price():.2f}"
        return cart_str


# ===== 测试代码 =====
print("===== 创建商品 =====")
apple = Product(1, "苹果", 5.99)
banana = Product(2, "香蕉", 3.50)
orange = Product(3, "橙子", 4.25)
print(f"商品1: {apple}")
print(f"商品2: {banana}")
print(f"商品3: {orange}")
print(f"商品repr: {repr(apple)}")

print("\n===== 购物车基本操作 =====")
cart = ShoppingCart()
print("空购物车:", cart)

# 添加商品测试
print("\n添加商品:")
cart.add_item(apple, 3)
cart.add_item(banana, 2)
print(cart)

# 添加已有商品测试
print("\n添加已有商品:")
cart.add_item(apple, 2)  # 现在应该有5个苹果
print(cart)

# 通过索引访问测试
print("\n通过索引访问:")
apple_info = cart[1]  # 获取ID为1的商品信息
print(f"ID为1的商品信息: {apple_info[0].name}, 数量: {apple_info[1]}")

# 通过索引修改数量测试
print("\n通过索引修改数量:")
cart[2] = 4  # 将香蕉的数量改为4
print(cart)

# 删除商品测试
print("\n删除商品:")
del cart[1]  # 删除苹果
print(cart)

# 长度测试
print("\n购物车商品种类:", len(cart))

# 迭代购物车测试
print("\n迭代购物车中的商品:")
for product, quantity in cart:
    print(f"  {product.name}: {quantity}个")

# 成员检查测试
print("\n成员检查:")
print(f"香蕉在购物车中? {2 in cart}")  # True
print(f"苹果在购物车中? {1 in cart}")  # False
print(f"橙子在购物车中? {3 in cart}")  # False

# 添加新商品测试
print("\n添加新商品:")
cart.add_item(orange, 1)
print(cart)

# 计算总价测试
print("\n购物车总价: ¥{:.2f}".format(cart.total_price()))

# 错误处理测试
print("\n===== 错误处理测试 =====")
try:
    cart[4]  # 尝试访问不存在的商品
except KeyError as e:
    print(f"预期的错误: {e}")