基本的な Python イテレータを構築する
質問
Python で反復関数 (または反復子オブジェクト) を作成するにはどうすればよいでしょうか?
解決
Python のイテレータ オブジェクトはイテレータ プロトコルに準拠しています。これは基本的に、次の 2 つのメソッドを提供することを意味します。 __iter__()
そして next()
. 。の __iter__
イテレータ オブジェクトを返し、ループの開始時に暗黙的に呼び出されます。の next()
このメソッドは次の値を返し、ループの増分ごとに暗黙的に呼び出されます。 next()
返す値がなくなった場合、StopIteration 例外が発生します。この例外は、反復を停止するループ構造によって暗黙的にキャプチャされます。
カウンタの簡単な例を次に示します。
class Counter:
def __init__(self, low, high):
self.current = low
self.high = high
def __iter__(self):
return self
def next(self): # Python 3: def __next__(self)
if self.current > self.high:
raise StopIteration
else:
self.current += 1
return self.current - 1
for c in Counter(3, 8):
print c
これにより、次のように出力されます。
3
4
5
6
7
8
前の回答で説明したように、これはジェネレーターを使用して記述する方が簡単です。
def counter(low, high):
current = low
while current <= high:
yield current
current += 1
for c in counter(3, 8):
print c
印刷出力は同じになります。内部では、ジェネレーター オブジェクトはイテレーター プロトコルをサポートし、クラス Counter とほぼ同様のことを実行します。
デビッド・マーツの記事、 イテレータと単純なジェネレータ, 、かなり良い紹介です。
他のヒント
反復関数を構築するには 4 つの方法があります。
- ジェネレーターを作成します ( 利回りキーワード)
- ジェネレーター式を使用します (生成)
- イテレータを作成します (定義
__iter__
そして__next__
(またはnext
Python 2.x の場合)) - Python が独自に反復処理できるクラスを作成します (定義する
__getitem__
)
例:
# generator
def uc_gen(text):
for char in text:
yield char.upper()
# generator expression
def uc_genexp(text):
return (char.upper() for char in text)
# iterator protocol
class uc_iter():
def __init__(self, text):
self.text = text
self.index = 0
def __iter__(self):
return self
def __next__(self):
try:
result = self.text[self.index].upper()
except IndexError:
raise StopIteration
self.index += 1
return result
# getitem method
class uc_getitem():
def __init__(self, text):
self.text = text
def __getitem__(self, index):
result = self.text[index].upper()
return result
4 つのメソッドすべての動作を確認するには:
for iterator in uc_gen, uc_genexp, uc_iter, uc_getitem:
for ch in iterator('abcde'):
print ch,
print
その結果、次のような結果が得られます。
A B C D E
A B C D E
A B C D E
A B C D E
注記:
2 つのジェネレータ タイプ (uc_gen
そして uc_genexp
)はできません reversed()
;単純な反復子 (uc_iter
) が必要になります __reversed__
マジック メソッド (後方に進む新しい反復子を返す必要があります)。そして getitem 反復可能 (uc_getitem
) が必要です __len__
魔法の方法:
# for uc_iter
def __reversed__(self):
return reversed(self.text)
# for uc_getitem
def __len__(self)
return len(self.text)
無限遅延評価イテレータに関するパニック大佐の 2 番目の質問に答えるために、上記の 4 つのメソッドをそれぞれ使用した例を次に示します。
# generator
def even_gen():
result = 0
while True:
yield result
result += 2
# generator expression
def even_genexp():
return (num for num in even_gen()) # or even_iter or even_getitem
# not much value under these circumstances
# iterator protocol
class even_iter():
def __init__(self):
self.value = 0
def __iter__(self):
return self
def __next__(self):
next_value = self.value
self.value += 2
return next_value
# getitem method
class even_getitem():
def __getitem__(self, index):
return index * 2
import random
for iterator in even_gen, even_genexp, even_iter, even_getitem:
limit = random.randint(15, 30)
count = 0
for even in iterator():
print even,
count += 1
if count >= limit:
break
print
(少なくとも私のサンプル実行では) 結果は次のようになります。
0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 42 44 46 48 50 52 54
0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38
0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30
0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32
まず第一に、 itertoolsモジュール これはイテレータが役立つあらゆる種類のケースで非常に便利ですが、Python でイテレータを作成するために必要なのは次のとおりです。
収率
それはクールじゃないですか?収量は通常の交換に使用できます 戻る 関数内で。これはオブジェクトを同じように返しますが、状態を破棄して終了するのではなく、次の反復を実行するときのために状態を保存します。以下は、から直接取得した実際の例です。 itertools関数リスト:
def count(n=0):
while True:
yield n
n += 1
機能の説明に記載されているように( カウント() itertools モジュールの関数...) を使用すると、n で始まる連続した整数を返す反復子が生成されます。
ジェネレータ式 まったく別のワームの缶詰です (素晴らしいワームです!)。の代わりに使用できます。 リストの内包表記 メモリを節約するため (リスト内包表記では、変数に割り当てられていない場合、使用後に破棄されるリストがメモリ内に作成されますが、ジェネレータ式ではジェネレータ オブジェクトを作成できます...これはイテレータの気の利いた言い方です)。ジェネレータ式定義の例を次に示します。
gen = (n for n in xrange(0,11))
これは、全範囲が 0 から 10 の間にあらかじめ決められている点を除けば、上記の反復子の定義と非常に似ています。
たった今見つけました xrange() (これまで見たことがなかったので驚きました...) 上記の例に追加しました。 xrange() の反復可能なバージョンです 範囲() これにはリストを事前に構築しないという利点があります。反復処理するデータの巨大なコーパスがあり、それを実行するためのメモリが限られている場合、これは非常に便利です。
皆さんの中にもやっている人がいるのを見かけます return self
で __iter__
. 。ただ注意したかったのは、 __iter__
それ自体をジェネレーターにすることができます (したがって、 __next__
そして育てる StopIteration
例外)
class range:
def __init__(self,a,b):
self.a = a
self.b = b
def __iter__(self):
i = self.a
while i < self.b:
yield i
i+=1
もちろん、ここではジェネレーターを直接作成することもできますが、より複雑なクラスの場合は便利です。
この質問はイテレータに関するものではなく、反復可能なオブジェクトに関するものです。Python では、シーケンスも反復可能であるため、反復可能なクラスを作成する 1 つの方法は、クラスをシーケンスのように動作させることです。それを与える __getitem__
そして __len__
メソッド。Python 2 と 3 でこれをテストしました。
class CustomRange:
def __init__(self, low, high):
self.low = low
self.high = high
def __getitem__(self, item):
if item >= len(self):
raise IndexError("CustomRange index out of range")
return self.low + item
def __len__(self):
return self.high - self.low
cr = CustomRange(0, 10)
for i in cr:
print(i)
これは反復可能な関数です。 yield
. 。それは、 iter
関数とその状態を可変に保つクロージャ (list
) Python 2 の囲みスコープ内。
def count(low, high):
counter = [0]
def tmp():
val = low + counter[0]
if val < high:
counter[0] += 1
return val
return None
return iter(tmp, None)
Python 3 の場合、クロージャー状態は、それを囲んでいるスコープ内で不変に保持され、 nonlocal
状態変数を更新するためにローカル スコープで使用されます。
def count(low, high):
counter = 0
def tmp():
nonlocal counter
val = low + counter
if val < high:
counter += 1
return val
return None
return iter(tmp, None)
テスト;
for i in count(1,10):
print(i)
1
2
3
4
5
6
7
8
9
このページのすべての回答は、複雑なオブジェクトに対して非常に優れています。ただし、組み込みの反復可能な型を属性として含むものについては、次のようになります。 str
, list
, set
または dict
, 、または任意の実装 collections.Iterable
, 、クラス内で特定のものを省略できます。
class Test(object):
def __init__(self, string):
self.string = string
def __iter__(self):
# since your string is already iterable
return (ch for ch in string)
次のように使用できます。
for x in Test("abcde"):
print(x)
# prints
# a
# b
# c
# d
# e
短くてシンプルなものを探しているなら、おそらくこれで十分でしょう。
class A(object):
def __init__(self, l):
self.data = l
def __iter__(self):
return iter(self.data)
使用例:
In [3]: a = A([2,3,4])
In [4]: [i for i in a]
Out[4]: [2, 3, 4]
Matt Gregory の答えに触発されて、ここでは a,b,...,z,aa,ab,...,zz,aaa,aab,...,zzy,zzz を返すもう少し複雑な反復子を示します。
class AlphaCounter:
def __init__(self, low, high):
self.current = low
self.high = high
def __iter__(self):
return self
def __next__(self): # Python 3: def __next__(self)
alpha = ' abcdefghijklmnopqrstuvwxyz'
n_current = sum([(alpha.find(self.current[x])* 26**(len(self.current)-x-1)) for x in range(len(self.current))])
n_high = sum([(alpha.find(self.high[x])* 26**(len(self.high)-x-1)) for x in range(len(self.high))])
if n_current > n_high:
raise StopIteration
else:
increment = True
ret = ''
for x in self.current[::-1]:
if 'z' == x:
if increment:
ret += 'a'
else:
ret += 'z'
else:
if increment:
ret += alpha[alpha.find(x)+1]
increment = False
else:
ret += x
if increment:
ret += 'a'
tmp = self.current
self.current = ret[::-1]
return tmp
for c in AlphaCounter('a', 'zzz'):
print(c)