python magic函数_Python Magic Method

Python 的 Magic Method 就是以双下划线起始和结尾的方法。

为什么要有这些方法呢？我的理解是：

Python 中万物皆对象，所以如果 Python 完全遵循面向对象的原则，那么所有的方法调用应该都是 obj.method(args) 这种形式，但事实上 Python 中有许多的内置函数和操作符，这些内置函数和操作符调用的就是这些 magic method。所以说，magic method的存在是为了让自定义对象能够使用 Python 内置函数和操作符。

我认为 Pythonic 很大一部分指的就是这个。

A Pythonic Card Deck

import collections

Card = collections.namedtuple('Card', ['rank', 'suit'])

class Deck:

ranks = [str(n) for n in range(2, 11)] + list('JQKA')

suits = 'spades diamonds clubs hearts'.split()

def __init__(self):

self._cards = [Card(rank, suit) for suit in self.suits

for rank in self.ranks]

def __len__(self):

return len(self._cards)

def __getitem__(self, position):

return self._cards[position]

>>> deck = Deck()

>>> len(deck)

52

>>> deck[0]

Card(rank='2', suit='spades')

>>> deck[:3]

[Card(rank='2', suit='spades'), Card(rank='3', suit='spades'), Card(rank='4', suit='spades')]

Pythonic Vector

# -*- coding: utf8 -*-

from array import array

import reprlib

import math

import numbers

import operator

import functools

import itertools

class Vector:

"""

>>> Vector([1, 2])

Vector([1.0, 2.0])

>>> Vector([2.1, 3.0, 4.2])

Vector([2.1, 3.0, 4.2])

>>> Vector(range(10))

Vector([0.0, 1.0, 2.0, 3.0, 4.0, ...])

"""

typecode = 'd'

# 要求 components 是个能迭代的对象

def __init__(self, components):

self._components = array(self.typecode, components)

# 使 Vector 支持迭代

# Vector 能迭代的特性使得下面的一些 magic method 定义起来特别方便

def __iter__(self):

return iter(self._components)

def __repr__(self):

components = reprlib.repr(self._components)

components = components[components.find('['):-1]

return 'Vector({})'.format(components)

# tuple 中的参数要求能迭代

def __str__(self):

return str(tuple(self))

def __bytes__(self):

return bytes([ord(self.typecode)]) + bytes(self._components)

@classmethod

def frombytes(cls, octets):

typecode = chr(octets[0])

memv = memoryview(octets[1:]).cast(typecode)

return cls(memv)

def __bool__(self):

return bool(abs(self))

# 要使 Vector 是一个序列，必须支持 __len__, __getitem__ 方法

def __len__(self):

return len(self._components)

# 如果这样实现的话，如果我们用切片，会发现返回的是 array 而不是 Vector

# >>> v1 = Vector([3, 4, 5])

# array('d', [4.0, 5.0])

# def __getitem__(self, index):

# return self._components[index]

# 用下面这张方法实现能返回 Vector

# 注意切片时参数 index 是个切片对象

# v = v = Vector(range(7))

# >>> v[-1]

# 6.0

# >>> v[1:4]

# Vector([1.0, 2.0, 3.0])

def __getitem__(self, index):

cls = type(self)

if isinstance(index, slice):

return cls(self._components[index])

elif isinstance(index, numbers.Integral):

return self._components[index]

else:

msg = "{cls.__name__} indeces must be integers"

raise TypeError(msg.format(cls=cls))

# 由于我们想要 Vector immutable， 所以我们不定义 __setitem__

# 目前我们取得元素只能用 v[0] 这样的形式

# 我们想用 v.x 这样的形式取得元素

# >>> v = Vector(range(10))

# >>> v.x

# 0.0

# >>> v.k

# ... Vector object has no attribute k

shortcut_names = 'xyz'

def __getattr__(self, name):

cls = type(self)

if len(name) == 1:

pos = cls.shortcut_names.find(name)

if 0 <= pos < len(self):

return self[pos]

msg = "{cls.__name__} object has no attribute {name}"

raise AttributeError(msg.format(cls=cls, name=name))

# 由于 __getattr__ 的调用方式是：

# 先从对象的属性(包括父类属性)中寻找，找不到时才调用 __getattr__ 方法

# 所以如果我们动态绑定对象属性，则不会调用 __getattr__ 方法

# >>> v = Vector(range(10))

# >>> v.x

# 0.0

# >>> v.x = 10

# >>> v.x

# 10

# >>> v

# Vector([0.0, 1.0, 2.0, 3.0, 4.0, ...])

# 我们当然可以用 __slots__ 限制对象属性，

# 但 __slots__ 的主要目的是节约内存而不是限制属性

# 在这里我们自定义 __setattr__

def __setattr__(self, name, value):

cls = type(self)

if len(name) == 1:

if name in cls.shortcut_names:

msg = "readonly attribute {name}"

elif name.islower():

msg= "can't set attribute 'a' to 'z' in {cls.__name__}"

else:

msg = ''

if msg:

raise AttributeError(msg.format(cls=cls, name=name))

super().__setattr__(name, value)

# 要使 Vector hashable，必须定义 __eq__ 和 __hash__ 方法

# 这里 a == b 的调用顺序是：

# 先调用 a.__eq__(b)

# 如果返回 NotImplemented，则接着调用 b.__eq__(a)

# 如果仍然返回 NotImplemented，则使用两者的id比较值作为最后结果

def __eq__(self, other):

if isinstance(other, Vector):

return len(self) == len(other) and \

all(a == b for a, b in zip(self, other))

else:

return NotImplemented

def __hash__(self):

hashes = (hash(x) for x in self)

return functools.reduce(operator.xor, hashes, 0)

# **Operator Overloading**

# 定义 __neg__ 和 __pos__ 方法

# 一般这种一元操作符要求返回一个新对象

def __abs__(self):

return math.sqrt(sum(x * x for x in self))

def __neg__(self):

return Vector(-x for x in self)

def __pos__(self):

return Vector(self)

# __add__ 和 __iadd__

# 一般来说 __add__ 返回新对象，__iadd__ 修改本身

# 对一些 immutable 对象，虽然没有定义 __iadd__ 方法，但仍能使用 a += b

# 这是因为在这种情况下 a += b 是 a = a + b 的语法糖，调用的是 __add__

# >>> v = Vector([1, 2 ,3])

# >>> v + Vector([10, 10, 10])

# Vector([11.0, 12.0, 13.0])

# >>> v + (10, 10, 10)

# Vector([11.0, 12.0, 13.0])

def __add__(self, other):

try:

pairs = itertools.zip_longest(self, other, fillvalue=0.0)

return Vector(a+b for a, b in pairs)

else TypeError:

return NotImplemented

# 现在我们的 Vector 可以与其他可迭代对象相加，但反过来却不行

# Python 中另外有个所有操作符都有个反方法，比如 __radd__

def __radd__(self, other):

return self + other

def __mul__(self, scalar):

if isinstance(scalar, numbers.Real):

return Vector(x * scalar for x in self)

else:

return NotImplemented

def __rmul__(self, scalar):

return self * scalar

# 注意上面 __add__ 和 __mul__ 对传入参数类型的检测：

# __add__ 比较符合 duck typing，这种方式更加灵活

# __mul__ 对传入参数进行限制，这种方式更加安全

# 虽然用 isinstance 不符合 OOP，但在操作符覆盖上常常使用