Analyse détaillée Python des conteneurs, des objets itérables, des itérateurs et des générateurs

Cet article vous apporte des connaissances pertinentes sur python, qui présente principalement des problèmes liés aux conteneurs, aux objets itérables, aux itérateurs et aux générateurs. Examinons-les ensemble, j'espère que cela sera utile à tout le monde.

Apprentissage recommandé : Tutoriel vidéo Python

Lorsque vous avez commencé à apprendre Python, avez-vous souvent entendu les grands parler de conteneurs, d'objets itérables, d'itérateurs, de générateurs, de listes/ensembles/dérivation de dictionnaire et bien d'autres concepts , en fait, ce n'est pas parce que les grands utilisent simplement des termes professionnels pour prétendre être B, mais ces choses doivent être comprises. Il ne suffit pas de connaître les bases des chaînes, des listes, etc., en particulier dans les aspects de la structure des données de Python.

Aujourd'hui, je vais vous parler des concepts difficiles à comprendre de conteneurs, d'objets itérables, d'itérateurs et de générateurs en Python, afin de faire passer votre base Python au niveau supérieur !

1. Conteneur

1. Qu'est-ce qu'un conteneur ?

En Python, un conteneur est une structure de données qui organise plusieurs éléments ensemble. Les éléments du conteneur peuvent être obtenus de manière itérative un par un. Pour parler franchement, sa fonction est tout comme son nom : utilisée pour stocker des choses (des données).

Le conteneur n'existe pas en réalité. Ce n'est pas un type de données, c'est juste un concept créé par l'homme pour faciliter l'apprentissage. Il peut être utilisé avec l'opérateur d'adhésion (in ou non). Déterminez si l'objet se trouve à l'intérieur du conteneur.

Bien sûr, ce n'est pas moi qui l'ai créé. Je n'en suis pas capable. Vous n'avez pas à vous inquiéter si je vous apprends des noms étranges que personne d'autre ne comprendra. ... python C'est ainsi que l'appelle la capitale centrale. Les types de conteneurs courants incluent la liste (list), le tuple (tuple), la chaîne (str), le dictionnaire (dict) et l'ensemble (set).

Étant donné que les données dans le conteneur peuvent être obtenues de manière itérative, nous devons apprendre un nouveau concept : les objets itérables.

---

2. Objets itérables

1. Qu'est-ce qu'un objet itérable ?

En python, un objet itérable ne fait pas référence à un type de données spécifique, il fait référence à un objet conteneur qui stocke des éléments.

En d'autres termes, si aucune donnée n'est stockée dans le conteneur, alors ce n'est pas un objet itérable. Tous les conteneurs ne sont pas des objets itérables. Les conteneurs incluent, sans s'y limiter, des objets itérables.

Faites attention à deux points :

1.很多容器都是可迭代对象（容器包含了可迭代对象）。

2.一个可迭代对象是不能独立的进行迭代的，迭代是通过for来完成的，凡是可迭代对象都可以直接使用for循环进行访问。

Tout le monde devrait être familier avec la boucle for, n'est-ce pas ? Vous êtes-vous déjà demandé comment la boucle for est implémentée ? Par exemple, dans cet exemple de boucle for, pourquoi peut-il afficher chaque élément de la liste ? Comment est-il mis en œuvre en interne ?

En fait, la boucle for fait deux choses :

1.使用 __iter__() 返回1个迭代器，迭代器在下面会讲，这里先知道有这么个东西。

2.使用 __next__() 获取迭代器中的每一个元素。

Ensuite, nous n'avons pas besoin d'une boucle for pour afficher chaque élément de la liste,

l = [1,2,3,4]# for i in l:#     print(i)ite =l.__iter__() #接收一下ietr()干了什么print(ite)  
#打印print(ite.__next__())    
#for循环干第2件事情的时候做的第1步print(ite.__next__())    
#for循环干第2件事情的时候做的第2步print(ite.__next__())   
 #for循环干第2件事情的时候做的第3步print(ite.__next__())    
#for循环干第2件事情的时候做的第4步

Le résultat de sortie :

Vous Nous pouvons voir que si nous supprimons la ligne de code qui l'imprime, et que l'effet d'exécution est le même que celui de chaque élément de la liste de sortie de la boucle for, la boucle for limite la plage à 4 fois, mais exécute en fait __iter__() une fois et 4. times_ _next__(), c'est-à-dire que l'essence de la boucle for accédant à l'objet d'itération est réalisée de cette manière.

De plus, les deux choses que fait essentiellement la boucle for sont indispensables. C'est-à-dire que si __iter__() ne renvoie pas l'itérateur en premier, __next()__ ne pourra pas obtenir l'élément, qui illustre exactement ce qui était. dit plus tôt. Le deuxième des deux points à noter : un objet itérable ne peut pas être itéré indépendamment.

Il existe deux fonctions intégrées qui ont le même principe et la même essence. De manière générale, il est plus pratique d'utiliser des fonctions intégrées. Au moins, vous n'avez pas besoin d'écrire autant de traits de soulignement :

内置函数 iter() 的本质是 __inter__() ，也是返回一个迭代器。

内置函数 next（） 的本质是 __next__()，也是有了迭代器之后获取元素。

. On peut voir que les résultats sont exactement les mêmes. Puisque nous parlons d’itérateurs, regardons ce qu’est un itérateur.

3. Itérateur

Nous pouvons probablement le voir dans l'exemple de boucle for ci-dessus,

只要是实现了__iter__()和__next__()的对象，就是迭代器，迭代器是一个可迭代对象。

总之，迭代器是有__iter__()生成，可以通过__next__()进行调用。

Dans ce cas, nous avons mentionné que range() est un objet itérable lorsque nous avons appris les bases de Python, il peut donc également être transmis __iter__() génère un itérateur.

---

4. Séquence

J'ai mentionné la séquence dans l'article spécial [Assignment Statement]. Permettez-moi d'en reparler ici La séquence est aussi un concept abstrait, qui comprend des listes, des tuples et des chaînes . n'existe pas en soi, et c'est aussi un mot conceptuel créé pour faciliter l'apprentissage.

可迭代对象包含序列，既然序列包含了列表、元组和字符串，前面我们的例子中也涉及到 了，所以说序列可以被iter（）和next（）使用。

序列可以分为有限序列和无限序列。有限序列就是有范围的，比如说range(10)就已经限定了范围，相反的，无限序列也就是没有限定范围的序列。

我们来生成一个无限序列，这里需要用到1个新模块itertools，itertools用于高效循环的迭代函数集合,它下面有一个方法count()，可生成迭代器且无范围，可以理解为无限迭代器。

通过这个例子我们可以看出来，只要执行一次，next()就会获取一次迭代器里面的内容并逐次获取，我这里只写了4个next()，你多写几次就会多输出几次。

像next()这种什么时候需要就什么时候调用的机制叫做懒加载机制，也叫懒汉式加载；

相反地就有饿汉式加载。比如for循环这种的，只要一执行就会把可迭代器里面的所有对象都获取。

---

五、列表推导式

列表推导式跟生成器有关，在讲生成器之前，需要先知道什么是列表推导式，列表推导式就是生成列表的一种方法，语法是这样的：

l = [i for i in 可迭代对象]

i表示要放进列表里的对象，for循环是一个式子。

比如我们用列表推导式来生成一个列表试试：

l = [i for i in range(5)]print(l)

运行结果：

[0, 1, 2, 3, 4]

运用列表推导式可以很方便地生成我们想要的列表。

同时它也有很多灵活的用法，比如在后面加上条件判断

l = [i for i in range(5) if 4<p>运行结果：</p><div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false">[0, 1, 2, 3, 4]

Copier après la connexion

if后面的条件判断为真，则可以正常生成列表，如果为假，则列表推导式是无效的，此时的l将是一个空列表。

还有其他灵活的用法，比如操作前面的i,比如让i的数值全都翻2倍：

我们把迭代对象换一下，换成字符串，也同样可以输出，只是*在字符串里面表示重复操作符，所以效果变成了这样：

不仅如此，前面的i*2我们还可以用函数来进行操作，比如：

总而言之，列表推导式就是用来快速和自定义生成列表的一种方法，很灵活。

那么有人可能会举一反三了，列表推导式都是用 [] 来进行操作的，那如果用（）来操作行吗?它会不会生成一个元组？我们来看看：

[] 换成（）之后，返回的是一个生成器generrator ，那么下面我们再来讲讲生成器：

---

六、生成器

生成器是真实存在于Python中的对象，与容器这种概念词是不同的，它是可以直接通过next()进行调用的。

1.生成器的第一种创建方法：生成器表达式

第一种创建方法跟列表推导式是差不多的，就是 [] 换成了（）：

l = (i for i in 可迭代对象)

比如我们来生成一个生成器，看看能不能用next()直接调用：

l = (i for i in "abcd")print(next(l))

运行结果：

a

可以看出，生成器是可以直接调用的。那么既然生成器可以被next()调用，那么生成器就是一个特殊的迭代器，是一个可迭代对象。

2.生成器的第二种创建方法：yield

除了用上面那种方法创建生成器，还可以用yield来创建，方法如下：

yield 关键字

比如说我们用一个函数中包含yield来创建生成器：

def fun():
    a = 10
    while 1:
        a += 1
        yield a


b = fun()print(b)

运行结果：

<generator></generator>

结果就是生成了一个生成器，而且此时的函数fun()就已经不再是一个函数了，它是一个生成器，只要函数中出现了yield，函数就变成了生成器。

为什么while循环没有一直执行？先不着急，我们输出看看：

def fun():
    a = 10
    while 1:
        a += 1
        yield a


b = fun()print(next(b))print(next(b))print(next(b))

运行结果：

111213

我调用了三次，所以它就运行了三次，while循环虽然存在，但是却不起作用，是因为前面我们提过的懒汉式加载。

什么时候需要了，什么时候用next()调用，就是懒汉式加载，不像饿汉式加载那样，提前生成了所有对象，如果这里换成for循环来完成，比如：

def fun():
    a = 10
    while 1:
        a += 1
        print(a)b = fun()

运行之后程序将会进入死循环，一直给a自加1，你可以试试看效果，这就是饿汉式加载提前生成了迭代器并调用了全部迭代器对象，饿汉式加载占用资源的放大镜。

七、小结

今天讲的内容可能听起来比较枯燥，这也是没得办法的，有些东西第一次听可能有点”难以下咽“，见得多了之后就习惯了，你得强迫自己去试着接受和理解这些抽象的东西。

最后用一张图来总结一下它们的关系：

推荐学习：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!