淘先锋技术网

首页 1 2 3 4 5 6 7

#!/usr/bin/python3#_*_ Coding: UTF-8 _*_

from __future__ importdivisionimportcollectionsimportcopyimportmathimportoperatorimportpickleimportsysimportasynciofrom typing importIterableclassMedusaSorcerer:

instance= 'medusa'

def __abs__(self):""">>> abs(MedusaSorcerer())

返回数字绝对值的方法"""

return '__abs__'

def __add__(self, other):""">>> MedusaSorcerer() + 123

实现加法运算"""

return '__add__'asyncdef __aenter__(self):"""异步上下文管理器是上下文管理器的一种

它能够在其 __aenter__ 和 __aexit__ 方法中暂停执行

在语义上类似于 __enter__

仅有的区别是它必须返回一个 可等待对象

官方中文文档:

https://docs.python.org/zh-cn/3/reference/datamodel.html?highlight=__aenter__#object.__aenter__"""await asyncio.sleep(123)

asyncdef __aexit__(self, exc_type, exc_val, exc_tb):"""异步上下文管理器是上下文管理器的一种

它能够在其 __aenter__ 和 __aexit__ 方法中暂停执行

在语义上类似于 __exit__

仅有的区别是它必须返回一个 可等待对象

官方中文文档:

https://docs.python.org/zh-cn/3/reference/datamodel.html?highlight=__aenter__#object.__aexit__"""await asyncio.sleep(123)def __aiter__(self):"""异步迭代器 可以在其 __anext__ 方法中调用异步代码

返回一个 异步迭代器 对象

官方中文文档:

https://docs.python.org/zh-cn/3/reference/datamodel.html?highlight=__aiter__#object.__aiter__"""

returnselfdef __and__(self, other):""">>> MedusaSorcerer() & 123

实现按位 and 运算"""

return '__and__ True'

def __anext__(self):"""必须返回一个 可迭代对象 输出迭代器的下一结果值

当迭代结束时应该引发 StopAsyncIteration 错误

官方中文文档:

https://docs.python.org/zh-cn/3/reference/datamodel.html?highlight=__aiter__#object.__anext__"""

pass

def __await__(self):"""返回一个迭代器

官方中文文档:

https://docs.python.org/zh-cn/3/reference/datamodel.html?highlight=__aiter__#object.__await__"""

pass

def __call__(self, *args, **kwargs):""">>> MedusaSorcerer()()

调用对象(callable):

但凡是可以把一对括号()应用到某个对象身上都可称之为可调用对象

如果在类中实现了 __call__ 方法, 那么实例对象也将成为一个可调用对象"""self.params= '__call__'

def __init__(self, **kwargs):""">>> MedusaSorcerer(element='__element__')

构造实例对象后初始化实例属性的方法"""self.params= 'params'self.element= kwargs.get('element')def __bool__(self):""">>> if MedusaSorcerer(): print('True')

布尔值比较时调度该方法"""

returnTruedef __bytes__(self):""">>> bytes(MedusaSorcerer())

返回字节数组调度的方法"""

return bytes('123', encoding='UTF-8')def __ceil__(self):""">>> math.ceil(MedusaSorcerer())

返回最小整数的时候调度该方法"""

return '__ceil__'

def __class_getitem__(cls, item):"""按照 key 参数指定的类型返回一个表示泛型类的专门化对象

官方中文文档, 或许你还需要查阅 PEP484 和 PEP560:

https://docs.python.org/zh-cn/3/reference/datamodel.html?highlight=__class_getitem__#object.__class_getitem__

PEP560案例和说明:

https://www.python.org/dev/peps/pep-0560/#class-getitem"""

pass

def __cmp__(self, other):""">>> sorted(MedusaSorcerer(), MedusaSorcerer())

在实现我们自定义的排序规则的时候我们需要对实例实现__cmp__方法

例如我给的例子中:

如果传递的对象params属性 大于 本身实例对象的params属性: 返回 -1

如果传递的对象params属性 小于 本身实例对象的params属性: 返回 +1

如果传递的对象params属性 等于 本身实例对象的params属性: 返回 0"""

if self.params

elif self.params >other.params:return 1

return0def __coerce__(self, other):""">>> coerce(MedusaSorcerer(), MedusaSorcerer())

实现了混合模式运算

Python3中已经废弃"""

pass

def __complex__(self):""">>> complex(MedusaSorcerer())

实现复数转换的时候调度该方法"""

return complex(123)def __contains__(self, item):""">>> item not in MedusaSorcerer()

>>> item in MedusaSorcerer()

判断是否包含元素时"""

return True if item == '123' elseFalsedef __copy__(self):""">>> copy.copy(MedusaSorcerer())

返回浅拷贝对象"""

return 123

def __deepcopy__(self, memodict={}):""">>> copy.deepcopy(MedusaSorcerer())

返回深拷贝对象"""

returnselfdef __del__(self):""">>> medusa = MedusaSorcerer()

>>> del medusa

对象进行垃圾回收时候的行为函数"""

print('__del__')def __delattr__(self, item):""">>> del self.params

实现删除实例属性的时候将会调度该方法"""self.__dict__.pop(item)def __delete__(self, instance):""">>> class Test: medusa = MedusaSorcerer()

>>> del Test().medusa

官方: 调用此方法以删除 instance 指定的所有者类的实例的属性

在其实例拥有者对其进行删除操作的时候调用该方法"""

print('__delete__')def __delitem__(self, key):""">>> del MedusaSorcerer()['params']

使用键值对删除的时候将会调度该方法"""self.__dict__.pop(key)def __delslice__(self, i, j):"""__getslice__、__setslice__、__delslice__:用于分片的三个操作

Python3中已经废弃"""

pass

def __dir__(self) ->Iterable[str]:""">>> dir(MedusaSorcerer())

返回所有实例属性和方法"""

return super().__dir__()def __divmod__(self, other):""">>> divmod(MedusaSorcerer(), 123)

返回 (整数, 取余) 的元组数组"""

return 123, 123

def __enter__(self):""">>> with MedusaSorcerer(): pass

调度 with 语句块的时候需要实现该方法"""self.enter= '__enter__'

def __eq__(self, other):""">>> MedusaSorcerer() == 123

调度判等条件的时候需要实现的方法"""

returnTruedef __exit__(self, exc_type, exc_val, exc_tb):""">>> with MedusaSorcerer(): pass

退出 with 语句块的时候将会调度该方法

退出关联到此对象的运行时上下文

各个参数描述了导致上下文退出的异常

如果上下文是无异常地退出的, 三个参数都将为 None

如果提供了异常并且希望方法屏蔽此异常(即避免其被传播)

则应当返回真值, 否则的话, 异常将在退出此方法时按正常流程处理"""self.enter= '__exit__'

def __float__(self):""">>> float(MedusaSorcerer())

返回浮点数将会调度该方法"""

return float(123)def __floor__(self):""">>> math.floor(MedusaSorcerer())

返回最大整数的时候调度该方法"""

return '__floor__'

def __floordiv__(self, other):""">>> MedusaSorcerer() // 123

进行除法运算的时候将会调度该方法"""

return 123.0

def __format__(self, format_spec):""">>> format(MedusaSorcerer(), 'self.params = %params%')

作为格式化字符串将字符串格式化返回"""

return format_spec.replace('%params%', self.params)def __fspath__(self):"""PEP 519

返回当前对象的文件系统表示

这个方法只应该返回一个 str 字符串或 bytes 字节串, 优先选择 str 字符串

官方中文文档:

https://docs.python.org/zh-cn/3/library/os.html?highlight=__fspath__#os.PathLike.__fspath__

https://www.python.org/dev/peps/pep-0519/#protocol

https://www.python.org/dev/peps/pep-0519/#have-fspath-only-return-strings"""

pass

def __ge__(self, other):""">>> MedusaSorcerer() >= 123

调度大于等于条件的时候需要实现的方法"""

returnTruedef __get__(self, instance, owner):""">>> class Test: medusa = MedusaSorcerer()

>>> print(Test().medusa)

官方: 调用此方法以获取所有者类的属性(类属性访问)或该类的实例的属性(实例属性访问)

官方: 可选的 owner 参数是所有者类而 instance 是被用来访问属性的实例,如果通过 owner 来访问属性则返回 None

在其实例拥有者对其进行查询操作的时候调用该方法"""

return '__get__'

def __getattr__(self, item):""">>> MedusaSorcerer().params_2 = 123

引用不存在实例属性时将会调度该方法

__getattr__存在时__getattr__不会被调用, 除非显示调用或引发AttributeError异常"""

return f'object has no attribute "{item}"'

def __getattribute__(self, item):""">>> MedusaSorcerer().params

引用存在实例属性时将会调度该方法

__getattr__存在时__getattr__不会被调用, 除非显示调用或引发AttributeError异常"""

return super().__getattribute__(item)def __getinitargs__(self):""">>> pickle.loads(pickle.dumps(MedusaSorcerer()))

在旧式类中(Python 3.x中默认都是新式类, 经典类被移除)

当你需要unpickle的时候调度__init__方法, 则需要定义该方法

并返回__init__所需参数元组"""

return '__getinitargs__',def __getitem__(self, item):""">>> MedusaSorcerer()['params']

实现用键值下表的方式获取数据"""

return self.__dict__.get(item)def __getnewargs__(self):""">>> pickle.loads(pickle.dumps(MedusaSorcerer()))

对新式类来说, 你可以通过这个方法改变类在反pickle时传递给__new__的参数

这个方法应该返回一个参数元组

在Python3.6前, 第2、3版协议会调用__getnewargs__, 更高版本协议会调用__getnewargs_ex__

其实pickle并不直接调用以下几个函数:

__getnewargs_ex__

__getnewargs__

__getstate__

事实上,, 这几个函数是复制协议的一部分它们实现了__reduce__这一特殊接口

复制协议提供了统一的接口, 用于在封存或复制对象的过程中取得所需数据

尽管这个协议功能很强, 但是直接在类中实现__reduce__接口容易产生错误

因此, 设计类时应当尽可能的使用高级接口, 比如__getnewargs_ex__、__getstate__和__setstate__"""

return '__getnewargs__',def __getstate__(self):""">>> pickle.loads(pickle.dumps(MedusaSorcerer()))

在pickle之前获取对象的状态

其实pickle并不直接调用以下几个函数:

__getnewargs_ex__

__getnewargs__

__getstate__

事实上,, 这几个函数是复制协议的一部分它们实现了__reduce__这一特殊接口

复制协议提供了统一的接口, 用于在封存或复制对象的过程中取得所需数据

尽管这个协议功能很强, 但是直接在类中实现__reduce__接口容易产生错误

因此, 设计类时应当尽可能的使用高级接口, 比如__getnewargs_ex__、__getstate__和__setstate__"""

return self.__dict__

def __gt__(self, other):""">>> MedusaSorcerer() > 123

调度大于条件的时候需要实现的方法"""

returnFalsedef __hash__(self):""">>> hash(MedusaSorcerer())

返回自定义散列值"""

return -123

def __hex__(self):"""__oct__, __hex__: use __index__ in oct() and hex() instead.

Python3 已经废弃

官方中文文档:

https://docs.python.org/zh-cn/3/whatsnew/3.0.html?highlight=__hex__#operators-and-special-methods"""

pass

def __iadd__(self, other):""">>> medusa = MedusaSorcerer()

>>> medusa += 123

实现就地加法运算"""

return self.params + f'{str(other)}(__iadd__)'

def __iand__(self, other):""">>> medusa = MedusaSorcerer()

>>> medusa &= 123

实现就地按位 and 运算"""

return '__iand__ True'

def __idiv__(self, other):""">>> medusa = MedusaSorcerer()

>>> medusa /= 123

实现就地除法运算

Python3已不再使用该方法, 迁移至__itruediv__"""

return '__idiv__'

def __ifloordiv__(self, other):""">>> medusa = MedusaSorcerer()

>>> medusa //= 123

实现就地整除运算"""

return '__ifloordiv__'

def __ilshift__(self, other):""">>> medusa = MedusaSorcerer()

>>> medusa <<= 123

实现就地左移位赋值运算符"""

return 123 <

https://www.python.org/dev/peps/pep-0465/#specification

官方中文文档 (无说明文档):

https://docs.python.org/zh-cn/3/reference/datamodel.html?highlight=__imatmul__#object.__imatmul__"""

pass

def __imod__(self, other):""">>> medusa = MedusaSorcerer()

>>> medusa %= 123

实现就地取余运算"""

return '__imatmul__'

def __imul__(self, other):""">>> medusa = MedusaSorcerer()

>>> medusa *= 123

实现就地乘法运算"""

return '__imul__'

def __index__(self):""">>> bin(MedusaSorcerer())

>>> hex(MedusaSorcerer())

>>> oct(MedusaSorcerer())

>>> operator.index(MedusaSorcerer())

调用此方法以实现operator.index()以及Python需要无损地将数字对象转换为整数对象的场合

例如切片或是内置的bin(), hex()和oct()函数

存在此方法表明数字对象属于整数类型, 且必须返回一个整数"""

return 123

def __init_subclass__(cls, **kwargs):""">>> class Test(MedusaSorcerer, params='class Test'): ...

>>> print(Test.params)

当一个类继承其他类时, 那个类的__init_subclass__会被调用

这样就可以编写能够改变子类行为的类

__init_subclass__只作用于定义了该方法的类下所派生的子类"""cls.params= '__init_subclass__' if not kwargs.get('params') else kwargs.get('params')

super().__init_subclass__()def __instancecheck__(self, instance):""">>> class BaseTypeClass(type):

>>> def __new__(cls, name, bases, namespace, **kwd): return type.__new__(cls, name, bases, namespace)

>>> def __instancecheck__(self, other): return False

>>> class A(metaclass=BaseTypeClass): ...

>>> print(isinstance(A(), A))

控制某个对象是否是该对象的实例

isinstance函数会进行快速检查

查看参数提供的实例的类型是否与该类的类型相同

如果相同则将提早返回结果, 并且不会调用__instancecheck__方法

这是为了避免不必要时对__instancecheck__进行复杂调用而使用的优化"""

pass

def __int__(self):""">>> int(MedusaSorcerer())

转换为数字类型的调度方法"""

return 123

def __invert__(self):""">>> ~MedusaSorcerer()

实现一元运算的返回值调度方法"""

return ~123

def __ior__(self, other):""">>> medusa = MedusaSorcerer()

>>> medusa |= 123

实现就地按位 or 操作的方法"""

return '__ior__'

def __ipow__(self, other):""">>> medusa = MedusaSorcerer()

>>> medusa **= 123

实现就地幂算法"""

return '__ipow__'

def __irshift__(self, other):""">>> medusa = MedusaSorcerer()

>>> medusa >>= 123

实现右移位赋值运算符"""

return '__irshift__'

def __isub__(self, other):""">>> medusa = MedusaSorcerer()

>>> medusa -= 123

实现减法赋值操作"""

return '__isub__'

def __iter__(self):""">>> medusa = iter(MedusaSorcerer())

>>> next(medusa)

创建可迭代对象需要实现的方法, 并需要实现__next__方法"""self.integer=0returnselfdef __itruediv__(self, other):""">>> medusa = MedusaSorcerer()

>>> medusa /= 123

实现就地除法运算

Python2中在 from __future__ import division 下才有用"""

return '__itruediv__'

def __ixor__(self, other):""">>> medusa = MedusaSorcerer()

>>> medusa ^= 123

实现就地按位异或运算"""

return '__ixor__'

def __le__(self, other):""">>> MedusaSorcerer() <= 123

定义小于等于操作符行为"""

return '__le__'

def __len__(self):""">>> len(MedusaSorcerer())

返回容器的长度"""

returnlen(self.params)def __long__(self):""">>> long(MedusaSorcerer)

Python2需要实现的Long类型转换"""

return '__long__'

def __lshift__(self, other):""">>> MedusaSorcerer() << 123

实现左移位运算符"""

return '__lshift__'

def __lt__(self, other):""">>> MedusaSorcerer() < 123

定义小于操作符行为"""

return '__lt__'

def __matmul__(self, other):"""查阅 PEP465:

https://www.python.org/dev/peps/pep-0465/#specification

官方中文文档 (无说明文档):

https://docs.python.org/zh-cn/3/reference/datamodel.html?highlight=__imatmul__#object.__matmul__"""

pass

def __missing__(self, key):""">>> class Dict(dict):

>>> def __missing__(self, key): return f'__missing__({key})'

>>> medusa = Dict({'1': 1})

>>> print(medusa['123'])

在字典的子类中使用, 访问字典类型的实例中不存在的Key值将会调用该方法"""

pass

def __mod__(self, other):""">>> MedusaSorcerer() % 123

实现取余运算操作"""

return '__mod__'

def __mro_entries__(self, bases):"""如果在类定义中出现的基类不是 type 的实例, 则使用 __mro_entries__ 方法对其进行搜索

当找到结果时, 它会以原始基类元组做参数进行调用

此方法必须返回类的元组以替代此基类被使用

元组可以为空, 在此情况下原始基类将被忽略

具体参阅 PEP560

官方中文文档:

https://docs.python.org/zh-cn/3/reference/datamodel.html?highlight=__imatmul__#resolving-mro-entries

https://www.python.org/dev/peps/pep-0560/#mro-entries"""

pass

def __mul__(self, other):""">>> MedusaSorcerer() * 123

实现乘法运算操作"""

return '__mul__'

def __ne__(self, other):""">>> MedusaSorcerer() != 123

定义不等判断行为"""

return '__ne__'

def __neg__(self):""">>> -MedusaSorcerer()

实现取负行为的方法"""

return '__neg__'

def __new__(cls, *args, **kwargs):""">>> MedusaSorcerer()

类对象实例化时将会首先调度该方法"""

if '__getnewargs__' in args: return 123

return super().__new__(cls)def __next__(self):""">>> medusa = iter(MedusaSorcerer())

>>> next(medusa)

创建迭代对象需要实现的方法, 并需要实现__iter__方法"""self.integer+= 1

returnself.integerdef __oct__(self):""">>> oct(MedusaSorcerer())

实现八进制数据转换

此处被__index__方法覆盖"""

return '__oct__'

def __or__(self, other):""">>> MedusaSorcerer() | 132

实现按位或运算符"""

return '__or__'

def __pos__(self):""">>> +MedusaSorcerer()

实现取正行为的方法"""

return '__pos__'

def __pow__(self, power, modulo=None):""">>> MedusaSorcerer() ** 123

实现幂值运算操作"""

return '__pow__'@classmethoddef __prepare__(metacls, name, bases):""">>> MedusaSorcerer()

__prepare__只在元类中有用, 而且必须声明为类方法

主要功能是罗列类的属性定义的顺序

第一个参数是元类, 随后两个参数分别是要构建的类的名称和基类组成的元组, 返回值必须是映射数据

元类构建新类时, 解释器会先调用__prepare__方法, 使用类定义体中的属性创建映射

接着把__prepare__方法返回的映射会传给__new__方法的最后一个参数

然后再传给__init__方法

此处我们传递的是一个空的OrderedDict实例对象"""

returncollections.OrderedDict()def __radd__(self, other):""">>> 123 + MedusaSorcerer()

实现反射加法操作"""

return '__radd__'

def __rand__(self, other):""">>> 123 & MedusaSorcerer()

实现反射按位与运算符"""

return '__rand__'

def __rdiv__(self, other):""">>> 123 / MedusaSorcerer()

实现反射除法

Python3 失效"""

return '__rdiv__'

def __rdivmod__(self, other):""">>> divmod(123, MedusaSorcerer())

返回反射 (整数, 取余) 的元组数组"""

return '__rdivmod__'

def __reduce__(self):""">>> pickle.dumps(MedusaSorcerer())

当定义扩展类型时, 也就是使用Python的C语言API实现的类型

如果你想pickle它们, 你必须告诉Python如何pickle它们

__reduce__ 被定义之后, 当对象被Pickle时就会被调用

它要么返回一个代表全局名称的字符串, Python会查找它并pickle

要么返回一个元组, 这个元组包含2到5个元素:

一个可调用的对象, 用于重建对象时调用

一个参数元素, 供那个可调用对象使用

被传递给 __setstate__ 的状态(可选)

一个产生被pickle的列表元素的迭代器(可选)

一个产生被pickle的字典元素的迭代器选可"""

return super().__reduce__()def __reduce_ex__(self, protocol):""">>> pickle.dumps(MedusaSorcerer())

__reduce_ex__的存在是为了兼容性

如果它被定义, 在pickle时__reduce_ex__会代替__reduce__被调用"""

return super().__reduce_ex__(protocol)def __repr__(self):""">>> repr(MedusaSorcerer())

返回对象转化为供解释器读取的形式的数据"""

return '__repr__'

def __reversed__(self):""">>> reversed(MedusaSorcerer())

返回一个反转的迭代器"""

return '__reversed__'

def __rfloordiv__(self, other):""">>> 123 // MedusaSorcerer()

实现反射整除运算"""

return '__rfloordiv__'

def __rlshift__(self, other):""">>> 123 << MedusaSorcerer()

实现反射左位移运算"""

return '__rlshift__'

def __rmatmul__(self, other):"""PEP465 (无说明文档):

https://www.python.org/dev/peps/pep-0465/#specification

官方中文文档 (无说明文档):

https://docs.python.org/zh-cn/3/reference/datamodel.html?highlight=__rmatmul__#object.__rmatmul__"""

pass

def __rmod__(self, other):""">>> 123 % MedusaSorcerer()

实现反射取余操作符"""

return '__rmod__'

def __rmul__(self, other):""">>> 123 * MedusaSorcerer()

实现反射乘法操作"""

return '__rmul__'

def __ror__(self, other):""">>> 123 | MedusaSorcerer()

实现反射按位或运算符"""

return '__ror__'

def __round__(self, n=None):""">>> round(MedusaSorcerer())

实现浮点数n的四舍五入值"""

return '__round__'

def __rpow__(self, other):""">>> 123 ** MedusaSorcerer()

反射幂值运算操作符"""

return '__rpow__'

def __rrshift__(self, other):""">>> 123 >> MedusaSorcerer()

实现反射右位移操作"""

return '__rrshift__'

def __rshift__(self, other):""">>> MedusaSorcerer() >> 123

实现右位移操作"""

return '__rshift__'

def __rsub__(self, other):""">>> 123 - MedusaSorcerer()

实现反射减法操作"""

return '__rsub__'

def __rtruediv__(self, other):""">>> 123 / MedusaSorcerer()

实现_true_反射除法

Python2 这个函数只有使用from __future__ import division时才有作用

Python3 全局生效"""

return '__rtruediv__'

def __rxor__(self, other):""">>> 123 ^ MedusaSorcerer()

实现反射按位异或运算符"""

return '__rxor__'

def __set__(self, instance, value):""">>> class Test: medusa = MedusaSorcerer()

>>> Test().medusa = 1

在其拥有者对其进行修改值的时候调用

一个类要成为描述器, 必须实现__get__, __set__, __delete__ 中的至少一个方法"""instance.params=valuedef __set_name__(self, owner, name):"""在所有者类 owner 创建时被调用, 描述器会被赋值给 name

官方中文文档:

https://docs.python.org/zh-cn/3/reference/datamodel.html?highlight=__set_name__#object.__set_name__

https://www.python.org/dev/peps/pep-0487/#proposal"""

pass

def __setattr__(self, key, value):""">>> self.params = 123

实例对象设置实例属性的时候将会调度该方法"""self.__dict__[key] =valuedef __setitem__(self, key, value):""">>> MedusaSorcerer()['key'] = 123

使用键值方式增加元素值"""self.__dict__[key] =valuedef __setslice__(self, i, j, sequence):"""__getslice__、__setslice__、__delslice__:用于分片的三个操作

Python3中已经废弃"""

pass

def __setstate__(self, state):""">>> pickle.loads(pickle.dumps(MedusaSorcerer()))

当一个对象被反pickle时, 如果定义了__setstate__, 对象的状态会传递给这个魔法方法

而不是直接应用到对象的__dict__属性

这个魔法方法和__getstate__相互依存

当这两个方法都被定义时, 你可以在Pickle时使用任何方法保存对象的任何状态

在 unpickling 之后还原对象的状态"""

pass

def __sizeof__(self):""">>> sys.getsizeof(MedusaSorcerer())

返回对象的大小"""

return 123

def __str__(self):""">>> str(MedusaSorcerer())

>>> print(MedusaSorcerer())

返回字符串调度的方法"""

return '__str__'

def __sub__(self, other):""">>> MedusaSorcerer() - 123

实现了加号运算"""

return '__sub__'

def __subclasscheck__(self, subclass):""">>> issubclass(MedusaSorcerer(), MedusaSorcerer)

对实例使用issubclass(subclass, class)时调用

它会判断subclass否是该类的子类

返回会与__instancecheck__一致, 忽略该方法"""

pass

def __truediv__(self, other):""">>> MedusaSorcerer() // 123

实现了整除运算

Python2 只有你声明了from __future__ import division该方法才会生效"""

return '__truediv__'

def __trunc__(self):""">>> math.trunc(MedusaSorcerer())

实现了math.trunc(), 向0取整"""

return '__trunc__'

def __unicode__(self):""">>> unicode(MedusaSorcerer())

Python2 中实现unicode转码"""

pass

def __xor__(self, other):""">>> MedusaSorcerer() ^ 123

实现按位异或运算符"""

return '__xor__'转载自--作者:MedusaSorcerer

链接:https://juejin.im/post/5e214fac5188252c6e1822c9