我正在使用Python 2.7.3。
考虑一个具有自定义(尽管较差)迭代和获取项行为的伪类:
class FooList(list):
def __iter__(self):
return iter(self)
def next(self):
return 3
def __getitem__(self, idx):
return 3
举个例子,看看奇怪的行为:
>>> zz = FooList([1,2,3])
>>> [x for x in zz]
# Hangs because of the self-reference in `__iter__`.
>>> zz[0]
3
>>> zz[1]
3
但是现在,让我们创建一个函数,然后对以下参数进行解压缩zz
:
def add3(a, b, c):
return a + b + c
>>> add3(*zz)
6
# I expected either 9 or for the interpreter to hang like the comprehension!
因此,参数解压缩以某种方式获取项目数据,zz
但不是通过使用实现的迭代器遍历对象,也不是通过穷人的迭代器并调用__getitem__
与对象一样多的项目来获取项目数据。
所以问题是:如果不通过这些方法,语法如何add3(*zz)
获取其数据成员zz
?我是否只是想从这样的类型中获取数据成员而错过另一种常见模式?
我的目标是看我是否可以编写实现迭代或项获取的类,以使其更改参数解包语法对该类的含义。在尝试了上面的两个示例之后,我现在想知道参数解包如何到达底层数据以及程序员是否可以影响该行为。谷歌为此只给出了解释*args
语法基本用法的大量结果。
我没有用例需要这样做,我并不是说这是个好主意。为了好奇,我只想看看该怎么做。
添加
由于内置类型是经过特殊处理的,因此这里有一个示例,object
其中我只维护一个列表对象并实现自己的get和set行为以模拟列表。
class FooList(object):
def __init__(self, lst):
self.lst = lst
def __iter__(self): raise ValueError
def next(self): return 3
def __getitem__(self, idx): return self.lst.__getitem__(idx)
def __setitem__(self, idx, itm): self.lst.__setitem__(idx, itm)
在这种情况下,
In [234]: zz = FooList([1,2,3])
In [235]: [x for x in zz]
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-235-ad3bb7659c84> in <module>()
----> 1 [x for x in zz]
<ipython-input-233-dc9284300db1> in __iter__(self)
2 def __init__(self, lst):
3 self.lst = lst
----> 4 def __iter__(self): raise ValueError
5 def next(self): return 3
6 def __getitem__(self, idx): return self.lst.__getitem__(idx)
ValueError:
In [236]: add_3(*zz)
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-236-f9bbfdc2de5c> in <module>()
----> 1 add_3(*zz)
<ipython-input-233-dc9284300db1> in __iter__(self)
2 def __init__(self, lst):
3 self.lst = lst
----> 4 def __iter__(self): raise ValueError
5 def next(self): return 3
6 def __getitem__(self, idx): return self.lst.__getitem__(idx)
ValueError:
但是,相反,如果我确保迭代停止并且总是返回3,那么我可以得到在第一种情况下我要拍摄的内容:
class FooList(object):
def __init__(self, lst):
self.lst = lst
self.iter_loc = -1
def __iter__(self): return self
def next(self):
if self.iter_loc < len(self.lst)-1:
self.iter_loc += 1
return 3
else:
self.iter_loc = -1
raise StopIteration
def __getitem__(self, idx): return self.lst.__getitem__(idx)
def __setitem__(self, idx, itm): self.lst.__setitem__(idx, itm)
然后我看到了,这是我最初的期望:
In [247]: zz = FooList([1,2,3])
In [248]: ix = iter(zz)
In [249]: ix.next()
Out[249]: 3
In [250]: ix.next()
Out[250]: 3
In [251]: ix.next()
Out[251]: 3
In [252]: ix.next()
---------------------------------------------------------------------------
StopIteration Traceback (most recent call last)
<ipython-input-252-29d4ae900c28> in <module>()
----> 1 ix.next()
<ipython-input-246-5479fdc9217b> in next(self)
10 else:
11 self.iter_loc = -1
---> 12 raise StopIteration
13 def __getitem__(self, idx): return self.lst.__getitem__(idx)
14 def __setitem__(self, idx, itm): self.lst.__setitem__(idx, itm)
StopIteration:
In [253]: ix = iter(zz)
In [254]: ix.next()
Out[254]: 3
In [255]: ix.next()
Out[255]: 3
In [256]: ix.next()
Out[256]: 3
In [257]: ix.next()
---------------------------------------------------------------------------
StopIteration Traceback (most recent call last)
<ipython-input-257-29d4ae900c28> in <module>()
----> 1 ix.next()
<ipython-input-246-5479fdc9217b> in next(self)
10 else:
11 self.iter_loc = -1
---> 12 raise StopIteration
13 def __getitem__(self, idx): return self.lst.__getitem__(idx)
14 def __setitem__(self, idx, itm): self.lst.__setitem__(idx, itm)
StopIteration:
In [258]: add_3(*zz)
Out[258]: 9
In [259]: zz[0]
Out[259]: 1
In [260]: zz[1]
Out[260]: 2
In [261]: zz[2]
Out[261]: 3
In [262]: [x for x in zz]
Out[262]: [3, 3, 3]
概要
语法*args
仅依赖迭代。对于内置类型,这种情况在从内置类型继承的类中无法直接覆盖。
这两个在功能上是等效的:
foo(*[x for x in args])
foo(*args)
即使对于有限的数据结构,这些也不相等。
foo(*args)
foo(*[args[i] for i in range(len(args))])
您被Python最令人讨厌的疣之一所bit:内置类型和它们的子类在某些地方被神奇地对待。
由于您的类型是的子类list
,因此Python会神奇地进入其内部以对其进行解压缩。它根本不使用真正的迭代器API。如果print
在next
和中插入语句__getitem__
,则会看到两个都没有被调用。此行为不能被覆盖。相反,您将必须编写自己的类以重新实现内置类型。您可以尝试使用UserList
;我还没有检查是否可行。
您问题的答案是,参数解压缩使用迭代。但是,__getitem__
如果没有显式__iter__
定义,则可以使用迭代本身。您不能创建一个定义与常规迭代行为不同的参数解压缩行为的类。
__iter__
不应假定迭代器协议(基本上是“如何工作”)适用于子类内置类型的类型,例如list
。如果您将内建子类化,则子类在某些情况下可能会像基础内建子一样神奇地表现,而无需使用自定义魔术方法(例如__iter__
)。如果您想完全可靠地自定义行为,则不能从内置类型中继承子类(当然,除外object
)。
本文收集自互联网,转载请注明来源。
如有侵权,请联系[email protected] 删除。
我来说两句