目录
背景:Python 是一种广泛使用的高级编程语言,以其简洁、易读和强大的功能而著称。它支持多种编程范式,包括面向对象、命令式和函数式编程。下面我将详细介绍 Python 的一些基本语法元素
1、注释
Python 中使用井号(#
)来标记注释。注释可以单独占一行,也可以跟在代码后面。注释用户对代码的功能和作用进行解释,但不会被 Python 解释器执行。为了代码的可读性,建议在#后面空一个空格再写注释。
多行注释用ctrl+/,取消多行注释也是ctrl+/
#单独占一行
print('hello world')#跟在代码后面
#多行注释用ctrl+/
# print('hello world')
# print('hello world')
# print('hello world')
2、打印函数print()
Python 中的 print()
函数是一个内置函数,用于向标准输出设备(通常是控制台)输出信息。这个函数非常灵活,可以接受多个参数,并且可以通过一些关键字参数来控制输出的格式。
2.1基本用法
最简单的 print()
调用是输出一个字符串或变量的值。
print("Hello, World!")
x = 10
print(x)
2.2输出多个参数
print()
可以一次输出多个项,它们之间默认用空格分隔。
print("Hello", "World", "Python")
# 输出: Hello World Python
2.3sep设置分隔符
可以通过 sep
关键字参数来自定义项之间的分隔符。
print("Hello", "World", "Python", sep="-")
# 输出: Hello-World-Python
2.4end设置结束符
默认情况下,print()
函数在输出内容后会添加一个换行符(\n
)。你可以通过 end
关键字参数来修改这个行为。
print("Hello, ", end="")
print("World!")
# 输出: Hello, World!
2.5文件输出
print()
还可以将输出重定向到文件。这通过 file
关键字参数实现。
with open("output.txt", "w") as f:
print("Hello, World!", file=f)
# 此时,"Hello, World!" 被写入到 output.txt 文件中
2.6格式化输出
print()
支持字符串格式化,可以使用老式的 %
格式化或者新的 .format()
方法。格式为print("格式化字符串"%(变量1,变量.....))
%s代表字符串,%d有符号十进制整数,%f浮点数
name = "Alice"
print("Hello, %s!" % name)
# 输出: Hello, Alice!
name = "Bob"
print("Hello, {}!".format(name))
# 输出: Hello, Bob!
3、输入函数input()
input()
函数是一个非常基础且强大的函数,它允许程序暂停执行并等待用户从标准输入(通常是键盘)输入一些数据。一旦用户按下回车键,输入的数据就会被读取,并可以作为一个字符串(str)返回给程序。
# 使用input函数接收用户输入
name = input("请输入你的名字: ")
# 打印用户输入的内容
print("你的名字为:", name)
无论用户输入的是什么(数字、单词、句子等),input()
函数总是将输入作为字符串返回。如果你需要其他类型的数据(如整数或浮点数),你需要使用相应的类型转换函数(如int()
、float()
)将字符串转换为所需的类型。
age_str = input("请输入你的年龄: ")
age = int(age_str) # 将字符串转换为整数
print("你的年龄是:", age)
4、变量
Python中的变量是一种用于存储数据的容器,它允许我们在程序中引用和修改这些数据。Python是一种动态类型语言,Python 中的变量不需要事先声明类型。这意味着变量的类型不是在声明时固定的,而是在赋值时由存储在该变量中的数据决定。变量名可以是字母、数字或下划线的任意组合,但不能以数字开头。Python 是大小写敏感的。
4.1变量赋值
在Python中,变量是通过赋值语句来创建的。赋值语句的语法非常简单:变量名后跟等号(=),等号后面是变量要存储的值或表达式的结果。
x = 5 # 创建一个名为x的变量,并赋值为5
y = "Hello, World!" # 创建一个名为y的变量,并赋值为字符串"Hello, World!"
4.2变量类型
由于Python是动态类型语言,因此变量类型不是固定的。但是,你可以通过内置函数type()
来检查变量的类型
x = 5
print(type(x)) # 输出:<class 'int'>
y = "Hello"
print(type(y)) # 输出:<class 'str'>
4.3基本数据类型
-
整数(int):用于表示整数值,如
1
、-10
、100
等。Python的整数类型没有大小限制,可以表示任意大小的整数。 -
浮点数(float):用于表示带有小数点的数字,如
3.14
、-0.001
等。浮点数运算可能会存在四舍五入的误差。 -
布尔值(bool):只有两个值,
True
和False
,用于表示逻辑值。 -
字符串(str):用于存储文本数据,由单引号(')、双引号(")或三引号('''或""")包围的任意文本。字符串是不可变的,但可以通过拼接等方式生成新的字符串。
-
列表(list):用于存储一系列有序的元素,这些元素可以是不同类型的数据。列表是可变的,可以添加、删除或修改列表中的元素。
-
元组(tuple):与列表类似,但元组是不可变的。一旦创建了元组,就不能修改它的元素。元组使用圆括号(())表示。
-
集合(set):一个无序的、不包含重复元素的集合。主要用于数学上的集合操作,如并集、交集、差集和对称差集等。
-
字典(dict):用于存储键值对,每个键都映射到一个值。字典中的键必须是唯一的,而值则不必。字典是无序的,但可以保持插入顺序(Python 3.7+)。字典是可变的,可以添加、删除或修改键值对。
-
字节(bytes)和字节数组(bytearray):用于处理二进制数据,bytes是不可变的,而bytearray是可变的
# 整数 x = 10 print(type(x)) # 输出:<class 'int'> # 浮点数 y = 3.14 print(type(y)) # 输出:<class 'float'> # 布尔值 is_valid = True print(type(is_valid)) # 输出:<class 'bool'> # 字符串 name = "Alice" print(type(name)) # 输出:<class 'str'> # 列表 numbers = [1, 2, 3, 4, 5] print(type(numbers)) # 输出:<class 'list'> # 元组 point = (10, 20) print(type(point)) # 输出:<class 'tuple'> # 集合 fruits = {'apple', 'banana', 'orange'} print(type(fruits)) # 输出:<class 'set'> # 字典 person = {'name': 'Alice', 'age': 30} print(type(person)) # 输出:<class 'dict'> # 类型转换 x_str = str(x) print(x_str) # 输出:'10' x_float = float(x) print(x_float) # 输出:10.0
5、运算符
Python中的运算符是编写Python程序时不可或缺的元素,它们用于执行各种操作,如算术运算、比较运算、逻辑运算和位运算等。
Python中的运算符是编写Python程序时不可或缺的元素,它们用于执行各种操作,如算术运算、比较运算、逻辑运算和位运算等。以下是Python中运算符的使用教程:
5.1算术运算符
算术运算符用于执行基本的数学运算。
- 加法 (
+
):用于将两个操作数相加。 - 减法 (
-
):用于将第一个操作数减去第二个操作数。 - 乘法 (
*
):用于将两个操作数相乘。 - 除法 (
/
):用于将第一个操作数除以第二个操作数,结果为浮点数。 - 整除 (
//
):用于执行两个数的整除操作,结果为整数,向下取整。 - 取余 (
%
):用于计算两个数相除后的余数。 - 幂 (
**
):用于执行一个数的指数运算。# 加法 a = 5 + 3 print(a) # 输出: 8 # 减法 b = 10 - 4 print(b) # 输出: 6 # 乘法 c = 2 * 3 print(c) # 输出: 6 # 除法 d = 10 / 2 print(d) # 输出: 5.0 # 整除 e = 10 // 3 print(e) # 输出: 3 # 取余 f = 10 % 3 print(f) # 输出: 1 # 幂 g = 2 ** 3 print(g) # 输出: 8
5.2比较运算符
比较运算符用于比较两个值,并返回一个布尔值(True
或False
)。
- 等于 (
==
):检查两个值是否相等。 - 不等于 (
!=
):检查两个值是否不相等。 - 大于 (
>
):检查左侧的值是否大于右侧的值。 - 小于 (
<
):检查左侧的值是否小于右侧的值。 - 大于等于 (
>=
):检查左侧的值是否大于等于右侧的值。 - 小于等于 (
<=
):检查左侧的值是否小于或等于右侧的值。# 等于 x = 5 y = 5 print(x == y) # 输出: True # 不等于 print(x != 6) # 输出: True # 大于 print(x > 3) # 输出: True # 小于 print(x < 6) # 输出: True # 大于等于 print(x >= 5) # 输出: True # 小于等于 print(x <= 5) # 输出: True
5.3赋值运算符
赋值运算符用于给变量赋值。
- 简单赋值 (
=
):将右侧的值赋给左侧的变量。 - 增量赋值 (如
+=
,-=
,*=
,/=
,%=
,//=
,**=
):这些运算符结合了运算和赋值,将运算结果赋给左侧的变量。# 简单赋值 h = 10 print(h) # 输出: 10 # 增量赋值 h += 5 # 等同于 h = h + 5 print(h) # 输出: 15 h *= 2 # 等同于 h = h * 2 print(h) # 输出: 30 # 其他增量赋值运算符类似
5.4逻辑运算符
逻辑运算符用于执行逻辑运算。
- 与 (
and
):如果两个条件都为真,则返回True
,否则返回False
。 - 或 (
or
):如果两个条件中至少有一个为真,则返回True
,否则返回False
。 - 非 (
not
):将条件的结果取反,如果条件为真,则返回False
,如果条件为假,则返回True
。# 与 print(True and True) # 输出: True print(True and False) # 输出: False # 或 print(True or False) # 输出: True print(False or False) # 输出: False # 非 print(not True) # 输出: False print(not False) # 输出: True
5.5身份运算符
身份运算符用于比较两个对象的身份。
is
:如果两个变量是同一个对象,则返回True
。is not
:如果两个变量不是同一个对象,则返回True
。# is a = [1, 2, 3] b = a c = [1, 2, 3] print(a is b) # 输出: True,因为a和b指向同一个对象 print(a is c) # 输出: False,尽管内容相同,但a和c不是同一个对象 # is not print(a is not c) # 输出: True
5.6成员运算符
成员运算符用于测试一个值是否是一个序列(如列表、元组或字符串)的成员。
in
:如果在序列中找到该值,则返回True
。not in
:如果在序列中没有找到该值,则返回True
。# in my_list = [1, 2, 3, 4, 5] print(3 in my_list) # 输出: True # not in print(6 not in my_list) # 输出: True
5.7位运算符
位运算符用于对整数进行位级操作。
- 按位与 (
&
):对两个数的二进制表示进行按位与操作。 - 按位或 (
|
):对两个数的二进制表示进行按位或操作。 - 按位异或 (
^
):对两个数的二进制表示进行按位异或操作。 - 按位取反 (
~
):对一个数的二进制表示进行按位取反操作。 - 左移 (
<<
):将一个数的二进制表示向左移动指定的位数。 - 右移 (
>>
):将一个数的二进制表示向右移动指定的位数。# 按位与 a = 60 # 二进制 0011 1100 b = 13 # 二进制 0000 1101 print(a & b) # 输出: 12 (二进制 0000 1100) # 按位或 print(a | b) # 输出: 61 (二进制 0011 1101) # 按位异或 print(a ^ b) # 输出: 49 (二进制 0011 0001) # 按位取反 print(~a) # 输出: -61,因为Python中整数是补码形式,取反后加1等于原数的相反数 # 左移 print(a << 2) # 输出: 240 (二进制 1111 0000) # 右移 print(a >> 2) # 输出: 15 (二进制 0000 1111)
5.8运算符优先级
Python中的运算符有不同的优先级,这决定了在一个表达式中各个运算符的执行顺序。通常,括号 ()
的优先级最高,用于改变默认的运算顺序。其他运算符的优先级从高到低依次为:幂运算符 **
、正负号 +x
, -x
、乘法 *
、除法 /
、取模 %
、取整除法 //
、加法 +
、减法 -
、位运算符(<<
, >>
, &
, ^
, |
)、比较运算符(<
, <=
, >
, >=
, ==
, !=
)、逻辑运算符(not
, and
, or
)和赋值运算符(=
及其复合形式)。
6、条件判断
6.1if elif语句
Python中的条件判断是通过if
、elif
(else if 的缩写)、和else
语句来实现的。这些语句允许程序根据条件(布尔表达式)的真假来执行不同的代码块。条件判断是编程中非常基础且强大的概念,它使得程序能够根据不同的输入或状态来做出不同的响应。
if 条件表达式:
# 如果条件为真,则执行这里的代码块
pass
elif 条件表达式2:
# 如果条件表达式为假,但条件表达式2为真,则执行这里的代码块
pass
else:
# 如果前面的条件表达式都为假,则执行这里的代码块
pass
if
后面跟着一个条件表达式,如果条件为真(True),则执行if
语句块中的代码。elif
(可选)是else if
的缩写,用于提供额外的条件测试。如果前面的if
或elif
条件都不满足,Python会检查下一个elif
语句的条件。else
(可选)部分在所有的if
和elif
条件都不满足时执行。pass
是一个空操作语句,用作占位符,当语法上需要语句但程序不需要执行任何操作时可以使用。# 假设我们要根据年龄来打印不同的消息 age = 20 if age < 13: print("你是一个孩子。") elif age >= 13 and age < 20: print("你是一个青少年。") elif age >= 20 and age < 65: print("你是一个成年人。") else: print("你是一位老年人。")
条件表达式的结果必须是布尔值(
True
或False
)。但是,Python会隐式地将非布尔值(如整数、浮点数、字符串等)转换为布尔值。例如,在布尔上下文中,0
、None
、空字符串""
、空列表[]
、空元组()
、空字典{}
和空集合set()
等都被视为False
,其他所有值都被视为True
6.2match语句使用
match
语句是Python 3.10版本引入的一个新特性,它提供了一种更直观和强大的方式来进行模式匹配。虽然match
语句通常与数据结构和类型相关联,但它也可以用于更广泛的条件判断场景,尤其是当需要基于不同条件执行不同代码块时。然而,需要注意的是,match
语句主要用于与case
标签一起,对表达式的值进行模式匹配
match subject:
case pattern1:
# 如果subject与pattern1匹配,执行这里的代码
...
case pattern2:
# 如果subject与pattern2匹配,执行这里的代码
...
case _: # 通配符模式,匹配任何值
# 如果没有其他模式匹配,执行这里的代码
...
subject
:是要与各个模式进行比较的表达式。pattern
:是一个或多个用于与subject
进行比较的模式。模式可以是字面量、变量、类型、元组、列表、字典、类实例等,也可以是使用|
(或)操作符组合的模式。_
:是一个特殊的通配符模式,它匹配任何值。在match
语句中,它通常用作最后一个case
,以捕获所有未被前面模式匹配的情况。color = "green" match color: case "red": print("Stop!") case "green" | "yellow": print("Go!") case _: print("I don't know about that color.") #在这个例子中,match语句根据color变量的值来匹配不同的模式。 #如果color是"red",则打印"Stop!"; #如果color是"green"或"yellow",则打印"Go!"; #如果color是其他任何值,则打印"I don't know about that color."。
7、循环
Python中的循环是一种控制流语句,它允许重复执行一段代码块直到满足特定条件为止。Python提供了两种基本的循环结构:for
循环和while
循环。每种循环都有其特定的用途和语法。
7.1for循环
for
循环用于遍历任何序列(如列表、元组或字符串)或其他可迭代对象
for 变量 in 可迭代对象:
# 循环体
pass
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
print(fruit)
7.2while循环
while
循环会在给定条件为真时重复执行一段代码块,只要条件表达式
的结果为真(True),循环就会继续执行。如果条件表达式的结果为假(False),循环就会结束。
while 条件表达式:
# 循环体
pass
count = 1
while count <= 5:
print(count)
count += 1
#使用while循环打印1-5
7.3循环控制语句
break
语句:用于立即退出循环,无论是for
循环还是while
循环
for i in range(1, 10):
if i == 5:
break
print(i)
continue
语句:用于跳过当前循环的剩余语句,并继续下一次循环。
for i in range(1, 10):
if i % 2 == 0:
continue
print(i)
else
语句与循环:for
和while
循环都可以有一个可选的else
子句,它在循环正常结束后执行(即不是通过break
语句退出的)。
for i in range(1, 5):
print(i)
else:
print("Loop completed normally.")
嵌套循环:循环可以嵌套在另一个循环内部。这意味着你可以在一个循环体内开始另一个循环。
for i in range(1, 4):
for j in range(1, i + 1):
print(f"{j}x{i}={i*j}", end='\t')
print() # 换行
#使用嵌套循环打印乘法口诀表
8、组合数据类型
Python中的组合数据类型(Composite Data Types)允许你将多个值组合成一个单一的数据项。这些类型对于组织和处理复杂数据非常有用。Python中有几种主要的组合数据类型,包括列表(List)、元组(Tuple)、字典(Dictionary)和集合(Set
8.1列表
列表是Python中最常用的数据类型之一,它是一个有序的集合,可以包含不同类型的元素。列表是可变的,意味着你可以添加、删除或更改列表中的元素
创建列表: 使用方括号[]
,元素之间用逗号,
分隔。
my_list = [1, 2, 3, 'a', 'b', 'c']
访问元素: 通过索引访问,索引从0开始。
print(my_list[0]) # 输出: 1
添加元素: 使用append()
在末尾添加,insert(index, value)
在指定位置插入。
my_list.append(4)
my_list.insert(1, 'x')
删除元素: 使用remove(value)
删除第一个匹配的元素,pop(index)
删除并返回指定索引的元素,默认删除最后一个元素。
my_list.remove('a')
print(my_list.pop()) # 删除并返回最后一个元素
切片: 使用[start:stop:step]
选择列表的一部分。
print(my_list[1:4]) # 输出: ['x', 2, 3]
遍历:列表的遍历通常使用for
循环。你可以直接遍历列表中的每个元素,或者通过索引和range()
函数遍历(尽管后者在简单遍历中不太常见)。
my_list = [1, 2, 3, 4, 5]
for item in my_list:
print(item)
# 输出:
# 1
# 2
# 3
# 4
# 5
8.2元组
元组与列表类似,但它是不可变的。一旦创建了元组,就不能更改其元素(但元素本身如果是可变类型,如列表,则内部元素可以更改
创建元组: 使用圆括号()
,元素之间用逗号,
分隔。
my_tuple = (1, 2, 3, 'a', 'b')
访问元素: 与列表相同,通过索引访问
print(my_tuple[0]) # 输出: 1
切片: 也支持切片操作。
print(my_tuple[1:3]) # 输出: (2, 3)
删除:del 元组
del my_tuple
遍历:元组的遍历与列表的遍历非常相似,因为元组也是可迭代对象。你可以使用相同的for
循环结构来遍历元组中的每个元素。
my_tuple = (1, 2, 3, 4, 5)
for item in my_tuple:
print(item)
# 输出:
# 1
# 2
# 3
# 4
# 5
8.3字典
字典是Python中的另一种组合数据类型,用于存储键值对(key-value pairs)。字典是无序的,但可以通过键快速访问其值
创建字典: 使用大括号{}
,键值对之间用逗号,
分隔,键与值之间用冒号:
分隔。
my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}
访问元素: 通过键访问值。
print(my_dict['name']) # 输出: John
添加或更新元素: 直接赋值给新键或现有键。
my_dict['job'] = 'Engineer'
my_dict['age'] = 31
删除元素: 使用del
语句或pop()
方法(后者会返回被删除的值)。
del my_dict['city']
print(my_dict.pop('age')) # 输出: 31
遍历: 可以遍历字典的键、值或键值对。
for key in my_dict:
print(key)
for value in my_dict.values():
print(value)
for key, value in my_dict.items():
print(key, value)
8.4集合
Python中的集合(Set)是一个无序的、不包含重复元素的数据结构。它主要用于数学上的集合操作,如并集、交集、差集和对称差集等。集合中的元素必须是不可变类型(如整数、浮点数、字符串和元组),但不能是列表或字典等可变类型
创建集合:集合可以使用大括号{}
来创建,但与字典不同,集合中的元素之间用逗号,
分隔,且没有键(key)和值(value)的概念。但是,注意空集合不能使用{}
来创建,因为这会与空字典混淆;应该使用set()
来创建空集合。
# 创建一个集合
my_set = {1, 2, 3, 4, 5}
# 创建一个空集合
empty_set = set()
添加元素:使用.add()
方法向集合中添加元素。
my_set = {1, 2, 3}
my_set.add(4) # 添加元素4
print(my_set) # 输出: {1, 2, 3, 4}
删除元素:可以使用.remove()
(如果元素存在则删除,不存在则抛出KeyError
)或.discard()
(如果元素存在则删除,不存在则不抛出错误)方法删除元素。还可以使用.pop()
方法随机删除并返回一个元素(如果集合为空,则抛出KeyError
)
my_set.remove(2) # 删除元素2
print(my_set) # 输出: {1, 3, 4}
# 如果尝试删除不存在的元素
# my_set.remove(5) # 这会抛出KeyError
my_set.discard(5) # 如果元素不存在,则不抛出错误
print(my_set) # 输出: {1, 3, 4}
# 随机删除并返回一个元素
popped_element = my_set.pop()
print(f"Popped element: {popped_element}, Set now: {my_set}")
检查元素:使用in
或not in
关键字检查集合中是否包含某个元素。
print(3 in my_set) # 输出: True
print(5 in my_set) # 输出: False
集合的并集:使用|
或.union()
方法合并两个集合,去除重复元素。
集合的交集:使用&
或.intersection()
方法找出两个集合中共有的元素。
集合的差集:使用-
或.difference()
方法找出存在于第一个集合中但不在第二个集合中的元素。
集合的对称差集:使用^
或.symmetric_difference()
方法找出存在于两个集合中但不同时存在于两个集合中的元素。
set_a = {1, 2, 3, 4}
set_b = {3, 4, 5, 6}
# 并集
union_set = set_a | set_b # 或使用 set_a.union(set_b)
print(union_set) # 输出: {1, 2, 3, 4, 5, 6}
# 交集
intersection_set = set_a & set_b # 或使用 set_a.intersection(set_b)
print(intersection_set) # 输出: {3, 4}
# 差集
difference_set = set_a - set_b # 或使用 set_a.difference(set_b)
print(difference_set) # 输出: {1, 2}
# 对称差集
symmetric_difference_set = set_a ^ set_b # 或使用 set_a.symmetric_difference(set_b)
print(symmetric_difference_set) # 输出: {1, 2, 5, 6}
9、异常
Python中的异常处理是一种非常重要的编程技术,它允许程序在运行时遇到错误时优雅地处理这些错误,而不是简单地崩溃并终止执行。异常处理通过使用try
和except
语句块来实现,还可以配合else
和finally
语句块来增强异常处理的灵活性
9.1常见的异常类型
-
Exception
:所有异常的基类,所有的内置和用户定义的异常都是它的子类。通常不推荐直接捕获Exception
,因为它会捕获到几乎所有的异常,包括那些你不希望捕获的(比如SystemExit
、KeyboardInterrupt
等),这可能会隐藏程序的真正问题。 -
AttributeError
:尝试访问一个对象不存在的属性时引发的异常。 -
IOError
(在Python 3.x中已被OSError
取代,但IOError
仍作为别名存在):进行输入/输出操作时发生错误,如打开不存在的文件。 -
OSError
:表示I/O操作失败或无法执行系统操作(如文件操作或文件系统错误)时引发的异常。它是许多I/O相关异常的基类。 -
ImportError
:无法导入模块或包时引发的异常。 -
IndentationError
:缩进错误,这是语法错误的一种,但Python会将其视为异常。 -
IndexError
:使用序列中不存在的索引时引发的异常,比如访问列表的索引超出了其长度范围。 -
KeyError
:尝试访问字典中不存在的键时引发的异常。 -
KeyboardInterrupt
:用户中断执行(通常是按下Ctrl+C)时引发的异常。 -
NameError
:尝试访问一个未被定义的局部变量或函数时引发的异常。 -
SyntaxError
:语法错误,比如拼写错误、缺少冒号等。这通常是解析代码时发现的错误,不是通过异常处理机制来捕获的,但Python会将其视为一个异常。 -
TypeError
:对类型进行了不支持的操作时引发的异常,比如尝试将非数字字符串与数字相加。 -
ValueError
:当传入的参数类型正确,但值不适合函数或操作的要求时引发的异常。比如,将int()
函数应用于非数字的字符串。 -
ZeroDivisionError
:尝试除以零时引发的异常。 -
AssertionError
:assert
语句失败时引发的异常,用于调试目的。 -
FileNotFoundError
(Python 3.x中新增):当尝试打开的文件不存在时引发的异常,是OSError
的一个子类。 -
PermissionError
(Python 3.3+):当操作系统不允许程序执行某个操作时引发的异常,比如没有文件的写权限。
9.2异常处理的基本机构
- try块:包含可能引发异常的代码。
- except块:用于捕获并处理try块中发生的异常。可以指定捕获特定类型的异常,也可以不指定以捕获所有类型的异常。
- else块(可选):如果try块中的代码没有引发异常,则执行else块中的代码。
- finally块(可选):无论是否发生异常,finally块中的代码都会被执行。通常用于执行清理操作,如关闭文件或释放资源。
假设我们要编写一个程序,该程序尝试将用户输入的字符串转换为整数。如果输入的是有效的整数字符串,则打印转换后的整数;如果输入的不是有效的整数字符串,则捕获ValueError
异常并打印一条错误消息。
try:
# 尝试将用户输入转换为整数
user_input = input("请输入一个整数:")
number = int(user_input)
print(f"您输入的整数是:{number}")
except ValueError:
# 如果转换失败,捕获ValueError异常
print("输入错误,请输入一个有效的整数。")
else:
# 如果try块中没有引发异常,则执行(在这个例子中,这个else块其实有点多余,因为print语句已经在try块中了)
# 但为了演示else的用法,我们暂时保留它
print("输入成功,没有发生异常。")
finally:
# 无论是否发生异常,都会执行finally块中的代码
print("程序执行完毕,进行清理工作(如果有的话)。")
在这个例子中,如果用户输入的是"123",则程序会打印"您输入的整数是:123"和"输入成功,没有发生异常。"以及"程序执行完毕,进行清理工作(如果有的话)。"。如果用户输入的是"abc",则程序会捕获ValueError
异常,打印"输入错误,请输入一个有效的整数。",然后仍然会打印"程序执行完毕,进行清理工作(如果有的话)。"。
9.3捕获多个异常
可以使用同一个except
语句来捕获多个异常,只需将异常类型放在括号中并用逗号分隔即可。
try:
# 尝试执行可能引发多种异常的代码
pass
except (TypeError, ValueError) as e:
# 捕获TypeError或ValueError异常
print(f"发生错误:{e}")
9.4捕获所有的异常
可以使用Exception
来捕获所有类型的异常(但请注意,这通常不是最佳实践,因为它可能会隐藏你原本想要处理的特定异常)。
try:
# 尝试执行可能引发异常的代码
pass
except Exception as e:
# 捕获所有类型的异常
print(f"发生未知错误:{e}")
9.5raise的用法
在Python中,raise
语句用于手动触发一个异常。当程序执行到raise
语句时,它会立即停止当前的代码执行,并向上层调用者抛出(或“触发”)一个异常。这个异常可以是Python内置的异常类型之一,也可以是自定义的异常类。如果异常没有被捕获处理,则程序将终止运行,并打印出一个错误信息。
基本用法:raise ExceptionType(args)
ExceptionType
:是你要抛出的异常的类型。这可以是任何继承自Exception
类的类,包括Python内置的异常类型和自定义的异常类。args
:是传递给异常构造函数的参数,它将被转换成字符串并用作异常的描述信息。如果异常类型需要其他形式的参数,也可以相应地传递。
try:
pwd = input('请输入你的密码')
if len(pwd)<8:
raise Exception('密码长度不够,请输入一个8位以上的密码')
except Exception as e:
print(e)
#输入123
#控制台则打印密码长度不够,请输入一个8位以上的密码
10、函数
Python中的函数是一种可重用的代码块,它接收一些输入(称为参数)并可能返回一些输出(称为返回值)。函数使得代码更加模块化,易于理解和维护。在Python中,你可以定义自己的函数来执行特定任务,也可以使用Python的内置函数和来自其他库的函数
10.1定义函数
在Python中,可以使用def
关键字来定义一个函数。定义函数时,你需要指定函数名、参数列表(可能为空)以及函数体(即函数的代码块)
def function_name(parameter1, parameter2, ...):
"""
函数的文档字符串(可选)
描述函数的功能、参数和返回值。
"""
# 函数体
# 你可以在这里编写实现函数功能的代码
# 使用return语句可以返回一个值给调用者(可选)
return result
10.2调用函数
定义函数后,你可以通过函数名加上圆括号(其中可以包含传递给函数的参数)来调用它。如果函数有返回值,则可以将返回值赋给一个变量,或者在其他表达式中使用它。
def add_numbers(a, b):
"""
计算并返回两个数的和。
参数:
a -- 第一个加数
b -- 第二个加数
返回:
两个数的和
"""
return a + b
# 调用函数
result = add_numbers(5, 3)
print(result) # 输出: 8
10.3参数与返回值
参数:函数可以定义零个或多个参数,这些参数在函数被调用时接收外部传入的值。
返回值:函数可以通过return
语句返回一个值给调用者。如果函数没有return
语句,或者return
语句后面没有跟任何值,那么函数将返回None
10.4默认参数与关键字参数
默认参数:在定义函数时,你可以为参数指定默认值。如果在调用函数时没有为这些参数提供值,那么将使用默认值。
def greet(name, greeting="Hello"):
print(f"{greeting}, {name}!")
greet("Alice") # 输出: Hello, Alice!
greet("Bob", "Hi") # 输出: Hi, Bob!
关键字参数:在调用函数时,你可以通过参数名来指定参数值,这称为关键字参数。使用关键字参数可以不必遵循函数定义中参数的顺序。
def person_info(name, age, job):
print(f"Name: {name}, Age: {age}, Job: {job}")
person_info(name="John", age=30, job="Engineer")
# 或者以不同的顺序(由于使用了关键字参数)
person_info(job="Doctor", name="Emily", age=25)
10.5可变参数
Python还支持可变数量的参数,这在处理不确定数量的输入时非常有用。
*args
:允许你将一个不定长度的参数列表传递给一个函数。def sum_numbers(*args): total = 0 for num in args: total += num return total print(sum_numbers(1, 2, 3, 4)) # 输出: 10
**kwargs
:允许你将不定长度的关键字参数传递给一个函数。def greet_person(**kwargs): for key, value in kwargs.items(): print(f"{key}: {value}") greet_person(name="Alice", age=30, city="New York") # 输出: # name: Alice # age: 30 # city: New York
10.6变量作用域
在Python中,函数变量作用域是一个非常重要的概念,它决定了变量在程序中的可见性和生命周期。Python中主要有三种作用域:局部作用域(Local Scope)、全局作用域(Global Scope)和内置作用域(Built-in Scope),但当我们讨论函数变量作用域时,主要关注的是局部作用域和全局作用域。
局部作用域是指变量在函数内部定义,并且只能在该函数内部被访问和修改。当函数被调用时,Python会创建一个新的局部命名空间,用来存储函数中定义的变量。这些变量在函数执行结束后将被销毁,除非它们被以某种方式(如返回值)传递到函数外部
全局作用域是指变量在函数外部定义,可以在整个模块(文件)中被访问和修改。在函数内部,如果你想访问或修改全局变量,你需要使用global
关键字来声明该变量是全局的
def my_function():
x = "这是一个局部变量"
print(x)
my_function() # 输出: 这是一个局部变量
# print(x) # 如果用这个,这里就会引发NameError,因为x是局部作用域中的变量
x = "这是一个全局变量"
def my_function():
print(x) # 访问全局变量
my_function() # 输出: 这是一个全局变量
def change_global():
global x
x = "全局变量已被修改"
change_global()
print(x) # 输出: 全局变量已被修改
如果你尝试在函数内部修改全局变量但未使用global
关键字,Python会创建一个同名的局部变量。
x = "这是一个全局变量"
def my_function():
x = "尝试修改但实际上是创建了局部变量"
print(x)
my_function() # 输出: 尝试修改但实际上是创建了局部变量
print(x) # 输出: 这是一个全局变量,全局变量未受影响
10.7匿名函数
Python中的匿名函数是通过lambda
关键字定义的简短函数。它们通常用于定义简单的、一次性的函数对象,这些对象可以作为参数传递给高阶函数(如map()
, filter()
, reduce()
等)或者在需要函数对象的任何地方使用。由于lambda
函数本质上是表达式,它们具有一个表达式,其结果自动成为函数的返回值。因此,lambda
函数不能包含多个表达式、控制语句(如if-else
、for
循环等)或文档字符串
语法:
lambda arguments: expression
arguments
是传递给函数的参数,可以有一个或多个,也可以没有(创建了一个不接受任何参数的函数)。expression
是一个关于参数的表达式,计算该表达式的结果并将其返回。
示例:
square = lambda x: x * x
print(square(4)) # 输出: 16
#这里定义了一个名为square的lambda函数,它接受一个参数x并返回x的平方。
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
print(squared) # 输出: [1, 4, 9, 16, 25]
#这里使用lambda函数作为map()函数的第一个参数。
#map()函数将lambda函数应用于numbers列表中的每个元素,
#并返回一个迭代器,该迭代器包含所有应用lambda函数后的结果。
#然后,使用list()函数将结果转换为列表。
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers) # 输出: [2, 4, 6, 8, 10]
10.8内置函数
Python提供了许多内置函数,这些函数可以直接使用,无需导入任何模块。它们通常用于执行常见的编程任务,如输入输出、数学运算、类型检查等。
# 使用内置函数len计算字符串的长度
s = "hello"
print(len(s)) # 输出: 5
# 使用内置函数print进行输出
print("Hello, World!")
# 使用内置函数max找出列表中的最大值
numbers = [1, 3, 5, 7, 9]
print(max(numbers)) # 输出: 9
# 使用内置函数type检查变量的类型
x = 5
print(type(x)) # 输出: <class 'int'>
10.9递归函数
Python中的递归函数是一种特殊的函数,它会直接或间接地调用自身。递归函数是解决可以分解为相似子问题的问题的一种强大方法。在递归函数中,通常会有一个或多个基本情况(base case),即不需要进一步递归就能直接求解的情况。当函数遇到基本情况时,就会停止递归调用并返回结果。递归函数还需要有一个或多个递归步骤(recursive step),这些步骤会将问题分解为更小的子问题,直到达到基本情况。
阶乘是所有小于或等于该数的正整数的积,特别地,0的阶乘是1。阶乘是一个很好的递归函数示例。
def factorial(n):
# 基本情况
if n == 0:
return 1
# 递归步骤
else:
return n * factorial(n-1)
# 测试
print(factorial(5)) # 输出: 120
factorial
函数检查基本情况(n == 0
),如果满足,则返回1。否则,它执行递归步骤,将问题分解为计算n-1
的阶乘,然后将结果与n
相乘。
斐波那契数列是一个经典的递归问题,其中每个数是前两个数的和,序列以0和1开始。
def fibonacci(n):
# 基本情况
if n <= 1:
return n
# 递归步骤
else:
return fibonacci(n-1) + fibonacci(n-2)
# 测试
print(fibonacci(10)) # 输出: 55
11、模块
在Python中,模块是一个包含Python定义和声明的文件,文件名就是模块名加上.py
后缀。模块允许你组织、封装代码,便于重用和维护。模块可以定义函数、类和变量,然后可以被其他模块或脚本导入(import)并使用。通俗讲,模块就好比是工具包,想使用这个工具包的工具,就需要导入import这个模块。
11.1导入模块
在Python中,你可以使用import
语句来导入模块。有几种不同的导入方式
导入整个模块
import math
print(math.sqrt(16)) # 使用模块中的函数时,需要前缀模块名
从模块中导入特定的函数或变量
from math import sqrt
print(sqrt(16)) # 直接使用函数名,无需模块名前缀
为导入的模块或函数指定别名
import math as m
print(m.sqrt(16)) # 使用别名前缀
from math import sqrt as square_root
print(square_root(16)) # 使用别名
导入模块中的所有内容(不推荐,因为可能导致命名冲突)
from math import *
print(sqrt(16))
导入自定义创建模块
你可以创建自己的模块,只需将Python代码保存为.py
文件即可。然后,你可以在其他Python脚本或模块中通过import
语句来导入它。
例如,假设你有一个名为mymodule.py
的文件,内容如下:
# mymodule.py
def greet(name):
print(f"Hello, {name}!")
my_variable = "This is a variable in mymodule."
你可以在另一个Python文件中这样导入和使用它:
# another_script.py
from mymodule import greet
greet("Bob")
# 注意:my_variable 没有被导入,所以不能直接访问
11.2包的使用
在Python中,包(Package)是一种高级的模块,它本质上是一个包含__init__.py
文件的目录,这个目录可以包含模块(.py
文件)和子包(即包含__init__.py
的子目录)。包的主要作用是提供一种组织模块的方式,使得模块可以分组成相关的集合,从而更容易地管理和维护大型的项目。
包的作用
-
命名空间管理:包为模块提供了一个更细粒度的命名空间。通过使用包,你可以避免不同库中的模块名冲突。
-
代码组织:包允许你将相关的模块组织在一起,形成一个逻辑上更紧密的结构。这有助于项目的理解和维护。
-
分发与部署:包可以作为一个整体被分发和部署,使得其他开发者可以更容易地安装和使用你的代码。
-
封装与隐藏:通过
__init__.py
文件,你可以控制哪些模块和子包被导入时自动加载,哪些则保持隐藏。
创建包
要创建一个包,你首先需要创建一个目录,并在该目录中放置一个名为__init__.py
的文件。这个文件可以是空的,但它必须存在,因为它告诉Python这个目录应该被视为一个Python包。然后,你可以在这个目录中添加模块(.py
文件)和子包(包含__init__.py
的子目录)。
__init__.py
文件可以包含初始化代码,也可以定义包级别的变量、函数或类。但是,它最常见的作用是作为包的标记文件,并且可能包含一些用于导入包中模块的import
语句,以便简化包的外部使用。
导入包和包中的模块
11.3Python中的标准库
Python的标准库(Standard Library)是一组与Python解释器一起安装的模块集合,它提供了大量的预定义函数和类,用于执行常见的编程任务。简单说标准库就是Python官方提供给我们的一些很好用的工具包,我们可以直接调用。如文件操作、网络编程、文本处理、数据压缩、正则表达式匹配等。使用标准库可以极大地提高编程效率,避免重复造轮子
例如:
os
模块提供了与操作系统交互的功能,如文件路径操作、文件和目录管理、环境变量访问等。
sys
模块提供了一些变量和函数,用于操作Python运行时环境。
json
模块用于处理JSON数据。JSON(JavaScript Object Notation)是一种轻量级的数据交换格式,易于人阅读和编写,同时也易于机器解析和生成
re
模块提供了对正则表达式的支持。正则表达式是一种强大的文本处理工具,可以用于搜索、替换、匹配等操作。
datetime
模块提供了日期和时间的处理功能。
import os
# 获取当前工作目录
current_dir = os.getcwd()
print("当前工作目录:", current_dir)
# 列出当前目录下的所有文件和目录
for item in os.listdir(current_dir):
print(item)
import sys
# sys.argv 是一个列表,包含了命令行参数
# sys.argv[0] 是脚本名,sys.argv[1:] 是传递给脚本的参数
print("脚本名:", sys.argv[0])
for arg in sys.argv[1:]:
print("参数:", arg)
import json
# 字典转JSON字符串
data = {'name': 'John', 'age': 30, 'city': 'New York'}
json_str = json.dumps(data)
print("JSON字符串:", json_str)
# JSON字符串转字典
json_str = '{"name": "John", "age": 30, "city": "New York"}'
data = json.loads(json_str)
print("解析后的字典:", data)
import re
# 假设我们要匹配的电话号码格式为:(xxx) xxx-xxxx
text = "Call me at (123) 456-7890 or (456) 789-1234"
phone_numbers = re.findall(r'\(\d{3}\) \d{3}-\d{4}', text)
print("电话号码:", phone_numbers)
from datetime import datetime
now = datetime.now()
print("当前日期和时间:", now)
# 格式化日期和时间
formatted_now = now.strftime("%Y-%m-%d %H:%M:%S")
print("格式化后的日期和时间:", formatted_now)
常见的标准库以及使用教程可以参考下面:
常见的标准库可以参考:python常用标准库_python标准库有哪些-CSDN博客
12、文件操作
12.1文件的基本概念
在Python中,文件是计算机存储设备上的一个序列化的数据结构,用于存储数据以供程序读取或写入。文件可以是文本文件,也可以是二进制文件,具体取决于文件中存储的数据类型。文件操作是编程中的一项基本任务,它允许程序与外部世界进行数据交换。
文件路径
文件路径是指向文件存储位置的字符串。在Python中,你可以使用绝对路径或相对路径来指定文件的位置。
- 绝对路径:从根目录(或某个固定点)开始的完整路径,如
C:\Users\Example\Documents\file.txt
(Windows)或/home/user/Documents/file.txt
(Linux/macOS)。 - 相对路径:相对于当前工作目录的路径。如果当前工作目录是
/home/user/Documents
,那么file.txt
就是相对于这个目录的相对路径。
文件模式
文件模式指定了文件应该如何被打开(只读、只写、追加等)以及文件是文本文件还是二进制文件。Python的open()
函数使用模式参数来控制这些行为。常见的模式包括:
'r'
:只读模式(默认)。如果文件不存在,抛出FileNotFoundError
。'w'
:只写模式。如果文件已存在,则覆盖;如果文件不存在,则创建新文件。'a'
:追加模式。如果文件已存在,写入的数据会被追加到文件末尾;如果文件不存在,则创建新文件进行写入。'r+'
、'w+'
、'a+'
:分别对应读写、读写(覆盖)、读写(追加)模式。'b'
:二进制模式。可以与上述模式组合使用,如'rb'
表示二进制只读模式。
文件对象
使用open()
函数打开文件时,Python会返回一个文件对象。这个文件对象包含了文件的各种方法和属性,用于执行文件操作(如读取、写入、关闭文件等)。
文件指针
文件指针是一个抽象的概念,用于跟踪当前读写操作在文件中的位置。当你打开文件时,文件指针通常位于文件的开头。当你读取或写入文件时,文件指针会向前移动相应的字节数。你可以使用seek()
方法来改变文件指针的位置,使用tell()
方法来获取当前文件指针的位置。
缓冲区
文件操作通常涉及磁盘I/O,这是相对较慢的操作。为了提高性能,Python(和大多数操作系统)使用缓冲区来减少磁盘I/O的次数。当你写入文件时,数据首先被写入到缓冲区中,然后在某个时间点(如缓冲区满或显式调用flush()
方法时)被写入到磁盘上。同样,当你从文件读取数据时,数据也是从磁盘读取到缓冲区中,然后从你的程序中读取。
文件编码
对于文本文件,Python需要知道文件的编码方式才能正确地将字节序列转换为字符串(在读取文件时)或将字符串转换为字节序列(在写入文件时)。默认情况下,Python使用系统默认的编码(如UTF-8),但你可以通过encoding
参数在open()
函数中指定其他编码方式。
文件关闭
完成文件操作后,应该使用close()
方法关闭文件。关闭文件可以释放系统资源,并确保所有缓冲的输出都被正确写入文件。为了避免忘记关闭文件,可以使用with
语句来自动管理文件的打开和关闭。
12.2读取文件
在Python中,读取文件是一个常见的操作,它允许你访问存储在文件中的信息。Python提供了多种方式来读取文件,包括一次性读取整个文件、逐行读取、以及按块读取等
使用open()
函数打开文件
在读取文件之前,你需要使用open()
函数以适当的模式(如'r'
表示只读模式)打开文件。open()
函数返回一个文件对象,该对象提供了多种方法来读取文件内容。
一次性读取整个文件
如果文件不是特别大,可以一次性将整个文件内容读取到内存中。这可以通过调用文件对象的read()
方法来实现。
# 打开文件
with open('example.txt', 'r') as file:
# 一次性读取整个文件内容
content = file.read()
# 处理文件内容
print(content)
逐行读取文件
对于大多数文本文件,逐行读取是一种更内存友好的方法。可以通过迭代文件对象来逐行读取文件,因为文件对象是可迭代的。
# 打开文件
with open('example.txt', 'r') as file:
# 逐行读取文件
for line in file:
# 处理每行内容
# 注意:每行末尾的换行符也会被读取,但通常不需要在打印时再次显示
print(line, end='') # 使用end=''来避免打印额外的换行符
按块读取文件
如果需要更精细地控制读取过程,或者正在处理一个非常大的文件,你可能希望按块读取文件。这可以通过调用文件对象的read(size)
方法来实现,其中size
是你希望读取的字节数。
# 打开文件
with open('large_file.txt', 'r') as file:
# 设置块大小(例如,1024字节)
chunk_size = 1024
# 读取文件内容,直到文件末尾
while True:
# 读取一个块
chunk = file.read(chunk_size)
# 如果读取到空字符串,表示已经到达文件末尾
if not chunk:
break
# 处理块内容
# 注意:这里处理的是字节串,对于文本文件,你可能需要将其解码为字符串
# 例如:chunk_str = chunk.decode('utf-8')
# 但对于文本模式打开的文件,read()方法直接返回字符串,无需解码
print(chunk, end='') # 假设这里是文本模式,直接打印
读取文件的其他注意事项
- 当使用
with
语句打开文件时,文件会在with
代码块执行完毕后自动关闭,这是一种很好的做法,因为它可以确保文件即使在发生异常时也能被正确关闭。 - 对于非文本文件(如图片、视频等),你应该以二进制模式(
'rb'
)打开文件,并使用字节类型的数据进行处理。 - 读取大文件时,请考虑使用逐行读取或按块读取的方法,以避免消耗过多内存。
- 在处理文件时,请确保你有足够的权限来读取目标文件。
12.3写入文件
在Python中,写入文件是一个将数据保存到文件中的过程。这可以通过使用open()
函数以写入模式(如'w'
、'a'
等)打开文件,并调用文件对象的write()
或writelines()
方法来实现。
使用open()
函数打开文件
在写入文件之前,你需要使用open()
函数以适当的模式打开文件。对于写入操作,常用的模式有:
'w'
:写入模式,如果文件已存在则覆盖,如果文件不存在则创建新文件。'a'
:追加模式,如果文件已存在则在文件末尾追加内容,如果文件不存在则创建新文件
# 以写入模式打开文件
with open('output.txt', 'w') as file:
# 写入内容
pass
# 以追加模式打开文件
with open('output.txt', 'a') as file:
# 追加内容
pass
使用write()
方法写入内容
write()
方法用于将字符串写入文件。如果文件是以写入模式('w'
)打开的,并且文件已存在,则原有内容会被覆盖。如果文件是以追加模式('a'
)打开的,则写入的内容会被追加到文件末尾。
# 写入内容到文件
with open('output.txt', 'w') as file:
file.write('Hello, Python!\n')
file.write('This is a test file.\n')
# 追加内容到文件
with open('output.txt', 'a') as file:
file.write('Appending more text.\n')
使用writelines()
方法写入多行
如果你有一个字符串列表,并希望将它们全部写入文件,可以使用writelines()
方法。但是,请注意,writelines()
不会自动在字符串之间添加换行符,因此你可能需要在每个字符串末尾手动添加\n
。
lines = ['First line.\n', 'Second line.\n', 'Third line.\n']
with open('output.txt', 'w') as file:
file.writelines(lines)
写入二进制文件
对于非文本文件(如图片、视频等),你需要以二进制模式('wb'
或'ab'
)打开文件,并使用字节类型的数据进行写入。
# 写入二进制数据到文件
data = b'\x89PNG\r\n\x1a\n...' # 假设这是PNG文件的头部
with open('image.png', 'wb') as file:
file.write(data)
注意事项
- 当使用
with
语句打开文件时,文件会在with
代码块执行完毕后自动关闭,这是一种很好的做法,因为它可以确保文件即使在发生异常时也能被正确关闭。 - 写入文件时,请确保你有足够的权限来写入目标文件。
- 如果文件以写入模式(
'w'
)打开,并且文件已存在,则原有内容会被覆盖。如果你不想覆盖原有内容,应该使用追加模式('a'
)。 - 对于文本文件,写入的内容应该是字符串类型。对于二进制文件,写入的内容应该是字节类型(
bytes
)。 - 在写入文件时,如果文件非常大,请考虑分批写入,以避免消耗过多内存。但是,对于大多数情况,Python的文件写入操作是高效的,并且会自动处理内存管理。
12.4文件追加
文件追加与写入类似,但使用'a'
模式打开文件时,如果文件已存在,写入的数据会被追加到文件末尾,而不是覆盖原有内容。
假设想在output.txt
文件的末尾追加以下内容
Appending some more text.
可以使用以下代码来实现:
# 向文件追加内容
with open('output.txt', 'a') as file:
file.write('Appending some more text.\n')
注意事项
-
当使用
with
语句时,文件会在with
代码块执行完毕后自动关闭,无需显式调用close()
方法。 - 读取文件时,如果文件很大,一次性读取整个文件可能会消耗大量内存。在这种情况下,可以逐行读取或使用
read(size)
方法分块读取。 - 写入文件时,如果文件已存在且以
'w'
模式打开,则原有内容会被覆盖。如果希望保留原有内容并追加新内容,请使用'a'
模式。 - 对于二进制文件,应使用
'rb'
、'wb'
和'ab'
模式进行读取、写入和追加操作,并使用字节类型的数据(如bytes
对象)进行读写。