Python——运算符重载(1)

标签：

=======================================================================

构造函数和表达式：__init__和__sub__

看一个简单的重载例子。下述Number类提供了一个方法来拦截实例的构造函数(__init__)，此外还有一个方法捕捉减法表达式(__sub__)。这种特殊的方法是钩子，可与内置运算绑定。

>>> class Number:
	def __init__(self,start):
		self.data = start
	def __sub__(self,other):
		return Number(self.data - other)

	
>>> X = Number(5)
>>> X.data
5
>>> Y = X - 2
>>> Y.data
3

常见的运算符重载方法

在类中，对内置对象（例如，整数和列表）所能做的事，几乎都有相应的特殊名称的重载方法。下表列出其中一些最常用的重载方法。

所有重载方法的名称前后都有两个下划线字符，以便把同类中定义的变量名区别开来。

运算符重载方法都是可选的——如果没有编写或继承一个方法，你的类直接不支持这些运算，并且试图使用它们会引发一个异常。

多数重载方法只用在需要对象行为表现的就像内置类型一样的高级程序中。然而，__init__构造函数常出现在绝大多数类中。

下面介绍一些运算符重载的用法示例。

=======================================================================

索引和分片：__getitem__和__setitem__

如果在类中定义了的话，则对于实例的索引运算，会自动调用__getitem__，把X作为第一个参数传递，并且方括号内的索引值传给第二个参数。例如，下面的类将返回索引值的平方。

>>> class Indexer:
	def __getitem__(self,index):
		return index**2

	
>>> X = Indexer()
>>> X[2]
4

>>> for i in range(5):
	print(X[i],end = ' ')

	
0 1 4 9 16 

拦截分片

有趣的是，除了索引，对于分片表达式也调用__getitem__。正式地讲，内置类型以同样的方式处理分片。例如，下面是一个内置列表上工作的分片，使用了上边界和下边界以及一个stride。（分片的知识可以回顾这里）

>>> L = [5,6,7,8,9]
>>> L[2:4]
[7, 8]
>>> L[1:]
[6, 7, 8, 9]
>>> L[:-1]
[5, 6, 7, 8]
>>> L[::2]
[5, 7, 9]

>>> L[slice(2,4)]
[7, 8]
>>> L[slice(1,None)]
[6, 7, 8, 9]
>>> L[slice(None,-1)]
[5, 6, 7, 8]
>>> L[slice(None,None,2)]
[5, 7, 9]

>>> class Indexer:
	data = [5,6,7,8,9]
	def __getitem__(self,index):
		print('getitem:',index)
		return self.data[index]

	
>>> X = Indexer()
>>> X[0]
getitem: 0
5
>>> X[1]
getitem: 1
6
>>> X[-1]
getitem: -1
9

>>> X[2:4]
getitem: slice(2, 4, None)
[7, 8]
>>> X[1:]
getitem: slice(1, None, None)
[6, 7, 8, 9]
>>> X[:-1]
getitem: slice(None, -1, None)
[5, 6, 7, 8]
>>> X[::2]
getitem: slice(None, None, 2)
[5, 7, 9]

def __setitem__(self,index,value):
	...
	self.data[index] = value

>>> class stepper:
	def __getitem__(self,i):
		return self.data[i]

	
>>> X = stepper()
>>> X.data = 'Spam'
>>> X[1]
'p'
>>> for item in X:
	print(item,end = ' ')

	
S p a m 

>>> 'p' in X
True
>>> [c for c in X]
['S', 'p', 'a', 'm']
>>> list(map(str.upper,X))
['S', 'P', 'A', 'M']
>>> a,b,c,d = X
>>> a,c,d
('S', 'a', 'm')
>>> list(X),tuple(X),''.join(X)
(['S', 'p', 'a', 'm'], ('S', 'p', 'a', 'm'), 'Spam')
>>> X
<__main__.stepper object at 0x0376A6B0>

迭代器对象：__iter__和__next__

尽管上述介绍的__getitem__技术有效，但它只是迭代的一种退而求其次的方法。一般Python中的迭代环境都会先尝试__iter__方法，再尝试__getitem__方法。

迭代环境是通过调用内置函数iter去尝试寻找__iter__方法来实现的，而这种方法应该返回一个迭代器对象。如果已经提供了，Python就会重复调用这个迭代器对象的next方法，直到发生StopIteration异常。如果没有找到这类__iter__方法，Python会改用__getitem__机制，就像之前那样通过偏移量重复索引，直到引发IndexError异常。
------------------------------------------------------------------------------------------------------------------

用户定义的迭代器

在__iter__机制中，类就是通过之前介绍的【迭代器协议】来实现用户定义的迭代器的。下述示例定义了用户定义的迭代器类来生成平方值。

>>> class Squares:
	def __init__(self,start,stop):
		self.value = start - 1
		self.stop = stop
	def __iter__(self):
		return self
	def __next__(self):
		if self.value == self.stop:
			raise StopIteration
		self.value += 1
		return self.value ** 2

	
>>> for i in Squares(1,5):
	print(i,end = ' ')

	
1 4 9 16 25 

>>> X = Squares(1,5)
>>> [n for n in X]
[1, 4, 9, 16, 25]
>>> [n for n in X]
[]
>>> [n for n in Squares(1,5)]
[1, 4, 9, 16, 25]

有多个迭代器的对象

之前提到过迭代器对象可以定义成一个独立的类，有其自己的状态信息，从而能够支持相同数据的多个迭代。看下例：

>>> s = 'ace'
>>> for x in s:
	for y in s:
		print(x+y,end=' ')

		
aa ac ae ca cc ce ea ec ee

>>> class SkipIterator:
	def __init__(self,wrapped):
		self.wrapped = wrapped
		self.offset = 0
	def __next__(self):
		if self.offset >= len(self.wrapped):
			raise StopIteration
		else:
			item = self.wrapped[self.offset]
			self.offset += 2
			return item

		
>>> class SkipObject:
	def __init__(self,wrapped):
		self.wrapped = wrapped
	def __iter__(self):
		return SkipIterator(self.wrapped)

	
>>> alpha = 'abcdef'
>>> skipper = SkipObject(alpha)
>>> I = iter(skipper)
>>> print(next(I),next(I),next(I))
a c e
>>> for x in skipper:
	for y in skipper:
		print(x+y,end = ' ')

		
aa ac ae ca cc ce ea ec ee

=======================================================================

成员关系：__contains__、__iter__和__getitem__

在迭代领域，类通常把in成员关系运算符实现为一个迭代，使用__iter__方法或__getitem__方法。要支持更加特定的成员关系，类可能编写一个__contains__方法——当出现的时候，该方法优先于__iter__方法，__iter__方法优先于__getitem__方法。

__contains__方法应该把成员关系定义为对一个映射应用键，以及用于序列的搜索。

考虑下面的类，它编写了3个方法和测试成员关系以及应用于一个实例的各种迭代环境。调用的时候，其方法会打印出跟踪消息。

class Iters:
    def __init__(self,value):
	    self.data = value
    def __getitem__(self,i):
    	print('get[%s]:'%i,end = '')
    	return self.data[i]
    def __iter__(self):
    	print('iter=> ',end='')
    	self.ix = 0
    	return self
    def __next__(self):
    	print('next:',end='')
    	if self.ix == len(self.data):
    		raise StopIteration
    	item = self.data[self.ix]
    	self.ix += 1
    	return item
    def __contains__(self,x):
    	print('contains:',end='')
    	return x in self.data

if __name__ == '__main__':
    X = Iters([1,2,3,4,5])
    print(3 in X)
    for i in X:
        print(i,end='')
    print()
    print([i**2 for i in X])
    print(list(map(bin,X)))

    I = iter(X)
    while 1:
        try:
            print(next(I),end = ' @ ')
        except StopIteration:
            break

contains:True
iter=> next:1next:2next:3next:4next:5next:
iter=> next:next:next:next:next:next:[1, 4, 9, 16, 25]
iter=> next:next:next:next:next:next:['0b1', '0b10', '0b11', '0b100', '0b101']
iter=> next:1 @ next:2 @ next:3 @ next:4 @ next:5 @ next:

iter=> next:next:next:True
iter=> next:1next:2next:3next:4next:5next:
iter=> next:next:next:next:next:next:[1, 4, 9, 16, 25]
iter=> next:next:next:next:next:next:['0b1', '0b10', '0b11', '0b100', '0b101']
iter=> next:1 @ next:2 @ next:3 @ next:4 @ next:5 @ next:

get[0]:get[1]:get[2]:True
get[0]:1get[1]:2get[2]:3get[3]:4get[4]:5get[5]:
get[0]:get[1]:get[2]:get[3]:get[4]:get[5]:[1, 4, 9, 16, 25]
get[0]:get[1]:get[2]:get[3]:get[4]:get[5]:['0b1', '0b10', '0b11', '0b100', '0b101']
get[0]:1 @ get[1]:2 @ get[2]:3 @ get[3]:4 @ get[4]:5 @ get[5]:

Python——运算符重载(1)

标签：

原文地址：http://blog.csdn.net/gavin_john/article/details/50717695