一、while 循環(huán)

while語句最基本的形式包括一個(gè)位于頂部的布爾表達(dá)式，一個(gè)或多個(gè)屬于while代碼塊的縮進(jìn)語句。

while 布爾表達(dá)式:
    代碼塊

while循環(huán)的代碼塊會(huì)一直循環(huán)執(zhí)行，直到布爾表達(dá)式的值為布爾假(0)。

如果布爾表達(dá)式不帶有 <、 >、 ==、 !=、 in、 not in 等運(yùn)算符，僅僅給出數(shù)值之類的條件，也是可以的。
當(dāng)while后寫入一個(gè)非零整數(shù)時(shí)，視為真值，執(zhí)行循環(huán)體；寫入0時(shí)，視為假值,不執(zhí)行循環(huán)體。
也可以寫入str、 list或任何序列，長度非零視為真，執(zhí)行循環(huán)體；否則視為假，不執(zhí)行循環(huán)體。

【例子】

count = 0
while count < 3:
    temp = input("請輸入一個(gè)數(shù)字：")
    guess = int(temp)
    if guess > 8:
        print("你輸入的數(shù)字 大于 正確的數(shù)字！")
    else:
        if guess == 8:
            print("恭喜，你猜對了！")
            print("但是，沒有獎(jiǎng)勵(lì)！")
            count = 3
        else:
            print("你輸入的數(shù)字 小于 正確的數(shù)字！")
    count = count + 1
    #count += 1
print("游戲結(jié)束！")

[root@10 python]# py guess_while.py 
請輸入一個(gè)數(shù)字：2
你輸入的數(shù)字 小于 正確的數(shù)字！
請輸入一個(gè)數(shù)字：4
你輸入的數(shù)字 小于 正確的數(shù)字！
請輸入一個(gè)數(shù)字：8
恭喜，你猜對了！
但是，沒有獎(jiǎng)勵(lì)！
游戲結(jié)束！
[root@10 python]# py guess_while.py 
請輸入一個(gè)數(shù)字：3
你輸入的數(shù)字 小于 正確的數(shù)字！
請輸入一個(gè)數(shù)字：9
你輸入的數(shù)字 大于 正確的數(shù)字！
請輸入一個(gè)數(shù)字：6
你輸入的數(shù)字 小于 正確的數(shù)字！
游戲結(jié)束！
[root@10 python]# py guess_while.py 
請輸入一個(gè)數(shù)字：8
恭喜，你猜對了！
但是，沒有獎(jiǎng)勵(lì)！
游戲結(jié)束！
[root@10 python]# 

【例子】 布爾表達(dá)式返回0，循環(huán)終止。

string = "abcd"
while string:
    print(string)
    string = string[1:]

string[1:] 字符串切片表示從索引為1的位置開始，取到字符串的末尾（包括末尾字符）。換句話說，它返回的是字符串中從第2個(gè)字符到最后一個(gè)字符的子字符串。
python-切片操作指南

[root@10 python]# 
[root@10 python]# py while_str.py 
abcd
bcd
cd
d
[root@10 python]#

二、while - else 循環(huán)

while 布爾表達(dá)式:
    代碼塊
else:
    代碼塊

當(dāng)while循環(huán)正常執(zhí)行完的情況下，執(zhí)行else輸出，如果while循環(huán)中執(zhí)行了跳出循環(huán)的語句，比如break，將不執(zhí)行else代碼塊的內(nèi)容。

【例子】

count = 0
while count < 5:
    print("%d is less than 5" % count)  # 將變量count的值替換為占位符%d(格式化整數(shù)的占位符)所在的位置。
    count = count + 1
else:
    print("%d is not less than 5" % count)

[root@10 python]# py while_else.py 
0 is less than 5
1 is less than 5
2 is less than 5
3 is less than 5
4 is less than 5
5 is not less than 5
[root@10 python]# 

【例子】

count = 0
while count < 5:
    print("%d is lose than 5" % count)
    break   # 當(dāng) break 執(zhí)行時(shí)，程序會(huì)立即退出當(dāng)前所在的循環(huán)。
else:
    print("%d is not less than 5" % count)

# 輸出： 0 is lose than 5 
# 而非： 0 is not less than 5

for 循環(huán)

for循環(huán)是迭代循環(huán)，在Python中相當(dāng)于一個(gè)通用的序列迭代器，可以遍歷任何有序序列，如str、 list、 tuple等，也可以遍歷任何可迭代對象，如dict。

for 迭代變量 in 可迭代對象：
    代碼塊

每次循環(huán)，迭代變量被設(shè)置為可迭代對象的當(dāng)前元素，提供給代碼塊使用。

【例子】

for L in 'HelloWorld':
    print(L, end=' ')   # end=' '，不換行輸出。

# 輸出："H e l l o W o r l d "

【例子】

member = ['張三', '李四', '王二', '麻子']
for each in member:
    print(each)

# 張三
# 李四
# 王二
# 麻子


for L in range(len(member)-1, -1, -1):  # 范圍是 3 到 0。
    print(member[L])

# 麻子
# 王二
# 李四
# 張三

【例子】
.items() 是一個(gè)字典數(shù)據(jù)類型（dict）的方法，它返回一個(gè)包含字典鍵值對的視圖對象。每個(gè)鍵值對都表示為一個(gè)元組，其中第一個(gè)元素是鍵，第二個(gè)元素是對應(yīng)的值。

這是一個(gè)示例代碼：

my_dict = {'a': 1, 'b': 2, 'c': 3}

for key,value in dic.items():
    print(key, value, sep=":", end=' ')

輸出：

a:1 b:2 c:3

上述代碼中，my_dict.items() 用于遍歷字典 my_dict 中的所有鍵值對。然后通過 print(key, value, sep=":", end=' ') 打印每個(gè)鍵值對，使用 : 分隔鍵和值，并使用空格作為分隔符，同時(shí)在同一行上連續(xù)打印。這樣，你會(huì)得到輸出結(jié)果：a:1 b:2 c:3。

【例子】
.keys() 是一個(gè)字典數(shù)據(jù)類型（dict）的方法，它返回一個(gè)包含字典所有鍵的視圖對象。

這是一個(gè)示例代碼：

my_dict = {'a': 1, 'b': 2, 'c': 3}

for key in my_dict.keys():
    print(key, end=' ')

輸出：

a b c 

如果你運(yùn)行以下代碼:

上述代碼中，my_dict.keys() 用于遍歷字典 my_dict 中的所有鍵。然后使用 print(key, end=' ') 打印每個(gè)鍵，并通過 end=' ' 將每個(gè)鍵之間的默認(rèn)空格改為一個(gè)空格，在同一行上連續(xù)打印。這樣，你會(huì)得到輸出結(jié)果：a b c。

【例子】
.values() 是一個(gè)字典數(shù)據(jù)類型（dict）的方法，它返回一個(gè)包含字典所有值的視圖對象。

這是一個(gè)示例代碼：

my_dict = {'a': 1, 'b': 2, 'c': 3}

for value in my_dict.values():
    print(value, end=' ')

輸出：

1 2 3 

上述代碼中，my_dict.values() 用于遍歷字典 my_dict 中的所有值。然后使用 print(value, end=' ') 打印每個(gè)值，并通過 end=' ' 將每個(gè)值之間的默認(rèn)空格改為一個(gè)空格，在同一行上連續(xù)打印。這樣，你會(huì)得到輸出結(jié)果：1 2 3。

四、for - else 循環(huán)

for 迭代變量 in 可迭代對象:
    代碼塊
else:
    代碼塊

當(dāng)for循環(huán)正常執(zhí)行完的情況下，執(zhí)行else輸出，如果for循環(huán)中執(zhí)行了跳出循環(huán)的語句，比如break，將不執(zhí)行else代碼塊的內(nèi)容，與while - else語句一樣。

【例子】

for num in range(10, 20):   # 迭代 10 到 20(不包括20) 之間的數(shù)字。
    for L in range(2, num): # 根據(jù)因子迭代。
        if num % L == 0:    # 確定第一個(gè)因子
            LL = num / L    # 計(jì)算第二個(gè)因子
            print('%d 等于 %d * %d' % (num, L, LL))
            break   # 跳出當(dāng)前循環(huán)
    else:   # 循環(huán)的 else 部分
        print(num, '是一個(gè)質(zhì)數(shù)')

這段代碼是用來判斷 10 到 20 之間的數(shù)字是質(zhì)數(shù)還是合數(shù)。質(zhì)數(shù)是只能被1和自身整除的大于1的整數(shù)，而合數(shù)是可以被大于1小于自身的整數(shù)整除的整數(shù)。

在這段代碼中，外層的 for 循環(huán)用于迭代 10 到 20（不包括20）之間的數(shù)字。內(nèi)層的 for 循環(huán)用于根據(jù)因子進(jìn)行迭代。

在內(nèi)層循環(huán)中，使用條件判斷 if num % L == 0 來確定是否存在因子。如果存在因子，則打印出由兩個(gè)因子組成的等式，并通過 break 關(guān)鍵字跳出當(dāng)前循環(huán)。

如果內(nèi)層循環(huán)沒有通過 break 跳出，即沒有找到任何因子，則執(zhí)行循環(huán)的 else 部分，打印出該數(shù)字是一個(gè)質(zhì)數(shù)。

所以，對于給定的代碼，它將打印出以下結(jié)果：

10 等于 2 * 5
11 是一個(gè)質(zhì)數(shù)
12 等于 2 * 6
13 是一個(gè)質(zhì)數(shù)
14 等于 2 * 7
15 等于 3 * 5
16 等于 2 * 8
17 是一個(gè)質(zhì)數(shù)
18 等于 2 * 9
19 是一個(gè)質(zhì)數(shù)

五、range() 函數(shù)

range([start,] stop9[, step=1])

• 這個(gè) BIF (Built-in function) 有三個(gè)參數(shù)，其中用中括號(hào)括起來的兩個(gè)表示這兩個(gè)參數(shù)是可選的。
• step=1 表示第三個(gè)參數(shù)的默認(rèn)值是1。
• range 這個(gè)BIF的作用是生成一個(gè)從start參數(shù)的值開始到stop參數(shù)的值結(jié)束的數(shù)字序列，該序列包含start的值但不包含stop的值。

【例子】
如果你運(yùn)行以下代碼:

for L in range(2, 6):
    print(L)

輸出將會(huì)是：

2 
3 
4 
5

上述代碼中，range(2, 6) 表示迭代從2開始到6（不包括6）之間的數(shù)字。然后使用 print(L) 打印每個(gè)迭代的數(shù)字。這樣，你會(huì)得到輸出結(jié)果：2 3 4 5。注意，輸出的每個(gè)數(shù)字都在單獨(dú)的一行上。

【例子】
如果你運(yùn)行以下代碼：

for L in range(1, 6, 2):
    print(L)

輸出將會(huì)是：

1
3
5

上述代碼中，range(1, 6, 2) 表示從1開始，以步長為2進(jìn)行迭代，直到小于6。也就是說，迭代的數(shù)字序列為 [1, 3, 5]。然后使用 print(L) 打印每個(gè)迭代的數(shù)字。這樣，你會(huì)得到輸出結(jié)果：1 3 5。注意，輸出的每個(gè)數(shù)字都在單獨(dú)的一行上。

六、enumerate()函數(shù)

enumerate(sequence, [start=0])

• sequence: 一個(gè)序列，迭代器或其他支持迭代對象。
• start: 下標(biāo)起始位置。
• 返回 enumerate(枚舉) 對象。

【例子】

my_list = ['a', 'b', 'c', 'd']
lst = list(enumerate(my_list))
print(lst)

lst = list(enumerate(my_list, start=1))
print(lst)

在第一段代碼中，使用 enumerate(my_list) 來遍歷 my_list 列表，并為每個(gè)元素添加一個(gè)索引值。結(jié)果被轉(zhuǎn)化為列表并賦值給變量 lst。然后，通過 print(lst) 打印輸出結(jié)果。
輸出結(jié)果為：

[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]

在第二段代碼中，使用 enumerate(my_list, start=1) 來遍歷 my_list 列表，并從索引值為 1 開始。結(jié)果同樣被轉(zhuǎn)化為列表并賦值給變量 lst。然后，通過 print(lst) 打印輸出結(jié)果。
輸出結(jié)果為：

[(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]

可以看到，第二段代碼中的索引值從 1 開始，而不是默認(rèn)的 0。這是通過 start=1 參數(shù)實(shí)現(xiàn)的。

enumerate() 與 for 循環(huán)的結(jié)合使用。

for L, LL in enumerate(A):
    do something with a

用enumerate不僅返回了A中的元素，還給該元素一個(gè)索引值(默認(rèn)從0開始)。此外，用enumerate(A, N)還可以確定索引起始值為N。

【例子】

languages = ['Python', 'R', 'C++']
for language in languages:
    print('%s 語言' % language)

print('結(jié)束！')


for L, language in enumerate(languages, 1):
    print('%d %s 語言' % (L, language))

print('結(jié)束！')

在第一個(gè)循環(huán)中，使用 for language in languages: 遍歷 languages 列表，并將當(dāng)前元素賦值給變量 language。然后使用字符串格式化 %s 將每個(gè)語言名稱插入到字符串中，并打印輸出。最后打印輸出 '結(jié)束！'。這樣會(huì)依次輸出以下內(nèi)容：

Python 語言
R 語言
C++ 語言
結(jié)束！

在第二個(gè)循環(huán)中，使用 enumerate(languages, 1) 在遍歷 languages 列表的同時(shí)獲取索引值。 1 參數(shù)表示索引從 1 開始。對于每個(gè)元素，將索引值賦值給變量 L，將當(dāng)前元素賦值給變量 language。然后使用字符串格式化 %d 和 %s 將索引和語言名稱插入到字符串中，并打印輸出。最后打印輸出 '結(jié)束！'。這樣會(huì)依次輸出以下內(nèi)容：

1 Python 語言
2 R 語言
3 C++ 語言
結(jié)束！

因此，代碼的最終輸出結(jié)果為：

Python 語言
R 語言
C++ 語言
結(jié)束！
1 Python 語言
2 R 語言
3 C++ 語言
結(jié)束！

七、break 語句

break語句可以跳出當(dāng)前所在層的循環(huán)。

【例子】

import random
secret = random.randint(1, 10)  # 1~10之間的隨機(jī)數(shù)

count = 0
while True:
    count = count + 1
    temp = input("請輸入一個(gè)數(shù)字(1~10)：")
    guess = int(temp)
    if guess > secret:
        print("你輸入的數(shù)字 大于 正確的數(shù)字！")
    else:
        if guess == secret:
            print("恭喜，你猜對了！")
            print("但是，沒有獎(jiǎng)勵(lì),總共嘗試了 %d 次！" % count)
            break
        else:
            print("你輸入的數(shù)字 小于 正確的數(shù)字！")
print("游戲結(jié)束！")

這段代碼是一個(gè)猜數(shù)字游戲的簡單實(shí)現(xiàn)。

首先，使用 random.randint(1, 10) 函數(shù)生成一個(gè) 1 到 10 之間的隨機(jī)數(shù)，并將其賦值給變量 secret。

然后，設(shè)置變量 count 的初始值為 0，用于計(jì)算猜測的次數(shù)。

接下來，進(jìn)入一個(gè)無限循環(huán) while True:。在每次循環(huán)中，首先將 count 加 1。然后使用 input 函數(shù)接收用戶輸入的一個(gè)數(shù)字，并將其轉(zhuǎn)換為整數(shù)類型。

代碼會(huì)通過多個(gè)判斷語句對用戶猜測的數(shù)字進(jìn)行評(píng)估和反饋：

1. 若猜測數(shù)字大于 secret，則輸出提示信息：你輸入的數(shù)字 大于 正確的數(shù)字！
2. 若猜測數(shù)字小于 secret，則輸出提示信息：你輸入的數(shù)字 小于 正確的數(shù)字！
3. 若猜測數(shù)字等于 secret，則輸出恭喜信息，提示用戶猜對了，并輸出猜測的次數(shù)信息：恭喜，你猜對了！但是，沒有獎(jiǎng)勵(lì)，總共嘗試了 X 次！（其中 X 是 count 的值）

最后，使用 break 關(guān)鍵字跳出循環(huán)，并輸出游戲結(jié)束的信息：游戲結(jié)束！

總結(jié)起來，這段代碼會(huì)不斷接收用戶輸入的數(shù)字，直到猜對為止，并在每次猜測后給出相應(yīng)的提示信息。最終會(huì)統(tǒng)計(jì)猜測的次數(shù)并輸出，然后結(jié)束游戲。

[root@10 python]# py guess_plus.py 
請輸入一個(gè)數(shù)字(1~10)：5
恭喜，你猜對了！
但是，沒有獎(jiǎng)勵(lì),總共嘗試了 1 次！
游戲結(jié)束！
[root@10 python]# py guess_plus.py 
請輸入一個(gè)數(shù)字(1~10)：5
你輸入的數(shù)字 大于 正確的數(shù)字！
請輸入一個(gè)數(shù)字(1~10)：3
你輸入的數(shù)字 小于 正確的數(shù)字！
請輸入一個(gè)數(shù)字(1~10)：4
恭喜，你猜對了！
但是，沒有獎(jiǎng)勵(lì),總共嘗試了 3 次！
游戲結(jié)束！
[root@10 python]# 

八、continue 語句

continue終止本輪循環(huán)并開始下一輪循環(huán)。

【例子】

for L in range(10):
    if L % 2 != 0:
        print(L)
        continue
    L += 100
    print(L)

在 for 循環(huán)中，range(10) 會(huì)生成一個(gè)從 0 到 9 的整數(shù)序列。對于每個(gè)迭代的元素 L，按照以下步驟執(zhí)行：

1. 對于 L 的值在 range(10) 中的每個(gè)迭代，首先會(huì)檢查 L 是否為奇數(shù)（L % 2 != 0）。

   • 如果 L 是奇數(shù)，則輸出當(dāng)前的奇數(shù) L。
   • 然后使用 continue 關(guān)鍵字跳過后續(xù)操作，直接進(jìn)入下一次循環(huán)。

2. 如果 L 不是奇數(shù)（即偶數(shù)），則執(zhí)行下面的代碼塊。

   • 將 L 的值增加 100：L += 100。
   • 輸出 L。

因此，循環(huán)的輸出結(jié)果是：

100
1
102
3
104
5
106
7
108
9

首次循環(huán)時(shí)，L 的初始值為0，不滿足 (L % 2 != 0) 的條件，所以 L 增加100后輸出100。

第二次循環(huán)，L 的初始值為1，滿足 (L % 2 != 0) 的條件，輸出1，然后使用 contLnue 跳過后續(xù)操作。

在每次迭代中，奇數(shù)直接輸出，而偶數(shù)則增加 100 后輸出。

九、pass 語句

pass語句的意思是“不做任何事”，如果你在需要有語句的地方不寫任何語句，那么解釋器會(huì)提示出錯(cuò)，而pass語句就是用來解決這些問題的。

【例子】

def a_func():

# IndentationError: expected an indented block

【例子】

def a_func():
    pass

pass是空語句，不做任何操作，只起到占位的作用，其作用是為了保持程序結(jié)構(gòu)的完整性。盡管pass語句不做任何操作，但如果暫時(shí)不確定要在一個(gè)位置放上什么樣的代碼，可以先放置一個(gè)pass語句，讓代碼可以正常運(yùn)行。

十、推導(dǎo)式

1. 列表推導(dǎo)式

[expr for value in collection [if condition] ]

【例子】

x = [-4, -2, 0, 2, 4]
y = [a * 2 for a in x]
print(y)

這段代碼創(chuàng)建了兩個(gè)列表 x 和 y，并使用列表推導(dǎo)式生成了 y 的值。

1. 在列表 x 中，包含了 -4, -2, 0, 2, 4 這五個(gè)元素。

2. 列表推導(dǎo)式 [a * 2 for a in x] 表示對于 x 中的每個(gè)元素 a，將其乘以 2，并將結(jié)果放入新的列表 y 中。

3. 所以，根據(jù)列表推導(dǎo)式的邏輯，y 的值將是 [-8, -4, 0, 4, 8]。

最后，代碼通過 print(y) 輸出了列表 y：

[-8, -4, 0, 4, 8]

因此，程序的輸出結(jié)果就是 [-8, -4, 0, 4, 8]。每個(gè)元素都是在原始列表 x 中的對應(yīng)元素乘以 2 后得到的值。

【例子】

x = [i ** 2 for i in range(1, 10)]
print(x)

這段代碼創(chuàng)建了一個(gè)列表 x，并使用列表推導(dǎo)式生成了 x 的值。

1. 列表推導(dǎo)式 [i ** 2 for i in range(1, 10)] 表示對于 range(1, 10) 中的每個(gè)元素 i，將其平方，并將結(jié)果放入新的列表 x 中。

2. 使用 range(1, 10) 生成一個(gè)從 1 到 9（包括 1 不包括 10）的整數(shù)序列。

3. 對于每個(gè)迭代的元素 i，計(jì)算它的平方 i ** 2，并將結(jié)果添加到列表 x 中。

所以，根據(jù)列表推導(dǎo)式的邏輯，x 的值將是 [1, 4, 9, 16, 25, 36, 49, 64, 81]。

最后，代碼通過 print(x) 輸出了列表 x：

[1, 4, 9, 16, 25, 36, 49, 64, 81]

因此，程序的輸出結(jié)果就是 [1, 4, 9, 16, 25, 36, 49, 64, 81]，即從 1 到 9 的平方數(shù)列表。

【例子】

x = [(i, i ** 2) for i in range(6)]
print(x)

這段代碼創(chuàng)建了一個(gè)列表 x，并使用列表推導(dǎo)式生成了 x 的值。

1. 列表推導(dǎo)式 [(i, i ** 2) for i in range(6)] 表示對于 range(6) 中的每個(gè)元素 i，創(chuàng)建一個(gè)元組 (i, i ** 2)，并將這些元組放入新的列表 x 中。

2. 使用 range(6) 生成一個(gè)從 0 到 5 的整數(shù)序列。

3. 對于每個(gè)迭代的元素 i，計(jì)算 i 的平方 i ** 2，然后創(chuàng)建一個(gè)包含兩個(gè)元素的元組 (i, i ** 2)。

所以，根據(jù)列表推導(dǎo)式的邏輯，x 的值將是 [(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]。

最后，代碼通過 print(x) 輸出了列表 x：

[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]

因此，程序的輸出結(jié)果就是 [(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]，即從 0 到 5 的每個(gè)數(shù)字及其平方組成的元組列表。

【例子】

x = [i for i in range(100) if (i % 2) != 0 and (i % 3) == 0]
print(x)

這段代碼創(chuàng)建了一個(gè)列表 x，并使用列表推導(dǎo)式生成了 x 的值。

1. 列表推導(dǎo)式 [i for i in range(100) if (i % 2) != 0 and (i % 3) == 0] 表示對于 range(100) 中的每個(gè)元素 i，如果 i 是奇數(shù)且是 3 的倍數(shù)，則將其添加到新的列表 x 中。

2. 使用 range(100) 生成一個(gè)從 0 到 99 的整數(shù)序列。

3. 對于每個(gè)迭代的元素 i，通過條件 (i % 2) != 0 and (i % 3) == 0 進(jìn)行篩選。這個(gè)條件要求 i 是奇數(shù)且是 3 的倍數(shù)。

所以，根據(jù)列表推導(dǎo)式的邏輯，x 的值將是滿足條件的從 0 到 99 的整數(shù)中，既是奇數(shù)又是 3 的倍數(shù)的數(shù)。

最后，代碼通過 print(x) 輸出了列表 x：

[3, 9, 15, 21, 27, 33, 39, 45, 51, 57, 63, 69, 75, 81, 87, 93, 99]

因此，程序的輸出結(jié)果就是包含滿足條件的從 0 到 99 的整數(shù)中既是奇數(shù)又是 3 的倍數(shù)的數(shù)的列表。

【例子】

a = [(i, j) for i in range(0,3) for j in range(0,3)]
print(a)

這段代碼創(chuàng)建了一個(gè)列表 a，并使用嵌套的列表推導(dǎo)式生成了 a 的值。

1. 嵌套的列表推導(dǎo)式 [ (i, j) for i in range(0, 3) for j in range(0, 3)] 表示對于 range(0, 3) 中的每個(gè)元素 i，以及對于 range(0, 3) 中的每個(gè)元素 j，都生成一個(gè)包含兩個(gè)元素 (i, j) 的元組，并將這些元組添加到新的列表 a 中。

2. 使用 range(0, 3) 生成一個(gè)從 0 到 2 的整數(shù)序列。

3. 第一個(gè) for 循環(huán)迭代 range(0, 3) 中的元素 i。

4. 第二個(gè)嵌套的 for 循環(huán)迭代 range(0, 3) 中的元素 j。

5. 對于每個(gè)迭代的元素 i 和 j，創(chuàng)建一個(gè)包含兩個(gè)元素 (i, j) 的元組，并將其添加到列表 a 中。

所以，根據(jù)嵌套的列表推導(dǎo)式的邏輯，a 的值將是所有可能的以從 0 到 2 的整數(shù)組成的元組 (i, j) 的列表。

最后，代碼通過 print(a) 輸出了列表 a：

[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

因此，程序的輸出結(jié)果就是包含所有可能的以從 0 到 2 的整數(shù)組成的元組 (i, j) 的列表。

【例子】

x = [[i, j] for i in range(0, 3) for j in range(0, 3)]
print(x)


x[0][0] = 10
print(x)

x[0][1] = 10
print(x)
# [[10, 10], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [2, 0], [2, 1], [2, 2]]

這段代碼創(chuàng)建了一個(gè)二維列表 x，并使用嵌套的列表推導(dǎo)式生成了 x 的值。

1. 嵌套的列表推導(dǎo)式 [[i, j] for i in range(0, 3) for j in range(0, 3)] 表示對于 range(0, 3) 中的每個(gè)元素 i，以及對于 range(0, 3) 中的每個(gè)元素 j，都生成一個(gè)包含兩個(gè)元素 [i, j] 的列表，并將這些列表添加到新的二維列表 x 中。

2. 使用 range(0, 3) 生成一個(gè)從 0 到 2 的整數(shù)序列。

3. 第一個(gè) for 循環(huán)迭代 range(0, 3) 中的元素 i。

4. 第二個(gè)嵌套的 for 循環(huán)迭代 range(0, 3) 中的元素 j。

5. 對于每個(gè)迭代的元素 i 和 j，創(chuàng)建一個(gè)包含兩個(gè)元素 [i, j] 的列表，并將其添加到二維列表 x 中。

所以，根據(jù)嵌套的列表推導(dǎo)式的邏輯，x 的值將是一個(gè) 3x3 的二維列表，其中包含從 0 到 2 的整數(shù)組成的列表。

最后，代碼通過 print(x) 輸出了二維列表 x：

[[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [2, 0], [2, 1], [2, 2]]

接下來，代碼將 x[0][0] 的值修改為 10，即修改二維列表 x 中第一行第一個(gè)元素的值。

最后，通過 print(x) 輸出了修改后的二維列表 x：

[[10, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [2, 0], [2, 1], [2, 2]]

因此，程序的輸出結(jié)果是首先輸出原始的二維列表 x，然后修改第一行第一個(gè)元素的值為 10，再輸出修改后的二維列表 x。

【例子】

a = [(i, j) for i in range(0, 3) if i < 1 for j in range(0, 3) if j > 1]
print(a)

這段代碼使用了列表推導(dǎo)式來創(chuàng)建一個(gè)名為 a 的列表。

列表推導(dǎo)式的邏輯如下：

1. 使用 range(0, 3) 生成一個(gè)從 0 到 2 的整數(shù)序列。

2. 第一個(gè) for 循環(huán)迭代 range(0, 3) 中的元素 i。

3. 在第一個(gè) for 循環(huán)中添加一個(gè) if 條件，即 if i < 1。這個(gè)條件會(huì)過濾出滿足條件的 i 值，只有當(dāng) i < 1 時(shí)才會(huì)繼續(xù)執(zhí)行后面的循環(huán)。

4. 第二個(gè)嵌套的 for 循環(huán)迭代 range(0, 3) 中的元素 j。

5. 在第二個(gè)嵌套的 for 循環(huán)中添加一個(gè) if 條件，即 if j > 1。這個(gè)條件會(huì)過濾出滿足條件的 j 值，只有當(dāng) j > 1 時(shí)才會(huì)將 (i, j) 添加到列表 a 中。

因此，根據(jù)列表推導(dǎo)式的邏輯，a 的值將是一個(gè)由滿足條件 (i < 1) 且 (j > 1) 的 (i, j) 元組組成的列表。

最后，通過 print(a) 輸出了列表 a：

[(0, 2)]

因?yàn)?i 的取值范圍是從 0 到 2，但我們只保留了滿足 i < 1 的值，所以只有 (0, 2) 符合條件被添加到了列表 a 中。

因此，程序的輸出結(jié)果是只包含一個(gè)元素 (0, 2) 的列表 a。

2. 元組推導(dǎo)式

( expr for value in collection [if condition])

【例子】

a = (x for x in range(10))
print(a)
# <generator object <genexpr> at 0x7f0885776e40>


print(tuple(a))
# (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

這段代碼展示了生成器表達(dá)式的使用以及將生成器轉(zhuǎn)換為元組的操作。

首先，代碼定義了一個(gè)生成器表達(dá)式 a，它使用 range(10) 來生成從 0 到 9 的整數(shù)序列，并將每個(gè)元素賦值給變量 x。生成器表達(dá)式使用圓括號(hào)來表示。

接著，通過 print(a) 輸出 a，得到的結(jié)果是 <generator object <genexpr> at 0x7f0885776e40>。這是因?yàn)樯善鲗ο蟊旧聿]有存儲(chǔ)所有元素的值，而是在需要時(shí)逐個(gè)生成，所以無法直接打印出所有的元素。

然后，通過 tuple(a) 將生成器 a 轉(zhuǎn)換為元組，并使用 print(tuple(a)) 輸出結(jié)果。得到的元組是 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)，其中包含了 range(10) 生成的所有整數(shù)。這是因?yàn)檗D(zhuǎn)換為元組后，生成器會(huì)被逐個(gè)迭代生成，并存儲(chǔ)在元組中。

因此，最終代碼輸出的結(jié)果是先打印生成器對象的描述信息，再將生成器轉(zhuǎn)換為元組并打印出元組的內(nèi)容。

注意：生成器在被迭代完畢后無法再次使用，如果需要重新迭代，則需要重新生成生成器對象 a。

3. 字典推導(dǎo)式

{ key_expr: value_expr for value in collection [if condition] }

【例子】

b = {i: i % 2 == 0 for i in range(10) if i % 3 == 0}
print(b)
# {0: True, 3: False, 6: True, 9: False}

這段代碼使用字典推導(dǎo)式創(chuàng)建了一個(gè)字典 b，其中鍵為整數(shù)序列 range(10) 中滿足條件 i % 3 == 0 的值，而對應(yīng)的值為判斷該整數(shù)是否為偶數(shù)的布爾結(jié)果。

具體來說，代碼首先使用 range(10) 生成從 0 到 9 的整數(shù)序列，并通過條件 i % 3 == 0 過濾出可被 3 整除的整數(shù)作為字典的鍵。

然后，在字典推導(dǎo)式的表達(dá)式部分，使用 i % 2 == 0 判斷每個(gè)整數(shù)是否為偶數(shù)，將判斷結(jié)果作為對應(yīng)鍵的值。判斷結(jié)果是布爾類型，如果整數(shù)是偶數(shù)，則為 True，否則為 False。

最后，通過 print(b) 打印字典 b 的內(nèi)容。輸出的結(jié)果為 {0: True, 3: False, 6: True, 9: False}。這是因?yàn)樵谡麛?shù)序列中，只有 0、3、6 和 9 能被 3 整除，而且對應(yīng)的判斷結(jié)果分別為 True、False、True 和 False。

因此，最終的輸出結(jié)果是一個(gè)字典，其中鍵為滿足條件的整數(shù)，值為判斷該整數(shù)是否為偶數(shù)的結(jié)果。

4. 集合推導(dǎo)式

{ expr for value in collection [if condition] }

【例子】

c = {i for i in [1, 2, 3, 4, 5, 5, 6, 4, 3, 2, 1]}
print(c)
# {1, 2, 3, 4, 5, 6}

這段代碼使用集合推導(dǎo)式創(chuàng)建了一個(gè)集合 c，其中包含了列表 [1, 2, 3, 4, 5, 5, 6, 4, 3, 2, 1] 中的唯一元素。

具體來說，代碼通過列表 [1, 2, 3, 4, 5, 5, 6, 4, 3, 2, 1] 創(chuàng)建了一個(gè)列表對象，并使用集合推導(dǎo)式將列表中的元素提取出來并去除重復(fù)值，形成了一個(gè)包含唯一元素的集合。

最后，通過 print(c) 打印集合 c 的內(nèi)容。輸出的結(jié)果為 {1, 2, 3, 4, 5, 6}，這是因?yàn)樵谠剂斜碇?，存在重?fù)的元素，通過集合推導(dǎo)式可以確保集合中只包含唯一的元素，并按照其在原始列表中的順序進(jìn)行排列。

因此，最終的輸出結(jié)果是一個(gè)集合，其中包含了列表中的唯一元素。

5. 其他

next(iterator[, default]) 方法從迭代器中返回下一個(gè)元素。如果迭代器已經(jīng)遍歷完畢，且提供了 default 參數(shù)，則返回 default，而不是引發(fā) StopIteration 異常。

【例子】

e = (i for i in range(10))
print(e)
# <generator object <genexpr> at 0x7f0885776e40>

print(next(e))  # 0
print(next(e))  # 1

for each in e:
    print(each, end=' ')

# 2 3 4 5 6 7 8 9 

這段代碼創(chuàng)建了一個(gè)生成器對象 e，它使用生成器表達(dá)式 (i for i in range(10)) 來生成從 0 到 9 的整數(shù)序列。

代碼中的 print(e) 打印了生成器對象 e 的表示形式，輸出結(jié)果為 <generator object <genexpr> at 0x7f0885776e40>。這個(gè)表示形式告訴我們這是一個(gè)生成器對象，位置在內(nèi)存地址 0x7f0885776e40 上。

接下來，代碼通過 next(e) 調(diào)用 next() 函數(shù)來獲取生成器 e 中的下一個(gè)元素。第一次調(diào)用 next(e) 返回 0，第二次調(diào)用 next(e) 返回 1。

然后，代碼使用 for each in e: 迭代生成器對象 e，依次遍歷生成器中的剩余元素，并將每個(gè)元素打印出來。最終的輸出結(jié)果為 2 3 4 5 6 7 8 9，這是因?yàn)樵谇懊嬉呀?jīng)使用 next() 函數(shù)獲取了生成器中的前兩個(gè)元素，所以迭代從第三個(gè)元素開始。

因?yàn)樯善魇侵饌€(gè)生成元素的，一旦元素被獲取并移到下一個(gè)元素，就不會(huì)再返回之前的元素。因此，在迭代的過程中，每調(diào)用一次 next(e)，生成器都會(huì)生成下一個(gè)元素，并返回給調(diào)用者。直到生成器中的所有元素都被遍歷完畢，才會(huì)結(jié)束迭代。

【例子】

s = sum([i for i in range(101)])
print(s)    # 5050
s = sum((i for i in range(101)))
print(s)    # 5050

這段代碼計(jì)算了從 0 到 100 的整數(shù)之和。

首先，使用列表推導(dǎo)式 [i for i in range(101)] 創(chuàng)建了一個(gè)包含從 0 到 100 的整數(shù)的列表，并通過 sum() 函數(shù)求得其總和。代碼 s = sum([i for i in range(101)]) 將該總和賦值給變量 s，并打印輸出結(jié)果為 5050。

接下來，使用生成器表達(dá)式 (i for i in range(101)) 創(chuàng)建了一個(gè)生成器對象，該生成器逐個(gè)生成從 0 到 100 的整數(shù)，并通過 sum() 函數(shù)求得生成器中所有元素的總和。代碼 s = sum((i for i in range(101))) 將該總和賦值給變量 s，并打印輸出結(jié)果仍為 5050。

無論是使用列表推導(dǎo)式還是生成器表達(dá)式，最終都可以得到相同的結(jié)果。不同的是，使用列表推導(dǎo)式會(huì)首先創(chuàng)建一個(gè)包含所有整數(shù)的列表，而生成器表達(dá)式則是逐個(gè)生成整數(shù)，避免了額外的內(nèi)存消耗。因此，在這個(gè)例子中，使用生成器表達(dá)式更加高效。

如有錯(cuò)誤歡迎指正，謝謝！