#!/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