Python 基础知识点详细整理
1. Python 简介与环境搭建
-
简介：解释 Python 的特点，解释其跨平台性、解释性和面向对象特性。
-
安装与配置：如何安装 Python，搭建 Python 环境，使用
pip安装库。 -
集成开发环境 (IDE)：如 PyCharm、VSCode、Jupyter 等的使用。
2. 基本数据类型
-
整数（int）、浮点数（float）、布尔值（bool）、字符串（str） 等数据类型。
-
数据类型的转换：
int(),float(),str()。 -
运算符：算术运算符（
+,-,*,/,//,%,**），比较运算符（==,!=,>,<等），逻辑运算符（and,or,not）。
3. 字符串处理
字符串（str）是 Python 中非常重要且常用的数据类型之一。它用于表示一段文本，是一种不可变类型的数据结构，这意味着一旦创建，字符串内容不可改变。Python 提供了丰富的操作和方法来处理字符串。
字符串创建
在 Python 中，字符串可以通过单引号、双引号或三引号（多行字符串）来创建。
-
单引号（
'）：my_string = 'Hello, World!'
-
双引号（
"）：my_string = "Hello, World!"
单引号和双引号的区别不大，可以自由选择，但如果字符串本身包含引号，可以用不同的符号避免冲突。
-
多行字符串（三引号）： 多行字符串可以通过三引号（
'''或"""）创建，支持在字符串中包含换行符。multi_line_string = '''This is a multi-line string in Python.'''
或者
multi_line_string = """This is another multi-line string in Python."""
字符串操作
-
len()获取字符串长度：len()函数可以返回字符串的字符数，包括空格和标点符号。my_string = "Hello, World!" print(len(my_string)) # 输出：13
-
字符串拼接（
+）： 可以使用+运算符将多个字符串拼接在一起。str1 = "Hello" str2 = "World" result = str1 + ", " + str2 + "!" print(result) # 输出：Hello, World!
-
字符串重复（
\*）： 可以使用*运算符将字符串重复指定的次数。my_string = "Hello! " * 3 print(my_string) # 输出：Hello! Hello! Hello!
-
查找子串（
find()）：find()方法用于查找子字符串在父字符串中的位置，返回子串的起始索引。如果没有找到，返回 -1。my_string = "Hello, World!" index = my_string.find("World") print(index) # 输出：7 -
替换子串（
replace()）：replace()方法用于将字符串中的某个子串替换为另一个子串。my_string = "Hello, World!" new_string = my_string.replace("World", "Python") print(new_string) # 输出：Hello, Python!
字符串切片
字符串切片可以通过 str[start:end:step] 的格式来操作，它允许提取字符串中的子串。
-
start：起始索引（包含该索引位置的字符）。
-
end：结束索引（不包含该索引位置的字符）。
-
step：步长，表示每隔多少个字符取一个。
-
基本切片操作：
my_string = "Hello, World!" print(my_string[0:5]) # 输出：Hello
-
省略 start 或 end： 如果省略
start，默认从字符串的开头开始；如果省略end，默认到字符串的末尾。print(my_string[:5]) # 输出：Hello print(my_string[7:]) # 输出：World!
-
步长（step）：
step参数控制切片的步进值。例如，可以通过设置step = 2来跳过字符。print(my_string[::2]) # 输出：Hlo ol!
-
负索引和反向切片： 负索引用于从字符串的末尾开始计数，
-1代表最后一个字符。print(my_string[-1]) # 输出：! print(my_string[::-1]) # 输出：!dlroW ,olleH (字符串反转)
常用字符串方法
-
strip()去除空白字符：strip()方法可以去除字符串两端的空格、换行符等空白字符。可以使用lstrip()去除左边的空白，rstrip()去除右边的空白。my_string = " Hello, World! " print(my_string.strip()) # 输出：Hello, World!
-
split()字符串分割：split()方法可以将字符串按指定的分隔符分割为列表。默认按空格分割，也可以指定其他分隔符。my_string = "apple,banana,cherry" fruits = my_string.split(",") print(fruits) # 输出：['apple', 'banana', 'cherry'] -
join()列表拼接为字符串：join()方法可以将列表中的元素拼接为字符串，指定一个连接符。fruits = ['apple', 'banana', 'cherry'] my_string = ", ".join(fruits) print(my_string) # 输出：apple, banana, cherry
-
upper()和lower()大小写转换：-
upper()：将字符串中的字母转换为大写。 -
lower()：将字符串中的字母转换为小写。
my_string = "Hello, World!" print(my_string.upper()) # 输出：HELLO, WORLD! print(my_string.lower()) # 输出：hello, world!
-
-
startswith()和endswith()：-
startswith()用于判断字符串是否以指定的前缀开始。 -
endswith()用于判断字符串是否以指定的后缀结束。
my_string = "Hello, World!" print(my_string.startswith("Hello")) # 输出：True print(my_string.endswith("World!")) # 输出：True -
4. 列表（List）与元组（Tuple）
列表和元组是 Python 中非常重要的两种内置数据类型。列表是可变的，元组是不可变的。它们都可以存储任意类型的数据，常用于存放有序的数据集合。以下是详细说明：
列表（List）
列表是一种可变的数据类型，使用方括号 [] 表示。它允许我们存储、修改、删除和查找数据，常用的操作非常灵活。
1. 列表的创建
列表可以存储任意类型的数据，包括整数、字符串、浮点数，甚至可以嵌套列表或其他数据结构。
# 创建一个包含不同类型元素的列表 my_list = [1, "hello", 3.14, True]
2. 列表的增、删、改、查
-
增加元素（
append()）：append()方法用于在列表末尾添加元素。my_list = [1, 2, 3] my_list.append(4) # 在末尾添加4 print(my_list) # 输出：[1, 2, 3, 4]
-
插入元素（
insert()）：insert()方法用于在指定索引处插入元素。my_list = [1, 2, 3] my_list.insert(1, "new") # 在索引1处插入"new" print(my_list) # 输出：[1, 'new', 2, 3]
-
删除元素（
remove()）：remove()方法用于删除列表中首次出现的指定元素。如果元素不存在，会抛出ValueError。my_list = [1, 2, 3, 2] my_list.remove(2) # 删除第一个2 print(my_list) # 输出：[1, 3, 2]
-
修改元素： 可以直接通过索引修改列表中的元素。
my_list = [1, 2, 3] my_list[1] = "changed" # 修改索引1处的元素 print(my_list) # 输出：[1, 'changed', 3]
-
访问元素： 使用索引访问列表中的元素。索引从
0开始，负数索引从列表末尾开始。my_list = [1, 2, 3] print(my_list[0]) # 输出：1 print(my_list[-1]) # 输出：3 (最后一个元素)
-
删除元素（
pop()和del）：-
pop()：删除并返回指定索引处的元素，默认删除最后一个元素。my_list = [1, 2, 3] last_element = my_list.pop() # 删除并返回最后一个元素 print(last_element) # 输出：3 print(my_list) # 输出：[1, 2]
-
del：使用del关键字可以删除列表中指定位置的元素，也可以删除整个列表。my_list = [1, 2, 3] del my_list[0] # 删除第一个元素 print(my_list) # 输出：[2, 3]
-
3. 列表的其他常用方法
-
extend()：将另一个列表中的元素追加到当前列表末尾。my_list = [1, 2, 3] my_list.extend([4, 5]) # 追加多个元素 print(my_list) # 输出：[1, 2, 3, 4, 5]
-
index()：返回指定元素的索引位置。my_list = [1, 2, 3, 4] print(my_list.index(3)) # 输出：2
-
count()：统计列表中某个元素出现的次数。my_list = [1, 2, 2, 3, 2] print(my_list.count(2)) # 输出：3
-
sort()：对列表进行排序（升序）。my_list = [3, 1, 2] my_list.sort() print(my_list) # 输出：[1, 2, 3]
-
reverse()：将列表的元素顺序反转。my_list = [1, 2, 3] my_list.reverse() print(my_list) # 输出：[3, 2, 1]
列表切片
与字符串一样，列表也支持切片操作，格式为 list[start:end:step]，其中：
-
start是开始的索引（包含）， -
end是结束的索引（不包含）， -
step是步长。 -
基本切片：
my_list = [0, 1, 2, 3, 4, 5] print(my_list[1:4]) # 输出：[1, 2, 3]
-
省略
start和end：print(my_list[:3]) # 输出：[0, 1, 2] (从头开始) print(my_list[3:]) # 输出：[3, 4, 5] (到结尾结束)
-
步长切片：
print(my_list[::2]) # 输出：[0, 2, 4] (每隔一个取值)
-
负索引和反向切片：
print(my_list[::-1]) # 输出：[5, 4, 3, 2, 1, 0] (反转列表)
元组（Tuple）
元组是一种不可变的数据类型，使用小括号 () 表示。元组的不可变性使得它更适合存储那些不希望被修改的数据。
1. 元组的创建
元组可以存储任意类型的元素，创建方式与列表类似，只是使用小括号。
# 创建一个元组 my_tuple = (1, "hello", 3.14)
-
注意
：单个元素的元组必须在元素后添加一个逗号，否则 Python 会将其视为普通的数据类型，而非元组。
single_element_tuple = (1,) # 正确的单元素元组 not_a_tuple = (1) # 这是整数，而不是元组
2. 访问元组元素
元组的访问方式与列表一样，可以使用索引和切片。
my_tuple = (1, 2, 3, 4) print(my_tuple[1]) # 输出：2 print(my_tuple[-1]) # 输出：4
3. 元组的不可变性
元组一旦创建，其元素不能修改。以下操作会导致错误：
my_tuple = (1, 2, 3) # my_tuple[0] = 10 # 报错，元组不允许修改元素
4. 元组的解包
元组支持解包操作，可以将元组中的值分别赋给多个变量。
my_tuple = (1, 2, 3) a, b, c = my_tuple # 将元组解包到变量 print(a, b, c) # 输出：1 2 3
5. 常用操作
虽然元组不可变，但它支持许多和列表类似的操作，例如：
-
count()：返回某个元素在元组中出现的次数。my_tuple = (1, 2, 2, 3) print(my_tuple.count(2)) # 输出：2
-
index()：返回元素在元组中的索引位置。my_tuple = (1, 2, 3) print(my_tuple.index(2)) # 输出：1
列表 vs 元组
| 特性 | 列表（List） | 元组（Tuple） |
|---|---|---|
| 可变性 | 可变 | 不可变 |
| 表示方式 | 方括号 [] | 小括号 () |
| 使用场景 | 需要频繁修改的数据 | 不可更改的数据集 |
| 常用方法 | append(), remove(), insert() | count(), index() |
| 内存使用 | 相对较大 | 相对较小 |
总结
-
列表：灵活且可变，适合存储和操作需要频繁增删改的数据。
-
元组：不可变，适合存储不需要修改的数据，因其不可变性，操作效率高且节省内存。
5. 字典（Dictionary）与集合（Set）
字典（Dictionary） 和 集合（Set） 是两种非常常用的数据结构。字典用于存储键值对，集合则是一种无序且元素唯一的集合。它们在日常开发中有广泛的应用，特别是在数据查找、去重等场景中。
字典（Dictionary）
字典是一种无序的可变容器，存储的是键值对。每个键值对中的键（key）必须是唯一的，值（value）可以是任意数据类型。字典使用大括号 {} 表示。
1. 字典的创建
字典以 {key: value} 的形式表示。键可以是字符串、整数、元组等不可变类型，而值可以是任意类型。
# 创建一个字典
my_dict = {
"name": "Alice",
"age": 25,
"city": "New York"
}
2. 字典的基本操作
-
添加键值对： 可以通过
dict[key] = value方式为字典添加新的键值对。如果键已存在，则会更新对应的值。my_dict["email"] = "alice@example.com" # 添加新的键值对 my_dict["age"] = 26 # 更新已有的键值对 print(my_dict) # 输出：{'name': 'Alice', 'age': 26, 'city': 'New York', 'email': 'alice@example.com'} -
删除键值对： 使用
del关键字删除指定键的键值对，或者使用pop()方法删除并返回对应的值。del my_dict["city"] # 删除键为 "city" 的键值对 print(my_dict) # 输出：{'name': 'Alice', 'age': 26, 'email': 'alice@example.com'} email = my_dict.pop("email") # 删除 "email" 键并返回值 print(email) # 输出：alice@example.com -
修改键值对： 修改字典中的值非常简单，直接通过键访问并赋值。
my_dict["age"] = 30 # 修改键 "age" 对应的值
-
查找键值对： 可以通过
dict[key]访问键对应的值。如果键不存在会抛出KeyError。为了避免此错误，可以使用get()方法。print(my_dict["name"]) # 输出：Alice print(my_dict.get("city", "Not Found")) # 输出：Not Found (指定默认值)
3. 字典的常用方法
-
get()：返回指定键对应的值，如果键不存在，则返回默认值。print(my_dict.get("email", "No email found")) # 输出：No email found -
keys()：返回字典中所有键的视图。print(my_dict.keys()) # 输出：dict_keys(['name', 'age', 'email'])
-
values()：返回字典中所有值的视图。print(my_dict.values()) # 输出：dict_values(['Alice', 30, 'alice@example.com'])
-
items()：返回字典中所有键值对的视图，形式为(key, value)的元组。print(my_dict.items()) # 输出：dict_items([('name', 'Alice'), ('age', 30), ('email', 'alice@example.com')]) -
update()：更新字典中的键值对，可以传入另一个字典或键值对序列。new_data = {"age": 35, "city": "Los Angeles"} my_dict.update(new_data) print(my_dict) # 输出：{'name': 'Alice', 'age': 35, 'email': 'alice@example.com', 'city': 'Los Angeles'}
4. 字典的其他操作
-
检查键是否存在： 使用
in关键字可以检查字典中是否存在某个键。print("name" in my_dict) # 输出：True -
遍历字典： 可以通过
for循环遍历字典的键、值或键值对。for key in my_dict: print(key, my_dict[key]) for key, value in my_dict.items(): print(key, value)
集合（Set）
集合是一个无序且不重复的元素集合，使用大括号 {} 或 set() 函数创建。集合最主要的特点是元素的唯一性，通常用于去重或集合运算。
1. 集合的创建
-
使用大括号
{}创建集合，或者使用
set()
函数。
# 使用大括号创建集合 my_set = {1, 2, 3, 3, 2} # 重复的元素会被自动去除 print(my_set) # 输出：{1, 2, 3} # 使用 set() 函数创建空集合（不能使用 {} 创建空集合，{} 是字典） empty_set = set()
2. 集合的基本操作
-
添加元素： 使用
add()方法可以向集合中添加新的元素。my_set = {1, 2, 3} my_set.add(4) print(my_set) # 输出：{1, 2, 3, 4} -
删除元素：
-
使用
remove()方法删除指定元素，如果元素不存在会抛出KeyError。 -
使用
discard()方法删除元素，如果元素不存在也不会抛出错误。
my_set.remove(4) # 正常删除 # my_set.remove(5) # 抛出 KeyError 错误 my_set.discard(5) # 删除不存在的元素不会抛出错误
-
-
清空集合： 使用
clear()方法可以清空集合中的所有元素。my_set.clear() print(my_set) # 输出：set() (空集合)
-
查找元素： 使用
in关键字可以检查某个元素是否在集合中。print(1 in my_set) # 输出：True
3. 集合的常用方法
-
union()（并集|）： 返回两个集合的并集（即两个集合的所有元素，去重）。set1 = {1, 2, 3} set2 = {3, 4, 5} result = set1.union(set2) print(result) # 输出：{1, 2, 3, 4, 5} # 使用 | 运算符 result = set1 | set2 print(result) # 输出：{1, 2, 3, 4, 5} -
intersection()（交集&）： 返回两个集合的交集（即两个集合中共同存在的元素）。set1 = {1, 2, 3} set2 = {2, 3, 4} result = set1.intersection(set2) print(result) # 输出：{2, 3} # 使用 & 运算符 result = set1 & set2 print(result) # 输出：{2, 3} -
difference()（差集-）： 返回存在于第一个集合但不存在于第二个集合的元素。set1 = {1, 2, 3} set2 = {2, 3, 4} result = set1.difference(set2) print(result) # 输出：{1} # 使用 - 运算符 result = set1 - set2 print(result) # 输出：{1} -
symmetric_difference()（对称差集^）： 返回两个集合中不重复的元素（即存在于其中一个集合，但不同时存在于两个集合中的元素）。set1 = {1, 2, 3} set2 = {2, 3, 4} result = set1.symmetric_difference(set2) print(result) # 输出：{1, 4} # 使用 ^ 运算符 result = set1 ^ set2 print(result) # 输出：{1, 4}
4. 集合的其他操作
-
去重： 集合的一个常用功能是去重，可以通过将列表或其他可迭代对象转为集合实现。
my_list = [1, 2, 2, 3, 3, 4] my_set = set(my_list) print(my_set) # 输出：{1, 2, 3, 4} -
遍历集合： 可以通过
for循环遍历集合中的所有元素。for element in my_set: print(element)
字典 vs 集合
| 特性 | 字典（Dictionary） | 集合（Set） |
|---|---|---|
| 结构 | 键值对 {key: value} | 无序元素集合 |
| 是否可变 | 可变 | 可变 |
| 是否允许重复 | 键不允许重复，值可以重复 | 不允许重复元素 |
| 常用场景 | 映射关系，键值对存储 | 去重、集合运算 |
| 表示方式 | {} 或 dict() | {} 或 set() |
总结
-
字典 是键值对的集合，适用于存储具有映射关系的数据，例如用户信息、配置项等。字典的查找速度快，并且支持增删改查等多种操作。
-
集合 是无序且唯一的元素集合，适用于去重、集合运算（如交集、并集、差集）等场景。它的特点是元素不重复且无序排列。
6. 条件判断与循环
条件判断和循环控制是编程的核心结构，帮助程序根据不同的条件做出不同的决策，并通过循环重复执行某些代码。Python 提供了非常简洁且强大的条件判断和循环语法。以下是详细的讲解。
条件判断
条件判断用于根据布尔表达式的结果执行不同的代码块，主要通过 if、elif、else 语句实现。
1. if 语句
if 语句用于判断某个条件是否为真。如果条件为真，则执行代码块；否则跳过。
age = 18
if age >= 18:
print("You are an adult.")
# 输出：You are an adult.
2. if-else 语句
if-else 语句在 if 条件为假时，会执行 else 语句下的代码块。
age = 16
if age >= 18:
print("You are an adult.")
else:
print("You are not an adult.")
# 输出：You are not an adult.
3. if-elif-else 语句
如果有多个条件，可以使用 elif 来继续判断其他条件，elif 表示“否则如果”。最后的 else 是所有条件都不成立时执行的代码块。
score = 85
if score >= 90:
print("A")
elif score >= 80:
print("B")
elif score >= 70:
print("C")
else:
print("D")
# 输出：B
4. 嵌套条件
if 语句可以嵌套在另一个 if 语句中，以处理更复杂的条件判断。
age = 20
if age >= 18:
if age < 65:
print("You are an adult.")
else:
print("You are a senior.")
else:
print("You are not an adult.")
# 输出：You are an adult.
5. 三元运算符
Python 允许使用简洁的三元运算符（也称为条件表达式）来代替 if-else 语句。当条件成立时执行某个表达式，不成立时执行另一个表达式。
age = 18 status = "adult" if age >= 18 else "minor" print(status) # 输出：adult
循环
循环结构允许我们多次执行相同的代码块，直到满足某个条件或遍历完某个序列。
1. for 循环
for 循环用于遍历一个序列（如列表、元组、字符串）或其他可迭代对象。每次迭代时，它会将序列中的下一个元素赋值给一个变量，并执行循环体。
# 遍历列表 fruits = ["apple", "banana", "cherry"] for fruit in fruits: print(fruit) # 输出： # apple # banana # cherry
-
使用
range()函数生成循环序列：range()函数生成一个整数序列，常用于循环控制。for i in range(3): print(i) # 输出：0, 1, 2
-
遍历字符串：
for char in "Python": print(char) # 输出： # P # y # t # h # o # n
2. while 循环
while 循环会反复执行某段代码，直到条件表达式为假时停止执行。适用于在不确定具体循环次数时使用。
count = 0 while count < 3: print(count) count += 1 # 输出：0, 1, 2
3. 循环中的 else 子句
for 和 while 循环都可以带有 else 子句，当循环正常结束（即没有通过 break 提前退出）时，else 块会被执行。
for i in range(5):
if i == 3:
break
print(i)
else:
print("Loop finished.") # 如果 `break` 发生，这段代码不会执行
# 输出：0, 1, 2
4. 循环控制
-
break语句：break语句用于立即退出循环，不再执行循环体中的其他代码，并直接跳到循环外的代码。for i in range(5): if i == 3: break print(i) # 输出：0, 1, 2 (遇到 `i == 3` 时提前退出循环)
-
continue语句：continue语句用于跳过当前循环的剩余部分，直接开始下一次迭代。for i in range(5): if i == 2: continue print(i) # 输出：0, 1, 3, 4 (当 i == 2 时，跳过该次循环)
常见的循环应用
1. 累加计算
通过循环，可以对多个数值进行累加或其他操作。
total = 0 for i in range(1, 6): total += i print(total) # 输出：15 (1 + 2 + 3 + 4 + 5)
2. 遍历字典
for 循环可以用于遍历字典的键、值或键值对。
my_dict = {"name": "Alice", "age": 25, "city": "New York"}
# 遍历键
for key in my_dict:
print(key)
# 遍历值
for value in my_dict.values():
print(value)
# 遍历键值对
for key, value in my_dict.items():
print(f"{key}: {value}")
# 输出：
# name: Alice
# age: 25
# city: New York
3. while 循环常用于不确定循环次数的场景
例如，用户输入时，直到输入特定字符为止。
while True:
user_input = input("Enter something (type 'exit' to quit): ")
if user_input == "exit":
break
print(f"You entered: {user_input}")
# 该循环将不断询问用户输入，直到用户输入 "exit" 为止。
总结
-
条件判断 通过
if、elif、else实现条件分支选择，允许程序根据不同条件执行不同的代码块。三元运算符使得条件判断更加简洁。 -
循环 提供了一种机制，帮助我们反复执行代码块。
for循环用于遍历可迭代对象，while循环用于当条件成立时反复执行代码。 -
循环控制 通过
break、continue可以控制循环的执行流程，else子句可以为循环提供额外的处理逻辑。
7. 函数
函数是将一段逻辑封装起来，方便重复使用和提高代码的可读性。Python 中使用 def 关键字来定义函数。
1. 函数定义
函数通过 def 关键字定义，后跟函数名和参数列表，代码块缩进表明属于函数体。函数可以通过 return 返回结果。
def greet(name):
return f"Hello, {name}!"
调用函数：
print(greet("Alice")) # 输出：Hello, Alice!
2. 参数传递
Python 支持多种方式向函数传递参数，包括位置参数、关键字参数、默认参数和可变参数。
位置参数
位置参数是最常见的参数传递方式，按顺序传递给函数。
def add(a, b): return a + b print(add(3, 5)) # 输出：8
关键字参数
关键字参数通过参数名进行传递，可以不按顺序传递。
print(add(b=5, a=3)) # 输出：8
默认参数
可以为函数参数设置默认值，当调用时未提供对应参数时使用默认值。
def greet(name="Guest"):
return f"Hello, {name}!"
print(greet()) # 输出：Hello, Guest!
print(greet("Alice")) # 输出：Hello, Alice!
可变参数（\*args 和 \**kwargs）
-
\*args：用于接收任意数量的位置参数，参数会被收集为一个元组。def multiply(*args): result = 1 for num in args: result *= num return result print(multiply(1, 2, 3, 4)) # 输出：24
-
\**kwargs：用于接收任意数量的关键字参数，参数会被收集为一个字典。def print_info(**kwargs): for key, value in kwargs.items(): print(f"{key}: {value}") print_info(name="Alice", age=25, city="New York") # 输出： # name: Alice # age: 25 # city: New York
3. 作用域
作用域指的是变量在程序中的可见范围。
-
局部变量：在函数内部定义的变量，作用范围仅限于函数内部。
def my_function(): local_var = "I am local" print(local_var) my_function() # 输出：I am local # print(local_var) # 报错：变量 local_var 作用域仅限于函数内部
-
全局变量：在函数外部定义的变量，作用于整个程序。可以在函数内使用全局变量。
global_var = "I am global" def my_function(): print(global_var) my_function() # 输出：I am global
-
global关键字：在函数内部修改全局变量时，必须使用global关键字。count = 0 def increment(): global count count += 1 increment() print(count) # 输出：1
4. 递归函数
递归函数是指函数调用自身，用于解决一些可以拆解成子问题的问题。例如，计算阶乘：
def factorial(n): if n == 1: return 1 else: return n * factorial(n - 1) print(factorial(5)) # 输出：120
递归的终止条件非常重要，避免无限递归导致程序崩溃。
8. 文件处理
Python 提供了强大的文件操作功能，允许我们对文件进行打开、读写和关闭等操作。
1. 文件打开与关闭
使用 open() 函数可以打开文件，open() 的第一个参数是文件名，第二个参数是文件模式。常见的文件模式包括：
-
'r'：读取模式（默认）。 -
'w'：写入模式（会覆盖文件，如果文件不存在会创建新文件）。 -
'a'：追加模式（在文件末尾追加内容）。 -
'b'：以二进制模式打开文件。
打开文件后需要使用 close() 方法关闭文件，释放资源。
# 打开文件进行读取
file = open("example.txt", 'r')
content = file.read()
print(content)
file.close()
2. 文件读写
-
read()：读取整个文件内容。file = open("example.txt", 'r') content = file.read() print(content) file.close() -
readlines()：一次性读取所有行并返回一个列表。file = open("example.txt", 'r') lines = file.readlines() for line in lines: print(line.strip()) # strip() 去除换行符 file.close() -
write()：写入内容到文件。file = open("example.txt", 'w') file.write("Hello, World!") file.close()
3. 上下文管理
Python 提供了 with 语句来管理文件的打开和关闭。使用 with 语句时，无论是否发生异常，文件都会自动关闭，避免忘记关闭文件或其他异常情况导致文件未关闭。
with open("example.txt", 'r') as file:
content = file.read()
print(content)
# 不需要调用 file.close()，文件会自动关闭
-
读取文件示例：
with open("example.txt", 'r') as file: for line in file: print(line.strip()) # 逐行读取并打印 -
写入文件示例：
with open("example.txt", 'w') as file: file.write("This is a new line.\n")
原文地址：https://blog.csdn.net/GDHBFTGGG/article/details/142727142
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！