Pengaturcaraan Python: Bagaimana untuk mendapatkan penjana dan ekspresi? Datang dan hidangkan!

Prakata

Dalam bab sebelumnya, kami mempelajari tentang iterator, yang merupakan alat yang hebat, terutamanya apabila anda perlu memproses set data yang besar. Walau bagaimanapun, membina iterator anda sendiri dalam Python agak menyusahkan dan memakan masa. Anda mesti menentukan kelas baharu yang melaksanakan protokol iterator (__iter__() dan kaedah __next__()). Dalam kelas ini, anda perlu mengurus sendiri keadaan dalaman pembolehubah dan mengemas kininya. Di samping itu, apabila tiada nilai untuk dikembalikan dalam kaedah __next__(), pengecualian StopIteration perlu dibuang.

Adakah terdapat cara yang lebih baik untuk melaksanakannya? Jawapannya ya! Ini adalah penyelesaian penjana Python. Mari kita lihat.

Apakah penjana?

Untuk membina iterator anda sendiri dengan lebih cekap, adalah bagus untuk mempunyai penyelesaian yang elegan untuk ini dalam Python. Penjana (Generator) yang disediakan oleh Python digunakan untuk membantu kami membuat iterator dengan mudah. Penjana membolehkan anda mengisytiharkan fungsi yang berkelakuan seperti iterator, iaitu, ia boleh digunakan dalam gelung for. Ringkasnya, penjana ialah fungsi yang mengembalikan objek lelaran. Jadi ini juga cara mudah untuk mencipta iterator. Apabila mencipta iterator, anda tidak perlu memikirkan semua kerja yang diperlukan (seperti protokol lelaran dan keadaan dalaman, dsb.) kerana Penjana akan mengendalikan semua kerja ini.

Seterusnya, kami melangkah lebih jauh dan mempelajari cara penjana berfungsi dalam Python dan cara mentakrifkannya dengan mudah.

Tentukan penjana

Seperti yang dinyatakan dalam bahagian sebelumnya, penjana ialah jenis fungsi khas dalam Python. Fungsi ini tidak mengembalikan nilai tunggal, tetapi objek lelaran. Dalam fungsi penjana, nilai pulangan menggunakan penyata hasil dan bukannya penyata pulangan. Fungsi penjana mudah ditakrifkan di bawah Senarai kod adalah seperti berikut:

Senarai Kod Fragmen-01

Dalam senarai di atas, kami mentakrifkan penjana fungsi . Fungsi ini melaksanakan pernyataan hasil dan bukannya kata kunci pulangan. Pernyataan hasil menjadikan fungsi ini sebagai penjana. Apabila kita memanggil fungsi ini, ia akan mengembalikan (menghasilkan) objek lelaran. Mari kita lihat panggilan penjana:

Senarai Kod Fragmen-02

Memanggil penjana biasanya serupa dengan mencipta objek, memanggil fungsi penjana, dan diberikan kepada pembolehubah.

Output menjalankan program adalah seperti berikut:

Yielding First Item
A
Yielding Second Item
B
Yielding Last Item
C

Dalam kod penjana aplikasi, kami memanggil fungsi firstGenerator(), iaitu penjana dan mengembalikan objek lelaran. Kami menamakan iterator ini myIter. Kemudian panggil fungsi next() pada objek iterator ini. Pada setiap panggilan seterusnya(), iterator melaksanakan pernyataan hasil dalam susunan masing-masing dan mengembalikan item.

Mengikut peraturan, fungsi penjana ini tidak sepatutnya mengandungi kata kunci pulangan. Kerana jika ia berlaku, pernyataan pemulangan akan menamatkan fungsi dan keperluan iterator tidak akan dipenuhi.

Sekarang, mari kita tentukan penjana yang lebih praktikal dengan bantuan gelung untuk. Dalam contoh ini, kami akan menentukan penjana yang akan terus menjana urutan nombor bermula dari 0, sehingga had maksimum yang diberikan.

Senarai kod adalah seperti berikut:

Senarai Kod Fragmen-03

Hasil output menjalankan program adalah serupa dengan berikut:

0
1
2
3

Dalam penyenaraian di atas, kami mentakrifkan fungsi penjana yang menjana integer daripada 0 kepada nombor tertentu. Seperti yang anda lihat, pernyataan hasil berada di dalam gelung for. Ambil perhatian bahawa nilai n disimpan secara automatik dalam panggilan next() berturut-turut.

Satu perkara yang perlu diambil perhatian ialah apabila mentakrifkan penjana, nilai pulangan mestilah pernyataan hasil Ini tidak bermakna pernyataan pulangan tidak boleh muncul dalam penjana. Cuma kenyataan pemulangan yang mengembalikan nilai bukan Tiada biasanya diletakkan di hujung penjana untuk menambah maklumat tambahan pada pengecualian StopIteration supaya pemanggil boleh mengendalikannya. Contohnya adalah seperti berikut:

Senarai Kod Fragmen-04

Berikut ialah hasil keluaran menjalankan atur cara tanpa pengendalian pengecualian, yang serupa dengan yang berikut:

99

100

Traceback (most recent call last):

File "……", line 11, in <module>

print(next(g))

StopIteration: 不支持大于100的数字生成！

Jika anda melakukan pemprosesan penangkapan pengecualian (cuba-kecuali) pada program, hasil yang dipaparkan akan menjadi lebih ringkas. Cuba jalankan sendiri.

生成器与普通函数

如果一个函数至少包含一个yield语句，那么它就是生成器函数。如果需要，还可以包含其他yield或return语句。yield和return关键字都将从函数中返回一些东西。

return和yield关键字之间的差异对于生成器来说非常重要。return语句会完全终止函数，而yield语句会暂停函数，保存它的所有状态，然后在后续的调用中继续执行。

我们调用生成器函数的方式和调用普通函数一样。但在执行过程中，生成器在遇到yield关键字时暂停。它将迭代器流的当前值发送到调用环境，并等待下一次调用。同时，它在内部保存局部变量及其状态。

以下是生成器函数与普通函数不同的关键点:

• ü Generator函数返回(生成)一个迭代器对象。你无需担心显式地创建此迭代器对象，yield关键字为你做了这个工作。
• ü Generator函数必须包含至少一个yield语句。如果需要，它可能包括多个yield关键字。
• ü Generator函数内部实现迭代器协议(iter()和next()方法)。
• ü Generator函数自动保存局部变量及其状态。
• ü Generator函数在yield关键字处暂停执行，并将控制权传递给调用者。
• ü Generator函数在迭代器流没有返回值时自动引发StopIteration异常。

我们用一个简单的例子来演示普通函数和生成器函数之间的区别。在这个例子中，我们要计算前n个正整数的和。为此，我们将定义一个函数，该函数给出前n个正数的列表。我们将以两种方式实现这个函数，一个普通函数和一个生成器函数。

普通函数代码如下：

代码清单片段-05

运行程序输出结果类似如下：

49999995000000

Elapsed Time in seconds: 1.2067763805389404

在代码清单中，我们定义一个普通函数，它返回前n个正整数的列表。当我们调用这个函数时，它需要一段时间来完成执行，因为它创建的列表非常庞大。它还使用了大量内存来完成此任务。

现在让我们为相同的操作定义一个生成器函数来实现，代码清单如下:

代码清单片段-06

运行程序结果类似如下：

49999995000000
（生成器模式）Elapsed Time in seconds: 1.0013225078582764

正如在生成器清单中所见，生成器在更短的时间内完成相同的任务，并且使用更少的内存资源。因为生成器是一个一个地生成项，而不是返回完整的列表。

性能改进的主要原因(当我们使用生成器时)是值的惰性生成。这种按需值生成的方式，会降低内存使用量。生成器的另一个优点是，你不需要等到所有元素都生成后才开始使用它们。

生成器表达式

有时候，我们需要简单的生成器来执行代码中相对简单的任务。这正是生成器表达式（Generator Expression）用武之地。可以使用生成器表达式轻松地动态创建简单的生成器。

生成器表达式类似于Python中的lambda函数。但要记住，lambda是匿名函数，它允许我们动态地创建单行函数。就像lambda函数一样，生成器表达式创建的是匿名生成器函数。

生成器表达式的语法看起来像一个列表推导式。不同之处在于，我们在生成器表达式中使用圆括号而不是方括号。请看示例:

运行结果类似如下：

49999995000000

（生成器模式）Elapsed Time in seconds: 1.0013225078582764

在上述清单中，我们在生成器表达式的帮助下定义了一个简单的生成器。下面是语法:cubes_gen = (i**3 for i in nums)。你可以在输出中看到生成器对象。正如所已经知的，为了能够在生成器中获取项，我们要么显式调用next()方法，要么使用for循环遍历生成器。接下来就打印cubes_gen对象中的项:

运行程序，遍历出的元素项结果是否和列表推导式一样。

我们再看一个例子。来定义一个生成器，将字符串中的字母转换为大写字母。然后调用next()方法打印前两个字母。代码示例如下：

运行输出结果如下：

M
A

生成器好处

生成器是非常棒的工具，特别是当需要在相对有限的内存中处理大型数据时。以下是在Python中使用生成器的一些主要好处:

1）内存效率:

假设有一个返回结果非常大序列的普通函数。例如，一个包含数百万项的列表。你必须等待这个函数完成所有的执行，并将整个列表返回给你。就时间和内存资源而言，这显然是低效的。另一方面，如果你使用生成器函数，它将一个一个地返回项，你将有机会继续执行下一行代码。而不需要等待函数执行列表中的所有项。因为生成器一次只给你一项。

2）延迟计算:

生成器提供了延迟(惰性)计算求值的功能。延迟计算是在真正需要值时计算值，而不是在实例化时计算值。假设你有一个大数据集要计算，延迟计算允许你在整个数据集仍在计算生成中可立即开始使用数据。因为如果使用生成器，则不需要整个数据集。

3）易实现和可读性:

生成器非常容易实现，并且提供了好的代码可读性。记住，如果你使用生成器，你不需要担心__iter__()和__next__()方法。你所需要的只是函数中一个简单的yield语句。

4）处理无限流:

当你需要表示无限的数据流时，生成器是非常棒的工具。例如，一个无限计数器。理论上，你不能在内存中存储无限流的，因为你无法确定存储无限流需要多少的内存大小。这是生成器真正发挥作用的地方，因为它一次只产生一项，它可以表示无限的数据流。它不需要将所有的数据流存储在内存中。

本文小结

主要介绍了生成器相关知识，用于更好的自定义迭代器。内容包括何为生成器？如何自定义生成器以及和普通函数的关键区别？如何实现生成器表达式？并总结了生成器的有点。通过这篇文章，相信你能更轻松高效的掌握Python常规的生成器方方面面。

Atas ialah kandungan terperinci Pengaturcaraan Python: Bagaimana untuk mendapatkan penjana dan ekspresi? Datang dan hidangkan!. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!