一、推導式

（一）.列表推導式（集合推導式也同理於此）

利用列表推導式，取出1-20內所有偶數

li = [i for i in range(1, 21) if i % 2 == 0] # 如果只有一個條件，要把if語句寫在最後面

第一個i是放入列表的值，後面都是推導的公式

print(li)

第一個 i 相當於下麵等價方案中的 append(i)。把 i 換成 "a" ，輸出的列表中全是 "a"

等價於

for i in range(1,21):
if i%2==0:
li.append(li)
print(li)

利用列表推導式，取出1-20內所有數。其中奇數用字元"a"代替，偶數則正常輸出

li = [i if i % 2 == 0 else "a" for i in range(1, 21)] # 添加多個條件的時候，要寫在前面
print(li)

列表推導式練習：將列表 li=['a','b','c','d','e'] 倒序

print([li.pop() for i in range(len(li))])

pop()函數，remove and return the last element

（二）.字典推導式

例1：
a = {str(i): i for i in range(5)}
print(a) # {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4}

例2：
a = {"i": i for i in range(5)}
print(a) # {'i': 4}

因為字典的鍵是唯一的，“例2”中的這個推導式，把鍵的名字給寫死了，每一次推導其實都是在修改原先的值。

例3：
print({i: 'a' for i in range(5)})

{0: 'a', 1: 'a', 2: 'a', 3: 'a', 4: 'a'}

“例3”是把值給寫死了。相當於dict.fromkeys([0,1,2,3,4],"a")

（三）.元祖的話，是返回一個生成器對象：
print((i for i in range(5)))

<generator object

需要用tuple()來查看：
print(tuple(i for i in range(5)))

(0, 1, 2, 3, 4)

二、迭代器

查看一個對象是否可迭代，使用dir(li)方法，結果中出現了 "iter" 就是可迭代。

使用dir(li)查看，要有 "iter" 和 "next" 才算是一個迭代器。

枚舉就是個迭代器

g = enumerate([1, 2, 3])
print(dir(g))

dir(g) 後，可以看到有 "iter" 和 "next"

（一）.__iter__() 和 next()：

(1).__iter__()把一個可迭代的對象變成迭代器。
li = [1, 2, 3]
g = li.__iter__() # 用這個方法變成迭代器
print(g.__next__()) # 實現迭代器（通俗理解：取值）

要賦值給一個變數。不然__next__()每次都是取第一個值

下麵這樣寫，取的永遠都是迭代器中的第一個值

print(li.__iter__().__next__())
print(li.__iter__().__next__())
print(li.__iter__().__next__())

這裡就理解：！迭代器對象，必須賦值給一個變數接受！

(2).__next__()，實現迭代器，本質就是取出迭代器的下一個元素。註意：元素取完了，如果再 next() 就會報 StopIteration 異常！
li = [1, 2, 3]
g = iter(li)
print(next(g)) # 這裡已經把第一個元素取出了
print("---")
for i in g: # 所以這裡只會取出後面的2個值
print(i)

三、生成器 generator

在python中，使用了關鍵字yield的函數被成為生成器。本質上是迭代器，關鍵字：yield

跟普通函數不同的是，生成器是一個返回迭代器的函數，只能用於迭代操作。

在調用生成器運行的過程中，每次遇到yield時，函數會暫停並保存當前所有的運行信息，返回yield的值。併在下一次執行next()方法時，從當前位置繼續運行。:

如下演示一個簡單的生成器：
def fun():
i = 1
while i < 5:
print(i)
# yield # 實現生成器的功能。1、暫停，2、返回值。
yield "stop" # 可以這樣寫，返回一個信息
i += 1
print("**", i)
print(fun()) # 這裡返回了一個記憶體地址
f = fun()
print(next(f))

使用yield演示斐波那契：
def fab(max_num):
n, a, b = 0, 0, 1
while n < max_num:
yield "暫停 列印b：", b
a, b = b, a + b
n += 1
for x in fab(20):
print(x)

四、模塊和包

（一）.模塊：本質上就是py文件。分為：內置模塊，第三方模塊。

(1).內置模塊的使用：

導入所有內容：import modulename；很直觀，但很占記憶體。

指定導入：from modulename import funcationname；明確知道自己要用什麼方法。

(2).自定義模塊的使用：

與當前py文件是同級路徑：直接導入。

不同路徑導入的參考：
import sys # 別忘了先導入這個
sys.path # 路徑先調出來。返回一個列表，是python的安裝目錄
sys.path.append(r"") # 小括弧內可添加自己py文件的絕對路徑，記得取消轉義

再 import modulename 就可以了

(3).得在自己寫的py文件的最後一行加入：
if name == 'main':
functionname1()
functionname2()

有這段代碼。測試是本身就有，還是導入進來的。

一定要對這個py文件本身執行，運行了，才會有結果。

（二）.包：很多py文件放在一個文件夾中。

（三）.if name == 'main':

就是個if判斷，'main'就是個字元串，判斷是導入的還是直接執行的。

當import一個py模塊（文件）的時候，會把那個py模塊（文件）執行一遍。

例1：

我有一個"test1.py"的模塊（文件），如下代碼：
import test2

print(name) # main
print(test2.__name__) # test2

"""
運行結果：

fengzi111
main
test2
"""

有另一個"test2.py"的文件，如下代碼：
print("fengzi111")

if name == 'main':
print("fengzi222")

"test1.py"中，import了"test2"，那麼"test2.py"就被執行了一遍。所以在"test1.py"的運行結果中，會出現fengzi111，因為 import test2 的時候，"test2.py"被執行了一遍。

為什麼列印不出fengzi222？

"test2.py"是被引入進"test1.py"中的。"test2.py"中就有了if判斷，判斷的結果：它們兩個不是同一個name。

看"test1.py"文件中的這條代碼 print(test2.__name__)，這條代碼特意顯示了一下"test2.py"是什麼名字。返回的結果是 test2，但現在執行的是"test1.py"這個文件呀！"test1"=="test2"嗎？顯然是False，那就不會有fengzi222了。