Posted on  Updated on 

python考试的基础知识

前言

计算机二级真是米奇妙妙屋,考了我几乎不会用到的知识点和一些操作,补充知识了

python的异常处理

使用 try-except 语句来捕获和处理运行时错误,并可以在 finally 代码块中执行清理操作。


捕获多个异常

1
2
3
4
5
try:
lst = [1, 2, 3]
print(lst[5]) # 触发 IndexError
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}")

🔹 解释

  • raise 用于手动抛出异常

总结

语法 作用
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]) # 输出appl
print(s[:-1:]) # 输出appl
print(s[:4]) # 输出appl
print(s[:5]) # 输出apple
print(s[:6]) # 输出apple
1
2
3
4
5
6
s = "banana"
print(s[::-1]) # 输出ananab,逆向
print(s[:-1:-1]) # 输出为空行
print(s[:-1:2]) # 输出为bnn
print(s[:5:2]) # 输出bnn
print(s[:6:-2]) # 输出为空行
  • s[start:end] 不包含 end 位置的字符。

  • s[::-1] 倒序字符串。

  • start、end 和 step 的方向要匹配,否则会返回空字符串。

random库

函数 作用
random.random() 生成 0 ~ 1 的随机小数
random.uniform(a, b) 生成范围 [a, b] 内的随机小数
random.randint(a, b) 生成范围 [a, b] 内的随机整数
random.randrange(a, b, step) 生成 ab 之间步长为 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 字符串方法,用于将多个字符串拼接成一个字符串,适用于列表、元组、集合等可迭代对象

🔹 语法

1
"分隔符".join(可迭代对象)

🔹 常见用法

用途 代码示例 输出
连接列表 " ".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) 设置画笔绝对方向 右,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 turtle

turtle.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))
# 输出不是3,而是下面的内容
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) # 输出['cnm', '123', [5, 6]]

img1.append(["5","6"])
print(img2) # 输出['cnm', '123', [5, 6], ['5', '6']]


赋值方式 是否影响原列表
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) # 2.0 (浮点除法,结果为浮点数)
print(a // b) # 2 (整除,结果为整数)

python的数据类型

1
2
3
4
5
6
数字类型
- 整数
- 浮点数
- 复数

字符串类型

📌 ord() vs. chr()

✅ **ord()**:返回字符的 Unicode 编码(整数)
✅ **chr()**:返回 Unicode 编码对应的字符

1
2
3
4
5
print(ord('A'))   # 65
print(chr(65)) # 'A'

print(ord('中')) # 20013
print(chr(20013)) # '中'

🚀 结论

  • ord(字符) → 获取 Unicode 码
  • chr(整数) → 获取对应字符

浮点数

1
print(0.3 == 0.1 + 0.2) # 打印为False

🔹 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"))  # 输出 13

x = 10
print(eval("x + 5")) # 输出 15

data = eval("{'name': 'Alice', 'age': 25}")
print(data["name"]) # 输出 Alice

format()

1
2
3
4
5
6
7
print("姓名: {0}, 年龄: {1}, 姓名: {0}".format(name, age))  # 输出: 姓名: Alice, 年龄: 25, 姓名: Alice

print("姓名: {n}, 年龄: {a}".format(n=name, a=age)) # 输出: 姓名: Alice, 年龄: 25

pi = 3.1415926535
print("圆周率: {:.2f}".format(pi)) # 输出: 圆周率: 3.14

📌 Python format() 字符串格式化 🎯

format() 方法用于格式化字符串,支持 位置参数关键字参数格式控制


1️⃣ 基本用法

1
2
3
4
name = "Alice"
age = 25
print("姓名: {}, 年龄: {}".format(name, age))
# 输出: 姓名: Alice, 年龄: 25

2️⃣ 位置参数

1
2
print("姓名: {0}, 年龄: {1}, 再次姓名: {0}".format(name, age))
# 输出: 姓名: Alice, 年龄: 25, 再次姓名: Alice

3️⃣ 关键字参数

1
2
print("姓名: {n}, 年龄: {a}".format(n=name, a=age))  
# 输出: 姓名: Alice, 年龄: 25

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"))  # '     text'
print("{:.2f}".format(3.14159)) # '3.14'
print("{:b}".format(10)) # '1010'
print("{:x}".format(255)) # 'ff'
print("{:.2%}".format(0.95)) # '95.00%'
print("{:,}".format(1000000)) # '1,000,000'
print("{:+d}".format(10)) # '+10'

这些格式化方式可以 美化输出、格式化数值、转换进制 等,非常实用!

示例:

1
2
3
4
print("{:*>10}".format("hi"))  # 输出: '********hi'
print("{:.2f}".format(3.14159)) # 输出: '3.14'
print("{:b}".format(10)) # 输出: '1010'
print("{:.2%}".format(0.95)) # 输出: '95.00%'

📌 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()) # ['Hello', 'World']

# 按逗号分割
print(text.split(',')) # ['apple', 'orange', 'banana']

# 限制分割次数
print(text.split(',', 1)) # ['apple', 'orange,banana']

📌 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()) # HELLO WORLD
print(text.lower()) # hello world
print(text.capitalize()) # Hello world
print(text.title()) # Hello World
print(text.swapcase()) # HeLLo wOrLd

这些方法适用于文本格式化、数据处理等场景。

📌 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
# Unicode 相关
print(ord('你')) # 20320
print(chr(20320)) # 你

# 进制转换
print(bin(255)) # 0b11111111
print(oct(255)) # 0o377
print(hex(255)) # 0xff
print(int('ff', 16)) # 255

这些函数适用于 字符处理、数制转换、编码解码等 场景。

strip()

strip() 用于去除字符串两端的指定字符(默认是空格、换行符)。

用法

1
2
3
4
5
s = "  Hello, World!  "
print(s.strip()) # 'Hello, World!'

s = "---Python---"
print(s.strip("-")) # 'Python'

相关函数

函数 作用
strip() 去除两端字符
lstrip() 去除左侧字符
rstrip() 去除右侧字符

示例:

1
2
3
s = "  Python  "
print(s.lstrip()) # "Python "
print(s.rstrip()) # " Python"

📌 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 time

# 获取当前时间戳
print(time.time()) # 1711785600.123456

# 暂停 2 秒
time.sleep(2)

# 获取本地时间
local_time = time.localtime()
print(time.strftime("%Y-%m-%d %H:%M:%S", local_time)) # 2025-03-29 12:34:56

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] 删除 ij-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) # 输出 [1, 2, 3, 4, 5, 6]


list1 = [1, 2, 3]
list1.append([4, 5, 6])
print(list1) # 输出 [1, 2, 3, [4, 5, 6]]

⚠ 区别:append(x) 直接添加整个对象,extend(iter) 拆开元素 依次添加! 🚀

📌 Python 字典(dict

字典(dict)是 键值对(key-value) 结构的数据类型,类似 JSON,可用于快速查找、存储数据。


📍 1. 创建字典

1
2
3
4
5
6
7
8
9
10
# 方式 1: 使用 {}
student = {"name": "Alice", "age": 20, "score": 95}

# 方式 2: 使用 dict()
info = dict(name="Bob", age=22, score=88)

# 方式 3: 通过列表或元组
data = dict([("name", "Tom"), ("age", 18)])

print(student) # {'name': 'Alice', 'age': 20, 'score': 95}

📍 2. 访问字典

1
2
3
4
5
6
# 直接访问(键不存在会报错)
print(student["name"]) # Alice

# 使用 get() 方法(键不存在返回 None 或默认值)
print(student.get("age")) # 20
print(student.get("gender", "未知")) # 未知

📍 3. 修改 & 添加元素

1
2
student["age"] = 21  # 修改
student["gender"] = "Female" # 添加

📍 4. 删除元素

1
2
3
4
del student["score"]  # 删除 key
print(student.pop("age")) # 21 (返回被删除的值)
print(student.popitem()) # 随机删除一个键值对
student.clear() # 清空字典

📍 5. 遍历字典

1
2
3
4
5
for key in student:
print(key, student[key]) # 遍历 key 和 value

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 库简介

jiebaPython 中文分词库,支持 精准模式、全模式、搜索引擎模式 三种分词方式。

📌 分词模式

模式 函数 特点
精确模式 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 jieba

text = "我喜欢Python编程"
print(list(jieba.cut(text)))
# ['我', '喜欢', 'Python', '编程']

print(list(jieba.cut(text, cut_all=True)))
# ['我', '喜欢', 'Python', '编程']

print(list(jieba.cut_for_search(text)))
# ['我', '喜欢', 'Python', '编程']

📌 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 jieba
import jieba.analyse

text = "人工智能和大数据是未来的趋势"
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" 二进制模式(如 rbwb
"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. 关闭文件

1
file.close()

推荐使用 with open(),自动关闭文件


🔹 6. 处理二进制文件

1
2
with open("image.jpg", "rb") as f:
data = f.read() # 读取二进制数据

🚀 总结

  • 读取read()readline()readlines()、遍历 for line in file
  • 写入write()writelines()
  • 模式rwaxbt
  • 推荐:用 with open() 避免忘记关闭文件

🎯 掌握这些操作,轻松处理文本和二进制文件! 🚀