Detaillierte Python-Analyse von Containern, iterierbaren Objekten, Iteratoren und Generatoren

Dieser Artikel vermittelt Ihnen relevantes Wissen über Python, das hauptsächlich verwandte Themen zu Containern, iterierbaren Objekten, Iteratoren und Generatoren vorstellt. Ich hoffe, dass es für alle hilfreich ist.

Empfohlenes Lernen: Python-Video-Tutorial

Als Sie anfingen, Python zu lernen, haben Sie die großen Jungs oft über Container, iterierbare Objekte, Iteratoren, Generatoren, Listen/Sets/Wörterbuchableitung und viele andere Konzepte sprechen hören? Tatsächlich liegt das nicht daran, dass die Großen nur Fachbegriffe verwenden, um vorzugeben, B zu sein, aber diese Dinge müssen verstanden werden. Es reicht nicht aus, nur die Grundlagen von Zeichenfolgen, Listen usw. zu kennen, insbesondere in Bezug auf die Datenstrukturaspekte von Python.

Heute erzähle ich Ihnen von den schwer verständlichen Konzepten von Containern, iterierbaren Objekten, Iteratoren und Generatoren in Python, um Ihre Python-Grundlage auf die nächste Stufe zu heben!

1. Container

1. Was ist ein Container?

In Python ist ein Container eine Datenstruktur, die mehrere Elemente zusammen organisiert. Die Elemente im Container können iterativ einzeln abgerufen werden. Um es ganz klar auszudrücken: Seine Funktion ist genau wie sein Name: Es wird zum Speichern von Dingen (Daten) verwendet.

Container ist eigentlich kein Datentyp, es ist nur ein Konzeptwort, das erstellt wurde, um das Lernen zu erleichtern. Es kann mit dem Mitgliedschaftsoperator verwendet werden. Stellen Sie fest, ob sich das Objekt im Container befindet.

Natürlich wurde es nicht von mir geschaffen. Es wurde von der offiziellen Regierung geschaffen. Sie müssen sich keine Sorgen machen, dass ich Ihnen einige seltsame Begriffe beibringe, die niemand sonst verstehen wird ... Python So nennt es die Zentralhauptstadt. Zu den gängigen Containertypen gehören list (list), tuple (tuple), string (str), dictionary (dict) und set (set).

Da die Daten im Container iterativ abgerufen werden können, müssen wir ein neues Konzept lernen: iterierbare Objekte.

---

2. Iterierbare Objekte

1 Was ist ein iterierbares Objekt?

In Python bezieht sich ein iterierbares Objekt nicht auf einen bestimmten Datentyp, sondern auf ein Containerobjekt, das Elemente speichert.

Mit anderen Worten: Wenn im Container keine Daten gespeichert sind, handelt es sich nicht um iterierbare Objekte. Container umfassen, sind aber nicht auf iterierbare Objekte beschränkt.

Achten Sie auf zwei Punkte:

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

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

Jeder sollte mit der for-Schleife vertraut sein, oder? Haben Sie sich jemals gefragt, wie die for-Schleife implementiert wird? Warum kann beispielsweise in diesem for-Schleifenbeispiel jedes Element in der Liste ausgegeben werden? Wie wird es intern umgesetzt?

Tatsächlich bewirkt die for-Schleife zwei Dinge:

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

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

Dann brauchen wir keine for-Schleife, um jedes Element in der Liste auszugeben,

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步

Das Ausgabeergebnis:

Du Sie können sehen, dass, wenn wir die Codezeile entfernen, die ite ausgibt, der Ausführungseffekt derselbe ist wie bei jedem Element in der Ausgabeliste der for-Schleife. Die for-Schleife begrenzt den Bereich auf 4 Mal, führt __iter__() jedoch tatsächlich einmal und 4 aus times_ _next__(), das heißt, auf diese Weise wird das Wesentliche des for-Schleifenzugriffs auf das Iterationsobjekt erreicht.

Darüber hinaus sind die beiden Dinge, die die for-Schleife im Wesentlichen tut, unverzichtbar. Das heißt, wenn __iter__() nicht zuerst den Iterator zurückgibt, kann __next()__ das Element nicht abrufen, was genau veranschaulicht, was war Der zweite von zwei zu beachtenden Punkten: Ein iterierbares Objekt kann nicht unabhängig iteriert werden.

Es gibt zwei integrierte Funktionen, die das gleiche Prinzip und die gleiche Essenz haben. Im Allgemeinen ist es bequemer, integrierte Funktionen zu verwenden:

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

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

Es ist ersichtlich, dass die Ergebnisse genau gleich sind. Da wir gerade von Iteratoren sprechen, werfen wir einen Blick darauf, was ein Iterator ist.

3. Iterator

Wir können es wahrscheinlich anhand des obigen for-Schleifen-Beispiels erkennen:

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

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

In diesem Fall haben wir beim Erlernen der Grundlagen von Python erwähnt, dass range() ein iterierbares Objekt ist, also kann es auch sein übergeben __iter__() generiert einen Iterator.

---

4. Sequenz

Ich habe die Sequenz im speziellen Artikel [Zuweisungsanweisung] erwähnt. Sequenz ist auch ein abstraktes Konzept, das Listen, Tupel und Zeichenfolgen umfasst selbst nicht existiert, ist auch ein konzeptionelles Wort, das geschaffen wurde, um das Lernen zu erleichtern.

可迭代对象包含序列，既然序列包含了列表、元组和字符串，前面我们的例子中也涉及到 了，所以说序列可以被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]

Nach dem Login kopieren

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教程

Das obige ist der detaillierte Inhalt vonDetaillierte Python-Analyse von Containern, iterierbaren Objekten, Iteratoren und Generatoren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!