解析python部分常用魔术方法

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

返回相加数值

     def __alloc__(self): # real signature unknown; restored from __doc__
         """
         B.__alloc__() -> int

         Return the number of bytes actually allocated.
         """
         return 0

返回实际占用字节数

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

相当于==

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

相当于 >=

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

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

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

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

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

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

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

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

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

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

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

相当于除 取整数 int

     def __format__(self): # real signature unknown; restored from __doc__
         """
         complex.__format__() -> str

         Convert to a string according to format_spec.
         """
         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__()

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

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

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

取出系列化恢复后的状态

     def __hash__(self, *args, **kwargs): # real signature unknown
         """ Return hash(self). """
         pass

__hash__方法就是将其id/16取整后作为integer返回

     def __init__(self, real, imag=None): # real signature unknown; restored from __doc__
         pass

初始化一个实例

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

内置函数int

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

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

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

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

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

相当于%

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

相当于*乘

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

相当于相反数

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

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

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

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

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

相当于 +

     def __pow__(self, *args, **kwargs): # real signature unknown
         """ Return pow(self, value, mod). """
         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

进阶

 """
 基础:
 初始化一个实例    x = MyClass()    x.__init__()
 作为一个字符串的”官方”表示    repr(x)    x.__repr__()
 作为一个字符串    str(x)    x.__str__()
 作为字节数组    bytes(x)    x.__bytes__()
 作为格式化字符串    format(x, format_spec)    x.__format__(format_spec)
 - __init__()方法在创建实例后调用.如果你想控制创建过程,请使用__new__()方法
 - 按照惯例, __repr__() 应该返回一个有效的Python表达式的字符串
 - __str__()方法也被称为你的print(x)

 迭代相关
 遍历一个序列    iter(seq)    seq.__iter__()
 从迭代器中获取下一个值    next(seq)    seq.__next__()
 以相反的顺序创建一个迭代器    reversed(seq)    seq.__reversed__()
 - __iter__()无论何时创建新的迭代器,都会调用该方法.
 - __next__()每当你从迭代器中检索一下个值的时候,都会调用该方法
 - __reversed__()方法并不常见.它需要一个现有序列并返回一个迭代器,该序列是倒序的顺序.

 属性
 得到一个属性    x.my_property    x.__getattribute__('my_property')
 获得一个属性    x.my_property    x.__getattr__('my_property')
 设置一个属性    x.my_property = value    x.__setattr__('my_property', value)
 阐述一个属性    del x.my_property    x.__delattr__('my_property')
 列出所有属性和方法    dir(x)    x.__dir__()
 如果你的类定义了一个__getattribute__()方法,Python将在每次引用任何属性或方法名时调用它.
 如果你的类定义了一个__getattr__()方法,Python只会在所有普通地方查找属性后调用它.如果一个实例x定义了一个属性 color, x.color将不会调用x.__getattr__('color'); 它将简单地返回已经定义的x.color值.
 __setattr__()只要你为属性指定值,就会调用该方法.
 __delattr__()只要删除属性,就会调用该方法.
 __dir__()如果您定义一个__getattr__() 或者 __getattribute__() 方法,该方法很有用.通常情况下,调用dir(x)只会列出常规属性和方法.
 __getattr__()和__getattribute__()方法之间的区别很微妙但很重要.

 函数类
 通过定义call()方法,您可以创建一个可调用类的实例 - 就像函数可调用一样.

 来”调用”像函数一样的实例    my_instance()    my_instance.__call__()
 行为
 如果你的类作为一组值的容器 - 也就是说,如果问你的类是否”包含”一个值是有意义的 - 那么它应该定义下面的特殊方法,使它像一个集合一样.
 序列的数量    len(s)    s.__len__()
 否包含特定的值    x in s    s.__contains__(s)
 字典(映射)
 如果你想…    所以,你写…    Python调用…
 通过它的key来获得值    x[key]    x.__getitem__(key)
 通过它的key来设置一个值    x[key] = value    x.__setitem__(key, value)
 删除键值对    del x[key]    x.__delitem__(key)
 为丢失的key提供默认值    x[nonexistent_key]    x.__missing__(nonexistent_key)
 数字
 加    x + y    x.__add__(y)
 减    x - y    x.__sub__(y)
 乘    x * y    x.__mul__(y)
 整除    x / y    x.__trueiv__(y)
 除    x // y    x.__floordiv__(v)
 取余    x % y    x.__mod__(y)
 整除与取余    divmod(x, y)    x.__divmod__(y)
 平方    x ** y    x.__pow__(y)
 左移    x << y    x.__lshift__(y)
 友移    x >> y    x.__rshift__(y)
 按位and运算    x & y    x.__and__(y)
 按位xor或运算    x ^ y    x.__xor__(y)
 按位or运算    `x    y`
 上述一组特殊方法采用第一种方法:给定x / y,它们提供了一种方法让x说”我知道如何用y整除自己”.以下一组特殊方法解决了第二种方法:它们为y提供了一种方法来说”我知道如何成为分母,并将自己整除x”.

 加    x + y    x.__radd__(y)
 减    x - y    x.__rsub__(y)
 乘    x * y    x.__rmul__(y)
 整除    x / y    x.__rtrueiv__(y)
 除    x // y    x.__rfloordiv__(v)
 取余    x % y    x.__rmod__(y)
 整除与取余    divmod(x, y)    x.__rdivmod__(y)
 平方    x ** y    x.__rpow__(y)
 左移    x << y    x.__rlshift__(y)
 友移    x >> y    x.__rrshift__(y)
 按位and运算    x & y    x.__rand__(y)
 按位xor或运算    x ^ y    x.__rxor__(y)
 按位or运算    `x    y`
 可是等等！还有更多！如果你正在进行”就地”操作,如x /= 3则可以定义更多特殊的方法.

 加    x + y    x.__iadd__(y)
 减    x - y    x.__isub__(y)
 乘    x * y    x.__imul__(y)
 整除    x / y    x.__itrueiv__(y)
 除    x // y    x.__ifloordiv__(v)
 取余    x % y    x.__imod__(y)
 整除与取余    divmod(x, y)    x.__idivmod__(y)
 平方    x ** y    x.__ipow__(y)
 左移    x << y    x.__ilshift__(y)
 友移    x >> y    x.__irshift__(y)
 按位and运算    x & y    x.__iand__(y)
 按位xor或运算    x ^ y    x.__ixor__(y)
 按位or运算    `x    y`
 还有一些”单个数”数学运算可以让你自己对类似数字的对象进行数学运算.

 负数    -x    x.__neg__()
 正数    +x    x.__pos__()
 绝对值    abs(x)    x.__abs__()
 逆    ~x    x.__invert__()
 复数    complex(x)    x.__complex__()
 整数    int(x)    x.__int__()
 浮点数    float(x)    x.__float__()
 四舍五入到最近的整数    round(x)    x.__round__()
 四舍五入到最近的n位数    round(x, n)    x.__round__(n)
 最小整数    math.ceil(x)    x.__ceil__()
 最大整数    math.floor(x)    x.__floor__()
 截断x到0的最接近的整数    math.trunc(x)    x.__trunc__()
 数字作为列表索引    a_list[x]    a_list[x.__index__()]
 比较
 等于    x == y    x.__eq__(y)
 不等于    x != y    x.__ne__(y)
 小于    x < y    x.__lt__(y)
 小于等于    x <= y    x.__le__(y)
 大于    x > y    x.__gt__(y)
 大于等于    x >= y    x.__ge__(y)
 布尔    if x:    x.__bool__()
 序列化
 对象副本    copy.copy(x)    x.__copy__()
 深拷贝    copy.deepcopy(x)    x.__deepcopy__()
 序列化一个对象    pickle.dump(x, file)    x.__getstate__()
 序列化一个对象    pickle.dump(x, file)    x.__reduce__()
 序列化一个对象    pickle.dump(x, file, protocol_version)    x.__reduce_ex__(protocol_version)
 取出恢复后的状态    x = pickle.load(fp)    x.__getnewargs__()
 取出恢复后的状态    x = pickle.load(fp)    x.__setstate__()
 with 语句
 with块限定了运行时上下文;在执行with语句时,”进入”上下文,并在执行块中的最后一个语句后”退出”上下文.

 进入with语句块    with x:    x.__enter__()
 退出with语句块    with x:    x.__exit__(exc_type, exc_value, traceback)
 真正深奥的东西
 x = MyClass()    x.__new__()
 del x    x.__del__()
 “    x.__solts__()
 hash(x)    x.__hash__()
 x.color    type(x).__dict__['color'].__get__(x, type(x))
 x.color = 'PapayaWhip'    type(x).__dict__['color'].__set__(x, 'PapayaWhip')
 del x.color    type(x).__dict__['color'].__del__(x)
 isinstance(x, MyClass)    MyClass.__instancecheck__(x)
 isinstance(C, MyClass)    MyClass.__subclasscheck__(C)
 isinstance(C, MyABC)    MyABC.__subclasshook__(C)
 Python正确调用__del__()特殊方法时非常复杂.为了完全理解它,你需要知道Python如何跟踪内存中的对象.
 """