Apa sebenarnya iterator, iterable, dan iterasi?

Apa definisi paling mendasar dari "iterable", "iterator" dan "iteration" dengan Python?

Saya telah membaca banyak definisi tetapi saya tidak dapat mengidentifikasi makna yang tepat karena masih tidak akan masuk.

Dapatkah seseorang tolong bantu saya dengan 3 definisi dalam istilah awam?

Iterasi adalah istilah umum untuk mengambil setiap item dari sesuatu, satu demi satu. Setiap kali Anda menggunakan loop, eksplisit atau implisit, untuk membahas sekelompok item, yaitu iterasi.

Dalam Python, iterable dan iterator memiliki arti khusus.

Sebuah iterable adalah obyek yang memiliki __iter__metode yang mengembalikan sebuah iterator , atau yang mendefinisikan __getitem__metode yang dapat mengambil indeks berurutan mulai dari nol (dan menimbulkan IndexErrorketika indeks tidak lagi berlaku). Jadi iterable adalah objek yang bisa Anda peroleh dari iterator .

Sebuah iterator adalah obyek dengan next(Python 2) atau __next__metode (Python 3).

Setiap kali Anda menggunakan forloop, atau map, atau daftar pemahaman, dll. Dengan Python, nextmetode ini dipanggil secara otomatis untuk mendapatkan setiap item dari iterator , sehingga melalui proses iterasi .

Tempat yang baik untuk memulai pembelajaran adalah bagian iterators dari tutorial dan bagian iterator dari halaman type standar . Setelah Anda memahami dasar-dasarnya, coba bagian iterators dari HOWTO Pemrograman Fungsional .

Inilah penjelasan yang saya gunakan dalam mengajar kelas Python:

ITERABLE adalah:

• apa pun yang dapat diulang (yaitu Anda dapat mengulangi string atau file) atau
• apa pun yang dapat muncul di sisi kanan for-loop: for x in iterable: ...atau
• apa pun yang dapat Anda panggil iter()yang akan mengembalikan ITERATOR: iter(obj)atau
• objek yang mendefinisikan __iter__yang mengembalikan ITERATOR baru, atau mungkin memiliki __getitem__metode yang cocok untuk pencarian yang diindeks.

ITERATOR adalah objek:

• dengan status yang mengingat di mana ia berada saat iterasi,
• dengan __next__metode itu:
  • mengembalikan nilai berikutnya dalam iterasi
  • memperbarui status untuk menunjuk pada nilai berikutnya
  • sinyal ketika itu dilakukan dengan menaikkan StopIteration
• dan itu self-iterable (artinya memiliki __iter__metode yang mengembalikan self).

Catatan:

• The __next__metode dalam Python 3 dieja nextdengan Python 2, dan
• Fungsi builtin next()memanggil metode pada objek yang diteruskan ke sana.

Sebagai contoh:

>>> s = 'cat'      # s is an ITERABLE
                   # s is a str object that is immutable
                   # s has no state
                   # s has a __getitem__() method 

>>> t = iter(s)    # t is an ITERATOR
                   # t has state (it starts by pointing at the "c"
                   # t has a next() method and an __iter__() method

>>> next(t)        # the next() function returns the next value and advances the state
'c'
>>> next(t)        # the next() function returns the next value and advances
'a'
>>> next(t)        # the next() function returns the next value and advances
't'
>>> next(t)        # next() raises StopIteration to signal that iteration is complete
Traceback (most recent call last):
...
StopIteration

>>> iter(t) is t   # the iterator is self-iterable

Jawaban di atas bagus, tetapi karena sebagian besar dari apa yang saya lihat, jangan terlalu menekankan perbedaan untuk orang-orang seperti saya.

Juga, orang cenderung menjadi "terlalu Pythonic" dengan meletakkan definisi seperti "X adalah objek yang memiliki __foo__()metode" sebelumnya. Definisi seperti itu benar - mereka didasarkan pada filosofi pengetikan bebek, tetapi fokus pada metode cenderung terjadi ketika mencoba memahami konsep dalam kesederhanaannya.

Jadi saya menambahkan versi saya.

Dalam bahasa alami,

• iterasi adalah proses mengambil satu elemen pada satu waktu dalam deretan elemen.

Dengan Python,

• iterable adalah objek yang, yah, iterable, yang sederhananya, berarti dapat digunakan dalam iterasi, misalnya dengan forloop. Bagaimana? Dengan menggunakan iterator . Saya akan jelaskan di bawah.

• ... iterator sementara adalah objek yang mendefinisikan bagaimana sebenarnya melakukan iterasi - khususnya apa elemen berikutnya . Itu sebabnya harus ada next()metode.

Iterator sendiri juga dapat diubah, dengan perbedaan bahwa __iter__()metode mereka mengembalikan objek yang sama ( self), terlepas dari apakah itemnya telah dikonsumsi oleh panggilan sebelumnya atau tidak next().

Jadi apa yang dipikirkan oleh juru bahasa Python ketika ia melihat for x in obj:pernyataan?

Lihat, satu forlingkaran. Sepertinya pekerjaan untuk iterator ... Mari kita ambil satu. ... Ada objorang ini , jadi mari kita tanyakan padanya.

"Tuan obj, apakah Anda memiliki iterator?" (... panggilan iter(obj), panggilan obj.__iter__(), yang dengan senang hati membagikan iterator baru yang mengkilap _i.)

OK, itu mudah ... Mari kita mulai iterasi. ( x = _i.next()... x = _i.next()...)

Karena Mr. objberhasil dalam tes ini (dengan memiliki metode tertentu mengembalikan iterator yang valid), kami menghadiahinya dengan kata sifat: Anda sekarang dapat memanggilnya "Mr. iterable obj".

Namun, dalam kasus sederhana, Anda biasanya tidak mendapat manfaat dari memiliki iterator dan iterable secara terpisah. Jadi Anda mendefinisikan hanya satu objek, yang juga merupakan iteratornya sendiri. (Python tidak benar-benar peduli yang _idiberikan oleh objtidak semua yang mengkilap, tetapi hanya objitu sendiri.)

Inilah sebabnya mengapa dalam kebanyakan contoh yang saya lihat (dan apa yang membingungkan saya berulang kali), Anda dapat melihat:

class IterableExample(object):

    def __iter__(self):
        return self

    def next(self):
        pass

dari pada

class Iterator(object):
    def next(self):
        pass

class Iterable(object):
    def __iter__(self):
        return Iterator()

Namun, ada beberapa kasus ketika Anda dapat memanfaatkan iterator terpisah dari iterable, seperti ketika Anda ingin memiliki satu baris item, tetapi lebih banyak "kursor". Misalnya ketika Anda ingin bekerja dengan elemen "saat ini" dan "yang akan datang", Anda dapat memiliki iterator yang terpisah untuk keduanya. Atau beberapa utas menarik dari daftar besar: masing-masing dapat memiliki iterator sendiri untuk melintasi semua item. Lihat jawaban @ Raymond dan @ glglgl di atas.

Bayangkan apa yang bisa Anda lakukan:

class SmartIterableExample(object):

    def create_iterator(self):
        # An amazingly powerful yet simple way to create arbitrary
        # iterator, utilizing object state (or not, if you are fan
        # of functional), magic and nuclear waste--no kittens hurt.
        pass    # don't forget to add the next() method

    def __iter__(self):
        return self.create_iterator()

Catatan:

• Saya akan ulangi lagi: iterator tidak bisa diubah . Iterator tidak dapat digunakan sebagai "sumber" di forloop. Apa yang fordibutuhkan terutama loop __iter__() (yang mengembalikan sesuatu dengan next()).

• Tentu saja, for bukan satu-satunya loop iterasi, jadi di atas berlaku untuk beberapa konstruksi lain juga ( while...).

• Iterator next() dapat membuang StopIteration untuk menghentikan iterasi. Tidak harus, meskipun, itu dapat beralih selamanya atau menggunakan cara lain.

• Dalam "proses berpikir" di atas, _i tidak benar-benar ada. Saya telah mengarang nama itu.

• Ada perubahan kecil dalam Python 3.x: next()metode (bukan built-in) sekarang harus dipanggil__next__() . Ya, seharusnya seperti itu selama ini.

• Anda juga dapat menganggapnya seperti ini: iterable memiliki data, iterator menarik item berikutnya

Penafian: Saya bukan pengembang interpreter Python, jadi saya tidak benar-benar tahu apa yang "dipikirkan" penerjemah. Renungan di atas semata-mata menunjukkan bagaimana saya memahami topik dari penjelasan lain, percobaan dan pengalaman kehidupan nyata dari seorang pemula Python.

Iterable adalah objek yang memiliki __iter__()metode. Mungkin dapat diulang beberapa kali, seperti list()s dan tuple()s.

Iterator adalah objek yang diulang. Itu dikembalikan oleh suatu __iter__()metode, mengembalikan dirinya sendiri melalui __iter__()metode sendiri dan memiliki next()metode (__next__() dalam 3.x).

Iterasi adalah proses memanggil next()resp ini . __next__()sampai meningkatStopIteration .

Contoh:

>>> a = [1, 2, 3] # iterable
>>> b1 = iter(a) # iterator 1
>>> b2 = iter(a) # iterator 2, independent of b1
>>> next(b1)
1
>>> next(b1)
2
>>> next(b2) # start over, as it is the first call to b2
1
>>> next(b1)
3
>>> next(b1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>> b1 = iter(a) # new one, start over
>>> next(b1)
1

Inilah lembar contekan saya:

 sequence
  +
  |
  v
   def __getitem__(self, index: int):
  +    ...
  |    raise IndexError
  |
  |
  |              def __iter__(self):
  |             +     ...
  |             |     return <iterator>
  |             |
  |             |
  +--> or <-----+        def __next__(self):
       +        |       +    ...
       |        |       |    raise StopIteration
       v        |       |
    iterable    |       |
           +    |       |
           |    |       v
           |    +----> and +-------> iterator
           |                               ^
           v                               |
   iter(<iterable>) +----------------------+
                                           |
   def generator():                        |
  +    yield 1                             |
  |                 generator_expression +-+
  |                                        |
  +-> generator() +-> generator_iterator +-+

Kuis: Apakah Anda melihat caranya ...

1. setiap iterator adalah iterable?
2. benda kontainer __iter__()metode dapat diimplementasikan sebagai generator?
3. iterable yang memiliki __next__metode belum tentu merupakan iterator?

Jawaban:

1. Setiap iterator harus memiliki __iter__metode. Memiliki __iter__cukup untuk menjadi sesuatu yang bisa diubah. Karena itu setiap iterator adalah iterable.

2. Ketika __iter__dipanggil itu harus mengembalikan iterator ( return <iterator>dalam diagram di atas). Memanggil generator mengembalikan generator iterator yang merupakan jenis iterator.

   class Iterable1:
       def __iter__(self):
           # a method (which is a function defined inside a class body)
           # calling iter() converts iterable (tuple) to iterator
           return iter((1,2,3))
   
   class Iterable2:
       def __iter__(self):
           # a generator
           for i in (1, 2, 3):
               yield i
   
   class Iterable3:
       def __iter__(self):
           # with PEP 380 syntax
           yield from (1, 2, 3)
   
   # passes
   assert list(Iterable1()) == list(Iterable2()) == list(Iterable3()) == [1, 2, 3]

3. Berikut ini sebuah contoh:

   class MyIterable:
   
       def __init__(self):
           self.n = 0
   
       def __getitem__(self, index: int):
           return (1, 2, 3)[index]
   
       def __next__(self):
           n = self.n = self.n + 1
           if n > 3:
               raise StopIteration
           return n
   
   # if you can iter it without raising a TypeError, then it's an iterable.
   iter(MyIterable())
   
   # but obviously `MyIterable()` is not an iterator since it does not have
   # an `__iter__` method.
   from collections.abc import Iterator
   assert isinstance(MyIterable(), Iterator)  # AssertionError

Saya tidak tahu apakah itu membantu siapa pun tetapi saya selalu suka memvisualisasikan konsep di kepala saya untuk lebih memahami mereka. Jadi ketika saya memiliki seorang putra kecil saya memvisualisasikan konsep iterable / iterator dengan batu bata dan kertas putih.

Misalkan kita berada di ruangan gelap dan di lantai kita punya batu bata untuk anakku. Batu bata dengan ukuran berbeda, warna, tidak masalah sekarang. Misalkan kita punya 5 bata seperti itu. Kelima bata itu dapat digambarkan sebagai objek - misalkan kit bata . Kita dapat melakukan banyak hal dengan kit batu bata ini - dapat mengambil satu dan kemudian mengambil kedua dan ketiga, dapat mengubah tempat batu bata, meletakkan bata pertama di atas yang kedua. Kita dapat melakukan banyak hal dengan itu. Oleh karena itu kit batu bata ini adalah objek atau urutan yang dapat diubah karena kita dapat melewati setiap bata dan melakukan sesuatu dengannya. Kami hanya bisa melakukannya seperti putra kecil saya - kami bisa bermain dengan satu bata pada satu waktu . Jadi sekali lagi saya bayangkan sendiri kit batu bata ini menjadiiterable .

Sekarang ingatlah bahwa kita berada di ruangan gelap. Atau hampir gelap. Masalahnya adalah kita tidak melihat dengan jelas batu bata itu, apa warnanya, bentuk apa, dll. Jadi, bahkan jika kita ingin melakukan sesuatu dengan mereka - alias mengulanginya - kita tidak benar-benar tahu apa dan bagaimana karena itu terlalu gelap.

Apa yang bisa kita lakukan adalah dekat dengan bata pertama - sebagai elemen kit batu bata - kita dapat meletakkan selembar kertas fluoresens putih agar kita dapat melihat di mana elemen bata pertama berada. Dan setiap kali kita mengambil batu bata dari kit, kita mengganti selembar kertas putih ke batu bata berikutnya agar dapat melihatnya di ruangan gelap. Selembar kertas putih ini tidak lebih dari sebuah iterator . Itu juga obyek . Tapi sebuah objek dengan apa yang bisa kita kerjakan dan mainkan dengan elemen dari objek kita yang dapat diubah - kit batu bata.

Omong-omong menjelaskan kesalahan awal saya ketika saya mencoba yang berikut di IDLE dan mendapat TypeError:

 >>> X = [1,2,3,4,5]
 >>> next(X)
 Traceback (most recent call last):
    File "<pyshell#19>", line 1, in <module>
      next(X)
 TypeError: 'list' object is not an iterator

Daftar X di sini adalah kit batu bata kami tetapi BUKAN selembar kertas putih. Saya perlu menemukan iterator terlebih dahulu:

>>> X = [1,2,3,4,5]
>>> bricks_kit = [1,2,3,4,5]
>>> white_piece_of_paper = iter(bricks_kit)
>>> next(white_piece_of_paper)
1
>>> next(white_piece_of_paper)
2
>>>

Tidak tahu apakah itu membantu, tetapi itu membantu saya. Jika seseorang dapat mengkonfirmasi / memperbaiki visualisasi konsep, saya akan berterima kasih. Itu akan membantu saya untuk belajar lebih banyak.

Iterable : - sesuatu yang dapat diubah adalah dapat diubah; seperti urutan seperti daftar, string dll. Juga memiliki __getitem__metode atau __iter__metode. Sekarang jika kita menggunakan iter()fungsi pada objek itu, kita akan mendapatkan iterator.

Iterator : - Ketika kita mendapatkan objek iterator dari iter()fungsi; kita memanggil __next__()metode (dalam python3) atau hanya next()(dalam python2) untuk mendapatkan elemen satu per satu. Kelas atau turunan dari kelas ini disebut iterator.

Dari dokumen: -

Penggunaan iterator meliputi dan menyatukan Python. Di belakang layar, pernyataan for memanggil  iter() objek kontainer. Fungsi mengembalikan objek iterator yang mendefinisikan metode  __next__() yang mengakses elemen dalam wadah satu per satu. Ketika tidak ada elemen lagi,  __next__() memunculkan eksepsi StopIteration yang memberitahu for loop untuk mengakhiri. Anda dapat menghubungi __next__()  metode menggunakan  next() fungsi bawaan; contoh ini menunjukkan cara kerjanya:

>>> s = 'abc'
>>> it = iter(s)
>>> it
<iterator object at 0x00A1DB50>
>>> next(it)
'a'
>>> next(it)
'b'
>>> next(it)
'c'
>>> next(it)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
    next(it)
StopIteration

Mantan kelas: -

class Reverse:
    """Iterator for looping over a sequence backwards."""
    def __init__(self, data):
        self.data = data
        self.index = len(data)
    def __iter__(self):
        return self
    def __next__(self):
        if self.index == 0:
            raise StopIteration
        self.index = self.index - 1
        return self.data[self.index]


>>> rev = Reverse('spam')
>>> iter(rev)
<__main__.Reverse object at 0x00A1DB50>
>>> for char in rev:
...     print(char)
...
m
a
p
s

Saya tidak berpikir Anda bisa membuatnya lebih sederhana daripada dokumentasi , namun saya akan mencoba:

• Iterable adalah sesuatu yang bisa diulangi . Dalam praktiknya itu biasanya berarti urutan misalnya sesuatu yang memiliki awal dan akhir dan beberapa cara untuk menelusuri semua item di dalamnya.

• Anda dapat menganggap Iterator sebagai metode pseudo pembantu (atau atribut semu) yang memberikan (atau menahan) item berikutnya (atau pertama) di iterable . (Dalam praktiknya itu hanya objek yang mendefinisikan metode next())

• Iterasi mungkin paling baik dijelaskan dengan definisi kata Merriam-Webster :

b: pengulangan urutan instruksi komputer beberapa kali atau sampai kondisi terpenuhi - bandingkan rekursi

iterable = [1, 2] 

iterator = iter(iterable)

print(iterator.__next__())   

print(iterator.__next__())   

begitu,

1. iterableadalah objek yang dapat dilingkarkan . mis. daftar, string, tuple dll.

2. menggunakan iterfungsi pada iterableobjek kita akan mengembalikan objek iterator.

3. sekarang objek iterator ini memiliki metode bernama __next__(dalam Python 3, atau hanya nextdalam Python 2) dimana Anda dapat mengakses setiap elemen iterable.

jadi, OUTPUT OF KODE DI ATAS AKAN:

1

2

Iterables memiliki __iter__metode yang membuat iterator baru setiap saat.

Iterator menerapkan __next__metode yang mengembalikan item individual, dan __iter__metode yang mengembalikanself .

Oleh karena itu, iterator juga dapat diubah, tetapi iterables bukan iterator.

Luciano Ramalho, Fluent Python.

Sebelum berurusan dengan iterables dan iterator, faktor utama yang menentukan iterable dan iterator adalah urutan

Sequence: Sequence adalah kumpulan data

Iterable: Iterable adalah objek tipe urutan yang mendukung __iter__ metode.

Metode Iter: Metode Iter mengambil urutan sebagai input dan membuat objek yang dikenal sebagai iterator

Iterator: Iterator adalah objek yang memanggil metode berikutnya dan melintang melalui urutan. Saat memanggil metode berikutnya, ia mengembalikan objek yang dilaluinya saat ini.

contoh:

x=[1,2,3,4]

x adalah urutan yang terdiri dari kumpulan data

y=iter(x)

Saat memanggilnya iter(x)mengembalikan iterator hanya ketika objek x memiliki metode iter jika tidak maka akan memunculkan eksepsi. Jika ia mengembalikan iterator maka y ditugaskan seperti ini:

y=[1,2,3,4]

Karena y adalah iterator maka itu mendukung next()metode

Saat memanggil metode berikutnya, ia mengembalikan elemen individual dari daftar satu per satu.

Setelah mengembalikan elemen terakhir dari urutan jika kita kembali memanggil metode berikutnya itu meningkatkan kesalahan StopIteration

contoh:

>>> y.next()
1
>>> y.next()
2
>>> y.next()
3
>>> y.next()
4
>>> y.next()
StopIteration

Dalam Python semuanya adalah objek. Ketika suatu objek dikatakan iterable, itu berarti bahwa Anda dapat melangkah (yaitu iterate) objek sebagai koleksi.

Array misalnya dapat diubah. Anda dapat melangkah melaluinya dengan for loop, dan beralih dari indeks 0 ke indeks n, n menjadi panjang objek array minus 1.

Kamus (pasangan kunci / nilai, juga disebut array asosiatif) juga dapat diubah. Anda dapat menelusuri kunci-kunci mereka.

Jelas benda-benda yang bukan koleksi tidak bisa diubah. Objek bool misalnya hanya memiliki satu nilai, Benar atau Salah. Itu tidak dapat diubah (tidak masuk akal bahwa itu adalah objek yang dapat diubah).

Baca lebih banyak. http://www.lepus.org.uk/ref/companion/Iterator.xml