Python Academy · Pelajaran

Protokol Lelaran

Fahami __iter__ dan __next__

Pelajaran 1 daripada 413 langkah

Protokol Lelaran ialah pelajaran Python Academy percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Python Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Python Academy merangkumi sejumlah 4 pelajaran.

Apakah Lelaran

Setiap kali anda menulis gelung for untuk senarai, rentetan atau kamus, Python menggunakan protokol lelaran di sebalik tabir.

Objek yang boleh anda ulangi dipanggil objek boleh lelar. Perkara yang sebenarnya menghasilkan nilai satu demi satu dipanggil lelaran.

for ch in 'abc':
    print(ch)

iter() dan next()

Dua fungsi terbina dalam menggerakkan lelaran:

iter(obj) meminta objek boleh lelar memberikan lelarannya.
next(it) meminta lelaran memberikan nilai seterusnya.

Apabila tiada lagi nilai, next() menaikkan StopIteration.

it = iter([10, 20, 30])
print(next(it))
print(next(it))
print(next(it))

StopIteration

Memanggil next() sekali terlalu banyak akan menaikkan StopIteration. Gelung for menangkapnya secara automatik dan berhenti dengan kemas.

it = iter([1])
print(next(it))
try:
    next(it)
except StopIteration:
    print('No more items')

Dua Kaedah Khas

Untuk mencipta lelaran sendiri, anda melaksanakan dua kaedah:

__iter__ memulangkan objek lelaran itu sendiri.
__next__ memulangkan nilai seterusnya atau menaikkan StopIteration.

class Count:
    def __init__(self, n):
        self.i = 0
        self.n = n
    def __iter__(self):
        return self
    def __next__(self):
        if self.i >= self.n:
            raise StopIteration
        self.i += 1
        return self.i

for x in Count(3):
    print(x)

Objek Boleh Lelaran berbanding Lelaran

Objek boleh lelar hanya memerlukan __iter__. Lelaran memerlukan kedua-dua __iter__ dan __next__.

Senarai ialah objek boleh lelar tetapi bukan lelaran: setiap panggilan kepada iter() memberikan lelaran yang baharu.

nums = [1, 2, 3]
print(iter(nums) is iter(nums))
it = iter(nums)
print(it is iter(it))

Lelaran Hanya Boleh Dihabiskan Sekali

Sesuatu lelaran hanya boleh digunakan sekali. Selepas anda sampai ke penghujung, lelaran itu kekal kosong. Untuk mengulanginya, cipta lelaran baharu.

it = iter([1, 2])
print(list(it))
print(list(it))

Lelaran Seperti Julat

Mari kita bina lelaran tersuai yang berkelakuan seperti pembilang ringkas. Perhatikan bahawa keadaannya berada dalam tika.

class EvenUpTo:
    def __init__(self, limit):
        self.cur = 0
        self.limit = limit
    def __iter__(self):
        return self
    def __next__(self):
        if self.cur > self.limit:
            raise StopIteration
        value = self.cur
        self.cur += 2
        return value

print(list(EvenUpTo(8)))

Memisahkan Objek Boleh Lelaran dan Lelaran

Reka bentuk yang lebih kemas mengasingkan bekas dan lelaran, supaya bekas itu boleh diulang berkali-kali.

class Bag:
    def __init__(self, items):
        self.items = items
    def __iter__(self):
        return BagIterator(self.items)

class BagIterator:
    def __init__(self, items):
        self.items = items
        self.i = 0
    def __iter__(self):
        return self
    def __next__(self):
        if self.i >= len(self.items):
            raise StopIteration
        v = self.items[self.i]
        self.i += 1
        return v

b = Bag(['x', 'y'])
print(list(b))
print(list(b))

Menggunakan next() dengan Nilai Lalai

next(it, default) memulangkan nilai lalai dan bukannya menaikkan StopIteration apabila lelaran kosong. Berguna untuk melihat nilai dengan selamat.

it = iter([42])
print(next(it, 'done'))
print(next(it, 'done'))

Lelaran Menjimatkan Memori

Lelaran menghasilkan satu item pada satu masa, jadi lelaran tidak perlu menyimpan keseluruhan jujukan dalam memori. Itulah sebabnya lelaran boleh digunakan untuk aliran yang sangat besar atau bahkan tidak terhingga.

class Naturals:
    def __init__(self):
        self.n = 0
    def __iter__(self):
        return self
    def __next__(self):
        self.n += 1
        return self.n

it = iter(Naturals())
print(next(it), next(it), next(it))

Fungsi Terbina Dalam yang Menghabiskan Lelaran

Banyak fungsi terbina dalam menerima sebarang objek lelar: sum, max, min, sorted, list, tuple. Fungsi-fungsi ini mendapatkan nilai sehingga StopIteration.

class Count:
    def __init__(self, n):
        self.i = 0
        self.n = n
    def __iter__(self):
        return self
    def __next__(self):
        if self.i >= self.n:
            raise StopIteration
        self.i += 1
        return self.i

print(sum(Count(5)))
print(max(Count(5)))

Semakan Ringkas

Uji pemahaman Anda tentang protokol lelaran.

Jawab dalam pelajaran interaktif

Imbas Kembali

Anda telah mempelajari protokol lelaran:

iter() mendapatkan objek lelar; next() mendapatkan nilai.
StopIteration menandakan penghujung, dan for mengendalikannya.
Objek lelar tersuai melaksanakan __iter__ dan __next__.
Objek lelar digunakan sekali sahaja dan menjimatkan memori.

Seterusnya, Anda akan membiarkan Python menulis objek lelar untuk Anda dengan yield.

Percuma untuk bermula

Pelajari Python dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 76
Pelajaran: 320

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Protokol Lelaran” percuma?

Ya — teks penuh “Protokol Lelaran” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Python Academy, tingkat taraf kepada CoddyKit PRO. Kursus Python Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Protokol Lelaran”?

Fahami __iter__ dan __next__ Anda berlatih Python Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Python Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Python Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 4.

Berapa lamakah pelajaran “Protokol Lelaran” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Python Academy ini?

Ya. Setiap pelajaran Python Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Python Academy