一、Python 简介

Python 是一种高级、解释型、通用的编程语言，由 Guido van Rossum 于 1989 年底发明，并于 1991 年首次发布。它以其简洁、易读、易维护的语法而闻名，被誉为 “优雅的编程语言”。Python 采用缩进来表示代码块，这使得代码的结构更加清晰，可读性更强。同时，Python 拥有丰富的标准库和第三方库，这些库涵盖了各种领域，如 Web 开发、数据科学、人工智能、网络编程等，可以大大提高开发效率。

在 Web 开发领域，Python 拥有许多强大的 Web 框架，如 Django、Flask 等。Django 是一个功能强大的 Web 框架，它遵循 “约定优于配置” 的原则，提供了丰富的功能和工具，如内置的数据库管理、用户认证、表单处理等，适合开发大型、复杂的 Web 应用程序。Flask 则是一个轻量级的 Web 框架，它更加灵活，开发者可以根据自己的需求选择和配置插件，适合开发小型、快速迭代的 Web 应用或微服务。

在数据科学领域，Python 已经成为了事实上的标准语言。它拥有众多优秀的数据处理和分析库，如 NumPy、Pandas、Matplotlib 和 Seaborn 等。NumPy 提供了高效的多维数组操作功能，是 Python 科学计算的基础库。Pandas 则提供了灵活的数据结构和数据处理工具，使得数据的读取、清洗、转换和分析变得更加便捷。Matplotlib 和 Seaborn 是常用的数据可视化库，它们可以帮助开发者将数据以直观的图表形式展示出来，便于理解和分析数据中的规律和趋势。

在人工智能和机器学习领域，Python 同样占据着重要的地位。Scikit-learn 是一个广泛使用的机器学习库，它提供了丰富的机器学习算法和工具，包括分类、回归、聚类、降维等，使得开发者可以轻松地构建和评估机器学习模型。而 TensorFlow 和 PyTorch 则是深度学习领域的两大主流框架，它们提供了高效的神经网络构建和训练功能，支持 GPU 加速，广泛应用于图像识别、自然语言处理、语音识别等领域 。

除此之外，Python 在网络爬虫、自动化脚本、游戏开发、科学计算等领域也有着广泛的应用。其强大的功能和丰富的库生态系统，使得它成为了众多开发者的首选编程语言之一。

二、环境搭建

在开始使用 Python 进行开发之前，我们需要先搭建好 Python 的开发环境。下面将分别介绍在 Windows、MacOS 和 Linux 系统下安装 Python 和常用开发工具 PyCharm 的步骤。

Windows 系统

1. 下载 Python 安装包：

• • 打开浏览器，访问 Python 官方网站：Python Releases for Windows | Python.org 。

• • 在下载页面中，根据你的系统是 32 位还是 64 位，选择对应的 Python 安装包下载。通常建议下载最新的稳定版本。

1. 安装 Python：

• • 下载完成后，双击安装包进行安装。在安装向导界面，勾选 “Add Python to PATH” 选项，这样安装程序会自动将 Python 添加到系统环境变量中，方便后续在命令行中使用 Python 命令。

• • 点击 “Install Now” 进行默认安装，或者点击 “Customize installation” 来自定义安装路径和其他安装选项。

• • 等待安装完成，安装过程中可能会提示安装一些依赖组件，按照提示操作即可。

1. 配置环境变量（若未自动配置）：

• • 如果在安装时没有勾选 “Add Python to PATH”，则需要手动配置环境变量。

• • 右键点击 “此电脑”，选择 “属性”。

• • 在弹出的窗口中，点击 “高级系统设置”。

• • 在 “系统属性” 窗口中，点击 “环境变量” 按钮。

• • 在 “系统变量” 中找到 “Path” 变量，点击 “编辑”。

• • 点击 “新建”，添加 Python 的安装路径（例如：C:\Python310）和 Python 安装目录下的 Scripts 文件夹路径（例如：C:\Python310\Scripts ），然后点击 “确定” 保存设置。

1. 验证 Python 安装：

• • 按下 Win + R 键，打开运行窗口，输入 “cmd” 并回车，打开命令提示符。

• • 在命令提示符中输入 “python --version”，如果显示安装的 Python 版本号，说明 Python 安装成功。

• • 也可以输入 “python”，进入 Python 交互式环境，尝试输入一些简单的 Python 代码，如 “print ('Hello, Python!')”，来验证 Python 是否可以正常运行。

1. 安装 PyCharm：

• • 访问 JetBrains 官网：Download PyCharm: The Python IDE for data science and web development by JetBrains ，下载适合 Windows 系统的 PyCharm 安装包。有社区版（Community Edition）和专业版（Professional Edition）可供选择，社区版免费且功能对于初学者和一般开发足够使用。

• • 下载完成后，双击安装包进行安装。按照安装向导的提示，选择安装路径、创建桌面快捷方式等选项，然后点击 “Install” 进行安装。

• • 安装完成后，打开 PyCharm，按照提示进行初始设置，如选择主题、配置插件等。

MacOS 系统

1. 检查预装 Python 版本：

• • 打开 “终端” 应用程序（可以通过在 “聚焦搜索” 中输入 “终端” 来找到它）。

• • 在终端中输入 “python --version” 或 “python3 --version”，查看系统预装的 Python 版本。MacOS 通常预装了 Python 2.x 版本，而我们一般希望使用 Python 3.x，所以可能需要安装新版本。

1. 下载 Python 安装包：

• • 打开浏览器，访问 Python 官方网站：Python Releases for macOS | Python.org 。

• • 选择适合 MacOS 系统的 Python 安装包下载，一般选择最新的稳定版本。

1. 安装 Python：

• • 下载完成后，双击下载的.pkg 文件，启动 Python 安装程序。

• • 按照安装向导的提示，点击 “继续” 并接受许可协议进行安装。在安装选项中，确保勾选了 “Install launcher” 和 “Add to PATH”（如果提供这些选项）。

1. 验证 Python 安装：

• • 打开终端，再次输入 “python3 --version”，如果显示安装的 Python 3 版本号，说明安装成功。

• • 也可以输入 “python3”，进入 Python 3 交互式环境进行测试。

1. 配置环境变量（如果需要）：

• • 在大多数情况下，Python 安装程序会自动将 Python 添加到环境变量中。但如果有需要手动配置的情况：

• • 打开终端，输入 “nano ~/.bash_profile”（如果使用的是 zsh shell，则输入 “nano ~/.zshrc” ）。

• • 在打开的文件中，添加以下行（根据你的 Python 安装路径调整）：export PATH="/usr/local/bin/python3:$PATH" 。

• • 按下 Ctrl + X，然后按 Y 键保存更改，最后按回车键退出。

• • 输入 “source ~/.bash_profile”（或 “source ~/.zshrc” ）使更改生效。

1. 安装 PyCharm：

• • 访问 JetBrains 官网下载页面：Download PyCharm: The Python IDE for data science and web development by JetBrains ，下载适用于 MacOS 的 PyCharm 安装包。

• • 下载完成后，将下载的 dmg 文件中的 PyCharm 图标拖动到 “应用程序” 文件夹中进行安装。

• • 打开 PyCharm，按照提示进行初始设置。

Linux 系统（以 Ubuntu 为例）

1. 检查预装 Python 版本：

• • 打开终端，输入 “python --version” 或 “python3 --version”，查看系统预装的 Python 版本。Ubuntu 系统一般预装了 Python 2 和 Python 3。

1. 安装 Python（如果需要更新版本）：

sudo apt update

sudo apt install python3 python3-pip

# 安装依赖包

sudo apt install build - essential zlib1g - dev libncurses5 - dev libgdbm - dev libnss3 - dev libssl - dev libreadline - dev libffi - dev wget

# 下载Python源代码

wget https://www.python.org/ftp/python/3.10.0/Python-3.10.0.tgz

# 解压源代码

tar -xvzf Python-3.10.0.tgz

# 进入解压目录

cd Python-3.10.0

# 配置安装路径等

• • 对于 Ubuntu 系统，可以使用包管理器 apt 来安装 Python 3。打开终端，输入以下命令安装 Python 3：

• • 如果需要安装特定版本的 Python，可以从 Python 官网下载源代码，然后进行编译安装。以下是安装 Python 3.10 的示例步骤：

./configure --enable-optimizations --prefix=/usr/local/python310

编译

make

安装

sudo make install

3. **配置环境变量（如果需要）**：

- 如果编译安装到自定义路径，需要配置环境变量。打开终端，输入“nano ~/.bashrc”。

- 在文件末尾添加以下行（根据你的Python安装路径调整）：`export PATH="/usr/local/python310/bin:$PATH"` 。

- 按下Ctrl + X，然后按Y键保存更改，最后按回车键退出。

- 输入“source ~/.bashrc”使更改生效。

4. **验证Python安装**：

- 在终端中输入“python3 --version”，如果显示安装的Python 3版本号，说明安装成功。

- 也可以输入“python3”进入Python 3交互式环境进行测试。

5. **安装PyCharm**：

- 访问JetBrains官网下载页面：https://www.jetbrains.com/pycharm/download/ ，下载适用于Linux的PyCharm安装包（通常是一个tar.gz压缩包）。

- 下载完成后，解压压缩包到你希望安装的目录，例如：

```bash

tar -xvzf pycharm-community-2023.2.tar.gz -C /opt/

• 进入解压后的目录，找到 bin 目录下的 pycharm.sh 文件，执行以下命令启动 PyCharm：

cd /opt/pycharm-community-2023.2/bin

./pycharm.sh

• 首次启动时，按照提示进行初始设置。

通过以上步骤，你应该已经在不同操作系统上成功搭建了 Python 开发环境并安装了 PyCharm 开发工具，接下来就可以开始愉快地进行 Python 编程之旅了。

三、基础语法

（一）变量与数据类型

在 Python 中，变量是用于存储数据的标识符，就像是一个可以装各种数据的盒子 。它不需要提前声明数据类型，直接赋值即可创建变量。例如：

name = "张三" # 创建一个字符串类型的变量name，存储值为"张三"

age = 25 # 创建一个整数类型的变量age，存储值为25

height = 1.75 # 创建一个浮点数类型的变量height，存储值为1.75

is_student = True # 创建一个布尔类型的变量is_student，存储值为True

Python 中常见的数据类型有：

• 整数（int）：用于表示整数，如1、-5、100等。Python 3.x 可以处理任意大小的整数，并且支持二进制（以0b开头）、八进制（以0o开头）和十六进制（以0x开头）的表示方式。例如：

binary_num = 0b1010 # 二进制整数，对应十进制的10

octal_num = 0o12 # 八进制整数，对应十进制的10

hexadecimal_num = 0xA # 十六进制整数，对应十进制的10

• 浮点数（float）：表示带有小数点的数字，如3.14、-0.5、1.23e-4（科学计数法表示，等同于0.000123）等。需要注意的是，浮点数在计算机中存储时可能存在精度问题，例如：

x = 0.1 + 0.2

print(x) # 输出结果可能不是0.3，而是接近0.3的一个近似值，如0.30000000000000004

如果需要精确的小数运算，可以使用decimal模块：

from decimal import Decimal

x = Decimal('0.1') + Decimal('0.2')

print(x) # 输出0.3

• 字符串（str）：用于存储文本数据，可以使用单引号（'）、双引号（"）或三引号（'''或"""）来创建字符串。单引号和双引号创建的字符串功能基本相同，三引号常用于创建多行字符串。例如：

single_quote_str = '这是一个单引号字符串'

double_quote_str = "这是一个双引号字符串"

multi_line_str = '''这是一个

多行字符串，

可以跨越多行书写。'''

字符串还支持很多有用的操作方法，如拼接、切片、查找等。例如：

str1 = "Hello"

str2 = "World"

concatenated_str = str1 + ", " + str2 # 字符串拼接

print(concatenated_str) # 输出Hello, World

sub_str = concatenated_str[0:5] # 切片，获取索引0到4（不包括5）的子字符串

print(sub_str) # 输出Hello

find_index = concatenated_str.find("World") # 查找子字符串"World"的位置

print(find_index) # 输出6，如果找不到则返回-1

• 布尔值（bool）：只有两个值True和False，用于表示逻辑判断的结果，通常在条件语句和循环语句中使用。例如：

a = 5

b = 3

result = a > b # 比较a是否大于b，结果为True

print(result) # 输出True

数据类型转换在编程中也经常用到，Python 提供了一些内置函数来实现数据类型的转换：

• int()：将一个数值或数值表示的字符串转换成整数。例如：

num_str = "10"

num_int = int(num_str)

print(num_int, type(num_int)) # 输出10 <class 'int'>

• float()：将一个数值表示字符串或者int型转换成浮点数。例如：

num_str = "3.14"

num_float = float(num_str)

print(num_float, type(num_float)) # 输出3.14 <class 'float'>

• str()：将指定的对象转换成字符串形式。例如：

num = 123

num_str = str(num)

print(num_str, type(num_str)) # 输出'123' <class'str'>

（二）运算符与表达式

运算符是编程语言中用于执行特定操作的符号，通过运算符和操作数可以组成表达式。Python 中的运算符种类丰富，以下是常见的几类运算符：

• 算术运算符：用于基本的算术运算，包括加法（+）、减法（-）、乘法（*）、除法（/）、取模（%，返回除法的余数）、幂运算（**）和取整除（//，返回商的整数部分）。例如：

a = 10

b = 3

print(a + b) # 加法，输出13

print(a - b) # 减法，输出7

print(a * b) # 乘法，输出30

print(a / b) # 除法，输出3.3333333333333335（浮点数结果）

print(a % b) # 取模，输出1

print(a ** b) # 幂运算，输出1000

print(a // b) # 取整除，输出3

• 比较运算符：用于比较两个值的大小或是否相等，返回布尔值True或False。包括等于（==）、不等于（!=）、大于（>）、小于（<）、大于等于（>=）和小于等于（<=）。例如：

a = 5

b = 3

print(a == b) # 比较a是否等于b，输出False

print(a != b) # 比较a是否不等于b，输出True

print(a > b) # 比较a是否大于b，输出True

print(a < b) # 比较a是否小于b，输出False

print(a >= b) # 比较a是否大于等于b，输出True

print(a <= b) # 比较a是否小于等于b，输出False

• 逻辑运算符：用于对布尔值进行逻辑运算，包括逻辑与（and）、逻辑或（or）和逻辑非（not）。运算规则如下：

• • and：只有当两个操作数都为True时，结果才为True，否则为False，相当于逻辑乘法。

• • or：只要两个操作数中有一个为True，结果就为True，否则为False，相当于逻辑加法。

• • not：对操作数进行取反，True变为False，False变为True。

例如：

a = True

b = False

print(a and b) # 逻辑与，输出False

print(a or b) # 逻辑或，输出True

print(not a) # 逻辑非，输出False

逻辑运算符还存在短路现象，即当and运算中第一个操作数为False时，就不再计算第二个操作数，直接返回False；当or运算中第一个操作数为True时，也不再计算第二个操作数，直接返回True。例如：

def func1():

print("func1被调用")

return True

def func2():

print("func2被调用")

return False

# 由于func1()返回True，所以不会调用func2()

result1 = func1() or func2()

print(result1) # 输出True

# 由于func2()返回False，所以会继续调用func1()

result2 = func2() and func1()

print(result2) # 输出False，并且func1()被调用

• 赋值运算符：用于将值赋给变量，最基本的赋值运算符是=，还包括一些复合赋值运算符，如+=（加法赋值）、-=（减法赋值）、*=（乘法赋值）、/=（除法赋值）、%=（取模赋值）、**=（幂赋值）、//=（取整除赋值）等。例如：

a = 5

a += 3 # 等同于a = a + 3，a的值变为8

print(a)

• 成员运算符：用于判断一个值是否是另一个序列（如列表、字符串、元组等）的成员，包括in和not in。例如：

my_list = [1, 2, 3, 4, 5]

print(3 in my_list) # 判断3是否在my_list中，输出True

print(6 not in my_list) # 判断6是否不在my_list中，输出True

• 身份运算符：用于比较两个对象是否是同一个对象，即是否在内存中具有相同的地址，包括is和is not。例如：

a = [1, 2, 3]

b = [1, 2, 3]

c = a

print(a is b) # a和b虽然值相同，但不是同一个对象，输出False

print(a is c) # a和c是同一个对象，输出True

运算符具有优先级和结合性，优先级决定了表达式中运算符的计算顺序，结合性决定了相同优先级运算符的计算方向（从左到右或从右到左）。例如，算术运算符中，乘除和取模的优先级高于加减；逻辑运算符中，not的优先级高于and，and的优先级高于or。在复杂表达式中，可以使用括号()来明确运算顺序，括号内的表达式先计算。例如：

result = 2 + 3 * 4 # 先计算乘法，再计算加法，结果为14

result = (2 + 3) * 4 # 先计算括号内的加法，再计算乘法，结果为20

（三）控制结构

控制结构决定了程序的执行流程，Python 中主要有条件语句和循环语句两种控制结构。

• 条件语句（if - else）：根据条件的真假来决定执行不同的代码块。Python 中的条件语句主要有三种形式：

• • 单分支结构（if）：

age = 18

if age >= 18:

print("你已经成年了")

• 双分支结构（if - else）：

age = 16

if age >= 18:

print("你已经成年了")

else:

print("你还未成年")

• 多分支结构（if - elif - else）：

score = 85

if score >= 90:

print("成绩为A")

elif score >= 80:

print("成绩为B")

elif score >= 60:

print("成绩为C")

else:

print("成绩为D")

条件语句中可以使用各种比较运算符和逻辑运算符来构建复杂的条件表达式，并且可以进行嵌套使用，以满足更复杂的逻辑需求。例如：

age = 20

is_student = True

if age >= 18:

if is_student:

print("你是一名成年学生")

else:

print("你是一名成年人，但不是学生")

else:

print("你未成年")

• 循环语句（for、while）：用于重复执行一段代码。

• • for 循环：常用于遍历序列（如列表、字符串、元组等）或由range()函数生成的数字序列。语法格式为：

for 变量 in 序列:

循环体代码

例如，遍历列表并打印每个元素：

fruits = ["苹果", "香蕉", "橘子"]

for fruit in fruits:

print(fruit)

使用range()函数生成数字序列并进行遍历：

for i in range(5): # 生成0到4的数字序列

print(i)

range()函数还可以指定起始值、结束值和步长，例如range(1, 10, 2)会生成从 1 开始（包括 1），到 10 结束（不包括 10），步长为 2 的数字序列，即1, 3, 5, 7, 9。

• while 循环：在条件为真时重复执行循环体代码。语法格式为：

while 条件:

循环体代码

例如，计算 1 到 100 的累加和：

sum_num = 0

i = 1

while i <= 100:

sum_num += i

i += 1

print("1到100的累加和为:", sum_num)

在循环中，可以使用break语句和continue语句来控制循环流程：

• break：用于立即终止循环，跳出循环体。例如，在遍历列表时，找到特定元素后停止遍历：

fruits = ["苹果", "香蕉", "橘子", "葡萄"]

for fruit in fruits:

if fruit == "橘子":

break

print(fruit)

• continue：用于跳过当前循环的剩余代码，直接进入下一次循环。例如，打印 1 到 10 中的奇数：

for i in range(1, 11):

if i % 2 == 0:

continue

print(i)

循环语句还可以和else语句配合使用，当循环正常结束（没有被break终止）时，会执行else中的代码块。例如：

for i in range(5):

print(i)

else:

print("循环正常结束")

在上述代码中，for循环正常结束后，会打印 “循环正常结束”。如果在循环中使用break提前终止了循环，则不会执行else中的代码。

四、数据结构

（一）列表（List）

列表是 Python 中一种有序且可变的数据结构，用方括号[]表示，其中的元素可以是任意数据类型，元素之间用逗号分隔。列表非常灵活，常用于存储和操作一组相关的数据。

1. 创建列表：

• • 创建一个空列表：

empty_list = []

• 创建包含元素的列表：

fruits = ["苹果", "香蕉", "橘子"]

numbers = [1, 2, 3, 4, 5]

mixed_list = [1, "hello", 3.14, True]

1. 访问列表元素：

• • 通过索引访问，索引从 0 开始。例如，访问fruits列表中的第一个元素：

first_fruit = fruits[0]

print(first_fruit) # 输出"苹果"

• 可以使用负数索引从列表末尾开始访问，-1表示最后一个元素，-2表示倒数第二个元素，以此类推。例如：

last_fruit = fruits[-1]

print(last_fruit) # 输出"橘子"

1. 修改列表元素：

• • 直接通过索引赋值来修改元素。例如，将fruits列表中的第二个元素修改为 “芒果”：

fruits[1] = "芒果"

print(fruits) # 输出["苹果", "芒果", "橘子"]

1. 添加和删除列表元素：

• • 添加元素：

• • • 使用append()方法在列表末尾添加一个元素。例如：

fruits.append("葡萄")

print(fruits) # 输出["苹果", "芒果", "橘子", "葡萄"]

• 使用insert()方法在指定索引位置插入一个元素。例如，在索引 1 的位置插入 “草莓”：

fruits.insert(1, "草莓")

print(fruits) # 输出["苹果", "草莓", "芒果", "橘子", "葡萄"]

• 删除元素：

• • 使用del语句根据索引删除元素。例如，删除索引 2 的元素：

del fruits[2]

print(fruits) # 输出["苹果", "草莓", "橘子", "葡萄"]

• 使用remove()方法根据元素值删除元素，如果有多个相同值，只删除第一个。例如，删除 “橘子”：

fruits.remove("橘子")

print(fruits) # 输出["苹果", "草莓", "葡萄"]

• 使用pop()方法删除并返回指定索引位置的元素，默认删除最后一个元素。例如：

removed_fruit = fruits.pop() # 删除并返回最后一个元素“葡萄”

print(removed_fruit) # 输出"葡萄"

print(fruits) # 输出["苹果", "草莓"]

1. 列表的常用方法：

• • count()：统计列表中某个元素出现的次数。例如：

nums = [1, 2, 2, 3, 2, 4]

count_two = nums.count(2)

print(count_two) # 输出3

• index()：返回列表中某个元素首次出现的索引。例如：

index_three = nums.index(3)

print(index_three) # 输出3

• sort()：对列表进行排序（默认升序）。例如：

nums.sort()

print(nums) # 输出[1, 2, 2, 2, 3, 4]

• reverse()：反转列表中的元素顺序。例如：

nums.reverse()

print(nums) # 输出[4, 3, 2, 2, 2, 1]

• extend()：将一个列表中的元素添加到另一个列表中。例如：

list1 = [1, 2, 3]

list2 = [4, 5, 6]

list1.extend(list2)

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

（二）元组（Tuple）

元组是 Python 中一种有序且不可变的数据结构，用圆括号()表示，元素之间用逗号分隔。元组一旦创建，其元素不能被修改、添加或删除。

1. 元组的定义和特点：

• • 不可变性是元组的重要特点，这使得元组在某些场景下比列表更具优势，比如作为字典的键（因为字典的键必须是不可变的），或者在多线程环境中共享数据时，由于不可变，无需担心数据被意外修改 。

• • 元组在创建和访问元素时，性能通常比列表更快，尤其是在处理大型数据集时，因为它不需要额外的空间来支持元素的修改操作。

1. 创建和访问元组元素：

• • 创建一个空元组：

empty_tuple = ()

• 创建包含元素的元组：

point = (10, 20)

fruits_tuple = ("苹果", "香蕉", "橘子")

• 当元组只有一个元素时，需要在元素后面加逗号，以区分单个元素和括号内的表达式。例如：

single_element_tuple = (5,)

• 访问元组元素和列表类似，通过索引访问，索引从 0 开始，也支持负数索引。例如：

first_fruit = fruits_tuple[0]

print(first_fruit) # 输出"苹果"

last_fruit = fruits_tuple[-1]

print(last_fruit) # 输出"橘子"

虽然元组本身不可变，但如果元组中包含可变对象（如列表），可变对象内部的元素是可以修改的。例如：

mixed_tuple = ([1, 2, 3], "hello")

mixed_tuple[0][1] = 99 # 修改元组中列表的元素

print(mixed_tuple) # 输出([1, 99, 3], 'hello')

（三）字典（Dictionary）

字典是 Python 中一种无序的、可变的数据结构，由键值对（key - value pairs）组成，用花括号{}表示。每个键必须是唯一的，且通常是不可变的数据类型（如字符串、数字、元组等），值可以是任意数据类型。字典常用于存储和快速查找相关的数据。

1. 创建字典：

• • 创建一个空字典：

empty_dict = {}

• 创建包含键值对的字典：

student = {"name": "张三", "age": 20, "grade": "A"}

phone_book = {"Alice": "123 - 456 - 7890", "Bob": "098 - 765 - 4321"}

1. 访问字典元素：

• • 通过键来访问对应的值。例如，获取student字典中 “name” 对应的值：

student_name = student["name"]

print(student_name) # 输出"张三"

• 使用get()方法访问值，它比直接通过键访问更安全，如果键不存在，get()方法返回None（也可以指定默认返回值）。例如：

grade = student.get("grade")

print(grade) # 输出"A"

nonexistent_value = student.get("score")

print(nonexistent_value) # 输出None

default_value = student.get("score", 0)

print(default_value) # 输出0

1. 修改字典元素：

• • 直接通过键赋值来修改对应的值。例如，将student字典中 “age” 对应的值修改为 21：

student["age"] = 21

print(student) # 输出{"name": "张三", "age": 21, "grade": "A"}

1. 添加和删除字典元素：

• • 添加元素：通过给不存在的键赋值来添加新的键值对。例如，给student字典添加 “major” 键值对：

student["major"] = "Computer Science"

print(student) # 输出{"name": "张三", "age": 21, "grade": "A", "major": "Computer Science"}

• 删除元素：

• • 使用del语句删除指定键值对。例如，删除student字典中 “grade” 键值对：

del student["grade"]

print(student) # 输出{"name": "张三", "age": 21, "major": "Computer Science"}

• 使用pop()方法删除指定键值对，并返回对应的值。例如：

removed_age = student.pop("age")

print(removed_age) # 输出21

print(student) # 输出{"name": "张三", "major": "Computer Science"}

1. 字典的常用方法：

• • keys()：返回字典中所有的键，可迭代对象。例如：

keys = student.keys()

print(list(keys)) # 输出["name", "major"]，将可迭代对象转换为列表

• values()：返回字典中所有的值，可迭代对象。例如：

values = student.values()

print(list(values)) # 输出["张三", "Computer Science"]

• items()：返回字典中所有的键值对，每个键值对以元组形式呈现，可迭代对象。例如：

items = student.items()

print(list(items)) # 输出[("name", "张三"), ("major", "Computer Science")]

• update()：使用另一个字典的键值对来更新当前字典，如果键已存在，则更新对应的值；如果键不存在，则添加新的键值对。例如：

new_info = {"age": 22, "city": "Beijing"}

student.update(new_info)

print(student) # 输出{"name": "张三", "major": "Computer Science", "age": 22, "city": "Beijing"}

（四）集合（Set）

集合是 Python 中一种无序的、不重复的数据结构，用花括号{}表示（注意，创建空集合必须使用set()函数，因为{}表示空字典）。集合主要用于成员检测和消除重复元素，以及进行集合的交、并、差等数学运算。

1. 集合的定义和特点：

• • 无序性意味着集合中的元素没有固定的顺序，每次输出集合元素时，顺序可能不同。

• • 不重复性是集合的重要特性，当向集合中添加已经存在的元素时，集合不会发生变化，这使得集合在数据去重方面非常高效。

1. 创建和操作集合：

• • 创建一个空集合：

empty_set = set()

• 创建包含元素的集合：

numbers_set = {1, 2, 3, 4, 4, 5} # 自动去重，最终集合为{1, 2, 3, 4, 5}

fruits_set = set(["苹果", "香蕉", "橘子", "苹果"]) # 自动去重，最终集合为{"苹果", "香蕉", "橘子"}

• 添加元素：使用add()方法添加单个元素，使用update()方法添加多个元素（可迭代对象）。例如：

fruits_set.add("葡萄")

print(fruits_set) # 输出{"苹果", "香蕉", "橘子", "葡萄"}

fruits_set.update(["草莓", "芒果"])

print(fruits_set) # 输出{"苹果", "香蕉", "橘子", "葡萄", "草莓", "芒果"}

• 删除元素：使用remove()方法删除指定元素，如果元素不存在会抛出KeyError异常；使用discard()方法删除指定元素，如果元素不存在不会抛出异常。例如：

fruits_set.remove("香蕉")

print(fruits_set) # 输出{"苹果", "橘子", "葡萄", "草莓", "芒果"}

fruits_set.discard("西瓜") # 不会抛出异常

1. 集合的交、并、差等运算：

• • 交集（Intersection）：使用&运算符或intersection()方法，返回两个集合中都存在的元素组成的新集合。例如：

set1 = {1, 2, 3, 4, 5}

set2 = {4, 5, 6, 7, 8}

intersection_set = set1 & set2

# 或者 intersection_set = set1.intersection(set2)

print(intersection_set) # 输出{4, 5}

• 并集（Union）：使用|运算符或union()方法，返回包含两个集合中所有元素的新集合（重复元素只保留一个）。例如：

union_set = set1 | set2

# 或者 union_set = set1.union(set2)

print(union_set) # 输出{1, 2, 3, 4, 5, 6, 7, 8}

• 差集（Difference）：使用-运算符或difference()方法，返回在第一个集合中但不在第二个集合中的元素组成的新集合。例如：

difference_set = set1 - set2

# 或者 difference_set = set1.difference(set2)

print(difference_set) # 输出{1, 2, 3}

• 对称差集（Symmetric Difference）：使用^运算符或symmetric_difference()方法，返回在两个集合中但不同时在两个集合中的元素组成的新集合，即两个集合的并集减去交集。例如：

symmetric_difference_set = set1 ^ set2

# 或者 symmetric_difference_set = set1.symmetric_difference(set2)

print(symmetric_difference_set) # 输出{1, 2, 3, 6, 7, 8}

五、函数与模块

（一）函数定义与调用

在 Python 中，函数是一段可重复使用的代码块，用于执行特定的任务。函数可以接受输入参数，并返回一个或多个值。合理使用函数能够提高代码的可读性、可维护性和复用性。

1. 函数定义：使用def关键字来定义函数，语法如下：

def 函数名(参数列表):

函数体

return 返回值

其中，函数名是自定义的标识符，遵循 Python 的命名规则；参数列表可以为空，也可以包含一个或多个参数，参数之间用逗号分隔；函数体是函数执行的具体代码，通过缩进来表示代码块；return语句用于返回函数的执行结果，返回值可以是任何数据类型，如果函数不需要返回值，可以省略return语句 。

例如，定义一个简单的函数，用于计算两个数的和：

def add_numbers(a, b):

result = a + b

return result

1. 函数调用：定义函数后，可以通过函数名和参数来调用函数。例如，调用上面定义的add_numbers函数：

sum_result = add_numbers(3, 5)

print(sum_result) # 输出8

1. 参数传递：

• • 位置参数：调用函数时，按照参数定义的顺序传递参数。例如：

def greet(name, message):

print(f"{message}, {name}!")

greet("Alice", "Hello") # 输出Hello, Alice!

• 关键字参数：调用函数时，通过参数名来传递参数，参数顺序可以与定义时不同。例如：

greet(message="Hi", name="Bob") # 输出Hi, Bob!

• 默认参数：在定义函数时，可以为参数指定默认值。调用函数时，如果没有传递该参数的值，则使用默认值。例如：

def greet(name, message="Hello"):

print(f"{message}, {name}!")

greet("Charlie") # 输出Hello, Charlie!

greet("David", "Good morning") # 输出Good morning, David!

• 可变参数：

• • 可变位置参数（*args）：使用*符号定义可变位置参数，它可以接受任意数量的非关键字参数，并将这些参数作为一个元组传递给函数。例如：

def print_numbers(*args):

for num in args:

print(num)

print_numbers(1, 2, 3) # 依次输出1 2 3

print_numbers(4, 5, 6, 7) # 依次输出4 5 6 7

• ** 可变关键字参数（kwargs）：使用**符号定义可变关键字参数，它可以接受任意数量的关键字参数，并将这些参数作为一个字典传递给函数。例如：

def print_info(**kwargs):

for key, value in kwargs.items():

print(f"{key}: {value}")

print_info(name="Eve", age=20, city="New York")

# 输出

# name: Eve

# age: 20

# city: New York

1. 返回值：

• • 返回单个值：函数可以返回一个值，如上面的add_numbers函数返回两个数的和。

• • 返回多个值：实际上是返回一个元组。例如，定义一个函数，返回两个数的商和余数：

def divide(a, b):

quotient = a // b

remainder = a % b

return quotient, remainder

result = divide(10, 3)

print(result) # 输出(3, 1)

quotient, remainder = divide(10, 3)

print(quotient) # 输出3

print(remainder) # 输出1

（二）模块导入与使用

模块是 Python 中组织代码的一种方式，一个模块可以包含函数、类、变量等定义。使用模块可以将相关的代码组织在一起，提高代码的可维护性和复用性。Python 中有标准库模块和第三方库模块，也可以创建自己的模块。

1. 模块的概念和作用：

• • 概念：模块是一个包含 Python 代码的文件，扩展名为.py。每个模块都有自己独立的命名空间，避免了不同模块中变量名和函数名的冲突。

• • 作用：

• • • 代码复用：将常用的功能封装在模块中，在不同的项目或代码文件中可以重复使用，减少重复代码的编写。

• • • 提高可读性和可维护性：将相关功能的代码放在同一个模块中，使得代码结构更加清晰，易于理解和维护。例如，在一个数据分析项目中，可以将数据读取、清洗、分析等功能分别封装在不同的模块中，每个模块专注于自己的任务，这样整个项目的结构更加清晰，也便于团队协作开发。

1. 标准库模块导入与使用：Python 标准库包含了大量实用的模块，如math（数学运算）、os（操作系统相关）、sys（系统相关）、random（随机数生成）等，无需额外安装即可使用。

• • import 模块名：直接导入整个模块，使用模块中的功能时需要加上模块名作为前缀。例如，使用math模块计算平方根：

import math

result = math.sqrt(16)

print(result) # 输出4.0

• from 模块名 import 功能名：从模块中导入特定的功能，使用时无需加上模块名前缀。例如，从math模块导入sqrt函数：

from math import sqrt

result = sqrt(25)

print(result) # 输出5.0

• import 模块名 as 别名：给模块起一个别名，方便在代码中使用，尤其是模块名较长时。例如，给math模块起别名m：

import math as m

result = m.sqrt(9)

print(result) # 输出3.0

• **from 模块名 import ***：导入模块中的所有功能，不推荐使用，因为可能会导致命名冲突，难以确定某个功能来自哪个模块。例如：

from math import *

result = sqrt(36)

print(result) # 输出6.0

1. 第三方库模块导入与使用：第三方库是由其他开发者开发并发布的库，丰富了 Python 的功能。使用第三方库前，通常需要使用包管理器（如pip）进行安装。

• • 例如，安装requests库（用于发送 HTTP 请求）：在命令行中输入pip install requests 。

• • 导入和使用requests库：

import requests

response = requests.get('https://www.example.com')

print(response.status_code) # 输出响应状态码

1. 创建和使用自定义模块：

• • 创建自定义模块：创建一个以.py为后缀的文件，例如mymodule.py，在文件中定义函数、类或变量。

# mymodule.py

def greet(name):

return f"Hello, {name}!"

PI = 3.14159

• 使用自定义模块：在其他 Python 文件中导入并使用自定义模块。

import mymodule

message = mymodule.greet("Alice")

print(message) # 输出Hello, Alice!

print(mymodule.PI) # 输出3.14159

• 也可以使用from mymodule import greet, PI这样的方式导入模块中的特定功能，使用时直接使用greet和PI，无需加上模块名前缀 。

六、面向对象编程

（一）类与对象

在 Python 中，类是一种抽象的数据类型，它定义了一组属性（Attributes）和方法（Methods）来描述具有共同特征和行为的事物。对象是类的实例，即具有类所定义的属性和行为的具体实体。例如，我们可以定义一个Student类来描述学生的属性（如姓名、年龄、成绩）和行为（如学习、考试）。

1. 定义类：使用class关键字来定义类，类名一般遵循大驼峰命名法（即每个单词的首字母大写，单词之间没有下划线）。在类中，可以定义属性和方法，属性用于存储对象的数据，方法用于定义对象的行为。以下是定义Student类的示例：

class Student:

def __init__(self, name, age, score):

self.name = name

self.age = age

self.score = score

def study(self):

print(f"{self.name}正在学习。")

def take_exam(self):

print(f"{self.name}正在参加考试。")

在上述代码中：

• __init__是一个特殊的方法，称为构造函数或初始化方法，用于在创建对象时初始化对象的属性。它的第一个参数必须是self，self代表类的实例本身，通过self可以访问对象的属性和方法 。在__init__方法中，将传递的参数name、age、score分别赋值给对象的属性self.name、self.age、self.score。

• study和take_exam是类的实例方法，它们也都有self参数，用于访问对象的属性和执行对象的行为。

1. 创建对象：创建对象（也称为实例化）非常简单，只需使用类名后跟一对圆括号，并传入必要的参数（如果__init__方法有参数的话）即可。例如：

student1 = Student("张三", 20, 85)

student2 = Student("李四", 21, 90)

这里创建了两个Student类的对象student1和student2，每个对象都有自己独立的属性值。

3. 访问对象的属性和方法：通过对象名和点号（.）来访问对象的属性和方法。例如：

print(student1.name) # 输出：张三

student1.study() # 输出：张三正在学习。

student2.take_exam() # 输出：李四正在参加考试。

1. 类属性和实例属性：

• • 实例属性：每个对象独有的属性，在__init__方法中通过self定义。如上面Student类中的name、age、score都是实例属性，不同对象的实例属性值可以不同。

• • 类属性：所有对象共享的属性，定义在类中但在方法之外。例如，我们可以给Student类添加一个类属性school，表示学校：

class Student:

school = "XX大学" # 类属性

def __init__(self, name, age, score):

self.name = name

self.age = age

self.score = score

def study(self):

print(f"{self.name}正在学习。")

def take_exam(self):

print(f"{self.name}正在参加考试。")

访问类属性可以通过类名或对象名，但通常建议使用类名访问。例如：

print(Student.school) # 输出：XX大学

print(student1.school) # 也可以通过对象访问，但不推荐

需要注意的是，如果通过对象名修改类属性，实际上是给该对象创建了一个与类属性同名的实例属性，而不会影响类属性本身。例如：

student1.school = "YY大学"

print(student1.school) # 输出：YY大学，此时student1有了自己的school实例属性

print(Student.school) # 输出：XX大学，类属性未改变

print(student2.school) # 输出：XX大学，student2的school还是类属性的值

1. 类方法和静态方法：

• • 类方法：使用@classmethod装饰器修饰的方法，它的第一个参数通常是cls，表示类本身。类方法可以访问类属性，但不能访问实例属性。例如：

class Student:

school = "XX大学"

def __init__(self, name, age, score):

self.name = name

self.age = age

self.score = score

def study(self):

print(f"{self.name}正在学习。")

def take_exam(self):

print(f"{self.name}正在参加考试。")

@classmethod

def print_school(cls):

print(f"学校名称是：{cls.school}")

调用类方法通过类名，例如：

Student.print_school() # 输出：学校名称是：XX大学

• 静态方法：使用@staticmethod装饰器修饰的方法，它不需要额外的第一个参数（既不是self也不是cls），类似于普通函数，只是放在类的命名空间中。静态方法不能访问类属性和实例属性，通常用于实现一些与类相关但又不需要访问类或实例状态的功能。例如：

class Student:

school = "XX大学"

def __init__(self, name, age, score):

self.name = name

self.age = age

self.score = score

def study(self):

print(f"{self.name}正在学习。")

def take_exam(self):

print(f"{self.name}正在参加考试。")

@classmethod

def print_school(cls):

print(f"学校名称是：{cls.school}")

@staticmethod

def welcome_message():

print("欢迎来到学校！")

调用静态方法也是通过类名，例如：

Student.welcome_message() # 输出：欢迎来到学校！

（二）继承与多态

1. 继承：继承是面向对象编程中的一个重要概念，它允许一个类（子类）基于另一个类（父类）来创建，子类可以继承父类的属性和方法，并且可以定义自己的属性和方法，从而实现代码的重用和扩展。在 Python 中，继承通过在类定义时指定父类来实现，语法如下：

class 子类名(父类名):

# 子类可以访问父类的属性和方法

# 也可以定义自己的属性和方法

pass

例如，我们定义一个Animal类作为父类，然后定义Dog类和Cat类作为Animal类的子类：

class Animal:

def __init__(self, name):

self.name = name

def speak(self):

pass

class Dog(Animal):

def speak(self):

return f"{self.name}汪汪叫"

class Cat(Animal):

def speak(self):

return f"{self.name}喵喵叫"

在上述代码中：

• Dog类和Cat类都继承自Animal类，它们可以访问Animal类中的__init__方法和speak方法（虽然Animal类中的speak方法没有具体实现，但子类可以重写它）。

• Dog类和Cat类都重写了Animal类中的speak方法，以实现自己特有的行为。

1. 多态：多态指的是同一操作作用于不同的对象，可以产生不同的表现形式。在 Python 中，多态主要通过继承和方法重写来实现。例如，我们定义一个函数，接受一个Animal类型的对象，并调用它的speak方法：

def animal_talk(animal):

return animal.speak()

dog = Dog("旺财")

cat = Cat("咪咪")

print(animal_talk(dog)) # 输出：旺财汪汪叫

print(animal_talk(cat)) # 输出：咪咪喵喵叫

在这个例子中，animal_talk函数接受一个Animal类型的对象参数，不论传入的是Dog还是Cat对象，都会调用它们各自实现的speak方法，从而展示出不同的行为，这就是多态的体现。多态使得代码更加灵活和可扩展，提高了代码的通用性和可维护性。例如，当我们以后添加新的动物类（如Bird类）时，只要它继承自Animal类并实现了speak方法，就可以直接使用animal_talk函数，而不需要修改animal_talk函数的代码。

3. 多重继承：Python 支持多重继承，即一个子类可以继承多个父类。多重继承可以让子类拥有多个父类的属性和方法。语法如下：

class 子类名(父类1, 父类2, ...):

pass

例如：

class Flyable:

def fly(self):

return f"{self.name}在飞翔"

class Swimmable:

def swim(self):

return f"{self.name}在游泳"

class Duck(Animal, Flyable, Swimmable):

def __init__(self, name):

super().__init__(name)

duck = Duck("唐老鸭")

print(duck.speak()) # 输出：唐老鸭汪汪叫（这里假设Animal类的speak方法是汪汪叫，实际可根据需求调整）

print(duck.fly()) # 输出：唐老鸭在飞翔

print(duck.swim()) # 输出：唐老鸭在游泳

在上述代码中，Duck类继承了Animal、Flyable和Swimmable三个类，所以Duck类的对象duck可以调用这三个类中的方法。不过，多重继承可能会导致代码复杂和菱形问题（即子类中调用的某个方法，在多个父类中都存在，不清楚该调用哪个父类的方法），在使用时需要谨慎考虑 。可以通过print(Duck.__mro__)或print(Duck.mro())来查看类的方法解析顺序（MRO），以了解在多重继承中方法的查找顺序。

七、异常处理

在 Python 编程中，异常处理是一项非常重要的技能。当程序执行过程中出现错误时，Python 会抛出异常，这些异常如果不加以处理，可能会导致程序崩溃或出现不可预期的行为。异常处理机制允许我们捕获这些异常，并采取相应的措施，使程序能够更加健壮和稳定地运行。

捕获和处理异常

在 Python 中，使用try - except语句来捕获和处理异常。try块中放置可能会引发异常的代码，except块用于处理捕获到的异常。基本语法如下：

try:

# 可能引发异常的代码

result = 10 / 0

except ZeroDivisionError:

# 处理异常的代码

print("除数不能为零")

在上述示例中，try块中的10 / 0会引发ZeroDivisionError异常，except ZeroDivisionError捕获到这个异常后，会执行print("除数不能为零")语句，避免程序崩溃。

可以有多个except子句来处理不同类型的异常，例如：

try:

num = int("abc")

result = 10 / num

except ValueError:

print("无法将字符串转换为整数")

except ZeroDivisionError:

print("除数不能为零")

在这个例子中，int("abc")会引发ValueError异常，10 / num（当num为 0 时）会引发ZeroDivisionError异常，不同的except子句分别处理这两种异常。

如果希望在没有异常发生时执行一些代码，可以使用else子句，它必须出现在所有except子句之后。例如：

try:

num = 5

result = 10 / num

except ZeroDivisionError:

print("除数不能为零")

else:

print(f"结果是: {result}")

在这个示例中，如果try块中的代码没有引发异常，就会执行else块中的代码。

无论try块中是否发生异常，finally子句中的代码总是会被执行，通常用于资源的清理工作，比如关闭文件、释放数据库连接等。语法如下：

try:

file = open("test.txt", "r")

data = file.read()

except FileNotFoundError:

print("文件未找到")

finally:

if file:

file.close()

在 Python 3 中，还可以使用with语句来自动管理资源，它会在代码块结束时自动关闭文件，无需显式调用close()方法，更加简洁和安全。例如：

try:

with open("test.txt", "r") as file:

data = file.read()

except FileNotFoundError:

print("文件未找到")

自定义异常类

除了使用 Python 内置的异常类型，我们还可以根据实际需求自定义异常类。自定义异常类需要继承自Exception类或其子类。例如：

class MyCustomError(Exception):

pass

try:

raise MyCustomError("这是一个自定义异常")

except MyCustomError as e:

print(f"捕获到自定义异常: {e}")

在上述代码中，定义了一个MyCustomError自定义异常类，它继承自Exception。使用raise语句抛出这个自定义异常，然后通过try - except块捕获并处理它。

可以在自定义异常类中添加更多的属性和方法，以提供更详细的错误信息和处理逻辑。例如：

class DatabaseError(Exception):

def __init__(self, message, error_code):

self.message = message

self.error_code = error_code

super().__init__(message)

try:

raise DatabaseError("数据库连接失败", 5001)

except DatabaseError as e:

print(f"错误信息: {e.message}")

print(f"错误代码: {e.error_code}")

在这个例子中，DatabaseError自定义异常类在初始化时接受message和error_code参数，分别表示错误信息和错误代码，在捕获异常时可以访问这些属性获取更详细的错误信息 。通过自定义异常类，能够更好地组织和管理代码中的异常处理，使代码的逻辑更加清晰，便于维护和调试。

八、文件操作

在 Python 中，文件操作是一项基础且重要的功能，它允许我们与外部文件进行交互，实现数据的读取、写入和追加等操作。同时，正确处理文件路径和文件编码也是确保文件操作顺利进行的关键。

文件读取操作

Python 提供了内置的open()函数来打开文件，该函数返回一个文件对象，通过这个对象可以对文件进行各种操作 。在读取文件时，常用的模式是'r'（只读模式）。例如，读取一个文本文件的内容：

try:

with open('example.txt', 'r', encoding='utf-8') as file:

content = file.read()

print(content)

except FileNotFoundError:

print("文件未找到")

在上述代码中：

• with open('example.txt', 'r', encoding='utf-8') as file：使用with语句打开example.txt文件，以只读模式'r'打开，并指定编码为utf-8。with语句会自动管理文件的打开和关闭，在代码块结束时，无论是否发生异常，文件都会被正确关闭，避免了手动调用close()方法可能出现的错误 。

• file.read()：读取文件的全部内容，并将其赋值给content变量。如果文件较大，一次性读取可能会占用大量内存，此时可以使用read(size)方法，指定每次读取的字节数或字符数（取决于文件的打开模式和编码），例如file.read(1024)表示每次读取 1024 个字节。

除了read()方法，还可以使用readline()方法逐行读取文件：

try:

with open('example.txt', 'r', encoding='utf-8') as file:

line = file.readline()

while line:

print(line.strip()) # strip()方法用于去除行末的换行符

line = file.readline()

except FileNotFoundError:

print("文件未找到")

readline()方法每次读取一行内容，返回一个字符串，当读取到文件末尾时，返回空字符串'' 。通过循环不断调用readline()方法，可以逐行读取整个文件内容。

readlines()方法则会一次性读取文件的所有行，并将每一行作为一个元素存储在列表中：

try:

with open('example.txt', 'r', encoding='utf-8') as file:

lines = file.readlines()

for line in lines:

print(line.strip())

except FileNotFoundError:

print("文件未找到")

这种方式适用于需要对文件的每一行进行批量处理的场景，但同样需要注意文件较大时可能带来的内存问题。

文件写入操作

文件写入操作使用open()函数时，常用的模式是'w'（写入模式）和'a'（追加模式）。当使用'w'模式打开文件时，如果文件已存在，会清空文件原有内容；如果文件不存在，则会创建一个新文件。例如：

with open('output.txt', 'w', encoding='utf-8') as file:

file.write("Hello, World!\n")

file.write("这是新的一行内容\n")

在上述代码中，file.write()方法将字符串写入文件，需要注意的是，write()方法不会自动添加换行符，如果需要换行，必须手动添加'\n' 。

如果希望在文件末尾追加内容，而不是覆盖原有内容，可以使用'a'模式：

with open('output.txt', 'a', encoding='utf-8') as file:

file.write("这是追加的内容\n")

多次执行上述代码，每次都会在output.txt文件的末尾追加新的内容。

文件路径处理

在 Python 中处理文件路径时，推荐使用pathlib模块，它提供了一种面向对象的方式来处理文件路径，使得代码更加简洁和跨平台。例如，创建一个表示文件路径的Path对象：

from pathlib import Path

file_path = Path("example.txt")

print(file_path)

可以使用Path对象的方法来获取文件的绝对路径、文件名、文件后缀等信息：

from pathlib import Path

file_path = Path("example.txt")

# 获取绝对路径

absolute_path = file_path.resolve()

print(f"绝对路径: {absolute_path}")

# 获取文件名

print(f"文件名: {file_path.name}")

# 获取文件后缀

print(f"文件后缀: {file_path.suffix}")

# 获取文件名（不带扩展）

print(f"文件名（不带扩展）: {file_path.stem}")

还可以使用Path对象来检查文件是否存在、是否是文件或目录等：

from pathlib import Path

file_path = Path("example.txt")

if file_path.exists():

if file_path.is_file():

print(f"{file_path} 是一个文件")

elif file_path.is_dir():

print(f"{file_path} 是一个目录")

else:

print(f"{file_path} 文件不存在")

在构建文件路径时，pathlib模块也提供了方便的操作方法，例如拼接路径：

from pathlib import Path

parent_dir = Path("data")

file_name = "example.txt"

full_path = parent_dir / file_name

print(full_path)

上述代码使用/运算符将父目录和文件名拼接成完整的文件路径，这种方式在不同操作系统上都能正确处理路径分隔符。

文件编码处理

在处理文件时，正确处理文件编码至关重要，否则可能会出现乱码或读取错误的问题。在 Python 中，使用open()函数时，可以通过encoding参数显式指定文件的编码格式。常见的编码格式有'utf-8'（支持多种语言，是互联网上最常用的编码格式）、'gbk'（常用于简体中文 Windows 系统）等。

例如，读取一个gbk编码的文件：

try:

with open('gbk_file.txt', 'r', encoding='gbk') as file:

content = file.read()

print(content)

except UnicodeDecodeError:

print("解码错误，可能是编码格式不正确")

当写入文件时，同样需要指定正确的编码格式，以确保写入的内容能够被正确读取：

with open('utf8_file.txt', 'w', encoding='utf-8') as file:

file.write("包含中文的内容")

如果不确定文件的编码格式，可以使用第三方库chardet来自动检测。首先需要安装chardet库，可以使用pip install chardet命令进行安装。然后使用chardet检测文件编码：

import chardet

with open('unknown_encoding.txt', 'rb') as file:

rawdata = file.read()

result = chardet.detect(rawdata)

encoding = result['encoding']

print(f"检测到的编码格式为: {encoding}")

在实际应用中，处理文件编码时还需要注意设置合适的错误处理方式。例如，当读取文件时遇到无法解码的字符，可以通过errors参数指定处理方式：

try:

with open('file_with_errors.txt', 'r', encoding='utf-8', errors='ignore') as file:

content = file.read()

print(content)

except FileNotFoundError:

print("文件未找到")

在上述代码中，errors='ignore'表示忽略无法解码的字符，继续读取文件内容。其他常见的错误处理方式还有'strict'（默认值，遇到错误抛出异常）、'replace'（用?替换无法解码的字符）等。

九、常用库介绍

（一）数据分析库

在 Python 的数据分析领域，有几个库堪称中流砥柱，它们极大地简化了数据处理、分析和可视化的过程，让数据科学家和开发者能够高效地从数据中提取有价值的信息。

NumPy：NumPy（Numerical Python）是 Python 的基础科学计算库，提供了一个强大的 N 维数组对象ndarray，支持快速、高效的数值计算。它的数组运算采用向量化操作，避免了传统 Python 循环的低效，大大提高了计算效率。例如，使用 NumPy 进行数组的加法运算：

import numpy as np

# 创建两个数组

a = np.array([1, 2, 3])

b = np.array([4, 5, 6])

# 向量加法

c = a + b

print(c) # 输出:[5 7 9]

NumPy 还支持广播机制，它能自动扩展数组维度以匹配另一个数组，方便进行不同形状数组之间的运算。例如：

d = np.array([[1, 2], [3, 4]])

e = 2 * d

print(e) # 输出: [[2 4] [6 8]]

pandas：pandas 是 Python 中最常用的数据处理库，提供了DataFrame和Series这两个核心数据结构。DataFrame是二维表格型数据结构，类似于 Excel 表格；Series是一维数组，可看作DataFrame中的一列。pandas 擅长数据的读取、清洗、转换和分析，拥有丰富的函数和方法。比如，使用 pandas 读取 CSV 文件并进行简单的数据查看：

import pandas as pd

# 读取CSV文件

data = pd.read_csv('data.csv')

# 查看数据前5行

print(data.head())

# 查看数据基本信息

data.info()

pandas 还提供了强大的数据筛选、合并、分组等功能。例如，筛选出data中年龄大于 30 的数据：

filtered_data = data[data['Age'] > 30]

print(filtered_data)

Matplotlib：Matplotlib 是一个用于绘制图表的基础库，支持多种图表类型，如线图、柱状图、散点图、饼图等，能帮助我们将数据以直观的可视化形式呈现出来。下面是使用 Matplotlib 绘制简单线图的示例：

import matplotlib.pyplot as plt

import numpy as np

# 生成数据

x = np.linspace(0, 10, 100)

y = np.sin(x)

# 绘制线图

plt.plot(x, y)

# 添加标题和标签

plt.title('Sin Function')

plt.xlabel('X')

plt.ylabel('Sin(X)')

# 显示图表

plt.show()

通过 Matplotlib，我们可以对图表进行高度自定义，包括颜色、线条样式、标记等，以满足不同的展示需求。

（二）Web 开发库

Python 丰富的 Web 开发库为开发者提供了多样化的选择，使创建 Web 应用变得更加便捷。下面主要介绍 Flask 和 Django 这两个常用的 Web 开发库。

Flask：Flask 是一个轻量级的 Web 框架，它简单灵活，易于上手，非常适合初学者或快速搭建小型项目、原型应用以及微服务。使用 Flask 构建 Web 应用，首先需要安装 Flask 库，可以使用pip install flask命令进行安装。然后编写一个简单的 Flask 应用示例：

from flask import Flask

# 创建Flask应用实例

app = Flask(__name__)

# 定义路由和视图函数

@app.route('/')

def index():

return 'Hello, Flask!'

if __name__ == '__main__':

app.run()

在上述代码中，通过Flask类创建了一个应用实例app，使用@app.route装饰器定义了一个路由/，当用户访问根路径时，会执行index函数并返回Hello, Flask!。运行该应用后，在浏览器中访问http://127.0.0.1:5000/即可看到相应的页面内容。

Django：Django 是一个功能强大的、高层次的 Web 框架，采用了 MTV（Model - Template - View）模式组织资源，提供了丰富的功能和工具，如内置的数据库管理、用户认证、表单处理、URL 路由等，适合构建大型、复杂的 Web 应用程序，如社交网站、电子商务平台等。以创建一个简单的 Django 项目和应用为例，首先使用django - admin命令创建项目：

django - admin startproject myproject

cd myproject

然后在项目中创建一个应用：

python manage.py startapp myapp

在myapp应用中定义视图函数，例如在views.py文件中：

from django.http import HttpResponse

def index(request):

return HttpResponse('Hello, Django!')

接着在项目的urls.py文件中配置 URL 路由，将myapp的视图函数与 URL 关联起来：

from django.contrib import admin

from django.urls import path

from myapp.views import index

urlpatterns = [

path('admin/', admin.site.urls),

path('', index, name='index')

]

最后运行 Django 项目：

python manage.py runserver

在浏览器中访问http://127.0.0.1:8000/，就可以看到Hello, Django!的页面。Django 的优势在于其强大的功能和完善的生态系统，能大大提高开发效率，但相对来说，学习曲线比 Flask 要陡峭一些 。

（三）机器学习库

Python 在机器学习领域拥有众多优秀的库，这些库提供了丰富的算法和工具，降低了机器学习的开发门槛，使得开发者能够快速构建和训练模型。下面介绍几个常用的机器学习库。

Scikit - learn：Scikit - learn 是一个广泛使用的机器学习库，提供了丰富的机器学习算法和工具，涵盖分类、回归、聚类、降维等多个领域。它的设计理念是简单、高效且具有可扩展性，非常适合初学者和快速迭代的机器学习项目。例如，使用 Scikit - learn 进行简单的线性回归预测：

from sklearn.linear_model import LinearRegression

import numpy as np

# 创建数据集

X = np.random.rand(10, 1)

y = 2 * X + 1 + 0.1 * np.random.randn(10, 1)

# 训练模型

model = LinearRegression()

model.fit(X, y)

# 预测

predictions = model.predict(X)

print(predictions)

在这个例子中，首先创建了一个随机的数据集X和对应的标签y，然后使用LinearRegression类创建线性回归模型并进行训练，最后使用训练好的模型进行预测。Scikit - learn 还提供了数据预处理、模型评估、交叉验证等功能，方便开发者进行机器学习项目的全流程开发。

TensorFlow：TensorFlow 是一个由 Google 开发和维护的深度学习框架，它提供了高效的神经网络构建和训练功能，支持 GPU 加速，能够处理大规模的数据集和复杂的模型。TensorFlow 使用计算图来表示神经网络的结构和计算过程，通过自动求导机制实现模型参数的优化。以下是使用 TensorFlow 构建一个简单的手写数字识别模型的示例（基于 MNIST 数据集）：

import tensorflow as tf

from tensorflow.keras.datasets import mnist

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Dense

# 加载MNIST数据集

(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

# 数据预处理

train_images = train_images.reshape((-1, 28 * 28)).astype('float32') / 255.0

test_images = test_images.reshape((-1, 28 * 28)).astype('float32') / 255.0

# 构建模型

model = Sequential([

Dense(512, activation='relu', input_shape=(28 * 28,)),

Dense(10, activation='softmax')

])

# 编译模型

model.compile(optimizer='adam',

loss='sparse_categorical_crossentropy',

metrics=['accuracy'])

# 训练模型

model.fit(train_images, train_labels, epochs=5, batch_size=64)

# 评估模型

test_loss, test_acc = model.evaluate(test_images, test_labels)

print(f"测试准确率: {test_acc}")

在上述代码中，首先加载 MNIST 数据集并进行预处理，然后使用Sequential模型搭建一个简单的神经网络，包含一个隐藏层和一个输出层，接着编译模型并指定优化器、损失函数和评估指标，最后进行模型的训练和评估。

PyTorch：PyTorch 是另一个主流的深度学习框架，它以其动态计算图和简洁的代码风格受到很多研究者和开发者的喜爱。与 TensorFlow 不同，PyTorch 的计算图是动态的，这使得调试和开发更加灵活，在研究领域应用广泛。下面是使用 PyTorch 实现简单的线性回归模型的示例：

import torch

import torch.nn as nn

import torch.optim as optim

# 创建数据集

x = torch.tensor([[1.0], [2.0], [3.0], [4.0]], dtype=torch.float32)

y = torch.tensor([[2.0], [4.0], [6.0], [8.0]], dtype=torch.float32)

# 定义模型

class LinearRegression(nn.Module):

def __init__(self):

super(LinearRegression, self).__init__()

self.linear = nn.Linear(1, 1)

def forward(self, x):

return self.linear(x)

model = LinearRegression()

# 定义损失函数和优化器

criterion = nn.MSELoss()

optimizer = optim.SGD(model.parameters(), lr=0.01)

# 训练模型

for epoch in range(100):

y_pred = model(x)

loss = criterion(y_pred, y)

optimizer.zero_grad()

loss.backward()

optimizer.step()

if (epoch + 1) % 10 == 0:

print(f'Epoch {epoch + 1}/{100}, Loss: {loss.item()}')

在这个示例中，首先创建了简单的数据集x和y，然后定义了一个继承自nn.Module的线性回归模型类LinearRegression，接着定义损失函数和优化器，最后通过循环进行模型的训练，并打印每 10 个 epoch 的损失值 。PyTorch 还提供了丰富的工具和函数，如数据加载器DataLoader、模型保存和加载等功能，方便进行深度学习项目的开发和部署。

十、总结与展望

Python 以其简洁易读的语法、丰富强大的库、跨平台兼容性以及支持多种编程范式等特点，在 Web 开发、数据科学、人工智能、网络爬虫、自动化脚本等众多领域发挥着重要作用。无论是初学者踏入编程世界，还是专业开发者构建复杂的应用系统，Python 都能提供高效且灵活的解决方案 。

对于希望深入学习 Python 的读者，建议不断实践，通过参与实际项目、解决实际问题来巩固所学知识，提升编程能力。可以从简单的脚本编写开始，逐渐过渡到复杂的项目开发，如 Web 应用开发、数据分析项目或机器学习模型构建等。同时，积极参与开源社区，学习优秀的代码示例，与其他开发者交流经验，这将有助于拓宽技术视野，跟上 Python 的发展步伐。

展望未来，随着科技的不断进步，Python 有望在新兴领域持续发力。在人工智能和机器学习领域，随着模型复杂度和数据规模的不断增长，Python 凭借其丰富的深度学习框架和工具，将继续推动技术的创新与突破，助力实现更智能的应用，如更精准的自然语言处理系统、更强大的图像识别技术等。在大数据领域，Python 在数据处理和分析方面的优势将进一步凸显，帮助企业从海量数据中挖掘更多有价值的信息，为决策提供有力支持。在物联网（IoT）领域，Python 的跨平台特性使其能够在不同设备和系统之间实现高效通信和数据交互，有望在智能家居、智能工业等场景中发挥更大作用 。

Python 的发展前景十分广阔，它将继续在技术创新和产业发展中扮演重要角色，为开发者带来更多机遇和挑战。让我们一起深入探索 Python 的世界，不断提升自己的编程技能，为技术进步贡献自己的力量。