Analisis terperinci Python tentang bekas, objek boleh lelaran, iterator dan penjana

Artikel ini membawa anda pengetahuan yang berkaitan tentang python, yang terutamanya memperkenalkan isu berkaitan tentang bekas, objek boleh lelar, iterator dan penjana Mari kita lihat bersama-sama.

Pembelajaran yang disyorkan: tutorial video python

Apabila anda mula belajar Python, adakah anda sering mendengar orang besar Kami bercakap tentang bekas, objek boleh lelar, iterator, penjana, senarai/set/kefahaman kamus dan banyak lagi konsep lain, ini bukan kerana orang besar hanya menggunakan istilah profesional untuk berpura-pura menjadi B, tetapi perkara ini perlu Faham, cuma. mengetahui asas rentetan, senarai, dll. tidak mencukupi, terutamanya dari segi struktur data Python.

Hari ini saya akan memberitahu anda tentang konsep bekas yang sukar difahami, objek boleh lelar, iterator dan penjana dalam Python, untuk membawa asas Python anda ke peringkat seterusnya!

1. Bekas

1.

Dalam Python, bekas ialah struktur data yang menyusun berbilang elemen bersama-sama Unsur-unsur dalam bekas boleh diperoleh secara berulang satu demi satu . Secara terang-terangan, fungsinya sama seperti namanya: digunakan untuk menyimpan sesuatu (data).

Bekas sebenarnya tidak wujud Ia bukan jenis data, tetapi konsep buatan Ia hanyalah kata konsep yang dicipta untuk memudahkan pembelajaran tentukan sama ada objek itu berada di dalam bekas.

Sudah tentu, ia tidak dicipta oleh saya. Ia dicipta oleh kerajaan rasmi. Saya tidak perlu risau . Jika anda mengatakannya, orang lain akan mendengar saya tidak faham…begitulah ia dipanggil dalam ular sawa. Jenis bekas biasa termasuk senarai, tuple, rentetan (str), kamus (dikt) dan set (set) .

Memandangkan data dalam bekas boleh diperoleh secara berulang, kita perlu mempelajari konsep baharu: objek boleh lelar.

---

2. Objek boleh lelar

1.

Dalam python, objek boleh lelar tidak merujuk kepada jenis data tertentu, ia merujuk kepada objek bekas yang menyimpan elemen.

Dalam erti kata lain, jika tiada data yang disimpan dalam bekas, ia bukan objek yang boleh diulang.

Perhatikan dua perkara:

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

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

Anda sepatutnya sudah biasa dengan gelung for, bukan? Pernahkah anda terfikir bagaimana gelung for dilaksanakan? Sebagai contoh, dalam contoh gelung ini, mengapa ia boleh mengeluarkan setiap elemen dalam senarai? Bagaimanakah ia dilaksanakan secara dalaman?

Sebenarnya, gelung for melakukan dua perkara:

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

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

Kemudian kita tidak memerlukan gelung for untuk keluarkan setiap item dalam senarai Satu elemen,

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步

Hasil keluaran:

Ia boleh dilihat jika kita mengalih keluar baris kod yang dicetak ite, kesan pelaksanaan akan sama seperti gelung for Setiap elemen dalam senarai output adalah sama Gelung for mengehadkan julat kepada 4 kali Malah, __iter__() dilaksanakan sekali dan __next__() dilaksanakan 4 kali. Dengan kata lain, gelung for mengakses intipati objek lelaran Ini adalah bagaimana ia dicapai.

Selain itu, dua perkara yang dilakukan oleh gelung for adalah amat diperlukan, iaitu, jika __iter__() tidak mengembalikan lelaran terlebih dahulu, __next()__ tidak boleh mendapatkan elemen, betul-betul titik kedua daripada dua perkara yang dinyatakan sebelum ini: objek boleh lelar tidak boleh diulang secara bebas.

Terdapat dua fungsi terbina dalam yang mempunyai prinsip dan intipati yang sama Secara umumnya, lebih mudah untuk menggunakan fungsi terbina dalam Sekurang-kurangnya anda tidak perlu menulis banyak garis bawah:

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

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

Dapat dilihat bahawa keputusannya adalah betul-betul sama Memandangkan kita bercakap tentang iterator, mari kita lihat apa itu iterator.

3. Iterator

Kita mungkin dapat melihat ini melalui contoh gelung for di atas,

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

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

Dalam kes ini, kami membincangkannya semasa kami mempelajari asasnya of Python range() ialah objek lelaran, jadi ia juga boleh menjana lelaran melalui __iter__().

---

4. Urutan

Saya menyebut urutan itu dalam artikel khas [Kenyataan Tugasan], tetapi saya akan membincangkannya sekali lagi di sini, Jujukan juga merupakan konsep abstrak, yang merangkumi senarai, tuple dan rentetan Ia tidak wujud dengan sendirinya, dan ia juga merupakan kata konsep yang dicipta untuk memudahkan pembelajaran.

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

Salin selepas log masuk

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

Atas ialah kandungan terperinci Analisis terperinci Python tentang bekas, objek boleh lelaran, iterator dan penjana. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!