本文按「基础→进阶」分类整理Python核心知识点，每个知识点均包含「核心说明+语法解释+实战示例+注意事项」，适配新手入门、进阶学习，所有示例可直接复制运行，兼顾实用性和易懂性。

一、Python基础知识点（入门必备）

1. 变量与数据类型

核心说明：变量用于存储数据，Python无需声明变量类型，赋值时自动确定类型；常用数据类型分为基本类型和复合类型，是所有Python代码的基础。

核心语法：

\1. 变量赋值：变量名 = 值（变量名需遵循标识符规则：字母、数字、下划线组成，不能以数字开头，区分大小写）；

\2. 常用基本类型：字符串（str）、整数（int）、浮点数（float）、布尔值（bool）；

\3. 类型查看：type(变量名) —— 查看变量的数据类型；

\4. 类型转换：int(值)、float(值)、str(值)、bool(值)。

实战示例：

# 变量赋值（自动确定类型）
name = "Python"  # 字符串str
age = 20         # 整数int
score = 95.5     # 浮点数float
is_study = True  # 布尔值bool（True/False，首字母大写）
​
# 查看类型
print(type(name))  # 输出：<class 'str'>
print(type(score)) # 输出：<class 'float'>
​
# 类型转换
num_str = "100"
num_int = int(num_str)  # 字符串转整数，结果为100
print(type(num_int))    # 输出：<class 'int'>

注意事项：变量名不能使用Python关键字（如if、for、print等）；布尔值转换时，0、空字符串、空列表等为空/零的值会转为False，非空/非零值转为True；不同类型的数据不能直接运算（如字符串和整数不能直接相加）。

2. 输入与输出（input() & print()）

核心说明：input() 用于获取用户键盘输入，print() 用于将内容输出到控制台，是Python与用户交互的核心函数。

核心语法：

\1. 输入：变量 = input("提示信息") —— 无论输入什么，默认返回字符串类型；

\2. 输出：print(内容1, 内容2, ...) —— 可同时输出多个内容，默认用空格分隔；print(内容, end="") —— 取消默认换行。

实战示例：

# 输入（获取用户姓名和年龄）
name = input("请输入你的姓名：")
age = input("请输入你的年龄：")
# 注意：input输入的是字符串，需转换为int才能进行数字运算
age = int(age)
​
# 输出
print("你的姓名是：", name)  # 输出多个内容
print("你的年龄是：", age, "岁")
print("Hello", end=" ")  # 取消换行
print("Python")  # 与上一行输出在同一行

注意事项：input() 默认返回字符串，若需获取数字（整数/浮点数），必须进行类型转换；print() 中可用逗号分隔多个输出内容，也可用f-string格式化输出（更简洁），如print(f"你的姓名是：{name}")。

3. 运算符（算术、赋值、比较、逻辑）

核心说明：运算符用于对数据进行运算，是编写逻辑、实现功能的基础，分为4大类，重点掌握常用运算符。

核心语法（常用）：

\1. 算术运算符：+（加）、-（减）、*（乘）、/（除，结果为浮点数）、//（整除，取整数部分）、%（取余）、**（幂运算）；

\2. 赋值运算符：=（赋值）、+=（加后赋值）、-=（减后赋值）、*=（乘后赋值）、/=（除后赋值）；

\3. 比较运算符：==（等于）、!=（不等于）、>（大于）、<（小于）、>=（大于等于）、<=（小于等于），结果为布尔值；

\4. 逻辑运算符：and（与，两者都为True才为True）、or（或，任一为True则为True）、not（非，取反）。

实战示例：

# 算术运算符
a = 10
b = 3
print(a + b)  # 13
print(a / b)  # 3.333...（浮点数）
print(a // b) # 3（整除，舍去小数）
print(a % b)  # 1（取余）
print(a ** 2) # 100（10的2次方）
​
# 赋值运算符
a += 5  # 等价于 a = a + 5，结果为15
print(a)
​
# 比较运算符
print(a == 15)  # True
print(b > 5)    # False
​
# 逻辑运算符
print(a > 10 and b < 5)  # True（两者都成立）
print(a < 10 or b == 3)  # True（任一成立）
print(not (a == 15))     # False（取反）

注意事项：算术运算中，除数不能为0，否则会报错；比较运算符 == 是判断相等，= 是赋值，切勿混淆；逻辑运算遵循“短路原则”（and前为False则不执行后半部分，or前为True则不执行后半部分）。

4. 条件判断（if-elif-else）

核心说明：根据条件的真假，执行不同的代码块，实现“分支逻辑”，是Python中最基础的逻辑控制语句。

核心语法：

if 条件1: 执行语句1（缩进，4个空格或1个Tab） elif 条件2: 执行语句2（缩进） else: 执行语句3（缩进）

说明：elif可多个，else可选；条件为布尔值，或可转换为布尔值的表达式。

实战示例：

# 根据分数判断等级
score = 85
if score >= 90:
    print("优秀")
elif score >= 80:
    print("良好")
elif score >= 60:
    print("及格")
else:
    print("不及格")
​
# 嵌套条件（条件内再写条件）
age = 18
is_student = True
if age >= 18:
    if is_student:
        print("成年学生")
    else:
        print("成年人")
else:
    print("未成年人")

注意事项：缩进是Python的语法规则，同一代码块的缩进必须一致，否则会报错；elif不能单独使用，必须跟在if后面；else必须跟在if或elif后面，不能单独使用。

5. 循环语句（for & while）

核心说明：用于重复执行一段代码，避免重复编写，分为for循环（遍历可迭代对象）和while循环（条件满足则循环）。

核心语法：

\1. for循环：for 变量 in 可迭代对象（字符串、列表、range等）: 循环执行语句（缩进） 可选：else（循环正常结束后执行，break终止则不执行）；

\2. while循环：while 条件: 循环执行语句（缩进） 可选：else（条件不满足时执行，break终止则不执行）；

\3. 循环控制：break（终止整个循环）、continue（跳过当前循环，进入下一次）。

实战示例：

# for循环（遍历字符串）
text = "Python"
for char in text:
    print(char)  # 依次输出P、y、t、h、o、n
​
# for循环（range()函数，生成指定范围的整数）
for i in range(5):  # 生成0-4（左闭右开）
    print(i)
​
# while循环（打印1-5）
num = 1
while num <= 5:
    print(num)
    num += 1  # 必须有“更新条件”，否则会无限循环
​
# 循环控制
for i in range(10):
    if i == 3:
        continue  # 跳过i=3，继续下一次循环
    if i == 7:
        break     # 终止循环，不再执行后续内容
    print(i)

注意事项：while循环必须有“循环更新条件”（如num += 1），否则会陷入无限循环，需手动终止；range(a, b) 生成a到b-1的整数，range(n) 生成0到n-1的整数；break终止整个循环，continue仅跳过当前一次循环。

二、Python进阶知识点（提升必备）

1. 列表（list）—— 最常用的复合数据类型

核心说明：列表是有序、可修改、可重复的复合数据类型，用于存储多个不同类型的数据，支持增删改查等操作，是Python中最常用的数据结构之一。

核心语法：

\1. 列表创建：列表名 = [元素1, 元素2, ...]（元素可任意类型，可重复）；

\2. 访问元素：列表名[索引]（索引从0开始，负数表示从末尾开始，如-1是最后一个元素）；

\3. 常用操作：append(元素)（末尾添加）、insert(索引, 元素)（指定位置添加）、remove(元素)（删除指定元素）、pop(索引)（删除指定索引元素，默认最后一个）、len(列表名)（获取长度）、sort()（排序）。

实战示例：

# 创建列表
lst = [10, "Python", 95.5, True]
​
# 访问元素
print(lst[0])   # 10（第一个元素）
print(lst[-1])  # True（最后一个元素）
​
# 增删改查
lst.append(20)  # 末尾添加20，列表变为[10, "Python", 95.5, True, 20]
lst.insert(1, "Hello")  # 在索引1位置添加Hello
lst.remove("Python")    # 删除元素"Python"
lst.pop()       # 删除最后一个元素（20）
print(len(lst)) # 获取列表长度，输出4
lst.sort()      # 排序（仅当列表元素为同一类型时可用，如全是数字）
​
print(lst)      # 输出：[10, 95.5, True, "Hello"]（排序后顺序根据类型而定）

注意事项：列表索引不能超出范围，否则会报错；remove() 仅删除第一个匹配的元素，若元素不存在则报错；sort() 排序时，列表元素需为同一类型（如全是整数、全是字符串），否则报错。

2. 字典（dict）—— 键值对存储数据

核心说明：字典是无序、可修改、键唯一的复合数据类型，以“键值对（key: value）”形式存储数据，通过键快速查找值，适合存储关联数据（如个人信息）。

核心语法：

\1. 字典创建：字典名 = {键1: 值1, 键2: 值2, ...}（键必须是不可变类型：字符串、整数、元组等，值可任意类型）；

\2. 访问元素：字典名[键] 或 字典名.get(键)（推荐，键不存在时返回None，不报错）；

\3. 常用操作：字典名[新键] = 新值（添加/修改键值对）、del 字典名[键]（删除键值对）、keys()（获取所有键）、values()（获取所有值）、items()（获取所有键值对）。

实战示例：

# 创建字典（存储个人信息）
person = {"name": "张三", "age": 20, "gender": "男", "score": 90}
​
# 访问元素
print(person["name"])  # 张三（通过键访问，键不存在报错）
print(person.get("height"))  # None（键不存在，不报错）
​
# 增删改查
person["height"] = 175  # 添加新键值对
person["age"] = 21      # 修改已有键值对
del person["score"]     # 删除键值对"score"
​
print(person.keys())    # 获取所有键：dict_keys(['name', 'age', 'gender', 'height'])
print(person.values())  # 获取所有值：dict_values(['张三', 21, '男', 175])
# 遍历字典（常用）
for key, value in person.items():
    print(f"{key}: {value}")

注意事项：字典的键必须唯一，若重复，后面的键值对会覆盖前面的；键必须是不可变类型（不能用列表作为键）；字典是无序的（Python 3.7+ 后有序，但不依赖顺序），不能通过索引访问。

3. 函数（def）—— 封装可复用代码

核心说明：函数是将一段可复用的代码封装起来，通过调用函数执行代码，减少重复编写，提高代码可读性和复用性，分为自定义函数和内置函数。

核心语法（自定义函数）：

def 函数名(参数1, 参数2, ..., 默认参数=值): 函数体（执行的代码，缩进） 可选：return 返回值（无return则返回None）

说明：参数分为位置参数（必须按顺序传入）、默认参数（可省略，有默认值）；函数调用：函数名(参数1, 参数2, ...)。

实战示例：

# 自定义函数（计算两个数的和，带默认参数）
def add(a, b=0):  # b是默认参数，默认值为0
    sum_result = a + b
    return sum_result  # 返回计算结果
​
# 调用函数
print(add(5, 3))  # 8（传入两个参数，覆盖默认值）
print(add(10))    # 10（仅传入a，b用默认值0）
​
# 自定义函数（无返回值）
def print_info(name, age):
    print(f"姓名：{name}，年龄：{age}")
​
print_info("李四", 22)  # 输出：姓名：李四，年龄：22
​
# 内置函数（Python自带，直接调用）
print(len([1,2,3]))  # 3（获取列表长度）
print(max(10, 20, 5))# 20（获取最大值）

注意事项：函数定义必须在调用之前，否则会报错；默认参数必须放在位置参数后面，否则会报错；函数内定义的变量是局部变量，只能在函数内使用，外部无法访问；若需修改全局变量，需用global关键字声明。

4. 模块与包（import）—— 扩展Python功能

核心说明：模块是一个.py文件，包含Python代码（函数、类、变量等）；包是多个模块的集合，用于组织代码；通过import导入模块/包，可直接使用其功能，无需重复编写。

核心语法：

\1. 导入模块：import 模块名 或 from 模块名 import 函数/类/变量；

\2. 导入包：import 包名.模块名 或 from 包名.模块名 import 功能；

\3. 别名：import 模块名 as 别名（简化调用）。

实战示例：

# 导入Python内置模块（math，数学相关功能）
import math
print(math.sqrt(16))  # 4.0（计算平方根）
print(math.pi)        # 3.141592653589793（圆周率）

# 简化导入（只导入需要的函数）
from math import sqrt, pi
print(sqrt(25))       # 5.0
print(pi)

# 给模块起别名
import math as m
print(m.pow(2, 3))    # 8.0（2的3次方）

# 导入第三方模块（需先安装，如requests，用于网络请求）
# pip install requests  # 安装命令（终端执行）
import requests
response = requests.get("https://www.baidu.com")
print(response.status_code)  # 200（表示请求成功）

注意事项：内置模块无需安装，直接导入即可；第三方模块需先通过pip安装（pip是Python的包管理工具）；导入时，模块名/包名区分大小写；若导入的模块/功能不存在，会报错。

5. 类与对象（面向对象编程）

核心说明：面向对象编程（OOP）的核心，类是“模板”，用于定义对象的属性和方法；对象是类的“实例”，拥有类定义的属性和方法，可实现代码的封装、继承和多态。

核心语法：

\1. 定义类：class 类名(): def init(self, 属性1, 属性2, ...): # 构造方法，初始化对象属性 self.属性1 = 属性1 self.属性2 = 属性2 def 方法名(self, 参数...): # 类的方法，self必须作为第一个参数（代表对象本身） 方法体 可选：return 返回值；

\2. 创建对象：对象名 = 类名(属性1, 属性2, ...)；

\3. 访问属性/调用方法：对象名.属性、对象名.方法名(参数...)。

实战示例：

# 定义类（学生类）
class Student:
    # 构造方法，初始化学生属性
    def __init__(self, name, age, score):
        self.name = name
        self.age = age
        self.score = score
    
    # 类的方法（显示学生信息）
    def show_info(self):
        print(f"姓名：{self.name}，年龄：{self.age}，成绩：{self.score}")
    
    # 类的方法（修改成绩）
    def update_score(self, new_score):
        self.score = new_score
        print(f"成绩已更新为：{self.score}")

# 创建对象（实例化类）
stu1 = Student("王五", 19, 88)
stu2 = Student("赵六", 20, 92)

# 访问属性、调用方法
print(stu1.name)       # 王五
stu1.show_info()       # 输出：姓名：王五，年龄：19，成绩：88
stu1.update_score(90)  # 输出：成绩已更新为：90
stu2.show_info()       # 输出：姓名：赵六，年龄：20，成绩：92

注意事项：类名首字母建议大写，遵循“大驼峰命名法”；init是构造方法，创建对象时自动执行，用于初始化属性；self是类中方法的第一个参数，代表对象本身，不能省略；一个类可以创建多个对象，每个对象的属性相互独立。

三、Python进阶延伸知识点（深化提升）

1. 元组（tuple）—— 不可变复合类型

核心说明：元组是有序、不可修改、可重复的复合数据类型，语法与列表类似，但用圆括号包裹，适合存储不可修改的数据（如常量、固定配置），比列表更节省内存。

核心语法：

\1. 元组创建：元组名 = (元素1, 元素2, ...)（元素可任意类型，可重复；单个元素需加逗号，如(1,)，否则会被识别为普通数据类型）；

\2. 访问元素：与列表一致，元组名[索引]（索引从0开始，支持负数）；

\3. 常用操作：len(元组名)（获取长度）、count(元素)（统计元素出现次数）、index(元素)（获取元素第一次出现的索引）；无增删改操作（不可修改）。

实战示例：

# 创建元组
t1 = (10, "Python", 95.5)  # 多个元素
t2 = (20,)  # 单个元素，必须加逗号
t3 = tuple([1,2,3])  # 列表转元组

# 访问元素
print(t1[0])   # 10
print(t1[-2])  # "Python"

# 常用操作
print(len(t1))          # 3（获取长度）
print(t1.count("Python"))  # 1（统计元素出现次数）
print(t1.index(95.5))   # 2（获取元素索引）

# 注意：元组不可修改，以下操作会报错
# t1[0] = 100  # 报错：'tuple' object does not support item assignment

注意事项：元组不可修改，一旦创建，元素的个数、值都无法更改；元组可作为字典的键（不可变类型），列表不可作为字典的键；元组的遍历方式与列表一致（for循环）。

2. 集合（set）—— 无序去重集合

核心说明：集合是无序、不可重复、无索引的复合数据类型，用大括号包裹，适合用于去重、集合运算（如交集、并集），元素必须是不可变类型（字符串、整数、元组等）。

核心语法：

\1. 集合创建：集合名 = {元素1, 元素2, ...} 或 集合名 = set(可迭代对象)（如列表、字符串）；

\2. 常用操作：add(元素)（添加元素）、remove(元素)（删除元素，不存在报错）、discard(元素)（删除元素，不存在不报错）、union()（并集）、intersection()（交集）、difference()（差集）；

\3. 核心特性：自动去重，添加重复元素不会生效。

实战示例：

# 创建集合（自动去重）
s1 = {10, 20, 30, 20}  # 去重后为{10,20,30}
s2 = set([1,2,2,3,4])  # 列表转集合，去重后为{1,2,3,4}
s3 = set("Python")      # 字符串转集合，去重后为{'P','y','t','h','o','n'}

# 常用操作
s1.add(40)  # 添加元素40
s1.remove(20)  # 删除元素20
s1.discard(50)  # 删除元素50，不存在不报错

# 集合运算
s4 = {10, 20, 30}
s5 = {20, 30, 40}
print(s4.union(s5))        # 并集：{10,20,30,40}
print(s4.intersection(s5)) # 交集：{20,30}
print(s4.difference(s5))   # 差集：{10}（s4中有、s5中没有）

# 去重实战（列表去重）
lst = [1,2,2,3,3,3]
new_lst = list(set(lst))  # 先转集合去重，再转列表
print(new_lst)  # 输出：[1,2,3]（顺序不固定，因集合无序）

注意事项：集合无序，不能通过索引访问元素；集合元素必须是不可变类型（不能用列表、字典作为集合元素）；remove() 删除不存在的元素会报错，优先使用discard()；集合运算适合用于数据去重和关系判断。

3. 异常处理（try-except）—— 避免程序崩溃

核心说明：异常是程序运行时出现的错误（如除数为0、索引越界），会导致程序崩溃；try-except 用于捕获异常、处理异常，让程序正常运行，是编写健壮代码的必备知识点。

核心语法：

try: 可能出现异常的代码块（缩进） except 异常类型1: 异常1发生时执行的代码（缩进） except 异常类型2: 异常2发生时执行的代码（缩进） else: 无异常时执行的代码（缩进，可选） finally: 无论是否有异常，都会执行的代码（缩进，可选）

常用异常类型：ZeroDivisionError（除数为0）、IndexError（索引越界）、TypeError（类型错误）、ValueError（值错误）。

实战示例：

# 捕获除数为0的异常
try:
    a = 10
    b = 0
    print(a / b)
except ZeroDivisionError:
    print("错误：除数不能为0！")
else:
    print("运算成功，结果为：", a / b)
finally:
    print("运算结束（无论是否出错都会执行）")

# 捕获多种异常
try:
    lst = [1,2,3]
    print(lst[5])  # 索引越界
    num = int("abc")  # 类型错误（字符串无法转整数）
except IndexError:
    print("错误：索引超出范围！")
except TypeError:
    print("错误：数据类型不匹配！")
except Exception as e:  # 捕获所有异常（兜底）
    print(f"发生未知错误：{e}")

注意事项：except 可捕获指定异常，也可用Exception捕获所有异常（兜底）；else 仅在无异常时执行，finally 无论是否有异常都会执行（适合关闭文件、释放资源）；不要滥用Exception，尽量捕获具体异常，便于排查问题。

4. 文件操作（open()）—— 读写本地文件

核心说明：通过open() 函数可打开本地文件，实现文件的读取、写入、追加等操作，是Python中处理本地数据的核心功能，需注意文件路径和关闭文件。

核心语法：

\1. 打开文件：file = open(文件路径, 打开模式, encoding="utf-8")；

\2. 打开模式（常用）：r（只读，默认）、w（写入，覆盖原有内容，文件不存在则创建）、a（追加，在文件末尾添加内容，文件不存在则创建）、r+（读写）；

\3. 常用操作：read()（读取全部内容）、readline()（读取一行）、readlines()（读取所有行，返回列表）、write(内容)（写入内容）；

\4. 关闭文件：file.close()（必须关闭，释放资源）；推荐使用with语句（自动关闭文件，无需手动操作）。

实战示例：

# 方式1：手动关闭文件
file1 = open("test.txt", "w", encoding="utf-8")  # 写入模式
file1.write("Python核心知识点\n")  # 写入内容
file1.write("文件操作实战")
file1.close()  # 必须关闭文件

# 方式2：with语句（推荐，自动关闭）
with open("test.txt", "a", encoding="utf-8") as file2:
    file2.write("\n追加的内容")  # 追加内容

# 读取文件
with open("test.txt", "r", encoding="utf-8") as file3:
    content1 = file3.read()  # 读取全部内容
    print("全部内容：", content1)
    
    file3.seek(0)  # 重置文件指针到开头
    content2 = file3.readline()  # 读取一行
    print("第一行内容：", content2)
    
    file3.seek(0)
    content3 = file3.readlines()  # 读取所有行，返回列表
    print("所有行：", content3)

注意事项：打开文件时需指定encoding="utf-8"，否则可能出现中文乱码；w模式会覆盖原有内容，需谨慎使用；读取文件后，文件指针会移动到末尾，需用seek(0)重置指针才能重新读取；with语句会自动关闭文件，避免忘记关闭导致资源泄露。

5. 装饰器（@decorator）—— 增强函数功能

核心说明：装饰器是Python的高级特性，本质是函数，用于在不修改原函数代码和调用方式的前提下，为函数添加额外功能（如计时、日志、权限校验），提高代码复用性。

核心语法：

\1. 定义装饰器： def 装饰器名(函数名): def 内部函数(args, **kwargs): # 额外功能代码（如计时、日志） 结果 = 函数名(args, **kwargs) # 调用原函数 # 额外功能代码 return 结果 return 内部函数；

\2. 使用装饰器：@装饰器名（放在原函数定义上方，语法糖）。

实战示例：

import time
​
# 定义装饰器（为函数添加计时功能）
def timer(func):
    def inner(*args, **kwargs):
        start_time = time.time()  # 记录开始时间
        result = func(*args, **kwargs)  # 调用原函数
        end_time = time.time()    # 记录结束时间
        print(f"函数{func.__name__}运行时间：{end_time - start_time:.2f}秒")
        return result
    return inner
​
# 使用装饰器（@语法糖，放在函数上方）
@timer
def add(a, b):
    time.sleep(1)  # 模拟函数运行耗时
    return a + b
​
# 调用函数（无需修改调用方式）
print(add(5, 3))  # 输出：函数add运行时间：1.00秒  8
​
# 装饰器叠加（多个装饰器为函数添加多个功能）
def log(func):
    def inner(*args, **kwargs):
        print(f"函数{func.__name__}被调用，参数：{args}, {kwargs}")
        result = func(*args, **kwargs)
        print(f"函数{func.__name__}调用结束，返回值：{result}")
        return result
    return inner
​
@log  # 先执行log装饰器
@timer # 再执行timer装饰器
def multiply(a, b):
    return a * b
​
multiply(4, 5)  # 输出日志和运行时间

注意事项：装饰器的执行顺序是“从下到上”（叠加装饰器时，下方装饰器先执行）；*args 和 **kwargs 用于接收原函数的任意参数，确保装饰器适配所有函数；装饰器不会修改原函数的代码和调用方式，仅增强功能。