Python语言学习笔记
·
数据容器-列表（list）
列表的常见方法：
| 方法 | 作用 | 样例 |
|---|---|---|
| append() | 在列表尾部追加元素 | s.append(10000) |
| insert() | 在指定索引之前，插入该元素 | s.insert（0，92） s.insert(索引，元素） |
| remove() | 移除列表中第一个匹配到的值 | s.remove(75) |
| pop() | 删除列表中指定索引位置的元素(未指定索引，删除最后一个） | s.pop(2) / s.pop() |
| sort() | 对列表进行排序(列表元素数据类型一致，才可进行排序) | s.sort() |
| reverse() | 反转列表元素 | s.reverse() |
s=[56,90,88,65,90,100,200,72,145]
print(s)
s.append(188)
print(s)
s.insert(2,80)
print(s)
s.remove(90)
print(s)
e=s.pop(1)
print(e)
e=s.pop()
print(e)
s.sort()
print(s)
s.reverse()
print(s)
[56, 90, 88, 65, 90, 100, 200, 72, 145]
[56, 90, 88, 65, 90, 100, 200, 72, 145, 188]
[56, 90, 80, 88, 65, 90, 100, 200, 72, 145, 188]
[56, 80, 88, 65, 90, 100, 200, 72, 145, 188]
80
188
[56, 65, 72, 88, 90, 100, 145, 200]
[200, 145, 100, 90, 88, 72, 65, 56]Python中用于数据统计的常见语句：
| min() | 获取最小值 | min(s) |
| max() | 获取最大值 | max(s) |
| len() | 获取元素个数 | len(s) |
| sum() | 求和 | sum(s) |
列表案例：
案例1：将用户输入的10个数字，存储到一个列表中，并将列表中的数字进行排序，输出其中最小值、最大值和平均值。
#1.定义列表 num_list= [] #2.将用户输入10个数字存入列表 for i in range(10): num=int(input("请输入一个有效数字：")) num_list.append(num) print("数字列表：",num_list) #排序 num_list.sort() print("排序后的数字列表：",num_list) #4.输入其中的最小值、最大值和平均值 print("最小值：",num_list[0]) print("最大值:",num_list[-1]) print("平均值：",sum(num_list)/len(num_list))备注：定义 列表，循环输入数字，append方法存入列表，打印列表，sort方法给列表排序，根据索引列出最小值和最大值、平均值。
案例2：合并两个列表中的元素，并对合并的结果进行去重处理（去除列表中的重复元素）。
num_list1 =[19,23,54,64,875,20,109,232,123,54] num_list2 = [5, 80,72, 35, 60,123, 54, 29, 91] #1.合并列表 #解包：将列表这一容器解开成一个一个独立元素 #组包：将多个值合并到一个容器 #合并方法1：解包+组包 num_list=[*num_list1,*num_list2] #合并方法2：遍历列表元素后，append添加 num_list=num_list1+num_list2 #合并方法3：遍历列表元素后，append添加 for num in num_list1: num_list2.append(num) #去除重复记录 new_list=[]#去除重复记录后的列表 for num in num_list: if num not in new_list: #去重 new_list.append(num) print(new_list)
解包：将列表这一容器解开成一个一个独立元素
*num_list1
*num_list2
组包：将多个值合并到一个容器
num_list=[*num_list1,*num_list2]
案例2知识点：
1.如何快速合并两个列表？
- 使用+运算符直接合并
- 使用*进行解包操作（解包指将列表这一类数据容器解开成独立的元素）
2.如何判断一个元素是否存在于列表之中？
- 可以使用in运算符，语法为 元素 in 列表
- 返回结果为布尔值，True表示存在，False表示不存在
案例3：生成1-20平方列表
方式一：传统方式
num_list=[]
for i in range(1,21):
num_list.append(i**2)
print(num_list)
方式二：列表推导式--->就是按照一定的方式生成一个列表的方式-->
语法格式1：[要插入的值 for i in 序列/列表]
num_list2 = [i**2 for i in range(1,21)] print(num_list)
案例4：从如下数字列表中提取所有偶数，并计算其平方，组成一个新的列表
方式一：列表推导式--->就是按照一定的方式生成一个列表的方式-
语法格式2：[要插入的值 for i in 序列/列表 if 条件]
num_list=[12,32,45,77,80,92,33,57,97,98]
new_list=[i**2 for i in num_list if i%2==0]
print(new_list)
列表练习题：
数据容器-字符串（str）
- 介绍：字符串是字符的容器，一个字符串可以存放任意数量的字符。
- 特点:不可变性（无法修改）、有序性、可迭代性（可以遍历 ）。
- 字符串中的每个一个字符元素都有其对应的下标（索引），通过元素对应的索引，就可获取到对应的元素。
字符串的特点
不可变性（无法修改）
s = "Hello Python" print(s[4]) # Forward indexing print(s[-8]) # Reverse indexing s[4] = "X" print(s)
bash
C:\Users\xxx\AppData\Roaming\Python\Scripts\uv.exe run D:/develop/Python/Python314/python.exe C:\Users\wangy\PycharmProjects\test\lesson\data-container-str.py
o
Traceback (most recent call last):
File "C:\Users\wangy\PycharmProjects\test\lesson\data-container-str.py", line 5, in <module>
s[4] = "X"
~^^^
TypeError: 'str' object does not support item assignment
Process finished with exit code 1
可迭代性
s = "Hello Python
for i in s:
print(i)
有序性
字符串的索引
- 正向索引：从0开始
- 反向索引：从-1开始
字符串的切片
语法：s[start:end:step]
- start：开始索引，不指定默认为0（第一个元素的索引）
- end：结束索引，不指定默认为-1（最后一个元素的索引）
- step：步长，不指定默认为1（-1表示从后向前）
s = "Hello Python" #切片 print(s[0:5:1]) print(s[:5:1]) print(s[:5:]) print(s[:5]) print(s[6:12:2]) #结束位置11索引位+1 才能包含 print(s[12:6:-1]) #开始索引和结束索引必须与步长方向保持一致 print(s[6::1]) #从6开始到末尾 print(s[6::]) #从6开始到末尾 print(s[-6:]) # 从后 个 print(s[::-1]) #反转
字符串的常用方法
| 方法 | 作用 | 样例 |
| find() | 在字符串中查找子串，返回第一次出现的索引位置，找不到返回-1 | s.find('Python') |
| count() | 统计子串在字符串中出现的次数 | s.count('H') |
| upper() | 将字符串中的所有字母转换为大写 | s.upper() |
| lower() | 将字符串中的所有字母转换为小写 | s.lower() |
| split() | 将字符串指定分隔符分割成列表 | s.split(' ') |
| strip() | 去除字符串两端的空白字符或指定字符 | s.strip()/s.strip('*') |
| replace() | 将字符串中的子串替换为新的子串 | s.replace('H','C') |
| startswith() | 检查字符串是否以指定子串开头，返回布尔值 | s.startswtich('P') |
字符串案例
1．邮箱格式验证：用户输入一个邮箱，验证邮箱格式是否正确(包含一个@和至少一个·)，如果输入正确，输出"邮箱格式正确"，否则输出"邮箱格式错误"。
#方式一:
mail = input("请输入邮箱：")
if mail.count("@") == 1 and mail.count(".") >= 1:
print(f"{mail}的邮箱格式正确")
else:
print(f"{mail}的邮箱格式错误")
#方式二：in 运算符
mail = input("请输入邮箱：")
if mail.count("@") == 1 and mail.count(".") >= 1:
if mail.count("@") == 1 and "." in mail:
print(f"{mail}的邮箱格式正确")
else:
print(f"{mail}的邮箱格式错误")
1．如何判断指定的子字符串是否出现在字符串之中？
- in 运算符，返回bool值
s = "Hello Python" r = 'H' in s print(r)
1，输入一个字符串，判断该字符串是否是回文（两边对称）
- 黄山落叶松叶落山黄
- 上海自来水来自海上
str = input("请输入字符串:")
if str == str[::-1]:
print(f"{str}是回文")
else:
print(f"{str}不是回文")
2．将用户输入的10个字符串，反转后全部转换为大写，然后记录在列表中，最后将列表内容，遍历输出出来。
基础版本（直接实现需求）
strings = []
for i in range(10):
s = input(f"请输入第{i+1}个字符串: ")
strings.append(s)
2. 反转并转换为大写，存入新列表
result = []
for s in strings:
reversed_upper = s[::-1].upper()
result.append(reversed_upper)
3. 遍历输出
for item in result:
print(item)
精简版本（列表推导式）
# 1. 接收用户输入的10个字符串
strings = [input(f"请输入第{i+1}个字符串: ") for i in range(10)]
2. 使用列表推导式将每个字符串反转并转换为大写
result = [s[::-1].upper() for s in strings]
3. 遍历输出处理后的结果
for item in result:
print(item)
增强版本（带序号输出 + 输入验证）
strings = []
for i in range(10):
s = input(f"请输入第{i+1}个字符串: ")
# 可选：去除首尾空格
strings.append(s.strip())
反转并转大写
result = [s[::-1].upper() for s in strings]
带序号遍历输出
for index, item in enumerate(result, start=1):
print(f"第{index}个处理结果: {item}")
数据容器-元组（tuple）
1.为什么要用元组？
- 元素可重复、有序、可以修改的
2.如果要记录一些信息，而这些信息，不能被修改，只能查询呢？
- 列表就不合适
- 此时就可以考虑元组，元组与列表最大的不同点在于：元组一旦定义完成，不可修改
介绍
元组是不可变的序列，类似于列表，但创建后不能修改。
特点
- 可以存储不同类型的元素
- 元素可以重复、有序、不可以修改（支持索引访问、切片）
#定义元组
元素名称=（元素1，元素2，.......）
#定义空元组
元素名称=（）
元素名称=tuple（）
方法
- count（）：统计某元素在元组出现的次数
- index（）：查找某个元素在元组中的索引位置（第一次出现的位置）
#元组基本操作 - tuple -->元素可以重复，有序，不可修改 #定义 t1 = (False,1,2,3,1,5,"A",True,1,2) print(t1) print(type(t1)) #索引访问 print(t1[0]) print(t1[-1]) # t1[0]=100 元组不支持赋值 print(t1[1:3:1]) #count() 统计元素的个数 print(t1.count(1)) # print(1==True) #元组中True的值为1 #index print(t1.index(True)) #注意点：如果定义单元素的元组，单个元素之后需要加上逗号，比如(100,) t2=() print(t2) print(type(t2)) t3 = (100,) print(t3) print(type(t3)) t4=tuple([100])#里面要加中括号 print(t4) print(type(t4))
1.元素有什么特点？
- 元素可以重复
- 元素有序
- 不可修改（只读）
2.元素的两个查询方法？
- count():统计指定元素的数量
- index():获取指定元素的索引，如果该元素不存在将报错
3.元组使用注意事项？
- 定义单元素元组时，需要在结尾加上逗号，比如('A',)
组包与解包
- 组包：将多个值合并到一个容器（ 元组、列表）中
- 解包：将容器（元组、列表）解开成独立的元素，分别赋值给多个变量
#组包操作 t1 = (5, 7, 9, 10, 2, 23, 12) t2 = 5, 7, 9, 10, 2, 23, 12 print(t1) print(t2) #解包操作 #基础解包（变量数量与容器的元素个数保持一致） a,b,c,d,e,f,g = t1 print(a,b,c,d,e,f,g) #扩展解包（收集剩余的所有元素，封装到list中） first,second,*other,last=t2 print(first,second,other,last) print(first) print(second) print(other) print(last) *other,last2,last1=t2 print(other) print(last2) print(last1)
# 案例1：现有两个变量，分别为：a = 10，b = 20，现需要将这两个变量值交换，然后输出到控制台。 # a = 10 # b = 20 # 方法一： # a,b=b,a #利用组包和解包的操作 # # 方法二 临时变量 # c=a # a=b # b=c # print(a) # print(b) 案例2：现有三个变量，分别为：a = 100，b = 200，c = 300，现需要将这三个变量值进行交换，将a，b，c的值分别赋值给c，a，b，并将其输出到控制台。+ a = 100 b = 200 c = 300 c,a,b = a,b,c print(a) print(b) print(c)
组包与解包？
- 组包：将多个值合并到一个容器
- 解包：将容器中的元素分别赋值给多个变量
- 在元组解包时，*表示收集剩余的所有元素，允许我们处理不确定数量的元素
# 元组 tuple 组包与解包
#组包操作
# t1 = (5, 7, 9, 10, 2, 23, 12)
# t2 = 5, 7, 9, 10, 2, 23, 12
# print(t1)
# print(t2)
# #解包操作
# #基础解包（变量数量与容器的元素个数保持一致）
# a,b,c,d,e,f,g = t1
# print(a,b,c,d,e,f,g)
# #扩展解包（收集剩余的所有元素，封装到list中）
# first,second,*other,last=t2
# print(first,second,other,last)
# print(first)
# print(second)
# print(other)
# print(last)
#
# *other,last2,last1=t2
# print(other)
# print(last2)
# print(last1)
# 案例1：现有两个变量，分别为：a = 10，b = 20，现需要将这两个变量值交换，然后输出到控制台。
a = 10
b = 20
# 方法一：利用组包和解包的操作
a,b=b,a
# 方法二 临时变量
c=a
a=b
b=c
print(a)
print(b)
# 案例2：现有三个变量，分别为：a = 100，b = 200，c = 300，现需要将这三个变量值进行交换，将a，b，c的值分别赋值给c，a，b，并将其输出到控制台。+
a = 100
b = 200
c = 300
c,a,b = a,b,c
print(a)
print(b)
print(c)
"""
根据如下提供的学生成绩单，完成如下需求：
计算每个学生的总分、各科平均分，然后一并输出出来。
统计各科成绩的最低分、最高分、平均分，并输出。
查找成绩优秀（平均分大于90）的学生，并输出。
"""
students = (
("S001", "王林",85, 92, 78),
("S002","李慕婉",92, 88, 95),
("S003", "张三", 78, 85, 82),
("S004", "曾牛", 88, 79, 91),
("S005", "周轶", 95, 96, 89),
("S006", "王卓", 76, 82, 77),
("S007", "红蝶", 89, 91, 94),
("S008","徐立国",75,69, 82),
("S009", "许木", 86, 89, 98),
("S010","遁天",66,59, 72)
)
# 1. 计算每个学生的总分、各科平均分，然后一并输出出来。 --------->{avg:.1f}-------->保留1位小数
print("学号\t\t姓名\t\t语文\t\t数学\t\t英语\t\t总分\t\t平均分")
#方式一：索引访问
for s in students:
total = s[2] + s[3] + s[4]
avg = total / 3
print(f"{s[0]} \t{s[1]} \t {s[2]} \t {s[3]} \t {s[4]} \t {total} \t {avg:.1f}")
#方式二：元组解包
for Id, name, chinese, math, english in students:
total = chinese + math + english
avg = total / 3
print(f"{id} \t {name} \t {chinese} \t {math} \t {english} \t {total} \t {avg:.1f}")
# 2. 统计各科成绩的最低分、最高分、平均分，并输出。
print(f"语文最低分为{min(s[2] for s in students)}，语文最高分为{max(s[2] for s in students)}，语文平均分为{sum(s[2] for s in students)/len(students):.3f}")
# 3. 查找成绩优秀（平均分大于90）的学生，并输出。
#方式一：索引访问
print("优秀学生名单如下：")
for s in students:
total = s[2] + s[3] + s[4]
avg = total / 3
if avg > 90:
print(f"优秀学生为{s[1]},平均分为{avg:.1f}")
#方式二：元组解包
print("优秀学生名单如下：")
for Id, name, chinese, math, english in students:
total = chinese + math + english
avg = total / 3
if avg > 90:
print(f"优秀学生为{name},平均分为{avg:.1f}")
数据容器-集合（set）
场景：在业务中，需要定义一个变量，来批量存储用户的手机号（唯一的）？
- 列表list，元组tuple可以存吗？不可以，因为这两种类型是可以存储重复元素的
- 此时就可以使用集合set来存储，set会自动去重，存储不重复的元素
介绍：集合（set）是一种无序的、不可重复、可以修改的数据容器
定义：
#定义集合
s1={"C","D","X","T","O","U"}
#定义空集合
s2=set( )
注意：空集合的定义不可以使用{}，{}表示的是空字典；由于集合是无序的，因此是不支持下标索引访问的
集合（set）中常见方法：
| 操作 | 含义 | 样例 |
| add（..） | 添加元素到集合中 | s1.add('t') |
| remove(..) | 移除集合中指定元素，指定元素不存在将报错 | s1.remove('t') |
| pop() | 随机删除集合中元素并返回 | e=s1.pop() |
| clear() | 清空集合 | s1.clear |
| difference() | 求两个集合的差集（包含在第一个元素不包含在第二个集合中的元素) | s1.difference(s2) / s1-s2 |
| union() | 求两个集合的并集 | s1.union(s2) / s1|s2 |
| intersection() | 求两个集合的交集 | s1.intersection(s2) / s1&s2 |
# #集合set ---> 无序,不可重复,可修改
# #定义
# s1={5, 3, 2, 0, 9 ,12, 43, 64, 22, 5, 0}
# print(s1)
# print(type(s1))
#
# # s2={} 这个是字典,所以不能用空的大括号定义空集合
# s2 = set( ) #这个才是set定义的空集合
# print(s2)
# print(type(s2))
#常见方法:
s1={100,200,300,400,500,600,700,800}
s1.add(900)
print(s1)
s1.remove(200)
print(s1)
e=s1.pop()
print(e)
print(s1)
s1.clear()
print(s1)
s2 = {"A", "B", "C", "D", "E", "X", "Y"}
s3 = {"C", "E", "Y", "Z"}
print(s2.difference(s3))
print(s2.union(s3))
print(s2.intersection(s3))
案例：
football_set = {"王林","曾牛","徐立国","遁天","天运子","韩立","厉飞雨","乌丑","紫灵"}#选修足球学生名单
basketball_set = {"张铁","墨居仁","王林","姜老道","曾牛","王蝉","韩立","天运子","李化元","厉飞雨","云露"}#选修篮球学生名单
french_set= {"许木","王卓","十三","虎咆","姜老道","天运子","红蝶","厉飞雨","韩立","曾牛"}#选修法语学生名单
art_set = {"遁天","天运子","韩立","虎咆","姜老道","紫灵"}#选修艺术学生名单
1. 找出同时选修了法语和艺术的学生
方式一
fa_set= french_set.intersection(art_set)
print(f"同时选修了法语和艺术的学生是：{fa_set}")
方式二
fa_set2=french_set & art_set
print(f"同时选修了法语和艺术的学生是：{fa_set2}")
2.找出同时选修了所有四门课程的学生
方式一
all_set = football_set.intersection(art_set.intersection(french_set.intersection(basketball_set)))
print(f"同时选修了所有四门课程的学生是:{all_set}")
方式二
all_set2 = football_set & art_set & basketball_set & french_set
print(f"同时选修了所有四门课程的学生是:{all_set2}")
3.找出选修了足球,但是没有选修篮球的学生
#方式一
cha_set = football_set.difference(basketball_set)
print(f"选修了足球,但是没有选修篮球的学生是:{cha_set}")
#方式二
cha_set2 = football_set - basketball_set
print(f"选修了足球,但是没有选修篮球的学生是:{cha_set2}")
#方式三 -->集合推导式
cha_set3 = {i for i in football_set if i not in basketball_set}
print(f"选修了足球,但是没有选修篮球的学生是:{cha_set3}")
4. 统计每一个学生选修的课程数量
allset = football_set.union(art_set.union(french_set.union(basketball_set))) #求并集方法1
allset2= football_set | art_set | french_set | basketball_set 求并集方法2
allist=[*football_set,*basketball_set,*french_set,*art_set]
for name in allset:
print(f"{name}同学选修了{allist.count(name)}门课程")
数据容器-字典（dict）
什么是字典？
- 通过【字/词语】，找到该字对应的解释
- 每个【字/词语】对应一个解释，【字/词语】是不能重复的
Python中的字典（dict），里面存储的是键值对（key：value）类型的数据，可以根据键（key）找到对应的值（value）
为什么要使用字典呢？
- 现在要存储班级学员高考成绩，其中包含王林(670)，韩立(556)，李慕婉(582)，紫灵(435)，许立国(608)…,该如何存储呢？
#定义字典存储
dict1 = {"王林"：670,"韩立":556,"李慕婉":582,"紫灵":435,"许立国":608,"王政":512,"张紫":678}
字典：使用键值对（key：value）来存储数据，每一个键都对应一个值，通过键（key）可以快速查找对应的值（value）。
特点：键值对（key：value）存储、键（key）不能重复、可修改。
定义：
注意：在字典（dict）中，值（value）可以是任何类型的数据，而键（key）不能是可变类型（例如，不能是列表、集合或另一个字典）。
#字典 -->key不能重复，如果重复，后面的值会覆盖前面的值 ， key必须是不可变类型（str，int，float，tuple）
#定义字典
dict1 = {"王林":670,"李慕":608,"徐立国":580,"韩立":688}
print(dict1)
print(type(dict1))
dict2 = {1.5:670,1:608,"徐立国":580,('A','B'):688}
print(dict2)
print(type(dict2))
#访问
print(dict2[1.5]) #获取值
dict1["李慕"]=688
print(dict1)
字典的常用操作
字典的增删改查操作方式如下：
| 类型 | 操作 | 含义 | 样例 |
| 添加 | 字典名称[key]=value | 往指定字典中添加key-value键值对 | dict1["涛哥"] = 688 |
| 删除 | 字典名称.pop(key) | 删除字典中指定的key，并返回该key对应的value | score=dict1.pop("涛哥") |
| del 字典名称[key] | 删除字典中指定的键值对 | del dict1["涛哥"] | |
| 修改 | 字典名称[key]=value | 修改字典中指定的key对应的值 | dict1["小智"]=658 |
| 查询 | 字典名称[key] | 根据key获取value | dict1["涛哥"] |
| 字典名称.get(key) | 根据key获取value | dict1.get("涛哥") | |
| 字典名称.keys() | 获取所有的value | dict1.keys() | |
| 字典名称.values() | 获取所有的value | dict1.values() | |
| 字典名称.items() | 获取所有的key-value键值对 | dict1.items() |
案例1
dict1 = {"王林":670,"李慕婉":608,"许立国":580,"韩立":688}
print(dict1)
dict1["磊哥"]=550 #新增
print(dict1)
dict1["磊哥"]=600 #修改
print(dict1)
print(dict1["磊哥"])
print(dict1.get("磊哥"))
print(dict1.keys())
print(dict1.values())
print(dict1.items())
print("-----------------------------------------------")
score=dict1.pop("磊哥")
print(score)
print(dict1)
del dict1["韩立"]
print(dict1)
print("-----------------------------------------------")
for k in dict1.keys():
print(f"{k}: {dict1[k]}")
print("-----------------------------------------------")
for item in dict1.items():
print(f"{item[0]}: {item[1]}:")
print("-----------------------------------------------")
for k,v in dict1.items():
print(f"{k}: {v}")
print("-----------------------------------------------")
案例2
- 开发一个购物车管理系统，实现商品信息的添加、修改、删除、查询功能。系统使用字典结构存储商品数据，通过控制台菜单与用户交互。具体功能如下：
- 添加购物车：用户根据提示录入商品名称、以及该商品的价格、数量，保存该商品信息到购物车。
- 修改购物车：要求用户输入要修改的购物车商品名称，然后再提示输入该商品的价格、数量，输入完成后修改该商品信息。
- 删除购物车：要求用户输入要删除的购物车名称，根据名称删除购物车中的商品。
- 查询购物车:将购物车中的商品信息展示出来，格式为："商品名称：xXx，商品价格：xXX，商品数量：xxx"。5. 退出购物车
shopping_cart = {}print("欢迎使用购物车管理系统~")
while True: # 1.制作菜单 menu = """ #################购物车系统################### # 1.添加购物车 # # 2.修改购物车 # # 3.删除购物车 # # 4.查询购物车 # # 5.退出购物车 # ############################################ """ # 2.执行的具体操作 print(menu)
choice = input("请选择要执行的操作（1-5）：") match choice: case "1": # 添加购物车 goods_name = input("请输入商品名称：") goods_price = float(input("请输入商品价格：")) goods_num = int(input("请输入商品数量：")) # 如果商品存在，则不执行添加，提示信息 if goods_name in shopping_cart: print("该商品已存在，请重新选择~") else: shopping_cart[goods_name] = {"price": goods_price, "num": goods_num} print("商品添加完毕~") case "2": # 修改购物车 goods_name = input("请输入要修改的商品名称：") if goods_name not in shopping_cart: print("该商品不存在,请重新选择~") continue goods_price = float(input("请输入最新的商品价格：")) goods_num = int(input("请输入商品最新的数量：")) shopping_cart[goods_name] = {"price": goods_price, "num": goods_num} print("商品修改完毕~") case "3": # 删除购物车 goods_name = input("请输入要修改的商品名称：") if goods_name not in shopping_cart: print("该商品不存在,请重新选择~") else: del shopping_cart[goods_name] print("商品删除完毕") case "4": # 查询购物车 for goods_name in shopping_cart.keys(): goods_info = shopping_cart[goods_name] print(f"商品名称:{goods_name},商品价格:{goods_info['price']},商品数量:{goods_info['num']}") case "5": # 退出购物车 print("Bye~") break case _: # 匹配其他所有情况 print("非法操作,不支持!!")</pre>
数据容器-总结与对比
| 特性 | 字符串（str) | 列表（list） | 元组（tuple） | 集合（set） | 字典（dict） |
| 有序性 | 有序 | 有序 | 有序 | 无序 | 有序（3.7+） |
| 重复元素 | 允许 | 允许 | 允许 | 不允许 | key不允许 |
| 可变性 | 不可变 | 可变 | 不可变 | 可变 | 可变 |
| 索引访问 | 支持 | 支持 | 支持 | 不支持 | 不支持 |
| 切片操作 | 支持 | 支持 | 支持 | 不支持 | 不支持 |
| 使用场景 | 文本处理 | 有序可重复数据集合 | 固定数据记录 | 去重数据集合 | 键值对 |
数据容器-综合练习
bash
student_list = {}menu = """ ######################################################################################### #1.添加学生信息 #2.修改学生信息 3.删除学生信息 4.查询学生信息 5.列出所有学生 6.统计班级成绩 7.退出系统 # ######################################################################################### """
while True: print(menu) choice = int(input("请选择要执行的操作（1-7）：")) match choice:
case 1: #添加学生信息 student_name = input("请输入要添加的学生姓名：") if student_name in student_list: print("该学生信息已存在，请勿重复添加") elif student_name.lower() == 'exit': print("已退出查询系统") break else: while True: try: student_chinese_score = float(input(f"请输入{student_name}的语文成绩：")) student_math_score = float(input(f"请输入{student_name}的数学成绩：")) student_english_score = float(input(f"请输入{student_name}的英语成绩：")) student_list[student_name]={ "chinese":student_chinese_score, "math":student_math_score, "english":student_english_score } print(f"{student_name}同学的成绩信息已录入") break except ValueError as e: print(f"输入的学生信息有误,错误信息为:{e}") continue case 2: #修改学生信息 attempt = 0 while True: attempt +=1 if attempt == 1: student_name = input("请输入要修改的学生姓名：") else: student_name = input("请重新输入再次要修改的学生姓名：") if student_name.lower() == 'exit': print("已退出查询系统") break if student_name not in student_list: print("该学生信息不存在") continue try: student_chinese_score = float(input(f"请输入{student_name}的语文成绩：")) student_math_score = float(input(f"请输入{student_name}的数学成绩：")) student_english_score = float(input(f"请输入{student_name}的英语成绩：")) student_list[student_name] = { "chinese": student_chinese_score, "math": student_math_score, "english": student_english_score } print(f"{student_name}同学的成绩信息已经修改完毕") break except ValueError as e: print(f"输入的成绩格式有误，错误信息：{e}") continue case 3: #删除学生信息 student_name = input("请输入要删除的学生姓名：") if student_name not in student_list: print(f"系统不存在{student_name}学生信息") else: del student_list[student_name] print(f"{student_name}同学的信息已经删除") case 4: #查询学生信息 attempt=0 while True: attempt +=1 if attempt == 1: student_name = input("请输入要查询的学生信息：") else: student_name = input("请重新输入要查询的学生信息：") if student_name.lower() == 'exit': print("已退出查询系统") break if student_name not in student_list: print(f"{student_name}同学的信息不存在") continue else: student_info = student_list[student_name] student_chinese_score=student_info["chinese"] student_math_score = student_info["math"] student_english_score = student_info["english"] print(f"{student_name}同学的语文成绩是{student_chinese_score},数学成绩是{student_math_score},英语成绩是{student_english_score}") break case 5: if not student_list: print("系统无学生信息") else: for student_name in student_list: student_info = student_list[student_name] student_chinese_score = student_info["chinese"] student_math_score = student_info["math"] student_english_score = student_info["english"] print(f"{student_name}的语文成绩是{student_chinese_score}，数学成绩是{student_math_score}，英语成绩是{student_english_score}") case 6: if not student_list: print("系统无学生信息，无法统计成绩") else: chinese_score_list=[] math_score_list=[] english_score_list=[] for student_name,student_info in student_list.items(): #items 要注意 可以列出键值对 chinese_score_list.append((student_name,student_info["chinese"])) math_score_list.append((student_name, student_info["math"])) english_score_list.append((student_name, student_info["english"])) max_chinese_score= max(chinese_score_list, key = lambda x:x[1]) min_chinese_score = min(chinese_score_list, key=lambda x: x[1]) avg_chinese_score = sum(score for _,score in chinese_score_list) / len(chinese_score_list) max_math_score = max(math_score_list, key=lambda x: x[1]) min_math_score = min(math_score_list, key=lambda x: x[1]) avg_math_score = sum(score for _,score in math_score_list) / len(math_score_list) max_english_score = max(english_score_list, key=lambda x: x[1]) min_english_score = min(english_score_list, key=lambda x: x[1]) avg_english_score = sum(score for _,score in english_score_list) / len(english_score_list) print(f"该班级{max_chinese_score[0]}同学是语文最高分，语文最高分数是{max_chinese_score[1]}，" f"该班级{min_chinese_score[0]}同学是语文最低分，语文最低分数是{min_chinese_score[1]}，" f"该班级语文平均分为{avg_chinese_score}") print(f"该班级{max_math_score[0]}同学是数学最高分，数学最高分数是{max_math_score[1]}，" f"该班级{min_math_score[0]}同学是数学最低分，数学最低分数是{min_math_score[1]}，" f"该班级数学平均分为{avg_math_score}") print(f"该班级{max_english_score[0]}同学是英语最高分，英语最高分数是{max_english_score[1]}，" f"该班级{min_english_score[0]}同学是英语最低分，英语最低分数是{min_english_score[1]}，" f"该班级英语平均分为{avg_english_score}") case 7: break case _: print("非法操作，不支持！！！！")
函数
- 函数是组织好的，可以重复使用的、用来实现特定功能的代码片段。
函数基础
函数定义
#定义函数
def 函数名(参数列表):
函数体
..........
return 返回值
#调用函数
函数名(参数)
#定义函数
def out_line():
print('-----------------------')#调用函数
out_line()
注意：函数定义时的参数列表与返回值语句是可有可无的（由需求确定），函数必须先定义后调用执行（函数定义时，内部代码并未执行，在调用时才执行）
1.函数定义及调用方法？
2.函数使用的注意事项
- 函数必须先定义，再调用
- 函数定义时，并不会执行，只有调用函数时，函数体的逻辑才会运行
- 函数通过缩进来描述归属关系
函数的参数与返回值
#计算圆的面积
def circle_area(r):
area=3.14 * r * r
return area
#调用函数
c_area=circle_area(10)
print(c_area)
#计算机长方形的面积
def rectangle_area(l,w): #形参（形式参数）：函数定义时括号里的参数，只能在函数内使用（局部变量）
area=l*w
return area
#调用函数
r_area=rectangle_area(20,10)
#实参（实际参数）：函数在实际使用时传入的参数
print(r_area)
注意：函数定义时如果有多个参数，多个参数之间使用逗号分隔
注意：return语句只有返回功能，而没有输出打印功能，如果要输出，需要结合print()函数来实现
1.有参数有返回值的函数定义及调用？
2.函数可以有多个返回值吗？
函数的说明文档
- 函数的说明文档（Docstring)是卸载函数开头，用三个引号包裹的字符串，用于解释函数的功能、参数、返回值等信息，方便调用者清楚函数的具体作用及细节。
def rectangle_area(l,w):
"""
根据长方形的长度和宽度来，计算长方形的面积
:param l:长度
:param w:宽度
:return:长方形的面积
"""
area = l*w
return area
# help(rectangle_area)
函数的嵌套调用
- 嵌套调用指的是在一个函数中，又调用了另外一个函数。
- 函数调用遵循栈结构（例：弹夹），最后调用的函数先返回LIFO（Last In First Out，后进先出）
案例
# 1.定义一个函数：根据传入的底和高计算三角形面积的函数（三角形面积=底★高/2）。
def triangle_area(b,h):
"""
根据传入的底和高计算三角形的面积
:param b: 底长
:param h: 高
:return: 三角形面积
"""
return b * h / 2
print("底长为30，高度为20的三角形面积：",triangle_area(30,20))
2.定义一个函数:计算传入的字符串中元音字母的个数(元音字母为 aeiouAEIOU）。
def count_aeiou(s):
"""
统计字符串中元音字母个数
:param s:
:return:
"""
num = 0
for w in s:
if w in "aeiouAEIOU":
num+=1
return num
print(count_aeiou("Hello Python Hello World OK"))
3. 定义一个函数：计算传入的班级学员高考成绩列表中成绩的最高分、最低分、平均分(保留1位小数)，并返回。
def calc_score(score_list):
"""
计算传入的班级学院高考成绩列表中成绩的最高分，最低分，平均分
:param score_list:分数列表
:return:最高分，最低分，平均分
"""
max_s=max(score_list)
min_s=min(score_list)
avg_s=round(sum(score_list)/len(score_list),1)
return max_s,min_s,avg_s
s_list=[589.609,605,643]
max_score,min_score,avg_score=calc_score(s_list)
print("最高分：",max_score)
print("最低分：",min_score)
print("平均分：",avg_score)
基础练习题
函数进阶
函数变量的作用域
- 变量的作用域指的是变量的作用范围（标识这个变量在哪里可以使用，在哪里不可以使用）
- 全局变量：在函数之外定义的变量，称之为全局变量，在整个文件中（包含函数内）都可以使用（通常定义在文件的顶部）
- 局部变量：在函数内部定义的变量，称之为局部变量，只能在该函数内部使用，外部无法访问（函数执行完毕后，会自动销毁内部局部变量）
global关键字
- global关键字用于明确告诉Python解释器，在函数中使用全局变量，使得可以在函数内部修改全局变量的值
注意：在基于global声明全局变量时，要先声明，再使用
# 函数 - 变量的作用域 num = 100#定义函数 def circle_area(r): #局部变量:只能在函数内部使用，外部无法访问 pi = 3.14 area = pi * r * r #局部变量 num global num num = 10000 print("num = ",num) #第一次访问num，输出10000
return area#调用函数 c_area = circle_area(10) print(c_area)
print("num = ", num) #第二次访问num，输出100，如果在函数内部使用global，输出10000
函数参数详解
传参方式
- 传参方式指的是，在调用函数时，传递实参的方式
1.位置参数：调用函数时根据函数定义时的位置来传递参数
要求：调用函数时参数顺序予定义函数时参数顺序完全一致
2.关键字参数：调用函数时函数定义时形参名称作为关键字，以”键-值“的形式来传递参数（不要求顺序）
要求：如果位置参数与关键字混用，关键字参数必须在位置参数之后（关键字参数之间，没有顺序要求）
#函数 - 传参方式
#定义函数
def reg_stu(name, age, gender, city):
print(f"注册成功，姓名： {name}，年龄：{age}，性别：{gender}，城市：{city}")
return {"name": name, "age": age, "gender": gender, "city": city}
#传参方式一：位置参数
stu = reg_stu("张三", 18, "男", "北京")
print(stu)
#传参方式二：关键字参数
stu = reg_stu(name="王林", age=18, gender="男", city="北京")
print(stu)
stu = reg_stu(age=18, name="王林", city="北京", gender="男")
print(stu)
#传参方式三：位置参数+关键字参数 位置参数在前，关键字参数在后
stu = reg_stu("王林", 18, gender="男", city="北京")#错误
print(stu)
位置参数 vs 关键字参数
黄金法则：半年后回头看你今天写得代码，能否一眼看出每个参数的含义，如果不能，就应该使用关键字参数
默认参数
- 默认参数也称为缺省函数，用于在定义函数时，为参数提供默认值，调用函数时，可以不传递有默认值的参数
注意:默认参数必须放在没有默认值的参数列表的后面，一个函数在定义时时可以设置多个默认参数的
注意：函数调用时，如果为默认参数传递了值，则会修改默认的参数值；如果没有传递该参数，则直接使用默认值。
def reg_stu(name, age, gender="男", city="北京"):
print(f"注册成功，姓名：{name}，年龄：{age}，性别：{gender}，城市：{city}")
return {"name": name, "age": age, "gender": gender, "city": city}
#调用函数
stu=reg_stu("张三", 18)
print(stu)
stu=reg_stu("李牧丸", 18,"女")
print(stu)
stu=reg_stu("韩立", 18, city="上海")
print(stu)
不定长参数
需求：定义函数，根据传入的数据，计算这批数据中的最小值、最大值、平均值。
- 介绍：不定长参数也叫可变参数，用于函数定义及调用时参数个数不确定（0个或多个）的场景
- 类型：1.位置传递 2.关键字传递
不定长参数-位置传递（*args）
注意：传递的所有匹配的位置参数都会被args变量收集，这些参数会合并封装成为一个元组，args时元组类型（注意并不会封装关键字参数）
注意：args只是约定俗称的变量名，并不是关键字，这里可以使用任何合法的变量名（如*data）
#不定长参数 *arg元组 #需求：根据传入的数据，计算这批数据的最小值，最大值，平均值 def calc_data(*args): min_data=min(args) max_data=max(args) avg_data=sum(args)/len(args) return min_data,max_data,round(avg_data,1) #调用函数 print(calc_data(2,7,9,10,45)) print(calc_data(2,7,9,10,45,73,37,93,92,111,222))
不定长参数-关键字传递（**kwargs）
注意：参数是以“键=值”形式传递的关键字参数，这些“键-值”，参数会被kwargs接受，并合并封装一个字典类型
注意：kwargs只是约定成俗的变量名，并不是关键字，这里可以使用任何合法的变量名（如**option）
#不定长参数 关键字 **kwargs字典 def calc_data(*args,**kwargs): """ 根据传入的数据，计算这批数据的最小值，最大值，平均值 :param args: 不定长位置参数，需要计算的这批数据 :param kwargs: 不定长关键字参数 :param round: 四舍五入保留几位小数，默认为1 :param print: 是否打印结果，默认为False :return: 最小值，最大值，平均值，保留一位小数 """ min_data=min(args) max_data=max(args) avg_data=sum(args)/len(args)if kwargs.get("round") is not None: avg_data=round(avg_data,kwargs.get("round")) if kwargs.get("print"): print(f"计算出来的最小值：{min_data},最大值：{max_data},平均值：{avg_data}") return min_data,max_data,avg_data#调用函数
print(calc_data(2,7,9,10,45,round=3,print=True))
print(calc_data(2,7,9,10,45,73,37,93,92,111,222,round=4,print=False))
参数类型
- 普通参数：数字、布尔、字符串、列表、集合、字典等
- 特殊参数：函数
#函数的参数类型
#加
def add (x, y):
return x+y
#减
def subtract (x, y):
return x-y
#乘
def multiply (x, y):
return x*y
#除
def divide (x, y):
return x/y
def calc(x,y,oper):
return oper(x,y)
print(calc(10,20,multiply))
匿名函数
- 匿名函数指的是没有名称的函数，需要通过lambda表达式来声明函数，可以简化函数的编写（单行表达式）
注意：函数逻辑比较简单（单行表达式）且只在一个地方使用时，可以考虑使用匿名函数，简化书写（通常作为高阶函数的参数使用）
#匿名函数
#需求1：打印一个分割线
def out_line():
print("--------------------------------------------------")
lambda_out_line = lambda : print("--------------------------------------------------")
lambda_out_line()
#需求2：计算两个数之和
def add(x,y):
return x+y
lambda_add=lambda x,y:x + y
print(lambda_add(100,200))
#需求3：完成如下列表的排序操作，按照每一个元素的字符个数，从小到大排序；
data_list = ["C++", "C", "Python", "Jack", "PHP", "Java", "Go", "JavaScript", "Rust"]
print(data_list)
data_list.sort(key=lambda item : len(item), reverse=True) #匿名函数的典型应用场景
print(data_list)
案例
#案例1：计算n的阶乘
#递归调用(先逐层递进，后逐层回归）：指的是 在函数中自己调用自己的情况 --->一定得有终结点
"""
jc(10) = 10 * jc(9)
jc(9) = 9 * jc(8)
jc(8) = 8 * jc(7)
jc(7) = 7 * jc(6) = 7 * 720 = 5040
jc(6) = 6 * jc(5) = 6 * 120 = 720
jc(5) = 5 * jc(4) = 5 * 24 = 120
jc(4) = 4 * jc(3) = 4 * 6 = 24
jc(3) = 3 * jc(2) = 3 * 2 = 6
jc(2) = 2 * jc(1) = 2 * 1 = 2
jc(1) = 1
"""
def jc(n):
if n == 1:
return 1
else:
return n * jc(n - 1)
print(jc(10))
""" 案例2：定义一个用于根据传入的一批商品信息（商品名、价格、数量）、优惠（优惠券、积分抵扣）、运费信息计算订单的总金额的函数。具体规则如下： 1. 优惠券需要商品金额满5000才可以使用，且优惠券金额不能超过商品总价。 2.积分抵扣需要商品总金额满5000才可以使用，100积分抵扣1元（且抵扣金额不能超过商品总价，积分只能整百抵扣）。 """ def calc_order_cost(*args,coupon=0,score=0,express=0.0): """ 根据传入的一批商品信息（商品名、价格、数量）、优惠（优惠券、积分抵扣）、运费信息计算订单的总金额 :param args:商品信息（商品名、价格、数量）---->如（"商品名",价格,数量）（"商品名",价格,数量） :param coupon:优惠券 :param score:积分 :param express:运费 :return:订单总金额 """ #订单的总金额 = 商品总金额 - 优惠券 - 积分抵扣 + 运费 #1.计算商品总金额 total_price=[goods[1] * goods[2] for goods in args] total_cost=sum(total_price) #扣减优惠券 if total_cost >= 5000 and coupon <= total_cost: total_cost -= coupon #扣减积分抵扣 if total_cost >= 5000 and score/100 <= total_cost: total_cost -= score // 100#添加运费 total_cost += express return total_cost #扣减积分抵扣total=calc_order_cost(("鼠标",188,2),("键盘",388,1),("手机",3999,1),coupon=10,score=4000,express=9.9)
print(total)
total=calc_order_cost(("鼠标",188,2),("键盘",388,1),("手机",6999,1),coupon=10,score=4000,express=9.9)
print(total)
total=calc_order_cost(("鼠标",188,2),("键盘",388,1),("手机",6999,1),express=9.9) print(total)
类型注解
类型注解是python中的一种语法特性，用于明确标识变量、函数参数和返回值的数值类型，从而使代码更清晰，更安全、更易维护。
类型推断
类型推断是值Python解释器自动推断出变量、表达式或函数返回值的数据类型的能力，而无需开发者显示声明。
注意：在对变量进行直接赋值，或者设计到变量的运算，容器的推导等场景时，解释器会自动推导出变量的类型
函数-类型注解
- 为函数添加类型注解，其实主要就是为函数的参数和返回值添加类型注解，具体语法如下：
模块
Python 模块（module）是一个以 .py 为扩展名的文件，它是 Python 程序的基本组织单位。在模块中，我们可以定义变量、函数、类以及可执行的代码。
模块导入方式
- 在使用模块中提供的功能之前，必须得先导入，再使用。
- 导入模块的具体语法如下：
| 导入形式 | 代码样例 | 调用方式 | 调用示例 |
|---|---|---|---|
import 模块名 | import random, os | 模块名.功能名 | random.randint(10, 100) |
import 模块名 as 别名 | import random as rd | 别名.功能名 | rd.randint(10, 100) |
from 模块名 import 功能名 | from random import randint, choice | 功能名 | randint(10, 100) |
from 模块名 import 功能名 as 别名 | from random import randint as rint | 别名 | rint(10, 100) |
from 模块名 import * | from random import * | 功能名 | randint(10, 100) |
# 导入模块 ---> 调用方式:模块名.功能名()
import random
import random as rd
for i in range(100):
print(rd.randint(1,100))
# 导入模块中的功能 from ... import ... -->调用方式:功能名() / 别名
from random import randint
from random import randint as rint
from random import *
for i in range(100):
print(randint(1,100))
自定义模块
当开发一些复杂的项目，为了让项目结构更清晰，更便于项目的维护管理 及 代码的 复用，可能会把一个项目拆分为若干个模块
注意：每一个python文件都可以作为一个模块，模块的名字就是文件的名字（建议使用python标识符定义，规范命名）
__all__特殊变量
__all__是一个模块级别的特殊变量，用于指定 from 模块名 import * 时会导入哪些功能（*通配了哪些功能）。
注意：__all__控制的是 from ... import * 时，要导入的功能，并不会影响直接导入具体的功能（如：from ... import 功能）
软件包
包
- 包：本质就是一个文件夹，该文件夹中可以包含若干python模块（.py），文件夹下还包含了一个)__init__.py。
- 作用：模块文件较多时，用来管理多个模块。（包的本质也是一个模块）
包的导入方式
| 导入形式 | 代码样例 | 调用方式 | 调用示例 |
|---|---|---|---|
import 包名.模块名 | import utils.my_fun | 包名.模块名.功能名 | utils.my_fun.log_separator1() |
from 包名 import 模块名 | from utils import my_fun | 模块名.功能名 | my_fun.log_separator1() |
from 包名 import * | from utils import * | 模块名.功能名 | my_fun.log_separator1() |
from 包名.模块名 import 功能名 | from utils.my_fun import log_separator1 | 功能名 | log_separator1() |
from 包名.模块名 import * | from utils.my_fun import * | 功能名 | log_separator1() |
#1.导入模块
# import utils.my_fun
# utils.my_fun.log_separator1()
#
# utils.my_fun.log_separator2()
# from utils import my_fun
#
# my_fun.log_separator1()
# my_fun.log_separator2()
# my_fun.log_separator3()
# 注意：如果要通过 from utils import * 导入包下的所有模块，需要 __init__.py 文件中添加__all__=[]
# from utils import *
# my_fun.log_separator1()
# my_fun.log_separator4()
# print(my_var.PI)
# print(my_var.NAME)
#2.导入模块中的功能
# 相对路径：从当前文件所在的目录开始查找
from utils.my_fun import log_separator1,log_separator3
#绝对路径：从项目的根目录开始查找
# from 第二章.utils.my_fun import log_separator1,log_separator3
log_separator1()
log_separator3()
面对对象基础
面向过程编程
- 核心思想：把一个需求分解成一系列要执行的步骤，然后按照步骤依次执行这些任务（关注的是流程、步骤）
- 适用场景：面向过程编程非常直接，适合 简单、线性的任务。
面向对象编程
- 对象可以理解为现实中具体的人/物在程序中的数字化身（万物皆对象）
- 它把一个人/物的特征（属性）和功能（方法）打包到一起，是面向对象编程的基本单元。（关注的是谁来帮我做这件事儿）
面对对象编程-类与对象
- 类：描述的是一组具有相同属性（特征）和方法（功能/行为）的模板。
- 对象：对象是类的实例，是基于类创建出来的（实例对象）
提示：对象是由类创建出来的，创建对象的过程，也称为对象的实例化。一个类可以创建无数个对象。
类的定义
定义类的语法如下 ：
#定义类 ----> 不推荐动态的为对象添加属性
class Car:
pass
#创建对象
c1=Car()
#动态的为对象添加属性
c1.color="red"
c1.brand="BMW"
c1.name="X5"
c1.price= 500000
print(c1)
print(c1.__dict__) #对象中的所有属性以字典的形式输出出来说明：类名的命名规范 ，遵循大驼峰命名法，每个单词的首字母都是大写，单词之间没有分隔符，比如UserInfo，UserAccount
说明：__dict__是Python中用户自定义类实例的一个特殊属性，用于以字典形式存储对象的属性
- 定义类的语法如下：
说明：定义在类的外面的称之为函数，定义在类中的函数称之为方法
- __init__:初始化方法，对象创建后自动调用，主要用于设置对象的初始状态（设置对象属性）
- self：方法的第一个参数，表示当前 创建的实例对象
# 定义类
class Car:
# __init__方法是初始化的方法，会在创建时自动调用，可以在该方法中为对象设置对应的属性；
# self：是第一个参数，当前创建出来的实例对象
def __init__(self,c_color,c_brand,c_name,c_price):
self.color = c_color
self.brand = c_brand
self.name = c_name
self.price = c_price
print("Car 类型的对象初始化完毕，对象属性已经添加完毕。")
c1=Car("红色","BMW","x7","800000")
print(c1.__dict__)
c2=Car("白色","奔驰","a7","700000")
print(c2.__dict__)
实例方法
# 实例方法
class Car:
# __init__方法是初始化的方法，会在创建时自动调用，可以在该方法中为对象设置对应的属性；
# self：是第一个参数，表示当前创建出来的实例对象
def __init__(self,c_color,c_brand,c_name,c_price):
self.color = c_color
self.brand = c_brand
self.name = c_name
self.price = c_price
print("Car 类型的对象初始化完毕，对象属性已经添加完毕。")
#定义实例方法
def running(self):
print(f"{self.brand} {self.name} 正在高速行驶中....")
def total_cost(self,discount,rate = 0.1):
"""
计算提车的总金额，包含两个部分：车的价格，税费
:param discount: 折扣
:param rate: 税率
:return: 提车的总金额
"""
total_cost = self.price * discount + rate * self.price
return total_cost
c1 = Car("红色","BMW","x7",800000)
print(c1)
# 调用对象中的方法
c1.running()
total = c1.total_cost(0.9,0.1)
print("提车的总费用为：",total)魔法方法
- 魔法方法是指Python中提供的以双下划线开头和结尾的特殊方法，用于定义类的特殊行为，比如：__init__.
- 魔法方法是不需要我们手动调用的，Python会在合适的时机自动调用
| 魔法方法 | 描述 |
|---|---|
__init__ | 初始化方法 |
__str__ | 字符串表示的方法 |
__eq__ | 比较两个对象是否相等（equal） |
__lt__、__le__、__gt__、__ge__ | 支持比较两个对象的大小（小于（less than），小于等于（less than or equal），大于（greater than），大于等于（greater than or equal）） |
# 实例方法
class Car:
# __init__方法是初始化的方法，会在创建时自动调用，可以在该方法中为对象设置对应的属性；
# self：是第一个参数，表示当前创建出来的实例对象
def __init__(self,c_color,c_brand,c_name,c_price):
self.color = c_color
self.brand = c_brand
self.name = c_name
self.price = c_price
print("Car 类型的对象初始化完毕，对象属性已经添加完毕。")
#定义实例方法
def running(self):
print(f"{self.brand} {self.name} 正在高速行驶中....")
def total_cost(self,discount,rate = 0.1):
"""
计算提车的总金额，包含两个部分：车的价格，税费
:param discount: 折扣
:param rate: 税率
:return: 提车的总金额
"""
total_cost = self.price * discount + rate * self.price
return total_cost
#魔法方法
def __str__(self):
return f"{self.color} {self.brand} {self.name} {self.price}"
def __eq__(self, other):
return self.price == other.price
def __lt__(self, other):
return self.price < other.price
#测试
c1 = Car("红色","BMW","x7",800000)
print(c1)
c2 = Car("红色","BMW","x7",900000)
print(c2)
print(c1 == c2)
print(c1 < c2)
实例属性与类属性
属性分为：
- 实例属性：实例属性属于每个具体对象的属性，每个对象都是独立的。（各个对象特有的数据）
- 类属性：类属性是属于类本身的属性，所有实例共享的。（所有对象共享的数据或配置）
说明：通过实例查找属性时，会先查找实例属性，实例属性不存在时，再查找类属性
# 实例属性与类属性
class Car:
# 类属性（所有实例对象共享的）
wheel = 4 #轮胎数量
tax_rate = 0.1 #购置税税率
def __init__(self, c_color, c_brand, c_name, c_price):
# 实例属性
self.color = c_color
self.brand = c_brand
self.name = c_name
self.price = c_price
self.wheel = 2 #实例属性
def running(self):
print(f"{self.brand} {self.name} 正在高速行驶中....")
def total_cost(self, discount, rate=0.1):
total_cost = self.price * discount + rate * self.price
return total_cost
#测试
c1 = Car("白色","BYD" ,"汉",180000)
print(c1.brand)
print(c1.wheel) # 输出轮胎数量 通过实例对象在查找属性时，会先查找实例属性，实例属性不存在，再查找类属性
#通过类名访问类属性
print(Car.wheel)
# c2 = Car( "黑色", "Tesla", "Model Y", 260000)
# print(c2)案例
"""
采用面向对象的编程思想，完成教务管理系统的开发。教务管理系统可以管理在校学生的成绩信息，通过控制台菜单与用户交互，具体的功能如下：
1.添加学生成绩：根据输入的学生姓名、语文成绩、数学成绩、英语成绩，记录在系统中
1.1 输入学生姓名、语文成绩、数学成绩、英语成绩
1.2 检查学生姓名是否已存在，如果学生不存在，再添加（存在则，不添加)
1.3 验证成绩范围（0-100分）
1.4 创建学生对象并添加到系统
2.修改学生成绩：根据输入的学生姓名，修改对应的学生成绩
2.1 输入要修改的学生姓名
2.2 根据姓名查找该学生，显示该生当前成绩信息
2.3 输入新的语文、数学、英语成绩
2.4 更新学生成绩数据
3. 删除学生成绩：根据输入的学生姓名，删除对应的学生成绩
4.查询指定学生成绩：根据输入的学生姓名，查找对应的学生成绩，并输出
4.1 输出格式为："姓名：张三 | 语文：85 | 数学：90 |英语：88 |总分：263"
5. 展示全部学生成绩：展示出系统中所有学生的成绩
"""
#学生类
class Student:
def __init__(self,name,chinese,math,english):
self.name = name
self.chinese = chinese
self.math = math
self.english = english
def __str__(self):
return f"姓名：{self.name} | 语文：{self.chinese} | 数学：{self.math} |英语：{self.english} |总分：{self.chinese + self.math + self.english}"
# 修改学生成绩
def update_score(self,chinese = None ,math = None,english = None):
if chinese is not None:
self.chinese = chinese
if math is not None:
self.math = math
if english is not None:
self.english = english
# 教务管理系统类
class EduManagement:
system_version = "1.0"
system_name = "教务管理系统"
def __init__(self):
self.student_list = [] #在校学生的成绩信息
# 添加学生成绩
def add_student(self):
name = input("请输入学生姓名：")
#判断学生姓名是否存在，如果存在，则添加失败（不能重复添加）
for s in self.student_list:
if s.name == name :
print("该学生已经存在，添加失败！")
return
chinese = int(input("请输入学生语文成绩："))
math = int(input("请输入学生数学成绩："))
english = int(input("请输入学生英语成绩："))
# 判断分数是否在0——100之间
if 0 <= chinese <= 100 and 0 <= math <=100 and 0 <= english <=100:
stu = Student(name,chinese,math,english)
self.student_list.append(stu)
print("学生添加成功 ~")
else:
print("各科成绩必须在 0~100 之间 ！")
#修改学生成绩
def update_student(self):
name = input("请输入要修改的学生姓名：")
for s in self.student_list:
if s.name == name :
print(f"当前成绩{s}")
chinese = int(input("请输入修改后的学生语文成绩："))
math = int(input("请输入修改后的学生数学成绩："))
english = int(input("请输入修改后的学生英语成绩："))
if 0 <= chinese <= 100 and 0 <= math <= 100 and 0 <= english <= 100:
s.update_score(chinese,math,english)
print("成绩修改成功 ~")
print(f"修改后的成绩：{s}")
return
else:
print("各科成绩必须在 0~100 之间 ！")
return
print("未找到该学生,修改失败！")
#删除学生成绩
def delete_student(self):
name = input("请输入要删除的学生姓名：")
for s in self.student_list:
if s.name == name:
self.student_list.remove(s)
print("学生信息删除成功~")
return
print("未找到该学生，删除失败！")
#查询指定学生成绩
def query_student(self):
name = input("请输入要查询的学生姓名：")
for s in self.student_list:
if s.name == name:
print(f"学生信息：{s}")
return
print("未找到该学生！")
#展示全部学生成绩
def list_student(self):
for s in self.student_list:
print(s)
def run(self):
print(f"欢迎使用教务管理系统 V{EduManagement.system_version}")
while True:
print()
print("#################################################################")
print("#1.添加学生 2.修改学生 3.删除学生 4.查询指定学生 5.查询所有学生 6.退出系统#")
print("#################################################################")
print()
choice = input("请选择要执行的操作，输入1-6:")
match choice:
case "1":
self.add_student()
case "2":
self.update_student()
case "3":
self.delete_student()
case "4":
self.query_student()
case "5":
self.list_student()
case "6":
print("Bye~")
break
case _:
print("输入错误，请选择1-6之间的菜单功能")
#测试
if __name__ == '__main__':
edu_management = EduManagement()
edu_management.run()
改进1（将输入姓名，找名字，输入成绩封装为方法）：
"""
教务管理系统 - 面向对象实现
功能：添加、修改、删除、查询学生成绩
"""
class Student:
"""学生类，封装学生信息和成绩操作"""
def __init__(self, name, chinese, math, english):
self.name = name
self.chinese = chinese
self.math = math
self.english = english
def __str__(self):
"""格式化输出学生信息"""
return f"姓名：{self.name} | 语文：{self.chinese} | 数学：{self.math} | 英语：{self.english} | 总分：{self.get_total_score()}"
def get_total_score(self):
"""计算总分"""
return self.chinese + self.math + self.english
def update_score(self, chinese=None, math=None, english=None):
"""
更新学生成绩
修正：判断传入的参数是否为None，而不是判断当前值
"""
if chinese is not None:
self.chinese = chinese
if math is not None:
self.math = math
if english is not None:
self.english = english
class System:
"""教务管理系统类"""
SYSTEM_NAME = "教务管理系统"
SYSTEM_VERSION = 1.0
def __init__(self):
self.student_list = []
def find_student(self, name):
"""
根据姓名查找学生
返回：找到的学生对象，未找到返回None
"""
for s in self.student_list:
if s.name == name:
return s
return None
def get_scores(self):
"""
获取并验证成绩输入
返回：语文、数学、英语成绩的元组
"""
while True:
try:
chinese = float(input("请输入语文成绩(0-100)："))
math = float(input("请输入数学成绩(0-100)："))
english = float(input("请输入英语成绩(0-100)："))
if 0 <= chinese <= 100 and 0 <= math <= 100 and 0 <= english <= 100:
return chinese, math, english
print("❌ 成绩必须在0-100之间，请重新输入！")
except ValueError:
print("❌ 请输入有效的数字！")
def add_student(self):
"""添加学生成绩"""
name = input("请输入要添加的学生姓名：").strip()
# 验证姓名不能为空
if not name:
print("❌ 姓名不能为空！")
return
# 检查学生是否已存在
if self.find_student(name):
print(f"❌ {name}同学已存在，不能重复添加")
return
# 输入成绩
chinese, math, english = self.get_scores()
# 创建学生对象并添加到系统
student = Student(name, chinese, math, english)
self.student_list.append(student)
print(f"✅ {name}同学信息已添加，添加信息为：{student}")
def update_student(self):
"""修改学生成绩"""
name = input("请输入要修改的学生姓名：").strip()
# 查找学生
student = self.find_student(name)
if not student:
print(f"❌ 系统中无{name}学生的信息，无法修改")
return
# 显示当前信息
print(f"当前信息：{student}")
# 输入新成绩
chinese, math, english = self.get_scores()
# 更新成绩
student.update_score(chinese, math, english)
print(f"✅ {name}学生信息修改完成，新信息为：{student}")
def delete_student(self):
"""删除学生成绩"""
name = input("请输入要删除的学生姓名：").strip()
student = self.find_student(name)
if not student:
print(f"❌ 系统中无{name}学生的信息，无法删除")
return
self.student_list.remove(student)
print(f"✅ {name}同学信息删除成功！")
def query_student(self):
"""查询指定学生成绩"""
name = input("请输入要查询的学生姓名：").strip()
student = self.find_student(name)
if student:
print(f"📋 学生信息为：{student}")
else:
print(f"❌ 系统中无{name}学生的信息，无法查询")
def show_all_students(self):
"""展示全部学生成绩"""
if not self.student_list:
print("📝 当前系统中没有任何学生信息")
return
print("=" * 80)
print("📋 所有学生信息如下：")
print("=" * 80)
# 显示所有学生
for i, student in enumerate(self.student_list, 1):
print(f"{i}. {student}")
print("=" * 80)
print(f"📊 总计：{len(self.student_list)} 名学生")
def run(self):
"""运行系统主菜单"""
print(f"🎓 欢迎来到{self.SYSTEM_NAME} v{self.SYSTEM_VERSION}")
print("=" * 80)
while True:
# 显示菜单
print()
print("=" * 80)
print(" 1. 添加学生 2. 修改学生 3. 删除学生")
print(" 4. 查询指定学生 5. 查询所有学生 6. 退出系统")
print("=" * 80)
try:
choice = input("请选择要执行的操作(1-6)：").strip()
# 处理空输入
if not choice:
print("❌ 请输入操作编号！")
continue
choice = int(choice)
# 执行对应操作
match choice:
case 1:
self.add_student()
case 2:
self.update_student()
case 3:
self.delete_student()
case 4:
self.query_student()
case 5:
self.show_all_students()
case 6:
print("👋 感谢使用教务管理系统，再见！")
break
case _:
print("❌ 操作编号错误，请输入1-6之间的数字")
except ValueError:
print("❌ 请输入有效的数字！")
except KeyboardInterrupt:
print("\n👋 检测到退出信号，再见！")
break
except Exception as e:
print(f"❌ 发生未知错误：{e}")
if __name__ == "__main__":
# 创建系统实例并运行
system = System()
system.run()改进2（将方法封装到字典里，用字典调用方法）
class Student:
"""学生类"""
def __init__(self, name, chinese, math, english):
self.name = name
self.chinese = chinese
self.math = math
self.english = english
self.total = chinese + math + english
self.avg = round(self.total / 3, 2)
def __str__(self):
return f"{self.name}\t{self.chinese}\t{self.math}\t{self.english}\t{self.total}\t{self.avg}"
class EduManagement:
def __init__(self):
self.student_list = []
# 方法封装到字典
self.actions = {
"1": self.add_student,
"2": self.update_student,
"3": self.delete_student,
"4": self.query_student,
"5": self.list_student,
}
def get_name(self, action="操作"):
"""获取学生姓名"""
return input(f"请输入要{action}的学生姓名：")
def find_student(self, name):
"""查找学生"""
for s in self.student_list:
if s.name == name:
return s
return None
def input_score(self):
"""输入成绩，返回元组或None"""
try:
chinese = int(input("请输入语文成绩："))
math = int(input("请输入数学成绩："))
english = int(input("请输入英语成绩："))
if 0 <= chinese <= 100 and 0 <= math <= 100 and 0 <= english <= 100:
return chinese, math, english
else:
print("❌ 成绩必须在0-100之间！")
return None
except ValueError:
print("❌ 请输入有效数字！")
return None
def add_student(self):
"""添加学生"""
name = self.get_name("添加")
if self.find_student(name):
print(f"❌ {name}已存在，添加失败！")
return
result = self.input_score()
if result is None:
return
chinese, math, english = result
stu = Student(name, chinese, math, english)
self.student_list.append(stu)
print(f"✅ {name}添加成功！")
def update_student(self):
"""修改学生成绩"""
name = self.get_name("修改")
stu = self.find_student(name)
if not stu:
print(f"❌ 未找到{name}！")
return
print(f"当前成绩：语文{stu.chinese} 数学{stu.math} 英语{stu.english}")
result = self.input_score()
if result is None:
return
chinese, math, english = result
stu.chinese = chinese
stu.math = math
stu.english = english
stu.total = chinese + math + english
stu.avg = round(stu.total / 3, 2)
print(f"✅ {name}成绩修改成功！")
def delete_student(self):
"""删除学生"""
name = self.get_name("删除")
stu = self.find_student(name)
if stu:
self.student_list.remove(stu)
print(f"✅ {name}删除成功！")
else:
print(f"❌ 未找到{name}！")
def query_student(self):
"""查询学生"""
name = self.get_name("查询")
stu = self.find_student(name)
if stu:
print("\n姓名\t语文\t数学\t英语\t总分\t平均分")
print("-" * 50)
print(stu)
else:
print(f"❌ 未找到{name}！")
def list_student(self):
"""显示所有学生"""
if not self.student_list:
print("📭 暂无学生信息！")
return
print("\n姓名\t语文\t数学\t英语\t总分\t平均分")
print("-" * 50)
for s in self.student_list:
print(s)
print(f"\n📊 共 {len(self.student_list)} 名学生")
def show_menu(self):
"""显示菜单"""
print("\n" + "=" * 40)
print(" 欢迎使用教务管理系统")
print("=" * 40)
print("1. 添加学生成绩")
print("2. 修改学生成绩")
print("3. 删除学生")
print("4. 查询学生成绩")
print("5. 显示所有学生")
print("6. 退出系统")
print("=" * 40)
def run(self):
"""运行主程序"""
while True:
self.show_menu()
choice = input("请选择功能(1-6)：")
if choice == "6":
print("👋 Bye~")
break
# 用字典调用对应方法
if choice in self.actions:
self.actions[choice]()
else:
print("❌ 输入错误，请选择1-6！")
# 运行程序
if __name__ == "__main__":
system = EduManagement()
system.run()练习
class Goods:
def __init__(self,name,price,number):
self.name = name
self.price = price
self.number = number
def __str__(self):
return f"商品名：{self.name},商品价格：{self.price},商品数量：{self.number}"
def alter_score(self,price = None,number = None):
self.price = price
self.number = number
class System:
System_Version = 1.0
System_Name = "购物车系统"
def __init__(self):
self.shopping_list = []
def add(self):
name = input("请输入要添加的商品名称：")
for s in self.shopping_list:
if s.name == name:
print("该商品名称已经存在")
return
price = int(input("请输入商品价格："))
number = int(input("请输入商品数量："))
if 0 <= price and 0 <= number:
goods = Goods(name,price,number)
self.shopping_list.append(goods)
print("添加商品成功！！！")
else:
print("输入的商品价格和数量有误")
def alter(self):
name = input("请输入要修改的商品名称：")
for s in self.shopping_list:
if s.name == name:
print(f"当前商品信息为：{s}")
price = int(input("请输入商品价格："))
number = int(input("请输入商品数量："))
if 0 <= price and 0 <= number:
s.alter_score(price,number)
print("商品信息修改完成！！")
return
else:
print("输入的商品价格和数量有误")
return
print("未找到要修改的商品信息！！！")
def delete(self):
name = input("请输入要删除的商品名称：")
for s in self.shopping_list:
if s.name == name:
self.shopping_list.remove(s)
print("该商品删除成功！！！")
return
print("未找到要删除的商品名称！！！！")
def query(self):
name = input("请输入要查询的商品名称：")
for s in self.shopping_list:
if s.name == name:
print(f"查询的学生信息为：{s}")
return
print("购物车不存在要查询的商品信息")
def student_list(self):
for s in self.shopping_list:
print(s)
def run(self):
print(f"欢迎使用{System.System_Name}{System.System_Version}")
while True:
print()
print("#################################################################")
print("#1.添加商品 2.修改商品 3.删除商品 4.查询指定商品 5.查询所有商品 6.退出系统#")
print("#################################################################")
print()
try:
choice = int(input("请输入要执行的操作数字:"))
match choice:
case 1:
self.add()
case 2:
self.alter()
case 3:
self.delete()
case 4:
self.query()
case 5:
self.student_list()
case 6:
print("bye~")
break
case _:
print("请输入正确操作数字，请重试~")
except Exception as e:
print(f"输入数字有误，报错信息为：{e}")
if __name__ == "__main__":
c1=System()
c1.run()异常
什么是异常
- 异常（也称为Bug）就是程序运行过程中出现的错误，他会中断程序的正常执行流程。
- 作用：
- 保证数据、逻辑的正确性，避免程序执行混乱
- 在开发阶段，尽量发现更多的问题，尽早解决问题，保障程序正常执行
异常处理
- 程序运行过程中出现异常，有两种处理方案：
- 不做处理：整个程序因为一个Bug，中断执行。
- 捕获异常：按照我们自己的处理方式，处理完异常，程序继续执行。(编写程序，做好预案，出现异常，做预案处理）
# 异常处理
try:
print("=======================")
print(myname)
print("=======================")
except NameError as e:
print("程序运行出错，请联系管理员 ~ : 异常信息：",e)
异常处理
try:
print("=======================")
print(myname)
print(1 / 0)
print("ABC"[10])
print("ABC".hello)
print("=======================")
except NameError as e:
print("名字不存在，请检查变量或函数名字，异常信息：",e)
except ZeroDivisionError as e:
print("0不能做被除数，异常信息：",e)
except IndexError as e:
print("索引错误，异常信息：",e)
except Exception as e:
print("程序运行出错，请联系管理员，异常信息：",e)
finally: #无论程序是否正常运行，finally代码块中的代码都会运行
print("资源释放 ~")
异常的传递
- 异常传递就是异常在函数调用中层层上报的过程，知道有人处理它，或者程序崩溃
#异常的传递
def fun1():
print("fun1 ... running ...")
fun2()
def fun2():
print("fun2 ... running ...")
fun3()
def fun3():
print("fun3 ... running ...")
print(my_color)
if __name__ == '__main__':
try:
fun1()
except Exception as e:
print("程序运行出错，请联系管理员，异常信息：",e)AI应用
AI
- AI:人工智能，是一个学科领域的统称，目标讲就是使机器能够像人类一样思考，学习、推理和解决问题。
AI大模型
- AI大模型：也称为大语言模型，是AI技术的一个分支。其实就是一个用代码模拟人类神经网络的程序（参数量极其庞大，通常达到数十亿至数千亿级别），通过大量的数据训练后，使其具备理解人类语言、思考、推理并输出人类语言的能力。
AI应用
- AI应用：是指将AI大模型技术落地到具体的业务场景中，用来解决实际问题的产品或者服务。
大模型部署
API:应用程序接口 ，是软件间的标准化的桥梁，允许开发者无需知晓内部细节即可调用外部功能或数据。
大模型部署-本地部署
- Ollma是一个在本地运行，管理大语言模型的工具。官网：https://ollama.com/
大模型部署-官方开放API
- 主流的大模型（如：deepseek、kimi）官方都提供了开放API，无需部署，就可以直接调用访问
大模型调用
网络基础知识
- 网络：就是我们通常说的互联网，就是由无数个计算机网络设备连接起来形成的全球性的网络基础设施
网络基础知识-IP
IP地址可以理解为就是设备在互联网中的地址（唯一身份证），每一个连入网络的设备都有一个自己的IP地址，用来定位设备在互联网中的位置。
- IPv4地址：32位二进制
- IPv6地址：128位二进制
注意：127.0.0.1 是一个非常特殊的IP地址，表示的是本机地址(也称为本地回环地址）。
网络基础知识-域名
- 域名(DomainName)，是由一串用点分隔的英文字母组成的。IP地址不便于记忆，因此设计出了域名，并通过DNS（域名解析服务器）来将域名和IP地址相互映射，便于记忆和访问。
网络基础知识-端口
- 端口号(Port)是整数，取值范围在0-65535，它是用来标识计算机设备中的运行中的程序。
注意：HTTP协议默认端口号为80，HTTPS协议默认端口为 443。
网络模型
互联网（Internet）连接了数以亿计的设备，网络四通八达就如同时城市的复杂的道路。网络中传输的数据就像是城市道路中的车流，如果不加以管理那必然会出现混乱。在国际ISO组织就统一了程序在网络中通信的模型和标准。包括：
- OSI网络模型:全球网络互连标准模型
- TCP/IP网络模型:可以认为是OSI的简化版
HTTP协议
- 概念:Hyper Text Transfer Protocol，超文本传输协议，规定了客户端和服务器之间数据传输的规则。(只有在请求及响应中都遵循了统一的规则，服务端才能读懂客户端发送来的请求，客户端才能解析服务端响应的结果）
特点：
- 基于文本的协议：请求和响应的部分的协议内容为文本格式，底层通过TCP协议传输，稳定性强。
- 基于请求-响应模型：一次请求对应一次响应，必须由客户端先发起请求，服务端才会返回响应。
- 无状态:服务端不会记忆与客户端的历史交互信息，每次请求-响应都是独立的。
HTTP协议-请求数据格式
POST /api/courses HTTP/1.1 请求行（请求方式、资源路径、协议）
Accept: application/json, text/plain, */* 请求头（格式key：value）Accept-Encoding: gzip, deflate, br, zstd
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6
Connection: keep-alive
Content-Length: 139
Content-Type: application/json
Host: localhost:90
Origin: http://localhost:90
Referer: http://localhost:90/resource/course
Sec-Fetch-Dest: empty
Sec-Fetch-Mode: cors
Sec-Fetch-Site: same-origin
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/143.0.0.0（空行）
{"phone":"18808088080","channel":1, "name":"虎咆","gender":1,"age":"32" } 请求体(请求参数部分，GET方式没有，POST可以有)
请求方式：
- GET:请求参数在请求行中，没有请求体。如:/api/courses?name=Python&status=1。GET请求请求参数大小在浏览器中是有限制的。
- POST：请求参数在请求体中，POST请求大小是没有限制的。
HTTP协议-响应数据格式
HTTP/1.1 200 响应行（协议、状态码）
Server: nginx/1.24.0 响应头(格式key：value)Date: Tue, 16 Dec 2025 12:38:08 GMT
Content-Type: application/json
Transfer-Encoding: chunked
Connection: keep-alive（空行）
{code: 1, msg: "success", data: null} 响应体(存放服务端响应的数据)
Apifox测试
Apifox
- Apifox是一款API设计、开发、测试的一体化协作平台，是项目开发中进行接口测试的神器。
Json格式
JSON(JavaScript Object Notation)是前端的一种对象表示方法。表示形式类似于Python中的字典，都是key：value这种形式，不过所有的key都必须使用双引号引起来，值可以是任何类型:
- 对象：用{}表示，{}之间是键值对形式，键是字符串，值可以是任意其它类型
- 数字：整数和小数都是数字，例如：12、3.14
- 字符串:用""引起来，例如："jack"
- 布尔：有两种值：true或false
- 列表：用[]表示，[]中是列表的元素，多个元素以,分割。
{
"model":"deepseek-chat",
"messages":[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "Hello!"}
],
"stream": false
}会话记忆-现状
会话记忆-处理方案(会话历史滚雪球)
调用本地部署模型
调用DeepSeek
import os
from openai import OpenAI
# 创建与AI大模型交互的客户端对象(DEEPSEEK_API_KEY 环境的名字，值就是DeepSeek的API_KEY)
client = OpenAI(api_key=os.environ.get('DEEPSEEK_API_KEY'),base_url="https://api.deepseek.com")
# 与AI大模型进行交互（）
response = client.chat.completions.create(
model="deepseek-v4-pro",
messages=[
{"role": "system", "content": "你是一名非常可爱的AI助理，你的名字叫小甜甜，请你使用温柔可爱的语气回答用户的问题"},
{"role": "user", "content": "你是谁，你能帮我做什么?"},
],
stream=False,
reasoning_effort="high",
extra_body={"thinking": {"type": "enabled"}}
)
print(response.choices[0].message.content)
提示词工程
- 提示词(Prompt)：是引导大模型(LLM)进行内容生成的命令（一句话、一个问题等）。
- 提示词工程(Prompt Engineering)：通过有技巧的编写提示词，使大模型生成出尽可能符合预期的内容，这一持续性的过程就称为提示词工程。
AI应用-实战
streamlit
streamlit是一个开源的python库，专为数据工程师及及其学习工程师设计，用于快速基于python代码构建交互式web网站（无需掌握前端技术）
官方网站：Streamlit • A faster way to build and share data apps
streamlit 入门程序
1.安装：pip install streamlit
2.在python文件中引入streamlit模块
3.基于streamlit中提供的API来构建Web应用
4.运行程序：streamlit run xxxx .py
Agent 垂直技术社区，欢迎活跃、内容共建。
更多推荐
6
0- 0
已为社区贡献2条内容
所有评论(0)