方法之特殊方法（Dunder Method）的定义

class ClassName:
    def __init__(self, param1, param2):
        self.param1 = param1
        self.param2 = param2

class Character:
    def __init__(self, name, health, experience):
        self.name = name           # 实例变量，每个角色的名字
        self.health = health       # 实例变量，每个角色的健康点数
        self.experience = experience  # 实例变量，每个角色的经验值

    def __str__(self):
        """特殊方法，定义角色的字符串表示形式"""
        return f"Character({self.name}, Health: {self.health}, Experience: {self.experience})"

arthur = Character("Character", 100, 0)

print(arthur) # 自动调用 Character 类中的 __str__ 特殊方法，输出 Character(Arthur, Health: 100, Experience: 0)

class Character:
    def __init__(self, name, level, items=None):
        self.name = name
        self.level = level
        self.items = items if items is not None else []

    def __str__(self):
        return f"{self.name}, Level {self.level}"

    def __repr__(self):
        return f"Character('{self.name}', {self.level}, {self.items})"

character = Character("Aragorn", 5, ["Sword", "Shield"])
print(str(character))  # 输出: Aragorn, Level 5

character = Character("Aragorn", 5, ["Sword", "Shield"])
print(repr(character))  # 输出: Character('Aragorn', 5, ['Sword', 'Shield'])

arthur = Character("Arthur", 100, 0)
print(arthur.name)

class Character:
    def __init__(self, name, health, experience):
        self.name = name           # 角色的名字
        self.health = health       # 角色的健康点数
        self.experience = experience  # 角色的经验值

# 创建角色实例
arthur = Character("Arthur", 100, 0)

# 直接修改属性
arthur.health = -50   # 将健康点数设置为负数
arthur.experience = -100  # 经验值也设置为一个不合逻辑的负数

class Character:
    def __init__(self, name, health, experience):
        self.name = name
        self.health = health
        self.experience = experience

    def set_health(self, value):
        if value < 0:
            self.health = 0
            print(f"{self.name} has died.")
        elif value > 100:
            self.health = 100
        else:
            self.health = value

    def add_experience(self, value):
        self.experience += value
        while self.experience >= 100:
            self.experience -= 100
            print(f"{self.name} has leveled up!")

# 创建角色实例
arthur = Character("Arthur", 50, 0)

# 直接修改属性
arthur.health = -20   # 将健康点数设置为负数
arthur.health = 150  # 健康值超出最大限制

class Character:
    def __init__(self, name, health, experience):
        self._name = name
        self._health = health
        self._experience = experience

class Character:
    def __init__(self, name, health, experience):
        self._name = name           # 初始化时将属性设置为私有
        self._health = health
        self._experience = experience

    # accessor for name
    def get_name(self):
        return self._name

    # mutator for name
    def set_name(self, value):
        if isinstance(value, str):  # 简单的类型检查
            self._name = value

    # accessor for health
    def get_health(self):
        return self._health

    # mutator for health
    def set_health(self, value):
        if value < 0:
            value = 0  # 保护健康值不为负
        elif value > 100:
            value = 100  # 限制健康值的最大值
        self._health = value

    # accessor for experience
    def get_experience(self):
        return self._experience

    # mutator for experience
    def set_experience(self, value):
        if value < 0:
            value = 0  # 防止经验值为负
        self._experience = value

arthur = Character("Arthur", 100, 50)

# 使用 getter 方法
print(arthur.get_name())  # 输出: Arthur

# 使用 setter 方法
arthur.set_health(150)
print(arthur.get_health())  # 输出: 100 (因为健康值被限制在100)

arthur.set_experience(-10)
print(arthur.get_experience())  # 输出: 0 (因为经验值不能为负)

class Character:
    def __init__(self, name, health, experience):
        self._name = name
        self._health = health
        self._experience = experience

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, value):
        if not isinstance(value, str):
            raise ValueError("Name must be a string")
        self._name = value

    @property
    def health(self):
        return self._health

    @health.setter
    def health(self, value):
        if value < 0:
            value = 0
        elif value > 100:
            value = 100
        self._health = value

    @property
    def experience(self):
        return self._experience

    @experience.setter
    def experience(self, value):
        if value < 0:
            value = 0
        self._experience = value

hero = Character("Arthur", 100, 50)

print(hero.name)            # 输出: Arthur
print(hero.health)          # 输出: 100
print(hero.experience)      # 输出: 50

hero.name = "SunWukong"   # 尝试将 name 设置为 "SunWukong"。由于这是一个字符串，赋值将成功。
hero.health = 110         # 尝试将 health 设置为 110。由于 mutator 方法中限制了健康值的最大值为 100，它将自动调整为 100。
hero.experience = -10     # 尝试将 experience 设置为 -10。由于 mutator 方法不允许负值，它将自动调整为 0。

print(hero.name)          # 输出: SunWukong
print(hero.health)          # 输出: 100
print(hero.experience)      # 输出: 0

class Character:
    def __init__(self, name, health, experience):
        self._name = name
        self._health = health
        self._experience = experience

    @property
    def name(self):
        return self._name

hero = Character("Arthur", 100, 50)

print(hero.name)       # 输出: Arthur

hero.name = "SunWukong"

Traceback (most recent call last):
  File "c:\Users\thinkstation\Desktop\testing\property.py", line 44, in <module>
    hero.name = "SunWukong"
    ^^^^^^^^^
AttributeError: property 'name' of 'Character' object has no setter

class Character:
    def __init__(self, name, health, experience):
        self._name = name
        self._health = health
        self._experience = experience
        self._password = None  # 私有属性，初始时没有设置

class Character:
    def __init__(self, name, health, experience):
        self._name = name
        self._health = health
        self._experience = experience
        self._password = None  # 私有属性，初始时没有设置

    # 只写属性 password 的 setter
    @property
    def password(self):
        raise AttributeError("This attribute is write-only")

    @password.setter
    def password(self, value):
        # 可以在这里加入密码强度验证等逻辑
        self._password = value

hero = Character("Arthur", 100, 50)

# 设置密码
hero.password = "secure_password123"

# 尝试读取密码
try:
    print(hero.password)
except AttributeError as e:
    print(e)  # 输出: This attribute is write-only

class Character:
    def __init__(self, name, health, experience):
        self._name = name
        self._health = health
        self._experience = experience

    @property
    def name(self):
        "The name of the character"
        return self._name

    @name.setter
    def name(self, value):
        self._name = value

    @name.deleter
    def name(self):
        print("Deleting name...")
        del self._name

    @property
    def health(self):
        "The health level of the character. Must be between 0 and 100."
        return self._health

    @health.setter
    def health(self, value):
        if value < 0:
            value = 0
        elif value > 100:
            value = 100
        self._health = value

    @health.deleter
    def health(self):
        print("Deleting health...")
        del self._health

    @property
    def experience(self):
        "The experience points of the character."
        return self._experience

    @experience.setter
    def experience(self, value):
        if value < 0:
            value = 0
        self._experience = value

    @experience.deleter
    def experience(self):
        print("Deleting experience...")
        del self._experience

hero = Character("Arthur", 100, 50)

# 删除属性
del hero.name
del hero.health
del hero.experience

# 尝试再次访问属性，会引发错误因为属性已被删除
try:
    print(hero.name)
except AttributeError as e:
    print(e)        # 输出：'Character' object has no attribute '_name'

help(Character)

Help on class Character in module __main__:

class Character(builtins.object)
 |  Character(name, health, experience)
 |
 |  Methods defined here:
 |
 |  __init__(self, name, health, experience)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  experience
 |      The experience points of the character.
 |
 |  health
 |      The health level of the character. Must be between 0 and 100.
 |
 |  name
 |      The name of the character

# 显示属性的文档字符串
print(Character.name.__doc__)       # 输出：The name of the character
print(Character.health.__doc__)     # 输出：The health level of the character. Must be between 0 and 100.
print(Character.experience.__doc__) # 输出：The experience points of the character.

class NonNegative:
    def __init__(self, default=0):
        self.default = default

    def __get__(self, instance, owner):
        # 返回实例中存储的值
        return getattr(instance, self.private_name, self.default)

    def __set__(self, instance, value):
        # 检查设置的值是否为负，如果是，抛出异常
        if value < 0:
            raise ValueError("This value must be non-negative")
        setattr(instance, self.private_name, value)

    def __set_name__(self, owner, name):
        # 存储属性的私有名称
        self.private_name = '_' + name

class Descriptor:
    def __init__(self, initial_value=None, name='my_var'):
        self.value = initial_value # 存储属性的实际数据
        self.name = name

    def __get__(self, obj, objtype=None):
        print(f"Getting: {self.name}")
        return self.value

    def __set__(self, obj, value):
        print(f"Setting: {self.name} to {value}")
        self.value = value

    def __delete__(self, obj):
        print(f"Deleting: {self.name}")
        del self.value

class Character:
    health = NonNegative()
    experience = NonNegative()

    def __init__(self, name, health, experience):
        self.name = name
        self.health = health
        self.experience = experience

hero = Character("Arthur", 100, 50)

# 尝试设置负的健康值
try:
    hero.health = -10
except ValueError as e:
    print(e)  # 输出: This value must be non-negative

# 正常设置经验值
hero.experience = 30
print(hero.experience)  # 输出: 30

# 尝试删除 health 属性
try:
    del hero.health
except AttributeError as e:
    print(e)  # 如果有特定的删除逻辑，可以在描述符中处理

class Character:
    def __init__(self, name, health, experience):
        self.name = name
        self.health = health
        self.experience = experience

    def __getattr__(self, attr):
        # 如果尝试访问的属性不存在，返回一个默认消息
        return f"{attr} not available"

hero = Character("Arthur", 100, 50)

# 正常访问存在的属性
print(hero.name)  # 输出：Arthur

# 尝试访问不存在的属性
print(hero.strength)  # 自动调用__getattr__(), 输出: strength not available

Traceback (most recent call last):
  File "c:\Users\thinkstation\Desktop\testing\property.py", line 48, in <module>
    hero.strength
AttributeError: 'Character' object has no attribute 'strength'

class Character:
    def __init__(self, name, health, experience):
        self.name = name
        self.health = health
        self.experience = experience

    def __getattr__(self, attr):
        # 提供默认值的字典
        default_values = {
            'strength': 10,
            'intelligence': 10,
            'agility': 10
        }
        # 如果属性在默认值字典中，返回默认值
        if attr in default_values:
            return default_values[attr]
        # 如果不在默认值字典中，返回通用不可用消息
        return f"{attr} not available"

hero = Character("Arthur", 100, 50)

# 正常访问存在的属性
print(hero.name)  # 输出: Arthur

# 尝试访问不存在的属性，但提供默认值
print(hero.strength)  # 输出: 10
print(hero.intelligence)  # 输出: 10

# 尝试访问不存在且无默认值的属性
print(hero.charisma)  # 输出: charisma not available

class Character:
    def __init__(self, name, health, experience):
        self.name = name
        self.health = health
        self.experience = experience
        self._profile_loaded = False
        self._profile = None

    def load_profile(self):
        # 这里模拟一个耗时的数据加载过程
        print("Loading profile from a slow database...")
        return {
            "biography": "Arthur was a legendary British leader.",
            "achievements": ["Established the Knights of the Round Table", "United Britain"]
        }

    def __getattr__(self, attr):
        if attr == "profile":
            if not self._profile_loaded:
                self._profile = self.load_profile()
                self._profile_loaded = True
            return self._profile
        return f"{attr} not available"

hero = Character("Arthur", 100, 50)

# 访问 profile 属性，将触发延迟加载
print(hero.profile)  # 输出加载过程和数据
print(hero.profile)  # 直接输出数据，无需再次加载

def __setattr__(self, name, value):
    # 自定义行为

class Character:
    def __init__(self, name, health, experience):
        self.name = name
        self.health = health
        self.experience = experience

    def __setattr__(self, key, value):
        # 对 health 和 experience 属性进行非负值检查
        if key in ["health", "experience"] and value < 0:
            raise ValueError(f"{key} cannot be negative.")

        # 调用基类的 __setattr__ 来实际设置属性
        super().__setattr__(key, value)

        # 记录属性设置
        print(f"Set {key} to {value}")

# 创建一个 Character 对象
hero = Character("Arthur", 100, 50)

# 修改 health 属性
hero.health = 80

# 尝试将 experience 设置为负值，将触发 ValueError
try:
    hero.experience = -10
except ValueError as e:
    print(e)    # 输出：experience cannot be negative

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class LinkedList:
    def __init__(self):
        self.head = None

    def append(self, data):
        new_node = Node(data)
        if self.head is None:
            self.head = new_node
        else:
            last = self.head
            while last.next:
                last = last.next
            last.next = new_node

    def display(self):
        current = self.head
        while current:
            print(current.data, end=' ')
            current = current.next
        print()

def __len__(self):
    count = 0
    current = self.head
    while current:
        count += 1
        current = current.next
    return count

# 创建一个 LinkedList 实例
heroes_list = LinkedList()

# 向链表中添加草丛三姐妹
heroes_list.append("妲己")
heroes_list.append("安琪拉")
heroes_list.append("王昭君")

# 使用 __len__ 方法获取链表的长度
length = len(heroes_list)  # 这里实际上调用的是 heroes_list.__len__()

# 打印链表的长度
print("Number of heroes in the linked list:", length) # 输出：Number of heroes in the linked list: 3

def __add__(self, other):
    if not isinstance(other, LinkedList):
        return NotImplemented
    new_list = LinkedList()
    current = self.head
    while current:
        new_list.append(current.data)
        current = current.next
    current = other.head
    while current:
        new_list.append(current.data)
        current = current.next
    return new_list

# 创建第二个 LinkedList 实例，并添加其他英雄
more_heroes_list = LinkedList()
more_heroes_list.append("露娜")
more_heroes_list.append("娜可露露")
more_heroes_list.append("貂蝉")

# 显示第一个链表的英雄名字和长度
print("First LinkedList:")
heroes_list.display()
print("Number of heroes in the first linked list:", len(heroes_list))

# 显示第二个链表的英雄名字和长度
print("\nSecond LinkedList:")
more_heroes_list.display()
print("Number of heroes in the second linked list:", len(more_heroes_list))

# 使用 __add__ 方法合并两个链表
combined_list = heroes_list + more_heroes_list

# 显示合并后的链表的英雄名字和长度
print("\nCombined LinkedList:")
combined_list.display()
print("Number of heroes in the combined linked list:", len(combined_list))

First LinkedList:
妲己 安琪拉 王昭君 
Number of heroes in the first linked list: 3

Second LinkedList:
露娜 娜可露露 貂蝉
Number of heroes in the second linked list: 3

Combined LinkedList:
妲己 安琪拉 王昭君 露娜 娜可露露 貂蝉
Number of heroes in the combined linked list: 6

def __mul__(self, n):
    if not isinstance(n, int):
        return NotImplemented
    if n <= 0:
        return LinkedList()  # 返回一个空的链表
    new_list = LinkedList()
    for _ in range(n):
        current = self.head
        while current:
            new_list.append(current.data)
            current = current.next
    return new_list

# 使用 __mul__ 方法重复链表内容
# 假设我们想将整个链表内容重复3次
repeated_list = heroes_list * 3

# 显示重复后的链表
print("Repeated LinkedList (3 times):")
repeated_list.display()

Repeated LinkedList (3 times):
妲己 安琪拉 王昭君 妲己 安琪拉 王昭君 妲己 安琪拉 王昭君

def __iadd__(self, other):
    if not isinstance(other, LinkedList):
        return NotImplemented
    current = self.head
    if not current:  
        self.head = other.head
    else:
        last = current
        while last.next:  
            last = last.next
        last.next = other.head  
    return self

def __imul__(self, n):
    if not isinstance(n, int):
        return NotImplemented
    original_data = list(self)  # # Convert the linked list to a list, which relies on the __iter__ method for iteration

    if n <= 0:
        self.head = None
    else:
        self.head = None
        for _ in range(n):
            for item in original_data:
                self.append(item)
    return self

# 使用 __imul__ 方法就地重复链表内容
heroes_list *= 3
print("\nHeroes List after using __imul__ (tripled in-place):")
heroes_list.display()
print("\nNumber of heroes after __imul__:", len(heroes_list))

Heroes List after using __imul__ (tripled in-place):
妲己 安琪拉 王昭君 妲己 安琪拉 王昭君 妲己 安琪拉 王昭君

Number of heroes after __imul__: 9

for number in [1, 2, 3, 4, 5]:
    print(number)

class LinkedListIterator:
    def __init__(self, head):
        self.current = head

    def __iter__(self):
        return self

    def __next__(self):
        if not self.current:
            raise StopIteration
        data = self.current.data
        self.current = self.current.next
        return data

def __iter__(self):
    return LinkedListIterator(self.head)

# 使用 for 循环迭代 LinkedList
for data in more_heroes_list:
    print(data, end=" ")     # 输出：露娜 娜可露露 貂蝉

def __contains__(self, item):
    current = self.head
    while current:
        if current.data == item:
            return True
        current = current.next
    return False

# 使用 __contains__ 方法实现检查某个元素是否在LinkedList对象中
print("安琪拉" in heroes_list)      # 输出：True
print("安琪拉" in more_heroes_list) # 输出：False

# 实现 __getitem__
def __getitem__(self, index):
    if index < 0:
        raise IndexError("Negative indices are not supported")
    current = self.head
    for _ in range(index):
        if current is None:
            raise IndexError("Index out of bounds")
        current = current.next
    if current is None:
        raise IndexError("Index out of bounds")
    return current.data

# 实现 __setitem__
def __setitem__(self, index, value):
    if index < 0:
        raise IndexError("Negative indices are not supported")
    current = self.head
    for _ in range(index):
        if current is None:
            raise IndexError("Index out of bounds")
        current = current.next
    if current is None:
        raise IndexError("Index out of bounds")
    current.data = value

# 实现 __delitem__
def __delitem__(self, index):
    if index < 0:
        raise IndexError("Negative indices are not supported")
    if self.head is None:
        raise IndexError("Index out of bounds")
    if index == 0:
        self.head = self.head.next
        return
    current = self.head
    previous = None
    for _ in range(index):
        previous = current
        if current is None or current.next is None:
            raise IndexError("Index out of bounds")
        current = current.next
    if current is None:
        raise IndexError("Index out of bounds")
    previous.next = current.next

# 使用 __getitem__ 访问元素
print(more_heroes_list[0])

# 使用 __setitem__ 修改元素
more_heroes_list[2] = '孙悟空'
print("\nHeros List after using __setitem__: ")
more_heroes_list.display()

# 使用 __delitem__ 删除元素
del more_heroes_list[2]
print("\nHeros List after using __delitem__: ")
more_heroes_list.display() 

露娜

Heros List after using __setitem__:
露娜 娜可露露 孙悟空

Heros List after using __delitem__:
露娜 娜可露露