通关Python自动化？你需要这份“技能树”全点亮指南

菜鸟小白的学习分享

发布于 2025-11-21 17:32:58

160

文章被收录于专栏：菜鸟小白的学习分享菜鸟小白的学习分享

「Python基础知识梳理」

基础语法

1. 标识符

标识符在Python中是用来给变量、函数、类等命名的名称，它需要遵循一定的命名规则：

命名规则

• 「首字符」：标识符的首字符必须是字母（ A−Z,a−zA−Z,a−z ）或下划线（_），不能是数字。

• 「后续字符」：后续字符可以是字母、数字或下划线。

• 「大小写敏感」：Python是大小写敏感的语言，例如apple和Apple是两个不同的标识符。

• 「禁止使用关键字」：标识符不能是Python的关键字，如if、else、for等。

命名规范

• 「见名知意」：标识符应具有一定的描述性，能够清晰地表达其代表的含义，提高代码的可读性。

• 「下划线命名法」：多个单词组成的标识符，推荐使用下划线连接，如first_name、student_count等。

• 「类名规范」：类名通常采用大驼峰命名法，即每个单词的首字母大写，如MyClass、UserInfo等。

• 「方法名和变量名」：方法名和变量名通常采用小驼峰命名法或下划线命名法，如myMethod、my_variable等。

2. 保留字

Python保留字是Python语言中已经被赋予特定意义的单词，它们有特殊的用途，不能用作变量名或函数名。以下是Python 3.x版本中的保留字列表：

分类	关键字	简要说明
布尔值	False, None, True	表示假值/空值/真值
控制流	if, elif, else, and, or, not	条件判断与逻辑运算
函数定义	def, lambda, return	函数与返回值定义
循环控制	for, while, break, continue	循环结构与流程控制
异常处理	try, except, finally, raise	错误捕获与处理机制
模块操作	import, from, as	模块导入与别名定义
异步编程	async, await	协程与异步操作
作用域	global, nonlocal	变量作用域声明
特殊操作	assert, del, pass, with, yield	调试/删除/占位/上下文/生成器
类定义	class	类对象定义
类型判断	is, in	成员检测与身份判断

这些保留字构成了Python程序的基本语法结构，如控制流程、数据类型、函数定义等。需要注意的是，Python是严格区分大小写的，保留字也不例外。例如，True和true是两个不同的标识符，其中True是保留字，而true不是。

3. 缩进

缩进规则

• 「缩进量」：通常使用4个空格作为一级缩进，也可使用一个制表符（Tab），但不可混用空格和制表符。

• 「一致性」：同一代码块中的语句必须保持相同的缩进量。

• 「代码块」：以冒号（:）结尾的语句（如if、for、def等）后，下一行开始缩进，表示新的代码块开始。

缩进的作用

• 「语法要求」：缩进是Python语法的一部分，不正确缩进会导致IndentationError。

• 「代码结构」：通过缩进清晰地表示代码块的包含和层次关系，提高代码的可读性。

• 「逻辑控制」：控制语句（如if、for、while等）中的缩进决定了代码的执行范围和逻辑结构。

注意事项

• 「避免过度嵌套」：过多的缩进层级会降低代码的可读性，应通过合理设计代码结构避免。

• 「编辑器设置」：使用支持Python的编辑器，可自动处理缩进，避免手动缩进错误。

• 「空行使用」：空行用于分隔不同功能的代码块，增强代码的可读性，但不影响缩进级别

4. 注释:单行注释,多行注释

单行注释

• 「语法」：以 # 开头，后接注释内容

• 「用法」：解释代码功能或临时禁用代码，可置于行尾或独立成行

• 「规范」：注释与代码间建议间隔两个空格，避免描述性重复内容

多行注释

• 「语法」：使用三对单引号（'''）或双引号（"""）包裹，或每行前加 #

• 「用法」：模块、函数、类的功能说明，复杂算法逻辑描述

• 「注意事项」：三引号形式可作为文档字符串（docstring），通过 「doc」 属性访问

5. 赋值

基础用法

• 「变量 = 表达式」：将右侧表达式计算结果赋予左侧变量，如 x = 10

序列解包

• 「多变量赋值」：通过逗号分隔同时赋值，如 a, b = 1, 2

• 「容器解包」：列表、元组等容器的元素拆解赋值，如 x, y = [3, 5]

链式赋值与增量赋值

• 「链式赋值」：单行内为多个变量赋予相同值，如 a = b = 0

• 「增量赋值」：运算符与等号结合简化运算，如 x += 1 等价于 x = x + 1

变量交换

• 「无需临时变量」：通过解包实现交换，如 a, b = b, a

注意事项

• 「可变对象引用」：赋值传递对象引用，修改可变对象（如列表）会影响所有引用

• 「深拷贝与浅拷贝」：对可变对象需显式使用 copy 或 deepcopy

6. 导入模块

常规导入

• 「导入整个模块」：import module1，使用时需带模块名前缀，如 module1.func()

别名导入

• 「简化模块名」：import module1 as alias，通过别名调用，如 alias.func()

指定成员导入

• 「导入特定函数/类」：from module1 import func，可直接调用 func()

• 「多个成员导入」：from module1 import func1, Class1

通配符导入

• 「导入全部公开成员」：from module1 import *，慎用以避免命名冲突

注意事项

• 「循环导入风险」：模块间相互导入可能导致逻辑错误

• 「命名空间污染」：优先使用模块名前缀或指定成员导入

• 「推荐实践」：避免通配符导入，明确导入所需成员或使用别名

2.2 数据类型与操作

1. 数字类型

Python中的数字类型主要包括整数（int）、浮点数（float）和复数（complex）。以下是这三种数字类型的详细介绍：

整数（int）

• 「定义」：整数是没有小数部分的数字，可以是正数、负数或零。

• 「表示方法」：直接书写数字，例如 x = 10。

• 「特点」：Python中的整数类型没有大小限制，可以表示任意大的整数。

• 「常用操作」：支持基本的算术运算，如加法、减法、乘法、除法（结果为浮点数）、整除、取余和幂运算。

浮点数（float）

• 「定义」：浮点数是带有小数部分的数字，用于表示实数。

• 「表示方法」：直接书写带小数点的数字，例如 y = 3.14，或者使用科学计数法，例如 z = 1.23e-4。

• 「特点」：浮点数的精度有限，遵循IEEE 754标准，可能会存在舍入误差。

• 「常用操作」：支持基本的算术运算，如加法、减法、乘法、除法等。

复数（complex）

• 「定义」：复数由实部和虚部组成，用于表示数学中的复数概念。

• 「表示方法」：使用 j 表示虚数单位，例如 z = 3 + 4j。

• 「特点」：Python内置了对复数的支持，可以进行复数的各种数学运算。

• 「常用操作」：支持基本的算术运算，如加法、减法、乘法、除法，以及复数的模、相位等运算。

类型转换

• 可以使用内置函数 int()、float() 和 complex() 进行类型转换。

• 例如，将浮点数转换为整数：x = int(3.14)，结果 x 为 3。

• 将整数转换为浮点数：y = float(10)，结果 y 为 10.0。

• 将实数转换为复数：z = complex(2)，结果 z 为 2+0j。

高精度计算

• 如果需要高精度的小数运算，可以使用 decimal 模块。

• 如果需要分数运算，可以使用 fractions 模块

2. 字符串

Python中的字符串是一种不可变的数据类型，用于表示文本信息。以下是关于Python字符串的一些重要知识点：

创建字符串

• 可以使用单引号（'）、双引号（"）或三引号（'''或"""）来创建字符串。

• 三引号允许创建多行字符串。

字符串特性

• 「不可变性」：字符串一旦创建，其内容不能被修改。任何看似修改字符串的操作实际上都会创建一个新的字符串对象。

• 「序列特性」：字符串支持索引和切片操作，可以通过索引访问单个字符，通过切片获取子串。

字符串操作

• 「拼接」：使用+运算符将两个字符串连接在一起。

• 「重复」：使用*运算符重复一个字符串。

• 「格式化」：使用%、str.format()或f-strings（Python 3.6+）来格式化字符串。

• 「方法」：字符串对象提供了丰富的方法，如upper()、lower()、strip()、split()、join()等，用于处理字符串。

转义字符

• 使用反斜杠（\）来转义特殊字符，如换行符（\n）、制表符（\t）等。

• 原始字符串通过在字符串前加上r或R来创建，忽略字符串中的转义字符。

字符串比较

• 可以使用比较运算符（如==、>、<等）来比较字符串。

• 字符串比较是基于字典顺序（lexicographical order）的。

字符串编码

• Python 3中的字符串默认使用Unicode编码，可以表示世界上几乎所有的字符。

• 可以使用encode()方法将字符串转换为字节串（bytes），使用decode()方法将字节串转换为字符串。

常用函数

• len()：返回字符串的长度。

• str()：将其他数据类型转换为字符串。

• str.upper()/str.lower()：转大写/小写

• str.strip()：去除首尾空格

• str.split(sep)：按分隔符分割字符串

• str.join(iterable)：用字符串连接可迭代对象

• str.replace(old, new)：替换子串

• str.isalnum()：判断是否全为字母或数字

• str.isdigit()：判断是否全为数字

3. 列表

Python列表（List）是一种有序、可变的数据集合，可以存储任意类型的对象，包括数字、字符串、其他列表等。以下是关于Python列表的详细介绍：

创建列表

• 使用方括号：my_list = [1, 2, 3, "apple"]

• 使用list()函数：empty_list = list() 或 list_from_tuple = list((1, 2, 3))

• 列表推导式：squares = [x**2 for x in range(1, 6)]

访问列表元素

• 通过索引访问：first_element = my_list

• 切片操作：sublist = my_list[1:3] 获取索引1到2的元素

列表操作

• 「添加元素」

◦ append()：在列表末尾添加一个元素，如 my_list.append(4)

◦ extend()：在列表末尾添加多个元素，如 my_list.extend()

◦ insert()：在指定位置插入元素，如 my_list.insert(1, "banana")

• 「删除元素」

◦ remove()：删除首个匹配的元素，如 my_list.remove("apple")

◦ pop()：删除并返回指定位置的元素，如 popped_item = my_list.pop(0)

◦ clear()：清空列表，如 my_list.clear()

• 「修改元素」

◦ 通过索引赋值，如 my_list = "orange"

• 「查询元素」

◦ index()：返回元素的索引，如 index = my_list.index("banana")

◦ count()：统计元素出现的次数，如 count = my_list.count(1)

列表方法

• sort()：对列表进行排序，如 my_list.sort()

• reverse()：反转列表元素顺序，如 my_list.reverse()

• len()：返回列表长度，如 length = len(my_list)

列表的特性

• 「有序性」：列表中的元素按照插入顺序排列。

• 「可变性」：列表创建后可以修改其内容。

• 「异构性」：列表可以包含不同类型的元素。

• 「动态性」：列表的大小可以自动调整。

• 「可迭代」：列表支持使用for循环进行遍历。

4. 元组

python元组（tuple）是一种不可变的有序序列，可以包含任意类型的元素，包括数字、字符串、列表、其他元组等。以下是关于Python元组的一些重要知识点：

创建元组

• 使用圆括号 () 来创建元组，元素之间用逗号 , 分隔。

• 如果元组只有一个元素，需要在元素后加逗号，否则会被视为普通数据类型。

• 可以使用 tuple() 函数将其他可迭代对象（如列表、字符串）转换为元组。

访问元组元素

• 通过索引访问元组中的元素，索引从0开始。

• 使用切片操作获取元组的子序列。

元组的不可变性

• 元组一旦创建，其元素不可被修改、添加或删除。

• 如果元组包含可变元素（如列表），可以修改这些可变元素内部的内容。

元组的常用操作

• 使用 + 运算符连接两个元组，生成新的元组。

• 使用 * 运算符重复元组元素，生成新的元组。

• 使用 len() 函数获取元组中元素的个数。

• 使用 count() 方法统计指定元素在元组中出现的次数。

• 使用 index() 方法查找指定元素在元组中首次出现的索引。

元组的应用场景

• 打包和解包：将多个值打包成一个元组，或将一个元组解包成多个变量。

• 交换变量值：通过元组打包和解包实现两个变量值的交换。

• 函数返回多个值：Python函数可以通过返回元组的方式返回多个值。

• 作为字典的键：由于元组是不可变的，可以作为字典的键使用。

注意事项

• 元组的不可变性使其在某些场景下比列表更安全，因为可以避免意外的修改。

• 在处理大量数据时，元组的性能通常优于列表，因为元组是不可变的，Python可以对其进行一些优化。

5. 字典

Python中的字典（dict）是一种无序的、可变的容器模型，用于存储键值对（key-value pairs）。字典是Python中非常重要的数据结构，具有以下几个特点：

创建字典

字典可以通过花括号{}来创建，键和值之间用冒号:分隔，键值对之间用逗号,分隔。例如：

my_dict = {"key1": "value1", "key2": "value2"}

访问字典中的值

可以通过键来访问字典中的值。如果键不存在，会抛出KeyError异常。为了避免这种情况，可以使用get()方法，它可以在键不存在时返回一个默认值。

value = my_dict["key1"]  # 直接访问
value = my_dict.get("key1", "default_value")  # 使用get()方法

修改和添加键值对

可以通过键来修改已有的值，或者添加新的键值对。

my_dict["key1"] = "new_value"# 修改值
my_dict["new_key"] = "new_value"# 添加新的键值对

删除键值对

可以使用del语句来删除字典中的键值对，或者使用pop()方法来删除并返回指定键的值。

del my_dict["key1"]  # 删除键值对
value = my_dict.pop("key2")  # 删除并返回指定键的值

字典的遍历

可以使用items()方法来遍历字典中的所有键值对，使用keys()方法遍历所有键，使用values()方法遍历所有值。

for key, value in my_dict.items():
    print(key, value)

for key in my_dict.keys():
    print(key)

for value in my_dict.values():
    print(value)

字典的特性

• 「键的唯一性」：字典中的键必须是唯一的，如果添加重复的键，后面的值会覆盖前面的值。

• 「键的不可变性」：字典的键必须是不可变的类型，如字符串、数字或元组。列表等可变类型不能作为字典的键。

• 「值的任意性」：字典的值可以是任意类型的对象，包括其他字典、列表等。

常用方法

• clear()：清空字典中的所有元素。

• copy()：返回字典的浅拷贝。

• update()：使用另一个字典或键值对更新当前字典。

• keys()、values()、items()：分别返回字典的所有键、所有值、所有键值对的视图对象。

• dict.clear()：清空字典

• dict.copy()：浅拷贝字典

• dict.get(key, default)：安全获取键值

• dict.items()：返回键值对视图

• dict.update(other_dict)：合并字典

6. 集合

Python中的集合（Set）是一种无序、可变且元素唯一的数据结构。以下是关于Python集合的详细介绍：

创建集合

• 使用花括号{}或set()函数创建。

• 创建空集合必须使用set()，因为{}表示空字典。

集合的特性

• 元素唯一性：集合中不会出现重复元素。

• 无序性：集合中的元素没有固定顺序。

• 可变性：集合可以添加或删除元素。

• 元素不可变：集合中的元素必须是不可变类型（如数字、字符串、元组），不能包含可变类型（如列表、字典）。

集合的操作

• 「添加元素」

◦ add(element)：添加单个元素。

◦ update(iterable)：添加多个元素，参数可以是列表、元组等可迭代对象。

• 「删除元素」

◦ remove(element)：删除指定元素，如果元素不存在会报错。

◦ discard(element)：删除指定元素，如果元素不存在不会报错。

◦ pop()：随机删除一个元素并返回该元素，集合为空时会报错。

◦ clear()：清空集合中的所有元素。

• 「集合运算」

◦ union(set)或|：返回两个集合的并集。

◦ intersection(set)或&：返回两个集合的交集。

◦ difference(set)或-：返回在第一个集合中但不在第二个集合中的元素。

◦ symmetric_difference(set)或^：返回两个集合的对称差集（只存在于其中一个集合的元素）。

• 「其他常用方法」

◦ len(set)：返回集合中元素的数量。

◦ in和not in：判断元素是否在集合中。

◦ copy()：返回集合的副本。

◦ issubset(set)和issuperset(set)：判断一个集合是否是另一个集合的子集或超集。

集合的遍历

由于集合是无序的，不能通过索引访问元素，但可以使用for循环遍历集合中的所有元素。

冰冻集合（Frozenset）

冰冻集合是不可变的集合，一旦创建就不能修改。可以使用frozenset()函数创建冰冻集合。冰冻集合可以作为字典的键或另一个集合的元素，因为它们是不可变的。

2.3 控制流程

1. if 语句

在Python中，if语句用于根据条件的真假来决定是否执行特定的代码块。Python中的if语句有几种形式：

if语句的基本形式

• 「单条件判断」：最基本的形式是if语句，它根据一个条件的真假来决定是否执行一段代码。

if 条件:
    条件成立时执行的代码

• 「双向条件判断」：if-else语句用于在条件不成立时执行另一段代码。

if 条件:
    条件成立时执行的代码
else:
    条件不成立时执行的代码

• 「多条件判断」：if-elif-else语句用于检查多个条件，并执行第一个为真的条件对应的代码块。如果所有条件都不成立，则执行else块中的代码（如果存在else块）。

if 条件1:
    条件1成立时执行的代码
elif 条件2:
    条件1不成立且条件2成立时执行的代码
else:
    所有条件都不成立时执行的代码

示例

• 「单条件判断示例」：检查一个数字是否为正数。

num = 10
if num > 0:
    print("这是一个正数")

• 「双向条件判断示例」：判断一个数字是正数还是负数。

num = -5
if num > 0:
    print("这是一个正数")
else:
    print("这是一个负数")

• 「多条件判断示例」：根据学生成绩判断等级。

score = 85
if score >= 90:
    print("优秀")
elif score >= 80:
    print("良好")
elif score >= 60:
    print("及格")
else:
    print("不及格")

注意事项

• Python使用缩进来定义代码块，通常使用4个空格作为缩进。

• if语句中的条件可以是任何返回布尔值的表达式，也可以使用比较运算符（如==, !=, >, <, >=, <=）和逻辑运算符（如and, or, not）来组合复杂的条件。

2. for 语句

Python中的for语句主要用于遍历序列（如列表、元祖、字符串）或其他可迭代对象（如字典、集合、生成器等）。以下是关于Python中for语句的详细介绍：

基本语法

Python中的for循环语法格式如下：

for item in iterable:
    # 执行循环体中的代码
    pass

遍历

• 遍历值：直接遍历序列中的每个元素。

fruits = ['apple', 'banana', 'cherry']
for fruit in fruits:
    print(fruit)

• 索引与值同时遍历：使用enumerate()函数可以同时获取元素的索引和值。

fruits = ['apple', 'banana', 'cherry']
for index, fruit in enumerate(fruits):
    print(f"Index: {index}, Fruit: {fruit}")

嵌套循环

for语句可以嵌套使用，形成多层循环，常用于处理二维数组等复杂数据结构。

matrix = [
    ,
    ,
    
]
for row in matrix:
    for element in row:
        print(element, end=' ')
    print()

跳出循环

Python提供了break和continue语句来控制循环的流程。 • break：立即终止循环。

for i in range(10):
    if i == 5:
        break
    print(i)

• continue：跳过当前迭代，继续下一次迭代。

for i in range(10):
    if i % 2 == 0:
        continue
    print(i)

结合 range() 函数

range()函数常用于生成一个整数序列，与for循环结合使用可以控制循环次数。

for i in range(5):
    print(i)

for... else 语句

在Python中，for循环可以结合else语句使用。当循环正常执行完毕（即没有被break语句中断）时，else语句块会被执行。

for num in range(10, 20):
    for i in range(2, num):
        if num % i == 0:
            print(f'{num} 是合数')
            break
    else:
        print(f'{num} 是质数')

示例

计算列表元素的和：

numbers = 
total = 0
for num in numbers:
    total += num
print(f"列表的总和是：{total}")

3. while 语句

Python 中的 while 语句是一种用于实现循环结构的控制流语句，它在指定条件为真（True）时，重复执行一段代码块，直到条件变为假（False）为止。

基本语法

while 条件表达式:
    循环体（要重复执行的代码）

• 「条件表达式」：每次循环开始前都会被评估。如果为真，循环体就会被执行；如果为假，循环就会终止。

• 「循环体」：包含要重复执行的语句，必须缩进（通常 4 个空格）。

执行流程

首先判断“条件表达式”的值。
如果为真（True），则执行“循环体”中的代码。
执行完后，再次判断条件表达式，如果仍为真，则继续执行循环体。
重复以上步骤，直到条件表达式为假（False），循环结束。

简单示例

count = 0
while count < 5:
    print(count)
    count += 1

输出：

4无限循环与退出

• 如果条件表达式始终为真（如 while True:），循环将无限执行，称为“死循环”。

• 可以使用 break 语句提前退出循环。

• 使用 continue 语句跳过当前循环的剩余代码，直接进入下一次循环。

循环的 else 子句

Python 的 while 循环可以搭配 else 子句使用。当循环条件变为假（False）时（即循环正常结束），else 子句中的代码会被执行。但如果循环被 break 语句中断，则 else 子句不会执行。

count = 0
while count < 3:
    print(count)
    count += 1
else:
    print("循环结束")

输出：

0
1
2

循环结束注意事项

• 「避免死循环」*：确保循环条件在某次迭代后变为假，否则循环将无法结束。

• 「缩进」：循环体内的代码必须缩进，否则会引发语法错误。

2.4 输入输出

1. print

Python中的print函数用于将指定对象输出到标准文本流（通常是控制台）。其基本语法为：

print(*objects, sep=' ', end='\n', file=None, flush=False)

参数说明 • objects：要打印的一个或多个对象，可以是字符串、数字或其他数据类型。多个对象之间用逗号分隔。

• sep：用于分隔多个对象的字符串，默认为空格。

• end：打印结束后附加的字符串，默认为换行符\n。

• file：指定输出的文件对象，默认为标准输出（控制台）。

• flush：布尔值，指定是否立即刷新输出流，默认为False。

用法示例

打印单个对象

print("Hello, World!")

输出：

Hello, World!

2.打印多个对象

name = "Alice"
age = 30
print("My name is", name, "and I am", age, "years old.")

输出：

My name is Alice and I am 30 years old.

使用sep参数自定义分隔符

fruits = ["apple", "banana", "cherry"]
print(*fruits, sep=", ")

输出：

apple, banana, cherry

使用end参数控制打印结束符

print("Hello", end=" ")
print("World!")

输出：

Hello World!

打印到文件

withopen("output.txt", "w") as f:
    print("Hello, World!", file=f)

使用格式化输出

◦ 使用占位符

name = "Alice"
age = 30
print("My name is %s and I am %d years old." % (name, age))

◦ 使用format方法

name = "Alice"
age = 30
print("My name is {} and I am {} years old.".format(name, age))

注意事项

• 在Python 2.x中，print是一个语句，而在Python 3.x中，print是一个函数。

• 标点符号需在英文状态下输入，否则可能导致语法错误。

2. 格式化

Python中主要有三种字符串格式化方法：

百分号（%）格式化

• 语法：使用%符号作为占位符，后面跟格式说明符（如%s表示字符串，%d表示整数）。

• 示例："Name: %s, Age: %d" % (name, age)。

• 优点：兼容旧版Python。

• 缺点：存在类型错误风险，如%d传入字符串会报错。

str.format()方法

• 语法：使用{}作为占位符，支持位置参数和关键字参数。

• 示例："{} is {}".format("Python", "awesome")或"{name} is {adj}".format(name="Python", adj="flexible")。

• 优点：功能强大且灵活，可控制数字格式、对齐与填充、类型转换等。

• 缺点：语法相对复杂。

f-string（格式化字符串字面值）

• 语法：在字符串前加f或F，在字符串中使用{}插入变量或表达式。

• 示例：f"Hello, {name}!"。

• 优点：语法简洁、性能高、可读性强，支持任意表达式。

• 缺点：仅支持Python 3.6及以上版本。

建议：在新项目中推荐使用f-string，因其简洁高效；维护旧项目时，根据Python版本选择%格式化或str.format()方法。

3. 文件操作

Python中的文件操作主要包括文件的读取、写入、追加、修改以及文件的基本管理操作。以下是Python文件操作的基本指南：

打开文件

Python中使用open()函数打开文件，该函数接受两个主要参数：文件名和打开模式。

file = open('filename.txt', 'ode')

打开模式

• r：只读模式（默认），文件必须存在。

• w：写入模式，如果文件存在则清空内容，不存在则创建新文件。

• a：追加模式，在文件末尾添加内容，不存在则创建新文件。

• x：创建模式，文件不存在则创建，存在则报错。

• b：二进制模式，用于处理非文本文件（如图片、音频）。

• +：读写模式，可与r、w、a组合使用。

文件读取

• read()：读取整个文件内容。

• readline()：读取一行内容。

• readlines()：读取所有行，返回一个列表，每个元素为一行。

withopen('example.txt', 'r') as file:
    content = file.read()  # 读取整个文件
    lines = file.readlines()  # 读取所有行

文件写入

• write(text)：写入文本内容。

• writelines(lines)：写入多行文本，参数为字符串列表。

withopen('example.txt', 'w') as file:
    file.write('Hello, Python!')  # 写入文本
    file.writelines(['Line 1\n', 'Line 2\n'])  # 写入多行

文件追加

withopen('example.txt', 'a') as file:
    file.write('Appending new content.')  # 追加内容

文件指针操作 • seek(offset, whence)：移动文件指针位置。

• tell()：返回当前文件指针位置。

withopen('example.txt', 'r') as file:
    file.seek(10, 0)  # 移动到文件开头第10个字节
    position = file.tell()  # 获取当前指针位置

上下文管理器

使用with语句可以自动管理文件的打开和关闭，确保文件在使用后正确关闭，避免资源泄露。

文件管理

Python还提供了许多用于文件管理的函数，如os模块中的rename()、remove()等，用于重命名和删除文件。

import os
os.rename('oldname.txt', 'newname.txt')  # 重命名文件
os.remove('file.txt')  # 删除文件

注意事项

• 确保文件路径正确，特别是在不同操作系统下路径分隔符可能不同。

• 处理大文件时，避免一次性读取全部内容到内存，使用逐行读取或分块读取的方式。

• 文件操作完成后，及时关闭文件以释放系统资源。

2.5 函数

Python中的函数是组织好的、可重复使用的代码块，用于执行特定的任务。函数可以提高代码的模块性和可读性，同时便于代码的复用。以下是关于Python函数的详细说明：

1. 函数定义

• 语法：

  def 函数名(参数列表):  
      """文档字符串"""  
      函数体  
      return 返回值

2.函数调用

函数的调用是通过函数名后跟括号来完成的，括号内可以包含传递给函数的参数。例如：

函数名(参数1, 参数2,...)

3. 参数类型

• 「位置参数」：按照参数定义的顺序传递参数。

• 「关键字参数」：通过参数名来传递参数，可以不按照参数定义的顺序。

• *「默认参数」：在函数定义时可以为参数设置默认值，调用函数时如果没有传递该参数，则使用默认值

• 「不定长参数」：可以接收任意数量的参数，通过在参数名前加*来定义。*args（元组）和 **kwargs（字典）

4. 变量作用域

• 「局部变量」：函数内定义，仅在函数内有效

• 「全局作用域global」：在函数外部定义的变量，可以在整个程序范围内访问。

• 「内建作用域」：Python内置的函数和变量，如print、len等，可以在任何地方访问。

• 「嵌套作用域」：在嵌套函数中，内部函数可以访问外部函数的变量

5.返回值

函数可以通过return语句返回一个值，如果没有return语句，函数默认返回None。返回值可以是任何Python对象，包括基本数据类型、列表、字典等。

示例

下面是一个包含上述概念的示例函数：

defgreet(name, message="Hello"):  # 默认参数
    print(f"{message}, {name}!")  # 局部变量
# 函数调用
greet("Alice")  # 输出 "Hello, Alice!"
greet("Bob", message="Hi")  # 输出 "Hi, Bob!"
# 全局变量
greeting = "Welcome"
defchange_greeting():
    global greeting  # 声明使用全局变量
    greeting = "Goodbye"

change_greeting()
print(greeting)  # 输出 "Goodbye"

2.6 类

在Python中，类是面向对象编程的核心概念，它允许用户定义新的数据类型，这些数据类型可以包含数据和操作数据的方法。以下是关于Python类的详细解释：

类的定义：实例方法，类方法和静态方法

• 「实例方法」：实例方法是与类的实例相关联的方法，它们通过实例来调用，第一个参数通常是self，代表调用该方法的实例本身。实例方法可以访问和修改实例的属性。

• 「类方法」：类方法是与类本身相关联的方法，而不是与类的实例相关联。类方法使用@classmethod装饰器来定义，第一个参数通常是cls，代表类本身。类方法可以访问和修改类的属性，但不能访问实例属性。

• 「静态方法」：静态方法是不与类的实例或类本身相关联的方法，它们使用@staticmethod装饰器来定义。静态方法不接收self或cls作为第一个参数，它们通常用于执行与类相关的独立任务，不依赖于类的状态。

  class 类名:  
      def __init__(self, 参数):  # 构造方法  
          self.属性 = 参数  
      @classmethod  
      def 类方法(cls): ...  # 类方法  
      @staticmethod  
      def 静态方法(): ...  # 静态方法

类的属性和方法

• 「类属」性：类属性是属于类本身的属性，所有类的实例共享这些属性。类属性在类定义中直接定义，可以通过类或实例来访问，但通常通过类来修改。

• 「实例属性」：实例属性是属于类的实例的属性，每个实例都有自己的实例属性。实例属性通常在__init__方法或其他实例方法中定义，通过实例来访问和修改。

• 「方法」：方法是类中定义的函数，用于执行特定的操作。除了实例方法、类方法和静态方法外，Python还支持其他类型的方法，如构造函数__init__（用于初始化实例）和析构函数__del__（用于清理实例）等。

类的继承

• 「继承」：继承是面向对象编程中的一个重要概念，它允许一个类（子类或派生类）继承另一个类（父类或基类）的属性和方法。子类可以重写父类的方法，也可以添加新的方法或属性。

• 「多重继承」：Python支持多重继承，即一个类可以继承多个父类。这在设计复杂的数据类型时非常有用，但也需要小心处理，以避免命名冲突和复杂性增加。

通过类和继承，Python提供了强大的面向对象编程能力，使得代码更加模块化、可重用和易于维护。

2.7 推导式

Python中的推导式是一种简洁的语法，用于从一个数据序列中创建新的数据序列。Python支持多种数据结构的推导式，包括列表、字典、集合和元组。以下是它们的基本用法：

列表推导式

列表推导式用于从一个可迭代对象中创建新的列表。基本语法如下：

[表达式 for 变量 in 可迭代对象 if 条件]

• 表达式：用于计算新列表中每个元素的值。

• 变量：迭代可迭代对象时的每个元素。

• 可迭代对象：任何可迭代的数据结构，如列表、元组、字符串等。

• 条件（可选）：用于筛选满足条件的元素。

示例：

# 生成1到10的平方列表
squares = [x**2 for x in range(1, 11)]
print(squares)  # 输出 
# 过滤出列表中的偶数
numbers = even_numbers = [x for x in numbers if x % 2 == 0]
print(even_numbers)  # 输出

字典推导式

字典推导式用于从一个可迭代对象中创建新的字典。基本语法如下：

{键表达式: 值表达式 for 变量 in 可迭代对象 if 条件}

• 键表达式：用于计算新字典中每个键的值。 • 值表达式：用于计算新字典中每个值的值。 • 变量：迭代可迭代对象时的每个元素。 • 可迭代对象：任何可迭代的数据结构。 • 条件（可选）：用于筛选满足条件的元素。

示例：

# 创建一个字典，键是1到5的数字，值是数字的平方
squares_dict = {x: x**2 for x in range(1, 6)}
print(squares_dict)  # 输出 {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# 将列表中的字符串作为键，字符串长度作为值
words = ['apple', 'banana', 'cherry']
word_lengths = {word: len(word) for word in words}
print(word_lengths)  # 输出 {'apple': 5, 'banana': 6, 'cherry': 6}

元组推导式（生成器表达式）

元组推导式实际上生成的是一个生成器对象，而不是一个元组。生成器对象是一种迭代器，可以按需生成值，从而节省内存。基本语法如下：

(表达式 for 变量 in 可迭代对象 if 条件)

• 表达式：用于计算生成器对象中每个元素的值。 • 变量：迭代可迭代对象时的每个元素。 • 可迭代对象：任何可迭代的数据结构。 • 条件（可选）：用于筛选满足条件的元素。示例：

# 生成1到10的平方的生成器对象
squares_gen = (x**2 for x in range(1, 11))
print(squares_gen)  # 输出 <generator object <genexpr> at 0x7f1234567890>

# 遍历生成器对象
for square in squares_gen:
    print(square)  # 依次输出1到10的平方

# 将生成器对象转换为元组
squares_tuple = tuple(x**2 for x in range(1, 11))
print(squares_tuple)  # 输出 (1, 4, 9, 16, 25, 36, 49, 64, 81, 100)

需要注意的是，生成器对象只能迭代一次，迭代后原生成器对象将不复存在。

集合推导式

集合推导式用于从一个可迭代对象中创建新的集合。基本语法如下：

{表达式 for 变量 in 可迭代对象 if 条件}

• 表达式：用于计算新集合中每个元素的值。 • 变量：迭代可迭代对象时的每个元素。 • 可迭代对象：任何可迭代的数据结构。 • 条件（可选）：用于筛选满足条件的元素。

示例：

# 生成1到10的平方的集合
squares_set = {x**2 for x in range(1, 11)}
print(squares_set)  # 输出 {1, 4, 9, 16, 25, 36, 49, 64, 81, 100}

# 过滤出列表中的偶数并去重
numbers = even_numbers_set = {x for x in numbers if x % 2 == 0}
print(even_numbers_set)  # 输出 {2, 4, 6, 8, 10}

2.8 装饰器

Python中的装饰器是一种强大的工具，用于在不修改原始函数或类代码的情况下，动态地添加或修改功能。以下是关于Python装饰器的基本概论以及函数装饰器和类装饰器的基本用法：

基本概论

• 「函数即对象」：在Python中，函数是一等公民，这意味着它们可以被赋值给变量，作为参数传递给其他函数，或者作为返回值从函数中返回。

• 「闭包」：闭包是指内部函数引用了外部函数的变量。即使外部函数已经返回，内部函数仍然可以访问这些变量。

• 「装饰器」：装饰器本质上是一个函数或类，它接收一个函数或类作为参数，并返回一个新的函数或类。装饰器可以在不修改原始代码的情况下，为函数或类添加额外的功能。

函数装饰器的基本用法

函数装饰器用于增强函数的行为。它们通过在函数定义前使用@decorator_name语法来应用。

1. 基本语法

def decorator_function(original_function):
    def wrapper(*args, **kwargs):
        # 在调用原始函数之前做的事情
        result = original_function(*args, **kwargs)
        # 在调用原始函数之后做的事情
        return result
    return wrapper

# 使用装饰器
@decorator_function
def target_function():
    pass

2. 示例：一个简单的装饰器，用于记录函数的执行时间。

import time

def timing_decorator(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        duration = end_time - start_time
        print(f"函数 {func.__name__} 执行时间为：{duration:.6f} 秒")
        return result
    return wrapper

@timing_decorator
def some_function():
    # 函数的具体实现pass

some_function()  # 调用函数时，装饰器会自动记录执行时间

类装饰器的基本用法

类装饰器用于增强类的行为。它们通过在类定义前使用@decorator_name语法来应用。

1. 基本语法

class DecoratorClass:
    def__init__(self, original_class):
        self.original_class = original_class

    def__call__(self, *args, **kwargs):
        # 在创建类实例之前做的事情
        instance = self.original_class(*args, **kwargs)
        # 在创建类实例之后做的事情
        return instance

# 使用类装饰器
@DecoratorClass
class TargetClass:
    pass

2. 示例：一个简单的类装饰器，用于记录类的初始化次数。

classCountInit:
    def__init__(self, original_class):
        self.original_class = original_class
        self.init_count = 0
    def__call__(self, *args, **kwargs):
        self.init_count += 1
        print(f"类 {self.original_class.__name__} 初始化次数：{self.init_count}")
        return self.original_class(*args, **kwargs)

@CountInit
class MyClass:
    def__init__(self):
        # 类的初始化代码pass

instance1 = MyClass()  # 创建实例时，装饰器会自动记录初始化次数
instance2 = MyClass()

通过使用装饰器，可以在不修改原始代码的情况下，为函数或类添加额外的功能，如日志记录、性能测试、权限验证等。装饰器是Python中实现代码复用和解耦的重要工具。

2.9 模块和包

Python中的模块和包是组织代码、实现代码复用以及管理项目结构的重要概念。以下是关于模块和包的详细解释：

模块

定义 ◦ 模块是一个以.py 为扩展名的 Python 源码文件，其中可以包含变量、函数、类等 Python 对象。
使用方法 ◦ 导入模块：使用 import 模块名语句导入模块，然后可以通过模块名.对象名的方式访问模块中的对象。 ◦ 导入模块中的特定对象：使用 from 模块名 import 对象名语句，可以直接在代码中使用该对象，无需通过模块名访问。 ◦ 给模块起别名：使用 import 模块名 as 别名或 from 模块名 import 对象名 as 别名语句，可以为模块或模块中的对象起一个别名，方便使用。

包

定义 ◦ 包是一个包含有__init__.py 文件的目录或文件夹，用于组织模块。
创建和使用方法 ◦ 创建包：创建一个文件夹，并在其中添加一个__init__.py 文件，该文件可以为空，也可以包含一些初始化代码。 ◦ 导入包：使用 import 包名语句导入包，然后可以通过包名.模块名的方式访问包中的模块。 ◦ 导入包中的模块：使用 from 包名 import 模块名语句，可以直接访问包中的模块。 ◦ 导入包中的子包：如果包中包含子包，可以使用 from 包名.子包名 import 模块名语句导入子包中的模块。

2.10 正则表达式

re模块常用方法

• re.match(pattern, string)：从字符串的开头开始匹配，如果开头不符合正则表达式，则匹配失败，返回None。

• re.search(pattern, string)：在字符串中搜索匹配正则表达式的第一个位置，只要找到一处匹配就返回匹配对象。

• re.findall(pattern, string)：搜索字符串，返回所有匹配正则表达式的非重叠结果列表。

• re.sub(pattern, repl, string)：替换字符串中所有匹配正则表达式的部分，返回替换后的新字符串。

• re.split(pattern, string)：根据正则表达式匹配的模式来分割字符串，返回分割后的列表。

正则表达式可选标志

• re.I：忽略大小写，进行匹配时忽略字符串和模式中的大小写差异。

• re.L：根据本地语言环境进行匹配，影响\w, \W, \b, \B等字符类。

• re.M：多行模式，^和$分别匹配每行的开头和结尾。

正则表达式模式

• ^：匹配字符串的开头。

• $：匹配字符串的结尾。

• .：匹配除换行符之外的任意单个字符。

• \w：匹配任何字母数字字符，等价于[a-zA-Z0-9_]。

• \s：匹配任何空白字符，包括空格、制表符、换页符等。

正则表达式实例

• 字符匹配：直接匹配指定的字符，例如'a'匹配字符a。

• 字符类：用[]定义一组字符，例如'[abc]'匹配a、b或c中的任意一个字符。

• 特殊字符类：如\d匹配任何数字，\D匹配任何非数字字符。

2.11 异常捕获

异常类型

Python中常见的异常类型包括但不限于以下几种： • SyntaxError：当Python解释器遇到语法错误时引发，例如缺少冒号、括号不匹配等。

• NameError：尝试访问一个未定义的变量时引发。

• ZeroDivisionError：当除数为零时引发。

• TypeError：当操作或函数应用于不适当类型的对象时引发，例如尝试连接字符串和整数。

• IndexError：当使用超出序列范围的索引时引发。

• KeyError：当尝试访问字典中不存在的键时引发。

• ValueError：当传入函数的参数类型正确但值不适当引发。

• IOError：当发生输入输出错误时引发，例如尝试打开不存在的文件。

• AttributeError：当尝试访问对象不存在的属性或方法时引发。

异常捕获

Python使用try和except语句来捕获和处理异常。try语句块包含可能引发异常的代码，而except语句块用于处理捕获到的异常。基本语法如下：

try:
    # 可能引发异常的代码
    result = 10 / 0
except ZeroDivisionError:
    # 处理特定异常print("除数不能为零")
except (TypeError, ValueError) as e:
    # 处理多种异常print(f"类型或值错误: {e}")
except Exception as e:
    # 处理所有其他异常print(f"发生未知错误: {e}")
else:
    # 如果没有异常发生，执行此代码块print("一切正常")
finally:
    # 无论是否发生异常，都会执行此代码块print("清理工作完成")

抛出异常

Python中的raise语句用于主动抛出异常。可以使用内置的异常类，也可以自定义异常类。抛出异常的基本语法如下：

raise Exception("这是一个异常")

或者自定义异常：

classMyCustomError(Exception):
    def__init__(self, message):
        super().__init__(message)

raise MyCustomError("自定义异常")

2.12 常用库

os

Python的os模块提供了与操作系统进行交互的功能，是Python标准库中最常用的模块之一。它允许开发者访问和操作文件系统、环境变量、进程管理等底层操作系统功能，使代码能够在不同平台上保持一致的行为。

os.path

os.path是os模块的一个子模块，提供了跨平台的路径处理功能，避免手动拼接路径导致的错误。例如，os.path.join()可以智能地拼接路径，os.path.abspath()可以获取路径的绝对形式，os.path.dirname()和os.path.basename()分别返回路径的目录部分和文件名部分。