魔术方法1

最新推荐文章于 2022-12-01 10:37:00 发布

原创最新推荐文章于 2022-12-01 10:37:00 发布 · 202 阅读

0 ·

CC 4.0 BY-SA版权

python 专栏收录该内容

7 篇文章

订阅专栏

本文围绕Python编程展开，介绍了特殊属性如__name__、__module__等，以及特殊方法如__dir__、__eq__等。还讲解了运算符重载，如Point类的加法重载，以及容器相关方法和可调用对象。通过实例展示了这些特性的使用，如斐波那契数列类的实现。

特殊属性

属性

__name__

__module__

__class__

__bases__

__doc__

__mro__

__dict__

查看属性

方法

__dir__

含义

类、函数、方法等的名字

类定义所在的模块名

对象或类所属的类

类的基类的元组，顺序为它们在基类列表中出现的顺序类、函数的文档字符串，如果没有定义则为None 类的mro，class.mro()返回的结果的保存在 __mro__ 中类或实例的属性，可写的字典

意义

返回类或者对象的所有成员名称列表。

dir()函数操作实例就是调用 __dir__ ()。

__dir__ 方

有 __dir__

self._name = name self.__age = 10 self.weight = 20

print('animal Module\'s names # cat.py

import animal

from animal import Animal class Cat(Animal):

x = 'cat’

y = 'abcd’

class Dog(Animal):

def __dir__(self):

= {}’.format(dir())) # 模块的属性

return [‘dog’] # 必须返回可迭代对象

print(’---------’)

print('Current Module\‘s names = {}’.format(dir())) # 模块名词空间内的属性

print('animal Module\'s names print("object’s __dict__

= {}’.format(dir(animal))) # 指定模块名词空间内的属性

= {}".format(sorted(object.__dict__.keys()))) # object的字典

print(“Animal’s dir() = {}”.format(dir(Animal))) # 类Animal的dir()

print("Cat’s dir()

= {}".format(dir(Cat))) # 类Cat的dir()

print(’~~~~~~~~~’)

tom = Cat(‘tom’)

print(sorted(dir(tom))) # 实例tom的属性、Cat类及所有祖先类的类属性

print(sorted(tom.__dir__())) # 同上

# dir()的等价近似如下，__dict__字典中几乎包括了所有属性

print(sorted(set(tom.__dict__.keys()) | set(Cat.__dict__.keys()) | set(object.__dict__.keys()))) print(“Dog’s dir = {}”.format(dir(Dog)))

dog = Dog(‘snoppy’)

print(dir(dog))

print(dog.__dict__)

# 执行结果

animal Module’s names

= [‘Animal’, ‘__builtins__’, ‘__cached__’, ‘__doc__’, ‘__file__’,

’__loader__’, ‘__name__’, ‘__package__’, ‘__spec__’]

---------

Current Module’s names = [‘Animal’, ’ Cat’, ‘Dog’, ‘__builtins__’, ‘__cached__’, ‘__doc__’, ‘__file__’, ‘__loader__’, ‘__name__’, ‘__package__’, ‘__spec__’, ‘animal’]

animal Module’s names

= [‘Animal’, ‘__builtins__’, ‘__cached__’, ‘__doc__’, ‘__file__’,

’__loader__’, ‘__name__’, ‘__package__’, ‘__spec__’]

object’s __dict__

= [’__class__’, ‘__delattr__’, ‘__dir__’, ‘__doc__’, ‘__eq__’,

’__format__’, ‘__ge__’, ‘__getattribute__’, ‘__gt__’, ‘__hash__’, ‘__init__’, ‘__le__’, ‘__lt__’, ‘__ne__’, ‘__new__’, ‘__reduce__’, ‘__reduce_ex__’, ‘__repr__’, ‘__setattr__’, ‘__sizeof__’, ‘__str__’, ‘__subclasshook__’]

Animal’s dir() = [’__class__’, ‘__delattr__’, ‘__dict__’, ‘__dir__’, ‘__doc__’, ‘__eq__’, ‘__format__’, ‘__ge__’, ‘__getattribute__’, ‘__gt__’, ‘__hash__’, ‘__init__’, ‘__le__’, ‘__lt__’, ‘__module__’, ‘__ne__’, ‘__new__’, ‘__reduce__’, ‘__reduce_ex__’, ‘__repr__’, ‘__setattr__’, ‘__sizeof__’, ‘__str__’, ‘__subclasshook__’, ‘__weakref__’, ‘x’]

Cat’s dir()

= [’__class__’, ‘__delattr__’, ‘__dict__’, ‘__dir__’, ‘__doc__’, ‘__eq__’,

’__format__’, ‘__ge__’, ‘__getattribute__’, ‘__gt__’, ‘__hash__’, ‘__init__’, ‘__le__’,

’__lt__’, ‘__module__’, ‘__ne__’, ‘__new__’, ‘__reduce__’, ‘__reduce_ex__’, ‘__repr__’,

’__setattr__’, ‘__sizeof__’, ‘__str__’, ‘__subclasshook__’, ‘__weakref__’, ‘x’, ‘y’] ~~~~~~~~~

[’_Animal__age’, ‘__class__’, ‘__delattr__’, ‘__dict__’, ‘__dir__’, ‘__doc__’, ‘__eq__’, ‘__format__’, ‘__ge__’, ‘__getattribute__’, ‘__gt__’, ‘__hash__’, ‘__init__’, ‘__le__’, ‘__lt__’, ‘__module__’, ‘__ne__’, ‘__new__’, ‘__reduce__’, ‘__reduce_ex__’, ‘__repr__’, ‘__setattr__’, ‘__sizeof__’, ‘__str__’, ‘__subclasshook__’, ‘__weakref__’, ‘_name’, ‘weight’, ‘x’, ‘y’]

[’_Animal__age’, ‘__class__’, ‘__delattr__’, ‘__dict__’, ‘__dir__’, ‘__doc__’, ‘__eq__’, ‘__format__’, ‘__ge__’, ‘__getattribute__’, ‘__gt__’, ‘__hash__’, ‘__init__’, ‘__le__’, ‘__lt__’, ‘__module__’, ‘__ne__’, ‘__new__’, ‘__reduce__’, ‘__reduce_ex__’, ‘__repr__’, ‘__setattr__’, ‘__sizeof__’, ‘__str__’, ‘__subclasshook__’, ‘__weakref__’, ‘_name’, ‘weight’, ‘x’, ‘y’]

[’_Animal__age’, ‘__class__’, ‘__delattr__’, ‘__dir__’, ‘__doc__’, ‘__eq__’, ‘__format__’, ‘__ge__’, ‘__getattribute__’, ‘__gt__’, ‘__hash__’, ‘__init__’, ‘__le__’, ‘__lt__’, ‘__module__’, ‘__ne__’, ‘__new__’, ‘__reduce__’, ‘__reduce_ex__’, ‘__repr__’, ‘__setattr__’, ‘__sizeof__’, ‘__str__’, ‘__subclasshook__’, ‘_name’, ‘weight’, ‘x’, ‘y’]

Dog’s dir = [’__class__’, ‘__delattr__’, ‘__dict__’, ‘__dir__’, ‘__doc__’, ‘__eq__’,

’__format__’, ‘__ge__’, ‘__getattribute__’, ‘__gt__’, ‘__hash__’, ‘__init__’, ‘__le__’,

’__lt__’, ‘__module__’, ‘__ne__’, ‘__new__’, ‘__reduce__’, ‘__reduce_ex__’, ‘__repr__’,

’__setattr__’, ‘__sizeof__’, ‘__str__’, ‘__subclasshook__’, ‘__weakref__’, ‘x’]

[‘dog’]

{’_Animal__age’: 10, ‘weight’: 20, ‘_name’: ‘snoppy’}

dir()的测试如下

class Person:

def show(self): # 方法中

a = 100

t = int(a)

print(dir())

print(locals())

def test(a=50, b=100): # 函数中

c = 150

print(dir())

print(locals())

Person().show()

test()

print(dir())

print(sorted(locals().keys()))

print(sorted(globals().keys()))

# 显示结果如下

[‘a’, ‘self’, ‘t’]

{‘t’: 100, ‘a’: 100, ‘self’: <__main__.Person object at 0x0000026EA752EB38>}

[‘a’, ‘b’, ‘c’]

{‘c’: 150, ‘b’: 100, ‘a’: 50}

[‘Person’, ‘__annotations__’, ‘__builtins__’, ‘__cached__’, ‘__doc__’, ‘__file__’, ‘__loader__’, ‘__name__’, ‘__package__’, ‘__spec__’, ‘test’]

[‘Person’, ‘__annotations__’, ‘__builtins__’, ‘__cached__’, ‘__doc__’, ‘__file__’, ‘__loader__’, ‘__name__’, ‘__package__’, ‘__spec__’, ‘test’]

[‘Person’, ‘__annotations__’, ‘__builtins__’, ‘__cached__’, ‘__doc__’, ‘__file__’, ‘__loader__’, ‘__name__’, ‘__package__’, ‘__spec__’, ‘test’]

内建函数

locals() 返回当前作用域中的变量字典

globals() 当前模块全局变量的字典

** **

魔术方法 ***

分类：

创建、初始化与销毁

__new__

__init__ 与 __del__

可视化

hash

bool

运算符重载

容器和大小

可调用对象

上下文管理

反射

描述器

其他杂项

** **

实例化

方法

__new__

class A:

意义

实例化一个对象

该方法需要返回一个值，如果该值不是cls的实例，则不会调用 __init__ 该方法永远都是静态方法

def __new__(cls, *args, **kwargs): print(cls)

print(args)

print(kwargs)

#return super().__new__(cls)

#return 1

return None

def __init__(self, name):

self.name = name

a = A()

print(a)

__new__ 方法很少使用，即使创建了该方法，也会使用 return super().__new__(cls) 基类object的 __new__ 方法来创建实例并返回。

** **

可视化

方法

__str__

__repr__

__bytes__

class A:

意义

str()函数、format()函数、print()函数调用，需要返回对象的字符串表达。如果没有定义，就去调用 __repr__ 方法返回字符串表达，如果 __repr__ 没有定义，就直接返回对象的内存地址信息

内建函数repr()对一个对象获取字符串表达。

调用 __repr__ 方法返回字符串表达，如果 __repr__ 也没有定义，就直接返回object的定义就是显示内存地址信息

bytes()函数调用，返回一个对象的bytes表达，即返回bytes对象

def __init__(self, name, age=18):

self.name = name

self.age = age

def __repr__(self):

return ‘repr: {},{}’.format(self.name, self.age) def __str__(self):

return 'str:

{},{}’.format(self.name, self.age)

def __bytes__(self):

#return “{} is {}”.format(self.name, self.age).encode() import json

return json.dumps(self.__dict__).encode()

print(A(‘tom’)) # print函数使用__str__

print(’{}’.format(A(‘tom’)))

print([A(‘tom’)]) # []使用__str__，但其内部使用__repr__

print([str(A(‘tom’))]) # []使用__str__，其中的元素使用str()函数也调用__str__ print(‘str:a,1’) # 字符串直接输出没有引号

s = '1’

print(s)

s1 = 'a’

print(s1)

print([s1],(s,)) # 字符串在基本数据类型内部输出有引号

print({s, ‘a’})

print(bytes(A(‘tom’)))

**注意不能通过判断是否带引号来判断输出值的类型，类型判断要使用type或isinstance **

hash

方法

__hash__

意义

内建函数 hash() 调用的返回值，返回一个整数。如果定义这个方法该类的实例就可hash。

print(hash(1))

print(hash(‘tom’))

print(hash((‘tom’,)))

class A:

def __init__(self, name, age=18): self.name = name

def __hash__(self):

return 1

def __repr__(self):

return self.name

print(hash(A(‘tom’)))

print((A(‘tom’), A(‘tom’)))

print([A(‘tom’), A(‘tom’)])

print(’~~~~~~~~~~~~~~~~~~~~’)

print({1, 1})

a1 = A(‘tom’)

a2 = A(‘tom’)

s = {a1, a2} # set

print(s) # 去重了吗

print(hash(a1), hash(a2))

t1 = (‘tom’,)

t2 = (‘tom’,)

print(t1 is t2)

print(t1 == t2)

print({t1, t2}, hash(t1), hash(t2))

print({(‘tom’,), (‘tom’,)})

print({‘tom’, ‘tom’})

上例中， A的实例放在set中，它们hash值是相同的，为什么不能去重？ hash值相同就会去重吗？

class A:

def __init__(self, name, age=18):

self.name = name

def __hash__(self):

return 1

def __eq__(self, other): # 这个函数作用？

return self.name == other.name

def __repr__(self):

return self.name

print(hash(A(‘tom’)))

print((A(‘tom’), A(‘tom’)))

print([A(‘tom’), A(‘tom’)])

print(’~~~~~~~~~~~~~~~~~~~~’)

s = {A(‘tom’), A(‘tom’)} # set

print(s)

方法

__eq__

意义

对应==操作符，判断2个对象是否相等，返回bool值

定义了这个方法，如果不提供 __hash__ 方法，那么实例将不可hash了

__hash__ 方法只是返回一个hash值作为set的key，但是去重，还需要 __eq__ 来判断2个对象是否相等。 hash值相等，只是hash冲突，不能说明两个对象是相等的。

因此，一般来说提供 __hash__ 方法是为了作为set或者dict的key，如果去重要同时提供 __eq__ 方法。不可hash对象isinstance(p1, collections.Hashable)一定为False。

去重需要提供 __eq__ 方法。

思考：

1. list类实例为什么不可hash？

2. functools.lru_cache使用到的functools._HashedSeq类继承自list，为什么可hash？

练习

设计二维坐标类Point，使其成为可hash类型，并比较2个坐标的实例是否相等？

** **

1. list类实例为什么不可hash

源码中有一句 __hash__ = None，也就是如果调用 __hash__ ()相当于None()，一定报错。

所有类都继承object，而这个类是具有 __hash__ ()方法的，如果一个类不能被hash，就把 __hash__ 设置为 None。

2. _HashedSeq类提供了__hash__方法，这个方法实际上计算的是元组的hash值

** **

练习参考

from collections import Hashable

class Point:

def __init__(self, x, y):

self.x = x

self.y = y

def __hash__(self):

return hash((self.x, self.y))

def __eq__(self, other):

return self.x == other.x and self.y == other.y

p1 = Point(4, 5)

p2 = Point(4, 5)

print(hash(p1))

print(hash(p2))

print(p1 is p2)

print(p1 == p2) # True 使用__eq__

print(hex(id(p1)), hex(id(p2)))

print(set((p1, p2)))

print(isinstance(p1, Hashable))

** **

bool

方法

__bool__

定义 __bool__

__len__ ()也

class A: pass

print(bool(A()))

if A():

print(‘Real A’)

class B:

def __bool__(self):

return False

print(bool(B))

print(bool(B()))

if B():

print(‘Real B’)

class C:

def __len__(self):

return 0

print(bool(C()))

if C():

print(‘Real C’)

** **

运算符重载

operator模块提供以下的特殊方法，可以将类的实例使用下面的操作符来操作

±-------------------------------------±------------------------------------------------------------------------------------------------------------------------------±--------------------------------------------+
| 运算符 | 特殊方法 | 含义 |
++=============================================+=+
| <, <=, ==, >, | __lt__ , __le__ , __eq__ , __gt__ , __ge__ , __ne__ | 比较运算符 |
| | | |
| >=, != | | |
±-------------------------------------±------------------------------------------------------------------------------------------------------------------------------±--------------------------------------------+
| +, -, *, /, %, //, **, divmod | __add__ , __sub__ , __mul__ , __truediv__ , __mod__ , __floordiv__ , __pow__ , __divmod__ | 算数运算符，移位、位运算也有对应的方法 |
±-------------------------------------±------------------------------------------------------------------------------------------------------------------------------±--------------------------------------------+
| +=, -=, *=, /=, | __iadd__ , __isub__ , __imul__ , __itruediv__ , __imod__ , __ifloordiv__ , __ipow__ | ** ** |
| | | |
| %=, //=, **= | | |
±-------------------------------------±------------------------------------------------------------------------------------------------------------------------------±--------------------------------------------+

实现A类的2个实例相减

class A:

def __init__(self, name, age=18):

self.name = name

self.age = age

def __sub__(self, other):

return self.age - other.age

def __isub__(self, other): # 如果没有定义__isub__，则会调用__sub__ return A(self.name, self - other)

tom = A(‘tom’)

jerry = A(‘jerry’, 16)

print(tom - jerry)

print(jerry - tom, jerry.__sub__(tom))

print(id(tom))

tom -= jerry

print(tom.age, id(tom))

__isub__ 方法定义，一般会in-place就地来修改自身

如果没有定义 __isub__ 方法，则会调用 __sub__

练习：

完成Point类设计，实现判断点相等的方法，并完成向量的加法

在直角坐标系里面，定义原点为向量的起点。两个向量和与差的坐标分别等于这两个向量相应坐标的和与差若向量的表示为(x,y)形式,

A(X1,Y1) B(X2,Y2)，则A+B=（X1+X2，Y1+Y2），A -B=（X1-X2，Y1-Y2）

** **

class Point:

def __init__(self, x, y):

self.x = x

self.y = y

def __eq__(self, other):

return self.x == other.x and self.y == other.y

def __add__(self, other):

return Point(self.x + other.x, self.y + other.y)

def add(self, other):

return (self.x + other.x, self.y + other.y)

def __str__(self):

return ‘<Point: {},{}>’.format(self.x, self.y)

p1 = Point(1,1)

p2 = Point(1,1)

print(p1.add(p2))

# 运算符重载

print(p1 + p2)

print(p1 == p2)

运算符重载应用场景

往往是用面向对象实现的类，需要做大量的运算，而运算符是这种运算在数学上最常见的表达方式。例如，上例中的对+进行了运算符重载，实现了Point类的二元操作，重新定义为Point + Point。

提供运算符重载，比直接提供加法方法要更加适合该领域内使用者的习惯。

int类，几乎实现了所有操作符，可以作为参考。

@functools.total_ordering 装饰器

__lt__ , __le__ , __eq__ , __gt__ , __ge__ 是比较大小必须实现的方法，但是全部写完太麻烦，使用 @functools.total_ordering 装饰器就可以大大简化代码。

但是要求 __eq__ 必须实现，其它方法 __lt__ , __le__ , __gt__ , __ge__ 实现其一

from functools import total_ordering

@total_ordering

class Person:

def __init__(self, name, age):

self.name = name

self.age = age

def __eq__(self, other):

return self.age == other.age

def __gt__(self, other):

return self.age > other.age

tom = Person(‘tom’, 20)

jerry = Person(‘jerry’, 16)

print(tom > jerry)

print(tom < jerry)

print(tom >= jerry) #

print(tom <= jerry) #

上例中大大简化代码，但是一般来说比较实现等于或者小于方法也就够了，其它可以不实现，所以这个装饰器只是看着很美好，且可能会带来性能问题，建议需要什么方法就自己创建，少用这个装饰器。

class Person:

def __init__(self, name, age):

self.name = name

self.age = age

def __eq__(self, other):

return self.age == other.age

def __gt__(self, other):

return self.age > other.age

def __ge__(self, other):

return self.age >= other.age

tom = Person(‘tom’, 20)

jerry = Person(‘jerry’, 16)

print(tom > jerry)

print(tom < jerry)

print(tom >= jerry) #

print(tom <= jerry)

print(tom == jerry)

print(tom != jerry)

__eq__ 等于可以推断不等于

__gt__ 大于可以推断小于

__ge__ 大于等于可以推断小于等于

**也就是用3个方法，就可以把所有比较解决了，所以total_ordering可以不使用 **

容器相关方法

方法

__len__

__iter__

__contains__

__getitem__

__setitem__

__missing__

class A(dict):

意义

内建函数len()，返回对象的长度（>=0的整数），如果把对象当做容器类型看，就如同list 或者dict。

bool()函数调用的时候，如果没有 __bool__() 方法，则会看 __len__() 方法是否存在，存在返回非0为真

迭代容器时，调用，返回一个新的迭代器对象

in 成员运算符，没有实现，就调用 __iter__ 方法遍历

实现self[key]访问。序列对象，key接受整数为索引，或者切片。对于set和dict，key为 hashable。key不存在引发KeyError异常

和 __getitem__ 的访问类似，是设置值的方法

字典或其子类使用 __getitem__() 调用时，key不存在执行该方法

def __missing__(self, key):

print('Missing key : ', key)

return 0

a = A()

print(a[‘k’])

思考

为什么空字典、空字符串、空元组、空集合、空列表等可以等效为False？练习

将购物车类改造成方便操作的容器类

class Cart:

def __init__(self):

self.items = []

def __len__(self):

return len(self.items)

def additem(self, item):

self.items.append(item)

def __iter__(self):

# yield from self.items

return iter(self.items)

def __getitem__(self, index): # 索引访问 return self.items[index]

def __setitem__(self, key, value): # 索引赋值 self.items[key] = value

def __str__(self):

return str(self.items)

def __add__(self, other): # +

self.items.append(other)

return self

cart = Cart()

cart.additem(1)

cart.additem(‘abc’)

cart.additem(3)

# 长度、bool

print(len(cart))

print(bool(cart))

# 迭代

for x in cart:

print(x)

# in

print(3 in cart)

print(2 in cart)

# 索引操作

print(cart[1])

cart[1] = 'xyz’

print(cart)

# 链式编程实现加法

print(cart + 4 + 5 + 6)

print(cart.__add__(17).__add__(18))

** **

可调用对象

Python中一切皆对象，函数也不例外。

def foo():

print(foo.__module__, foo.__name__)

foo()

# 等价于

foo.__call__()

函数即对象，对象foo加上()，就是调用此函数对象的 __call__() 方法可调用对象

方法

__call__

意义

类中定义一个该方法，实例就可以像函数一样调用

可调用对象：定义一个类，并实例化得到其实例，将实例像函数一样调用。 class Point:

def __init__(self, x, y):

self.x = x

self.y = y

def __call__(self, *args, **kwargs):

return “<Point {}:{}>”.format(self.x, self.y)

p = Point(4, 5)

print§

print(p())

# 累加

class Adder:

def __call__(self, *args):

ret = 0

for x in args:

ret += x

self.ret = ret

return ret

adder = Adder()

print(adder(4, 5, 6))

print(adder.ret)

练习：

定义一个斐波那契数列的类，方便调用，计算第n项。

增加迭代的方法、返回容器长度、支持索引的方法。

class Fib:

def __init__(self):

self.items = [0, 1, 1]

def __call__(self, index):

if index < 0:

raise IndexError(‘Wrong Index’)

if index < len(self.items):

return self.items[index]

for i in range(len(self.items), index+1):

self.items.append(self.items[i-1] + self.items[i-2]) return self.items[index]

print(Fib()(101))

上例中，增加迭代的方法、返回容器长度、支持索引的方法

class Fib:

def __init__(self):

self.items = [0, 1, 1]

def __call__(self, index):

return self[index]

def __iter__(self):

return iter(self.items)

def __len__(self):

return len(self.items)

def __getitem__(self, index):

if index < 0:

raise IndexError(‘Wrong Index’)

if index < len(self.items):

return self.items[index]

for i in range(len(self), index+1):

self.items.append(self.items[i-1] + self.items[i-2]) return self.items[index]

def __str__(self):

return str(self.items)

__repr__ = __str__

fib = Fib()