当前位置:   article > 正文

超详细的 Python 基础语句总结_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

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/2023面试高手/article/detail/421706
推荐阅读
相关标签
  

闽ICP备14008679号