一、分支语句if
if条件判断1：
执行语句1······
elif判断条件2：
执行语句2····
elif判断条件3：
执行语句3····
else：
执行语句4
demo:
print("请输入数字：")
a =input() # 从控制台输入内容放到变量a
flag = int(a) # 输入的内容默认是字符串的
if flag == 1:
print("喝奶")
elif flag == 2:
print("吃饭")
elif flag == 3:
print("吃大餐")
else:
print("不吃")
作业
回文数实现
def huiwenshu():
"""
编写一个Python程序，输入一个5位数，判断输入的这个数字是否为回文数。
回文数是指从左到右和从右到左读都一样的数。例如12321。
如果输入的是回文数，输出是回文数，否则输出不是回文数。
"""
# 输入一个5位数
inp = input("请输入一个五位数：\n")
re = inp[::-1]
if re == inp:
print(f"{inp}是一个回文数")
else:
print(f"{inp}不是一个回文数")
成绩判断
def get_grade():
"""
编写一个 Python 程序，用户输入一个分数，程序将根据分数判断并输出相应的等级。
分数在 90 分及以上为 A 等级，60 -89 分为 B 等级，否则为 C 等级。
:return:
"""
# 用户输入一个分数
grade = int(input("请输入分数：\n"))
# 分数在 90 分及以上为 A 等级，60 -89 分为 B 等级，否则为 C 等级。
if grade >=0 and grade <= 100:
if grade >= 90:
print(f"你的等级为A等级,分数是：{grade}")
elif grade >= 60:
print(f"你的等级为B等级,分数是：{grade}")
else:
print(f"你的等级为C等级,分数是：{grade}")
else:
print("请输入正确的分数！")
计算器
def calc():
"""编写一个简单的Python程序，实现一个简易的计算器。
用户可以输入两个数字和一个运算符（+、-、*、/），
程序将根据运算符执行相应的计算操作，并输出结果。
"""
# 输入两个数字和运算符
num1 = int(input("请输入第一个数字：\n"))
oper = input("请输入一个运算符：\n")
num2 = int(input("请输入第二个数字：\n"))
# 根据运算符执行相应的计算操作
if oper == "+":
result = num1 + num2
print(f"结果为{result}")
elif oper == "-":
result = num1 - num2
print(f"结果为{result}")
elif oper == "*":
result = num1 * num2
print(f"结果为{result}")
elif oper == "/":
if num2 != 0:
result = num1 / num2
else:
result = "除数不能为零"
print(f"结果为{result}")
elif oper == "%":
result = num1 % num2
print(f"结果为{result}")
else:
print("请输入正确的运算符！")
乘公交
def take_bus():
"""
编写一个 Python 程序，模拟乘坐公交车过程，并且可以有座位坐下。
要求：输入公交卡当前的余额，只要不低于2元，就可以上公交车；
如果车上有空座位，就可以坐下。
:return:
"""
# 输入公交卡当前余额
balance = int(input("请输入公交卡当前余额：\n"))
if balance >= 2:
print("请上车！")
seat_num = int(input("请输入当前公交空座位数：\n"))
if seat_num > 0:
print("请坐！")
else:
print("无空座位。")
else:
print("余额不足，请充值！")
二、匹配语句match介绍
在 Python 中，match 是 Python 3.10 版本引入的一种模式匹配语法。
它提供了一种简洁而强大的方式来匹配和处理不同模式的逻辑，当成功匹配一个模式时，就执行该模式后的代码块。
match 语句适用于有限的精准值的匹配，不适用于范围值的判断。
基本语法结构
match 语法的基本结构如下：
match value:
case pattern1:
# 处理 pattern1 匹配成功的情况
case pattern2:
# 处理 pattern2 匹配成功的情况
...
case patternN:
# 处理 patternN 匹配成功的情况
case _:
# 处理所有其他情况的匹配（相当于默认情况）
-
match表示匹配模式的开始 -
value表示需要进行匹配的目标值 -
case表示提供一个匹配模式 -
pattern表示被匹配的值，该值一般为一个字面量值。 -
-表示当所有模式都未匹配成功，则执行该模式下的代码块，本质上-是一个变量，用来匹配任意值。
示例: 根据输入httpCode值不同，输出对应的描述
httpCode = int(input("请输入一个HTTP状态码："))
match httpCode:
case 101:
print("临时响应")
case 200:
print("请求成功")
case 301:
print("重定向")
case 404:
print("页面找不到")
case 500:
print("服务器内部错误")
case _:
print("无效的状态码")
| 组合多个匹配值
match 可以在一个匹配模式中，提供多个匹配值，使用 | 组合，在匹配时，只要成功匹配其中一个值即可。
示例: 改进 HTTPCode 示例，可以匹配不同级别中的更多状态码
httpCode = int(input("请输入一个HTTP状态码："))
match httpCode:
case 100 | 101:
print("临时响应")
case 200 | 201 | 203 | 204 | 205:
print("请求成功")
case 301 | 304 | 307:
print("重定向")
case 401 | 403| 404 | 405:
print("页面找不到")
case 500 | 502 | 503:
print("服务器内部错误")
case _:
print("无效的状态码")
匹配模式绑定变量
在提供匹配值时，除可以提供字面值外，还可以提供变量，用来匹配任意值，如_,但是在一个匹配语句中，只能出现一个独立的匹配变量。
在编写程序过程中，如果需要动态匹配部分数据，比如一个元组中的部分值，此时可以通过绑定变量的方式，提供一个字面值和变量的混合匹配模式，字面值用来精确匹配，变量用来模糊匹配。
示例：输入一个坐标，输出该坐标点的位置。
# point is an (x, y) tuple
x = int(input("x:"))
y = int(input("y:"))
point = (x, y)
match point:
case (0, 0):
print("坐标在原点上")
case (0, y):
print(f"坐标在Y轴上")
case (x, 0):
print(f"坐标在X轴上")
case (x, y):
print(f"X={x}, Y={y}")
case _:
raise ValueError("没有这个坐标点")
上面代码中：
- 第一个模式有两个字面值，这两个字面值都能精确匹配者能成功匹配当前模式。
- 第二，三两个模式结合了一个字面值和一个变量，而变量绑定了一个来自目标的值（point），此时，字面值需要精确匹配，而绑定的变量可以匹配该位置的任意值。
- 第四个模式捕获了两个值，此时，目标值中的任意值都会被成功匹配。
- 这使得它在概念上类似于解包赋值 (x, y) = point。
三、循环语句while
循环的构成要素
- 初始化语句： 一条或多条语句，用于完成一些初始化工作。初始在循环开始之前执行。
- 循环条件：一般是一个布尔表达式，这个表达式能决定是否执行循环体
- 循环体：这个部分是循环的主体，如果循环条件允许，这个代码块将被重复执行。
- 迭代语句：这个部分在每次执行循环体结束后，对循环条件求值之前执行，通常用于控制循环条件中的变量向趋近于结束条件改变。
while 循环的语法
while 条件表达式:
循环体
当条件表达式的返回值为真时，则执行循环体中的语句，执行完毕后，重新判断条件表达 式的返回值，直到表达式返回的结果为假时，退出循环。
numbers = [12, 37, 5, 42, 8, 3]
even = []
odd = []
while len(numbers) > 0:
# 移除列表中的一个元素（默认最后一个），并返回该元素的值
number = numbers.pop()
if(number % 2 == 0):
# append()列表末尾添加新的对象
even.append(number)
else:
odd.append(number)
print(even)
print(odd)
运行结果：
[8, 42, 12]
[3, 5, 37]
实战
求 1~10 之间所有整数的乘积。
def num_re():
"""求 1~10 之间所有整数的乘积。"""
# 变量
num = 2
# 起始结果
result = 1
while num <=10 and num > 0:
result = num * result
num += num
print(f"1~10 之间所有整数的乘积是：{result}")
输入密码，直到密码输入正确，输出”登录成功“
def password():
"""输入密码，直到密码输入正确，输出”登录成功“"""
password = "1599887456"
str = " "
while str != password:
str = input("请输入密码：\n")
print("登录成功")
行酒令
def xingjiuling():
"""
在行酒令中，有一个数7小游戏，
游戏参与者依次报数，
但需要跳过所有包含7或7的整数倍的数字，
编写程序找出1~100范围内所有符合该条件的数字。
:return:
"""
num = 1
while num >=1 and num <=100:
num += 1
if num % 7 == 0:
print(num)
四、循环语句for-in
for-in 循环的语法
for 迭代变量 in 对象:
循环体
for-in 循环会将可迭代对象中的元素依次取出，保存到迭代变量中。每取出一个变量，便执行一次循环体，在循环体中可以通过引用迭代变量，使用取出的数据。
遍历可迭代对象
使用for-in循环处理可迭代对象，可以使操作过程变的极其简单。
使用场景： 明确的知道循环执行的次数或者要对一个容器进行迭代
range函数：
- 1.range(101)可以产生一个0-100的整数序列
- 2.range(1,100)可以产生一个1到99的整数序列
- 3.range(1,100,2)可以产生一个1到99的奇数序列，其中的2是步长
- 当range只传入一个参数的时候，传入的是 结束数值，遵循前闭后开原则
- 当range传入两个参数的时候，传入的是 （开始数值，结束数值），遵循前闭后开原则
- 当range传入三个参数的时候，传入的是 （开始数值，结束数值，步长）遵循前闭后开原则
遍历字符串
s = "Hello Hogworts!"
for c in s:
print(c)
示例： 输出前面示例中每个字符对应的ASCII码值。
s = "Hello Hogworts!"
for c in s:
print(f"字符【 {c} 】的ASCII码为：【 {ord(c)} 】")
遍历元组
t = (1,2,3,4,5)
for n in t:
print(n)
示例：输出前面示例元组中每个数字的立方值
t = (1,2,3,4,5)
for n in t:
print(f"数字【 {n} 】的立方值为：【 {n*3} 】")
遍历列表
requestMethods = ["get", "post", "put","delete", "patch", "header", "options",'trace']
for method in requestMethods:
print(method)
示例：将前面示例列表中所有的请求方式转换为大写输出
requestMethods = ["get", "post", "put","delete", "patch", "header", "options",'trace']
for method in requestMethods:
print(f"请求方式【 {method} 】转换为大写后：【 {method.upper()} 】")
遍历字典
requestMethods = {
"get": "用于获取服务器上的资源，通过在URL中传递参数来发送请求。",
"post": "用于向服务器提交数据，一般用于创建新的资源或进行修改操作。",
"put": "用于更新服务器上的资源，一般用于修改已存在的资源的全部内容。",
"delete": "用于删除服务器上的资源。"
}
for method in requestMethods:
print(method)
从前面的代码中可以看出，字典是一个比较特殊的数据类型，由key-value组成，在使用for-in遍历字典时，默认遍历的是字典的所有key,相当于下面的代码
requestMethods = {
"get": "用于获取服务器上的资源，通过在URL中传递参数来发送请求。",
"post": "用于向服务器提交数据，一般用于创建新的资源或进行修改操作。",
"put": "用于更新服务器上的资源，一般用于修改已存在的资源的全部内容。",
"delete": "用于删除服务器上的资源。"
}
for method in requestMethods.keys():
print(method)
如果想遍历字典中的所有值，可以使用下面的方式
requestMethods = {
"get": "用于获取服务器上的资源，通过在URL中传递参数来发送请求。",
"post": "用于向服务器提交数据，一般用于创建新的资源或进行修改操作。",
"put": "用于更新服务器上的资源，一般用于修改已存在的资源的全部内容。",
"delete": "用于删除服务器上的资源。"
}
for method in requestMethods.values():
print(method)
但是直接对字典取值遍历的使用方式大多数情况下是无意义的。
示例： 通过遍历字典的key,输出每个key对应的值。
requestMethods = {
"get": "用于获取服务器上的资源，通过在URL中传递参数来发送请求。",
"post": "用于向服务器提交数据，一般用于创建新的资源或进行修改操作。",
"put": "用于更新服务器上的资源，一般用于修改已存在的资源的全部内容。",
"delete": "用于删除服务器上的资源。"
}
for method in requestMethods:
print(f"请求方式【 {method} 】的作用为：【 {requestMethods[method]} 】")
此种方式虽然可以取到结果，但是for-in循环在遍历字符时，配合字典的items()方法，实现更简单的方法
requestMethods = {
"get": "用于获取服务器上的资源，通过在URL中传递参数来发送请求。",
"post": "用于向服务器提交数据，一般用于创建新的资源或进行修改操作。",
"put": "用于更新服务器上的资源，一般用于修改已存在的资源的全部内容。",
"delete": "用于删除服务器上的资源。"
}
for item in requestMethods.items():
print(f"请求方式【 {item[0]} 】的作用为：【 {item[1]} 】")
甚至，代码还可以配合解包操作，更简单的实现
requestMethods = {
"get": "用于获取服务器上的资源，通过在URL中传递参数来发送请求。",
"post": "用于向服务器提交数据，一般用于创建新的资源或进行修改操作。",
"put": "用于更新服务器上的资源，一般用于修改已存在的资源的全部内容。",
"delete": "用于删除服务器上的资源。"
}
for key, value in requestMethods.items():
print(f"请求方式【 {key} 】的作用为：【 {value} 】")
作业
回文数实现
def huiwenshu():
"""
编写一个Python程序，输入一个5位数，
判断输入的这个数字是否为回文数。
回文数是指从左到右和从右到左读都一样的数。例如12321。如果输入的是回文数，输出是回文数，否则输出不是回文数。
:return:
"""
# 输入一个5位数
num = str(input("请输入一个5位数：\n"))
flag = True
# 判断是否是5位数
if len(num) == 5:
# 编辑字符串的一半字符
for i in range(len(num) // 2):
if num[i] != num[-i-1]:
flag = False
break
if flag:
print(f"{num}是一个回文数")
else:
print(f"{num}不是一个回文数")
else:
print("请输入5位数字！")
五、数字序列
range函数
range() 函数是一个用于生成整数序列的内置函数，通过指定起始值、停止值和步长，它能够生成一个按照指定规则递增或递减的整数序列。
range() 通常用于配合for-in循环结构中控制迭代次数或遍历特定范围的情况使用。
range函数的基本语法
格式：range(start, stop, step)
-
start: 可选参数，表示起始值，默认为0。 -
stop: 表示结束值，不包含在范围内。 -
step: 可选参数， 表示步长，默认为1。
# 确定开始和结束范围
nums = list(range(1, 10))
print(nums)
# 使用默认开始值
nums = list(range(10))
print(nums)
# 确定范围和步长
nums = list(range(1, 10, 2))
print(nums)
# 使用负步长
nums = list(range(10, 1, -3))
print(nums)
for-in结合range函数实现计次循环
for i in range(10):
print(i)
示例：计算 1~100 的整数和
result = 0
for i in range(1, 101):
result += i
print(result)
随机数
在程序开发过程中，经常会使用到随机数，Python 中 ，可以使用 random 模块中的 randint() 函数获取随机数。
格式： randint(start, stop)
-
start为随机数获取初始范围 -
stop为随机数获取结束范围，包含该值。 - 使用该函数前需要导入，
from random import randint
from random import randint
print(randint(1, 3))
# 输出：3
示例： 骰子游戏： 从键盘输入一个数字，和程序随机生成的 1~6范围的数字比较大小
from random import randint
play = int(input("请输入一个1-6之间的数字："))
bot = randint(1, 6)
if play == bot:
print("点数相同，平局")
elif play > bot:
print(f"玩家{play}点，电脑{bot}点，玩家胜")
else:
print(f"玩家{play}点，电脑{bot}点，电脑胜")
作业
猜数字
def caishuzi():
"""
编写一个 Python 程序，实现一个猜数字的游戏。
程序随机生成一个1-100目标数字，在一定的范围内，玩家需要根据提示猜测目标数字，直到猜中为止。
游戏会根据玩家的猜测给出提示，告诉玩家猜的数字是大了还是小了，最终告诉玩家猜对了，并显示猜测次数。
:return:
"""
bot = randint(1, 101)
guess_count = 0
while True:
num = int(input("请输入猜测数字：\n"))
guess_count += 1
if num == bot:
print(f"猜对了！正确数字是{num}, 猜测次数是{guess_count}")
break
elif num > bot:
print(f"大了，请重新猜")
else:
print(f"小了，请重新猜")
猜拳游戏
def caiquan_game():
"""
编写一个Python程序，实现一个简单的猜拳游戏。
玩家和电脑各自选择石头、剪刀或布，根据规则判断胜负关系，并输出比赛结果。
:return:
"""
player = input("请输入玩家选择的选项（石头/剪刀/布）：")
bot = random.choice(["石头", "剪刀", "布"])
print(f"电脑出拳：{bot}")
if player == bot:
print("平局")
elif (player == "石头" and bot == "剪刀") or\
(player == "剪刀" and bot == "布") or \
(player == "布" and bot == "石头"):
print("玩家胜！")
else:
print("电脑胜！")
词频次数
def cipin():
"""编写一个Python程序，来计算给定文本中每个单词出现的次数。"""
text = """
Python is a popular programming language. It is widely used for web development, data science, and more.
Python has a simple and readable syntax, which makes it great for beginners.
"""
# 大小写统一
last_text = text.lower()
# 分单词
words = last_text.split()
# 保存单词及次数的字典
word_count = {}
for word in words:
# 去除标点符号
word = word.strip(",.")
# 如果单词在保存的字典里，则次数加一
if word in word_count:
word_count[word] += 1
# 如果单词不在保存的字典里，则新增1次
else:
word_count[word] = 1
for word, count in word_count.items():
print(f"{word}:{count}")
水仙花数
def shuixianhuashu():
"""
编写一个 Python 程序，找出100-999范围内的水仙花数。
所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。
例如：153是一个"水仙花数"，因为153=1的三次方＋5的三次方＋3的三次方。
"""
for num in range(100, 1000):
# 获取百位数
i = num // 100
# 获取十位数
j = num // 10 % 10
# 获取个位数
k = num % 10
if num == i ** 3 + j ** 3 + k ** 3:
# 输出水仙花数
print(f"水仙花数为{num}")
六、循环嵌套特征
- 循环嵌套不局限于某种循环形式，可任意相互嵌套
- 外层循环循环一次，内层循环循环一轮
示例1：使用 for-in 循环遍历二维列表
data = [
[1,2,3,4,5,6,7,8,9],
["A","B","C","D","E"],
["Hello","World","Python","Hogwarts"]
]
for item in data:
for el in item:
print(el)
分组显示：
data = [
[1, 2, 3, 4, 5, 6, 7, 8, 9],
["A", "B", "C", "D", "E"],
["Hello", "World", "Python", "Hogwarts"]
]
for item in data:
for el in item:
print(el, end=" ")
print()
示例2：使用 while 循环遍历二维列表
data = [
[1,2,3,4,5,6,7,8,9],
["A","B","C","D","E"],
["Hello","World","Python","Hogwarts"]
]
l1 = len(data)
i = 0
while i < l1:
item = data[i]
l2 = len(item)
j = 0
while(j < l2):
el = item[j]
print(el)
j += 1
i += 1
示例3: 输出九九乘法表的结果
for i in range(1,10):
for j in range(1,i+1):
print(i*j, end=" ")
print()
实战作业
- 使用
for-in内嵌while访问示例中的二维列表
def forinwhile():
"""使用 `for-in` 内嵌 `while` 访问示例中的二维列表"""
data = [
[1, 2, 3, 4, 5, 6, 7, 8, 9],
["A", "B", "C", "D", "E"],
["Hello", "World", "Python", "Hogwarts"]
]
for item in data:
i = 0
length = len(item)
while i < length:
el = item[i]
print(el, end=" ")
i += 1
print()
- 使用
while内嵌for-in访问示例中的二维列表
def whileforin():
"""使用 while 内嵌 for-in 访问示例中的二维列表"""
data = [
[1, 2, 3, 4, 5, 6, 7, 8, 9],
["A", "B", "C", "D", "E"],
["Hello", "World", "Python", "Hogwarts"]
]
i = 0
length = len(data)
while i < length:
item = data[i]
for el in item:
print(el, end=" ")
i += 1
print()
- 实现 九九乘法表标准格式输出
def chengfaguocheng():
for i in range(1, 10):
for j in range(1, i+1):
print(f"{i}*{j}={i*j}", end=" ")
print()
作业
数字组合
def shuzizuhe():
"""
编写一个 Python 程序，
输出所有由数字1、2、3、4 组成的互不相同且无重复数字的三位数。
即个位，十位，百位互不相同且无重复数字。
"""
for i in range(1, 5):
for j in range(1, 5):
for k in range(1, 5):
if i != j and i != k and j != k:
print(f"{i}{j}{k}")
七、循环跳转
在使用循环进行实现逻辑时，并不是每次都会将循环执行完毕，或者循环根本没有结束的条件，此时，在循环过程中，期望达到某个条件时，结束循环继续向后执行，此时，就可以使用循环跳转来完成此功能。
Python中提供两种循环跳转语句：
-
break结束当前循环 -
continue结束本次循环
在讲解之前，先来了解一种特殊的循环方式。
死循环
死循环是指循环条件恒等为真，循环会一直执行下去，死循环并不是一种错误语法，反之，有效使用死循环可以解决很多问题。但实际使用中，还是要尽量避免死循环的使用。
while True:
print("Hogwarts!")
一般，在不确定循环次数的情况下，可以使用死循环来实现。比如web服务器监听处理客户端的请求连接，服务器并不知道会有多少客户端会连接，此时就可以使用死循环实现。
示例： 从键盘持续输入数据，每输入一次，将数据添加到列表中保存
data = []
while True:
d = input("请输入数据：")
data.append(d)
print(data)
此程序只为演示死循环的使用方式，并无实际意义。
break 语句
break 语句可以中止当前的while 或for-in循环，无论循环还有多少次没有循环，都会无条件结束循环后，跳转到循环后的语句继续执行。
以生活中的跑步为例，计划跑 5 圈，可是在跑到第 2 圈的时候，接到了室友的电话叫去吃大餐，于是果断停下来，中止跑步，这就相当于使用 break 语句提前中止了循环。
break 语句的语法比较简单，只需要在相应的 while 或 for 语句中加入即可。
前面的示例自用 break 可以优化为,当输入 bye 时，结束输入
data = []
while True:
d = input("请输入数据：")
if d == "bye":
break
data.append(d)
print(data)
需要注意的是，break 语句出现在多层循环中时，所处在哪个循环的循环体内，就跳出哪个循环，更外层的循环不受影响。
for i in range(2):
for j in range(5):
print("Hello", j)
if j == 2:
break
continue 语句
continue 语句的作用用来中止本次循环而提前进入下一次循环中，循环体中未执行完的代码不在执行。
仍然以操场跑步为例，计划跑 5 圈，但是在跑完每圈的前一百米就回到起点重新跑，后面的不太跑了。
for i in range(10):
print("*" * 10)
print("i=",i)
if i % 3 == 0:
continue
print("i*10= ", i*10)
大多数情况下，可以通过改变条件的方式，避免continue的使用。而代码更简洁。
for i in range(10):
print("*" * 10)
print("i=",i)
if i % 3 != 0:
print("i*10= ", i*10)
loop-else
在Python中，不只if 语句可以使用else, 循环语句也可以使用else。
当一个循环没有被break中断而正常循环结束，就会执行else后的代码块。
for i in range(5):
print(i)
else:
print("Over")
如果循环被断，则不会执行else后的语句
for i in range(5):
print(i)
if i == 2:
break
else:
print("Over")
在某些场景下，else 可以简化代码。
names = ["tom","jack","rose","tony"]
inName = input("请输入要查找的姓名：")
# 不使用Else形式
flag = False
for name in names:
if name == inName:
print("找到了")
flag = True
break
if not flag:
print("没找到")
# 使用Else形式
for name in names:
if name == inName:
print("找到了")
break
else:
print("没找到")
八、推导式
Python 推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。
Python 支持各种数据结构的推导式：
- 元组(tuple)推导式
- 列表(list)推导式
- 字典(dict)推导式
- 集合(set)推导式
元组推导式
元组推导式可以利用 range 区间、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的元组。
元组推导式基本格式：
(out_exp_res for item in Sequence )
或
(out_exp_res for item in Sequence if conditional )
-
out_exp_res：生成元素表达式，可以是有返回值的函数。 -
for out_exp in Sequence：迭代 Sequence 将 out_exp 传入到 out_exp_res 表达式中。 -
if condition：条件语句，可以过滤Sequence中不符合条件的值。
# 简单的元组推导式
t1 = (x for x in range(1,10))
# 生成128位ASCII码元组
t2 = (chr(x) for x in range(128))
# 生成100以内能被7整除所有数字的元组
t3 = (x for x in range(100) if x%7==0)
# 生成99乘法表结果元组
t4 = (x*y for x in range(1,10) for y in range(1, x+1))
words = ["apple", "banana", "cherry"]
upper_words = (word.upper() for word in words)
列表推导式
列表推导式与元组推导式的区别：
- 格式上外部由圆括号包裹的表达式改为中括号
列表推导式格式为：
[out_exp_res for item in Sequence ]
或
[out_exp_res for item in Sequence if conditional ]
-
out_exp_res：生成元素表达式，可以是有返回值的函数。 -
for out_exp in Sequence：迭代 Sequence 将 out_exp 传入到 out_exp_res 表达式中。 -
if condition：条件语句，可以过滤Sequence中不符合条件的值。
# 简单的元组推导式
l1 = [x for x in range(1,10)]
# 生成128位ASCII码元组
l2 = [chr(x) for x in range(128)]
# 生成100以内能被7整除所有数字的元组
l3 = [x for x in range(100) if x%7==0]
# 生成99乘法表结果元组
l4 = [x*y for x in range(1,10) for y in range(1, x+1)]
# 将列表中的字符串转换为大写
words = ["apple", "banana", "cherry"]
upper_words = [word.upper() for word in words]
字典推导式
字典推导式与前两种推导式的区别
- 推导式使用花括号包裹
- 结果表达式需要使用 key-value 形式
字典推导基本格式：
{ key_expr: value_expr for value in collection }
或
{ key_expr: value_expr for value in collection if condition }
names = ['Bob','Tom','alice','Jerry','Wendy','Smith']
# 将列表中各字符串值为键，各字符串的长度为值，组成键值对
newdict = {name:len(name) for name in names}
集合推导式
集合推导式与字典推导式的区别在于结果表达式是单一结果，不是key-value形式。
集合推导式基本格式：
{ expression for item in Sequence } 或 { expression for item in Sequence if conditional }
data = ['Bob','123','Tom','ab123','alice','123abc','Jerry','456','Wendy','554','Smith']
# 筛选列表中的数字字符串
newset = {n for n in data if n.isdigit()}
推导式的优点
- 简洁高效：推导式允许在一行代码中完成复杂的生成操作，避免了使用显式的循环和临时变量的繁琐过程。这样可以大大减少代码量，并提高编码效率。
- 可读性好：推导式使用简洁的语法，将迭代、条件判断和表达式结合在一起，使得代码更加紧凑和易于理解。它提供了一种清晰、直观的方式来表达列表生成的逻辑，使得代码更加可读性强，降低了出错的可能性。
- 灵活性强：推导式非常灵活，可以根据需要添加条件判断、多个迭代变量和嵌套结构，以满足不同的需求。这使得推导式适用于各种场景，从简单的数据转换到复杂的筛选和操作，都可以通过简单而直观的语法实现。
总的来说，推导式提供了一种简洁高效、可读性好和灵活性强的方法来处理列表数据。它是Python中强大而常用的特性之一，为开发者提供了更好的编码体验和效率。