Python基础知识点完整总结

轩情吖2026-09-08 13:28

Python基础知识点完整总结

  • 一、单引号'、双引号"、三引号'''/"""用法区别
  • 二、运算结果是否带小数点判断规则
  • [三、input () 函数返回值特性](#三、input () 函数返回值特性)
  • [四、int ()、str () 类型转换](#四、int ()、str () 类型转换)
  • [五、type () 与 isinstance () 区别](#五、type () 与 isinstance () 区别)
  • 六、数据类型、运算符整理
    • [1. 独有数据类型](#1. 独有数据类型)
    • [2. Python 独有运算符](#2. Python 独有运算符)
    • [3. 和 C/C++ 运算符差异点](#3. 和 C/C++ 运算符差异点)
  • 七、两种格式化输出方式
    • [1. format 基础写法（你当前学习："xxx {}"）](#1. format 基础写法（你当前学习："xxx {}"）)
    • [2. f-string （f"内容 {变量}"，Python3.6+）](#2. f-string （f"内容 {变量}"，Python3.6+）)
  • [八、函数 / 类型构造器 逐个定性、区分对照表](#八、函数 / 类型构造器 逐个定性、区分对照表)
    • [1. 逐个定性 + 含义](#1. 逐个定性 + 含义)
    • [2. 核心区别对照表](#2. 核心区别对照表)
    • [3. 关键差异拆解](#3. 关键差异拆解)
  • [九、Python list 列表完整总结](#九、Python list 列表完整总结)
    • [1. 列表基础特性](#1. 列表基础特性)
    • [2. 列表基础操作：查看、修改、删除、遍历](#2. 列表基础操作：查看、修改、删除、遍历)
    • [3. 切片 x:y:z 详解（截取子列表）](#3. 切片 [x:y:z] 详解（截取子列表）)
    • [4. 列表内置常用方法](#4. 列表内置常用方法)
    • [5. 序列解包 *](#5. 序列解包 *)
    • [6. 列表推导式](#6. 列表推导式)
  • 十、字符串知识点
    • [1. 字符串基础特性](#1. 字符串基础特性)
    • [2. 字符串切片 sstart: end: step](#2. 字符串切片 s[start: end: step])
    • [3. 常用字符串内置方法（全部返回新字符串 / 新容器，原字符串不变）](#3. 常用字符串内置方法（全部返回新字符串 / 新容器，原字符串不变）)
    • [4. 案例拓展细节（邮箱判断代码要点）](#4. 案例拓展细节（邮箱判断代码要点）)
  • [十一、Python tuple 元组完整总结](#十一、Python tuple 元组完整总结)
    • [1. 元组基础特性](#1. 元组基础特性)
    • [2. 元组内置方法（只有 2 个，元组不可变，没有 append/remove 等修改方法）](#2. 元组内置方法（只有 2 个，元组不可变，没有 append/remove 等修改方法）)
    • [3. 组包 & 解包](#3. 组包 & 解包)
    • [4. 元组遍历方式](#4. 元组遍历方式)
    • [5. 嵌套元组](#5. 嵌套元组)
  • [十二、Python set 集合完整总结](#十二、Python set 集合完整总结)
    • [1. Set 集合核心特性](#1. Set 集合核心特性)
    • [2. Set 常用内置方法](#2. Set 常用内置方法)
  • [十三、Python dict 字典完整总结](#十三、Python dict 字典完整总结)
    • [1. 字典核心特性](#1. 字典核心特性)
    • [2. 增、删、改、查操作](#2. 增、删、改、查操作)
    • [3. 字典常用内置方法](#3. 字典常用内置方法)
    • [4. 字典循环遍历（重点）](#4. 字典循环遍历（重点）)
    • [5. 关键易错点汇总](#5. 关键易错点汇总)
  • [十四、Python 函数核心特性总结](#十四、Python 函数核心特性总结)
    • [1. 函数基础](#1. 函数基础)
    • [2. 函数参数体系](#2. 函数参数体系)
    • [3. 变量作用域与 global 关键字](#3. 变量作用域与 global 关键字)
    • [4. 匿名函数（lambda 表达式）](#4. 匿名函数（lambda 表达式）)
    • [5. 类型注解（Type Hints）](#5. 类型注解（Type Hints）)
    • [6. 重点易错细节汇总](#6. 重点易错细节汇总)
  • [十五、Python 模块与软件包知识点](#十五、Python 模块与软件包知识点)
    • [1. 模块 module](#1. 模块 module)
    • [2. 软件包 package](#2. 软件包 package)
    • [3. 核心易错点汇总](#3. 核心易错点汇总)
  • 十六、Python面向对象基础
    • [1. 面向对象编程核心思想](#1. 面向对象编程核心思想)
    • [2. 类的定义与属性的两种定义方式](#2. 类的定义与属性的两种定义方式)
    • [3. 实例方法](#3. 实例方法)
    • [4. 魔法方法（特殊方法）](#4. 魔法方法（特殊方法）)
    • [5. 实例属性与类属性](#5. 实例属性与类属性)
    • [6. 异常处理](#6. 异常处理)
    • [7. 面向对象分层设计实战（教务管理系统）](#7. 面向对象分层设计实战（教务管理系统）)

🌟🌟hello，各位读者大大们你们好呀🌟🌟

🚀🚀系列专栏：【Python的学习】

📝📝本篇内容：字符串引号；运算结果小数点规则；input 返回字符串；int/str 类型转换；type 与 isinstance 区别；基础数据类型与运算符；format/f-string 格式化；内置函数、类型构造器、模块函数区分；list 列表特性、索引、删除、切片、内置方法、序列解包、列表推导式；字符串不可变、索引切片、常用内置方法；tuple 元组特性、count/index、组包解包、嵌套元组；set 集合去重无序、增删、交并差运算；dict 字典键值对、增删改查、keys/values/items、遍历；函数 def 定义调用；return 返回值；函数文档字符串 Docstring; 嵌套调用栈；形参与实参；位置参数、关键字参数；默认参数；*args 不定长位置参数；kwargs 不定长关键字参数；高阶函数 (函数作参数);global 全局变量；lambda 匿名函数；类型注解 Type Hints; 模块 module 定义；五种导入语法；__all__作用；name__与__main; 包 package;init.py 作用；包导入语法；面向对象类与对象；大驼峰命名；__dict__查看对象属性；动态添加对象属性；init__初始化方法；self 实例参数；实例方法；魔法方法__init/str/eq/lt; 实例属性与类属性；属性查找顺序；异常 try‑except‑finally; 常见异常类型；实体类 + 管理类分层设计

⬆⬆⬆⬆上一篇：MySQL Connect（2）

💖💖作者简介：轩情吖，请多多指教(>> •̀֊•́ ) ̖́-

一、单引号'、双引号"、三引号'''/"""用法区别

单引号' ' ：普通单行字符串，内部可直接写双引号，不用转义；

例 ：'abc"123"'

双引号" " ：和单引号功能完全一致，内部可直接写单引号；

例 ："abc'123'"

三引号''' '''/""" """

支持多行字符串，自动保留换行；

可同时包含单 / 双引号无需转义；

不作赋值变量时，可当多行注释使用。

二、运算结果是否带小数点判断规则

Python 区分整数 int、浮点数 float，结果有无小数点看运算类型：

纯整数+ - * // % ：结果为 int，无小数点；

只要参与运算有浮点数，所有四则运算结果都是 float，带小数点；

/ 普通除法 ：无论整数相除，结果永远 float（带小数点）；

// 地板除 ：整数相除得 int；含浮点数则得 float。

示例 ：

5/2=2.5、5//2=2、5*2.0=10.0

三、input () 函数返回值特性

input()接收控制台输入，无论用户输入数字 / 文字，统一返回字符串 str 类型。

例：num = input("输入数字")，输入 10，num是"10"，不能直接算数运算，需转 int/float。

四、int ()、str () 类型转换

int(数据) ：把合法数字字符串 / 浮点数转为整数

int("123") → 123；int(3.9) → 3（直接截断小数）

str(数据) ：任意数据转为字符串

str(666) → "666"、str(True) → "True"

五、type () 与 isinstance () 区别

type(变量) ：严格匹配类型，不识别继承关系，只返回精确类型

type(5) → int

isinstance(变量, 类型)：判断是否属于该类型 / 子类，返回布尔值 True/False

python 复制代码 
isinstance(True, int) # True，布尔是int子类
type(True) == int     # False

日常判断类型优先用isinstance。

六、数据类型、运算符整理

1. 独有数据类型

NoneType ：唯一值 None，表示空值、无对象

str字符串 ：原生字符串，不用 char 数组

bool布尔 ：只有 True/False，本质是 int 子类

复数 complex ：直接支持1+2j复数运算

序列容器 ：list 列表、tuple 元组、dict 字典、set 集合

大整数 int：无溢出限制，不用 long long

2. Python 独有运算符

// 地板整除、% 取模（支持负数）

** 幂运算（2**3=8）

:= 海象赋值运算符

in / not in 成员判断（判断元素是否在容器）

is / is not 判断内存地址（C 只有 == 值比较）

逻辑运算符：and/or/not，替代 C 的&& || !

3. 和 C/C++ 运算符差异点

除法 ：/永远浮点数；C 整数相除直接截断

自增i++、自减i-- Python 不支持，只能i+=1

三元表达式写法不同 ：a if 条件 else b

位运算通用，但 Python 无 unsigned 无符号整数

七、两种格式化输出方式

1. format 基础写法（你当前学习："xxx {}"）

字符串写{}占位，搭配.format()填充变量

python 复制代码 
a = 10
print("数字是{}".format(a))

2. f-string （f"内容 {变量}"，Python3.6+）

最简写法，字符串前缀加 f，大括号直接放变量 / 表达式

python 复制代码 
a = 10
print(f"数字是{a*2}")

共同点：均使用{}作为占位符；f-string 语法更简洁。

八、函数 / 类型构造器 逐个定性、区分对照表

1. 逐个定性 + 含义

random.randint (a,b)

random：标准库模块（单独的.py 文件，需要先 import random 导入才能用）

randint：定义在 random 模块内部的普通函数

完整含义：模块内的工具函数

调用格式：模块名.函数名 (参数)

str () /float () /int ()

三者是内置类型类（语言原生自带，不用导入）

str、float、int 本身是类；

加 () 是调用类的构造器，生成对应类型的新对象，常俗称类型转换函数；

作用：创建整数、浮点数、字符串实例，实现类型转换。

调用格式：类型名 (参数)

max () /min () /len () /sum ()

全部是全局内置独立函数，解释器启动就存在，无需 import

不依附任何模块、不依附任何类；

接收容器 / 序列作为参数，计算并返回结果，不会创建新类型对象；

调用格式：函数名 (容器 / 数据)

2. 核心区别对照表

写法 归属分类 调用前提 核心作用 标志性特征
random.randint() 模块内部函数 必须先 import random 生成随机整数 带有 .，前面是模块名
int() / float() / str() 内置类型类（构造器） 直接使用，无需导入 新建 int/float/str 对象、类型转换 名字本身就是数据类型
len() / sum() / max() / min() 全局内置独立函数 直接使用，无需导入 统计、计算已有数据，不造新对象 入参传入容器，只返回数值

3. 关键差异拆解

random.randint () 和另外两组最大区别

需要导入模块，属于模块命名空间下的函数；

而内置函数、内置类型类全局直接可用。

int ()/str () 与 len ()/sum () 的核心区分

int ("123")：创造全新对象

输入字符串，输出一个全新整数实例，改变数据类型；

len (1,2,3)：读取 / 计算现有对象，不生成新类型

只是读取列表长度，原有列表不变，返回单纯数字。

九、Python list 列表完整总结

1. 列表基础特性

存储规则 ：有序、允许元素重复、可存放任意不同数据类型（数字、字符串等混合）

可变性 ：可变序列，支持直接修改、删除、新增元素

下标索引 ：下标从 0 开始；支持反向负索引 -1 代表最后一个元素

类型判断 ：type (列表) 输出 list；isinstance (变量，list) 判断是否为列表

示例：a=1,2,"111"

2. 列表基础操作：查看、修改、删除、遍历

查看元素（索引取值）

python 复制代码 
a[下标]    # 正向索引，从0开始
a[-1]      # 负向索引，取最后一位

注意：下标超出列表长度会直接报错。

修改元素

直接通过下标重新赋值：

python 复制代码 
a[0] = "111"

删除元素

del a 下标 ：根据下标直接删除对应元素

pop (下标) ：删除指定下标元素，同时返回被删除的值，不传下标默认删最后一位

remove (值)：删除列表中第一个匹配该值的元素

遍历列表

python 复制代码 
for i in a:
    print(i)

循环依次取出列表每一个元素。

3. 切片 x:y:z 详解（截取子列表）

语法 ：列表 起始 x: 终止 y: 步长 z

x：起始下标，省略默认从头（0）

y：终止下标，截取到 y 前一位，不包含 y；省略默认截取到末尾

z：步长，每隔 z-1 个元素取一个，省略默认 1

常用切片示例

python 复制代码 
b[0:5]   # 下标0~4，步长1
b[:-1:2] # 从头到倒数第二个元素，步长2
b[::]    # 完整复制整个列表

负索引、正负步长都可搭配切片使用。

4. 列表内置常用方法

以 list1 = 7,2,8,5,4,6,11,5,3 为例 ：

append (数据) ：在列表尾部追加单个元素

insert (下标，数据) ：在指定下标位置插入元素，原有元素后移

remove (值) ：删除列表第一个等于该值的元素

pop (下标) ：删除指定下标元素，返回被删除元素

sort () ：原地升序排序列表（直接修改原列表）

reverse ()：原地反转列表顺序（颠倒元素）

5. 序列解包 *

作用

把列表 / 元组里所有元素拆开，批量展开。

合并列表用法

python 复制代码 
num_list = [*num_list1, *num_list2]

num_list1 拆出列表 1 全部元素，num_list2 拆出列表 2 全部元素，再装进新列表，等价 num_list1 + num_list2。

核心特点

单星号 *：只解包列表、元组这类序列；

可一次性打散多个容器快速合并。

6. 列表推导式

基础作用

一行代码替代 for + append 循环，快速生成新列表，简洁高效。

三种常用模板

基础版 ：遍历运算

需求 ：1~20 数字平方存入列表

循环写法：

python 复制代码 
num_list=[]
for i in range(1,21):
    num_list.append(i**2)

推导式简写：

python 复制代码 
new_num_list=[i**2 for i in range(1,21)]

格式：表达式 for 变量 in 可迭代对象

带 if 筛选版 ：过滤元素

需求：只取偶数，计算平方

python 复制代码 
new_num_list=[i**2 for i in num_list if i%2==0]

十、字符串知识点

1. 字符串基础特性

不可修改（不可变序列）

字符串创建后不能直接修改某个下标字符（s0='a' 直接报错）。想要修改只能通过切片、replace 等方法生成新字符串，原字符串保持不变。

有序、支持下标索引

字符拥有顺序编号，正向索引从 0 开始；支持 si 获取指定位置字符。

可迭代

方式 1 ：for char in s 直接遍历每一个字符

方式 2：for i in range(len(s)) 通过下标遍历

支持成员运算符 in："." in mail 判断子串是否存在于字符串中

2. 字符串切片 sstart: end: step

语法 ：sstart: end :step

规则：左闭右开，取 [start, end) 区间字符

默认省略规则

start 省略 ：默认从头开始

end 省略 ：默认截取到末尾

step 省略：步长 = 1，正向截取

负步长（逆序核心 ::-1）

s::-1 ：start、end 全部省略，步长 =-1，字符串完整反转

负步长时：遍历方向从右往左，起始下标要 > 结束下标才能取到内容

示例：s="abcd"，s3:0:-1 → dcb

3. 常用字符串内置方法（全部返回新字符串 / 新容器，原字符串不变）

方法 作用 注意点
s.index(子串) 查找子串首次出现下标 找不到直接报错
s.find(子串) 查找子串首次出现下标 找不到返回 -1，不会崩溃，优先推荐
s.count(子串) 统计子串出现次数 可统计单个字符、多字符
s.upper() 全部转为大写 返回新串
s.lower() 全部转为小写 返回新串
s.split("分隔符") 按照分隔符切割字符串，返回列表 list 连续分隔符会产生空字符串元素，如 " hello world ".split(" ") 存在空项
s.strip() 去除字符串首尾空白（空格、换行、tab） 只删两端，中间空格保留；配套还有lstrip()左清除、rstrip()右清除
s.replace(old,new) 替换子串 全部匹配内容都会替换，生成新字符串
s.startswith("xx") 判断字符串是否以指定内容开头 返回布尔值 True/False
s.endswith("xx") 判断字符串是否以指定内容结尾 返回布尔值 True/False

4. 案例拓展细节（邮箱判断代码要点）

python 复制代码 
mail.count("@") == 1   # 约束：有且只能有一个@符号
"." in mail            # 字符串成员判断，邮箱必须包含点

补充：当前只是简易校验，正式邮箱还有更多规则（不能 @开头 / 结尾、@不能在最后一个.后面等）

十一、Python tuple 元组完整总结

1. 元组基础特性

有序 ：元素有固定下标索引，支持下标取值ti、切片tstart: end :step

不可修改（不可变） ：元组本身不能增、删、改内部元素。循环里i +=1只是修改循环变量，不会改变原元组。

允许重复元素 ：同一个值可以多次存放。

定义写法

python 复制代码 
t1 = (1,2,3)   #标准括号写法
t2 = 1,2,3     #可以省略括号，逗号才是元组标志
t3 = (1,)      #单个元素必须加逗号，(1)只是数字表达式，不是元组

切片：t起始:结束:步长，切片返回的结果仍然是元组类型。

2. 元组内置方法（只有 2 个，元组不可变，没有 append/remove 等修改方法）

方法 作用
tuple.count(val) 统计元组中val出现的次数
tuple.index(val) 查找val第一次出现的下标，找不到直接报错

元组不支持：append、pop、remove、sort 这类修改容器的函数。

3. 组包 & 解包

1. 组包

把多个值，打包封装成一个元组容器。

python 复制代码 
t3 = 1,2,3   #组包，多个变量用逗号隔开，自动封装为元组

2. 解包 ：把容器（元组 / 列表）拆分为多个变量

普通解包：变量数量和元素个数必须一致

python 复制代码 
a,b,c = t3

*星号解包：把剩余所有元素收集为列表 list

python 复制代码 
t3 = 1,2,3
a,*b = t3    # a=1，b=[2,3]  *放后面接收剩余
*c,d = t3    # c=[1,2]，d=3  *放前面接收前面剩余

带*接收出来的变量，类型一定是列表 list，不是元组。

一个解包语句中，只能有一个 *。

3. 经典用法：变量交换（本质：组包 + 解包）

python 复制代码 
a,b = 10,20
a,b = b,a

执行过程 ：

b,a先组包成临时元组(20,10)

再解包赋值给左边a,b，完成交换，不需要中间临时变量。

也支持多变量轮换：x,y,z = z,x,y

4. 元组遍历方式

直接 for 遍历元素

python 复制代码 
for i in t1:
    print(i)

通过下标索引遍历

python 复制代码 
for i in range(len(t1)):
    print(t1[i])

解包遍历（适合嵌套元组，示例成绩代码）

python 复制代码 
# stu是嵌套元组，直接解包
for name,sid,chinese,math,eng in stu:
    pass

5. 嵌套元组

元组内部可以存放元组、列表等容器，如示例：

python 复制代码 
stu=(("lisa","S001",80,81,72), ("jack","S002",90,94,92))

取值 ：stu00取第一个学生姓名。

⚠️注意：元组本身不可变；如果元组里面存放可变对象（列表），列表内部的元素是可以修改的。

十二、Python set 集合完整总结

1. Set 集合核心特性

元素唯一，自动去重

集合中不允许存在重复元素，初始化、添加元素时重复数据会直接丢弃。

python 复制代码 
test_set1={8,2,3,9,21,11,3,8} # 重复3、8自动只保留一份

无序

集合没有下标、顺序不固定，不能通过索引取值。

元素类型要求 ：必须是不可变类型（可哈希）

数字、字符串、元组可以放入集合；列表、字典、集合不能作为集合元素。

空集合创建注意

{} 代表空字典，空集合必须使用 set() 创建

python 复制代码 
test_set2 = set()  # 正确空集合

集合本身是可变容器：可以增、删元素；但集合内元素不可变。

2. Set 常用内置方法

1. 增删操作

方法 作用
set.add(x) 向集合添加单个元素；元素已存在不会报错，无效果
set.remove(x) 删除指定元素；元素不存在会直接报错
set.pop() 随机删除一个元素，并且返回被删除元素；集合为空时报错
set.clear() 清空集合所有元素，变成空集合 set()

2. 集合运算（交集、并集、差集）

每种运算都有 方法调用形式 和 运算符简写形式，效果完全一致

① 交集 ：同时存在于两个集合的元素

数学含义：既在 A 又在 B

python 复制代码 
A.intersection(B)
A & B

示例：同时选修法语和艺术的学生

python 复制代码 
fa_set = french_set.intersection(art_set)
fa_set2 = french_set & art_set

多集合连续交集：A & B & C & D / 链式调用 A.intersection(B).intersection©

② 并集 ：所有集合全部元素，自动去重

数学含义：属于 A 或者属于 B

python 复制代码 
A.union(B)
A | B

示例：获取所有选课学生

python 复制代码 
all_stu = football_set | basketball_set | art_set | french_set

③ 差集 ：在 A 中，但是不在 B 中的元素

数学含义：A 有，B 没有

python 复制代码 
A.difference(B)
A - B

示例：选足球但没选篮球

python 复制代码 
f_set = football_set.difference(basketball_set)
f_set2 = football_set - basketball_set

十三、Python dict 字典完整总结

1. 字典核心特性

存储形式 ：以键值对（key: value）存储数据，格式 {key1:value1, key2:value2,...}

键（key）规则

键不允许重复；出现重复键，后面的值会直接覆盖前面的值

键不可修改（必须是不可变类型） ：字符串、数字、元组；列表不能作为键

值（value）规则

值允许重复、允许修改，可以是任意数据类型

创建方式

python 复制代码 
# 方式1：字面量创建
dt = {"Jack":91,"Dane":99,"John":99}
# 方式2：空字典两种写法
dt1 = {}
dt2 = dict()

数据查找：通过 key 索引取值，不能通过下标数字索引

2. 增、删、改、查操作

1. 新增 / 修改元素

语法 ：字典key = 值

如果 key 不存在：执行添加操作

如果 key 已存在：执行修改（覆盖）操作

python 复制代码 
dt["Philip"] = 77   # key不存在 → 添加
dt["Jack"] = 100    # key存在 → 修改

2. 查询元素

两种取值方式 ：

字典key

key 不存在会直接报错

字典.get(key)

key 不存在不会报错，返回 None，推荐优先使用

python 复制代码 
print(dt["Dane"])
print(dt.get("Dane"))

3. 删除元素

字典.pop(key)

删除指定键，返回被删除的 value

python 复制代码 
e = dt.pop("Philip")

del 字典key

删除指定键值对，无返回值

python 复制代码 
del dt["Jack"]

3. 字典常用内置方法

方法 作用
.keys() 获取字典所有键，返回 dict_keys 对象
.values() 获取字典所有值，返回 dict_values 对象
.items() 获取所有键值对元组 (key,value)，返回 dict_items 对象

示例：

python 复制代码 
print(dt.keys())
print(dt.values())
print(dt.items())

4. 字典循环遍历（重点）

方式 1：遍历 .items () （推荐，解包 key、value）

python 复制代码 
# 直接解包
for name,score in dt.items():
    print(f"{name}: {score}")

# 不解包，拿到元组再索引
for item in dt.items():
    print(f"{item[0]}: {item[1]}")

原理 ：.items() 内部每一组数据是 (key, value) 二元元组，可以直接进行序列解包。

拓展：普通嵌套列表 \[1,2,3,4] 同样支持 for a,b in 列表 解包。

方式 2：遍历 .keys () ，再通过 key 取值

python 复制代码 
for name in dt.keys():
    print(f"{name}: {dt[name]}")

5. 关键易错点汇总

键不能重复，重复键会覆盖旧值；值可以重复

key 必须不可变类型，list 不能当 key

dtkey 和 get() 区别：key 不存在时前者报错，后者返回 None

字典没有数字下标，只能用 key 访问

.keys()/.values()/.items() 返回的不是普通列表，是专用对象，可以直接用于 for 循环

十四、Python 函数核心特性总结

1. 函数基础

1.1 定义与调用

核心规则：

  • 语法：def 函数名(参数列表): 后接缩进的函数体

  • 函数必须先定义、后调用；定义阶段仅解析语法，不执行函数体代码，调用时才真正执行

  • 参数列表、return 语句均为可选项，由业务需求决定

代码示例：

python 复制代码 
# 无参无返回值函数
def out_line():
    print('---------------------------')

# 调用函数
out_line()

# 有参有返回值函数：计算三角形面积
def triangle(down, tall):
    return down * tall / 2

print(triangle(16, 9))  # 输出: 72.0

1.2 返回值特性

核心规则：

  • 无 return 或 return 后无值时，函数默认返回 None

  • 多返回值会被 Python 自动封装为元组（tuple），支持用多个变量直接解包接收

  • return 仅负责将结果返回给调用方，不具备打印输出功能

代码示例：

python 复制代码 
# 多返回值：返回最高分、最低分、平均分
def score(score_list):
    return max(score_list), min(score_list), round(sum(score_list)/len(score_list), 1)

# 接收方式1：单个变量接收，得到完整元组
result = score([1,2,3,4,5,6,7,8,9])
print(result)  # 输出: (9, 1, 5.0)

# 接收方式2：多变量解包接收
max_s, min_s, avg_s = score([1,2,3,4,5,6,7,8,9])
print(max_s, min_s, avg_s)  # 输出: 9 1 5.0

1.3 函数说明文档（Docstring）

核心规则：

  • 写在函数开头，用三引号包裹，用于描述函数功能、参数含义、返回值含义

  • 标准格式：:param 参数名: 参数描述，:return: 返回值描述

  • 可通过 help(函数名) 或 IDE 鼠标悬浮查看

代码示例：

python 复制代码 
def vowel(string):
    """
    计算字符串中元音字母的个数
    :param string: 待统计的目标字符串
    :return: 元音字母的总个数
    """
    cnt = 0
    for c in string:
        if c in "aeiouAEIOU":
            cnt += 1
    return cnt

print(vowel("hello world A"))  # 输出: 3
help(vowel)  # 查看完整函数说明

1.4 嵌套调用

核心规则：

  • 在一个函数内部调用另一个函数，称为函数嵌套调用

  • 调用过程遵循栈结构后进先出（LIFO）：最后被调用的函数最先执行完毕并返回

  • 执行顺序：外层函数前半段 → 内层函数完整执行 → 外层函数后半段

代码示例：

python 复制代码 
def function_a():
    print("a ... before")
    function_b()
    print("a ... after")

def function_b():
    print("b ... before")
    function_c()
    print("b ... after")

def function_c():
    print("c ...")

function_a()
# 输出顺序：
# a ... before
# b ... before
# c ...
# b ... after
# a ... after

2. 函数参数体系

2.1 形参与实参

  • 形参（形式参数）：函数定义时括号内的参数，属于函数内的局部变量，仅函数内部可用

  • 实参（实际参数）：函数调用时传入的具体数据，会赋值给对应的形参

2.2 两种传参方式：位置参数 + 关键字参数

核心规则：

  • 位置参数：按形参定义的顺序依次传参，顺序、数量必须完全一致

  • 关键字参数：以 形参名=值 形式传参，参数顺序无要求

  • 混用规则：位置参数必须全部放在关键字参数之前，关键字参数之间无顺序限制

代码示例：

python 复制代码 
def student(name, age, sex, location):
    print(f"{name} is {age} years old, sex is {sex}, location is {location}")

# 1. 纯位置参数传参
student("Jack", 20, "男", "上海")

# 2. 纯关键字参数传参（顺序任意）
student(name="Danna", age=21, sex="男", location="北京")
student(location="北京", name="Danna", age=21, sex="男")

# 3. 位置+关键字混用（位置必须在前）
student("Alice", 19, location="南京", sex="女")

2.3 默认参数（缺省参数）

核心规则：

  • 定义函数时为参数设置默认值，调用时该参数可传可不传

  • 传值则覆盖默认值，不传则直接使用默认值

  • 语法强制 ：默认参数必须全部放在无默认值参数的右侧，否则直接语法报错

代码示例：

python 复制代码 
def goods(name, price, number=1, location="上海"):
    print(f"{name} 单价{price}元，数量{number}，产地{location}")

# 不传默认参数，使用默认值
goods("apple", 5)  # 输出: apple 单价5元，数量1，产地上海

# 覆盖部分默认参数
goods("apple", 5, location="北京")  # 输出: apple 单价5元，数量1，产地北京

# 覆盖全部默认参数
goods("banana", 3, 5, "广州")  # 输出: banana 单价3元，数量5，产地广州

2.4 不定长参数（可变参数）

用于函数参数数量不确定的场景，分为两类，可组合使用。

2.4.1 不定长位置参数 *args

核心规则：

  • 收集所有匹配的位置参数，自动封装为一个元组（tuple）

  • args 是约定俗成的变量名，并非语法关键字，可自定义为其他名称

代码示例：

python 复制代码 
def for_list(*args):
    print(type(args))  # 输出: <class 'tuple'>
    for i in args:
        print(i, end=" ")

for_list(1, 2, 3, 4, 5, 6, 7)
# 输出:
# <class 'tuple'>
# 1 2 3 4 5 6 7

2.4.2 不定长关键字参数 **kwargs

核心规则：

  • 收集所有匹配的关键字参数，自动封装为一个字典（dict）

  • 推荐用 kwargs.get("键") 取值，避免键不存在时报错

  • kwargs 是约定俗成的变量名，并非语法关键字

代码示例：

python 复制代码 
def calcuate_avg(*args, **kwargs):
    avg = sum(args) / len(args)
    # 通过get获取配置项，键不存在时返回None，不报错
    if kwargs.get("round") is not None:
        avg = round(avg, kwargs.get("round"))
    if kwargs.get("print") is True:
        print("平均分:", avg)
    return avg

calcuate_avg(1, 2, 3, 4, 5, 6, 7, round=2, print=True)
# 输出: 平均分: 4.0

2.4.3 组合使用规则

核心规则： *args 必须写在 **kwargs 之前，对应实参中「位置参数在前、关键字参数在后」的底层语法规则，消除参数匹配的歧义。

2.5 函数作为参数

核心规则：函数本身可以作为参数传入另一个函数，传递的是计算逻辑而非单纯数据，是高阶函数的基础。

代码示例：

python 复制代码 
def add(a, b):
    return a + b

def sub(a, b):
    return a - b

# 高阶函数：接收函数作为参数
def calculate(a, b, operator):
    return operator(a, b)

print(calculate(1, 2, add))  # 输出: 3
print(calculate(1, 2, sub))  # 输出: -1

3. 变量作用域与 global 关键字

核心规则：

  • 全局变量：定义在函数外部的变量，全文件范围内可读取；函数内直接对同名变量赋值，会创建新的局部变量，不会修改全局变量

  • global 关键字：在函数内部声明「此处要操作的是全局变量」，从而实现函数内修改全局变量的值

  • 语法要求：必须先声明 global，再对变量赋值

代码示例：

python 复制代码 
global_x = 10  # 全局变量
y = 20

# 未使用global：函数内创建同名局部变量，不影响全局
def test1():
    global_x = 100  # 这是局部变量
    print("函数内global_x:", global_x)  # 输出: 100

test1()
print("函数外global_x:", global_x)  # 输出: 10（全局变量未被修改）

# 使用global：操作并修改全局变量
def test2():
    global global_x
    global_x = 100  # 修改全局变量
    print("函数内global_x:", global_x)  # 输出: 100
    print("全局变量y:", y)  # 仅读取全局变量，无需global声明

test2()
print("函数外global_x:", global_x)  # 输出: 100（全局变量已被修改）

4. 匿名函数（lambda 表达式）

核心规则：

  • 语法：lambda 参数列表 : 表达式

  • 无需写 return，表达式的执行结果自动作为返回值

  • 仅支持单行表达式，适合逻辑简单的场景

  • 常作为高阶函数的参数使用，简化代码

代码示例：

python 复制代码 
# 1. 赋值给变量间接调用
add = lambda a, b: a + b
print(add(1, 2))  # 输出: 3

# 2. 定义后直接调用
print((lambda a, b: a + b)(10, 20))  # 输出: 30

# 3. 无参匿名函数
(lambda : print("---------------"))()  # 输出: ---------------

# 4. 作为高阶函数参数
print(calculate(5, 3, lambda x, y: x * y))  # 输出: 15

5. 类型注解（Type Hints）

核心规则：

  • 仅为类型提示，运行时不会强制校验类型，不影响代码执行

  • 提升代码可读性，支持 IDE 自动补全与提前发现类型问题

  • 容器类型易错点：list 是元素类型统一 + 长度不限；tuple 是逐位对应类型 + 长度固定

5.1 变量类型注解

代码示例：

python 复制代码 
# 基础类型
x: int = 10
score: float = 98.5
flag: bool = True

# 联合类型：支持多种类型
num: int | float = 21.5

# 列表：所有元素类型统一，长度不限
my_list: list[int] = [1, 2, 3, 4]
my_list2: list[int | float] = [1, 2.1, 3, 4.5]

# 元组：按位置一一对应类型，长度固定
my_tuple: tuple[int, float, str] = (1, 2.1, "hello")

# 字典：分别指定键类型、值类型
options: dict[str, int] = {"count": 0, "total": 0}

5.2 函数类型注解

代码示例：

python 复制代码 
# 标注参数类型 + 返回值类型
def student(name: str, age: int | float, score: float) -> str:
    info = f"{name} is {age} years old, score is {score}"
    print(info)
    return info

# 带默认值的函数，解释器可自动推断类型，等价于隐式类型注解
def teacher(name="xxx", age=22, salary=9000):
    return f"{name} is {age} years old, salary is {salary}"

student("lisa", 20, 99.4)
teacher("Elieven", 25, 9900)

6. 重点易错细节汇总

  1. 返回值：多返回值本质是返回元组，不是独立的多个返回值；return 不具备打印功能，输出必须配合 print()。

  2. 参数顺序：位置 + 关键字参数混用，位置参数必须全部在前；默认参数必须定义在无默认参数的右侧；*args 必须在 **kwargs 之前。

  3. 不定长参数：*args 封装为元组，**kwargs 封装为字典；args/kwargs 只是约定命名，不是语法关键字。

  4. 作用域：函数内直接给同名变量赋值，默认创建局部变量；修改全局变量必须先加 global 声明。

  5. 类型注解：list[int] 表示所有元素都是 int、长度任意；tuple[int, str] 表示第 1 位 int、第 2 位 str、长度固定，二者语义完全不同。

  6. 匿名函数：无需写 return，表达式结果自动返回；仅适合单行简单逻辑，复杂逻辑优先用命名函数。

  7. 递归：递归函数必须设置明确的终止条件，否则会无限递归直至栈溢出报错。

十五、Python 模块与软件包知识点

1. 模块 module

1.1 模块基础定义

一个.py文件就是一个Python模块，是代码基础组织单位；

模块内可存放：变量、函数、类、可执行代码。

作用：提高代码复用、降低开发门槛、避免全局命名冲突。

1.2 系统内置标准模块（自带无需新建文件）

常用内置模块：

math（数学运算）、random（随机数）、os（操作系统操作）、datetime（日期时间）

re（正则表达式）、sys（系统参数）、time（时间）、csv（csv文件读写）

示例random随机点名：

python 复制代码 
import random
names = ["王林", "李慕婉", "许立国"]
print(random.choice(names))

1.3 自定义模块

自己编写的.py文件即为自定义模块，文件名就是模块名，命名需符合Python标识符规范。

示例自定义模块circle_fun.py：

python 复制代码 
# 根据半径计算圆面积
def circle_area(r):
    pi = 3.14
    return pi * r * r
# 根据半径计算圆周长
def circle_perimeter(r):
    pi = 3.14
    return 2 * pi * r

其他文件main.py可导入调用里面的函数。

1.4 五种模块导入语法

导入写法 代码示例 调用方式
import 模块名 import random random.randint(1,10)
import 模块名 as 别名 import random as rd rd.randint(1,10)
from 模块名 import 功能 from random import randint randint(1,10)
from 模块名 import 功能 as 别名 from random import randint as r r(1,10)
from 模块名 import * from random import * randint(1,10)

导入语句统一写在文件最开头。

1.5 模块特殊变量

（1）__all__

模块内特殊列表变量，仅控制 from 模块 import * 时能导入的内容，不影响精准导入。

示例my_func.py：

python 复制代码 
__all__ = ["print1", "print2"]
PI = 3.14
def print1():
    print("*****")
def print2():
    print("**********")
def print3():
    print("***************")

执行from my_func import *，只能使用print1、print2，print3无法直接调用；

但from my_func import print3依旧可以正常导入。

（2）__name__

内置标识变量，区分模块运行方式：

  1. 当前文件直接运行 ：__name__ == "__main__"

  2. 当前文件被其他文件导入 ：__name__ == 模块文件名（无.py）

用途：仅在单独运行该模块时执行测试代码，导入时不执行测试逻辑。

示例：

python 复制代码 
def print1():
    print("测试函数")
if __name__ == "__main__":
    print1() # 只有直接运行文件才执行

2. 软件包 package

2.1 包定义

本质是存放多个模块的文件夹 ，文件夹内必须存在__init__.py文件，才会被识别为Python包；

包用于归类管理大量模块，优化大型项目文件结构，包本身也属于特殊模块。

2.2 __init__.py核心作用

  1. 标记当前文件夹为Python包，普通文件夹无法导入；

  2. 定义__all__ = ["模块名1", "模块名2"]，控制from 包 import *能导入哪些模块；

    示例__init__.py：

python 复制代码 
__author__ = 'lnb'
__all__ = ["my_time"]

2.3 包的五种导入语法

项目结构示例：

text 复制代码 
utils（包）
├─ __init__.py
├─ my_time.py（模块）
└─ my_fun.py（模块）
导入写法 代码示例 调用方式
import 包名.模块名 import utils.my_time utils.my_time.get_now_time()
from 包名 import 模块名 from utils import my_time my_time.get_now_time()
from 包名 import * from utils import * my_time.get_now_time()（依赖__all__）
from 包名.模块名 import 功能 from utils.my_time import get_now_time get_now_time()
from 包名.模块名 import * from utils.my_time import * get_now_time()

3. 核心易错点汇总

  1. 区分模块与包：单个.py是模块；带__init__.py的文件夹是包；

  2. from xxx import *受__all__限制，精准导入（from xxx import 功能）不受限制；

  3. if __name__ == "__main__"隔离测试代码，避免模块被导入时自动执行测试；

  4. 空文件夹不能作为包，必须创建__init__.py；

  5. 导入包/模块时，Python会根据sys.path路径查找文件，找不到则报错；

  6. 导入模块会自动执行模块内顶层代码，测试代码必须放在if __name__ == "__main__"内。

十六、Python面向对象基础

1. 面向对象编程核心思想

1.1 概念说明

  • 面向过程编程：把需求拆解为一系列执行步骤，按流程依次执行，核心关注「做什么、怎么做」，适合简单、线性的任务。

  • 面向对象编程 ：核心思想是「万物皆对象」，把现实事物的 属性（特征）和方法（行为 / 功能） 打包成一个整体，核心关注「谁来做」，更适合复杂系统的开发与维护。

  • 类与对象的关系：

    • 类：是一组具有相同属性和方法的对象的抽象模板，描述一类事物的共同特征。

    • 对象：是类的具体实例，是基于类创建出的真实实体；一个类可以实例化出无数个对象。

    • 实例化：通过类创建对象的过程。

2. 类的定义与属性的两种定义方式

2.1 基础规范

  • 类名遵循大驼峰命名法 ：每个单词首字母大写，单词间无分隔符，例如 Student、EduManagement。

  • 特殊属性 __dict__：以字典形式存储当前对象的所有实例属性，可用于快速查看对象所有数据。

2.2 动态添加属性（不推荐）

2.2.1 概念说明

对象创建完成后，通过 对象名.属性名 = 值 的方式手动绑定属性。特点是灵活但不规范，无法保证同类对象的属性统一。

2.2.2 代码示例

python 复制代码 
# 定义空类
class Car:
    pass

# 实例化对象
car = Car()
# 动态为对象添加实例属性
car.color = "red"
car.brand = "BMW"
car.price = 200000

# 访问属性
print(car.color)
print(car.brand)
print(car.price)
# __dict__ 查看对象所有属性（字典形式）
print(car.__dict__)

2.3 通过 init 初始化属性（推荐）

2.3.1 概念说明

  • __init__ 是 Python 内置的初始化魔法方法，对象创建时由 Python 自动调用，专门用于统一设置对象的初始属性。

  • self 参数：类中所有实例方法的第一个参数，代表当前正在操作的实例对象本身；调用方法时无需手动传递 self 参数。

  • 方法内通过 self.属性名 = 参数 为对象绑定实例属性，保证所有同类对象属性一致。

2.3.2 代码示例

python 复制代码 
class Phone:
    # 初始化方法，创建对象时自动执行
    def __init__(self, brand, price):
        # self.属性名 = 传入参数  → 绑定实例属性
        self.brand = brand
        self.price = price

# 创建对象时，直接传入属性值，自动调用__init__
phone = Phone("OPPO", 5499)

# 访问实例属性
print(phone.brand)
print(phone.price)
print(phone.__dict__)

3. 实例方法

3.1 核心概念

  • 定义在类内部的函数称为方法，用于描述对象的行为与功能。

  • 第一个参数必须是 self，代表调用该方法的实例对象。

  • 方法内部通过 self.属性名 访问实例属性，通过 self.方法名() 调用同类的其他方法。

  • 调用方式：对象名.方法名(实参)，调用时无需传递 self 参数。

3.2 代码示例

python 复制代码 
class Phone:
    def __init__(self, brand, price):
        self.brand = brand
        self.price = price

    # 实例方法1：展示信息
    def display(self):
        # 方法内通过self访问自身属性
        print(f"My Phone brand is {self.brand}, price is {self.price}")

    # 实例方法2：输出购买地点
    def location(self):
        print("It is bought in Shanghai")

# 创建对象
phone = Phone("OPPO", 5499)
# 调用实例方法
phone.display()
phone.location()

4. 魔法方法（特殊方法）

4.1 核心概念

  • 格式为 __xxx__ 的特殊方法，由 Python 在特定时机自动调用，无需开发者手动触发。

  • 作用：自定义类的特殊行为，比如打印输出、对象比较、运算逻辑等。

4.2 常用魔法方法汇总

魔法方法 触发时机 核心作用
__init__(self, ...) 创建对象时自动调用 初始化实例属性
__str__(self) print(对象) / str(对象) 时触发 自定义对象的字符串表示
__eq__(self, other) 对象1 == 对象2 时触发 自定义对象相等的判断规则
__lt__(self, other) 对象1 < 对象2 时触发 自定义「小于」的比较逻辑
__le__ / __gt__ / __ge__ <= / > / >= 时触发 自定义对应比较逻辑

4.2.1 比较运算符的反向调用机制

  • 执行 a > b 时，若类未定义 __gt__，Python 会自动反向调用 b.__lt__(a)；因此只要实现了 __lt__，> 运算符也可正常使用。

  • 但 <=、>= 不会自动推导逻辑，未定义对应魔法方法会直接报错。

4.3 完整代码示例

python 复制代码 
class Phone:
    def __init__(self, brand, price):
        self.brand = brand
        self.price = price

    # 1. __str__：自定义print对象的输出内容
    def __str__(self):
        return f"{self.brand}:{self.price}"

    # 2. __eq__：自定义 == 比较规则（价格相等则认为对象相等）
    def __eq__(self, other):
        return self.price == other.price

    # 3. __lt__：自定义 < 比较规则（按价格比较）
    def __lt__(self, other):
        return self.price < other.price


# 创建两个对象
apple = Phone("Apple", 10499)
vivo = Phone("VIVO", 5499)

# 测试__str__
print("__str__效果:", apple)

# 测试__eq__
print("apple == vivo:", apple == vivo)

# 测试__lt__
print("apple < vivo:", apple < vivo)

# 测试 > ：反向调用vivo.__lt__(apple)，无需定义__gt__也能运行
print("apple > vivo:", apple > vivo)

# 取消下面注释会报错：<= 不会自动推导，必须定义__le__
# print("apple <= vivo:", apple <= vivo)

5. 实例属性与类属性

5.1 核心概念对比

类型 归属 定义位置 特点 访问方式
实例属性 每个具体对象 __init__ 方法内，self.xxx 绑定 各个对象独立，修改互不影响 对象名.属性名
类属性 类本身 类内部、所有方法外部 所有实例共享，修改后所有对象都受影响 推荐 类名.属性名

5.1.1 属性查找规则

通过对象访问属性时，先在实例属性中查找，找不到再去类属性中查找。

5.2 代码示例

python 复制代码 
class Phone:
    # 类属性：所有实例共享，定义在类内、方法外
    memory = 16
    capacity = 512

    def __init__(self, brand, price):
        # 实例属性：每个对象独有
        self.brand = brand
        self.price = price
        # 实例属性初始化为类属性的值
        self.memory = Phone.memory


# 创建两个对象
apple = Phone("Apple", 10499)
vivo = Phone("VIVO", 5499)

# 1. 访问类属性：推荐用类名访问
print("类属性memory:", Phone.memory)
# 实例对象也可以访问类属性（先找实例，找不到再找类）
print("实例访问类属性capacity:", apple.capacity)

# 2. 修改类属性：所有实例都会受影响
Phone.memory = 32
print("修改类属性后 apple.memory:", apple.memory)
print("修改类属性后 vivo.memory:", vivo.memory)

# 3. 修改实例属性：只影响当前对象，互不干扰
apple.price = 9999
print("apple价格:", apple.price)
print("vivo价格:", vivo.price)

6. 异常处理

6.1 核心概念

  • 异常：程序运行过程中出现的错误，未处理时会中断程序执行。

  • 异常处理：提前预设错误处理逻辑，出现异常时按预案执行，保证程序继续运行而不崩溃。

  • 异常传递：异常会在函数 / 方法调用链中层层向上传递，直到被捕获，否则最终导致程序崩溃。

  • 常见异常类型：ValueError（值错误）、NameError（变量未定义）、TypeError（类型错误）、IndexError（索引越界）、KeyError（键不存在）、ZeroDivisionError（除零错误）。

6.2 标准语法

python 复制代码 
try:
    # 可能出现异常的业务代码
except 具体异常类型 as 变量名:
    # 对应异常的处理逻辑
except Exception as e:
    # 捕获所有未提前指定的异常（兜底）
finally:
    # 无论是否出现异常，都会执行的代码（常用于释放资源）

6.3 代码示例

6.3.1 基础异常捕获

python 复制代码 
try:
    a = 5 / 0
    print(my_name)
except ZeroDivisionError as e:
    print("除数不能为0，错误信息：", e)
except NameError as e:
    print("变量未定义，错误信息：", e)
except Exception as e:
    print("未知异常：", e)
finally:
    print("程序执行结束，释放资源")

6.3.2 业务场景（成绩输入校验）

python 复制代码 
while True:
    try:
        score = int(input("请输入成绩："))
        if 0 <= score <= 100:
            print("成绩录入成功：", score)
            break
        else:
            print("成绩必须在0-100之间，请重新输入")
    except ValueError:
        print("输入无效，请输入数字")

7. 面向对象分层设计实战（教务管理系统）

7.1 设计思想

采用「实体类 + 管理类」的职责拆分模式，符合面向对象封装思想，结构清晰、易维护：

  • 实体类（Student）：封装单个事物的属性与自身行为，比如学生的姓名、成绩，以及修改成绩的方法。

  • 管理类（EduManagement）：维护实体对象的集合，对外提供增删改查等系统功能。

7.2 完整代码示例

python 复制代码 
# ========== 实体类：封装单个学生的数据与自身行为 ==========
class Student:
    def __init__(self, name, chinese, math, english):
        self.name = name
        self.chinese = chinese
        self.math = math
        self.english = english

    # 自身行为：修改成绩，支持只修改部分科目
    def modify(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

    # 自定义打印格式
    def __str__(self):
        return f"{self.name}：语文{self.chinese}，数学{self.math}，英语{self.english}"


# ========== 管理类：维护学生集合，提供系统功能 ==========
class EduManagement:
    def __init__(self):
        # 存储所有学生对象的容器
        self.student_list = []

    # 1. 添加学生
    def add_student(self):
        name = input("请输入学生姓名：")
        # 判重
        for stu in self.student_list:
            if stu.name == name:
                print("该学生已存在！")
                return
        # 成绩输入+异常捕获
        try:
            chinese = int(input("请输入语文成绩："))
            math = int(input("请输入数学成绩："))
            english = int(input("请输入英语成绩："))
        except ValueError:
            print("成绩输入无效，请输入数字！")
            return
        # 成绩范围校验
        if not (0 <= chinese <= 100 and 0 <= math <= 100 and 0 <= english <= 100):
            print("成绩需在0-100之间！")
            return
        # 创建学生对象并加入列表
        self.student_list.append(Student(name, chinese, math, english))
        print("学生添加成功！")

    # 2. 修改学生成绩
    def modify_student(self):
        name = input("请输入要修改的学生姓名：")
        for stu in self.student_list:
            if stu.name == name:
                try:
                    chinese = int(input("请输入修改后的语文成绩："))
                    math = int(input("请输入修改后的数学成绩："))
                    english = int(input("请输入修改后的英语成绩："))
                except ValueError:
                    print("成绩输入无效，请输入数字！")
                    return
                if not (0 <= chinese <= 100 and 0 <= math <= 100 and 0 <= english <= 100):
                    print("成绩需在0-100之间！")
                    return
                stu.modify(chinese, math, english)
                print("成绩修改成功！")
                return
        print("该学生不存在！")

    # 3. 删除学生
    def delete_student(self):
        name = input("请输入要删除的学生姓名：")
        for stu in self.student_list:
            if stu.name == name:
                self.student_list.remove(stu)
                print("删除成功！")
                return
        print("该学生不存在！")

    # 4. 查询指定学生
    def find_student(self):
        name = input("请输入要查询的学生姓名：")
        for stu in self.student_list:
            if stu.name == name:
                print(stu)
                return
        print("该学生不存在！")

    # 5. 展示所有学生
    def show_all(self):
        if not self.student_list:
            print("系统中暂无学生信息")
            return
        for stu in self.student_list:
            print(stu)

    # 系统主菜单
    def run(self):
        while True:
            print("\n" + "#" * 40)
            print("1.添加学生  2.修改成绩  3.删除学生  4.查询学生  5.展示全部  6.退出")
            print("#" * 40)
            choice = input("请输入您的选择(1-6)：")
            match choice:
                case "1":
                    self.add_student()
                case "2":
                    self.modify_student()
                case "3":
                    self.delete_student()
                case "4":
                    self.find_student()
                case "5":
                    self.show_all()
                case "6":
                    print("退出系统，Bye！")
                    break
                case _:
                    print("请输入1-6的有效数字！")


# 启动程序
if __name__ == "__main__":
    edu = EduManagement()
    edu.run()

🌸🌸Python基础知识点完整总结大概就讲到这里啦，博主后续会继续更新更多Python的相关知识，干货满满，如果觉得博主写的还不错的话，希望各位小伙伴不要吝啬手中的三连哦！你们的支持是博主坚持创作的动力！💪💪

相关推荐
青 春 记 忆1 小时前
零基础入门python69：为 FastAPI 项目构建可复现 Docker 镜像
python·fastapi·后端开发
<花开花落>1 小时前
Python 项目迁移到 uv：经验小结与可复用工作流
python·uv
databook1 小时前
正态分布撒谎时：用柯西分布捕捉生活中的“黑天鹅”
python·数据挖掘·数据分析
Java后端的Ai之路1 小时前
LangChain Deep Agents 从入门到企业实战
开发语言·人工智能·python·langchain·deepagents
2601_962381581 小时前
Mac和Windows，哪种电脑适合新手学Python|数智码力分享
windows·python·mac·编程环境·学习入门
会飞的拖把1 小时前
Python文件操作详解：从文件读写到os、shutil模块实战
开发语言·python
RS迷途小书童1 小时前
Python 解析大疆无人机 SRT 字幕日志
开发语言·python·无人机
我不会起名字3222 小时前
一天一道算法题（29）：单调栈
java·数据结构·python·算法·leetcode·golang·单调栈
萧鼎2 小时前
2026新库实测：sbxloop 1.5.24 让 AI Agent 在 Docker 沙箱中安全自治，告别环境混乱
人工智能·python·开源·开发工具·ai agent
热门推荐
01国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）02GitHub 镜像站点03历年考研数学一、数学二、数学三真题试卷及答案PDF04蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接052026 国产 AI 大模型横评：DeepSeek、通义千问、Kimi、文心一言、星火、豆包谁更能打？06微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新07ZCode 周末送额度活动开启：3 亿 Token 免费领取08Agnes AI 免费 API 接入指南：文本、生图、生视频，一套接口全免费09AI 编程 IDE 全景解析 2026：Agent 全面接管开发链路10VSCode+CodeX扩展，无法启动