Completely master the double-down method in Python

This article brings you relevant knowledge about Python . There are some special methods in Python whose method names begin and end with double underscores, so they are also called double underscore methods. Let’s take a look at it together, I hope it will be helpful to everyone.

[Related recommendations: Python3 video tutorial ]

Preface Everyone has something to remember when writing Python code There is no such doubt.

Why does the number in mathematics become a splicing function in string operations, such as 'ab' 'cd' The result is abcd ; and the number * becomes a repeated function, such as 'ab' * 2 , the result is abab .

Why some objects print can output data, but print custom class objects output a bunch of incomprehensible code ed2f2d7ff9fc9df585859ed324192a57 .

It’s not because the system has been specially customized, but because there is a special type of method in Python that is automatically called on certain occasions. For example, after the __add__ method is defined in the string class str , when the code encounters string addition 'ab' 'cd' , it will Automatically call the __add__ method to complete string splicing.

Because the method names of this type of special method start and end with double underscores, they are also called double-underscore methods.

There are many double download methods in Python. Today we will explain it in detail.

Double download method in Python

1. The init method __init__ is a method that many people come into contact with The first Double down method .

class A: def __init__(self, a): self.a = a When calling A() to instantiate an object, the __init__ method will be automatically called to complete the initialization of the object.

2. Double under method of operator Define operator-related double under method in the class, you can directly add, subtract, multiply, divide, and compare on the class object Wait for operations.

Here, define a ruler class Rule , which contains an attribute r_len representing the length of the ruler.

class Rule: def __init__(self, r_len): self.r_len = r_len 2.1 Comparison operators If you want to compare different rulers according to their length, you need to define comparison operators in the Rule class.

class Rule: def __init__(self, r_len): self.r_len = r_len

# < 运算符 def __lt__(self, other): return self.r_len < other.r_len

# <= 运算符 def __le__(self, other): return self.r_len <= other.r_len

# > 运算符 def __gt__(self, other): return self.r_len > other.r_len

# >= 运算符 def __ge__(self, other): return self.r_len >= other.r_len Four comparisons a8a5a9aa8e3f84589d12252bdf50cac1 and >= are defined here operator, so that the Rule objects can be compared using the following code.

rule1 = Rule(10) rule2 = Rule(5) print(rule1 > rule2) # True print(rule1 >= rule2) # True print(rule1 When > is used to compare rule1 and rule2 , the rule1 object will automatically call __gt__ method, and pass the rule2 object to the other parameter to complete the comparison.

The following is the double-under method of the comparison operator

The double-under method of the comparison operator

2.2 Arithmetic operators Can support addition, subtraction, multiplication and division of class objects.

def __add__(self, other): return Rule(self.r_len + other.r_len) The __add__ method is defined here, corresponding to the operator. It will add the lengths of the two rulers and generate a new ruler.

rule1 = Rule(10) rule2 = Rule(5) rule3 = rule1 + rule2 The following is the double-under method of arithmetic operators

2.3 Reverse arithmetic operator It supports other types of variables with Rule Class addition. Taking the __radd__ method as an example

def __radd__(self, other): return self.r_len + other rule1 = Rule(10) rule2 = 10 + rule1 When the program executes 10 rule1 , it will try to call the __add__ of the int class but The int class class does not define a method for adding the Rule class object, so the program will call the of the object rule1 on the right of __radd__ method, and pass 10 to the other parameter.

So this operator is also called the right addition operator. The operators it supports are the same as the arithmetic operators above. Just add r before the method name.

2.4 Incremental assignment operator The incremental assignment operators are = , -= , *= , /= etc.

def __iadd__(self, other): self.r_len += other return self rule1 = Rule(10) rule1 += 5 Except for the __pmod__ method, everything else is the same as the arithmetic operators, with i added before the aspect name.

2.4 Bit Operators This part supports binary operations such as negation, shift, AND or NOT. Since the Rule class does not involve bit operations, let's change to another example.

The class that defines binary string BinStr , contains the bin_str attribute, which represents a binary string.

class BinStr: def __init__(self, bin_str): self.bin_str = bin_str x = BinStr('1010') #创建二进制字符串对象 print(x.bin_str) # 1010 Define a negation operator for BinStr ~

# ~ 运算符 def __invert__(self): inverted_bin_str = ''.join(['1' if i == '0' else '0' for i in self.bin_str]) return BinStr(inverted_bin_str) __invert__ 方法中，遍历 bin_str 字符串，将每位取反，并返回一个新的 BinStr 类对象。

x = BinStr('1011')

invert_x = ~x print(invert_x.bin_str) # 0100 下面是位运算符的双下方法

这部分也支持反向位运算符和增量赋值位运算符，规则跟算数运算符一样，这里就不再赘述。

3.字符串表示 这部分涉及两个双下方法 __repr__ 和 __format__ ，在某些特殊场景，如 print ，会自动调用，将对象转成字符串。

还是以 BinStr 为例，先写 __repr__ 方法。

def __repr__(self): decimal = int('0b'+self.bin_str, 2) return f'二进制字符串：{self.bin_str}，对应的十进制数字：{decimal}' x = BinStr('1011') print(x) # 输出：二进制字符串：1011，对应的十进制数字：11 当程序执行 print(x) 时，会自动调用 __repr__ 方法，获取对象 x 对应的字符串。

再写 __format__ 方法，它也是将对象格式化为字符串。

def __format__(self, format_spec): return format_spec % self.bin_str print('{0:二进制字符串：%s}'.format(x)) # 输出：二进制字符串：1011 当 .format 方法的前面字符串里包含 0: 时，就会自动调用 __format__ 方法，并将字符串传给 format_spec 参数。

4.数值转换 调用 int(obj) 、 float(obj) 等方法，可以将对象转成相对应数据类型的数据。

def __int__(self): return int('0b'+self.bin_str, 2) x = BinStr('1011') print(int(x)) 当调用 int(x) 时，会自动调用 __int__ 方法，将二进制字符串转成十进制数字。

数值转换除了上面的两个外，还有 __abs__ 、 __bool__ 、 __complex__ 、 __hash__ 、 __index__ 和 __str__ 。

__str__ 和 __repr__ 一样，在 print 时都会被自动调用，但 __str__ 优先级更高。

5.集合相关的双下方法 这部分可以像集合那样，定义对象长度、获取某个位置元素、切片等方法。

以 __len__ 和 __getitem__ 为例

def __len__(self): return len(self.bin_str)

def __getitem__(self, item): return self.bin_str[item] x = BinStr('1011')

print(len(x)) # 4 print(x[0]) # 1 print(x[0:3]) # 101 len(x) 会自动调用 __len__ 返回对象的长度。

通过 [] 方式获取对象的元素时，会自动调用 __getitem__ 方法，并将切片对象传给 item 参数，即可以获取单个元素，还可以获取切片。

集合相关的双下方法还包括 __setitem__ 、 __delitem__ 和 __contains__ 。

6.迭代相关的双下方法 可以在对象上使用 for-in 遍历。

def __iter__(self): self.cur_i = -1 return self

def __next__(self): self.cur_i += 1 if self.cur_i >= len(self.bin_str): raise StopIteration() # 退出迭代 return self.bin_str[self.cur_i] x = BinStr('1011') for i in x: print(i) 当在 x 上使用 for-in 循环时，会先调用 __iter__ 方法将游标 cur_i 置为初始值 -1 ，然后不断调用 __next__ 方法遍历 self.bin_str 中的每一位。

这部分还有一个 __reversed__ 方法用来反转对象。

def __reversed__(self): return BinStr(''.join(list(reversed(self.bin_str)))) x = BinStr('1011') reversed_x = reversed(x) print(reversed_x) # 输出：二进制字符串：1101，对应的十进制数字：13 7.类相关的双下方法 做 web 开发的朋友，用类相关的双下方法会更多一些。

7.1 实例的创建和销毁 实例的创建是 __new__ 和 __init__ 方法，实例的销毁是 __del__ 方法。

__new__ 的调用早于 __init__ ，它的作用是创建对象的实例（内存开辟一段空间），而后才将该实例传给 __init__ 方法，完成实例的初始化。

由于 __new__ 是类静态方法，因此它可以控制对象的创建，从而实现 单例模式 。

__del__ 方法在实例销毁时，被自动调用，可以用来做一些清理工作和资源释放的工作。

7.2 属性管理 类属性的访问和设置。包括 __getattr__ 、 __getattribute__ 、 __setattr__ 和 __delattr__ 方法。

__getattr__ 和 __getattribute__ 的区别是，当访问类属性时，无论属性存不存在都会调用 __getattribute__ 方法，只有当属性不存在时才会调用 __getattr__ 方法。

7.3 属性描述符 控制属性的访问，一般用于把属性的取值控制在合理范围内。包括 __get__ 、 __set__ 和 __delete__ 方法。

class XValidation: def __get__(self, instance, owner): return self.x

def __set__(self, instance, value): if 0 <= value <= 100: self.x = value else: raise Exception('x不能小于0，不能大于100')

def __delete__(self, instance): print('删除属性')

class MyCls: x = XValidation()

def __init__(self, n): self.x = n

obj = MyCls(10) obj.x = 101 print(obj.x) # 抛异常：Exception: x不能小于0，不能大于100 上述例子，通过类属性描述符，可以将属性x的取值控制在 [0, 100] 之前，防止不合法的取值。

8.总结 虽然上面介绍的不是所有的双下方法，但也算是绝大多数了。

虽然双下方法里可以编写任意代码，但大家尽量编写与方法要求一样的代码。如，在 __add__ 方法实现的不是对象相加而是相减，虽然也能运行，但这样会造成很大困惑，不利于代码维护。

【相关推荐： Python3视频教程 】

Completely master the double-down method in Python

Related articles