一、while 循环

while语句最基本的形式包括一个位于顶部的布尔表达式，一个或多个属于while代码块的缩进语句。

while 布尔表达式:
    代码块

while循环的代码块会一直循环执行，直到布尔表达式的值为布尔假(0)。

如果布尔表达式不带有 <、 >、 ==、 !=、 in、 not in 等运算符，仅仅给出数值之类的条件，也是可以的。
当while后写入一个非零整数时，视为真值，执行循环体；写入0时，视为假值,不执行循环体。
也可以写入str、 list或任何序列，长度非零视为真，执行循环体；否则视为假，不执行循环体。

【例子】

count = 0
while count < 3:
    temp = input("请输入一个数字：")
    guess = int(temp)
    if guess > 8:
        print("你输入的数字 大于 正确的数字！")
    else:
        if guess == 8:
            print("恭喜，你猜对了！")
            print("但是，没有奖励！")
            count = 3
        else:
            print("你输入的数字 小于 正确的数字！")
    count = count + 1
    #count += 1
print("游戏结束！")

[root@10 python]# py guess_while.py 
请输入一个数字：2
你输入的数字 小于 正确的数字！
请输入一个数字：4
你输入的数字 小于 正确的数字！
请输入一个数字：8
恭喜，你猜对了！
但是，没有奖励！
游戏结束！
[root@10 python]# py guess_while.py 
请输入一个数字：3
你输入的数字 小于 正确的数字！
请输入一个数字：9
你输入的数字 大于 正确的数字！
请输入一个数字：6
你输入的数字 小于 正确的数字！
游戏结束！
[root@10 python]# py guess_while.py 
请输入一个数字：8
恭喜，你猜对了！
但是，没有奖励！
游戏结束！
[root@10 python]# 

【例子】 布尔表达式返回0，循环终止。

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

string[1:] 字符串切片表示从索引为1的位置开始，取到字符串的末尾（包括末尾字符）。换句话说，它返回的是字符串中从第2个字符到最后一个字符的子字符串。
python-切片操作指南

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

二、while - else 循环

while 布尔表达式:
    代码块
else:
    代码块

当while循环正常执行完的情况下，执行else输出，如果while循环中执行了跳出循环的语句，比如break，将不执行else代码块的内容。

【例子】

count = 0
while count < 5:
    print("%d is less than 5" % count)  # 将变量count的值替换为占位符%d(格式化整数的占位符)所在的位置。
    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   # 当 break 执行时，程序会立即退出当前所在的循环。
else:
    print("%d is not less than 5" % count)

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

for 循环

for循环是迭代循环，在Python中相当于一个通用的序列迭代器，可以遍历任何有序序列，如str、 list、 tuple等，也可以遍历任何可迭代对象，如dict。

for 迭代变量 in 可迭代对象：
    代码块

每次循环，迭代变量被设置为可迭代对象的当前元素，提供给代码块使用。

【例子】

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() 是一个字典数据类型（dict）的方法，它返回一个包含字典键值对的视图对象。每个键值对都表示为一个元组，其中第一个元素是键，第二个元素是对应的值。

这是一个示例代码：

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=' ') 打印每个键值对，使用 : 分隔键和值，并使用空格作为分隔符，同时在同一行上连续打印。这样，你会得到输出结果：a:1 b:2 c:3。

【例子】
.keys() 是一个字典数据类型（dict）的方法，它返回一个包含字典所有键的视图对象。

这是一个示例代码：

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

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

输出：

a b c 

如果你运行以下代码:

上述代码中，my_dict.keys() 用于遍历字典 my_dict 中的所有键。然后使用 print(key, end=' ') 打印每个键，并通过 end=' ' 将每个键之间的默认空格改为一个空格，在同一行上连续打印。这样，你会得到输出结果：a b c。

【例子】
.values() 是一个字典数据类型（dict）的方法，它返回一个包含字典所有值的视图对象。

这是一个示例代码：

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=' ') 打印每个值，并通过 end=' ' 将每个值之间的默认空格改为一个空格，在同一行上连续打印。这样，你会得到输出结果：1 2 3。

四、for - else 循环

for 迭代变量 in 可迭代对象:
    代码块
else:
    代码块

当for循环正常执行完的情况下，执行else输出，如果for循环中执行了跳出循环的语句，比如break，将不执行else代码块的内容，与while - else语句一样。

【例子】

for num in range(10, 20):   # 迭代 10 到 20(不包括20) 之间的数字。
    for L in range(2, num): # 根据因子迭代。
        if num % L == 0:    # 确定第一个因子
            LL = num / L    # 计算第二个因子
            print('%d 等于 %d * %d' % (num, L, LL))
            break   # 跳出当前循环
    else:   # 循环的 else 部分
        print(num, '是一个质数')

这段代码是用来判断 10 到 20 之间的数字是质数还是合数。质数是只能被1和自身整除的大于1的整数，而合数是可以被大于1小于自身的整数整除的整数。

在这段代码中，外层的 for 循环用于迭代 10 到 20（不包括20）之间的数字。内层的 for 循环用于根据因子进行迭代。

在内层循环中，使用条件判断 if num % L == 0 来确定是否存在因子。如果存在因子，则打印出由两个因子组成的等式，并通过 break 关键字跳出当前循环。

如果内层循环没有通过 break 跳出，即没有找到任何因子，则执行循环的 else 部分，打印出该数字是一个质数。

所以，对于给定的代码，它将打印出以下结果：

10 等于 2 * 5
11 是一个质数
12 等于 2 * 6
13 是一个质数
14 等于 2 * 7
15 等于 3 * 5
16 等于 2 * 8
17 是一个质数
18 等于 2 * 9
19 是一个质数

五、range() 函数

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

• 这个 BIF (Built-in function) 有三个参数，其中用中括号括起来的两个表示这两个参数是可选的。
• step=1 表示第三个参数的默认值是1。
• range 这个BIF的作用是生成一个从start参数的值开始到stop参数的值结束的数字序列，该序列包含start的值但不包含stop的值。

【例子】
如果你运行以下代码:

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

输出将会是：

2 
3 
4 
5

上述代码中，range(2, 6) 表示迭代从2开始到6（不包括6）之间的数字。然后使用 print(L) 打印每个迭代的数字。这样，你会得到输出结果：2 3 4 5。注意，输出的每个数字都在单独的一行上。

【例子】
如果你运行以下代码：

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

输出将会是：

1
3
5

上述代码中，range(1, 6, 2) 表示从1开始，以步长为2进行迭代，直到小于6。也就是说，迭代的数字序列为 [1, 3, 5]。然后使用 print(L) 打印每个迭代的数字。这样，你会得到输出结果：1 3 5。注意，输出的每个数字都在单独的一行上。

六、enumerate()函数

enumerate(sequence, [start=0])

• sequence: 一个序列，迭代器或其他支持迭代对象。
• start: 下标起始位置。
• 返回 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 列表，并为每个元素添加一个索引值。结果被转化为列表并赋值给变量 lst。然后，通过 print(lst) 打印输出结果。
输出结果为：

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

在第二段代码中，使用 enumerate(my_list, start=1) 来遍历 my_list 列表，并从索引值为 1 开始。结果同样被转化为列表并赋值给变量 lst。然后，通过 print(lst) 打印输出结果。
输出结果为：

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

可以看到，第二段代码中的索引值从 1 开始，而不是默认的 0。这是通过 start=1 参数实现的。

enumerate() 与 for 循环的结合使用。

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

用enumerate不仅返回了A中的元素，还给该元素一个索引值(默认从0开始)。此外，用enumerate(A, N)还可以确定索引起始值为N。

【例子】

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

print('结束！')


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

print('结束！')

在第一个循环中，使用 for language in languages: 遍历 languages 列表，并将当前元素赋值给变量 language。然后使用字符串格式化 %s 将每个语言名称插入到字符串中，并打印输出。最后打印输出 '结束！'。这样会依次输出以下内容：

Python 语言
R 语言
C++ 语言
结束！

在第二个循环中，使用 enumerate(languages, 1) 在遍历 languages 列表的同时获取索引值。 1 参数表示索引从 1 开始。对于每个元素，将索引值赋值给变量 L，将当前元素赋值给变量 language。然后使用字符串格式化 %d 和 %s 将索引和语言名称插入到字符串中，并打印输出。最后打印输出 '结束！'。这样会依次输出以下内容：

1 Python 语言
2 R 语言
3 C++ 语言
结束！

因此，代码的最终输出结果为：

Python 语言
R 语言
C++ 语言
结束！
1 Python 语言
2 R 语言
3 C++ 语言
结束！

七、break 语句

break语句可以跳出当前所在层的循环。

【例子】

import random
secret = random.randint(1, 10)  # 1~10之间的随机数

count = 0
while True:
    count = count + 1
    temp = input("请输入一个数字(1~10)：")
    guess = int(temp)
    if guess > secret:
        print("你输入的数字 大于 正确的数字！")
    else:
        if guess == secret:
            print("恭喜，你猜对了！")
            print("但是，没有奖励,总共尝试了 %d 次！" % count)
            break
        else:
            print("你输入的数字 小于 正确的数字！")
print("游戏结束！")

这段代码是一个猜数字游戏的简单实现。

首先，使用 random.randint(1, 10) 函数生成一个 1 到 10 之间的随机数，并将其赋值给变量 secret。

然后，设置变量 count 的初始值为 0，用于计算猜测的次数。

接下来，进入一个无限循环 while True:。在每次循环中，首先将 count 加 1。然后使用 input 函数接收用户输入的一个数字，并将其转换为整数类型。

代码会通过多个判断语句对用户猜测的数字进行评估和反馈：

1. 若猜测数字大于 secret，则输出提示信息：你输入的数字 大于 正确的数字！
2. 若猜测数字小于 secret，则输出提示信息：你输入的数字 小于 正确的数字！
3. 若猜测数字等于 secret，则输出恭喜信息，提示用户猜对了，并输出猜测的次数信息：恭喜，你猜对了！但是，没有奖励，总共尝试了 X 次！（其中 X 是 count 的值）

最后，使用 break 关键字跳出循环，并输出游戏结束的信息：游戏结束！

总结起来，这段代码会不断接收用户输入的数字，直到猜对为止，并在每次猜测后给出相应的提示信息。最终会统计猜测的次数并输出，然后结束游戏。

[root@10 python]# py guess_plus.py 
请输入一个数字(1~10)：5
恭喜，你猜对了！
但是，没有奖励,总共尝试了 1 次！
游戏结束！
[root@10 python]# py guess_plus.py 
请输入一个数字(1~10)：5
你输入的数字 大于 正确的数字！
请输入一个数字(1~10)：3
你输入的数字 小于 正确的数字！
请输入一个数字(1~10)：4
恭喜，你猜对了！
但是，没有奖励,总共尝试了 3 次！
游戏结束！
[root@10 python]# 

八、continue 语句

continue终止本轮循环并开始下一轮循环。

【例子】

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

在 for 循环中，range(10) 会生成一个从 0 到 9 的整数序列。对于每个迭代的元素 L，按照以下步骤执行：

1. 对于 L 的值在 range(10) 中的每个迭代，首先会检查 L 是否为奇数（L % 2 != 0）。

   • 如果 L 是奇数，则输出当前的奇数 L。
   • 然后使用 continue 关键字跳过后续操作，直接进入下一次循环。

2. 如果 L 不是奇数（即偶数），则执行下面的代码块。

   • 将 L 的值增加 100：L += 100。
   • 输出 L。

因此，循环的输出结果是：

100
1
102
3
104
5
106
7
108
9

首次循环时，L 的初始值为0，不满足 (L % 2 != 0) 的条件，所以 L 增加100后输出100。

第二次循环，L 的初始值为1，满足 (L % 2 != 0) 的条件，输出1，然后使用 contLnue 跳过后续操作。

在每次迭代中，奇数直接输出，而偶数则增加 100 后输出。

九、pass 语句

pass语句的意思是“不做任何事”，如果你在需要有语句的地方不写任何语句，那么解释器会提示出错，而pass语句就是用来解决这些问题的。

【例子】

def a_func():

# IndentationError: expected an indented block

【例子】

def a_func():
    pass

pass是空语句，不做任何操作，只起到占位的作用，其作用是为了保持程序结构的完整性。尽管pass语句不做任何操作，但如果暂时不确定要在一个位置放上什么样的代码，可以先放置一个pass语句，让代码可以正常运行。

十、推导式

1. 列表推导式

[expr for value in collection [if condition] ]

【例子】

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

这段代码创建了两个列表 x 和 y，并使用列表推导式生成了 y 的值。

1. 在列表 x 中，包含了 -4, -2, 0, 2, 4 这五个元素。

2. 列表推导式 [a * 2 for a in x] 表示对于 x 中的每个元素 a，将其乘以 2，并将结果放入新的列表 y 中。

3. 所以，根据列表推导式的逻辑，y 的值将是 [-8, -4, 0, 4, 8]。

最后，代码通过 print(y) 输出了列表 y：

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

因此，程序的输出结果就是 [-8, -4, 0, 4, 8]。每个元素都是在原始列表 x 中的对应元素乘以 2 后得到的值。

【例子】

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

这段代码创建了一个列表 x，并使用列表推导式生成了 x 的值。

1. 列表推导式 [i ** 2 for i in range(1, 10)] 表示对于 range(1, 10) 中的每个元素 i，将其平方，并将结果放入新的列表 x 中。

2. 使用 range(1, 10) 生成一个从 1 到 9（包括 1 不包括 10）的整数序列。

3. 对于每个迭代的元素 i，计算它的平方 i ** 2，并将结果添加到列表 x 中。

所以，根据列表推导式的逻辑，x 的值将是 [1, 4, 9, 16, 25, 36, 49, 64, 81]。

最后，代码通过 print(x) 输出了列表 x：

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

因此，程序的输出结果就是 [1, 4, 9, 16, 25, 36, 49, 64, 81]，即从 1 到 9 的平方数列表。

【例子】

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

这段代码创建了一个列表 x，并使用列表推导式生成了 x 的值。

1. 列表推导式 [(i, i ** 2) for i in range(6)] 表示对于 range(6) 中的每个元素 i，创建一个元组 (i, i ** 2)，并将这些元组放入新的列表 x 中。

2. 使用 range(6) 生成一个从 0 到 5 的整数序列。

3. 对于每个迭代的元素 i，计算 i 的平方 i ** 2，然后创建一个包含两个元素的元组 (i, i ** 2)。

所以，根据列表推导式的逻辑，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)]

因此，程序的输出结果就是 [(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]，即从 0 到 5 的每个数字及其平方组成的元组列表。

【例子】

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

这段代码创建了一个列表 x，并使用列表推导式生成了 x 的值。

1. 列表推导式 [i for i in range(100) if (i % 2) != 0 and (i % 3) == 0] 表示对于 range(100) 中的每个元素 i，如果 i 是奇数且是 3 的倍数，则将其添加到新的列表 x 中。

2. 使用 range(100) 生成一个从 0 到 99 的整数序列。

3. 对于每个迭代的元素 i，通过条件 (i % 2) != 0 and (i % 3) == 0 进行筛选。这个条件要求 i 是奇数且是 3 的倍数。

所以，根据列表推导式的逻辑，x 的值将是满足条件的从 0 到 99 的整数中，既是奇数又是 3 的倍数的数。

最后，代码通过 print(x) 输出了列表 x：

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

因此，程序的输出结果就是包含满足条件的从 0 到 99 的整数中既是奇数又是 3 的倍数的数的列表。

【例子】

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

这段代码创建了一个列表 a，并使用嵌套的列表推导式生成了 a 的值。

1. 嵌套的列表推导式 [ (i, j) for i in range(0, 3) for j in range(0, 3)] 表示对于 range(0, 3) 中的每个元素 i，以及对于 range(0, 3) 中的每个元素 j，都生成一个包含两个元素 (i, j) 的元组，并将这些元组添加到新的列表 a 中。

2. 使用 range(0, 3) 生成一个从 0 到 2 的整数序列。

3. 第一个 for 循环迭代 range(0, 3) 中的元素 i。

4. 第二个嵌套的 for 循环迭代 range(0, 3) 中的元素 j。

5. 对于每个迭代的元素 i 和 j，创建一个包含两个元素 (i, j) 的元组，并将其添加到列表 a 中。

所以，根据嵌套的列表推导式的逻辑，a 的值将是所有可能的以从 0 到 2 的整数组成的元组 (i, j) 的列表。

最后，代码通过 print(a) 输出了列表 a：

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

因此，程序的输出结果就是包含所有可能的以从 0 到 2 的整数组成的元组 (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]]

这段代码创建了一个二维列表 x，并使用嵌套的列表推导式生成了 x 的值。

1. 嵌套的列表推导式 [[i, j] for i in range(0, 3) for j in range(0, 3)] 表示对于 range(0, 3) 中的每个元素 i，以及对于 range(0, 3) 中的每个元素 j，都生成一个包含两个元素 [i, j] 的列表，并将这些列表添加到新的二维列表 x 中。

2. 使用 range(0, 3) 生成一个从 0 到 2 的整数序列。

3. 第一个 for 循环迭代 range(0, 3) 中的元素 i。

4. 第二个嵌套的 for 循环迭代 range(0, 3) 中的元素 j。

5. 对于每个迭代的元素 i 和 j，创建一个包含两个元素 [i, j] 的列表，并将其添加到二维列表 x 中。

所以，根据嵌套的列表推导式的逻辑，x 的值将是一个 3x3 的二维列表，其中包含从 0 到 2 的整数组成的列表。

最后，代码通过 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 中第一行第一个元素的值。

最后，通过 print(x) 输出了修改后的二维列表 x：

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

因此，程序的输出结果是首先输出原始的二维列表 x，然后修改第一行第一个元素的值为 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)

这段代码使用了列表推导式来创建一个名为 a 的列表。

列表推导式的逻辑如下：

1. 使用 range(0, 3) 生成一个从 0 到 2 的整数序列。

2. 第一个 for 循环迭代 range(0, 3) 中的元素 i。

3. 在第一个 for 循环中添加一个 if 条件，即 if i < 1。这个条件会过滤出满足条件的 i 值，只有当 i < 1 时才会继续执行后面的循环。

4. 第二个嵌套的 for 循环迭代 range(0, 3) 中的元素 j。

5. 在第二个嵌套的 for 循环中添加一个 if 条件，即 if j > 1。这个条件会过滤出满足条件的 j 值，只有当 j > 1 时才会将 (i, j) 添加到列表 a 中。

因此，根据列表推导式的逻辑，a 的值将是一个由满足条件 (i < 1) 且 (j > 1) 的 (i, j) 元组组成的列表。

最后，通过 print(a) 输出了列表 a：

[(0, 2)]

因为 i 的取值范围是从 0 到 2，但我们只保留了满足 i < 1 的值，所以只有 (0, 2) 符合条件被添加到了列表 a 中。

因此，程序的输出结果是只包含一个元素 (0, 2) 的列表 a。

2. 元组推导式

( 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)

这段代码展示了生成器表达式的使用以及将生成器转换为元组的操作。

首先，代码定义了一个生成器表达式 a，它使用 range(10) 来生成从 0 到 9 的整数序列，并将每个元素赋值给变量 x。生成器表达式使用圆括号来表示。

接着，通过 print(a) 输出 a，得到的结果是 <generator object <genexpr> at 0x7f0885776e40>。这是因为生成器对象本身并没有存储所有元素的值，而是在需要时逐个生成，所以无法直接打印出所有的元素。

然后，通过 tuple(a) 将生成器 a 转换为元组，并使用 print(tuple(a)) 输出结果。得到的元组是 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)，其中包含了 range(10) 生成的所有整数。这是因为转换为元组后，生成器会被逐个迭代生成，并存储在元组中。

因此，最终代码输出的结果是先打印生成器对象的描述信息，再将生成器转换为元组并打印出元组的内容。

注意：生成器在被迭代完毕后无法再次使用，如果需要重新迭代，则需要重新生成生成器对象 a。

3. 字典推导式

{ 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}

这段代码使用字典推导式创建了一个字典 b，其中键为整数序列 range(10) 中满足条件 i % 3 == 0 的值，而对应的值为判断该整数是否为偶数的布尔结果。

具体来说，代码首先使用 range(10) 生成从 0 到 9 的整数序列，并通过条件 i % 3 == 0 过滤出可被 3 整除的整数作为字典的键。

然后，在字典推导式的表达式部分，使用 i % 2 == 0 判断每个整数是否为偶数，将判断结果作为对应键的值。判断结果是布尔类型，如果整数是偶数，则为 True，否则为 False。

最后，通过 print(b) 打印字典 b 的内容。输出的结果为 {0: True, 3: False, 6: True, 9: False}。这是因为在整数序列中，只有 0、3、6 和 9 能被 3 整除，而且对应的判断结果分别为 True、False、True 和 False。

因此，最终的输出结果是一个字典，其中键为满足条件的整数，值为判断该整数是否为偶数的结果。

4. 集合推导式

{ 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}

这段代码使用集合推导式创建了一个集合 c，其中包含了列表 [1, 2, 3, 4, 5, 5, 6, 4, 3, 2, 1] 中的唯一元素。

具体来说，代码通过列表 [1, 2, 3, 4, 5, 5, 6, 4, 3, 2, 1] 创建了一个列表对象，并使用集合推导式将列表中的元素提取出来并去除重复值，形成了一个包含唯一元素的集合。

最后，通过 print(c) 打印集合 c 的内容。输出的结果为 {1, 2, 3, 4, 5, 6}，这是因为在原始列表中，存在重复的元素，通过集合推导式可以确保集合中只包含唯一的元素，并按照其在原始列表中的顺序进行排列。

因此，最终的输出结果是一个集合，其中包含了列表中的唯一元素。

5. 其他

next(iterator[, default]) 方法从迭代器中返回下一个元素。如果迭代器已经遍历完毕，且提供了 default 参数，则返回 default，而不是引发 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 

这段代码创建了一个生成器对象 e，它使用生成器表达式 (i for i in range(10)) 来生成从 0 到 9 的整数序列。

代码中的 print(e) 打印了生成器对象 e 的表示形式，输出结果为 <generator object <genexpr> at 0x7f0885776e40>。这个表示形式告诉我们这是一个生成器对象，位置在内存地址 0x7f0885776e40 上。

接下来，代码通过 next(e) 调用 next() 函数来获取生成器 e 中的下一个元素。第一次调用 next(e) 返回 0，第二次调用 next(e) 返回 1。

然后，代码使用 for each in e: 迭代生成器对象 e，依次遍历生成器中的剩余元素，并将每个元素打印出来。最终的输出结果为 2 3 4 5 6 7 8 9，这是因为在前面已经使用 next() 函数获取了生成器中的前两个元素，所以迭代从第三个元素开始。

因为生成器是逐个生成元素的，一旦元素被获取并移到下一个元素，就不会再返回之前的元素。因此，在迭代的过程中，每调用一次 next(e)，生成器都会生成下一个元素，并返回给调用者。直到生成器中的所有元素都被遍历完毕，才会结束迭代。

【例子】

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

这段代码计算了从 0 到 100 的整数之和。

首先，使用列表推导式 [i for i in range(101)] 创建了一个包含从 0 到 100 的整数的列表，并通过 sum() 函数求得其总和。代码 s = sum([i for i in range(101)]) 将该总和赋值给变量 s，并打印输出结果为 5050。

接下来，使用生成器表达式 (i for i in range(101)) 创建了一个生成器对象，该生成器逐个生成从 0 到 100 的整数，并通过 sum() 函数求得生成器中所有元素的总和。代码 s = sum((i for i in range(101))) 将该总和赋值给变量 s，并打印输出结果仍为 5050。

无论是使用列表推导式还是生成器表达式，最终都可以得到相同的结果。不同的是，使用列表推导式会首先创建一个包含所有整数的列表，而生成器表达式则是逐个生成整数，避免了额外的内存消耗。因此，在这个例子中，使用生成器表达式更加高效。

如有错误欢迎指正，谢谢！