基本的な Python イテレータを構築する

https://stackoverflow.com/questions/19151

09-06-2019
|

質問

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

これにより、次のように出力されます。

前の回答で説明したように、これはジェネレーターを使用して記述する方が簡単です。

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)

ライセンス： CC-BY-SA と帰属

所属していません StackOverflow