python考试的基础知识
前言 计算机二级真是米奇妙妙屋,考了我几乎不会用到的知识点和一些操作,补充知识了
python的异常处理 使用 try-except
语句来捕获和处理运行时错误,并可以在 finally
代码块中执行清理操作。
捕获多个异常 1 2 3 4 5 try : lst = [1 , 2 , 3 ] print (lst[5 ]) except (IndexError, ZeroDivisionError) as e: print (f"发生错误:{e} " )
3. 捕获所有异常 1 2 3 4 try : x = 10 / 0 except Exception as e: print (f"捕获所有异常:{e} " )
🔹 解释 :
Exception
是所有异常的基类,捕获任何异常。
不推荐 滥用 Exception
,因为可能忽略关键错误。
4. 使用 finally
语句 1 2 3 4 5 6 7 try : file = open ("test.txt" , "r" ) data = file.read() except FileNotFoundError: print ("文件未找到!" ) finally : print ("无论是否发生异常,都会执行此处" )
🔹 finally
语句的作用 :
无论是否发生异常,finally
块的代码都会执行 (比如关闭文件、释放资源等)。
5. 使用 else
语句 1 2 3 4 5 6 7 try : num = int (input ("输入一个数字: " )) result = 100 / num except ZeroDivisionError: print ("不能除以零!" ) else : print (f"计算结果: {result} " )
🔹 else
语句的作用 :
只有在 try
代码块无异常时才执行 (适用于有可能引发异常但希望后续代码不受影响的情况)。
6. 自定义异常 1 2 3 4 5 6 7 8 9 10 class MyError (Exception ): """自定义异常类""" def __init__ (self, message ): self.message = message super ().__init__(message) try : raise MyError("这是一个自定义异常" ) except MyError as e: print (f"捕获到异常: {e} " )
🔹 解释 :
raise MyError("错误信息")
主动抛出异常 。
MyError
继承 Exception
,定义自定义异常类型。
7. raise
关键字 1 2 3 4 5 6 try : age = int (input ("请输入年龄: " )) if age < 0 : raise ValueError("年龄不能为负数" ) except ValueError as e: print (f"异常: {e} " )
🔹 解释 :
总结
语法
作用
try-except
捕获异常,避免程序崩溃
except Exception as e
获取异常信息
except (TypeError, ValueError)
捕获多个异常
else
只有 try
代码块没有异常 时才执行
finally
无论是否异常都会执行 (释放资源)
raise
主动抛出异常
自定义异常
继承 Exception
,创建自己的异常类
python的异常处理类型 以下是 Python 常见 的异常,按类别精简整理:
异常类型
说明
ZeroDivisionError
除数为零,如 10 / 0
ValueError
传入无效参数,如 int("abc")
TypeError
数据类型错误,如 "abc" + 123
IndexError
列表索引越界,如 lst[10]
KeyError
字典键不存在,如 dict["missing_key"]
AttributeError
访问对象不存在的属性,如 "abc".no_method()
NameError
变量未定义,如 print(undeclared_var)
FileNotFoundError
文件未找到,如 open("missing.txt")
IOError
I/O 读写错误
ImportError
模块导入失败,如 import nonexistent_module
RuntimeError
运行时错误的通用异常
SyntaxError
代码语法错误
IndentationError
缩进错误
KeyboardInterrupt
用户手动终止程序(Ctrl + C
)
这些是开发过程中最常见 的异常类型,掌握它们可以更好地进行异常处理!
字符串的操作 1 2 3 4 5 6 s = "apple" print (s[:-1 ]) print (s[:-1 :]) print (s[:4 ]) print (s[:5 ]) print (s[:6 ])
1 2 3 4 5 6 s = "banana" print (s[::-1 ]) print (s[:-1 :-1 ]) print (s[:-1 :2 ]) print (s[:5 :2 ]) print (s[:6 :-2 ])
random库
函数
作用
random.random()
生成 0 ~ 1 的随机小数
random.uniform(a, b)
生成范围 [a, b]
内的随机小数
random.randint(a, b)
生成范围 [a, b]
内的随机整数
random.randrange(a, b, step)
生成 a
到 b
之间步长为 step
的随机整数
random.choice(seq)
随机选择一个元素
random.choices(seq, k=n)
选择 k
个元素(可重复)
random.sample(seq, k=n)
选择 k
个不重复元素
random.shuffle(seq)
打乱序列顺序
random.choice([True, False])
生成随机布尔值
random.randbytes(n)
生成 n
个随机字节
✅ random
适用于随机抽奖、游戏随机事件、数据加密、模拟实验 等场景! 🚀
join()函数 🔹 join()
函数简介 join()
是 Python 字符串方法 ,用于将多个字符串拼接成一个字符串 ,适用于列表、元组、集合等可迭代对象 。
🔹 语法
🔹 常见用法
用途
代码示例
输出
连接列表
" ".join(["Hello", "World"])
"Hello World"
使用 -
连接
"-".join(["2025", "03", "28"])
"2025-03-28"
直接拼接
"".join(["A", "B", "C"])
"ABC"
连接元组
",".join(("apple", "banana"))
"apple,banana"
连接集合
`”
“.join({“Python”, “Java”})`
连接字典键
",".join({"name": "Alice", "age": "25"})
"name,age"
连接数字(错误)
"-".join([1, 2, 3])
❌ TypeError
连接数字(正确)
"-".join(map(str, [1, 2, 3]))
"1-2-3"
连接多行字符串
"\n".join(["第一行", "第二行"])
换行显示
📌 turtle
库常用函数 📌 1. 画笔移动 🎯
函数
作用
forward(n)
/ fd(n)
前进 n
像素
backward(n)
/ bk(n)
后退 n
像素
right(deg)
/ rt(deg)
右转 deg
度
left(deg)
/ lt(deg)
左转 deg
度
seth(deg)
设置画笔绝对方向 (0°
右,90°
上,180°
左,270°
下)
goto(x, y)
移动到 (x, y) 位置
setx(x)
/ sety(y)
移动到 指定 x 或 y 坐标
home()
回到 (0,0) 初始点
📌 2. 画笔控制 ✏️
函数
作用
pendown()
/ pd()
落笔 (开始画图)
penup()
/ pu()
抬笔 (不画图移动)
pensize(n)
设置画笔粗细
pencolor("red")
设置画笔颜色
speed(n)
设置绘画速度 (1~10,0最快)
📌 3. 画图 🖌️
函数
作用
circle(r)
画半径 r
的圆
dot(size, color)
画指定大小和颜色的点
begin_fill()
/ end_fill()
填充颜色 (需 fillcolor()
)
fillcolor("blue")
设置填充颜色
📌 4. 其他 🎨
函数
作用
clear()
清空画布
reset()
重置画布
hideturtle()
隐藏画笔
showturtle()
显示画笔
done()
结束绘制,窗口保持
📌 🎯 示例:画一个正方形 1 2 3 4 5 6 7 8 9 10 import turtleturtle.pensize(3 ) turtle.pencolor("blue" ) for _ in range (4 ): turtle.forward(100 ) turtle.right(90 ) turtle.done()
一些error 1 2 3 4 a ="3.14" print (int (a))ValueError: invalid literal for int () with base 10 : '3.14'
img1 = img2 并没有复制 img2,只是让 img1 指向 img2 的内存地址
1 2 3 4 5 6 7 8 9 10 11 img1 = ["123" ,"123" ] img2 = ["cnm" ,"123" ] img1 = img2 img1.append([5 ,6 ]) print (img2) img1.append(["5" ,"6" ]) print (img2)
赋值方式
是否影响原列表
img1 = img2
✅ 影响(指向同一块内存)
img1 = img2.copy()
❌ 不影响(但嵌套列表仍会受影响)
img1 = copy.deepcopy(img2)
❌ 完全不影响(独立拷贝)
选择题避坑点 📌 静态语言 vs. 脚本语言(简介)
静态语言 :变量类型固定 ,需编译 后运行,速度快(如 C、C++、Java)。
脚本语言 :变量类型动态 ,解释执行 ,开发效率高(如 Python、JavaScript)。🚀 总结 :高性能选 静态语言 ,开发效率选 脚本语言 。
📌 编译 vs. 解释
编译 :代码先转换为机器码 ,再运行,速度快(如 C、C++)。源代码->目标代码
解释 :代码逐行翻译并执行 ,开发效率高(如 Python、JavaScript)。逐条转换->逐条运行
📌 a / b
vs. a // b
的区别 1 2 3 4 5 a = 6 b = 3 print (a / b) print (a // b)
python的数据类型 1 2 3 4 5 6 数字类型 - 整数 - 浮点数 - 复数 字符串类型
📌 ord()
vs. chr()
✅ **ord()
**:返回字符的 Unicode 编码(整数) ✅ **chr()
**:返回 Unicode 编码对应的字符
1 2 3 4 5 print (ord ('A' )) print (chr (65 )) print (ord ('中' )) print (chr (20013 ))
🚀 结论 :
ord(字符)
→ 获取 Unicode 码
chr(整数)
→ 获取对应字符
浮点数
🔹 Python 函数可选参数规则
规则
示例
说明
默认参数在必选参数后
def func(a, b=10): pass
❌ 错误 def func(b=10, a):
默认值在定义时计算一次
def func(lst=[]): lst.append(1)
可变对象会被共享,建议用 None
替代
可选参数可用关键字调用
func(name="Alice", message="Hi")
调用时可指定参数名
可选参数可与 *args
结合
def func(a, *args, b=10): pass
b
必须使用关键字传参
可选参数可与 **kwargs
结合
def func(a, b=10, **kwargs): pass
kwargs
捕获额外的关键字参数
✅ 牢记:默认参数必须放在必选参数后,避免可变默认值 🚀
格式化输出 📌 Python 格式化输出对比 🎯
方式
语法
示例
特点
%
格式化(旧)
"格式符" % (值1, 值2, …)
"姓名: %s, 年龄: %d" % (name, age)
旧式写法,不推荐
str.format()
"{} {}".format(值1, 值2)
"姓名: {}, 年龄: {}".format(name, age)
灵活但较冗长
f-string(推荐)
f"字符串 {变量} 其他文本"
f"姓名: {name}, 年龄: {age}"
最简洁,推荐使用
📌 eval()
函数 ✅ 作用 :执行字符串中的Python 表达式 ,并返回结果。📍 示例 :
1 2 3 4 5 6 7 print (eval ("3 + 5 * 2" )) x = 10 print (eval ("x + 5" )) data = eval ("{'name': 'Alice', 'age': 25}" ) print (data["name" ])
1 2 3 4 5 6 7 print ("姓名: {0}, 年龄: {1}, 姓名: {0}" .format (name, age)) print ("姓名: {n}, 年龄: {a}" .format (n=name, a=age)) pi = 3.1415926535 print ("圆周率: {:.2f}" .format (pi))
format()
方法用于格式化字符串,支持 位置参数 、关键字参数 和 格式控制 。
1️⃣ 基本用法 1 2 3 4 name = "Alice" age = 25 print ("姓名: {}, 年龄: {}" .format (name, age))
2️⃣ 位置参数 1 2 print ("姓名: {0}, 年龄: {1}, 再次姓名: {0}" .format (name, age))
3️⃣ 关键字参数 1 2 print ("姓名: {n}, 年龄: {a}" .format (n=name, a=age))
4️⃣ 格式控制 是的,还有一些其他格式化方式,以下是扩展的 Python 格式化字符串 选项,包括 对齐、填充、数制转换、千位分隔符等 :
格式
作用
示例 (format(值, "格式")
)
输出
{:>10}
右对齐 (默认空格填充)
format("text", ">10")
' text'
{:^10}
居中对齐
format("text", "^10")
' text '
{:*^10}
*
填充 + 居中
format("text", "*^10")
'**text***'
{:.2f}
保留 2 位小数
format(3.14159, ".2f")
'3.14'
{:b}
二进制
format(10, "b")
'1010'
{:o}
八进制
format(10, "o")
'12'
{:x}
十六进制(小写)
format(10, "x")
'a'
{:X}
十六进制(大写)
format(10, "X")
'A'
{:.2%}
百分比(保留 2 位小数)
format(0.95, ".2%")
'95.00%'
{:,}
千位分隔符 (逗号)
format(1000000, ",")
'1,000,000'
{:_}
千位分隔符 (下划线)
format(1000000, "_")
'1_000_000'
{:+d}
显示正负号
format(10, "+d")
'+10'
{:<10}
左对齐
format("text", "<10")
'text '
{:#x}
带 0x
前缀的十六进制
format(10, "#x")
'0xa'
📍 示例代码 1 2 3 4 5 6 7 print ("{:>10}" .format ("text" )) print ("{:.2f}" .format (3.14159 )) print ("{:b}" .format (10 )) print ("{:x}" .format (255 )) print ("{:.2%}" .format (0.95 )) print ("{:,}" .format (1000000 )) print ("{:+d}" .format (10 ))
这些格式化方式可以 美化输出、格式化数值、转换进制 等,非常实用!
示例:
1 2 3 4 print ("{:*>10}" .format ("hi" )) print ("{:.2f}" .format (3.14159 )) print ("{:b}" .format (10 )) print ("{:.2%}" .format (0.95 ))
📌 print()
函数 🎯 print()
是 Python 的内置函数,用于将信息输出到控制台。它常用于调试、显示结果或与用户交互。
📍 语法:
1 print (*objects, sep=' ' , end='\n' , file=sys.stdout, flush=False )
📍 参数解释:
**objects
**:要输出的内容,可以是多个对象,使用逗号分隔。
**sep
**:用于分隔多个对象的字符,默认为空格 ' '
。
**end
**:输出的结尾字符,默认为换行符 \n
。可以设置为其他字符。
**file
**:输出目标,默认为 sys.stdout
,即屏幕。如果要输出到文件,可以传递文件对象。
**flush
**:是否立即刷新输出缓冲区,默认为 False
。设置为 True
时,输出会立即刷新。
📌 split()
函数 🎯 split() 是 Python 字符串的内置方法,用于将字符串拆分成多个子字符串,默认按空白字符(如空格、换行符)进行分割。
常见用法: 1 2 3 4 5 6 7 8 9 10 text = "apple,orange,banana" print ("Hello World" .split()) print (text.split(',' )) print (text.split(',' , 1 ))
📌 Python 字符串大小写格式化函数 🎯
函数
作用
示例
输出
upper()
转换为大写
"hello".upper()
"HELLO"
lower()
转换为小写
"HELLO".lower()
"hello"
capitalize()
首字母大写,其余小写
"hello world".capitalize()
"Hello world"
title()
每个单词首字母大写
"hello world".title()
"Hello World"
swapcase()
大小写互换
"Hello World".swapcase()
"hELLO wORLD"
示例代码 1 2 3 4 5 6 7 text = "hElLo WoRlD" print (text.upper()) print (text.lower()) print (text.capitalize()) print (text.title()) print (text.swapcase())
这些方法适用于文本格式化、数据处理等场景。
📌 replace()
函数 🎯 replace()
是 Python 字符串的内置方法,用于 替换字符串中的指定子串 。
📍 语法
1 str .replace(old, new, count)
📍 参数
参数
描述
默认值
old
需要被替换的子字符串
必填
new
替换后的新字符串
必填
count
(可选) 替换次数,默认全部替换
None
replace()
方法不会修改原字符串,而是返回一个新字符串。
📌 Unicode 编码 & 进制转换内置函数 🎯 Python 提供了一些 Unicode 编码 处理和 进制转换 的内置函数,常用于字符编码、数制转换等场景。
📍 Unicode 相关函数
函数
作用
示例
输出
ord(c)
获取字符的 Unicode 码点
ord('A')
65
chr(n)
将 Unicode 码点转换为字符
chr(65)
'A'
encode()
将字符串编码为字节串
"你好".encode("utf-8")
b'\xe4\xbd\xa0\xe5\xa5\xbd'
decode()
将字节串解码为字符串
b'\xe4\xbd\xa0\xe5\xa5\xbd'.decode("utf-8")
"你好"
📍 进制转换相关函数
函数
作用
示例
输出
bin(x)
整数 → 二进制
bin(10)
'0b1010'
oct(x)
整数 → 八进制
oct(10)
'0o12'
hex(x)
整数 → 十六进制
hex(10)
'0xa'
int(s, base)
任意进制 → 十进制整数
int('1010', 2)
10
📍 示例代码 1 2 3 4 5 6 7 8 9 print (ord ('你' )) print (chr (20320 )) print (bin (255 )) print (oct (255 )) print (hex (255 )) print (int ('ff' , 16 ))
这些函数适用于 字符处理、数制转换、编码解码等 场景。
strip()
strip()
用于去除字符串两端的指定字符(默认是空格、换行符)。
用法
1 2 3 4 5 s = " Hello, World! " print (s.strip()) s = "---Python---" print (s.strip("-" ))
相关函数
函数
作用
strip()
去除两端字符
lstrip()
去除左侧字符
rstrip()
去除右侧字符
示例:
1 2 3 s = " Python " print (s.lstrip()) print (s.rstrip())
📌 time
库简介 🎯 time
是 Python 的内置库,用于处理时间相关的操作,如获取当前时间、执行延迟、时间格式转换等。
📍 常用函数
函数
作用
示例
time()
返回当前时间的 时间戳 (秒级)
time.time()
→ 1711785600.123456
sleep(sec)
让程序暂停 sec
秒
time.sleep(2)
→ 暂停 2 秒
localtime(sec)
将时间戳转换为 本地时间对象
time.localtime(time.time())
gmtime(sec)
转换为 UTC 时间对象
time.gmtime(time.time())
strftime(format, t)
按格式转换时间对象为 字符串
time.strftime("%Y-%m-%d %H:%M:%S")
strptime(str, fmt)
将时间字符串转换为 时间对象
time.strptime("2025-03-29", "%Y-%m-%d")
mktime(t)
将 本地时间对象 转换为 时间戳
time.mktime(time.localtime())
📍 示例代码 1 2 3 4 5 6 7 8 9 10 11 import timeprint (time.time()) time.sleep(2 ) local_time = time.localtime() print (time.strftime("%Y-%m-%d %H:%M:%S" , local_time))
time
主要用于 时间管理、计时器、日期转换等 场景。
python的数据类型 📌 列表操作函数 🎯
函数
作用
append(x)
在末尾添加 元素 x
extend(iter)
合并 可迭代对象 iter
到列表
insert(i, x)
在索引 i
处插入 元素 x
remove(x)
删除 列表中第一个 值为 x
的元素
pop(i)
删除并返回 索引 i
处的元素(默认删除最后一个)
del list[i]
删除 索引 i
处的元素
del list[i:j]
删除 i
到 j-1
之间的元素
clear()
清空列表
index(x)
返回 x
第一次出现的索引
count(x)
返回 x
在列表中出现的次数
sort()
排序 (默认升序,可用 reverse=True
降序)
reverse()
反转列表 顺序
copy()
返回列表副本
📌 extend(iter)
📍 示例 :
1 2 3 4 5 6 7 8 9 list1 = [1 , 2 , 3 ] list1.extend([4 , 5 , 6 ]) print (list1) list1 = [1 , 2 , 3 ] list1.append([4 , 5 , 6 ]) print (list1)
⚠ 区别:append(x) 直接添加整个对象,extend(iter) 拆开元素 依次添加! 🚀
📌 Python 字典(dict
) 字典(dict
)是 键值对(key-value) 结构的数据类型,类似 JSON,可用于快速查找、存储数据。
📍 1. 创建字典 1 2 3 4 5 6 7 8 9 10 student = {"name" : "Alice" , "age" : 20 , "score" : 95 } info = dict (name="Bob" , age=22 , score=88 ) data = dict ([("name" , "Tom" ), ("age" , 18 )]) print (student)
📍 2. 访问字典 1 2 3 4 5 6 print (student["name" ]) print (student.get("age" )) print (student.get("gender" , "未知" ))
📍 3. 修改 & 添加元素 1 2 student["age" ] = 21 student["gender" ] = "Female"
📍 4. 删除元素 1 2 3 4 del student["score" ] print (student.pop("age" )) print (student.popitem()) student.clear()
📍 5. 遍历字典 1 2 3 4 5 for key in student: print (key, student[key]) for key, value in student.items(): print (key, ":" , value)
📍 6. 字典常用方法
方法
作用
dict.keys()
获取所有键
dict.values()
获取所有值
dict.items()
获取所有键值对
dict.get(k,v)
获取值,若键不存在返回 v
dict.pop(k)
删除 k
并返回对应的值
dict.update(d)
更新字典
dict.clear()
清空字典
字典适用于 快速查找数据、存储键值对信息 ,是 Python 最重要的数据结构之一 ! 🚀
sort函数 sort()
对列表原地排序,不返回新列表 。sorted()
返回新列表
📌 语法 1 list .sort(key=None , reverse=False )
key
:排序依据函数,如 len
按长度排。
reverse=True
降序,默认升序。
📌 常见排序依据函数
函数
作用
示例
len
按长度排序
words.sort(key=len)
str.lower
忽略大小写排序
words.sort(key=str.lower)
abs
按绝对值排序
nums.sort(key=abs)
lambda x: x[1]
按元组第二个元素排序
pairs.sort(key=lambda x: x[1])
字典按值排序,降序
ls.sort(key=lambda x:x[1], reverse=True) # 按照数量排序
📌 jieba 库简介 jieba
是 Python 中文分词库 ,支持 精准模式、全模式、搜索引擎模式 三种分词方式。
📌 分词模式
模式
函数
特点
精确模式
jieba.cut(s)
精准切分,适合文本分析
全模式
jieba.cut(s, cut_all=True)
词汇最大化,但有冗余
搜索模式
jieba.cut_for_search(s)
细粒度切分,适合搜索
📌 示例
1 2 3 4 5 6 7 8 9 10 11 import jiebatext = "我喜欢Python编程" print (list (jieba.cut(text))) print (list (jieba.cut(text, cut_all=True ))) print (list (jieba.cut_for_search(text)))
📌 jieba 库常用函数
函数
作用
示例
jieba.cut(s, cut_all=False)
精确模式分词(默认)
jieba.cut("我爱Python")
jieba.cut(s, cut_all=True)
全模式分词
jieba.cut("我爱Python", cut_all=True)
jieba.cut_for_search(s)
搜索引擎模式分词
jieba.cut_for_search("我爱Python")
jieba.lcut(s)
返回列表(精确模式)
jieba.lcut("我爱Python")
jieba.lcut_for_search(s)
返回列表(搜索模式)
jieba.lcut_for_search("我爱Python")
jieba.add_word(w)
添加自定义词
jieba.add_word("人工智能")
jieba.del_word(w)
删除词汇
jieba.del_word("数据")
jieba.analyse.extract_tags(s, topK=5)
关键词提取
jieba.analyse.extract_tags("文本")
jieba.analyse.textrank(s, topK=5)
TextRank关键词提取
jieba.analyse.textrank("文本")
jieba.load_userdict(f)
加载自定义词典
jieba.load_userdict("dict.txt")
1 2 3 4 5 6 7 8 9 import jiebaimport jieba.analysetext = "人工智能和大数据是未来的趋势" jieba.add_word("人工智能" ) print (jieba.lcut(text)) keywords = jieba.analyse.extract_tags(text, topK=2 ) print (keywords)
📌 Python 文件读写操作 Python 提供 open()
函数用于文件操作,支持 读取、写入、追加 等模式。
🔹 1. open()
打开文件 1 file = open ("data.txt" , "r" , encoding="utf-8" )
参数
作用
文件路径
可使用相对路径 或绝对路径
mode
访问模式(见下表)
encoding
指定编码,如 utf-8
(避免中文乱码)
🔹 2. 文件访问模式
模式
描述
"r"
只读(默认),文件不存在时报错
"w"
写入(清空原内容) ,文件不存在则创建
"a"
追加 ,文件不存在则创建
"x"
创建 ,文件存在时报错
"b"
二进制模式 (如 rb
、wb
)
"t"
文本模式 (默认,可省略)
"r+"
读写模式,不清空文件
"w+"
读写模式,清空原内容
🔹 3. 读取文件 1 2 with open ("data.txt" , "r" , encoding="utf-8" ) as file: content = file.read()
方法
作用
file.read(n)
读取n 个字符(省略 n
读取全部)
file.readline()
读取一行
file.readlines()
读取所有行,返回 列表
示例
1 2 3 with open ("data.txt" , "r" , encoding="utf-8" ) as file: for line in file: print (line.strip())
🔹 4. 写入文件 1 2 with open ("output.txt" , "w" , encoding="utf-8" ) as file: file.write("Hello, World!\n" )
方法
作用
file.write(str)
写入字符串
file.writelines(list)
写入列表 ,元素需为字符串
追加模式
1 2 with open ("output.txt" , "a" , encoding="utf-8" ) as file: file.write("追加内容\n" )
🔹 5. 关闭文件
推荐使用 with open()
,自动关闭文件 ✅
🔹 6. 处理二进制文件 1 2 with open ("image.jpg" , "rb" ) as f: data = f.read()
🚀 总结
读取 :read()
、readline()
、readlines()
、遍历 for line in file
写入 :write()
、writelines()
模式 :r
、w
、a
、x
、b
、t
推荐 :用 with open()
避免忘记关闭文件
🎯 掌握这些操作,轻松处理文本和二进制文件! 🚀