作用：用来把变量填充到字符串里面
name = "Tom" age = 18 ——> print("我是{}，今年{}岁".format(name, age))
1. String常用方法
strip()——>去空格 replace()——>替换字符串 split()——>字符串 → 列表
join()——>列表→字符串 find()——>查找位置 startswith()——>判断开头
endswith()——>判断结尾 upper()/lower()——>大小写转换
count()——>统计次数 len()——>获取长度
1、upper()
作用： 将字符串全部转换为大写
name = "hello" print(name.upper()) ——> HELLO
2、lower()
作用： 将字符串全部转换为小写
name = "HELLO" print(name.lower()) ——> hello
3、strip()
作用： 去掉字符串两端的空格（也可去掉指定字符）
text = " hello " print(text.strip()) ——> hello
4、replace()
作用： 替换字符串中的内容
text = "I like Python"
print(text.replace("Python", "Java")) ——> I like Java
5、split()
作用： 按指定字符分割字符串，返回列表 text = "apple,banana,orange"
print(text.split(",")) ——> ['apple', 'banana', 'orange']
6、join()
作用： 将列表中的字符串拼接成一个字符串
fruits = ["apple", "banana", "orange"]
print(",".join(fruits)) ——> apple,banana,orange
7、find()
作用： 查找子字符串第一次出现的位置，找不到返回 -1
text = "hello python"
print(text.find("python")) ——> 6
8、startswith()
作用： 判断字符串是否以指定内容开头
url = "https://example.com"
print(url.startswith("https")) ——> True
9、endswith()
作用： 判断字符串是否以指定内容结尾
file = "test.py" print(file.endswith(".py")) ——>True
10、count()
作用： 统计某个字符串出现的次数
text = "hello hello python" print(text.count("hello")) ——> 2
11、len()
作用： 获取字符串长度（内置函数，不是字符串方法）
text = "Python"
print(len(text)) ——> 6
2. List常用操作
1、append()
作用： 在列表末尾添加一个元素
fruits = ["apple", "banana"]
fruits.append("orange") print(fruits) ——> ['apple', 'banana', 'orange']
2、insert()
作用： 在指定位置插入元素
nums = [1, 3]
nums.insert(1, 2) print(nums) ————> [1, 2, 3]
3、extend()
作用： 将另一个列表追加到当前列表
a = [1, 2] b = [3, 4]
a.extend(b) print(a) ————> [1, 2, 3, 4]
4、remove()
作用： 删除指定元素
nums = [1, 2, 3]
nums.remove(2) print(nums) ————> [1, 3]
5、pop()
作用： 删除并返回指定位置的元素（默认最后一个）
nums = [1, 2, 3]
x = nums.pop() print(x) print(nums) ————> 3 [1, 2]
6、index()
作用： 获取元素第一次出现的位置
nums = [10, 20, 30]
print(nums.index(20)) ————> 1
7、count()
作用： 统计元素出现次数
nums = [1, 2, 2, 3]
print(nums.count(2)) ————> 2
8、sort()
作用： 对列表进行排序（默认升序）
nums = [3, 1, 2]
nums.sort() print(nums) ————> [1, 2, 3]
9、reverse()
作用： 反转列表
nums = [1, 2, 3]
nums.reverse() print(nums) ————> [3, 2, 1]
3. Dict常用操作
1、get()
作用： 获取指定键的值，键不存在不会报错
user = {"name": "Tom"}
print(user.get("name")) ————> Tom
2、pop()
作用： 删除指定键，并返回对应的值
user = {"name": "Tom", "age": 18}
user.pop("age") print(user) ————> {'name': 'Tom'}
3、keys()
作用： 获取字典所有的键
user = {"name": "Tom", "age": 18}
print(user.keys()) ————> dict_keys(['name', 'age'])
4、values()
作用： 获取字典所有的值
user = {"name": "Tom", "age": 18}
print(user.values()) ————> dict_values(['Tom', 18])
5、items()
作用： 获取所有键值对
user = {"name": "Tom", "age": 18}
print(user.items()) ————> dict_items([('name', 'Tom'), ('age', 18)])
4. 文件常用操作
1、open()
作用： 打开文件
f = open("test.txt", "r")
总结： open(文件名, 模式)
2、read()
作用： 读取整个文件内容
with open("test.txt", "r") as f:
print(f.read())
总结： 一次性读取全部内容。
3、readline()
作用： 读取一行内容
with open("test.txt", "r") as f:
print(f.readline())
总结： 每次读取一行
4、readlines()
作用： 读取所有行，返回列表
with open("test.txt", "r") as f:
print(f.readlines()) ————> ['第一行\n', '第二行\n']
总结： 返回由每一行组成的列表。
5、write()
作用： 写入内容到文件
with open("test.txt", "w") as f:
f.write("Hello Python")
6、seek()
作用： 移动文件指针
with open("test.txt", "r") as f:
f.seek(0)
print(f.read())
7、文件的拓展模式
1. "r"（Read） 作用： 只读模式，文件必须存在
2. "w"（Write） 作用： 写入模式，覆盖原文件；文件不存在会自动创建
3. "a"（Append） 作用： 追加模式，在文件末尾写入；文件不存在会自动创建
4. "r+" 作用： 可读可写，文件必须存在
5. "w+" 作用： 可读可写，覆盖原文件；不存在则创建
6. "a+" 作用： 可读可写，写入时始终追加到文件末尾。
7. "rb" 作用： 以二进制方式读取文件（常用于图片、视频、压缩包）
8. "wb" 作用： 以二进制方式写入文件
5、Python 闭包
作用: 一个函数返回另一个函数，并且返回的函数可以访问外部函数的变量。
def 外部函数():
变量
def 内部函数():
使用变量
return 内部函数
总结： 闭包 = 外部函数 + 内部函数 + return 内部函数 + 内部函数使用外部变量
6、Lambda 表达式
作用: Lambda（匿名函数）用于定义一个简单的、只有一行代码的函数
lambda 参数: 返回值
add = lambda x, y: x + y
print(add(3, 5)) ——————> 8
7、locals() 和 globals()
1. locals()
作用： 获取当前局部作用域中的所有变量，返回一个字典。
def test():
name = "Tom"
age = 18
print(locals())
test() ————> {'name': 'Tom', 'age': 18}
总结： locals() 返回当前函数中的局部变量
2. globals()
作用： 获取当前全局作用域中的所有变量，返回一个字典。
name = "Tom"
print(globals()["name"]) ————> tom
总结： globals() 返回程序中的全局变量
8、迭代器（Iterator）
作用： 迭代器用于逐个获取数据，每次取一个元素，而不是一次取完所有元素
iter(可迭代对象)
next(迭代器)
总结： 迭代器是一个可以逐个返回元素的对象，通过 iter() 创建，通过 next() 获取下一个元素，数据取完后会抛出 StopIteration
9、map() 高阶函数
作用： map() 会将一个函数依次作用到可迭代对象（如列表）的每个元素上，并返回一个迭代器。
map(函数, 可迭代对象)
nums = [1, 2, 3]
result = map(lambda x: x * 2, nums)
print(list(result)) ————> [2, 4, 6]
总结： map() = 对列表中的每个元素执行同一个函数，并返回新的结果。通常需要配合 list() 将结果转换为列表。
10、reduce() 高阶函数
作用： 会将可迭代对象中的元素依次进行累积计算，最终返回一个结果
from functools import reduce
reduce(函数, 可迭代对象)
nums = [1, 2, 3, 4]
result = reduce(lambda x, y: x + y, nums)
print(result) ————> 10
执行过程：
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
总结： reduce() = 将列表中的元素按照指定规则依次计算，最后得到一个结果。常用于求和、求积、累积计算等。
11、filter() 高阶函数
作用： 用于过滤数据，保留满足条件的元素，并返回一个迭代器
filter(函数, 可迭代对象)
nums = [1, 2, 3, 4, 5]
result = filter(lambda x: x % 2 == 0, nums)
print(list(result)) ————> [2, 4]
总结: filter() = 根据条件筛选数据，只保留返回 True 的元素。通常需要配合 list() 将结果转换为列表
12、sorted() 高阶函数
作用： sorted() 用于对可迭代对象进行排序，并返回一个新的排序结果
sorted(可迭代对象, key=函数, reverse=False) #key：指定排序规则 reverse（默认 False，升序）
students = [
{"name": "Tom", "age": 20},
{"name": "Jack", "age": 18},
{"name": "Lucy", "age": 22}
]
result = sorted(students, key=lambda x: x["age"])
print(result) ————>
[
{'name': 'Jack', 'age': 18},
{'name': 'Tom', 'age': 20},
{'name': 'Lucy', 'age': 22}
]
总结： sorted() 可以根据 key 指定的规则进行排序，lambda 常用于定义排序规则，返回一个新的排序结果，不会修改原列表
13、推导式
作用： 用于快速生成新的列表、字典、集合，比 for 循环更简洁
[表达式 for 变量 in 可迭代对象]
nums = [1, 2, 3, 4]
result = [x * 2 for x in nums]
print(result) ————> [2, 4, 6, 8]
总结： 推导式就是用一行代码生成新的列表、字典或集合，基本格式为：表达式 + for + if
[表达式 for x in 数据] # 列表推导式
{x: 表达式 for x in 数据} # 字典推导式
{表达式 for x in 数据} # 集合推导式
14、生成器
作用： 生成器用于按需生成数据，每次只生成一个元素，比列表更节省内存
def 函数():
yield 数据
def nums():
yield 1
yield 2
yield 3
g = nums()
print(next(g)) ————> 1
print(next(g)) ————> 2
print(next(g)) ————> 3
总结： 生成器是使用 yield 定义的特殊函数，每次调用 next() 都会返回一个值，并从上次暂停的位置继续执行
15、递归
作用： 递归就是函数自己调用自己
def sum_num(n):
if n == 1:
return 1
return n + sum_num(n - 1)
print(sum_num(5))
计算逻辑： 等待5+ sum_num(4) 等待4+ sum_num(3) 等待3+ sum_num(2) 等待2+ sum_num(1) 执行 sum_num(1) 返回——>↓
5 + 10 = 15 4 + 6 = 10 3 + 3 = 6 2 + 1 = 3 return：1
16、random 模块（随机数）
import random
1. random.random() #生成 0~1 之间的随机浮点数（包含 0，不包含 1）
2. random.randint(1,10) #生成指定范围内的随机整数（包含两端）
3. random.choice() #从序列中随机选择一个元素 fruits = ["apple", "banana", "orange"] print(random.choice(fruits))
4. random.shuffle() #打乱列表顺序（原列表会被修改）nums = [1, 2, 3, 4] random.shuffle(nums)
17、pickle 模块
作用： pickle 用于将 Python 对象保存到文件，或从文件中恢复对象
1. pickle.dump() #将对象直接保存到文件
import pickle
data = {"name": "Tom"}
with open("data.pkl", "wb") as f:
pickle.dump(data, f)
# 总结： 对象 → 文件
2. pickle.load() #从文件中读取对象
with open("data.pkl", "rb") as f:
data = pickle.load(f)
print(data) ————> {'name': 'Tom'}
# 总结： 文件 → 对象
18、json 模块
作用： 用于 Python 对象与 JSON 数据之间的转换
import json
1. json.dumps() # 将 Python 对象转换为 JSON 字符串
data = {"name": "Tom", "age": 18}
result = json.dumps(data)
print(result) ————> {"name": "Tom", "age": 18}
2. json.loads() # 将 JSON 字符串 转换为 Python 对象
s = '{"name": "Tom", "age": 18}'
result = json.loads(s)
print(result) ————> {'name': 'Tom', 'age': 18}
3. json.dump() # 将 Python 对象写入 JSON 文件
data = {"name": "Tom", "age": 18}
with open("data.json", "w") as f:
json.dump(data, f)
4. json.load() # 从 JSON 文件中读取数据，并转换为 Python 对象
with open("data.json", "r") as f:
data = json.load(f)
print(data) ————> {'name': 'Tom', 'age': 18}
19、time 模块
作用： time 模块用于处理时间，如获取当前时间、格式化时间、暂停程序等
import time
time.time() # 获取当前时间戳（1970-01-01 00:00:00 到现在的秒数）
time.sleep() # 让程序暂停指定秒数 ————> time.sleep(1)
time.localtime() # 将时间戳转换为本地时间对象
time.strftime() # 将时间对象格式化为字符串 now = time.localtime() print(time.strftime("%Y-%m-%d %H:%M:%S", now)) ——> 2026-07-31 17:05:30
20、zipfile 模块
作用： 用于创建、读取、解压 ZIP 压缩文件
import zipfile
1. ZipFile() #打开或创建 ZIP 文件
zip_file = zipfile.ZipFile("test.zip", "r") #打开test.zip文件
2. write() #向 ZIP 文件中添加文件
with zipfile.ZipFile("test.zip", "w") as z:
z.write("test.txt") #将test.txt文件添加到test.zip中
3. extract() # 解压指定文件
with zipfile.ZipFile("test.zip", "r") as z:
z.extract("test.txt") #将test.zip里的test.txt解压出来
4. extractall() # 解压 ZIP 中的所有文件
with zipfile.ZipFile("test.zip", "r") as z:
z.extractall("output") #解压全部文件到指定的output目录
5. namelist() # 获取 ZIP 文件中的所有文件名
with zipfile.ZipFile("test.zip", "r") as z:
print(z.namelist()) ——> ['test.txt'] #查看压缩包中的文件列表
21、os 模块
作用： 用于操作操作系统，如文件、目录、路径、环境变量等
import os
1. os.getcwd() # 获取当前工作目录
2. os.listdir() # 获取指定目录下的所有文件和文件夹 print(os.listdir(".")) ——> ['a.txt', 'b.py', 'test']
3. os.mkdir() # 创建一个目录 os.mkdir("demo")
4. os.remove() # 删除文件 os.remove("a.txt")
5. os.rmdir() # 删除空目录 os.rmdir("demo")
6. os.rename() # 重命名文件或目录 os.rename("a.txt", "b.txt")
7. os.path.exists() # 判断文件或目录是否存在 print(os.path.exists("a.txt")) ——> True
8. os.path.join() # 拼接路径 path = os.path.join("data", "test.txt") print(path) ——> data/test.txt
22、shutil 模块
作用： 用于高级文件操作，如复制、移动、删除目录等
import shutil
1. shutil.copy() # 复制文件 shutil.copy("a.txt", "b.txt") 保留内容
2. shutil.copytree() # 复制整个目录 shutil.copytree("test", "test_copy")
3. shutil.move() # 移动或重命名文件/目录 shutil.move("a.txt", "demo/a.txt")
4. shutil.rmtree() # 删除整个目录（包括里面所有文件） shutil.rmtree("test")
浙公网安备 33010602011771号