超详细的 Python 基础语句总结_python语言基础

目录
一、运算符
1.1 + ——两个对象相加
1.2 - ——得到负数或是一个数减去另一个数
1.3 * ——两个数相乘或是返回一个被重复若干次的字符串、列表、元组
1.4 / ——两个数相除
1.5 // ——返回商的整数部分（向下取整）
1.6 % ——返回除法的余数
1.7 ** ——返回一个数的幂
1.8 = —— 简单的赋值
1.9 += —— 加法赋值
1.10 -= —— 减法赋值
1.11 *= —— 乘法赋值
1.12 /= —— 除法赋值运算符
1.13 %= —— 取模赋值运算符
1.14 **= —— 幂赋值运算符
1.15 //= —— 取整除赋值运算符
1.16 == —— 等于运算符
1.17 != —— 不等于运算符
1.18 > —— 大于运算符
1.19 < —— 小于运算符
1.20 >= —— 大于等于运算符
1.21 <= —— 小于等于运算符
1.22 and —— 与运算符
1.23 or—— 或运算符
1.24 not—— 非运算符
1.25 & —— 按位与运算符
1.26 | —— 按位或运算符
1.27 ^ —— 按位异或运算符
1.28 ~ —— 按位取反运算符
1.29 << —— 左移动运算符
1.30 >> —— 右移动运算符
1.31 in —— 在指定的序列中查找
1.32 not in —— 在指定的序列中查找
1.33 is —— 判断两个标识是否引自同一个对象
1.34 is not —— 判断两个标识是否引自同一个对象
二、流程控制
2.1 if 语句--简单的条件判断
2.2 if…else 语句 --二分支条件判断
2.3 if…elif…else 语句--多分支条件判断
2.4 for 语句--循环
2.5 for…else 语句--循环
2.6 while 语句--循环
2.7 while…else 语句--循环
2.8 break 语句--终止当前循环
2.9 continue 语句--终止本次循环进入下一次循环
2.10 条件表达式(三目运算符、三元表达式)
三、函数
3.1 def 语句--自定义函数
3.2 lambda 表达式--匿名函数
3.3 pass 语句--空语句
3.4 yield 语句--生成器
四、程序调试与异常处理
4.1 assert 语句--应用断言调试程序
4.2 raise 语句--抛出异常
4.3 try…except 语句--捕获异常
4.4 try…except…else 语句--捕获异常
4.5 try…except…finally 语句--捕获异常
一、运算符
1.1 + ——两个对象相加
+ 运算符用于实现 2 个对象的相加。视频讲解链接如下：

https://www.bilibili.com/video/BV1Ao4y1m7nh

【示例1】数字相加。在 Python 中，经常会遇到使用 + 进行数值相加的情况，常用应用如下：

a = 13
b = 2
c = 4.0
d = 5.0
print(a + b)  # 整数相加 15
print(c + d)  # 浮点数相加 9.0
print(a + c)  # 整数和浮点数相加 17.0
print(a + .5)  # 整数和省略零的浮点数相加 13.5
1
2
3
4
5
6
7
8
【示例2】字符串相加。在 Python 中，如果 + 号的两侧是字符串类型数据，则表示将 2 个字符串进行拼接。常用应用如下：

s1 = 'Amo'
s2 = 'Xiang'
print(s1 + s2)  # 字符串拼接
print(s1 + ' ' + s2)  # 2个字符串间添加空格
print(s1 + '\n' + s2)  # 2个字符串间添加换行符
1
2
3
4
5
程序执行结果如下图所示：

【示例3】元组、列表相加。当元组、列表使用 + 相加时，返回合并后的元组、列表。常用应用如下：

t1 = (1, 2, 3)
t2 = (4, 5, 6)
t3 = ('a', 'b', 'c')
t4 = ('d', 'e', 'f')
t5 = (('o', 'p', 'q'), ('x', 'y', 'z'))
print(t1 + t2)  # (1, 2, 3, 4, 5, 6)
# (1, 2, 3, 4, 5, 6, 'a', 'b', 'c', 'd', 'e', 'f')
print(t1 + t2 + t3 + t4)
# (1, 2, 3, 4, 5, 6, 'a', 'b', 'c', 'd', 'e', 'f', ('o', 'p', 'q'), ('x', 'y', 'z'))
print(t1 + t2 + t3 + t4 + t5)

print("*" * 90)
l1 = [1, 2, 3]
l2 = [4, 5, 6]
l3 = [['a', 'b', 'c']]
l4 = [['d', 'e', 'f']]
l5 = [['o', 'p', 'q'], ('x', 'y', 'z')]
print(l1 + l2)  # [1, 2, 3, 4, 5, 6]
# [['a', 'b', 'c'], ['d', 'e', 'f']]
print(l3 + l4)
# [1, 2, 3, 4, 5, 6, ['a', 'b', 'c'], ['d', 'e', 'f'], ['o', 'p', 'q'], ('x', 'y', 'z')]
print(l1 + l2 + l3 + l4 + l5)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
说明：字典和集合不能使用“+”进行操作。

说明：不同数据类型，不能直接进行 + 运算。如下：

1.2 - ——得到负数或是一个数减去另一个数
- 运算符在 Python 中有两个作用，一个是作为负号使用，在数字前表示负数；另一个是作为减号，表示前一个数字减去后一个数字。

【示例1】作为负号使用。作为负号使用时，注意负负为正。常用应用如下：

num1 = 4
num2 = -5
num3 = -6.0
print(-num1)  # -4
print(num2)  # -5
print(-num3)  # 6.0
1
2
3
4
5
6
【示例2】作为减号使用。作为减号使用时，常用应用如下：

num1 = 5
num2 = 1
num3 = 10
num4 = 8.0
print(num1 - num2)  # 4
print(num1 - num3)  # -5
print(num1 - num4)  # -3.0
1
2
3
4
5
6
7
1.3 * ——两个数相乘或是返回一个被重复若干次的字符串、列表、元组
* 运算符在 Python 中有两个作用，一个是作为乘号使用，表示两个数相乘；另一个是和整数 n 组合，作为重复符号使用，表示字符串、列表、元组重复 n 次。

【示例1】作为乘号使用。作为乘号使用时，常用应用如下：

num1 = 3
num2 = 4
num3 = 5.5
num4 = -6
print(num1 * num2)  # 12
print(num1 * num3)  # 16.5
print(num1 * num4)  # -18
1
2
3
4
5
6
7
【示例2】对字符串使用*号。使用“*”作为重复符号，打印一个等腰三角形。代码如下：

print(' ' * 2 + '*' + ' ' * 2)
print(' ' + '*' * 3 + ' ')
print('*' * 5)
1
2
3
【示例3】对元组使用*号。“*”号作为重复符号，同样可以作用在元组上。

l1 = (1, 2, 3)
l2 = (('a', 'b', 'c'), ('d', 'e', 'f'))
# (1, 2, 3, 1, 2, 3, 1, 2, 3)
print(l1 * 3)
# (('a', 'b', 'c'), ('d', 'e', 'f'), ('a', 'b', 'c'), ('d', 'e', 'f'))
print(l2 * 2)
1
2
3
4
5
6
【示例4】对列表使用*号。“*”号作为重复符号，同样可以作用在列表上。

l1 = [1, 2, 3]
l2 = [['a', 'b', 'c']]
board = [['-'] * 3 for i in range(3)]  # 使用列表解析式
# [1, 2, 3, 1, 2, 3, 1, 2, 3]
print(l1 * 3)
# [['a', 'b', 'c'], ['a', 'b', 'c'], ['a', 'b', 'c']]
print(l2 * 3)
# [['-', '-', '-'], ['-', '-', '-'], ['-', '-', '-']]
print(board)
1
2
3
4
5
6
7
8
9
1.4 / ——两个数相除
/ 运算符用于实现 2 个对象的相除。

【示例1】实现人民币和美元的转换。已知1美元兑换人民币 6.78 元，编写程序实现人民币转换成美元的功能。代码如下：

exchange_rate = 6.78  # 汇率
RMB = input('请输入人民币金额：')
try:
    US = float(RMB) / exchange_rate
    print('转化后的美元是:{:.2f}'.format(US))
except ValueError:
    print('请输入正确的数值类型。')
1
2
3
4
5
6
7
程序执行结果如下图所示：

1.5 // ——返回商的整数部分（向下取整）
// 运算符用于取整除，返回商的整数部分，注意向下取整。例如 8 // 3 = 2。

【示例1】将描述“秒”转化为“分 秒”的格式。在考试系统中需要记录用户的答题时间。通常答题时间是以秒为单位记录的。比如用时“100”秒，为了增加可读性，需要将“100秒”转化为“1分钟40秒“的形式。如下代码，可以实现该功能：

def second_format(seconds):
    minutes = seconds // 60  # 计算分钟数
    if minutes > 0:
        seconds = seconds - minutes * 60  # 计算剩余秒数
    return minutes, seconds

i = 2
while i > 0:
    seconds = input('请输入秒数：')
    result = second_format(int(seconds))
    print(f'{seconds}秒可以转化为{result[0]}分{result[1]}秒')
    i -= 1
1
2
3
4
5
6
7
8
9
10
11
12
13
程序执行结果如下图所示：

【示例2】统计程序运行所占用的内存。psutil 是个跨平台库模块，能够轻松实现获取系统运行的进程和系统利用率，包括CPU、内存、磁盘、网络等信息。使用“pip install psutil”命令安装psutil模块，然后统计程序运行所占用的内存，并将其转化MB单位大小。代码如下：

import os
import psutil

def show_memory_info(hint):
    """显示当前Python程序占用的内存大小"""
    pid = os.getpid()
    p = psutil.Process(pid)
    info = p.memory_full_info()
    memory = info.uss / 1024. / 1024  # 1MB = 1024KB = 1024B
    print('{} memory used: {} MB'.format(hint, memory))

# 测试函数占用多少内存
show_memory_info('initial')
list_val = [i for i in range(10000000)]
show_memory_info('finished')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
程序执行结果如下图所示：

1.6 % ——返回除法的余数
% 运算符用于取模，返回除法的余数，例如 8%2 结果为 0，8%3 结果为2。

【示例1】负数使用%求余数。计算下面的除法求余结果：

result1 = 8 % 3
result2 = -8 % 3
result3 = 8 % -3
result4 = 0 % -3  # 0
result5 = 0 % 6  # 0
print(f"8  % 3 的结果是：{result1}")  # 2
print(f"-8 % 3 的结果是：{result2}")  # 1
print(f"8 % -3 的结果是：{result3}")  # -1
1
2
3
4
5
6
7
8
上面的结果可能与很多人的预期不符，这个结果是由 Python 机制决定的。在 Python 中取余数遵循下面的公式：

r=a-n*(a//n)
# r=a-n*(a//n)
# 8 % 3 ==> a=8,n=3 ==> 8-3*(8//3) ==> 8-3*2 ==> 2
# 注意：-8//3 计算时向下取整，结果为-3，而不是-2。
# -8 % 3 ==> a=-8,n=3 ==> -8-3*(-8//3) ==> -8-3*(-3) ==> -8+9 ==> 1
# 8 % -3 ==> a=8,n=-3 ==> 8-(-3)*(8//-3) ==> 8+3*(-3) ==> 8-9 ==> -1
1
2
3
4
5
6
1.7 ** ——返回一个数的幂
** 运算符用于返回一个数的幂，例如 2 ** 2 结果为4 ，2 ** 3 结果为8。

【示例1】用 3 种方式求 x 的 y 次幂。

import math

# 计算x的y次幂
x = 10
y = 3
# 方式1
print(x ** y)  # 1000
# 方式2
print(pow(x, y))  # 1000
# 方式3
print(math.pow(x, y))  # 返回类型为浮点型: 1000.0
1
2
3
4
5
6
7
8
9
10
11
1.8 = —— 简单的赋值
= 是简单的赋值运算符，例如将 a=1，表示将数值 1 赋值给变量 a。

【示例1】不同类型数据的赋值。

# 常用数据类型赋值
num = 123  # 数值
str_val = "Amo"  # 字符串
tuple_val = (1, 2, 3)  # 元组
list_val = [1, 2, 3]  # 列表
dict_val = {"name": "Amo", "age": 18}  # 字典
set_val = {1, 2, 3}  # 集合

def fun():
    print("函数赋值")

f = fun  # 函数赋值
f()  # 调用函数：函数赋值

class Student:

    def __init__(self):
        print("类赋值")

s = Student  # 类赋值
s()  # 类的实例化：类赋值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
1.9 += —— 加法赋值
+= 是加法赋值运算符，例如将 a +=1,等价于 a=a+1。

【示例1】计算字典中各值的累加和。

basket = {"fruit": 45.80, "meat": 20.45, "juice": 10}  # 购物车数据
total = 0  # 初始化总价
# 方式1：
for item in basket.values():
    total += item
print(f'方式1的计算结果为{total}')
# 方式2：
total = sum(basket.values())
print(f'方式2的计算结果为{total}')
1
2
3
4
5
6
7
8
9
【示例2】将数字0-9自动转化为汉字。

numbers = input("请输入0-9之间的数字:")
digits_mapping = {
    "0": "零",
    "1": "壹",
    "2": "贰",
    "3": "叁",
    "4": "肆",
    "5": "伍",
    "6": "陆",
    "7": "柒",
    "8": "捌",
    "9": "玖",
}

output = ""
for number in numbers:  # 遍历输入的数字
    output += digits_mapping.get(number, "!") + " "  # 匹配字典的键，然后将结果连接在一起
print(output)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
1.10 -= —— 减法赋值
-= 是减法赋值运算符，如加法运算符类似，例如将a -=1,等价于a=a-1。

【示例1】“逢7过”游戏。“逢7过”是一个锻炼头脑敏捷性的益智游戏。游戏规则是大家围成一圈，然后从1开始依序喊数字，如果数字是7或者7的倍数，就不能喊出这个数字，必须做一个动作。使用Python 计算出200以内的7的倍数。例如7、14、28等。代码如下：

value = 200  # 初始值
L = []
while value > 0:
    if value % 7 == 0:  # 如果被7整除
        L.append(value)  # 添加到列表
    value -= 1
L.reverse()  # 列表反转
print(L)  # 输出列表
1
2
3
4
5
6
7
8
1.11 *= —— 乘法赋值
“*=”是乘法赋值运算符，如加法运算符类似，例如将a *=3,等价于a = a*3。

【示例1】多种类型使用乘法赋值。对不同类型数据使用乘法赋值运算，代码如下：

# 数字
num = 5
num *= 3
print(num)  # 15
# 字符串
str_val = "Amo"
str_val *= 3
print(str_val)  # AmoAmoAmo
# 元组
tuple_val = (1, 2, 3)
tuple_val *= 3
print(tuple_val)  # (1, 2, 3, 1, 2, 3, 1, 2, 3)
# 列表
list_val = [1, 2, 3]
list_val *= 3
print(list_val)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
【示例2】计算摆满国际象棋所需要的麦子数。国际象棋共有64个格子，如果第一个小格内放入一粒麦子，在第二个小格内放入两粒，第三小格内放入给四粒，以此类推，每一小格内都比前一小格加一倍的麦子，直至放满64个格子，总共需要多少颗麦子。代码如下：

def getNumberOfWheat(grid):
    """
    获取放grid格时的麦子数
    :param grid: 格子数
    :return: 返回放满格子数时的麦子数量
    """
    g_sum = 0
    numberOfWhearInGrid = 1  # 第一个格子放置1粒
    g_sum += numberOfWhearInGrid  # 第一个格子的总粒数
    for i in range(2, grid + 1):  # 从第2个格子开始，遍历每一个格子
        numberOfWhearInGrid *= 2  # 下一个格子是前一个格子的2倍
        g_sum += numberOfWhearInGrid  # 计算所有格子中总粒数
    return g_sum

print(f"放满4个格子需要{getNumberOfWheat(4)}颗麦子")  # 由于第1个格子默认放置1，所以从第2个开始计算共63个格子
print(f'放满64个格子需要{getNumberOfWheat(64)}颗麦子')  # 由于第1个格子默认放置1，所以从第2个开始计算共63个格子
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
1.12 /= —— 除法赋值运算符
/= 是除法赋值运算符，例如将 a /=3,等价于 a = a/3。

【示例1】用2种方式对列表中的元素批量相除。

list_value = [1, 2, 3, 4, 5]
# 方式1：
new_value = [i / 2 for i in list_value]  # 使用列表解析式
print(new_value)  # [0.5, 1.0, 1.5, 2.0, 2.5]
# 方式2：
new_value = []
for i in list_value:
    i /= 2  # 除法赋值运算
    new_value.append(i)  # 追加到新列表
print(new_value)  # [0.5, 1.0, 1.5, 2.0, 2.5]
1
2
3
4
5
6
7
8
9
10
1.13 %= —— 取模赋值运算符
%= 是取模运算符，例如将 a %= 3,等价于a = a%3。

【示例1】对列表中的元素批量取模。

list_value = [10, 11, 12, 13, 14, 15]
new_value = []
for i in list_value:
    i %= 2  # 取模运算
    val = '奇数' if i else '偶数'  # 三元表达式
    new_value.append(val)  # 追加到新列表
print(new_value)  # ['偶数', '奇数', '偶数', '奇数', '偶数', '奇数']
1
2
3
4
5
6
7
1.14 **= —— 幂赋值运算符
“**=”是幂赋值运算符，例如将a **= 3,等价于a = a**3。

【示例1】用3种方式对列表中的元素批量求平方。

list_value = [1, 2, 3, 4, 5]
# 方式1：
new_value = [i ** 2 for i in list_value]  # 使用列表解析式
print(new_value)  # [1, 4, 9, 16, 25]
# 方式2
new_value = []
for i in list_value:
    i **= 2  # 幂赋值操作
    new_value.append(i)  # 追加到新列表
print(new_value)  # [1, 4, 9, 16, 25]
# 方式3
new_value = list(map(lambda x: x ** 2, list_value))
print(new_value)  # [1, 4, 9, 16, 25]
1
2
3
4
5
6
7
8
9
10
11
12
13
1.15 //= —— 取整除赋值运算符
“//=”是取整除赋值运算符，例如将a //= 3,等价于a = a//3。

【示例1】用3种方式对列表中的元素批量取整数赋值

list_value = [1, 2, 3, 4, 5]
# 方式1：
new_value = [i // 2 for i in list_value]  # 使用列表解析式
print(new_value)  # [0, 1, 1, 2, 2]
# 方式2
new_value = []
for i in list_value:
    i //= 2
    new_value.append(i)  # 追加到新列表
print(new_value)  # [0, 1, 1, 2, 2]
# 方式3
new_value = list(map(lambda x: x // 2, list_value))
print(new_value)  # [0, 1, 1, 2, 2]
1
2
3
4
5
6
7
8
9
10
11
12
13
1.16 == —— 等于运算符
“==”是等于运算符，用于比较对象是否相等。如果相等，返回 True，否则返回 False。

【示例1】== 运算符与 is 的区别。“==” 运算符用于比较对象的值是否相等，如果值相等即返回True，而is既要判断值是否相等，又要内存地址相等。它们之间的区别可以通过如下代码来验证：

intern(驻留) 机制和字符串长短无关，在交互模式下，每行字符串字面量都会申请一个新字符串，但是只含大小写字母、数字和下划线的会被 intern，也就是维护了一张 dict 来使得这些字符串全局唯一。上面的代码，需要在 Python 命令提示符下，一行一行输入运行，才是上面的结果。在 Pycharm 或 IDLE 中，将上面的代码保存为文件运行，结果输出不一样。这是因为 Pycharm 中把整数、字符串存储为常量，因此在同一上下文中对同一整数的赋值将产生完全相同的结果。

【示例2】if 语句判断是否相等。

score = int(input('前输入分数：'))
if score == 100:
    print('恭喜你已经通关！')
else:
    print('请继续努力哦！')
1
2
3
4
5
1.17 != —— 不等于运算符
“!=” 是不等于运算符，用于比较对象是否不相等。如果不相等，返回 True，否则返回 False。

【示例1】遍历列表输出不等于某值的信息。获取公司列表中，英文名不是 ”neusoft” 的所有公司的中文名。

list_val = [['neusoft', '东软集团股份有限公司'],
            ['baidu', '百度在线网络技术有限公司'],
            ['tencent', '深圳市腾讯计算机系统有限公司'],
            ['alibaba', '阿里巴巴网络技术有限公司']]

list_new = []
for (name, val) in list_val:  # 遍历列表
    if name != "neusoft":  # 判断不等于
        list_new.append(val)  # 添加到新列表
# ['百度在线网络技术有限公司', '深圳市腾讯计算机系统有限公司', '阿里巴巴网络技术有限公司']
print(list_new)
1
2
3
4
5
6
7
8
9
10
11
1.18 > —— 大于运算符
“>”运算符用于比较对象大小。如果a的值大于b，则a >b返回True，否则返回False。

【示例1】比较数字、字符串、元组、列表和集合类型数据的大小。代码如下：

print(2 > 1)  # True
print(2.3 > 1.4)  # True
print('b' > 'a')  # True
print('abc' > 'abb')  # True
print((1, 2, 3) > (1, 2, 2))  # True
print([1, 2, 3] > [1, 2, 2])  # True
print({1, 2, 3} > {1, 2, 2})  # True
"""说明：比较大小时，先比较第一个元素，ASCII码值大的元素比较大。如果第一个元素相同，则比较第二个元素，以此类推。"""
1
2
3
4
5
6
7
8
【示例2】判断电梯是否超载。已知电梯限载6人，当超过6人时，请提示超载信息，并提示超载人数。代码如下：

person = ['Andy', 'Kobe', 'Jack', 'Jim', 'Mark', 'Tim', 'Bob']  # 电梯内成员列表
stander_number = 6  # 电梯荷载人数
number = len(person)  # 获取内人数
if number > stander_number:  # 如果电梯内人数超过荷载人数
    print('您已超载')
    print(f'超载人数{number - stander_number}人')
else:
    print('符合要求')
1
2
3
4
5
6
7
8
1.19 < —— 小于运算符
“<”运算符用于比较对象大小。如果a的值小于b，则a < b返回True，否则返回False。

【示例1】将倒序索引转化为正序索引。在对序列进行切片操作时，即可以正序切片，也可以倒序切片。编写一个函数，用于计算倒序的索引在正序的位置。代码如下：

def fixIndex(object, index):
    if index < 0:
        # 如果index在右侧，则将其转化为左侧
        index += len(object) + 1
    return index

list_val = [1, 2, 3, 4, 5]
index1 = fixIndex(list_val, -1)
index2 = fixIndex(list_val, -2)
index3 = fixIndex(list_val, -3)
index4 = fixIndex(list_val, -4)
index5 = fixIndex(list_val, -5)
print(f'倒数第1个是正数第{index1}个')
print(f'倒数第2个是正数第{index2}个')
print(f'倒数第3个是正数第{index3}个')
print(f'倒数第4个是正数第{index4}个')
print(f'倒数第5个是正数第{index5}个')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
【示例2】获取列表中最小的元素。在一个全是数字的列表中，获取值最下的元素。代码如下：

numbers = [3, 6, 2, 8, 4, 10]
min_num = numbers[0]
for number in numbers:
    if number < min_num:
        min_num = number
print(f'列表中最小的元素是{min_num}')
1
2
3
4
5
6
1.20 >= —— 大于等于运算符
“>=”运算符用于比较对象大小。如果a的值大于或者等于b，则a >=b 返回True，否则返回False。

【示例1】判断考试成绩是否及格。语文考试及格成绩为60分，如果成绩大于或者等于60分，则成绩及格，否则成绩不及格。实现该功能的代码如下：

score = float(input('请输入你的分数:'))
if score >= 60:
    print('恭喜你，考试通过！')
else:
    print('很遗憾，没有通过考试')
1
2
3
4
5
1.21 <= —— 小于等于运算符
“<=”运算符用于比较对象大小。如果a 的值小于或者等于b，则a <=b 返回True，否则返回False。

【示例2】用2种方式获取偶数。

# 方式1：使用列表解析式
list_val = [i for i in range(21) if i % 2 == 0]
print(list_val)
# 方式2：使用循环遍历
list_val = []
num = 0
while num <= 20:
    if num % 2 == 0:  # 判断能否被2整除
        list_val.append(num)  # 将偶数追加到列表
    num += 1  # 变量自增
print(list_val)
1
2
3
4
5
6
7
8
9
10
11
1.22 and —— 与运算符
“and”运算符用于表示逻辑与。例如opt1 and opt2，如果opt1与opt2全部为真，则返回True，否则返回False。

【示例1】判断电梯是否超载。

num = int(input('请输入人数:'))
weight = float(input('请输入总重量:'))
if num <= 10 and weight <= 1000:
    print('电梯正常运行')
else:
    print('电梯超载')
1
2
3
4
5
6
1.23 or—— 或运算符
“or”运算符用于表示逻辑或。例如opt1 or opt2，如果opt1和opt2全部为否，则返回False,否则返回True。

【示例1】使用or运算符判断某个区间之外的数据。

num = float(input('请输入产品销量:'))
if num > 500 or num < 20:
    print('该产品需要重点关注！')
else:
    print('该产品销量平稳！')
1
2
3
4
5
1.24 not—— 非运算符
“not”运算符用于表示逻辑非。例如not opt，如果opt为False，则返回True，如果opt为True，则返回False。

【示例1】判断输入的值是否为整数。

str_val = input('请输入整数:')
if not str_val.isdigit():
    print('格式错误')
else:
    print(f'你输入的整数是{str_val}')
1
2
3
4
5
1.25 & —— 按位与运算符
按位与运算符：参与运算的两个值，如果两个相应位都为1，则该位的结果为1，否则为0。

【示例1】输出按位与的结果。

a = 0b00111100
b = 0b00001101
# 说明：a&b 的结果是0000 1100，转化为十进制为12。
print(a & b)  # 12
1
2
3
4
1.26 | —— 按位或运算符
按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。

【示例1】输出按位或的结果。

a = 0b00111100
b = 0b00001101
# 说明：a|b 的结果是0011 1101，转化为十进制为61。
print(a | b)  # 61
1
2
3
4
1.27 ^ —— 按位异或运算符
按位异或运算符：当两对应的二进位相异时，结果为1。

【示例1】输出按位异或的结果。

a = 0b00111100
b = 0b00001101
# 说明：a^b 的结果是0011 0001，转化为十进制为49。
print(a ^ b)  # 49
1
2
3
4
1.28 ~ —— 按位取反运算符
按位取反运算符：对数据的每个二进制位取反，即把1变为0，把0变为1。~x类似于 -x-1。

【示例1】输出按位取反的结果。

a = 0b00111100
# 说明：~a 的结果是1100 0011，转化为补码为10111101，转化十进制为-61。
print(~a)  # -61
1
2
3
1.29 << —— 左移动运算符
左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。

【示例1】输出左移动运算的结果。

a = 0b00111100
# 说明：在数字x上左移y比特得到x * (2**y)。
print(f'a的值是{a}')  # a的值是60
print(f'a移动2位的结果是{a << 2}')  # 240
print(f'a移动3位的结果是{a << 3}')  # 480
1
2
3
4
5
1.30 >> —— 右移动运算符
右移动运算符：把">>“左边的运算数的各二进位全部右移若干位，”>>"右边的数指定移动的位数。如果符号位为0，则右移后高位补0，如果符号位为1，则高位补1。

【示例1】输出右移动运算的结果。

a = 0b00111100

# 说明：在数字x上右移y比特得到x / (2**y)。这里取的是商，不要余数。
print(f'a的值是{a}')  # 60
print(f'a移动2位的结果是{a >> 2}')  # 15
print(f'a移动3位的结果是{a >> 3}')  # 7
1
2
3
4
5
6
1.31 in —— 在指定的序列中查找
“in”运算符表示在指定的序列中如果查找到值返回True，否则返回False。

【示例1】判断字符是否在字符串中。

str_val = 'AmoXiang'
print('A' in str_val)  # True
print('Am' in str_val)  # True
print('ma' in str_val)  # False
1
2
3
4
【示例2】判断元素是否在元组中。

tuple_val = (1, (2, 3), 4, 5)
print(1 in tuple_val)  # True
print((4, 5) in tuple_val)  # False
print((2, 3) in tuple_val)  # True
1
2
3
4
【示例3】判断元素是否在列表中。

list_val = [1, (2, 3), 4, 5]
print(2 in list_val)  # False
print([4, 5] in list_val)  # False
print((2, 3) in list_val)  # True
1
2
3
4
【示例4】判断元素是否在字典中。

dict_val = {'name': 'Amo', 'age': 18}
print('name' in dict_val)  # True
print('age' in dict_val)  # True
print('Amo' in dict_val)  # False
1
2
3
4
【示例5】判断元素是否在集合中。

set_val = {1, 2, 3, 'Amo', (1, 2, 3)}
print(1 in set_val)  # True
print((1, 2) in set_val)  # False
print('Amo' in set_val)  # True
print((1, 2, 3) in set_val)  # True
1
2
3
4
5
1.32 not in —— 在指定的序列中查找
“not in”运算符表示如果在指定的序列中没有找到值返回True，否则返回False。它与“in”操作符是逆操作。

【示例1】删除列表中的重复元素。

numbers = [2, 2, 4, 6, 3, 4, 6, 1]
uniques = []
for number in numbers:
    if number not in uniques:
        uniques.append(number)
# [2, 4, 6, 3, 1]
print(uniques)
1
2
3
4
5
6
7
【示例2】判断字符串信息是否合法。在注册网站时，需要用户填写“真实姓名”、“手机号”和“密码”3个字段。使用“not in”操作符，完成判断用户填写的注册信息是否正确，代码如下：

res = []
# 判断是否填写完全
if 'truename' not in res or 'phone' not in res or 'password' not in res:
    print('必须填写真实姓名、手机号和密码')
1
2
3
4
1.33 is —— 判断两个标识是否引自同一个对象
is是判断两个标识符是不是引用自一个对象。如果引用的是同一个对象则返回True，否则返回False。

【示例1】判断空字符串、空元组和空列表是否为None。

def test_none(val):
    if val is None:
        print(f'{val} is None')
    else:
        print(f'{val} is not None')

test_none('')  # is not None
test_none(())  # () is not None
test_none([])  # [] is not None
test_none(test_none(''))  # None is None
1
2
3
4
5
6
7
8
9
10
11
1.34 is not —— 判断两个标识是否引自同一个对象
is not 是判断两个标识符是不是引用自不同对象，如果引用的不是同一个对象则返回结果True，否则返回False。

【示例1】判断是否开启调试模式。

class Test(object):
    def run(self, debug=None):
        if debug is not None:
            self.debug = bool(debug)

test = Test()
test.run(debug=True)
if test.debug:
    print('调试模式已开启')
else:
    print('调试模式已关闭')
1
2
3
4
5
6
7
8
9
10
11
12
【示例2】使用is not 避免隐式判断错误。在if表达式中，if is和if not会把后面的对象自动隐式转化为布尔型数据。在某些情况下会导致难以发现的错误。例如下面的代码：

def pay(name, salary=None):
    if not salary:
        salary = 8

    print(f'{name}的钟点工工薪水是{salary}元')

pay("Amo", 0)
1
2
3
4
5
6
7
8
程序执行结果如下：

这是为什么？因为函数接受 salary 参数时，为其赋值 0。此时，if not salary为 True，所以继续执行if语句。下面使用 is not 对函数进行修改，避免隐式转换导致的错误。代码如下：

def pay(name, salary=None):
    if salary is None:
        salary = 8

    print(f'{name}的钟点工工薪水是{salary}元')

pay("Amo", 0)  # Amo的钟点工工薪水是0元
1
2
3
4
5
6
7
8
二、流程控制
2.1 if 语句–简单的条件判断
有时候，我们需要在满足某种条件时进行一些操作，而不满足条件时就不进行任何操作，这个时候我们可以只使用 if 语句。Python 中使用 if 关键字来组成最简单的选择语句，if 语句的基本形式如下：

if 表达式:
    语句块
1
2
如果判断条件成立就执行语句块，否则直接跳过。

【示例1】实现“如果…就”形式的判断。通过if语句实现如果年龄小于12岁，就不可以玩《王者荣耀》游戏功能。要求输入年龄，使用if语句判断是否小于12，如果小于，则提示“抱歉，您的年龄太小，不适合玩《王者荣耀》游戏！”，代码如下：

age = int(input('请输入您的年龄：'))
if age < 12:  # 如果年龄小于12岁
    print('抱歉，您的年龄太小，不适合玩《王者荣耀》游戏！')
1
2
3
程序运行结果如下图所示：

【示例2】使用 and 连接条件的判断。如年龄在 18 周岁以上，70 周岁以下，可以申请小型汽车驾驶证。可以分解为两个条件：年龄在 18 周岁以上，即年龄>=18；70周岁以下，即年龄<=70。使用 and 来实现满足这两个条件的判断，输入年龄>=18，年龄<=70，使用print()函数输出“您可以申请小型汽车驾驶证！”，代码如下：

age = int(input('请输入您的年龄：'))  # 输入年龄
# 简写
# if 18 <= age <= 70:
if age >= 18 and age <= 70:  # 输入年龄是否在18--70之间
    print('您可以申请小型汽车驾驶证！')
1
2
3
4
5
程序运行结果如下图所示：

【示例3】使用 or 连接条件的判断。将日销量低于10的商品，高于100的商品，列为重点关注商品。使用 or 来实现两个条件的判断，输入日销量<10或者输入日销量>100，使用 print() 函数输出“该商品为重点关注商品！”，代码如下：

sales = int(input('请输入商品日销量：'))  # 输入商品日销量
if sales < 10 or sales > 100:  # 判断条件
    print('该商品为重点关注商品！')
1
2
3
程序运行结果如下图所示：

【示例4】 if 语句和 if…else 语句嵌套。要求输入一个整数，先使用 if 语句判断是否为有效整数，如果是，则将其转换为整型，再使用 if…else 语句验证是否在 0~150 之间，如果在，则输出该数字，否则提示，代码如下：

number = input('请输入一个整数：')
if number.isdigit():  # 外层if语句
    number = int(number)
    if 0 <= number <= 150:  # 内层if语句
        print(number)
    else:
        print('不是有效的成绩！')
1
2
3
4
5
6
7
程序运行结果如下图所示：

【示例5】if 语句、if…else 和 while 语句嵌套。编写一个 while 死循环，在该循环中，要求输入一个整数，先使用 if 语句判断是否为有效整数，如果是，则将其转换为整型，再使用 if…else 语句验证是否在 0~150 之间，如果在，则输出该数字，并且跳出循环，否则提示并且进行下一次循环，代码如下：

while True:  # 外层for循环
    number = input('请输入一个整数：')
    if number.isdigit():  # 外层if语句
        number = int(number)
        if 0 <= number < 150:  # 内层if语句
            print(number)
            break  # 跳出循环
        else:
            print('不是有效的成绩，请重新输入！')
1
2
3
4
5
6
7
8
9
程序运行结果如下图所示：

【示例6】if 语句和 for 语句嵌套。使用 for 语句循环遍历字符串，在循环体中，使用 if 语句判断当前字符是否已经获取，如果没有获取，则添加到新字符串中，最后输出新字符串，从而达到去除重复字符的目的，代码如下：

name = '张王李王陈张李王陈王张'
newname = ''
for char in name:  # 外层for循环
    if char not in newname:  # 内层if语句
        newname += char
print(newname)
1
2
3
4
5
6
程序运行结果如下图所示：

2.2 if…else 语句 --二分支条件判断
在 Python 中使用 if…else 语句根据给定的条件进行判断，并根据判定的结果(真或假)来执行相应的操作，if…else 语句的语法格式如下：

if 表达式:
    语句块1
else:
    语句块2
1
2
3
4
其中，if 意为“如果”，else 意为“否则”，用来对条件进行判断，如果满足条件，则执行 if 后面的语句块1，否则，执行 else 后面的语句块2。使用 if…else 语句时，表达式可以是一个单纯的布尔值或变量，也可以是比较表达式或逻辑表达式。

【示例1】实现“如果…就…否则…”形式的判断。使用 if…else 语句判断机动车驾驶人考试科目二是否通过，通过分数为80分。如果分数大于或等于80分，则提示“考试合格！”，否则提示“考试不合格”。代码如下：

record = int(input('请输入机动车驾驶人科目二的考试成绩：'))
if record >= 90:  # 使用if判断是否符合条件
    print('本次成绩', record, '分\n考试合格！')
else:  # 不符合条件
    print('本次成绩', record, '分\n考试不合格！')
1
2
3
4
5
【示例2】嵌套的 if…else 语句。“逢七哈哈”游戏的规则是：遇到以数字7结尾的数或者是7的位数时，说“哈哈”，否则直接说出该数字。下面通过嵌套的if…else语句实现输入一个数字，根据该规则输出相应的内容，代码如下：

number = input('请输入一个整数：')  # 输入要判断的数字
if int(number) % 7 == 0:  # 判断是否为7的倍数
    print('哈哈')
else:
    if number.endswith('7'):  # 判断是否以7结尾
        print('哈哈')
    else:
        print(number)
1
2
3
4
5
6
7
8
【示例3】if…else 语句与 while 语句嵌套。将学生信息保存在字典中，使用 if 语句判断是否有要查找的学生信息，如果找到通过 while 语句循环输入并修改学生的信息，当全部输入并且没有出错时，跳出循环，显示修改结果，代码如下：

student = {'id': '1001', 'name': '无语', 'english': 98, 'python': 100, 'c': 96}
student_id = input('请输入要修改的学生ID号：')
if student['id'] == student_id:  # 判断是否为要修改的学生
    print('找到了这名学生，可以修改他的信息！')
    while True:  # 输入要修改的信息
        try:
            student['name'] = input('请输入姓名：')
            student['english'] = int(input('请输入英语成绩：'))
            student['python'] = int(input('请输入Python成绩：'))
            student['c'] = int(input('请输入C语言成绩：'))
        except Exception as e:
            print('您的输入有误，请重新输入。')
        else:
            break  # 跳出循环
    print(student)
    print('修改成功！')
else:
    print('没有找到该学生的相关信息！')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
程序运行结果如下图所示：

【示例4】if…else 语句与 for 语句嵌套。使用 if…else 语句与 for 语句嵌套实现当列表不为空时遍历学生信息并输出，如果列表为空，则给出提示，代码如下：

student = [{'id': '1001', 'name': '无语', 'english': 98, 'python': 100, 'c': 96},
           {'id': '1002', 'name': '琦琦', 'english': 100, 'python': 96, 'c': 97}]
if student:  # 外层if语句
    for s in student:  # 内层for语句
        print(s['id'], '的名字是', s['name'], 'English成绩是', s['english'],
              'Python成绩是', s['python'], 'C语言成绩是', s['c'])
else:
    print('没有学生信息！')
1
2
3
4
5
6
7
8
程序运行结果如下图所示：

【示例1】实现“如果…否则如果…否则如果…”形式的判断（类似Java中的Switch语句）。根据空气质量指数输出相应的空气质量状况，参考下表所示的空气质量指数范围及空气质量状况对应表，输入你所在城市的空气质量指数，判断空气质量状态。

代码如下：

aqi = int(input('请输入你所在城市的空气质量指数：'))  # 定义整型变量aqi表示空气质量指数
if 0 <= aqi <= 50:
    print('空气质量状况：优秀')
elif 51 <= aqi <= 100:
    print('空气质量状况：良好')
elif 101 <= aqi <= 150:
    print('空气质量状况：轻度污染')
elif 151 <= aqi <= 200:
    print('空气质量状况：中度污染')
elif 201 <= aqi <= 300:
    print('空气质量状况：重度污染')
else:
    print('空气质量状况：严重污染')
1
2
3
4
5
6
7
8
9
10
11
12
13
【示例2】while 和 if…elif…else 语句嵌套。根据身高、体重计算身体质量指数，身体质量指数（BMI，Body Mass Index）是国际上常用的衡量人体肥胖程度和是否健康的重要标准，BMI=体重/身高2，下表为BMI指数中国参考标准。

创建一个 while 死循环，在该循环中，定义两个变量：一个用于记录身高（单位：米），另一个用于记录体重（单位：千克），根据公式计算BMI指数，判断体重状况，代码如下：

while True:
    height = float(input('请输入您的身高（单位：米）：'))  # 输入身高
    weight = float(input('请输入您的体重（单位：千克）：'))  # 输入体重
    bmi = weight / (height * height)  # 计算BMI指数
    # 判断体体重状况
    if bmi < 18.5:
        print('您的BMI指数为：' + str(bmi))  # 输出BMI指数
        print('偏瘦 ~@_@~')
    elif bmi < 23.9:
        print('您的BMI指数为：' + str(bmi))  # 输出BMI指数
        print('正常 (-_-)')
    elif bmi < 28:
        print('您的BMI指数为：' + str(bmi))  # 输出BMI指数
        print('偏胖 ~@_@~')
    else:
        print('您的BMI指数为：' + str(bmi))  # 输出BMI指数
        print('肥胖 ^@_@^')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
【示例3】while、if 和 if…elif…else 语句嵌套。使用 if…elif…else 语句实现判断用户选择的菜单项，代码如下：

import re  # 导入正则表达式模块

def menu():
    # 输出菜单
    print('''
    X―――――――学生信息管理系统――――――――[
    │                                              │
    │   =============== 功能菜单 ============   │
    │                                              │
    │   1 录入学生信息                             │
    │   2 查找学生信息                             │
    │   3 删除学生信息                             │
    │   4 修改学生信息                             │
    │   5 排序                                     │
    │   6 统计学生总人数                           │
    │   7 显示所有学生信息                         │
    │   0 退出系统                                 │
    │  ======================================  │
    │  说明：通过数字或↑↓方向键选择菜单          │
    ^―――――――――――――――――――――――a
    ''')

if __name__ == '__main__':
    flag = True  # 开关管控
    while flag:
        menu()  # 显示菜单
        option = input('请选择：')  # 选择菜单项
        option_str = re.sub(r'\D', '', option)  # 提取数字
        if option_str in ['0', '1', '2', '3', '4', '5', '6', '7']:  # 外层if语句
            option_int = int(option_str)
            if option_int == 0:  # 内层if语句
                print('您已退出学生成绩管理系统！')
                flag = False
            elif option_int == 1:  # 录入学生成绩信息
                # 这里具体去实现每一个函数就可以了
                # TODO 1.insert()
                # insert() ==> 用于学生成绩信息录入
                print('录入学生成绩信息')
            elif option_int == 2:  # 查找学生成绩信息
                # TODO 2
                print('查找学生成绩信息')
            elif option_int == 3:  # 删除学生成绩信息
                print('删除学生成绩信息')
            elif option_int == 4:  # 修改学生成绩信息
                print('修改学生成绩信息')
            elif option_int == 5:  # 排序
                print('排序')
            elif option_int == 6:  # 统计学生总数
                print('统计学生总数')
            elif option_int == 7:  # 显示所有学生信息
                print('显示所有学生信息')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
2.3 if…elif…else 语句–多分支条件判断
在开发程序时，常常遇到多选一的情况，则可以使用 if…elif…else 语句，该语句是一个多分支选择语句，if…elif…else 语句的语法格式如下：

if 表达式1:
    语句块1
elif 表达式2:
    语句块2
elif 表达式3:
    语句块3
…
else:
    语句块n
1
2
3
4
5
6
7
8
9
其中，elif 是 else if 的缩写，使用 if…elif…else 语句时，首先对 if 语句中的表达式1进行判断，如果表达式1的结果为真，则执行语句块1，然后跳过 elif 语句和 else 语句；如果表达式1的结果为假，则不执行语句块1，而进行下一个 elif 的判断，判断 elif 语句中的表达式2。如果表达式2为真，那么执行语句块2而不会执行后面的 elif 语句和 else 语句。当所有的判断都不成立，也就是都为假时，才会执行 else 后的语句块。使用 if…elif…else 语句时，表达式可以是一个单纯的布尔值或变量，也可以是比较表达式或逻辑表达式。

2.4 for 语句–循环
for 语句是一个依次重复执行的循环。通常适用于枚举或遍历序列，以及迭代对象中的元素。for 语句的语法格式如下：

for 迭代变量 in 对象:
    循环体
1
2
参数说明：

迭代变量：用于保存读取出的值；
对象：要遍历或迭代的对象，如字符串、列表、元组、字典等数据结构；
循环体：为一组被重复执行的语句。
【示例1】想要实现从1到100的累加，可以通过下面的代码实现：

result = 0  # 保存累加结果的变量
for i in range(101):
    result += i  # 实现累加功能

print('1+2+3+……+100的结果为：', result)  # 在循环结束时输出结果
1
2
3
4
5
【示例2】指定范围和步长的数值循环：

for i in range(1, 10, 2):
    print(i, end=' ')  # 1 3 5 7 9 
1
2
【示例3】遍历字符串：

str1 = '莫轻言放弃'
for s in str1:
    print(s)
1
2
3
【示例4】遍历整个列表：

print('福布斯2018全球富豪榜前五名:')
name = ['杰夫・贝佐斯', '比尔・盖茨', '沃伦•巴菲特', '伯纳德・阿诺特', '阿曼西奥・奥特加']
for item in name:
    print(item)
1
2
3
4
【示例5】 通过for语句和enumerate()函数实现带编号输出：

print('福布斯2018全球富豪榜前八名:')
name = ['杰夫・贝佐斯', '比尔・盖茨', '沃伦•巴菲特', '伯纳德・阿诺特', '阿曼西奥・奥特加']
for index, item in enumerate(name):
    print(index + 1, item)
1
2
3
4
【示例6】切片遍历列表：

phonename = ['华为', 'vivo', '小米', 'OPPO', '三星']  # 定义列表
for name in phonename[1:4]:  # 切片遍历列表
    print(name)  # 输出列表元素的值
1
2
3
【示例7】遍历元组：

musicname = ('Better Off', 'Going Home', 'Breeze', 'The Spectre')  # 定义元组
for name in musicname:  # 遍历元组
    print(name)  # 输出每个元组元素的值
1
2
3
【示例8】遍历集合：

setname = {'麻省理工学院', '斯坦福大学', '哈佛大学', '加州理工学院', '牛津大学'}
print('世界著名大学排名：')
for i in setname:
    print('☛', i)
1
2
3
4
【示例9】遍历字典的key-value（键值对）：

dictionary = {'无语': '5月25日', '琦琦': '10月8日', '碧海苍梧': '7月27日', }
for key, value in dictionary.items():
    print(key, '的生日为', value)
1
2
3
【示例10】for语句与for语句嵌套

row = 5  # 行数
for i in range(1, row + 1):  # 控制行数
    for j in range(row - i):  # 控制每行的空格数
        print(" ", end="")  # 不换行
    for j in range(1, 2 * i):  # 控制每行显示的*号数
        print("*", end="")  # 不换行
    print("")  # 强制换行
1
2
3
4
5
6
7
【示例11】for语句与if语句嵌套

print('Python的应用领域：')
fields = ['数据分析', '网络爬虫', 'Web 开发', '游戏开发', '云 计 算', '人工智能']
for index, fields in enumerate(fields):  # for语句
    if index % 2 == 0:  # if语句
        print(fields, end='\t')
    else:
        print(fields)
1
2
3
4
5
6
7
【示例12】for语句与while语句嵌套

row = 5  # 行数
for i in range(1, row + 1):  # 控制行数
    a = 1
    while a <= i:
        print('*', end='')  # 不换行
        a += 1
    print('')  # 强制换行
1
2
3
4
5
6
7
2.5 for…else 语句–循环
for…else 语句是在 for 语句的基本上添加了一个 else 子句，用于当循环条件不满足时，执行指定代码。for 语句的语法格式如下：

for 迭代变量 in 对象:
    循环体
else:
    语句块
1
2
3
4
参数说明：

迭代变量：用于保存读取出的值；
对象：要遍历或迭代的对象，如字符串、列表、元组、字典等数据结构；
循环体：为一组被重复执行的语句。
语句块：循环条件不满足后执行的一组语句。如果使用 break 语句中止循环，则不执行。
【示例1】for…else 语句的基本应用。实现从 1~100 的累加，并且在 else 子句中输出累加结果，代码如下：

result = 0  # 保存累加结果的变量
for i in range(101):
    result += i  # 实现累加功能
else:
    print('1+2+3+……+100的结果为：', result)  # 在循环结束时输出结果
1
2
3
4
5
【示例2】嵌套的 for…else 语句。使用嵌套的 for…else 语句输出 20 以内的全部质数，代码如下：

for i in range(1, 20):  # 循环语句
    for j in range(2, i):
        if i % j == 0:  # 如果一个数能被除1和它本身之外的数整除，则它不是质数
            break  # 跳出for循环
    else:
        print(i, end='  ')  # 输出质数
else:
    print('是质数。')
1
2
3
4
5
6
7
8
【示例3】在 for…else 语句中，当循环条件不满足时，执行 else 子句，但是如果使用 break 语句中止循环，则不执行else子句，代码如下：

menu = ['1', '2', '3', '4', '5', '6', '0']  # 菜单编号
for opt in menu:  # 循环语句
    if opt == '0':
        print('找到了退出菜单！')
        break  # 跳出for循环       
else:
    print('没有找到相应菜单！')
1
2
3
4
5
6
7
2.6 while 语句–循环
while 语句是通过一个条件来控制是否要继续反复执行循环体中的语句。while 语句的语法格式如下：

初始化语句 # 类似于 i=0
while 条件表达式:
    循环体
    条件控制语句  # 类似于 i+=1
1
2
3
4
当条件表达式的返回值为真时，则执行循环体中的语句，执行完毕后，重新判断条件表达式的返回值，直到表达式返回的结果为假时，退出循环。

【示例1】使用 while 语句实现固定次数的循环。使用 while 语句计算 1~100 偶数之和，代码如下：

num = 1
result = 0
while num <= 100:  # while循环条件
    if num % 2 == 0:
        result += num
    num += 1  # 变量自加
print('1~100偶数之和为:', result)
1
2
3
4
5
6
7
【示例2】使用while语句实现不定次循环（while语句与if语句嵌套）。使用 while 语句，实现猜数字游戏，代码如下：

import random  # 导入随机数模块

number = random.randint(1, 100)  # 生成1~100之间的随机整数
while True:  # 无限循环
    value = int(input('请输入100以内的数字：'))  # 输入数字
    if value > number:
        print('高了')
    elif value < number:
        print('低了！')
    else:
        print('恭喜您，猜对了！')
        break  # 退出循环
1
2
3
4
5
6
7
8
9
10
11
12
【示例3】使用while语句与while语句嵌套。使用 while 语句与 while 语句嵌套输出九九乘法表，代码如下：

i = 1  # 初始值
while i <= 9:  # 外层循环（控制行数）
    j = 1
    while j < i + 1:  # 内层循环（控制列数）
        result = i * j
        print(str(i) + '*' + str(j) + '=', i * j, end='\t')  # 不换行
        j += 1
    print('')  # 强制换行
    i += 1
1
2
3
4
5
6
7
8
9
【示例4】使用while语句与for语句嵌套。在应用 pygame 模块开发游戏时，经常需要使用 while 语句与 for 语句嵌套实现控制窗体的关闭，代码如下：

import pygame  # 导入Pygame库
import sys  # 导入系统模块

pygame.init()  # 初始化Pygame
screen = pygame.display.set_mode((320, 240))  # 显示窗口
while True:  # 外层while循环
    # 获取单击事件
    for event in pygame.event.get():  # 内层for循环
        if event.type == pygame.QUIT:  # 如果单击了关闭窗体就将窗体关闭
            pygame.quit()  # 退出窗口
            sys.exit()  # 关闭窗口
1
2
3
4
5
6
7
8
9
10
11
2.7 while…else 语句–循环
while…else 语句是在 while 语句的基本上添加了一个 else 子句，用于当循环条件不满足时，执行指定代码。while…else 语句的语法格式如下：

初始化语句 # 类似于 i=0
while 条件表达式:
    循环体
    条件控制语句  # 类似于 i+=1
else:
    语句块
1
2
3
4
5
6
当条件表达式的返回值为真时，则执行循环体中的语句，执行完毕后，重新判断条件表达式的返回值，直到表达式返回的结果为假时，执行语句块中的语句。

【示例1】使用 while 语句实现不定次循环时输出循环次数。使用 while 语句，实现猜数字游戏，要求每次只有5次机会，当机会用完，还没有猜对时，结束程序并且提示“您的机会已用完。”，代码如下：

import random  # 导入随机数模块

number = random.randint(1, 100)  # 生成1~100之间的随机整数
count = 0  # 次数
while count < 5:  # 无限循环
    count += 1
    value = int(input('请输入100以内的数字：'))  # 输入数字
    if value > number:
        print('高了')
    elif value < number:
        print('低了！')
    else:
        print('恭喜您，猜对了！')
        break  # 退出循环
else:
    print('您的机会已用完。')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
说明：else 子句只有当循环条件不满足时，才会被执行，使用 break 语句跳出循环时，不会被执行。

2.8 break 语句–终止当前循环
break 语句用来终止循环，即循环条件成立或者序列还没被完全递归完，也会停止执行循环语句。break 语句的常用语法格式如下：

if 条件表达式:
    break
1
2
其中，条件表达式用于判断何时调用 break 语句跳出循环。

【示例1】在 for 语句中使用 break 语句。

for i in range(1, 11):
    if i == 5:
        break  # break语句终止循环
    print(i, end=' ')
1
2
3
4
【示例2】在 while 循环中使用 break 语句。

num = 10
while True:  # while循环条件
    num -= 1  # 变量自加
    print(num)  # 输出num的值
    if num <= 6:
        break
1
2
3
4
5
6
2.9 continue 语句–终止本次循环进入下一次循环
continue 语句在语句块执行过程中直接跳到循环的下一次迭代。即终止当前循环，而执行下一次循环。continue 语句的语法格式如下：

if 条件表达式:
    continue
1
2
其中，条件表达式用于判断何时调用 continue 语句跳出循环。

【示例1】在 for 语句中使用 continue 语句

for i in range(1, 11):
    if i == 2 or i == 8:
        continue  # continue语句跳出本次循环，继续下一次循环
    print(i, end=' ')
1
2
3
4
【示例2】在 while 循环中使用 continue 语句

num = 0  # 定义变量并赋初值
while num < 5:
    num += 1  # 改变变量的值
    if num == 2:
        continue
    print('sum的值为:', num)  # 输出sum的值
1
2
3
4
5
6
注意：break 语句和 continue 语句只能用在循环中，break 语句和 continue 语句在循环嵌套中，只对最近的一层循环起作用。

2.10 条件表达式(三目运算符、三元表达式)
条件表达式是 Python 选择语句中比较简练的一种赋值方式，常用于赋值语句中，其基本格式为：

a if b else c
1
如果判定条件 b 为真，返回为真时的结果 a，否则，返回为假时的结果 c。

【示例1】应用条件表达式比较大小。

num1 = 100
num2 = 78
large = num1 if num1 > num2 else num2  # 求较大数
print('%d和%d %d较大。' % (num1, num2, large))
small = num1 if num1 < num2 else num2  # 求较小数
print('%d和%d %d较小。' % (num1, num2, small))
1
2
3
4
5
6
使用条件表达式时，先计算中间的条件（num1>num2），如果结果为 True，返回 if 语句左边的值（num1），否则返回 else 右边的值（num2）。例如上面求较大数的表达式，当结果为真时，则返回 num1 的值，即结果为100。

【示例2】应用条件表达式根据计算结果返回不同的信息。使用条件表达式判断一个数能否被2整除，并根据结果返回是奇数还是偶数，代码如下：

number = int(input('请输入一个数：'))
result = '奇数' if number % 2 == 1 else '偶数'  # 条件表达式
print(number, '是' + result)
1
2
3
【示例3】应用条件表达式处理自定义函数的可选参数。

def demo(param=None):
    return '没有指定参数' if param is None else 'param参数值为――' + param

print(demo())  # 调用函数不指定参数
print(demo('莫轻言放弃'))  # 调用函数并指定参数
1
2
3
4
5
6
【示例4】使用多条件的条件表达式。使用条件表达式返回输入的年份是否为闰年，代码如下：

year = int(input('请输入一个数：'))
result = '闰年' if (year % 4 == 0 and year % 100 != 0) or year % 400 == 0 else '不是闰年'
print(year, result)
1
2
3
三、函数
3.1 def 语句–自定义函数
使用 def 关键字可以实现定义一个函数，具体的语法格式如下：

def functionname([parameterlist]):
    ['''comments''']
    [functionbody]
    [return]
1
2
3
4
参数说明如下：

functionname：函数名称，在调用函数时使用。
parameterlist：可选参数，用于指定向函数中传递的参数。如果有多个参数，各参数间使用逗号 , 分隔。如果不指定，则表示该函数没有参数。在调用时，也不指定参数。
return。在函数体内，一旦执行 return 语句，函数将返回结果，并立即停止函数的运行。如果没有 return 语句，执行完函数体内所有的代码后，也会返回特殊值(None)。如果明确让函数返回 None，可以写为 ⇒ return None/return 都可。
comments：可选参数，表示为函数指定注释，注释的内容通常是说明该函数的功能、要传递的参数的作用等，可以为用户提供友好提示和帮助的内容。说明：在定义函数时，如果指定了 '''comments''' 参数，那么在调用函数时，输入函数名称及左侧的小括号时，就会显示该函数的帮助信息。这些帮助信息就是通过定义的注释提供的。
functionbody：可选参数，用于指定函数体，即该函数被调用后，要执行的功能代码。
注意：函数体“functionbody”和注释 comments相对于def关键字必须保持一定的缩进。

【示例1】定义一个空函数。如果想定义一个什么也不做的空函数，可以使用pass语句作为占位符。代码如下：

def empty_fun():
    pass
1
2
【示例2】定义并调用一个函数。定义一个根据身高、体重计算 BMI 指数的函数 fun_bmi()，该函数包括 3 个参数，分别用于指定姓名、身高和体重，再根据公式：BMI=体重/（身高×身高）计算BMI指数，并输出结果，代码如下：

def fun_bmi(person, height, weight):
    """功能：根据身高和体重计算BMI指数
       person：姓名
       height：身高，单位：米
       weight：体重，单位：千克
    """
    print(person + '的身高：' + str(height) + '米 \t 体重：' + str(weight) + '千克')
    bmi = weight / (height * height)  # 用于计算BMI指数，公式为“体重/身高的平方”
    print(person + '的BMI指数为：' + str(bmi))  # 输出BMI指数
    # 判断身材是否合理
    if bmi < 18.5:
        print('偏瘦 ~@_@~')
    elif bmi < 23.9:
        print('正常 (-_-)')
    elif bmi < 28:
        print('偏胖 ~@_@~')
    else:
        print('肥胖 ^@_@^')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
调用刚刚创建的 fun_bmi() 函数，可以使用下面的代码。

fun_bmi("Amo", 1.76, 50)  # 计算匿名的BMI指数
1
调用 fun_bmi() 函数后，将显示如下运行结果。

在使用上面的方法调用自定义函数时，指定的参数顺序必须和定义时的一致。如果想改变传递顺序，在调用自定义函数时，也可以通过关键字参数指定各参数值，这样就可以不按定义时的参数位置来传递各参数的值了。例如，可以把上面调用 fun_bmi() 函数的代码修改为以下代码。

fun_bmi(height=1.76, weight=50, person='Amo')  # 计算匿名的BMI指数
1
说明：通过上面的代码调用 fun_bmi() 函数后，也将显示调用方法一的结果。敲重点，函数不调用不执行！

【示例3】定义并调用带默认值的函数。定义一个根据身高、体重计算BMI指数的函数fun_bmi()，该函数包括3个带默认值的参数，分别用于指定姓名、身高和体重，再根据公式：BMI=体重/（身高×身高）计算BMI指数，并输出结果，代码如下：

def fun_bmi(person='佚名', height=1.70, weight=60):
    """功能：根据身高和体重计算BMI指数
       person：姓名
       height：身高，单位：米
       weight：体重，单位：千克
    """
    print(person + '的身高：' + str(height) + '米 \t 体重：' + str(weight) + '千克')
    bmi = weight / (height * height)  # 用于计算BMI指数，公式为“体重/身高的平方”
    print(person + '的BMI指数为：' + str(bmi))  # 输出BMI指数
    # 判断身材是否合理
    if bmi < 18.5:
        print('偏瘦 ~@_@~')
    elif bmi < 23.9:
        print('正常 (-_-)')
    elif bmi < 28:
        print('偏胖 ~@_@~')
    else:
        print('肥胖 ^@_@^')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
调用 fun_bmi() 函数，各参数值都采用默认，代码如下：

fun_bmi()  # 调用指定默认值的函数不指定参数值
fun_bmi('零语', 1.65, 55)  # 调用指定默认值的函数时指定参数值
1
2
调用 fun_bmi() 函数后，将显示如下运行结果。

说明：在自定义函数时，如果即包含普通参数又包含带默认值的参数，那么带默认值的参数需要放在普通参数的后面。

【示例4】定义并调用带可变参数*args的函数。定义一个根据身高、体重计算BMI指数的函数fun_bmi()，该函数只包括一个可变参数，用于指定测试人的姓名、身高和体重，再根据公式：BMI=体重/（身高×身高）计算测试人的BMI指数，并输出结果，代码如下：

def fun_bmi(*args):
    """功能：根据身高和体重计算BMI指数
       * person：可变参数，需传递带3个元素的元组
                 分别为姓名、身高（单位：米）、体重（单位：千克）
    """
    for item in args:
        print('%s %s %s' % ('=' * 13, item[0], '=' * 13))
        print('身高：%s 米 \t 体重：%s 千克' % (item[1], item[2]))
        bmi = item[2] / (item[1] * item[1])  # 用于计算BMI指数，公式为“体重/身高的平方”
        print('BMI指数为：%f' % bmi)  # 输出BMI指数
1
2
3
4
5
6
7
8
9
10
说明：在上面的代码中，item为传递的元组，它的第一个元素为姓名（通过item[0]获取）、第二个元素为身高（通过item[1]获取），第三个元素为体重（通过item[2]获取）。

通过下面两种方法调用上面的 fun_bmi() 函数都可以计算两位测试人的 BMI 指数。

fun_bmi(('绮梦', 1.70, 60), ('零语', 1.78, 62))
list_person = [('绮梦', 1.70, 60), ('零语', 1.78, 62)]

fun_bmi(*list_person)  # 使用已有的列表作为函数的可变参数
1
2
3
4
运行结果如下。

【示例5】定义并调用带可变参数**kwargs的函数。定义一个根据身高、体重计算BMI指数的函数fun_bmi()，该函数只包括一个关键字可变参数，用于指定测试人的姓名、身高和体重，再根据公式：BMI=体重/（身高×身高）计算测试人的BMI指数，并输出结果，代码如下：

def fun_bmi(**kwargs):
    """功能：根据身高和体重计算BMI指数
       * person：可变参数，需传递带3个元素的元组
                 分别为姓名、身高（单位：米）、体重（单位：千克）
    """
    for value in kwargs.values():  # 遍历字典中的值
        print('%s %s %s' % ('=' * 13, value[0], '=' * 13))
        print('身高：%s 米 \t 体重：%s 千克' % (value[1], value[2]))
        bmi = value[2] / (value[1] * value[1])  # 用于计算BMI指数，公式为“体重/身高的平方”
        print('BMI指数为：%f' % bmi)  # 输出BMI指数
1
2
3
4
5
6
7
8
9
10
说明：在上面的代码中，value 为传递的字典中的值，它的第一个元素为姓名（通过value[0]获取）、第二个元素为身高（通过value[1]获取），第三个元素为体重（通过value[2]获取）。

通过下面两种方法调用上面的 fun_bmi() 函数都可以计算两位测试人的 BMI 指数。

fun_bmi(p1=('绮梦', 1.70, 60), p2=('零语', 1.78, 62))

dict_person = {'p1': ('绮梦', 1.70, 60), 'p2': ('零语', 1.78, 62)}
fun_bmi(**dict_person)  # 使用已有的字典作为函数的可变参数
1
2
3
4
运行结果如下：

【示例6】定义并调用带可变参数*args和普通参数结合的函数。定义一个包括可变参数*args和普通参数结合的自定义函数，在函数中，输出普通参数以及遍历输出可变参数的值，代码如下：

def print_coffee(*args, name):
    print('欢迎光临%s咖啡馆~\n我店的咖啡有：' % name)
    for item in args:  # 遍历输出可变参数*args的值
        print(item)
1
2
3
4
调用自定义 print_coffee() 函数，传递可变参数和普通参数，代码如下：

print_coffee('蓝山', '卡布奇诺', '摩卡', '哥伦比亚', name='依米')
1
注意：在定义和调用带可变参数*args和普通参数的函数时，*args需要在前，普通参数在后。

【示例7】定义并调用带可变参数**kwargs和普通参数结合的函数。定义一个包括可变参数**kwargs和普通参数结合的自定义函数，在函数中，输出普通参数以及遍历输出关键字可变参数的值，代码如下：

def print_coffee(name, **kwargs):
    print('欢迎光临%s咖啡馆~\n我店的咖啡有：' % name)
    for item in kwargs.values():
        print(item)
1
2
3
4
调用自定义 print_coffee() 函数，传递普通参数和关键字可变参数，代码如下：

print_coffee('依米', id1='蓝山', id2='卡布奇诺', id3='摩卡', id4='哥伦比亚')
1
注意：在定义和调用带可变参数**kwargs和普通参数的函数时，普通参数需要在前，**kwargs关键字参数在后。

【示例8】定义并调用带返回值的函数。定义一个带返回值的自定义函数，在函数中，输出普通参数以及遍历输出关键字可变参数的值，代码如下：

def area(w, h):
    return w * h
1
2
调用自定义 area() 函数，传递矩形的宽度和高度，并输出返回结果，代码如下：

rect = area(450, 200)
print('矩形面积：', rect)
1
2
3.2 lambda 表达式–匿名函数
在 Python 中，使用 lambda 表达式创建匿名函数，其语法格式如下：

result = lambda [arg1 [,arg2,……,argn]]:expression
1
参数说明如下：

result：用于调用 lambda 表达式。
[arg1 [,arg2,……,argn]]：可选参数，用于指定要传递的参数列表，多个参数间使用逗号 , 分隔。
expression：必选参数，用于指定一个实现具体功能的表达式。如果有参数，那么在该表达式中将应用这些参数。
注意：使用 lambda 表达式时，参数可以有多个，用逗号 , 分隔，但是表达式只能有一个，即只能返回一个值。而且也不能出现其他非表达式语句(如for或while)。

【示例1】实现带参数的匿名函数。使用lambda表达式定义一个带参数的匿名函数，用于计算圆的面积，代码如下：

import math  # 导入math模块
r = 100  # 半径
result = lambda r: math.pi * r * r  # 计算圆的面积的lambda表达式
print('半径为', r, '的圆面积为：', result(r))
1
2
3
4
【示例2】实现带默认值参数的匿名函数。使用lambda表达式定义一个指定参数默认值的匿名函数，用于计算圆的面积，代码如下：

import math  # 导入math模块
result = lambda r=100: math.pi * r * r  # 计算圆的面积的lambda表达式
print('圆面积为：', result())  # 不指定半径
1
2
3
【示例3】在匿名函数后面直接传递参数。使用lambda表达式定义一个计算圆面积的匿名函数，并且在定义时直接在后面指定参数值，代码如下：

import math  # 导入math模块
result = (lambda r: math.pi * r * r)(100)  # 计算圆的面积的lambda表达式
print('圆面积为：', result)  # 不指定半径
1
2
3
【示例4】使用lambda表达式自定义排序规则。

方法一：使用 lambda 表达式指定排序规则为先按字符串的长度排序，当长度相同时再按字母或数字排序（不区分大小写），代码如下：

list1 = ['第6页', '第4页', '第16页', '第7页', '第22页', '第1页']
print('排序前：', list1)
list1.sort(key=lambda x: (len(x), x.lower()))  # 自定义排序规则
print('排序后：', list1)
1
2
3
4
方法二：使用 lambda 表达式指定排序规则为使用正则表达式提取字符串中的数字，再转换为整型排序，代码如下：

import re  # 导入正则表达式模块

list1 = ['第6页', '第4页', '第16页', '第7页', '第22页', '第1页']
print('排序前：', list1)
list1.sort(key=lambda x: (float(re.sub(r'\D', '', x))))  # 自定义排序规则
print('排序后：', list1)
1
2
3
4
5
6
【示例5】将lambda表达式与map()函数结合使用。将lambda表达式作为map()函数的参数实现将列表中的全部英文名字转换为首字母大写，代码如下：

name = ['rose', 'aurora', 'jim', 'lily', 'lucy']
name = map(lambda x: x.capitalize(), name)  # 将列表中的全部英文名字变为首字母大写
print(list(name))
1
2
3
【示例6】将lambda表达式与filter()函数结合使用。使用lambda表达式指定filter()函数的过滤条件，实现过滤掉不符合条件的数据，代码如下：

# 过滤掉重复的元素，只要有重复的就两个都不保留
list1 = ['a', 'b', 'a', 'c']
list2 = filter(lambda x: list1.count(x) == 1, list1)
print(list(list2))
# 保留年龄大于等于18岁的数据
list3 = [('无语', 30), ('琦琦', 10), ('明日', 19)]
list3 = filter(lambda x: x[1] > 18, list3)
print(list(list3))
1
2
3
4
5
6
7
8
【示例7】指定tkinter模块中控件内联的回调（callback）函数。在使用tkinter模块的窗体中，通过lambda表达式为按钮控件指定单击后的回调（callback）函数，代码如下：

import sys  # 导入操作系统模块
from tkinter import Button  # 导入tkinter模块的Button控件

button = Button(text='单击按钮', command=(lambda: sys.stdout.write('愿你的青春不负梦想。\n')))
button.pack()  # 将按钮放置到主窗口中
button.mainloop()  # 进入消息循环
1
2
3
4
5
6
3.3 pass 语句–空语句
pass 是一个空语句，不会输出任何内容，常被用作占位符，防止语法错误。如果循环体或者函数体为空，解释器就会报错。这时可以用 pass 语句来占位，以防止程序报错。pass 语句语法格式如下：

pass
1
【示例1】pass 应用场景合集。示例代码如下：

"""
1.在选择语句中使用pass语句
"""
num = int(input('请输入一个整数：'))  # 输入一个数
if num % 2 != 0:  # 判断是否为奇数
    print(num)
else:  # 不是奇数的情况
    pass  # pass语句，用于占位

"""
2.在循环语句中使用pass语句
"""
menu = ['0', '1', '2', '3', '4', '5', '6']  # 菜单编号
for opt in menu:  # 循环语句
    pass  # 空语句

"""
3.在循环和选择语句中使用pass语句
"""
for i in range(1, 10):
    if i % 2 != 0:  # 判断是否为奇数
        print(i)
    else:  # 不是奇数的情况
        pass  # pass语句，用于占位

"""
4.在自定义函数中使用pass语句
"""

def func():
    pass

"""
5.在创建类时使用pass语句
"""

class Geese:
    pass
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
敲重点：pass 语句和注释之间的区别在于：解释器会完全忽略注释，但不会忽略 pass 语句。

3.4 yield 语句–生成器
yield 语句可以在函数中定义生成器对象。它可以生成一个值的序列，以便于在迭代中使用。使用了 yield 语句的函数（也称生成器函数）与普通函数不同，普通函数调用一次返回一个值（如果没有 return 语句，则返回 None），而生成器函数则会返回一个生成器对象，通过调用该对象的 __next__() 方法，可以不断地执行语句，直到遇到 yield 语句为止，并且在停止的地方生成一个结果。接下来还可以再次调用 __next__() 方法继续执行。

def functionname([parameterlist]):
    functionbody
    yield expression
1
2
3
参数说明如下：

functionname：函数名称，在调用函数时使用。
parameterlist：可选参数，用于指定向函数中传递的参数。如果有多个参数，各参数间使用逗号 , 分隔。如果不指定，则表示该函数没有参数。在调用时，也不指定参数。
functionbody：可选参数，用于指定函数中要执行的代码。
yield expression：用于生成一个结果。
【示例1】使用yield语句实现一个生成器并迭代它。定义一个函数，在该函数中，创建一个死循环，然后在该循环中使用yield语句生成一个结果，然后再创建生成器对象，并且分3次调用它的__next__()方法，代码如下：

def fun():
    i = 0
    while True:
        yield i  # 生成一个结果
        i += 1

f = fun()  # 生成器对象
print(f.__next__())  # 调用生成器对象的__next__()方法
print(f.__next__())  # 调用生成器对象的__next__()方法
print(f.__next__())  # 调用生成器对象的__next__()方法
1
2
3
4
5
6
7
8
9
10
11
从上面的结果中可以看出，虽然在函数中使用了死循环，但是并没有出现死循环，这是因为调用函数后，代码并不会开始执行，而是在调用 __next__() 方法时才开始执行，并且在遇到 yield 语句后，程序便会停下来，直到下次调用 __next__() 方法。

【示例2】使用yield语句实现一个输出古诗内容的生成器。

str1 = "千山鸟飞绝"
str2 = "万径人踪灭"
str3 = "孤舟蓑笠翁"
str4 = "独钓寒江雪"

def fun():
    verse = [list(str1), list(str2), list(str3), list(str4)]  # 定义一个二维列表
    print("\n-- 横版 --\n")
    for i in range(4):  # 循环古诗的每一行
        for j in range(5):  # 循环每一行的每个字（列）
            if j == 4:  # 如果是一行中的最后一个字
                yield verse[i][j] + '\n'  # 换行输出
            else:
                yield verse[i][j]  # 不换行输出
    verse.reverse()  # 对列表进行逆序排列
    print("\n-- 竖版 --\n")
    for i in range(5):  # 循环每一行的每个字（列）
        for j in range(4):  # 循环新逆序排列后的第一行
            if j == 3:  # 如果是最后一行
                yield verse[j][i] + '\n'  # 换行输出
            else:
                yield verse[j][i]  # 不换行输出

for i in fun():  # 迭代生成器的值
    print(i, end='')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
四、程序调试与异常处理
4.1 assert 语句–应用断言调试程序
assert 的中文意思是断言，它一般用于对程序某个时刻必须满足的条件进行验证。assert 语句的基本语法如下：

assert expression [,reason]
1
参数说明：

expression：条件表达式，如果该表达式的值为真时，什么都不做，如果为假时，则抛出 AssertionError 异常。
reason：可选参数，用于对判断条件进行描述，为了让他人更好地知道出现了什么问题。
【示例1】使用断言调试程序。要求输入一个数字，然后使用 assert 语句对输入的空值抛出异常，代码如下：

number = input('请输入一个数字：')
assert number != '', '不能输入空值！'  # 当值为空时通过断言抛出异常
print('您输入了：', number)
1
2
3
运行程序，什么都不输入，直接按下 <Enter> 键时，将抛出如下图所示的 AssertionError 异常。

【示例2】在除法运算中使用断言调试程序。定义执行除法运算的 division() 函数，并且在该函数中使用 assert 断言调试程序，代码如下：

def division():
    num1 = int(input('请输入被除数：'))  # 用户输入提示，并记录
    num2 = int(input('请输入除数：'))
    assert num2 != 0, '除数不能为0'  # 应用断言调试
    result = num1 // num2  # 执行除法运算
    print(result)

if __name__ == '__main__':
    division()  # 调用函数
1
2
3
4
5
6
7
8
9
10
运行程序，输入除数为0，将抛出下图所示的 AssertionError 异常。

【示例3】应用断言和异常处理语句处理异常。

def division():
    num1 = int(input('请输入被除数：'))  # 用户输入提示，并记录
    num2 = int(input('请输入除数：'))
    assert num2 != 0, '除数不能为0'  # 应用断言调试
    result = num1 // num2  # 执行除法运算
    print(result)

if __name__ == '__main__':
    try:
        division()  # 调用函数
    except AssertionError as e:  # 处理AssertionError异常
        print('\n输入有误：', e)
1
2
3
4
5
6
7
8
9
10
11
12
13
程序运行结果如下图所示：

说明：凡是可以使用 print 来辅助查看的地方，都可以使用断言(assert) 来替代。assert 语句只在调试阶段有效。我们可以通过在执行 python 命令时加入-O（大写）参数来关闭 assert 语句。关闭之后，可以把所有的 assert 语句当成 pass 语句忽略掉。

4.2 raise 语句–抛出异常
如果某个函数或方法可能会产生异常，但不想在当前函数或方法中处理这个异常，则可以使用 raise 语句在函数或方法中抛出异常。raise 语句的基本格式如下：

raise [ExceptionName[(reason)]]
1
其中，ExceptionName[(reason)] 为可选参数，用于指定抛出的异常名称，以及异常信息的相关描述。如果省略，就会把当前的错误原样抛出。ExceptionName(reason) 参数中的(reason)也可以省略，如果省略，则在抛出异常时，不附带任何描述信息。

【示例1】：使用raise语句抛出异常并处理

def division():
    num1 = int(input('请输入被除数：'))  # 用户输入提示，并记录
    num2 = int(input('请输入除数：'))
    if num2 == 0:
        raise ValueError('除数不能为0')
    result = num1 // num2  # 执行除法运算
    print(result)

if __name__ == '__main__':
    try:  # 捕获异常
        division()  # 调用函数
    except ValueError as e:  # 处理ValueError异常
        print('输入错误：', e)  # 输出错误原因
1
2
3
4
5
6
7
8
9
10
11
12
13
14
【示例2】：使用raise语句针对不同情况抛出不同异常

try:
    username = input('请输入用户名（不超过16个字符）：')
    pwd = input('请输入密码（只能由字母和数字组成）：')
    if len(username) > 16:  # 如果用户超过16个字符
        raise ValueError('用户名输入不合法，不能超过16个字符！')  # 抛出ValueError异常
    if not pwd.isalnum():
        raise ValueError('密码输入不合法，不能包括除了数字和字母以外的字符！')  # 抛出ValueError异常
except ValueError as e:
    print(e)
1
2
3
4
5
6
7
8
9
程序运行结果如下图所示：

4.3 try…except 语句–捕获异常
try…except 语句用于捕获并处理异常。在使用时，把可能产生异常的代码放在 try 语句块中，把处理结果放在 except 语句块中，这样，当 try 语句块中的代码出现错误，就会执行 except 语句块中的代码，如果 try 语句块中的代码没有错误，那么 except 语句块将不会执行。具体的语法格式如下：

try:
    block1
except [ExceptionName [as alias]]：
    block2
1
2
3
4
参数说明：

block1：表示可能出现错误的代码块。
ExceptionName [as alias]：可选参数，用于指定要捕获的异常。其中，ExceptionName 表示要捕获的异常名称，如果在其右侧加上 as alias 则表示为当前的异常指定一个别名，通过该别名，可以记录异常的具体内容。在使用 try…except 语句捕获异常时，如果在 except 后面不指定异常名称，则表示捕获全部异常。
block2：表示进行异常处理的代码块。在这里可以输出固定的提示信息，也可以通过别名输出异常的具体内容。
说明：使用 try…except 语句捕获异常后，当程序出错时，输出错误信息后，程序会继续执行。

【示例1】一次捕获一种异常

def division():
    num1 = int(input('请输入被除数：'))  # 用户输入提示，并记录
    num2 = int(input('请输入除数：'))
    result = num1 // num2  # 执行除法运算
    print(result)

if __name__ == '__main__':
    try:  # 捕获异常
        division()  # 调用分苹果的函数
    except ZeroDivisionError:  # 处理异常
        print('输入错误：除数不能为0')  # 输出错误原因
1
2
3
4
5
6
7
8
9
10
11
12
程序执行结果如下图所示：

【示例2】一次捕获多种异常

def division():
    num1 = int(input('请输入被除数：'))  # 用户输入提示，并记录
    num2 = int(input('请输入除数：'))
    result = num1 // num2  # 执行除法运算
    print(result)

if __name__ == '__main__':
    try:  # 捕获异常
        division()  # 调用函数
    except (ZeroDivisionError, ValueError):  # 处理异常
        print('您的输入有误！')
1
2
3
4
5
6
7
8
9
10
11
12
程序执行结果如下图所示：

说明：如果还需要捕获更多种异常，可以在 ValueError 的后面继续添加异常名称，并且使用英文半角的逗号分隔。

【示例3】使用多个except子句分别捕获多种异常。

def division():
    num1 = int(input('请输入被除数：'))  # 用户输入提示，并记录
    num2 = int(input('请输入除数：'))
    result = num1 // num2  # 执行除法运算
    print(result)

if __name__ == '__main__':
    try:  # 捕获异常
        division()  # 调用函数
    except ZeroDivisionError:  # 处理异常
        print('\n出错了：除数不能为0！')
    except ValueError as e:  # 处理ValueError异常
        print('输入错误：', e)  # 输出错误原因
1
2
3
4
5
6
7
8
9
10
11
12
13
14
说明：如果还需要捕获更多种异常，可以继续添加except子句。

【示例4】一次捕获全部异常。

def division():
    num1 = int(input('请输入被除数：'))  # 用户输入提示，并记录
    num2 = int(input('请输入除数：'))
    result = num1 // num2  # 执行除法运算
    print(result)

if __name__ == '__main__':
    try:  # 捕获异常
        division()  # 调用函数
    except Exception as e:  # 处理异常
        print('出错了：', e)
1
2
3
4
5
6
7
8
9
10
11
12
程序执行结果如下图所示：

4.4 try…except…else 语句–捕获异常
try…except…else 语句也是异常处理结构，它是在 try…except 语句的基础上再添加一个 else 子句，用于指定当 try 语句块中没有发现异常时要执行的语句块。当 try 语句中发现异常时，该语句块中的内容将不被执行。语法格式如下：

try:
    block1
except [ExceptionName [as alias]]：
    block2
else:
    block3
1
2
3
4
5
6
参数说明：

block1：表示可能出现错误的代码块。
ExceptionName [as alias]：可选参数，用于指定要捕获的异常。其中，ExceptionName表示要捕获的异常名称，如果在其右侧加上as alias则表示为当前的异常指定一个别名，通过该别名，可以记录异常的具体内容。
block2：表示进行异常处理的代码块。在这里可以输出固定的提示信息，也可以通过别名输出异常的具体内容。
block3：没有产生异常时执行的语句块。
【示例1】捕获异常并在没有异常时给出提示。

def division():
    num1 = int(input('请输入被除数：'))  # 用户输入提示，并记录
    num2 = int(input('请输入除数：'))
    result = num1 // num2  # 执行除法运算
    return result

if __name__ == '__main__':
    try:  # 捕获异常
        result = division()  # 调用函数
    except ZeroDivisionError:  # 处理异常
        print('\n出错了：除数不能为0！')
    except ValueError as e:  # 处理ValueError异常
        print('输入错误：', e)  # 输出错误原因
    else:  # 没有抛出异常时执行
        print('结果为：', result)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
程序运行结果如下图所示：

【示例2】应用try…except语句实现当输入的学生成绩有误时给出提示，否则输出输入结果。

while True:
    try:  # 捕获异常
        english = int(input('请输入英语成绩：'))
        python = int(input('请输入Python成绩：'))
        c = int(input('请输入C语言成绩：'))
    except:  # 处理异常
        print('输入无效，不是整型数据,请重新录入信息！')
        continue  # 继续循环
    else:  # 没有抛出异常时执行
        print('英语：', english, '\tPython：', python, '\tC语言：', c)
        break  # 跳出循环
1
2
3
4
5
6
7
8
9
10
11
程序运行结果如下图所示：

4.5 try…except…finally 语句–捕获异常
完整的异常处理语句应该包含 finally 代码块，通常情况下，无论程序中有无异常产生，finally 代码块中的代码都会被执行。其基本格式如下：

try:
    block1
except [ExceptionName [as alias]]：
    block2
finally:
    block3
1
2
3
4
5
6
对于 try…except…finally 语句的理解并不复杂，它只是比 try…except 语句多了一个 finally 语句，如果程序中有一些在任何情形中都必须执行的代码，那么就可以将它们放在 finally 语句的区块中。

说明：使用 except 子句是为了允许处理异常。无论是否引发了异常，使用 finally 子句都可以执行清理代码。如果分配了有限的资源（如打开文件），则应将释放这些资源的代码放置在 finally 块中。

【示例1】在捕获异常时应用 finally 子句输出指定的提示信息。

def division():
    num1 = int(input('请输入被除数：'))  # 用户输入提示，并记录
    num2 = int(input('请输入除数：'))
    result = num1 // num2  # 执行除法运算
    return result

if __name__ == '__main__':
    try:  # 捕获异常
        result = division()  # 调用函数
    except ZeroDivisionError:  # 处理异常
        print('\n出错了：除数不能为0！')
    except ValueError as e:  # 处理ValueError异常
        print('输入错误：', e)  # 输出错误原因
    else:  # 没有抛出异常时执行
        print('结果为：', result)
    finally:  # 无论是否抛出异常都执行
        print('\n执行了除法运算！')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
程序没有抛出异常时的运行结果。

程序抛出异常时的运行结果。

【示例2】在连接数据库时应用 try…except…finally 子句。

import sqlite3  # 导入sqlite3模块

try:
    # 连接到SQLite数据库
    # 数据库文件是test.db，如果文件不存在，会自动在当前目录创建
    conn = sqlite3.connect('test.db')
except Exception as e:  # 处理异常
    print(e)
else:
    try:
        cursor = conn.cursor()  # 创建一个Cursor
        # 执行一条SQL语句，创建user表
        cursor.execute('create table user(id int(10) primary key,name varchar(20))')
    except Exception as e1:  # 处理异常
        print(e1)
    finally:  # 无论是否抛出异常都执行
        cursor.close()  # 关闭游标
finally:  # 无论是否抛出异常都执行
    conn.close()  # 关闭Connection
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
第一次运行上面的代码时，不会抛出异常。再次运行上面的代码时，就会由于数据表已经存在而抛出异常。

————————————————
版权声明：本文为CSDN博主「Amo Xiang」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/xw1680/article/details/116792540