Generator Python

Dalam tutorial ini, Anda akan belajar cara membuat iterasi dengan mudah menggunakan generator Python, perbedaannya dengan iterator dan fungsi normal, dan mengapa Anda harus menggunakannya.

Video:Generator Python

Generator dengan Python

Ada banyak pekerjaan dalam membangun iterator dengan Python. Kita harus mengimplementasikan kelas dengan __iter__() dan __next__() metode, lacak status internal, dan tingkatkan StopIteration ketika tidak ada nilai yang dikembalikan.

Ini panjang dan berlawanan dengan intuisi. Generator datang untuk menyelamatkan dalam situasi seperti itu.

Generator Python adalah cara sederhana untuk membuat iterator. Semua pekerjaan yang kami sebutkan di atas secara otomatis ditangani oleh generator dengan Python.

Sederhananya, generator adalah fungsi yang mengembalikan objek (iterator) yang dapat kita ulangi (satu nilai pada satu waktu).

Buat Generator dengan Python

Cukup sederhana untuk membuat generator dengan Python. Ini semudah mendefinisikan fungsi normal, tetapi dengan yield pernyataan alih-alih return pernyataan.

Jika suatu fungsi berisi setidaknya satu yield pernyataan (mungkin berisi yield . lainnya atau return pernyataan), itu menjadi fungsi generator. Keduanya yield dan return akan mengembalikan beberapa nilai dari suatu fungsi.

Perbedaannya adalah ketika return pernyataan mengakhiri fungsi sepenuhnya, yield pernyataan menjeda fungsi yang menyimpan semua statusnya dan kemudian melanjutkan dari sana pada panggilan yang berurutan.

Perbedaan antara fungsi Generator dan fungsi Normal

Berikut adalah perbedaan fungsi generator dari fungsi normal.

Fungsi generator berisi satu atau lebih yield pernyataan.
Saat dipanggil, ia mengembalikan objek (iterator) tetapi tidak segera memulai eksekusi.
Metode seperti __iter__() dan __next__() diimplementasikan secara otomatis. Jadi kami dapat mengulangi item menggunakan next() .
Setelah fungsi menghasilkan, fungsi dijeda dan kontrol ditransfer ke pemanggil.
Variabel lokal dan statusnya diingat di antara panggilan yang berurutan.
Akhirnya, ketika fungsi berakhir, StopIteration dinaikkan secara otomatis pada panggilan lebih lanjut.

Berikut adalah contoh untuk menggambarkan semua poin yang disebutkan di atas. Kami memiliki fungsi generator bernama my_gen() dengan beberapa yield pernyataan.

# A simple generator function
def my_gen():
    n = 1
    print('This is printed first')
    # Generator function contains yield statements
    yield n

    n += 1
    print('This is printed second')
    yield n

    n += 1
    print('This is printed at last')
    yield n

Proses interaktif dalam interpreter diberikan di bawah ini. Jalankan ini di shell Python untuk melihat hasilnya.

>>> # It returns an object but does not start execution immediately.
>>> a = my_gen()

>>> # We can iterate through the items using next().
>>> next(a)
This is printed first
1
>>> # Once the function yields, the function is paused and the control is transferred to the caller.

>>> # Local variables and theirs states are remembered between successive calls.
>>> next(a)
This is printed second
2

>>> next(a)
This is printed at last
3

>>> # Finally, when the function terminates, StopIteration is raised automatically on further calls.
>>> next(a)
Traceback (most recent call last):
...
StopIteration
>>> next(a)
Traceback (most recent call last):
...
StopIteration

Satu hal yang menarik untuk diperhatikan pada contoh di atas adalah nilai variabel n diingat di antara setiap panggilan.

Tidak seperti fungsi normal, variabel lokal tidak dihancurkan saat fungsi menghasilkan. Selanjutnya, objek generator hanya dapat diulang satu kali.

Untuk memulai kembali proses, kita perlu membuat objek generator lain menggunakan sesuatu seperti a = my_gen() .

Satu hal terakhir yang perlu diperhatikan adalah kita dapat menggunakan generator dengan for loop secara langsung.

Ini karena for loop mengambil iterator dan mengulanginya menggunakan next() fungsi. Secara otomatis berakhir ketika StopIteration dibangkitkan. Periksa di sini untuk mengetahui bagaimana for loop sebenarnya diimplementasikan dengan Python.

# A simple generator function
def my_gen():
    n = 1
    print('This is printed first')
    # Generator function contains yield statements
    yield n

    n += 1
    print('This is printed second')
    yield n

    n += 1
    print('This is printed at last')
    yield n


# Using for loop
for item in my_gen():
    print(item)

Saat Anda menjalankan program, outputnya adalah:

This is printed first
1
This is printed second
2
This is printed at last
3

Generator Python dengan Loop

Contoh di atas kurang bermanfaat dan kami mempelajarinya hanya untuk mendapatkan gambaran tentang apa yang terjadi di latar belakang.

Biasanya, fungsi generator diimplementasikan dengan loop yang memiliki kondisi terminasi yang sesuai.

Mari kita ambil contoh generator yang membalikkan string.

def rev_str(my_str):
    length = len(my_str)
    for i in range(length - 1, -1, -1):
        yield my_str[i]


# For loop to reverse the string
for char in rev_str("hello"):
    print(char)

Keluaran

o
l
l
e
h

Dalam contoh ini, kami telah menggunakan range() berfungsi untuk mendapatkan indeks dalam urutan terbalik menggunakan for loop.

Catatan :Fungsi generator ini tidak hanya bekerja dengan string, tetapi juga dengan jenis iterable lainnya seperti list, tuple, dll.

Ekspresi Generator Python

Generator sederhana dapat dengan mudah dibuat dengan cepat menggunakan ekspresi generator. Membuat generator menjadi mudah.

Mirip dengan fungsi lambda yang membuat fungsi anonim, ekspresi generator membuat fungsi generator anonim.

Sintaks untuk ekspresi generator mirip dengan pemahaman daftar di Python. Tapi tanda kurung siku diganti dengan tanda kurung bulat.

Perbedaan utama antara pemahaman daftar dan ekspresi generator adalah bahwa pemahaman daftar menghasilkan seluruh daftar sementara ekspresi generator menghasilkan satu item pada satu waktu.

Mereka memiliki eksekusi yang malas (memproduksi barang hanya ketika diminta). Karena alasan ini, ekspresi generator jauh lebih hemat memori daripada pemahaman daftar yang setara.

# Initialize the list
my_list = [1, 3, 6, 10]

# square each term using list comprehension
list_ = [x**2 for x in my_list]

# same thing can be done using a generator expression
# generator expressions are surrounded by parenthesis ()
generator = (x**2 for x in my_list)

print(list_)
print(generator)

Keluaran

[1, 9, 36, 100]
<generator object <genexpr> at 0x7f5d4eb4bf50>

Kita dapat melihat di atas bahwa ekspresi generator tidak segera menghasilkan hasil yang diperlukan. Sebagai gantinya, ia mengembalikan objek generator, yang menghasilkan item hanya sesuai permintaan.

Berikut adalah bagaimana kita bisa mulai mendapatkan item dari generator:

# Initialize the list
my_list = [1, 3, 6, 10]

a = (x**2 for x in my_list)
print(next(a))

print(next(a))

print(next(a))

print(next(a))

next(a)

Ketika kita menjalankan program di atas, kita mendapatkan output sebagai berikut:

1
9
36
100
Traceback (most recent call last):
  File "<string>", line 15, in <module>
StopIteration

Ekspresi generator dapat digunakan sebagai argumen fungsi. Bila digunakan sedemikian rupa, tanda kurung bulat dapat dihilangkan.

>>> sum(x**2 for x in my_list)
146

>>> max(x**2 for x in my_list)
100

Penggunaan Generator Python

Ada beberapa alasan yang menjadikan generator sebagai implementasi yang andal.

1. Mudah Diimplementasikan

Generator dapat diimplementasikan dengan cara yang jelas dan ringkas dibandingkan dengan rekan kelas iteratornya. Berikut adalah contoh untuk mengimplementasikan urutan pangkat 2 menggunakan kelas iterator.

class PowTwo:
    def __init__(self, max=0):
        self.n = 0
        self.max = max

    def __iter__(self):
        return self

    def __next__(self):
        if self.n > self.max:
            raise StopIteration

        result = 2 ** self.n
        self.n += 1
        return result

Program di atas panjang dan membingungkan. Sekarang, lakukan hal yang sama menggunakan fungsi generator.

def PowTwoGen(max=0):
    n = 0
    while n < max:
        yield 2 ** n
        n += 1

Karena generator melacak detail secara otomatis, implementasinya menjadi lebih ringkas dan lebih bersih.

2. Memori Efisien

Fungsi normal untuk mengembalikan urutan akan membuat seluruh urutan dalam memori sebelum mengembalikan hasilnya. Ini berlebihan, jika jumlah item dalam urutan sangat besar.

Implementasi generator dari urutan seperti itu ramah memori dan lebih disukai karena hanya menghasilkan satu item pada satu waktu.

3. Mewakili Aliran Tak Terbatas

Generator adalah media yang sangat baik untuk mewakili aliran data yang tak terbatas. Aliran tak terbatas tidak dapat disimpan dalam memori, dan karena generator hanya menghasilkan satu item dalam satu waktu, mereka dapat mewakili aliran data tak terbatas.

Fungsi generator berikut dapat menghasilkan semua bilangan genap (setidaknya secara teori).

def all_even():
    n = 0
    while True:
        yield n
        n += 2

4. Pembangkit Pipa

Beberapa generator dapat digunakan untuk menyalurkan serangkaian operasi. Ini paling baik diilustrasikan menggunakan contoh.

Misalkan kita memiliki generator yang menghasilkan angka-angka dalam deret Fibonacci. Dan kami memiliki generator lain untuk mengkuadratkan angka.

Jika kita ingin mengetahui jumlah kuadrat dari bilangan-bilangan pada deret Fibonacci, kita dapat melakukannya dengan cara berikut dengan mem-pipelin output dari fungsi generator secara bersamaan.

def fibonacci_numbers(nums):
    x, y = 0, 1
    for _ in range(nums):
        x, y = y, x+y
        yield x

def square(nums):
    for num in nums:
        yield num**2

print(sum(square(fibonacci_numbers(10))))

Keluaran

Pipelining ini efisien dan mudah dibaca (dan ya, jauh lebih keren!).

Python Iterator Penutupan Python

Python