+ 运算符用于实现 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
【示例2】字符串相加。在 Python 中，如果 + 号的两侧是字符串类型数据，则表示将 2 个字符串进行拼接。常用应用如下：
s1 = 'Amo'
s2 = 'Xiang'
print(s1 + s2) # 字符串拼接
print(s1 + ' ' + s2) # 2个字符串间添加空格
print(s1 + '\n' + s2) # 2个字符串间添加换行符
程序执行结果如下图所示：
+ 相加时，返回合并后的元组、列表。常用应用如下：
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)
说明：字典和集合不能使用“+”进行操作。
- 运算符在 Python 中有两个作用，一个是作为负号使用，在数字前表示负数；另一个是作为减号，表示前一个数字减去后一个数字。
【示例1】作为负号使用。作为负号使用时，注意负负为正。常用应用如下：
num1 = 4
num2 = -5
num3 = -6.0
print(-num1) # -4
print(num2) # -5
print(-num3) # 6.0
【示例2】作为减号使用。作为减号使用时，常用应用如下：
num1 = 5
num2 = 1
num3 = 10
num4 = 8.0
print(num1 - num2) # 4
print(num1 - num3) # -5
print(num1 - num4) # -3.0
* 运算符在 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
【示例2】对字符串使用*号。使用“*”作为重复符号，打印一个等腰三角形。代码如下：
print(' ' * 2 + '*' + ' ' * 2)
print(' ' + '*' * 3 + ' ')
print('*' * 5)
【示例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)
【示例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)
/ 运算符用于实现 2 个对象的相除。
【示例1】实现人民币和美元的转换。已知1美元兑换人民币 6.78 元，编写程序实现人民币转换成美元的功能。代码如下：
exchange_rate = 6.78 # 汇率
RMB = input('请输入人民币金额：')
try:
US = float(RMB) / exchange_rate
print('转化后的美元是:{:.2f}'.format(US))
except ValueError:
print('请输入正确的数值类型。')
程序执行结果如下图所示：
// 运算符用于取整除，返回商的整数部分，注意向下取整。例如 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
程序执行结果如下图所示：
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')
程序执行结果如下图所示：
% 运算符用于取模，返回除法的余数，例如 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
上面的结果可能与很多人的预期不符，这个结果是由 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
** 运算符用于返回一个数的幂，例如 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
= 是简单的赋值运算符，例如将 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() # 类的实例化：类赋值
+= 是加法赋值运算符，例如将 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}')
【示例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)
-= 是减法赋值运算符，如加法运算符类似，例如将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) # 输出列表
“*=”是乘法赋值运算符，如加法运算符类似，例如将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]
【示例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个格子
/= 是除法赋值运算符，例如将 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]
%= 是取模运算符，例如将 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) # ['偶数', '奇数', '偶数', '奇数', '偶数', '奇数']
“**=”是幂赋值运算符，例如将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]
“//=”是取整除赋值运算符，例如将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]
“==”是等于运算符，用于比较对象是否相等。如果相等，返回 True，否则返回 False。
【示例1】== 运算符与 is 的区别。“==” 运算符用于比较对象的值是否相等，如果值相等即返回True，而is既要判断值是否相等，又要内存地址相等。它们之间的区别可以通过如下代码来验证：
【示例2】if 语句判断是否相等。
score = int(input('前输入分数：'))
if score == 100:
print('恭喜你已经通关！')
else:
print('请继续努力哦！')
“!=” 是不等于运算符，用于比较对象是否不相等。如果不相等，返回 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)
“>”运算符用于比较对象大小。如果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码值大的元素比较大。如果第一个元素相同，则比较第二个元素，以此类推。'''
【示例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('符合要求')
“<”运算符用于比较对象大小。如果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}个')
【示例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}')
“>=”运算符用于比较对象大小。如果a的值大于或者等于b，则a >=b 返回True，否则返回False。
【示例1】判断考试成绩是否及格。语文考试及格成绩为60分，如果成绩大于或者等于60分，则成绩及格，否则成绩不及格。实现该功能的代码如下：
score = float(input('请输入你的分数:'))
if score >= 60:
print('恭喜你，考试通过！')
else:
print('很遗憾，没有通过考试')
“<=”运算符用于比较对象大小。如果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)
“and”运算符用于表示逻辑与。例如opt1 and opt2，如果opt1与opt2全部为真，则返回True，否则返回False。
【示例1】判断电梯是否超载。
num = int(input('请输入人数:'))
weight = float(input('请输入总重量:'))
if num <= 10 and weight <= 1000:
print('电梯正常运行')
else:
print('电梯超载')
“or”运算符用于表示逻辑或。例如opt1 or opt2，如果opt1和opt2全部为否，则返回False,否则返回True。
【示例1】使用or运算符判断某个区间之外的数据。
num = float(input('请输入产品销量:'))
if num > 500 or num < 20:
print('该产品需要重点关注！')
else:
print('该产品销量平稳！')
“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，则该位的结果为1，否则为0。
【示例1】输出按位与的结果。
a = 0b00111100
b = 0b00001101
# 说明：a&b 的结果是0000 1100，转化为十进制为12。
print(a & b) # 12
按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。
【示例1】输出按位或的结果。
a = 0b00111100
b = 0b00001101
# 说明：a|b 的结果是0011 1101，转化为十进制为61。
print(a | b) # 61
按位异或运算符：当两对应的二进位相异时，结果为1。
【示例1】输出按位异或的结果。
a = 0b00111100
b = 0b00001101
# 说明：a^b 的结果是0011 0001，转化为十进制为49。
print(a ^ b) # 49
按位取反运算符：对数据的每个二进制位取反，即把1变为0，把0变为1。~x类似于 -x-1。
【示例1】输出按位取反的结果。
a = 0b00111100
# 说明：~a 的结果是1100 0011，转化为补码为10111101，转化十进制为-61。
print(~a) # -61
左移动运算符：运算数的各二进位全部左移若干位，由'<<'右边的数指定移动的位数，高位丢弃，低位补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
右移动运算符：把'>>“左边的运算数的各二进位全部右移若干位，”>>'右边的数指定移动的位数。如果符号位为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
“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
【示例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
【示例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
【示例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
【示例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
“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)
【示例2】判断字符串信息是否合法。在注册网站时，需要用户填写“真实姓名”、“手机号”和“密码”3个字段。使用“not in”操作符，完成判断用户填写的注册信息是否正确，代码如下：
res = []
# 判断是否填写完全
if 'truename' not in res or 'phone' not in res or 'password' not in res:
print('必须填写真实姓名、手机号和密码')
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
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('调试模式已关闭')
【示例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)
程序执行结果如下：
def pay(name, salary=None):
if salary is None:
salary = 8
print(f'{name}的钟点工工薪水是{salary}元')
pay('Amo', 0) # Amo的钟点工工薪水是0元
有时候，我们需要在满足某种条件时进行一些操作，而不满足条件时就不进行任何操作，这个时候我们可以只使用 if 语句。Python 中使用 if 关键字来组成最简单的选择语句，if 语句的基本形式如下：
if 表达式:
语句块
如果判断条件成立就执行语句块，否则直接跳过。
【示例1】实现“如果…就”形式的判断。通过if语句实现如果年龄小于12岁，就不可以玩《王者荣耀》游戏功能。要求输入年龄，使用if语句判断是否小于12，如果小于，则提示“抱歉，您的年龄太小，不适合玩《王者荣耀》游戏！”，代码如下：
age = int(input('请输入您的年龄：'))
if age < 12: # 如果年龄小于12岁
print('抱歉，您的年龄太小，不适合玩《王者荣耀》游戏！')
程序运行结果如下图所示：
age = int(input('请输入您的年龄：')) # 输入年龄
# 简写
# if 18 <= age <= 70:
if age >= 18 and age <= 70: # 输入年龄是否在18--70之间
print('您可以申请小型汽车驾驶证！')
程序运行结果如下图所示：
sales = int(input('请输入商品日销量：')) # 输入商品日销量
if sales < 10 or sales > 100: # 判断条件
print('该商品为重点关注商品！')
程序运行结果如下图所示：
number = input('请输入一个整数：')
if number.isdigit(): # 外层if语句
number = int(number)
if 0 <= number <= 150: # 内层if语句
print(number)
else:
print('不是有效的成绩！')
程序运行结果如下图所示：
while True: # 外层for循环
number = input('请输入一个整数：')
if number.isdigit(): # 外层if语句
number = int(number)
if 0 <= number < 150: # 内层if语句
print(number)
break # 跳出循环
else:
print('不是有效的成绩，请重新输入！')
程序运行结果如下图所示：
name = '张王李王陈张李王陈王张'
newname = ''
for char in name: # 外层for循环
if char not in newname: # 内层if语句
newname += char
print(newname)
程序运行结果如下图所示：
在 Python 中使用 if…else 语句根据给定的条件进行判断，并根据判定的结果(真或假)来执行相应的操作，if…else 语句的语法格式如下：
if 表达式:
语句块1
else:
语句块2
其中，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考试不合格！')
【示例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)
【示例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('没有找到该学生的相关信息！')
程序运行结果如下图所示：
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('没有学生信息！')
程序运行结果如下图所示：
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('空气质量状况：严重污染')
【示例2】while 和 if…elif…else 语句嵌套。根据身高、体重计算身体质量指数，身体质量指数（BMI，Body Mass Index）是国际上常用的衡量人体肥胖程度和是否健康的重要标准，BMI=体重/身高2，下表为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('肥胖 ^@_@^')
【示例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('显示所有学生信息')
在开发程序时，常常遇到多选一的情况，则可以使用 if…elif…else 语句，该语句是一个多分支选择语句，if…elif…else 语句的语法格式如下：
if 表达式1:
语句块1
elif 表达式2:
语句块2
elif 表达式3:
语句块3
…
else:
语句块n
其中，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 语句时，表达式可以是一个单纯的布尔值或变量，也可以是比较表达式或逻辑表达式。
for 语句是一个依次重复执行的循环。通常适用于枚举或遍历序列，以及迭代对象中的元素。for 语句的语法格式如下：
for 迭代变量 in 对象:
循环体
参数说明：
【示例1】想要实现从1到100的累加，可以通过下面的代码实现：
result = 0 # 保存累加结果的变量
for i in range(101):
result += i # 实现累加功能
print('1+2+3+……+100的结果为：', result) # 在循环结束时输出结果
【示例2】指定范围和步长的数值循环：
for i in range(1, 10, 2):
print(i, end=' ') # 1 3 5 7 9
【示例3】遍历字符串：
str1 = '莫轻言放弃'
for s in str1:
print(s)
【示例4】遍历整个列表：
print('福布斯2018全球富豪榜前五名:')
name = ['杰夫・贝佐斯', '比尔・盖茨', '沃伦·巴菲特', '伯纳德・阿诺特', '阿曼西奥・奥特加']
for item in name:
print(item)
【示例5】 通过for语句和enumerate()函数实现带编号输出：
print('福布斯2018全球富豪榜前八名:')
name = ['杰夫・贝佐斯', '比尔・盖茨', '沃伦·巴菲特', '伯纳德・阿诺特', '阿曼西奥・奥特加']
for index, item in enumerate(name):
print(index + 1, item)
【示例6】切片遍历列表：
phonename = ['华为', 'vivo', '小米', 'OPPO', '三星'] # 定义列表
for name in phonename[1:4]: # 切片遍历列表
print(name) # 输出列表元素的值
【示例7】遍历元组：
musicname = ('Better Off', 'Going Home', 'Breeze', 'The Spectre') # 定义元组
for name in musicname: # 遍历元组
print(name) # 输出每个元组元素的值
【示例8】遍历集合：
setname = {'麻省理工学院', '斯坦福大学', '哈佛大学', '加州理工学院', '牛津大学'}
print('世界著名大学排名：')
for i in setname:
print('☛', i)
【示例9】遍历字典的key-value（键值对）：
dictionary = {'无语': '5月25日', '琦琦': '10月8日', '碧海苍梧': '7月27日', }
for key, value in dictionary.items():
print(key, '的生日为', value)
【示例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('') # 强制换行
【示例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)
【示例12】for语句与while语句嵌套
row = 5 # 行数
for i in range(1, row + 1): # 控制行数
a = 1
while a <= i:
print('*', end='') # 不换行
a += 1
print('') # 强制换行
for…else 语句是在 for 语句的基本上添加了一个 else 子句，用于当循环条件不满足时，执行指定代码。for 语句的语法格式如下：
for 迭代变量 in 对象:
循环体
else:
语句块
参数说明：
【示例1】for…else 语句的基本应用。实现从 1~100 的累加，并且在 else 子句中输出累加结果，代码如下：
result = 0 # 保存累加结果的变量
for i in range(101):
result += i # 实现累加功能
else:
print('1+2+3+……+100的结果为：', result) # 在循环结束时输出结果
【示例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('是质数。')
【示例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('没有找到相应菜单！')
while 语句是通过一个条件来控制是否要继续反复执行循环体中的语句。while 语句的语法格式如下：
初始化语句 # 类似于 i=0
while 条件表达式:
循环体
条件控制语句 # 类似于 i+=1
当条件表达式的返回值为真时，则执行循环体中的语句，执行完毕后，重新判断条件表达式的返回值，直到表达式返回的结果为假时，退出循环。
【示例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)
【示例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 # 退出循环
【示例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
【示例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() # 关闭窗口
while…else 语句是在 while 语句的基本上添加了一个 else 子句，用于当循环条件不满足时，执行指定代码。while…else 语句的语法格式如下：
初始化语句 # 类似于 i=0
while 条件表达式:
循环体
条件控制语句 # 类似于 i+=1
else:
语句块
当条件表达式的返回值为真时，则执行循环体中的语句，执行完毕后，重新判断条件表达式的返回值，直到表达式返回的结果为假时，执行语句块中的语句。
【示例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('您的机会已用完。')
说明：else 子句只有当循环条件不满足时，才会被执行，使用 break 语句跳出循环时，不会被执行。
break 语句用来终止循环，即循环条件成立或者序列还没被完全递归完，也会停止执行循环语句。break 语句的常用语法格式如下：
if 条件表达式:
break
其中，条件表达式用于判断何时调用 break 语句跳出循环。
【示例1】在 for 语句中使用 break 语句。
for i in range(1, 11):
if i == 5:
break # break语句终止循环
print(i, end=' ')
【示例2】在 while 循环中使用 break 语句。
num = 10
while True: # while循环条件
num -= 1 # 变量自加
print(num) # 输出num的值
if num <= 6:
break
continue 语句在语句块执行过程中直接跳到循环的下一次迭代。即终止当前循环，而执行下一次循环。continue 语句的语法格式如下：
if 条件表达式:
continue
其中，条件表达式用于判断何时调用 continue 语句跳出循环。
【示例1】在 for 语句中使用 continue 语句
for i in range(1, 11):
if i == 2 or i == 8:
continue # continue语句跳出本次循环，继续下一次循环
print(i, end=' ')
【示例2】在 while 循环中使用 continue 语句
num = 0 # 定义变量并赋初值
while num < 5:
num += 1 # 改变变量的值
if num == 2:
continue
print('sum的值为:', num) # 输出sum的值
注意：break 语句和 continue 语句只能用在循环中，break 语句和 continue 语句在循环嵌套中，只对最近的一层循环起作用。
条件表达式是 Python 选择语句中比较简练的一种赋值方式，常用于赋值语句中，其基本格式为：
a if b else c
如果判定条件 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))
使用条件表达式时，先计算中间的条件（num1>num2），如果结果为 True，返回 if 语句左边的值（num1），否则返回 else 右边的值（num2）。例如上面求较大数的表达式，当结果为真时，则返回 num1 的值，即结果为100。
【示例2】应用条件表达式根据计算结果返回不同的信息。使用条件表达式判断一个数能否被2整除，并根据结果返回是奇数还是偶数，代码如下：
number = int(input('请输入一个数：'))
result = '奇数' if number % 2 == 1 else '偶数' # 条件表达式
print(number, '是' + result)
【示例3】应用条件表达式处理自定义函数的可选参数。
def demo(param=None):
return '没有指定参数' if param is None else 'param参数值为――' + param
print(demo()) # 调用函数不指定参数
print(demo('莫轻言放弃')) # 调用函数并指定参数
【示例4】使用多条件的条件表达式。使用条件表达式返回输入的年份是否为闰年，代码如下：
year = int(input('请输入一个数：'))
result = '闰年' if (year % 4 == 0 and year % 100 != 0) or year % 400 == 0 else '不是闰年'
print(year, result)
使用 def 关键字可以实现定义一个函数，具体的语法格式如下：
def functionname([parameterlist]):
['''comments''']
[functionbody]
[return]
参数说明如下：
, 分隔。如果不指定，则表示该函数没有参数。在调用时，也不指定参数。'''comments''' 参数，那么在调用函数时，输入函数名称及左侧的小括号时，就会显示该函数的帮助信息。这些帮助信息就是通过定义的注释提供的。注意：函数体“functionbody”和注释 comments相对于def关键字必须保持一定的缩进。
【示例1】定义一个空函数。如果想定义一个什么也不做的空函数，可以使用pass语句作为占位符。代码如下：
def empty_fun():
pass
【示例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('肥胖 ^@_@^')
调用刚刚创建的 fun_bmi() 函数，可以使用下面的代码。
fun_bmi('Amo', 1.76, 50) # 计算匿名的BMI指数
调用 fun_bmi() 函数后，将显示如下运行结果。
fun_bmi(height=1.76, weight=50, person='Amo') # 计算匿名的BMI指数
说明：通过上面的代码调用 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('肥胖 ^@_@^')
调用 fun_bmi() 函数，各参数值都采用默认，代码如下：
fun_bmi() # 调用指定默认值的函数不指定参数值
fun_bmi('零语', 1.65, 55) # 调用指定默认值的函数时指定参数值
调用 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指数
说明：在上面的代码中，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) # 使用已有的列表作为函数的可变参数
运行结果如下。
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指数
说明：在上面的代码中，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) # 使用已有的字典作为函数的可变参数
运行结果如下：
def print_coffee(*args, name):
print('欢迎光临%s咖啡馆~\n我店的咖啡有：' % name)
for item in args: # 遍历输出可变参数*args的值
print(item)
调用自定义 print_coffee() 函数，传递可变参数和普通参数，代码如下：
print_coffee('蓝山', '卡布奇诺', '摩卡', '哥伦比亚', name='依米')
注意：在定义和调用带可变参数*args和普通参数的函数时，*args需要在前，普通参数在后。
【示例7】定义并调用带可变参数**kwargs和普通参数结合的函数。定义一个包括可变参数**kwargs和普通参数结合的自定义函数，在函数中，输出普通参数以及遍历输出关键字可变参数的值，代码如下：
def print_coffee(name, **kwargs):
print('欢迎光临%s咖啡馆~\n我店的咖啡有：' % name)
for item in kwargs.values():
print(item)
调用自定义 print_coffee() 函数，传递普通参数和关键字可变参数，代码如下：
print_coffee('依米', id1='蓝山', id2='卡布奇诺', id3='摩卡', id4='哥伦比亚')
注意：在定义和调用带可变参数**kwargs和普通参数的函数时，普通参数需要在前，**kwargs关键字参数在后。
【示例8】定义并调用带返回值的函数。定义一个带返回值的自定义函数，在函数中，输出普通参数以及遍历输出关键字可变参数的值，代码如下：
def area(w, h):
return w * h
调用自定义 area() 函数，传递矩形的宽度和高度，并输出返回结果，代码如下：
rect = area(450, 200)
print('矩形面积：', rect)
在 Python 中，使用 lambda 表达式创建匿名函数，其语法格式如下：
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))
【示例2】实现带默认值参数的匿名函数。使用lambda表达式定义一个指定参数默认值的匿名函数，用于计算圆的面积，代码如下：
import math # 导入math模块
result = lambda r=100: math.pi * r * r # 计算圆的面积的lambda表达式
print('圆面积为：', result()) # 不指定半径
【示例3】在匿名函数后面直接传递参数。使用lambda表达式定义一个计算圆面积的匿名函数，并且在定义时直接在后面指定参数值，代码如下：
import math # 导入math模块
result = (lambda r: math.pi * r * r)(100) # 计算圆的面积的lambda表达式
print('圆面积为：', result) # 不指定半径
【示例4】使用lambda表达式自定义排序规则。
方法一：使用 lambda 表达式指定排序规则为先按字符串的长度排序，当长度相同时再按字母或数字排序（不区分大小写），代码如下：
list1 = ['第6页', '第4页', '第16页', '第7页', '第22页', '第1页']
print('排序前：', list1)
list1.sort(key=lambda x: (len(x), x.lower())) # 自定义排序规则
print('排序后：', list1)
方法二：使用 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)
【示例5】将lambda表达式与map()函数结合使用。将lambda表达式作为map()函数的参数实现将列表中的全部英文名字转换为首字母大写，代码如下：
name = ['rose', 'aurora', 'jim', 'lily', 'lucy']
name = map(lambda x: x.capitalize(), name) # 将列表中的全部英文名字变为首字母大写
print(list(name))
【示例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))
【示例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() # 进入消息循环
pass 是一个空语句，不会输出任何内容，常被用作占位符，防止语法错误。如果循环体或者函数体为空，解释器就会报错。这时可以用 pass 语句来占位，以防止程序报错。pass 语句语法格式如下：
pass
【示例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
敲重点：pass 语句和注释之间的区别在于：解释器会完全忽略注释，但不会忽略 pass 语句。
yield 语句可以在函数中定义生成器对象。它可以生成一个值的序列，以便于在迭代中使用。使用了 yield 语句的函数（也称生成器函数）与普通函数不同，普通函数调用一次返回一个值（如果没有 return 语句，则返回 None），而生成器函数则会返回一个生成器对象，通过调用该对象的 __next__() 方法，可以不断地执行语句，直到遇到 yield 语句为止，并且在停止的地方生成一个结果。接下来还可以再次调用 __next__() 方法继续执行。
def 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__()方法
从上面的结果中可以看出，虽然在函数中使用了死循环，但是并没有出现死循环，这是因为调用函数后，代码并不会开始执行，而是在调用 __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='')
assert 的中文意思是断言，它一般用于对程序某个时刻必须满足的条件进行验证。assert 语句的基本语法如下：
assert expression [,reason]
参数说明：
【示例1】使用断言调试程序。要求输入一个数字，然后使用 assert 语句对输入的空值抛出异常，代码如下：
number = input('请输入一个数字：')
assert number != '', '不能输入空值！' # 当值为空时通过断言抛出异常
print('您输入了：', number)
运行程序，什么都不输入，直接按下 <Enter> 键时，将抛出如下图所示的 AssertionError 异常。
def division():
num1 = int(input('请输入被除数：')) # 用户输入提示，并记录
num2 = int(input('请输入除数：'))
assert num2 != 0, '除数不能为0' # 应用断言调试
result = num1 // num2 # 执行除法运算
print(result)
if __name__ == '__main__':
division() # 调用函数
运行程序，输入除数为0，将抛出下图所示的 AssertionError 异常。
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)
程序运行结果如下图所示：
如果某个函数或方法可能会产生异常，但不想在当前函数或方法中处理这个异常，则可以使用 raise 语句在函数或方法中抛出异常。raise 语句的基本格式如下：
raise [ExceptionName[(reason)]]
其中，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) # 输出错误原因
【示例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)
程序运行结果如下图所示：
try…except 语句用于捕获并处理异常。在使用时，把可能产生异常的代码放在 try 语句块中，把处理结果放在 except 语句块中，这样，当 try 语句块中的代码出现错误，就会执行 except 语句块中的代码，如果 try 语句块中的代码没有错误，那么 except 语句块将不会执行。具体的语法格式如下：
try:
block1
except [ExceptionName [as alias]]：
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') # 输出错误原因
程序执行结果如下图所示：
def division():
num1 = int(input('请输入被除数：')) # 用户输入提示，并记录
num2 = int(input('请输入除数：'))
result = num1 // num2 # 执行除法运算
print(result)
if __name__ == '__main__':
try: # 捕获异常
division() # 调用函数
except (ZeroDivisionError, ValueError): # 处理异常
print('您的输入有误！')
程序执行结果如下图所示：
【示例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) # 输出错误原因
说明：如果还需要捕获更多种异常，可以继续添加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)
程序执行结果如下图所示：
try…except…else 语句也是异常处理结构，它是在 try…except 语句的基础上再添加一个 else 子句，用于指定当 try 语句块中没有发现异常时要执行的语句块。当 try 语句中发现异常时，该语句块中的内容将不被执行。语法格式如下：
try:
block1
except [ExceptionName [as alias]]：
block2
else:
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)
程序运行结果如下图所示：
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 # 跳出循环
程序运行结果如下图所示：
完整的异常处理语句应该包含 finally 代码块，通常情况下，无论程序中有无异常产生，finally 代码块中的代码都会被执行。其基本格式如下：
try:
block1
except [ExceptionName [as alias]]：
block2
finally:
block3
对于 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执行了除法运算！')
程序没有抛出异常时的运行结果。
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
第一次运行上面的代码时，不会抛出异常。再次运行上面的代码时，就会由于数据表已经存在而抛出异常。
联系客服
