大模型学习-python基础Day3
流程控制语句
顺序，分支，循环
一.分支
1.单分支
语法：
if 条件判断（True/False）：
语句
根据条件表达式返回的结果决定是否执行语句内容
如果返回true，则执行语句；若返回falsse，则语句不会被执行。
2.双分支
语法：
if 条件判断（True/False）：
语句1
else：
语句2
3.多分支
语法：
if 条件判断（True/False）：
语句1
elif 条件判断（True/False）：
语句2
......
else：
语句n
使用多分支语句，需要注意以下几点：
if语句至多有1个else语句，else语句在所有的elif语句之后；
if语句可以有若干个elif语句，他们必须在else之前；
一旦其中一个分支检测为true，其他的elif以及else语句都不会执行；
score = 85
if score >= 90:
print("优秀")
elif score >= 80:
print("良好")
elif score >= 60:
print("及格")
else:
print("不及格")
4.match case语句
match subject: #subject是表达式，返回结果和后面case的值进行匹配
case pattern1:
# 处理 pattern1
case pattern2:
# 处理 pattern2
case _:
# 默认情况
point = (3, 4)
match point:
case (0, 0):
print("原点")
case (0, y):
print(f"Y轴上，y={y}")
case (x, 0):
print(f"X轴上，x={x}")
case (x, y):
print(f"坐标({x}, {y})")
5.三目运算符
condition ? exprIfTrue : exprIfFalse
condition：布尔表达式，结果为true或false。exprIfTrue：条件为true时执行的表达式。exprIfFalse：条件为false时执行的表达式。
let score = 85;
let grade = score >= 90 ? "A" : score >= 80 ? "B" : "C";
console.log(grade); // 输出："B"
二.循环
1.while循环
while condition:
# 循环体代码
# 需包含改变条件的语句，避免无限循环
- 条件前置：先判断条件，再决定是否执行循环体。
- 手动控制循环变量：需在循环体内修改条件相关的变量，否则可能导致无限循环。
- 适用场景：适合循环次数不确定的情况（如用户输入验证、动态数据遍历）。
while-else语句
while condition:
# 循环体代码
else:
# 循环正常结束后执行的代码
- 当
condition为True时，循环体代码会重复执行。 - 当
condition变为False时，循环终止，并执行else块中的代码。 - 如果在循环体中遇到
break语句，循环会立即终止，且else块不会执行。
利用break中断while循环
count = 0
while count < 3:
if count == 1:
break #结束整个循环
print(f"Count is {count}")
count += 1
else:
print("Loop ended normally")
2.for语句
for i in range(3):
print(i)
else:
print("Loop completed")
for 临时变量 in 可迭代对象：
重复执行的代码（循环体）
else：
循环正常结束时候，执行的代码
#遍历列表
for i in [10,20,30]
print(i)
#遍历字符串
for str in "hello world"
print(str)
#遍历range数列
for i in range(10):
print(i)
range(a,b):从a到b-1，左闭右开
range使用
range(stop)
range(start, stop[, step])
不指定起始值时，默认从0开始到stop-1结束：
for i in range(5):
print(i) # 输出0,1,2,3,4
添加步长参数可控制序列间隔：
for i in range(0, 10, 2):
print(i) # 输出0,2,4,6,8
负步长可生成递减序列：
for i in range(5, 0, -1):
print(i) # 输出5,4,3,2,1
生成一个九九乘法表
for i in range(1, 10): # 外层循环控制行数（1到9）
for j in range(1, i + 1): # 内层循环控制列数（1到当前行数）
print(f"{j} x {i} = {i * j}", end="\t") # 使用制表符对齐
print() # 每行结束后换行
3.循环中的关键字
continue关键字：跳过当次正在进行的循环，后面代码也不再执行，直接进入下一轮循环
for i in range(5):
if i == 2:
continue
print(i) # 输出 0 1 3 4
break关键字：立即停止当前循环，跳出当前循环体
for i in range(10):
if i == 5:
break
print(i) # 输出 0 1 2 3 4
pass关键字：空操作占位符，保持语法完整性但不执行任何操作。常用于未完成的代码块。
for i in range(3):
pass # 无操作
三.列表
列表是一个可变的、有序的元素集合
列表使用[]定义，数据之间使用，分隔
列表中每个元素都有对应的位置值，称为索引从起始从0开始向后逐个递增，并且从末尾-1开始逐个向前递减
列表中元素可以是不同类型
1.创建列表
fruits = ["apple", "banana", "cherry"]
numbers = [1, 2, 3, 4]
mixed = [1, "text", True]
#访问列表中的元素
print(numbers[0]) #1
print(numbers[1]) #2
print(numbers[-1]) #4
2.列表切片
Python中的列表切片允许提取列表的一部分，语法为list[start:stop:step]。start表示起始索引（包含），stop表示结束索引（不包含），step表示步长（默认为1）。
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
slice_part = numbers[2:7] # 结果为 [2, 3, 4, 5, 6]
#打印所有元素
print(numbers[:]) #结果[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
#取索引从2到4（不包含）的元素
print(numbers[2:4])
#从索引2开始到末尾的元素
print(numbers[2:])
#索引从0开始到2（不包含）的元素
print(numbers[:2])
#倒序取所有元素
print(numbers[::-1])
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
even_indices = numbers[::2] # 结果为 [0, 2, 4, 6, 8]
reversed_list = numbers[::-1] # 结果为 [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
3.列表中添加元素
使用append()方法
append()方法用于在列表末尾添加单个元素。该方法直接修改原列表，无返回值。
my_list = [1, 2, 3]
my_list.append(4) # 添加后列表变为 [1, 2, 3, 4]
使用insert()方法
insert()方法可在指定索引位置插入单个元素。需提供插入位置的索引和元素值。
my_list = [1, 3]
my_list.insert(1, 2) # 在索引1处插入2，列表变为 [1, 2, 3]
使用extend()方法
extend()方法用于在列表末尾添加多个元素（通常为可迭代对象）。与append()不同，它会将可迭代对象的元素逐个加入列表。
my_list = [1, 2]
my_list.extend([3, 4]) # 添加后列表变为 [1, 2, 3, 4]
4.列表相加，列表乘法
list1 = [1, 2, 3]
list2 = [4, 5, 6]
result = list1 + list2
print(result) # 输出: [1, 2, 3, 4, 5, 6]
list1 = [1, 2, 3]
result = list1 * 3
print(result) # 输出: [1, 2, 3, 1, 2, 3, 1, 2, 3]
5.修改列表中的元素
通过索引修改单个元素
my_list = [1, 2, 3, 4]
my_list[1] = 20 # 将索引1的元素从2改为20
print(my_list) # 输出: [1, 20, 3, 4]
通过切片修改多个元素
my_list = [1, 2, 3, 4]
my_list[1:3] = [20, 30] # 修改索引1到2的元素
print(my_list) # 输出: [1, 20, 30, 4]
列表解析式修改
my_list = [1, 2, 3, 4]
my_list = [x*2 for x in my_list] # 创建新列表，每个元素乘以2
print(my_list) # 输出: [2, 4, 6, 8]
注意事项
- 索引从0开始，注意不要越界
- 切片修改时，右侧可迭代对象的长度不必与切片长度相同
- 列表解析式会创建新列表，原列表对象会被替换
6.检查成员成员是否为列表中的元素
list1 = [100,"liujie",200]
print(100 in list1) #true
7.获取列表长度
list1 = [100,200,300]
print(len(list1)) #3
8.求列表中元素的最大、最小、加和
numbers = [3, 1, 4, 1, 5, 9, 2]
max_value = max(numbers)
min_value = min(numbers)
total = sum(numbers)
print(f"最大值: {max_value}")
print(f"最小值: {min_value}")
print(f"总和: {total}")
9.遍历列表
使用for循环直接遍历
直接使用for item in list结构可以依次访问列表中的每个元素：
my_list = [1, 2, 3]
for item in my_list:
print(item)
通过索引遍历
利用range(len(list))获取索引范围，通过下标访问元素：
for i in range(len(my_list)):
print(my_list[i])
使用enumerate函数
同时获取元素和对应的索引：
for index, item in enumerate(my_list):
print(f"Index: {index}, Value: {item}")
10.列表的删除
删除列表中所有匹配的特定值
使用 list.remove(value) 方法可以删除列表中第一个匹配的指定值。若需删除所有匹配值，需结合循环或列表推导式。
my_list = [1, 2, 2, 3, 2]
my_list.remove(2) # 仅删除第一个2，列表变为 [1, 2, 3, 2]
# 删除所有2
my_list = [x for x in my_list if x != 2] # 列表推导式生成新列表 [1, 3]
使用 del 语句或 list.pop() 方法可以删除列表中指定位置的元素。
del list[index]：直接删除索引位置的元素，不返回被删除的值。list.pop(index)：删除并返回索引位置的元素，若省略index则默认删除最后一个元素。
my_list = [1, 2, 3, 4, 5]
del my_list[1] # 删除索引1的元素，列表变为 [1, 3, 4, 5]
popped_item = my_list.pop(2) # 删除索引2的元素，返回4，列表变为 [1, 3, 5]
11.嵌套列表
nested_list = [1, [2, 3], [4, [5, 6]]]
value = nested_list[1][0] # 获取子列表中的第一个元素
12.列表推导式
[expression for item in iterable if condition]
- expression：对当前迭代项的操作或表达式。
- item：迭代变量，代表可迭代对象中的每个元素。
- iterable：可迭代对象（如列表、字符串、元组等）。
- condition（可选）：过滤条件，仅当条件为真时保留该项。
基础用法
squares = [x**2 for x in range(10)]
# 输出：[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
带条件的过滤
even_numbers = [x for x in range(20) if x % 2 == 0]
# 输出：[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
包含多个循环的列表推导式
list1 = [1,2,3,4,5]
list2 = ['a','b','c','d','e']
list3 = [(i,j) for i in list1 for j in list2]
[(1, 'a'), (1, 'b'), (1, 'c'), (1, 'd'), (1, 'e'),
(2, 'a'), (2, 'b'), (2, 'c'), (2, 'd'), (2, 'e'),
(3, 'a'), (3, 'b'), (3, 'c'), (3, 'd'), (3, 'e'),
(4, 'a'), (4, 'b'), (4, 'c'), (4, 'd'), (4, 'e'),
(5, 'a'), (5, 'b'), (5, 'c'), (5, 'd'), (5, 'e')]
13.zip函数
names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]
paired = zip(names, ages)
print(list(paired)) # 输出: [('Alice', 25), ('Bob', 30), ('Charlie', 35)]
14.常用函数
常用列表函数整理（现用现查）
| 函数/方法 | 描述 | 示例 |
|---|---|---|
append(x) | 在列表末尾添加元素x | lst.append(1) |
extend(iterable) | 将可迭代对象的所有元素添加到列表末尾 | lst.extend([2, 3]) |
insert(i, x) | 在索引i处插入元素x | lst.insert(0, 'a') |
remove(x) | 删除列表中第一个值为x的元素 | lst.remove('a') |
pop([i]) | 删除并返回索引i处的元素（默认最后一个） | lst.pop() |
clear() | 删除列表中的所有元素 | lst.clear() |
index(x) | 返回第一个值为x的元素的索引 | lst.index(2) |
count(x) | 返回x在列表中出现的次数 | lst.count(1) |
sort() | 对列表进行排序 | lst.sort() |
reverse() | 反转列表中的元素顺序 | lst.reverse() |
copy() | 返回列表的浅拷贝 | new_lst = lst.copy() |
len() | 返回列表的长度 | len(lst) |
max() | 返回列表中的最大值 | max(lst) |
min() | 返回列表中的最小值 | min(lst) |
sum() | 返回列表中所有元素的和（仅限数值列表） | sum(lst) |
sorted() | 返回排序后的新列表（不修改原列表） | sorted(lst) |
reversed() | 返回反向迭代器（不修改原列表） | list(reversed(lst)) |
enumerate() | 返回枚举对象（包含索引和值的元组） | list(enumerate(lst)) |
zip() | 将多个列表的元素配对为元组 | list(zip(lst1, lst2)) |
filter() | 根据函数过滤列表元素 | list(filter(lambda x: x > 0, lst)) |
map() | 对列表的每个元素应用函数 | list(map(str, lst)) |
any() | 检查列表中是否有任一元素为True | any(lst) |
all() | 检查列表中所有元素是否都为True | all(lst) |
slice() | 返回切片对象，用于列表切片 | lst[slice(1, 3)] |
注意事项
- 表中列出的函数和方法适用于Python的列表（
list）类型。 - 部分函数（如
len、max、min等）是内置函数，可直接使用。 - 部分方法（如
sort、reverse等）会直接修改原列表。 - 使用
filter和map时，通常需要结合lambda表达式或自定义函数。
浅拷贝copy方法：
copy方法用于创建对象的浅拷贝。浅拷贝意味着新对象是原对象的一个副本，但只复制了最外层的对象，内部嵌套的对象仍然是引用。浅拷贝会创建一个新对象，其内容是原对象中元素的引用。对于可变对象（如列表、字典），修改新对象的嵌套元素会影响原对象。
import copy
original_list = [1, 2, [3, 4]]
shallow_copied_list = copy.copy(original_list)
# 修改浅拷贝列表的顶层元素
shallow_copied_list[0] = 100
print(original_list) # 输出: [1, 2, [3, 4]]
# 修改浅拷贝列表的嵌套元素
shallow_copied_list[2][0] = 300
print(original_list) # 输出: [1, 2, [300, 4]]
更多推荐
6
0- 0
已为社区贡献17条内容
所有评论(0)