解析python部分常用魔术方法

1     def __add__(self, *args, **kwargs): # real signature unknown
2         """ Return self+value. """
3         pass

返回相加数值

1     def __alloc__(self): # real signature unknown; restored from __doc__
2         """
3         B.__alloc__() -> int
4         
5         Return the number of bytes actually allocated.
6         """
7         return 0

返回实际占用字节数

1     def __eq__(self, *args, **kwargs): # real signature unknown
2         """ Return self==value. """
3         pass

相当于==

1     def __ge__(self, *args, **kwargs): # real signature unknown
2         """ Return self>=value. """
3         pass

相当于 >=

1     def __gt__(self, *args, **kwargs): # real signature unknown
2         """ Return self>value. """
3         pass

判断self是否大于 为真返回True,假返回False

1     def __abs__(self, *args, **kwargs): # real signature unknown
2         """ abs(self) """
3         pass

实现了内置函数abs()  取绝对值

1     def __bool__(self, *args, **kwargs): # real signature unknown
2         """ self != 0 """
3         pass

判断是否不等于0 为真返回True,假返回False

1     def __divmod__(self, *args, **kwargs): # real signature unknown
2         """ Return divmod(self, value). """
3         pass

实现了内置函数divmod 取两个值的除数和余数运算结果结合起来,返回一个包含商和余数的元组(a // b, a % b)。

1     def __float__(self, *args, **kwargs): # real signature unknown
2         """ float(self) """
3         pass

实现了内置float函数  float()函数用于将整数和字符串转换成浮点数。

1     def __floordiv__(self, *args, **kwargs): # real signature unknown
2         """ Return self//value. """
3         pass

相当于除 取整数 int

1     def __format__(self): # real signature unknown; restored from __doc__
2         """
3         complex.__format__() -> str
4         
5         Convert to a string according to format_spec.
6         """
7         return ""

我自己的理解是默认调用时 例如

a="a"

b = a.__format__(str(4))

print(b) # b="a   "

print(len(b)) # 

类似于format 默认以空格连接

下面是其他人的调用方法将__format__重写 使其拼接的不是空格

__format__()传参方法:someobject.__format__(specification)

  specification为指定格式,当应用程序中出现"{0:specification}".format(someobject)或format(someobject, specification)时,会默认以这种方式调用

  当specification为" "时,一种合理的返回值是return str(self),这为各种对象的字符串表示形式提供了明确的一致性

  注意,"{0!s}".format()和"{0!r}".format()并不会调用__format__()方法,他们会直接调用__str__()或者__repr__()

1  def __getattribute__(self, *args, **kwargs): # real signature unknown
2         """ Return getattr(self, name). """
3         pass

实习了getattr 函数用于返回一个对象属性值。可以设定默认值

 def __getnewargs__(self, *args, **kwargs): # real signature unknown
        pass

取出系列化恢复后的状态

1     def __hash__(self, *args, **kwargs): # real signature unknown
2         """ Return hash(self). """
3         pass
__hash__方法就是将其id/16取整后作为integer返回
1     def __init__(self, real, imag=None): # real signature unknown; restored from __doc__
2         pass

初始化一个实例

1     def __int__(self, *args, **kwargs): # real signature unknown
2         """ int(self) """
3         pass

内置函数int

1     def __le__(self, *args, **kwargs): # real signature unknown
2         """ Return self<=value. """
3         pass

相当于<= 为真返回 True 假返回False

1     def __lt__(self, *args, **kwargs): # real signature unknown
2         """ Return self<value. """
3         pass

相当于< 为真返回 True 假返回False

1     def __mod__(self, *args, **kwargs): # real signature unknown
2         """ Return self%value. """
3         pass

相当于%

1     def __mul__(self, *args, **kwargs): # real signature unknown
2         """ Return self*value. """
3         pass

相当于*乘

1     def __neg__(self, *args, **kwargs): # real signature unknown
2         """ -self """
3         pass

相当于相反数

1     def __new__(*args, **kwargs): # real signature unknown
2         """ Create and return a new object.  See help(type) for accurate signature. """
3         pass

__init__()方法在创建实例后调用.如果你想控制创建过程,请使用__new__()方法 

1     def __ne__(self, *args, **kwargs): # real signature unknown
2         """ Return self!=value. """
3         pass

相当于!= 真返回 True 假返回False

1     def __pos__(self, *args, **kwargs): # real signature unknown
2         """ +self """
3         pass

相当于 +

1     def __pow__(self, *args, **kwargs): # real signature unknown
2         """ Return pow(self, value, mod). """
3         pass

相当于平方

    def __radd__(self, *args, **kwargs): # real signature unknown
        """ Return value+self. """
        pass

相加

    def __rdivmod__(self, *args, **kwargs): # real signature unknown
        """ Return divmod(value, self). """
        pass

相当于divmod

进阶

  1 """
  2 基础:
  3 初始化一个实例    x = MyClass()    x.__init__()
  4 作为一个字符串的”官方”表示    repr(x)    x.__repr__()
  5 作为一个字符串    str(x)    x.__str__()
  6 作为字节数组    bytes(x)    x.__bytes__()
  7 作为格式化字符串    format(x, format_spec)    x.__format__(format_spec)
  8 - __init__()方法在创建实例后调用.如果你想控制创建过程,请使用__new__()方法 
  9 - 按照惯例, __repr__() 应该返回一个有效的Python表达式的字符串 
 10 - __str__()方法也被称为你的print(x)
 11 
 12 迭代相关
 13 遍历一个序列    iter(seq)    seq.__iter__()
 14 从迭代器中获取下一个值    next(seq)    seq.__next__()
 15 以相反的顺序创建一个迭代器    reversed(seq)    seq.__reversed__()
 16 - __iter__()无论何时创建新的迭代器,都会调用该方法. 
 17 - __next__()每当你从迭代器中检索一下个值的时候,都会调用该方法 
 18 - __reversed__()方法并不常见.它需要一个现有序列并返回一个迭代器,该序列是倒序的顺序.
 19 
 20 属性
 21 得到一个属性    x.my_property    x.__getattribute__('my_property')
 22 获得一个属性    x.my_property    x.__getattr__('my_property')
 23 设置一个属性    x.my_property = value    x.__setattr__('my_property', value)
 24 阐述一个属性    del x.my_property    x.__delattr__('my_property')
 25 列出所有属性和方法    dir(x)    x.__dir__()
 26 如果你的类定义了一个__getattribute__()方法,Python将在每次引用任何属性或方法名时调用它.
 27 如果你的类定义了一个__getattr__()方法,Python只会在所有普通地方查找属性后调用它.如果一个实例x定义了一个属性 color, x.color将不会调用x.__getattr__('color'); 它将简单地返回已经定义的x.color值.
 28 __setattr__()只要你为属性指定值,就会调用该方法.
 29 __delattr__()只要删除属性,就会调用该方法.
 30 __dir__()如果您定义一个__getattr__() 或者 __getattribute__() 方法,该方法很有用.通常情况下,调用dir(x)只会列出常规属性和方法.
 31 __getattr__()和__getattribute__()方法之间的区别很微妙但很重要.
 32 
 33 函数类
 34 通过定义call()方法,您可以创建一个可调用类的实例 - 就像函数可调用一样.
 35 
 36 来”调用”像函数一样的实例    my_instance()    my_instance.__call__()
 37 行为
 38 如果你的类作为一组值的容器 - 也就是说,如果问你的类是否”包含”一个值是有意义的 - 那么它应该定义下面的特殊方法,使它像一个集合一样.
 39 序列的数量    len(s)    s.__len__()
 40 否包含特定的值    x in s    s.__contains__(s)
 41 字典(映射)
 42 如果你想…    所以,你写…    Python调用…
 43 通过它的key来获得值    x[key]    x.__getitem__(key)
 44 通过它的key来设置一个值    x[key] = value    x.__setitem__(key, value)
 45 删除键值对    del x[key]    x.__delitem__(key)
 46 为丢失的key提供默认值    x[nonexistent_key]    x.__missing__(nonexistent_key)
 47 数字
 48 加    x + y    x.__add__(y)
 49 减    x - y    x.__sub__(y)
 50 乘    x * y    x.__mul__(y)
 51 整除    x / y    x.__trueiv__(y)
 52 除    x // y    x.__floordiv__(v)
 53 取余    x % y    x.__mod__(y)
 54 整除与取余    divmod(x, y)    x.__divmod__(y)
 55 平方    x ** y    x.__pow__(y)
 56 左移    x << y    x.__lshift__(y)
 57 友移    x >> y    x.__rshift__(y)
 58 按位and运算    x & y    x.__and__(y)
 59 按位xor或运算    x ^ y    x.__xor__(y)
 60 按位or运算    `x    y`
 61 上述一组特殊方法采用第一种方法:给定x / y,它们提供了一种方法让x说”我知道如何用y整除自己”.以下一组特殊方法解决了第二种方法:它们为y提供了一种方法来说”我知道如何成为分母,并将自己整除x”.
 62 
 63 加    x + y    x.__radd__(y)
 64 减    x - y    x.__rsub__(y)
 65 乘    x * y    x.__rmul__(y)
 66 整除    x / y    x.__rtrueiv__(y)
 67 除    x // y    x.__rfloordiv__(v)
 68 取余    x % y    x.__rmod__(y)
 69 整除与取余    divmod(x, y)    x.__rdivmod__(y)
 70 平方    x ** y    x.__rpow__(y)
 71 左移    x << y    x.__rlshift__(y)
 72 友移    x >> y    x.__rrshift__(y)
 73 按位and运算    x & y    x.__rand__(y)
 74 按位xor或运算    x ^ y    x.__rxor__(y)
 75 按位or运算    `x    y`
 76 可是等等!还有更多!如果你正在进行”就地”操作,如x /= 3则可以定义更多特殊的方法.
 77 
 78 加    x + y    x.__iadd__(y)
 79 减    x - y    x.__isub__(y)
 80 乘    x * y    x.__imul__(y)
 81 整除    x / y    x.__itrueiv__(y)
 82 除    x // y    x.__ifloordiv__(v)
 83 取余    x % y    x.__imod__(y)
 84 整除与取余    divmod(x, y)    x.__idivmod__(y)
 85 平方    x ** y    x.__ipow__(y)
 86 左移    x << y    x.__ilshift__(y)
 87 友移    x >> y    x.__irshift__(y)
 88 按位and运算    x & y    x.__iand__(y)
 89 按位xor或运算    x ^ y    x.__ixor__(y)
 90 按位or运算    `x    y`
 91 还有一些”单个数”数学运算可以让你自己对类似数字的对象进行数学运算.
 92 
 93 负数    -x    x.__neg__()
 94 正数    +x    x.__pos__()
 95 绝对值    abs(x)    x.__abs__()
 96 逆    ~x    x.__invert__()
 97 复数    complex(x)    x.__complex__()
 98 整数    int(x)    x.__int__()
 99 浮点数    float(x)    x.__float__()
100 四舍五入到最近的整数    round(x)    x.__round__()
101 四舍五入到最近的n位数    round(x, n)    x.__round__(n)
102 最小整数    math.ceil(x)    x.__ceil__()
103 最大整数    math.floor(x)    x.__floor__()
104 截断x到0的最接近的整数    math.trunc(x)    x.__trunc__()
105 数字作为列表索引    a_list[x]    a_list[x.__index__()]
106 比较
107 等于    x == y    x.__eq__(y)
108 不等于    x != y    x.__ne__(y)
109 小于    x < y    x.__lt__(y)
110 小于等于    x <= y    x.__le__(y)
111 大于    x > y    x.__gt__(y)
112 大于等于    x >= y    x.__ge__(y)
113 布尔    if x:    x.__bool__()
114 序列化
115 对象副本    copy.copy(x)    x.__copy__()
116 深拷贝    copy.deepcopy(x)    x.__deepcopy__()
117 序列化一个对象    pickle.dump(x, file)    x.__getstate__()
118 序列化一个对象    pickle.dump(x, file)    x.__reduce__()
119 序列化一个对象    pickle.dump(x, file, protocol_version)    x.__reduce_ex__(protocol_version)
120 取出恢复后的状态    x = pickle.load(fp)    x.__getnewargs__()
121 取出恢复后的状态    x = pickle.load(fp)    x.__setstate__()
122 with 语句
123 with块限定了运行时上下文;在执行with语句时,”进入”上下文,并在执行块中的最后一个语句后”退出”上下文.
124 
125 进入with语句块    with x:    x.__enter__()
126 退出with语句块    with x:    x.__exit__(exc_type, exc_value, traceback)
127 真正深奥的东西
128 x = MyClass()    x.__new__()
129 del x    x.__del__()
130 “    x.__solts__()
131 hash(x)    x.__hash__()
132 x.color    type(x).__dict__['color'].__get__(x, type(x))
133 x.color = 'PapayaWhip'    type(x).__dict__['color'].__set__(x, 'PapayaWhip')
134 del x.color    type(x).__dict__['color'].__del__(x)
135 isinstance(x, MyClass)    MyClass.__instancecheck__(x)
136 isinstance(C, MyClass)    MyClass.__subclasscheck__(C)
137 isinstance(C, MyABC)    MyABC.__subclasshook__(C)
138 Python正确调用__del__()特殊方法时非常复杂.为了完全理解它,你需要知道Python如何跟踪内存中的对象.
139 """
View Code
原文地址:https://www.cnblogs.com/ltn26/p/10255371.html