Programmation Python : Comment obtenir des générateurs et des expressions ? Venez le servir !

Préface

Dans le chapitre précédent, nous avons découvert les itérateurs, qui sont un excellent outil, en particulier lorsque vous devez traiter de grands ensembles de données. Cependant, créer vos propres itérateurs en Python est un peu fastidieux et prend du temps. Vous devez définir une nouvelle classe qui implémente le protocole itérateur (méthodes __iter__() et __next__()). Dans ce cours, vous devez gérer vous-même l'état interne des variables et les mettre à jour. De plus, lorsqu'il n'y a aucune valeur à renvoyer dans la méthode __next__(), une exception StopIteration doit être levée.

Existe-t-il une meilleure façon de le mettre en œuvre ? La réponse est oui ! Il s'agit de la solution génératrice de Python. Jetons-y un coup d'œil.

Qu'est-ce qu'un générateur ?

Afin de créer vos propres itérateurs plus efficacement, c'est bien d'avoir une solution élégante pour cela en Python. Le générateur (Generator) fourni par Python est utilisé pour nous aider à créer facilement des itérateurs. Generator permet de déclarer une fonction qui se comporte comme un itérateur, c'est-à-dire qu'elle peut être utilisée dans une boucle for. En termes simples, un générateur est une fonction qui renvoie un objet itérateur. C'est donc aussi un moyen simple de créer un itérateur. Lors de la création d'un itérateur, vous n'avez pas besoin de penser à tout le travail requis (comme le protocole d'itération et l'état interne, etc.) car le générateur gérera tout cela.

Ensuite, allons plus loin et apprenons facilement comment fonctionnent les générateurs en Python et comment les définir.

Définir un générateur

Comme mentionné dans la section précédente, un générateur est un type spécial de fonction en Python. Cette fonction ne renvoie pas une seule valeur, mais un objet itérateur. Dans les fonctions génératrices, la valeur de retour utilise une instruction rendement au lieu d'une instruction return. Une fonction génératrice simple est définie ci-dessous. La liste de codes est la suivante :

Fragment de liste de codes-01

Dans la liste ci-dessus, nous définissons une fonction génératrice. Cette fonction exécute l'instruction rendement au lieu du mot-clé return. L'instruction rendement fait de cette fonction un générateur. Lorsque nous appelons cette fonction, elle renverra (produira) un objet itérateur. Jetons un coup d'œil à l'appel du générateur :

Code List Snippet-02

Appeler un générateur est généralement similaire à créer un objet, appeler la fonction du générateur et l'attribuer à une variable.

Le résultat de l'exécution du programme est le suivant :

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

Dans le code du générateur d'application, nous appelons la fonction firstGenerator(), qui est un générateur et renvoie un objet itérateur. Nous nommons cet itérateur myIter. Appelez ensuite la fonction next() sur cet objet itérateur. À chaque appel next(), l'itérateur exécute les instructions rendement dans leur ordre respectif et renvoie un élément.

Selon les règles, cette fonction génératrice ne doit pas contenir le mot-clé return. Parce que si c'est le cas, l'instruction return mettra fin à la fonction et les exigences de l'itérateur ne seront pas satisfaites.

Maintenant, définissons un générateur plus pratique à l'aide d'une boucle for. Dans cet exemple, nous définirons un générateur qui générera en continu une séquence de nombres partant de 0, jusqu'à une limite maximale donnée.

La liste de codes est la suivante :

Code List Snippet-03

Le résultat de l'exécution du programme est similaire à ce qui suit :

0
1
2
3

Dans la liste ci-dessus, nous définissons une fonction génératrice qui génère un entier de 0 à un nombre donné. Comme vous pouvez le voir, l'instruction rendement se trouve à l'intérieur de la boucle for. Notez que la valeur de n est automatiquement stockée dans les appels next() successifs.

Une chose à noter est que lors de la définition d'un générateur, la valeur de retour doit être une instruction rendement. Cela ne signifie pas qu'une instruction return ne peut pas apparaître dans un générateur. C'est juste que l'instruction return qui renvoie une valeur non None est généralement placée à la fin du générateur pour ajouter des informations supplémentaires à l'exception StopIteration afin que l'appelant puisse la gérer. Un exemple est le suivant :

Fragment de liste de codes-04

Ce qui suit est le résultat de l'exécution du programme sans gestion des exceptions, qui est similaire à ce qui suit :

99

100

Traceback (most recent call last):

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

print(next(g))

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

Si le programme est intercepté avec des exceptions ( try-sauf), les résultats affichés sont plus concis, essayez de l'exécuter vous-même.

生成器与普通函数

如果一个函数至少包含一个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常规的生成器方方面面。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!