2-1、__add__(self, other)、__sub__(self, other)、__mul__(self, other)等：自定义对象之间的算术运算。
2-2、__eq__(self, other)、__ne__(self, other)、__lt__(self, other)等：定义对象之间的比较操作。

3、字符串和表示

3-1、__str__(self)：定义对象的字符串表示，常用于print()函数。
3-2、__repr__(self)：定义对象的官方字符串表示，用于repr()函数和交互式解释器。

4、容器管理

4-1、__getitem__(self, key)、__setitem__(self, key, value)、__delitem__(self, key)：用于实现类似列表或字典的索引访问、设置和删除操作。
4-2、__len__(self)：返回对象的长度或元素个数。

5、可调用对象

5-1、__call__(self, [args...])：允许对象像函数一样被调用。

6、上下文管理

6-1、__enter__(self)、__exit__(self, exc_type, exc_val, exc_tb)：用于实现上下文管理器，如with语句中的对象。

7、属性访问和描述符

7-1、__getattr__, __setattr__, __delattr__：这些方法允许对象在访问或修改不存在的属性时执行自定义操作。
7-2、描述符(Descriptors)是实现了__get__, __set__, 和__delete__方法的对象，它们可以控制对另一个对象属性的访问。

8、迭代器和生成器

8-1、__iter__和__next__：这些方法允许对象支持迭代操作，如使用for循环遍历对象。
8-2、__aiter__, __anext__：这些是异步迭代器的魔法方法，用于支持异步迭代。

9、数值类型

9-1、__int__(self)、__float__(self)、__complex__(self)：定义对象到数值类型的转换。
9-2、__index__(self)：定义对象用于切片时的整数转换。

10、复制和序列化

10-1、__copy__和__deepcopy__：允许对象支持浅复制和深复制操作。
10-2、__getstate__和__setstate__：用于自定义对象的序列化和反序列化过程。

11、自定义元类行为

11-1、__metaclass__(Python 2)或元类本身(Python 3)：允许自定义类的创建过程，如动态创建类、修改类的定义等。

12、自定义类行为

12-1、__init__和__new__：用于初始化对象或控制对象的创建过程。
12-2、__init_subclass__：在子类被创建时调用，允许在子类中执行一些额外的操作。

13、类型检查和转换

13-1、__instancecheck__和__subclasscheck__：用于自定义isinstance()和issubclass()函数的行为。

14、自定义异常

14-1、你可以通过继承内置的Exception类来创建自定义的异常类，并定义其特定的行为。

三、学习方法

要学好Python的魔法方法，你可以遵循以下方法及步骤：

1、理解基础

首先确保你对Python的基本语法、数据类型、类和对象等概念有深入的理解，这些是理解魔法方法的基础。

2、查阅文档

仔细阅读Python官方文档中关于魔法方法的部分，文档会详细解释每个魔法方法的作用、参数和返回值。你可以通过访问Python的官方网站或使用help()函数在Python解释器中查看文档。

3、编写示例

为每个魔法方法编写简单的示例代码，以便更好地理解其用法和效果，通过实际编写和运行代码，你可以更直观地感受到魔法方法如何改变对象的行为。

4、实践应用

在实际项目中尝试使用魔法方法。如，你可以创建一个自定义的集合类，使用__getitem__、__setitem__和__delitem__方法来实现索引操作。只有通过实践应用，你才能更深入地理解魔法方法的用途和重要性。

5、阅读他人代码

阅读开源项目或他人编写的代码，特别是那些使用了魔法方法的代码，这可以帮助你学习如何在实际项目中使用魔法方法。通过分析他人代码中的魔法方法使用方式，你可以学习到一些新的技巧和最佳实践。

6、参加社区讨论

参与Python社区的讨论，与其他开发者交流关于魔法方法的使用经验和技巧，在社区中提问或回答关于魔法方法的问题，这可以帮助你更深入地理解魔法方法并发现新的应用场景。

7、持续学习

Python语言和其生态系统不断发展，新的魔法方法和功能可能会不断被引入，保持对Python社区的关注，及时学习新的魔法方法和最佳实践。

8、练习与总结

多做练习，通过编写各种使用魔法方法的代码来巩固你的理解，定期总结你学到的知识和经验，形成自己的知识体系。

9、注意兼容性

在使用魔法方法时，要注意不同Python版本之间的兼容性差异，确保你的代码在不同版本的Python中都能正常工作。

10、避免过度使用

虽然魔法方法非常强大，但过度使用可能会导致代码难以理解和维护，在编写代码时，要权衡使用魔法方法的利弊，避免滥用。

总之，学好Python的魔法方法需要不断地学习、实践和总结，只有通过不断地练习和积累经验，你才能更好地掌握这些强大的工具，并在实际项目中灵活运用它们。

四、魔法方法

20、format方法

20-1、语法


__format__(self, format_spec, /)
    Default object formatter

20-2、参数

20-2-1、self(必须)：一个对实例对象本身的引用，在类的所有方法中都会自动传递。

20-2-2、format_spec(必须)：一个字符串，表示格式说明符。它定义了应该如何格式化对象。

20-2-3、/(可选)：这是从Python 3.8开始引入的参数注解语法，它表示这个方法不接受任何位置参数(positional-only parameters)之后的关键字参数(keyword arguments)。

20-3、功能

用于定义对象的自定义格式化字符串表示。

20-4、返回值

返回一个字符串，该字符串表示按照format_spec格式化后的对象。

20-5、说明

在定义__format__方法时，你可以根据需要实现复杂的格式化逻辑。例如，你可以检查 format_spec 的值，并根据不同的值返回不同的字符串表示。

20-6、用法


# 020、__format__方法：
# 1、简单的整数格式化
class MyInt:
    def __init__(self, value):
        self.value = value
    def __format__(self, format_spec):
        return format(self.value, format_spec)
if __name__ == '__main__':
    num = MyInt(12345)
    print(format(num, '08d'))  # 输出: 00012345
 
# 2、自定义日期格式化
from datetime import datetime
class MyDate:
    def __init__(self, year, month, day):
        self.date = datetime(year, month, day)
    def __format__(self, format_spec):
        return self.date.strftime(format_spec)
if __name__ == '__main__':
    date = MyDate(2023, 3, 17)
    print(format(date, '%Y-%m-%d'))  # 输出: 2023-03-17
 
# 3、货币格式化
class Money:
    def __init__(self, amount):
        self.amount = amount
    def __format__(self, format_spec):
        if format_spec == 'c':
            return f'${self.amount:.2f}'.replace('.', ',')
        else:
            return format(self.amount, format_spec)
if __name__ == '__main__':
    money = Money(12345.6789)
    print(format(money, 'c'))  # 输出: $12,345.68
 
# 4、百分比格式化
class Percentage:
    def __init__(self, value):
        self.value = value
    def __format__(self, format_spec):
        return format(self.value * 100, format_spec) + '%'
if __name__ == '__main__':
    percentage = Percentage(0.85)
    print(format(percentage, '.1f'))  # 输出: 85.0%
 
# 5、分数格式化(带分数和小数)
from fractions import Fraction
class MixedNumber:
    def __init__(self, numerator, denominator):
        self.fraction = Fraction(numerator, denominator)
    def __format__(self, format_spec):
        whole, numerator = divmod(self.fraction.numerator, self.fraction.denominator)
        return f'{whole} {numerator}/{self.fraction.denominator}'
if __name__ == '__main__':
    mixed = MixedNumber(7, 3)
    print(format(mixed, ''))  # 输出: 2 1/3
 
# 6、十六进制颜色格式化
class Color:
    def __init__(self, r, g, b):
        self.rgb = (r, g, b)
    def __format__(self, format_spec):
        if format_spec == 'hex':
            return "#{:02x}{:02x}{:02x}".format(self.rgb[0], self.rgb[1], self.rgb[2])
        else:
            raise ValueError("Invalid format specifier for Color")
if __name__ == '__main__':
    color = Color(255, 0, 0)
    print(format(color, 'hex'))  # 输出: #ff0000
 
# 7、自定义二进制表示
class Binary:
    def __init__(self, value):
        self.value = value
    def __format__(self, format_spec):
        if format_spec == 'b':
            return bin(self.value)[2:]  # 去掉'0b'前缀
        else:
            return format(self.value, format_spec)
if __name__ == '__main__':
    binary = Binary(10)
    print(format(binary, 'b'))  # 输出: 1010
 
# 8、自定义角度格式化(转为度分秒)
class Angle:
    def __init__(self, degrees):
        self.degrees = degrees
    def __format__(self, format_spec):
        if format_spec == 'dms':
            # 将角度转换为度分秒
            minutes, seconds = divmod(abs(self.degrees) * 60, 60)
            degrees = int(abs(self.degrees))
            seconds = round(seconds, 2)  # 保留两位小数
            degrees_sign = '' if self.degrees >= 0 else '-'
            # 格式化输出
            return f"{degrees_sign}{degrees:02d}°{int(minutes):02d}′{seconds:05.2f}″"
        else:
            raise ValueError(f"Invalid format specifier for Angle: '{format_spec}'")
if __name__ == '__main__':
    angle = Angle(123.4567)
    print(format(angle, 'dms'))  # 输出: 123°123′27.40″
    angle_negative = Angle(-45.1234)
    print(format(angle_negative, 'dms'))  # 输出: -45°45′07.40″
 
# 9、自定义时间格式化
from datetime import timedelta
class CustomTimeDelta:
    def __init__(self, seconds):
        self.seconds = seconds
    def __format__(self, format_spec):
        if format_spec == 'hms':
            hours, remainder = divmod(self.seconds, 3600)
            minutes, seconds = divmod(remainder, 60)
            return f"{int(hours):02d}:{int(minutes):02d}:{int(seconds):02d}"
        else:
            raise ValueError("Invalid format specifier for CustomTimeDelta")
if __name__ == '__main__':
    delta = CustomTimeDelta(3725)
    print(format(delta, 'hms'))  # 输出: 01:02:05
 
# 10、自定义复数格式化
class ComplexNumber:
    def __init__(self, real, imag):
        self.real = real
        self.imag = imag
    def __format__(self, format_spec):
        if format_spec == 'polar':
            magnitude = (self.real**2 + self.imag**2)**0.5
            angle = (math.atan2(self.imag, self.real) * 180 / math.pi) % 360
            return f"({magnitude:.2f}, {angle:.2f}°)"
        else:
            return f"{self.real:.2f} + {self.imag:.2f}j"
import math
if __name__ == '__main__':
    cn = ComplexNumber(3, 4)
    print(format(cn, ''))           # 输出: 3.00 + 4.00j
    print(format(cn, 'polar'))     # 输出: (5.00, 53.13°)
 
# 11、自定义科学计数法格式化
class ScientificNumber:
    def __init__(self, value):
        self.value = value
    def __format__(self, format_spec):
        if format_spec == 'sci':
            return f"{self.value:.2E}"
        else:
            return format(self.value, format_spec)
if __name__ == '__main__':
    sn = ScientificNumber(123456789)
    print(format(sn, 'sci'))  # 输出: 1.23E+08
 
# 12、自定义二进制浮点数格式化
class BinaryFloat:
    def __init__(self, value):
        self.value = value
    def __format__(self, format_spec):
        if format_spec == 'binf':
            # 这里为了简化，只展示整数部分和小数点后一位的二进制表示
            integer_part = bin(int(self.value))[2:]
            fraction_part = bin(int((self.value - int(self.value)) * 2))[2:3]
            return f"{integer_part}.{fraction_part}"
        else:
            return format(self.value, format_spec)
if __name__ == '__main__':
    bf = BinaryFloat(3.5)
    print(format(bf, 'binf'))  # 输出可能不完全准确，因为浮点数二进制表示有限: 11.1

21、ge方法

21-1、语法


__ge__(self, other, /)
    Return self >= other

21-2、参数

21-2-1、self(必须)：表示调用该方法的对象本身。

21-2-2、other(必须)：表示要与self进行比较的另一个对象，它可以是与self相同类型的对象，也可以是其他类型的对象(这取决于你的比较逻辑)。

21-2-3、/(可选)：这是从Python 3.8开始引入的参数注解语法，它表示这个方法不接受任何位置参数(positional-only parameters)之后的关键字参数(keyword arguments)。

21-3、功能

用于实现对象的“大于或等于”比较操作。

21-4、返回值

返回一个布尔值(True或False)，指示self是否大于或等于other。

21-5、说明

无

21-6、用法


# 021、__ge__方法：
# 1、整数类
class IntWrapper:
    def __init__(self, value):
        self.value = value
    def __ge__(self, other):
        if isinstance(other, IntWrapper):
            return self.value >= other.value
        elif isinstance(other, int):
            return self.value >= other
        else:
            return NotImplemented
if __name__ == '__main__':
    a = IntWrapper(5)
    b = IntWrapper(3)
    print(a >= b)  # True
    print(a >= 4)  # True
    print(a >= IntWrapper(6))  # False
 
# 2、字符串长度比较
class StringLength:
    def __init__(self, string):
        self.string = string
    def __ge__(self, other):
        if isinstance(other, StringLength):
            return len(self.string) >= len(other.string)
        elif isinstance(other, int):
            return len(self.string) >= other
        else:
            return NotImplemented
if __name__ == '__main__':
    s1 = StringLength("hello")
    s2 = StringLength("Myelsa")
    print(s1 >= s2)  # False
    print(s1 >= 4)  # True
 
# 3、自定义分数类
from fractions import Fraction
class MyFraction:
    def __init__(self, numerator, denominator):
        self.fraction = Fraction(numerator, denominator)
    def __ge__(self, other):
        if isinstance(other, MyFraction):
            return self.fraction >= other.fraction
        elif isinstance(other, (int, float)):
            return self.fraction >= Fraction(other)
        else:
            return NotImplemented
if __name__ == '__main__':
    f1 = MyFraction(1, 2)
    f2 = MyFraction(3, 4)
    print(f1 >= f2)  # False
    print(f1 >= 0.4)  # True
 
# 4、自定义点类(二维空间)
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def __ge__(self, other):
        if isinstance(other, Point):
            return self.x >= other.x and self.y >= other.y
        else:
            return NotImplemented
if __name__ == '__main__':
    p1 = Point(3, 6)
    p2 = Point(10, 8)
    print(p1 >= p2)  # False
 
# 5、自定义字典长度比较
class DictLengthWrapper:
    def __init__(self, dictionary):
        self.dictionary = dictionary
    def __ge__(self, other):
        if isinstance(other, DictLengthWrapper):
            return len(self.dictionary) >= len(other.dictionary)
        elif isinstance(other, int):
            return len(self.dictionary) >= other
        else:
            return NotImplemented
if __name__ == '__main__':
    d1 = DictLengthWrapper({'a': 1, 'b': 2})
    d2 = DictLengthWrapper({'c': 3})
    print(d1 >= d2)  # True
    print(d1 >= 2)  # True
 
# 6、自定义时间类
class CustomDate:
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day
    def __repr__(self):
        return f"CustomDate({self.year}, {self.month}, {self.day})"
    def __str__(self):
        return f"{self.year}-{self.month}-{self.day}"
    def __ge__(self, other):
        if isinstance(other, CustomDate):
            # 比较年份，年份大的日期大
            if self.year > other.year:
                return True
            # 如果年份相同，比较月份
            elif self.year == other.year and self.month > other.month:
                return True
            # 如果年份和月份都相同，比较天数
            elif self.year == other.year and self.month == other.month and self.day >= other.day:
                return True
            # 其他情况，当前日期小于或等于比较日期
            else:
                return False
        else:
            # 对于非CustomDate类型的比较，返回NotImplemented
            return NotImplemented
if __name__ == '__main__':
    d1 = CustomDate(2009, 10, 8)
    d2 = CustomDate(2018, 3, 6)
    d3 = CustomDate(2024, 3, 13)
    print(d1 >= d2)  # False
    print(d1 >= d3)  # False
    print(d2 >= d3)  # False
    # 尝试与其他类型比较，将会返回NotImplemented
    # print(d1 >= (2023, 3, 15))  # TypeError: '>=' not supported between instances of 'CustomDate' and 'tuple'
 
# 7、自定义价格类
class Price:
    def __init__(self, amount):
        self.amount = amount
    def __ge__(self, other):
        if isinstance(other, Price):
            return self.amount >= other.amount
        elif isinstance(other, (int, float)):
            return self.amount >= other
        else:
            return NotImplemented
if __name__ == '__main__':
    p1 = Price(10.24)
    p2 = Price(10.18)
    print(p1 >= p2)  # True
    print(p1 >= 10)  # True
 
# 8、自定义成绩类
class Grade:
    def __init__(self, score):
        self.score = score
    def __ge__(self, other):
        if isinstance(other, Grade):
            return self.score >= other.score
        elif isinstance(other, (int, float)):
            return self.score >= other
        else:
            return NotImplemented
    def __str__(self):
        return f"Grade: {self.score}"
if __name__ == '__main__':
    g1 = Grade(85)
    g2 = Grade(80)
    print(g1 >= g2)  # True
    print(g1 >= 85)  # True
 
# 9、自定义长度单位类
class Length:
    def __init__(self, meters):
        self.meters = meters
    def __ge__(self, other):
        if isinstance(other, Length):
            return self.meters >= other.meters
        elif isinstance(other, (int, float)):
            return self.meters >= other
        else:
            return NotImplemented
    def __str__(self):
        return f"{self.meters} meters"
if __name__ == '__main__':
    l1 = Length(10)
    l2 = Length(5)
    print(l1 >= l2)  # True
    print(l1 >= 8)  # True
 
# 10、自定义权重类(考虑精度)
from decimal import Decimal, getcontext
class Weight:
    def __init__(self, value, precision=2):
        getcontext().prec = precision + 2  # 设置精度以支持比较
        self.value = Decimal(value)
    def __ge__(self, other):
        if isinstance(other, Weight):
            return self.value >= other.value
        elif isinstance(other, (int, float, Decimal)):
            return self.value >= Decimal(other)
        else:
            return NotImplemented
    def __str__(self):
        return f"{self.value:.{getcontext().prec - 2}f} kg"
if __name__ == '__main__':
    w1 = Weight('10.24')
    w2 = Weight('10.18')
    print(w1 >= w2)  # True
    print(w1 >= 10.5)  # False
 
# 11、自定义日期类
from datetime import datetime
class CustomDate:
    def __init__(self, year, month, day):
        self.date = datetime(year, month, day)
    def __ge__(self, other):
        if isinstance(other, CustomDate):
            return self.date >= other.date
        elif isinstance(other, datetime):
            return self.date >= other
        else:
            return NotImplemented
    def __str__(self):
        return self.date.strftime('%Y-%m-%d')
if __name__ == '__main__':
    d1 = CustomDate(2024, 3, 13)
    d2 = CustomDate(2024, 5, 11)
    print(d1 >= d2)  # False
    print(d1 >= datetime(2023, 3, 15))  # True
 
# 12、自定义版本类
class Version:
    def __init__(self, version_string):
        self.parts = tuple(map(int, version_string.split('.')))
    def __ge__(self, other):
        if isinstance(other, Version):
            return self.parts >= other.parts
        elif isinstance(other, str):
            other_version = Version(other)
            return self.parts >= other_version.parts
        else:
            return NotImplemented
    def __str__(self):
        return '.'.join(map(str, self.parts))
if __name__ == '__main__':
    v1 = Version('1.2.3')
    v2 = Version('1.2.2')
    print(v1 >= v2)  # True
    print(v1 >= '1.2.3')  # True

22、get方法

22-1、语法


__get__(self, instance, owner=None, /)
    Return an attribute of instance, which is of type owner

22-2、参数

22-2-1、self(必须)：一个对描述符实例对象本身的引用，在类的所有方法中都会自动传递。

22-2-2、instance(必须)：拥有描述符的类的实例。当描述符是通过实例访问时，这个参数会被设置为实例本身；如果描述符是通过类而不是实例访问的(例如类属性)，这个参数会是None。

22-2-3、owner(可选)：拥有描述符的类。

22-2-4、/(可选)：这是从Python 3.8开始引入的参数注解语法，它表示这个方法不接受任何位置参数(positional-only parameters)之后的关键字参数(keyword arguments)。

22-3、功能

用于访问描述符的值。

22-4、返回值

返回一个值，即描述符被访问时应该返回的值。

22-5、说明

在Python中，__get__ 方法通常与描述符(descriptors)一起使用，描述符是一种具有绑定行为的对象属性，这些属性可以重写属性的访问、赋值和删除操作。描述符常用于实现如属性验证、类型检查、属性访问控制等高级功能。

22-6、用法


# 022、__get__方法：
# 1、简单的属性访问
class MyDescriptor:
    def __init__(self, initial_value):
        self.value = initial_value
    def __get__(self, instance, owner):
        return self.value
class MyClass:
    x = MyDescriptor(10)
if __name__ == '__main__':
    obj = MyClass()
    print(obj.x)  # 输出: 10
 
# 2、访问实例属性(如果存在)
class MyDescriptor:
    def __init__(self, name):
        self.name = name
    def __get__(self, instance, owner):
        if instance is not None and hasattr(instance, self.name):
            return instance.__dict__[self.name]
        return None
class MyClass:
    def __init__(self, value):
        self.x = value
    x = MyDescriptor('x')
if __name__ == '__main__':
    obj = MyClass(20)
    print(obj.x)  # 输出: 20
 
# 3、属性计算
class MyDescriptor:
    def __get__(self, instance, owner):
        if instance is None:
            return self
        return instance.y * 2
class MyClass:
    z = MyDescriptor()
    def __init__(self, y):
        self.y = y
if __name__ == '__main__':
    obj = MyClass(5)
    print(obj.z)  # 输出: 10
 
# 4、访问控制(只读)
class MyDescriptor:
    def __init__(self, value):
        self._value = value
    def __get__(self, instance, owner):
        return self._value
    def __set__(self, instance, value):
        raise AttributeError("This attribute is read-only")
class MyClass:
    x = MyDescriptor(10)
if __name__ == '__main__':
    obj = MyClass()
    print(obj.x)  # 输出: 10
    # obj.x = 20  # 这会抛出一个AttributeError: This attribute is read-only
 
# 5、延迟初始化
class MyDescriptor:
    def __get__(self, instance, owner):
        if not hasattr(instance, '_initialized'):
            print('Initializing...')
            instance._initialized = True
            instance.y = 42
        return instance.y
class MyClass:
    y = MyDescriptor()
if __name__ == '__main__':
    obj = MyClass()
    print(obj.y)  # 输出: Initializing... 42
 
# 6、线程安全属性(简化版)
import threading
class ThreadSafeDescriptor:
    def __init__(self, init_value):
        self._lock = threading.Lock()
        self._value = init_value
 
    def __get__(self, instance, owner):
        with self._lock:
            return self._value
 
    def __set__(self, instance, value):
        with self._lock:
            self._value = value
# 省略了 __set__ 的实际使用，因为它在这个简化的例子中并不明显
 
# 7、验证属性值
class MyDescriptor:
    def __init__(self):
        self._value = None
    def __get__(self, instance, owner):
        return self._value
    def __set__(self, instance, value):
        if not isinstance(value, int) or value < 0:
            raise ValueError("Value must be a non-negative integer")
        self._value = value
class MyClass:
    x = MyDescriptor()
if __name__ == '__main__':
    obj = MyClass()
    obj.x = 10  # 正常
    # obj.x = -1  # 这会抛出一个 ValueError
 
# 8、缓存属性值
class CachedDescriptor:
    def __init__(self, func):
        self.func = func
        self.name = func.__name__
    def __get__(self, instance, owner):
        if instance is None:
            return self
        # 尝试从实例的缓存中获取值
        cache = getattr(instance, '__cache__', None)
        if cache is None:
            cache = {}
            setattr(instance, '__cache__', cache)
        if self.name not in cache:
            # 如果缓存中没有值，则调用函数并存储结果
            cache[self.name] = self.func(instance)
        return cache[self.name]
class MyClass:
    def __init__(self, data):
        self.data = data
    @CachedDescriptor
    def expensive_calculation(self):
        print("Calculating...")
        # 假设这是一个非常耗时的计算
        result = sum(range(self.data))
        return result
if __name__ == '__main__':
    obj = MyClass(1000)
    print(obj.expensive_calculation)  # 输出: Calculating... 和计算结果
    print(obj.expensive_calculation)  # 直接从缓存中获取，不会再次计算
 
# 9、属性依赖其他属性
class DependentDescriptor:
    def __init__(self, attr_name):
        self.attr_name = attr_name
    def __get__(self, instance, owner):
        if instance is None:
            return self
        # 假设另一个属性是 instance.base_value
        base_value = getattr(instance, 'base_value', None)
        if base_value is not None:
            return base_value * 2  # 假设这个描述符的值是 base_value 的两倍
        return None
class MyClass:
    double_value = DependentDescriptor('base_value')
    def __init__(self, base_value):
        self.base_value = base_value
if __name__ == '__main__':
    obj = MyClass(5)
    print(obj.double_value)  # 输出: 10

五、推荐阅读

1、Python筑基之旅

2、Python函数之旅

3、Python算法之旅

4、博客个人主页

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小小林熬夜学编程/article/detail/664299