Introduction
In Python, all methods enclosed by "" double underscores are collectively called "Magic Method", such as the initialization method of a classinit, All magic methods in Python have corresponding descriptions in official documents, but the official descriptions are confusing and loosely organized. It's hard to find an example.
Construction and initialization
Every Pythoner knows the most basic magic method, init. Through this method we can define the initial operation of an object. However, when x = SomeClass() is called, init is not the first method called. In fact, there is another method called <a href="http://www.php.cn/wiki/165.html" target="_blank">new</a>, and the two together form the "constructor".
new is used to create a class and return an instance of this class, while init just initializes the instance with the passed parameters.
At the end of the object life cycle, the del method will be called, and del can be understood as the "destructor". Let’s take a look at these three methods through the code:
from os.path import join
class FileObject:
'''给文件对象进行包装从而确认在删除时文件流关闭'''
def init(self, filepath='~', filename='sample.txt'):
#读写模式打开一个文件
self.file = open(join(filepath, filename), 'r+')
def del(self):
self.file.close()
del self.file
Copy after login
Many people who come to Python from other languages will complain that it lacks the real functionality of classes. Encapsulation. (There is no way to define a private variable and then define a public getter and setter). Python can actually complete encapsulation through magic methods. Let’s take a look:
Define when the user tries to get a non-existent behavior when using the attribute. This applies to retrieving and redirecting common spelling errors, warning when retrieving some deprecated attributes (you can also calculate and give a value if you like) or handling an AttributeError. It will only be returned when calling a property that does not exist.
and getattr(self, name)Different, setattr is an encapsulated solution. Regardless of whether the attribute exists, it allows you to define the assignment behavior to the attribute, so that you can customize the value of the attribute. When implementing setattr, avoid the "infinite recursion" error.
Same as setattr, but the function is to delete an attribute instead of Set them up. It is also necessary to prevent infinite recursion during implementation.
##
getattribute defines that your attribute is The behavior when accessed, in comparison, getattr will only work when the attribute does not exist. Therefore, in Python versions that support getattribute, getattribute must be called before calling getattr. getattributeAlso avoid the "infinite recursion" error. It should be reminded that it is best not to try to implement getattribute, because this approach is rarely seen and it is easy to cause bugs.
When defining attribute access control, it may easily cause "infinite recursion". For example, the following code:
# 错误用法
def setattr(self, name, value):
self.name = value
# 每当属性被赋值的时候(如self.name = value)， ``setattr()`` 会被调用，这样就造成了递归调用。
# 这意味这会调用 ``self.setattr('name', value)`` ，每次方法会调用自己。这样会造成程序崩溃。
# 正确用法
def setattr(self, name, value):
self.dict[name] = value # 给类中的属性名分配值
# 定制特有属性Copy after login
Python’s magic method is very powerful, but it needs to be used with caution. It is very important to understand the correct method of use.
Create a custom container
There are many ways to make your Python class behave the same as the built-in container types, such as our commonly used list, dict, tuple,
string, etc. wait. Python's container types are divided into variable types (such as list, dict) and immutable types (such as string, tuple). The difference between variable containers and immutable containers is that once a value is assigned to an immutable container, one of them cannot be modified. elements are modified. Before talking about creating a custom container, you should first understand the protocol. The protocol here is very similar to the so-called "interface" concept in other languages. It gives you a lot of methods that you have to define. However, protocols in Python are very informal and do not require explicit implementation declarations. In fact, they are more like a guide.
自定义容器的magic method
下面细致了解下定义容器可能用到的魔术方法。首先，实现不可变容器的话，你只能定义 len 和 getitem (下面会讲更多)。可变容器协议则需要所有不可变容器的所有，另外还需要 setitem 和 delitem 。如果你希望你的对象是可迭代的话，你需要定义 iter 会返回一个迭代器。迭代器必须遵循迭代器协议，需要有 iter(返回它本身) 和 next。
返回容器的长度。对于可变和不可变容器的协议，这都是其中的一部分。
定义当某一项被访问时，使用self[key]所产生的行为。这也是不可变容器和可变容器协议的一部分。如果键的类型错误将产生TypeError；如果key没有合适的值则产生KeyError。
当你执行self[key] = value时，调用的是该方法。
定义当一个项目被删除时的行为(比如 del self[key])。这只是可变容器协议中的一部分。当使用一个无效的键时应该抛出适当的异常。
返回一个容器迭代器，很多情况下会返回迭代器，尤其是当内置的iter()方法被调用的时候，以及当使用for x in container:方式循环的时候。迭代器是它们本身的对象，它们必须定义返回self的iter方法。
实现当reversed()被调用时的行为。应该返回序列反转后的版本。仅当序列可以是有序的时候实现它，例如对于列表或者元组。
定义了调用in和not in来测试成员是否存在的时候所产生的行为。你可能会问为什么这个不是序列协议的一部分？因为当contains没有被定义的时候，如果没有定义，那么Python会迭代容器中的元素来一个一个比较，从而决定返回True或者False。
dict字典类型会有该方法，它定义了key如果在容器中找不到时触发的行为。比如d = {'a': 1}, 当你执行d[notexist]时，d.missing['notexist']就会被调用。
一个列子
下面是书中的例子，用魔术方法来实现Haskell语言中的一个数据结构。
# -*- coding: utf-8 -*-
class FunctionalList:
''' 实现了内置类型list的功能,并丰富了一些其他方法: head, tail, init, last, drop, take'''
def init(self, values=None):
if values is None:
self.values = []
else:
self.values = values
def len(self):
return len(self.values)
def getitem(self, key):
return self.values[key]
def setitem(self, key, value):
self.values[key] = value
def delitem(self, key):
del self.values[key]
def iter(self):
return iter(self.values)
def reversed(self):
return FunctionalList(reversed(self.values))
def append(self, value):
self.values.append(value)
def head(self):
# 获取第一个元素
return self.values[0]
def tail(self):
# 获取第一个元素之后的所有元素
return self.values[1:]
def init(self):
# 获取最后一个元素之前的所有元素
return self.values[:-1]
def last(self):
# 获取最后一个元素
return self.values[-1]
def drop(self, n):
# 获取所有元素，除了前N个
return self.values[n:]
def take(self, n):
# 获取前N个元素
return self.values[:n]
Copy after login
其实在collections模块中已经有了很多类似的实现，比如Counter、OrderedDict等等。
反射
你也可以控制怎么使用内置在函数sisinstance()和issubclass()方法 反射定义魔术方法. 这个魔术方法是:
检查一个实例是不是你定义的类的实例
这些魔术方法的用例看起来很小, 并且确实非常实用. 它们反应了关于面向对象程序上一些重要的东西在Python上,并且总的来说Python: 总是一个简单的方法去找某些事情, 即使是没有必要的. 这些魔法方法可能看起来不是很有用, 但是一旦你需要它们，你会感到庆幸它们的存在。
可调用的对象
你也许已经知道，在Python中，方法是最高级的对象。这意味着他们也可以被传递到方法中，就像其他对象一样。这是一个非常惊人的特性。
在Python中，一个特殊的魔术方法可以让类的实例的行为表现的像函数一样，你可以调用它们，将一个函数当做一个参数传到另外一个函数中等等。这是一个非常强大的特性，其让Python编程更加舒适甜美。
允许一个类的实例像函数一样被调用。实质上说，这意味着 x() 与 x.call() 是相同的。注意 call 的参数可变。这意味着你可以定义 call 为其他你想要的函数，无论有多少个参数。
call 在那些类的实例经常改变状态的时候会非常有效。调用这个实例是一种改变这个对象状态的直接和优雅的做法。用一个实例来表达最好不过了:
# -*- coding: UTF-8 -*-
class Entity:
"""
调用实体来改变实体的位置
"""
def init(self, size, x, y):
self.x, self.y = x, y
self.size = size
def call(self, x, y):
"""
改变实体的位置
"""
self.x, self.y = x, y
Copy after login
上下文管理
with声明是从Python2.5开始引进的关键词。你应该遇过这样子的代码:
with open('foo.txt') as bar:
# do something with barCopy after login
在with声明的代码段中，我们可以做一些对象的开始操作和退出操作,还能对异常进行处理。这需要实现两个魔术方法: enter 和 exit。
定义了当使用with语句的时候，会话管理器在块被初始创建时要产生的行为。请注意，enter的返回值与with语句的目标或者as后的名字绑定。
exit(self, <a href="http://www.php.cn/wiki/265.html" target="_blank">exception</a>_type, exception_value, traceback):
定义了当一个代码块被执行或者终止后，会话管理器应该做什么。它可以被用来处理异常、执行清理工作或做一些代码块执行完毕之后的日常工作。如果代码块执行成功，exception_type，exception_value，和traceback将会为None。否则，你可以选择处理这个异常或者是直接交给用户处理。如果你想处理这个异常的话，请确保exit在所有语句结束之后返回True。如果你想让异常被会话管理器处理的话，那么就让其产生该异常。
描述器是通过获取、设置以及删除的时候被访问的类。当然也可以改变其它的对象。描述器并不是独立的。相反，它意味着被一个所有者类持有。当创建面向对象的数据库或者类，里面含有相互依赖的属相时，描述器将会非常有用。一种典型的使用方法是用不同的单位表示同一个数值，或者表示某个数据的附加属性。
为了成为一个描述器，一个类必须至少有get，set，<a href="http://www.php.cn/wiki/1298.html" target="_blank">delete</a>方法被实现：
-
get(self, instance, owner):
定义了当描述器的值被取得的时候的行为。instance是拥有该描述器对象的一个实例。owner是拥有者本身
-
set(self, instance, value):
定义了当描述器的值被改变的时候的行为。instance是拥有该描述器类的一个实例。value是要设置的值。
-
delete(self, instance):
定义了当描述器的值被删除的时候的行为。instance是拥有该描述器对象的一个实例。
下面是一个描述器的实例：单位转换。
# -*- coding: UTF-8 -*-
class Meter(object):
"""
对于单位"米"的描述器
"""
def init(self, value=0.0):
self.value = float(value)
def get(self, instance, owner):
return self.value
def set(self, instance, value):
self.value = float(value)
class Foot(object):
"""
对于单位"英尺"的描述器
"""
def get(self, instance, owner):
return instance.meter * 3.2808
def set(self, instance, value):
instance.meter = float(value) / 3.2808
class Distance(object):
"""
用米和英寸来表示两个描述器之间的距离
"""
meter = Meter(10)
foot = Foot()
Copy after login
使用时：
>>>d = Distance()
>>>print d.foot
>>>print d.meter
32.808
10.0
Copy after login
复制
有时候，尤其是当你在处理可变对象时，你可能想要复制一个对象，然后对其做出一些改变而不希望影响原来的对象。这就是Python的copy所发挥作用的地方。
定义了当对你的类的实例调用copy.copy()时所产生的行为。copy.copy()返回了你的对象的一个浅拷贝——这意味着，当实例本身是一个新实例时，它的所有数据都被引用了——例如，当一个对象本身被复制了，它的数据仍然是被引用的（因此，对于浅拷贝中数据的更改仍然可能导致数据在原始对象的中的改变）。
定义了当对你的类的实例调用copy.deepcopy()时所产生的行为。copy.deepcopy()返回了你的对象的一个深拷贝——对象和其数据都被拷贝了。memodict是对之前被拷贝的对象的一个缓存——这优化了拷贝过程并且阻止了对递归数据结构拷贝时的无限递归。当你想要进行对一个单独的属性进行深拷贝时，调用copy.deepcopy()，并以memodict为第一个参数。
Appendix
Magic method for comparison
cmp(self, other) |
is the most basic magic method among comparison methods |
eq(self, other) |
Define the behavior of equality symbols, == |
ne(self,other) |
Define the behavior of the inequality symbol,! = |
lt(self,other) |
Define the behavior of the less than symbol, < |
gt(self,other) | Define the behavior of the greater than symbol, > |
le(self,other) |
Define the behavior of the less than or equal symbol, <= |
ge(self,other) | Definition of greater than or equal to Symbolic behavior, >= |
##Magic methods for numerical calculations
Unary
Operators and functions
##pos(self)
Implement an operation of taking a positive number |
|
neg(self)
|
|
abs(self)
|
|
invert( self)
| operator(～operator)
|
round(self, n )
|
|
floor(self)
|
|
##ceil(self)
Implements the functional behavior of math.ceil() |
|
trunc(self)
Implement the function behavior of math.trunc() |
|
Binary operation symbol or function
Magic method##add( self, other)
Realize an addition |
##sub(self, other) |
Realize a subtraction |
mul(self, other) |
Realize a multiplication |
floorp(self , other) |
Implement an integer division operation () generated by the "//" operator |
p(self, other) |
Realize a division operation represented by the "/" operator |
truep(self, other) |
Realize true division |
mod(self, other) |
Implement a modulo operation represented by the "%" operator |
pmod(self, other) |
Implement a built-in function pmod() |
pow |
Implement the behavior of an exponential operation ("**" operator) | ##lshift(self, other) |
Implementation The function of a bit left shift operation (<<) | rshift(self, other) |
implements a bit right shift operation ( >>) Function
|
| Implements the behavior of a bitwise AND operation (&)
##or(self, other) |
Implement the behavior of a bitwise OR operation |
xor(self, other)
|
| xor(self, other)
Increment operation
iadd(self, other) |
Additional assignment |
isub(self, other) |
Subtractive assignment |
imul(self, other) |
Multiplication assignment |
ifloorp(self , other) |
Integer division assignment, floor division, equivalent to //= operator |
ip(self, other) |
Division assignment, equivalent to /= operator |
itruep(self, other) |
True division assignment |
imod_(self, other) |
Modular assignment, equivalent to %= operator |
ipow |
Power assignment, equivalent to **= operator |
##ilshift(self, other) | Left shift assignment, equivalent to <<= operator | irshift(self, other) | Left shift assignment, equivalent In >>= operator |
iand(self, other) | and assignment, it is equivalent to &= operator |
ior(self, other) | or assignment |
ixor(self, other) | XOR operator, equivalent to ^= operator |
Type conversion
##int(self)
|
|
long(self)
|
|
float(self)
| float |
##complex(self)
Convert to plural type |
| ##oct(self)
Convert to octal |
| hex(self)
Convert to hexadecimal |
##index(self) |
If you define a numeric type that may be used for slicing operations, you should define index |
trunc(self) |
Called when math.trunc(self) is usedtruncReturns an integer intercept of the self type
|
|
Perform mixed type operations |
|
The above is the detailed content of Detailed introduction to Python magic method Magic Method. For more information, please follow other related articles on the PHP Chinese website!
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
