Python魔法之旅-魔法方法(06)

目录

一、概述

1、定义

2、作用

二、应用场景

1、构造和析构

2、操作符重载

3、字符串和表示

4、容器管理

5、可调用对象

6、上下文管理

7、属性访问和描述符

8、迭代器和生成器

9、数值类型

10、复制和序列化

11、自定义元类行为

12、自定义类行为

13、类型检查和转换

14、自定义异常

三、学习方法

1、理解基础

2、查阅文档

3、编写示例

4、实践应用

5、阅读他人代码

6、参加社区讨论

7、持续学习

8、练习与总结

9、注意兼容性

10、避免过度使用

四、魔法方法

20、__format__方法

20-1、语法

20-2、参数

20-3、功能

20-4、返回值

20-5、说明

20-6、用法

21、__ge__方法

21-1、语法

21-2、参数

21-3、功能

21-4、返回值

21-5、说明

21-6、用法

22、__get__方法

22-1、语法

22-2、参数

22-3、功能

22-4、返回值

22-5、说明

22-6、用法

五、推荐阅读

1、Python筑基之旅

2、Python函数之旅

3、Python算法之旅

4、博客个人主页

一、概述

1、定义

        魔法方法(Magic Methods/Special Methods，也称特殊方法或双下划线方法)是Python中一类具有特殊命名规则的方法，它们的名称通常以双下划线(`__`)开头和结尾。

        魔法方法用于在特定情况下自动被Python解释器调用，而不需要显式地调用它们，它们提供了一种机制，让你可以定义自定义类时具有与内置类型相似的行为。

2、作用

        魔法方法允许开发者重载Python中的一些内置操作或函数的行为，从而为自定义的类添加特殊的功能。

二、应用场景

1、构造和析构

1-1、__init__(self, [args...])：在创建对象时初始化属性。
1-2、__new__(cls, [args...])：在创建对象时控制实例的创建过程(通常与元类一起使用)。
1-3、__del__(self)：在对象被销毁前执行清理操作，如关闭文件或释放资源。

2、操作符重载

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、语法
  1. __format__(self, format_spec, /)
  2.     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、用法
  1. # 020、__format__方法：
  2. # 1、简单的整数格式化
  3. class MyInt:
  4.     def __init__(self, value):
  5.         self.value = value
  6.     def __format__(self, format_spec):
  7.         return format(self.value, format_spec)
  8. if __name__ == '__main__':
  9.     num = MyInt(12345)
  10.     print(format(num, '08d'))  # 输出: 00012345
  11.  
  12. # 2、自定义日期格式化
  13. from datetime import datetime
  14. class MyDate:
  15.     def __init__(self, year, month, day):
  16.         self.date = datetime(year, month, day)
  17.     def __format__(self, format_spec):
  18.         return self.date.strftime(format_spec)
  19. if __name__ == '__main__':
  20.     date = MyDate(2023, 3, 17)
  21.     print(format(date, '%Y-%m-%d'))  # 输出: 2023-03-17
  22.  
  23. # 3、货币格式化
  24. class Money:
  25.     def __init__(self, amount):
  26.         self.amount = amount
  27.     def __format__(self, format_spec):
  28.         if format_spec == 'c':
  29.             return f'${self.amount:.2f}'.replace('.', ',')
  30.         else:
  31.             return format(self.amount, format_spec)
  32. if __name__ == '__main__':
  33.     money = Money(12345.6789)
  34.     print(format(money, 'c'))  # 输出: $12,345.68
  35.  
  36. # 4、百分比格式化
  37. class Percentage:
  38.     def __init__(self, value):
  39.         self.value = value
  40.     def __format__(self, format_spec):
  41.         return format(self.value * 100, format_spec) + '%'
  42. if __name__ == '__main__':
  43.     percentage = Percentage(0.85)
  44.     print(format(percentage, '.1f'))  # 输出: 85.0%
  45.  
  46. # 5、分数格式化(带分数和小数)
  47. from fractions import Fraction
  48. class MixedNumber:
  49.     def __init__(self, numerator, denominator):
  50.         self.fraction = Fraction(numerator, denominator)
  51.     def __format__(self, format_spec):
  52.         whole, numerator = divmod(self.fraction.numerator, self.fraction.denominator)
  53.         return f'{whole} {numerator}/{self.fraction.denominator}'
  54. if __name__ == '__main__':
  55.     mixed = MixedNumber(7, 3)
  56.     print(format(mixed, ''))  # 输出: 2 1/3
  57.  
  58. # 6、十六进制颜色格式化
  59. class Color:
  60.     def __init__(self, r, g, b):
  61.         self.rgb = (r, g, b)
  62.     def __format__(self, format_spec):
  63.         if format_spec == 'hex':
  64.             return "#{:02x}{:02x}{:02x}".format(self.rgb[0], self.rgb[1], self.rgb[2])
  65.         else:
  66.             raise ValueError("Invalid format specifier for Color")
  67. if __name__ == '__main__':
  68.     color = Color(255, 0, 0)
  69.     print(format(color, 'hex'))  # 输出: #ff0000
  70.  
  71. # 7、自定义二进制表示
  72. class Binary:
  73.     def __init__(self, value):
  74.         self.value = value
  75.     def __format__(self, format_spec):
  76.         if format_spec == 'b':
  77.             return bin(self.value)[2:]  # 去掉'0b'前缀
  78.         else:
  79.             return format(self.value, format_spec)
  80. if __name__ == '__main__':
  81.     binary = Binary(10)
  82.     print(format(binary, 'b'))  # 输出: 1010
  83.  
  84. # 8、自定义角度格式化(转为度分秒)
  85. class Angle:
  86.     def __init__(self, degrees):
  87.         self.degrees = degrees
  88.     def __format__(self, format_spec):
  89.         if format_spec == 'dms':
  90.             # 将角度转换为度分秒
  91.             minutes, seconds = divmod(abs(self.degrees) * 60, 60)
  92.             degrees = int(abs(self.degrees))
  93.             seconds = round(seconds, 2)  # 保留两位小数
  94.             degrees_sign = '' if self.degrees >= 0 else '-'
  95.             # 格式化输出
  96.             return f"{degrees_sign}{degrees:02d}°{int(minutes):02d}′{seconds:05.2f}″"
  97.         else:
  98.             raise ValueError(f"Invalid format specifier for Angle: '{format_spec}'")
  99. if __name__ == '__main__':
  100.     angle = Angle(123.4567)
  101.     print(format(angle, 'dms'))  # 输出: 123°123′27.40″
  102.     angle_negative = Angle(-45.1234)
  103.     print(format(angle_negative, 'dms'))  # 输出: -45°45′07.40″
  104.  
  105. # 9、自定义时间格式化
  106. from datetime import timedelta
  107. class CustomTimeDelta:
  108.     def __init__(self, seconds):
  109.         self.seconds = seconds
  110.     def __format__(self, format_spec):
  111.         if format_spec == 'hms':
  112.             hours, remainder = divmod(self.seconds, 3600)
  113.             minutes, seconds = divmod(remainder, 60)
  114.             return f"{int(hours):02d}:{int(minutes):02d}:{int(seconds):02d}"
  115.         else:
  116.             raise ValueError("Invalid format specifier for CustomTimeDelta")
  117. if __name__ == '__main__':
  118.     delta = CustomTimeDelta(3725)
  119.     print(format(delta, 'hms'))  # 输出: 01:02:05
  120.  
  121. # 10、自定义复数格式化
  122. class ComplexNumber:
  123.     def __init__(self, real, imag):
  124.         self.real = real
  125.         self.imag = imag
  126.     def __format__(self, format_spec):
  127.         if format_spec == 'polar':
  128.             magnitude = (self.real**2 + self.imag**2)**0.5
  129.             angle = (math.atan2(self.imag, self.real) * 180 / math.pi) % 360
  130.             return f"({magnitude:.2f}, {angle:.2f}°)"
  131.         else:
  132.             return f"{self.real:.2f} + {self.imag:.2f}j"
  133. import math
  134. if __name__ == '__main__':
  135.     cn = ComplexNumber(3, 4)
  136.     print(format(cn, ''))           # 输出: 3.00 + 4.00j
  137.     print(format(cn, 'polar'))     # 输出: (5.00, 53.13°)
  138.  
  139. # 11、自定义科学计数法格式化
  140. class ScientificNumber:
  141.     def __init__(self, value):
  142.         self.value = value
  143.     def __format__(self, format_spec):
  144.         if format_spec == 'sci':
  145.             return f"{self.value:.2E}"
  146.         else:
  147.             return format(self.value, format_spec)
  148. if __name__ == '__main__':
  149.     sn = ScientificNumber(123456789)
  150.     print(format(sn, 'sci'))  # 输出: 1.23E+08
  151.  
  152. # 12、自定义二进制浮点数格式化
  153. class BinaryFloat:
  154.     def __init__(self, value):
  155.         self.value = value
  156.     def __format__(self, format_spec):
  157.         if format_spec == 'binf':
  158.             # 这里为了简化，只展示整数部分和小数点后一位的二进制表示
  159.             integer_part = bin(int(self.value))[2:]
  160.             fraction_part = bin(int((self.value - int(self.value)) * 2))[2:3]
  161.             return f"{integer_part}.{fraction_part}"
  162.         else:
  163.             return format(self.value, format_spec)
  164. if __name__ == '__main__':
  165.     bf = BinaryFloat(3.5)
  166.     print(format(bf, 'binf'))  # 输出可能不完全准确，因为浮点数二进制表示有限: 11.1

21、__ge__方法

21-1、语法
  1. __ge__(self, other, /)
  2.     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、用法
  1. # 021、__ge__方法：
  2. # 1、整数类
  3. class IntWrapper:
  4.     def __init__(self, value):
  5.         self.value = value
  6.     def __ge__(self, other):
  7.         if isinstance(other, IntWrapper):
  8.             return self.value >= other.value
  9.         elif isinstance(other, int):
  10.             return self.value >= other
  11.         else:
  12.             return NotImplemented
  13. if __name__ == '__main__':
  14.     a = IntWrapper(5)
  15.     b = IntWrapper(3)
  16.     print(a >= b)  # True
  17.     print(a >= 4)  # True
  18.     print(a >= IntWrapper(6))  # False
  19.  
  20. # 2、字符串长度比较
  21. class StringLength:
  22.     def __init__(self, string):
  23.         self.string = string
  24.     def __ge__(self, other):
  25.         if isinstance(other, StringLength):
  26.             return len(self.string) >= len(other.string)
  27.         elif isinstance(other, int):
  28.             return len(self.string) >= other
  29.         else:
  30.             return NotImplemented
  31. if __name__ == '__main__':
  32.     s1 = StringLength("hello")
  33.     s2 = StringLength("Myelsa")
  34.     print(s1 >= s2)  # False
  35.     print(s1 >= 4)  # True
  36.  
  37. # 3、自定义分数类
  38. from fractions import Fraction
  39. class MyFraction:
  40.     def __init__(self, numerator, denominator):
  41.         self.fraction = Fraction(numerator, denominator)
  42.     def __ge__(self, other):
  43.         if isinstance(other, MyFraction):
  44.             return self.fraction >= other.fraction
  45.         elif isinstance(other, (int, float)):
  46.             return self.fraction >= Fraction(other)
  47.         else:
  48.             return NotImplemented
  49. if __name__ == '__main__':
  50.     f1 = MyFraction(1, 2)
  51.     f2 = MyFraction(3, 4)
  52.     print(f1 >= f2)  # False
  53.     print(f1 >= 0.4)  # True
  54.  
  55. # 4、自定义点类(二维空间)
  56. class Point:
  57.     def __init__(self, x, y):
  58.         self.x = x
  59.         self.y = y
  60.     def __ge__(self, other):
  61.         if isinstance(other, Point):
  62.             return self.x >= other.x and self.y >= other.y
  63.         else:
  64.             return NotImplemented
  65. if __name__ == '__main__':
  66.     p1 = Point(3, 6)
  67.     p2 = Point(10, 8)
  68.     print(p1 >= p2)  # False
  69.  
  70. # 5、自定义字典长度比较
  71. class DictLengthWrapper:
  72.     def __init__(self, dictionary):
  73.         self.dictionary = dictionary
  74.     def __ge__(self, other):
  75.         if isinstance(other, DictLengthWrapper):
  76.             return len(self.dictionary) >= len(other.dictionary)
  77.         elif isinstance(other, int):
  78.             return len(self.dictionary) >= other
  79.         else:
  80.             return NotImplemented
  81. if __name__ == '__main__':
  82.     d1 = DictLengthWrapper({'a': 1, 'b': 2})
  83.     d2 = DictLengthWrapper({'c': 3})
  84.     print(d1 >= d2)  # True
  85.     print(d1 >= 2)  # True
  86.  
  87. # 6、自定义时间类
  88. class CustomDate:
  89.     def __init__(self, year, month, day):
  90.         self.year = year
  91.         self.month = month
  92.         self.day = day
  93.     def __repr__(self):
  94.         return f"CustomDate({self.year}, {self.month}, {self.day})"
  95.     def __str__(self):
  96.         return f"{self.year}-{self.month}-{self.day}"
  97.     def __ge__(self, other):
  98.         if isinstance(other, CustomDate):
  99.             # 比较年份，年份大的日期大
  100.             if self.year > other.year:
  101.                 return True
  102.             # 如果年份相同，比较月份
  103.             elif self.year == other.year and self.month > other.month:
  104.                 return True
  105.             # 如果年份和月份都相同，比较天数
  106.             elif self.year == other.year and self.month == other.month and self.day >= other.day:
  107.                 return True
  108.             # 其他情况，当前日期小于或等于比较日期
  109.             else:
  110.                 return False
  111.         else:
  112.             # 对于非CustomDate类型的比较，返回NotImplemented
  113.             return NotImplemented
  114. if __name__ == '__main__':
  115.     d1 = CustomDate(2009, 10, 8)
  116.     d2 = CustomDate(2018, 3, 6)
  117.     d3 = CustomDate(2024, 3, 13)
  118.     print(d1 >= d2)  # False
  119.     print(d1 >= d3)  # False
  120.     print(d2 >= d3)  # False
  121.     # 尝试与其他类型比较，将会返回NotImplemented
  122.     # print(d1 >= (2023, 3, 15))  # TypeError: '>=' not supported between instances of 'CustomDate' and 'tuple'
  123.  
  124. # 7、自定义价格类
  125. class Price:
  126.     def __init__(self, amount):
  127.         self.amount = amount
  128.     def __ge__(self, other):
  129.         if isinstance(other, Price):
  130.             return self.amount >= other.amount
  131.         elif isinstance(other, (int, float)):
  132.             return self.amount >= other
  133.         else:
  134.             return NotImplemented
  135. if __name__ == '__main__':
  136.     p1 = Price(10.24)
  137.     p2 = Price(10.18)
  138.     print(p1 >= p2)  # True
  139.     print(p1 >= 10)  # True
  140.  
  141. # 8、自定义成绩类
  142. class Grade:
  143.     def __init__(self, score):
  144.         self.score = score
  145.     def __ge__(self, other):
  146.         if isinstance(other, Grade):
  147.             return self.score >= other.score
  148.         elif isinstance(other, (int, float)):
  149.             return self.score >= other
  150.         else:
  151.             return NotImplemented
  152.     def __str__(self):
  153.         return f"Grade: {self.score}"
  154. if __name__ == '__main__':
  155.     g1 = Grade(85)
  156.     g2 = Grade(80)
  157.     print(g1 >= g2)  # True
  158.     print(g1 >= 85)  # True
  159.  
  160. # 9、自定义长度单位类
  161. class Length:
  162.     def __init__(self, meters):
  163.         self.meters = meters
  164.     def __ge__(self, other):
  165.         if isinstance(other, Length):
  166.             return self.meters >= other.meters
  167.         elif isinstance(other, (int, float)):
  168.             return self.meters >= other
  169.         else:
  170.             return NotImplemented
  171.     def __str__(self):
  172.         return f"{self.meters} meters"
  173. if __name__ == '__main__':
  174.     l1 = Length(10)
  175.     l2 = Length(5)
  176.     print(l1 >= l2)  # True
  177.     print(l1 >= 8)  # True
  178.  
  179. # 10、自定义权重类(考虑精度)
  180. from decimal import Decimal, getcontext
  181. class Weight:
  182.     def __init__(self, value, precision=2):
  183.         getcontext().prec = precision + 2  # 设置精度以支持比较
  184.         self.value = Decimal(value)
  185.     def __ge__(self, other):
  186.         if isinstance(other, Weight):
  187.             return self.value >= other.value
  188.         elif isinstance(other, (int, float, Decimal)):
  189.             return self.value >= Decimal(other)
  190.         else:
  191.             return NotImplemented
  192.     def __str__(self):
  193.         return f"{self.value:.{getcontext().prec - 2}f} kg"
  194. if __name__ == '__main__':
  195.     w1 = Weight('10.24')
  196.     w2 = Weight('10.18')
  197.     print(w1 >= w2)  # True
  198.     print(w1 >= 10.5)  # False
  199.  
  200. # 11、自定义日期类
  201. from datetime import datetime
  202. class CustomDate:
  203.     def __init__(self, year, month, day):
  204.         self.date = datetime(year, month, day)
  205.     def __ge__(self, other):
  206.         if isinstance(other, CustomDate):
  207.             return self.date >= other.date
  208.         elif isinstance(other, datetime):
  209.             return self.date >= other
  210.         else:
  211.             return NotImplemented
  212.     def __str__(self):
  213.         return self.date.strftime('%Y-%m-%d')
  214. if __name__ == '__main__':
  215.     d1 = CustomDate(2024, 3, 13)
  216.     d2 = CustomDate(2024, 5, 11)
  217.     print(d1 >= d2)  # False
  218.     print(d1 >= datetime(2023, 3, 15))  # True
  219.  
  220. # 12、自定义版本类
  221. class Version:
  222.     def __init__(self, version_string):
  223.         self.parts = tuple(map(int, version_string.split('.')))
  224.     def __ge__(self, other):
  225.         if isinstance(other, Version):
  226.             return self.parts >= other.parts
  227.         elif isinstance(other, str):
  228.             other_version = Version(other)
  229.             return self.parts >= other_version.parts
  230.         else:
  231.             return NotImplemented
  232.     def __str__(self):
  233.         return '.'.join(map(str, self.parts))
  234. if __name__ == '__main__':
  235.     v1 = Version('1.2.3')
  236.     v2 = Version('1.2.2')
  237.     print(v1 >= v2)  # True
  238.     print(v1 >= '1.2.3')  # True

22、__get__方法

22-1、语法
  1. __get__(self, instance, owner=None, /)
  2.     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、用法
  1. # 022、__get__方法：
  2. # 1、简单的属性访问
  3. class MyDescriptor:
  4.     def __init__(self, initial_value):
  5.         self.value = initial_value
  6.     def __get__(self, instance, owner):
  7.         return self.value
  8. class MyClass:
  9.     x = MyDescriptor(10)
  10. if __name__ == '__main__':
  11.     obj = MyClass()
  12.     print(obj.x)  # 输出: 10
  13.  
  14. # 2、访问实例属性(如果存在)
  15. class MyDescriptor:
  16.     def __init__(self, name):
  17.         self.name = name
  18.     def __get__(self, instance, owner):
  19.         if instance is not None and hasattr(instance, self.name):
  20.             return instance.__dict__[self.name]
  21.         return None
  22. class MyClass:
  23.     def __init__(self, value):
  24.         self.x = value
  25.     x = MyDescriptor('x')
  26. if __name__ == '__main__':
  27.     obj = MyClass(20)
  28.     print(obj.x)  # 输出: 20
  29.  
  30. # 3、属性计算
  31. class MyDescriptor:
  32.     def __get__(self, instance, owner):
  33.         if instance is None:
  34.             return self
  35.         return instance.y * 2
  36. class MyClass:
  37.     z = MyDescriptor()
  38.     def __init__(self, y):
  39.         self.y = y
  40. if __name__ == '__main__':
  41.     obj = MyClass(5)
  42.     print(obj.z)  # 输出: 10
  43.  
  44. # 4、访问控制(只读)
  45. class MyDescriptor:
  46.     def __init__(self, value):
  47.         self._value = value
  48.     def __get__(self, instance, owner):
  49.         return self._value
  50.     def __set__(self, instance, value):
  51.         raise AttributeError("This attribute is read-only")
  52. class MyClass:
  53.     x = MyDescriptor(10)
  54. if __name__ == '__main__':
  55.     obj = MyClass()
  56.     print(obj.x)  # 输出: 10
  57.     # obj.x = 20  # 这会抛出一个AttributeError: This attribute is read-only
  58.  
  59. # 5、延迟初始化
  60. class MyDescriptor:
  61.     def __get__(self, instance, owner):
  62.         if not hasattr(instance, '_initialized'):
  63.             print('Initializing...')
  64.             instance._initialized = True
  65.             instance.y = 42
  66.         return instance.y
  67. class MyClass:
  68.     y = MyDescriptor()
  69. if __name__ == '__main__':
  70.     obj = MyClass()
  71.     print(obj.y)  # 输出: Initializing... 42
  72.  
  73. # 6、线程安全属性(简化版)
  74. import threading
  75. class ThreadSafeDescriptor:
  76.     def __init__(self, init_value):
  77.         self._lock = threading.Lock()
  78.         self._value = init_value
  79.  
  80.     def __get__(self, instance, owner):
  81.         with self._lock:
  82.             return self._value
  83.  
  84.     def __set__(self, instance, value):
  85.         with self._lock:
  86.             self._value = value
  87. # 省略了 __set__ 的实际使用，因为它在这个简化的例子中并不明显
  88.  
  89. # 7、验证属性值
  90. class MyDescriptor:
  91.     def __init__(self):
  92.         self._value = None
  93.     def __get__(self, instance, owner):
  94.         return self._value
  95.     def __set__(self, instance, value):
  96.         if not isinstance(value, int) or value < 0:
  97.             raise ValueError("Value must be a non-negative integer")
  98.         self._value = value
  99. class MyClass:
  100.     x = MyDescriptor()
  101. if __name__ == '__main__':
  102.     obj = MyClass()
  103.     obj.x = 10  # 正常
  104.     # obj.x = -1  # 这会抛出一个 ValueError
  105.  
  106. # 8、缓存属性值
  107. class CachedDescriptor:
  108.     def __init__(self, func):
  109.         self.func = func
  110.         self.name = func.__name__
  111.     def __get__(self, instance, owner):
  112.         if instance is None:
  113.             return self
  114.         # 尝试从实例的缓存中获取值
  115.         cache = getattr(instance, '__cache__', None)
  116.         if cache is None:
  117.             cache = {}
  118.             setattr(instance, '__cache__', cache)
  119.         if self.name not in cache:
  120.             # 如果缓存中没有值，则调用函数并存储结果
  121.             cache[self.name] = self.func(instance)
  122.         return cache[self.name]
  123. class MyClass:
  124.     def __init__(self, data):
  125.         self.data = data
  126.     @CachedDescriptor
  127.     def expensive_calculation(self):
  128.         print("Calculating...")
  129.         # 假设这是一个非常耗时的计算
  130.         result = sum(range(self.data))
  131.         return result
  132. if __name__ == '__main__':
  133.     obj = MyClass(1000)
  134.     print(obj.expensive_calculation)  # 输出: Calculating... 和计算结果
  135.     print(obj.expensive_calculation)  # 直接从缓存中获取，不会再次计算
  136.  
  137. # 9、属性依赖其他属性
  138. class DependentDescriptor:
  139.     def __init__(self, attr_name):
  140.         self.attr_name = attr_name
  141.     def __get__(self, instance, owner):
  142.         if instance is None:
  143.             return self
  144.         # 假设另一个属性是 instance.base_value
  145.         base_value = getattr(instance, 'base_value', None)
  146.         if base_value is not None:
  147.             return base_value * 2  # 假设这个描述符的值是 base_value 的两倍
  148.         return None
  149. class MyClass:
  150.     double_value = DependentDescriptor('base_value')
  151.     def __init__(self, base_value):
  152.         self.base_value = base_value
  153. if __name__ == '__main__':
  154.     obj = MyClass(5)
  155.     print(obj.double_value)  # 输出: 10

五、推荐阅读

1、Python筑基之旅

2、Python函数之旅

3、Python算法之旅

4、博客个人主页

文章知识点与官方知识档案匹配，可进一步学习相关知识
Python入门技能树首页概览425874 人正在系统学习中
遨游码海，我心飞扬
微信名片
注：本文转载自blog.csdn.net的神奇夜光杯的文章"https://myelsa1024.blog.csdn.net/article/details/139333081"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！