Python 中的魔法函数，也被称为特殊方法或双下划线方法，是 Python 中一些特殊命名的函数，它们以双下划线开头和结尾。这些函数定义了对象在特定情况下的行为，例如创建、比较、运算、迭代等。
魔法函数主要是为某些特殊需求而设计的。例如__str__() 和__repr__() 函数用于打印输出对象的信息，__add__() 函数用于定义两个对象相加的行为，__len__() 函数定义当被 len() 调用时的行为等。Python 魔法函数是实现 Python 语法糖的一种方式，提高代码的可读性和可维护性，比如对象相加，大家更习惯 c = a + b 的形式，如果用户使用 a + b 能自动调用 a.__add__(b) 的话，自然要方便很多了，而魔法函数正好有这种功能。
魔法函数
__init__
__init__ 对象初始化函数，在创建实例化对象时自动调用。这个最熟悉的就不多说了。
|
1
2
3
4
5
|
class TestClass:
def __init__(self, name):
self.name = name
obj = TestClass("Alice")
|
__str__
以用户友好的方式返回对象的字符串表示，使用 str() 时自动调用。
|
1
2
3
4
5
6
7
8
9
10
|
class PointClass:
def __init__(self, x, y):
self.x = x
self.y = y
def __str__(self):
return f"({self.x}, {self.y})"
p = PointClass(3, 4)
print(p) # (3, 4)
|
__repr__
以开发者友好的方式返回对象的字符串表示，使用 repr() 时自动调用。当使用 print() 函数打印对象时，首先调用的是 __str__ 方法，如果对象没有定义 __str__ 方法，才会调用 __repr__ 方法。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
class PointClass:
def __init__(self, x, y):
self.x = x
self.y = y
def __str__(self):
return f"({self.x}, {self.y})"
def __repr__(self):
return f"Point({self.x}, {self.y})"
p = PointClass(3, 4)
print(p) # (3, 4)
print(str(p)) # (3, 4)
print(repr(p)) # Point(3, 4)
|
__len__
返回对象的长度，使用 len() 自动调用。
|
1
2
3
4
5
6
7
8
9
|
class ListClass:
def __init__(self, items):
self.items = items
def __len__(self):
return len(self.items)
my_list = ListClass([1, 2, 3, 4, 5])
print(len(my_list)) # 5
|
__missing__
当尝试访问字典中不存在的键时，如果定义了 __missing__ 方法，它将被调用，而不是抛出 KeyError。
|
1
2
3
4
5
6
7
8
9
10
11
12
|
class DictClass(dict):
def __missing__(self, key):
self[key] = "default"
return "default"
my_dict = DictClass({'a': 1, 'b': 2})
print(my_dict['c']) # default
print(my_dict.keys()) # dict_keys(['a', 'b', 'c'])
my_dict = dict({'a': 1, 'b': 2})
print(my_dict['c']) # KeyError: 'c'
|
__getitem__
获取对象的指定元素，当使用索引操作符[]来访问对象的元素时自动调用。
|
1
2
3
4
5
6
7
8
9
|
class DictClass:
def __init__(self, items):
self.items = items
def __getitem__(self, key):
return self.items.get(key)
my_dict = DictClass({'a': 1, 'b': 2})
print(my_dict['a']) # 1
|
__setitem__
给对象的指定元素设置值，给对象设定值时自动调用。
|
1
2
3
4
5
6
7
8
9
10
|
class DictClass:
def __init__(self, items):
self.items = items
def __setitem__(self, key, value):
self.items[key] = value
my_dict = DictClass({'a': 1, 'b': 2})
my_dict['c'] = 3
print(my_dict.items) # {'a': 1, 'b': 2, 'c': 3}
|
__delitem__
删除对象指定元素，使用 del 删除对象元素时自动调用。
|
1
2
3
4
5
6
7
8
9
10
|
class DictClass:
def __init__(self, items):
self.items = items
def __delitem__(self, key):
del self.items[key]
my_dict = DictClass({'a': 1, 'b': 2})
del my_dict['a']
print(my_dict.items) # {'b': 2}
|
__contains__
判断对象是否包含指定元素，使用 in 判断时自动调用。
|
1
2
3
4
5
6
7
8
9
|
class ListClass:
def __init__(self, items):
self.items = items
def __contains__(self, item):
return item in self.items
my_list = ListClass([1, 2, 3, 4, 5])
print(3 in my_list) # True
|
__iter__
返回迭代器对象。
|
1
2
3
4
5
6
7
8
9
10
|
class ListClass:
def __init__(self, items):
self.items = items
def __iter__(self):
return iter(self.items)
my_list = ListClass([1, 2, 3, 4, 5])
for item in my_list:
print(item) # 依次输出: 1, 2, 3, 4, 5
|
__next__
返回迭代器的下一个元素，循环遍历获取对象元素时自动调用。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
class ListClass:
def __init__(self, items):
self.items = items
self.index = 0
def __iter__(self):
return self
def __next__(self):
if self.index >= len(self.items):
raise StopIteration
value = self.items[self.index]
self.index += 1
return value
my_list = ListClass([1, 2, 3, 4, 5])
for item in my_list:
print(item) # 依次输出: 1, 2, 3, 4, 5
|
__eq__
判断两个对象是否相等，两个对象使用 == 判断时自动调用。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
class PointClass:
def __init__(self, x, y):
self.x = x
self.y = y
def __eq__(self, other):
return self.x == other.x and self.y == other.y
p1 = PointClass(3, 4)
p2 = PointClass(3, 4)
p3 = PointClass(5, 6)
print(p1 == p2) # True
print(p1 == p3) # False
|
__abs__
输出对象的绝对值。
|
1
2
3
4
5
6
7
8
9
10
|
class PointClass:
def __init__(self, x, y):
self.x = x
self.y = y
def __abs__(self):
return (self.x * self.x + self.y * self.y) ** 0.5
p1 = PointClass(3, 4)
print(abs(p1)) # 5.0
|
__lt__
判断一个对象是否小于另一个对象。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
class PointClass:
def __init__(self, x, y):
self.x = x
self.y = y
def __lt__(self, other):
return self.x < other.x and self.y < other.y
p1 = PointClass(3, 4)
p2 = PointClass(3, 4)
p3 = PointClass(5, 6)
print(p1 < p2) # False
print(p1 < p3) # True
|
__le__
判断一个对象是否小于或等于另一个对象。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
class PointClass:
def __init__(self, x, y):
self.x = x
self.y = y
def __le__(self, other):
return self.x <= other.x and self.y <= other.y
p1 = PointClass(3, 4)
p2 = PointClass(3, 4)
p3 = PointClass(5, 6)
print(p1 <= p2) # True
print(p1 <= p3) # True
|
__gt__
判断一个对象是否大于另一个对象。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
class PointClass:
def __init__(self, x, y):
self.x = x
self.y = y
def __gt__(self, other):
return self.x > other.x and self.y > other.y
p1 = PointClass(3, 4)
p2 = PointClass(3, 4)
p3 = PointClass(1, 2)
print(p1 > p2) # False
print(p1 > p3) # True
|
__ge__
判断一个对象是否大于或等于另一个对象。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
class PointClass:
def __init__(self, x, y):
self.x = x
self.y = y
def __ge__(self, other):
return self.x >= other.x and self.y >= other.y
p1 = PointClass(3, 4)
p2 = PointClass(3, 4)
p3 = PointClass(1, 2)
print(p1 >= p2) # True
print(p1 >= p3) # True
|
__add__
定义对象的加法操作，对象之间使用 + 自动调用。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
class PointClass:
def __init__(self, x, y):
self.x = x
self.y = y
def __add__(self, other):
return PointClass(self.x + other.x, self.y + other.y)
def __str__(self):
return f"({self.x}, {self.y})"
p1 = PointClass(1, 2)
p2 = PointClass(3, 4)
print(p1 + p2) # (4, 6)
|
__sub__
定义对象的减法操作，对象之间使用 - 自动调用。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
class PointClass:
def __init__(self, x, y):
self.x = x
self.y = y
def __sub__(self, other):
return PointClass(self.x - other.x, self.y - other.y)
def __str__(self):
return f"({self.x}, {self.y})"
p1 = PointClass(1, 2)
p2 = PointClass(3, 4)
print(p1 - p2) # (-2, -2)
|
__mul__
定义对象的乘法操作，对象之间使用 * 自动调用，可以根据操作数类型进行对象乘法和数乘。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
class PointClass:
def __init__(self, x, y):
self.x = x
self.y = y
def __mul__(self, other):
if isinstance(other, PointClass):
return PointClass(self.x * other.x, self.y * other.y)
elif isinstance(other, int) or isinstance(other, float):
return PointClass(self.x * other, self.y * other)
else:
raise TypeError(f"Unsupported operand type: {type(other)}")
def __str__(self):
return f"({self.x}, {self.y})"
p1 = PointClass(1, 2)
p2 = PointClass(3, 4)
print(p1 * p2) # (3, 8)
print(p1 * 3) # (3, 6)
print(p1 * "t") # TypeError: Unsupported operand type: <class 'str'>
|
__call__
使对象可调用。
|
1
2
3
4
5
6
7
8
9
10
11
12
|
class Calculator:
def __init__(self, x, y):
self.x = x
self.y = y
def __call__(self):
return self.x + self.y
calc = Calculator(3, 4)
result = calc()
print(result) # 7
|
|
1
2
3
4
5
6
7
|
class Calculator:
def __call__(self, a, b):
return a + b
calc = Calculator()
result = calc(3, 4)
print(result) # 7
|
__getattr__
在访问对象不存在的属性时调用。
|
1
2
3
4
5
6
|
class Person:
def __getattr__(self, name):
return f"Attribute '{name}' does not exist."
p = Person()
print(p.age) # Attribute 'age' does not exist.
|
__setattr__
当设置类实例属性时自动调用。
|
1
2
3
4
5
6
7
8
|
class Person:
def __setattr__(self, name, value):
print(f"Setting attribute '{name}' to '{value}'")
super().__setattr__(name, value)
p = Person()
p.name = "Alice" # Setting attribute 'name' to 'Alice'
print(p.name) # Alice
|
__delattr__
删除对象属性时自动调用。
|
1
2
3
4
5
6
7
8
9
10
|
class Person:
def __delattr__(self, name):
print(f"Deleting attribute '{name}'")
super().__delattr__(name)
p = Person()
p.name = "Alice"
print(p.name) # Alice
del p.name # Deleting attribute 'name'
print(p.name) # AttributeError: 'Person' object has no attribute 'name
|
__enter__
__enter__() 方法用于进入上下文管理器所定义的代码块之前执行的操作。
__exit__
上下文管理器的 __exit__() 方法还有三个参数，即异常类型、异常值和追踪信息。如果在 with 语句块中发生了异常，这些参数会传递给 __exit__() 方法，可以在该方法中进行相关的处理。
__del__
当对象不再被引用时，Python的垃圾回收机制会调用这个方法。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
class FileHandler:
def __init__(self, filename):
self.filename = filename
def __enter__(self):
print("goto __enter__ open file")
self.file = open(self.filename, 'w', encoding='utf-8')
return self.file
def __exit__(self, exc_type, exc_val, exc_tb):
print("goto __exit__ close file")
self.file.close()
def __del__(self):
print("goto __del__ release resource")
print("process start")
with FileHandler("./test.txt") as f:
f.write("hello world!\n")
print("process end")
# process start
# goto __enter__ open file
# goto __exit__ close file
# goto __del__ release resource
# process end
|
魔法属性
__dict__
__dict__ 包含通过 __init__方法初始化的属性和值。
|
1
2
3
4
5
6
7
8
9
10
|
class TestClass:
def __init__(self, name):
self.name = name
def test(self):
self.age = 25
obj = TestClass("Alice")
print(obj.__dict__) # {'name': 'Alice'}
# print(TestClass.__dict__)
|
__slots__
内置类属性__slots__是一个特殊的内置类属性，它可以用于定义类的属性名称的集合。一旦在类中定义了__slots__属性，Python 将限制该类的实例只能拥有__slots__中定义的属性。
|
1
2
3
4
5
6
7
8
9
10
11
12
|
class Person:
__slots__ = ('name', 'age')
def __init__(self, name, age):
self.name = name
self.age = age
self.address = "" # AttributeError: 'Person' object has no attribute 'address'
person = Person("Alice", 30)
print(person.name) # 输出 "Alice"
print(person.age) # 输出 30
print(person.__slots__) # ('name', 'age')
|
|
