`Pytest` 是一个功能强大且易于使用的 Python 测试框架，适用于各种规模的项目。



它使得编写简单而可读的测试变得容易，同时支持复杂的功能测试和单元测试。以下是关于 `Pytest` 的详细介绍和使用指南。

### 安装

首先，你需要安装 `pytest` 包。可以通过 pip 来安装：

```bash
pip install pytest
```

### 基本概念

- **测试函数**：以 `test_` 开头的函数名。
- **测试文件**：文件名以 `test_` 开头或结尾。
- **断言**：使用标准的 `assert` 语句进行断言，无需导入额外的模块。

### 基本使用示例

以下是一些具体的示例，展示了如何使用 `pytest` 编写和运行测试。

#### 1. 简单测试函数

创建一个名为 `test_sample.py` 的文件，并添加以下内容：

```python
def add_numbers(a, b):
    return a + b

def test_add_numbers():
    assert add_numbers(2, 3) == 5
    assert add_numbers(-1, 1) == 0
```

然后在命令行中运行：

```bash
pytest test_sample.py
```

#### 2. 使用参数化测试

`@pytest.mark.parametrize` 装饰器允许你对同一测试函数执行多次，每次使用不同的参数。

```python
import pytest

@pytest.mark.parametrize("a,b,expected", [
    (2, 3, 5),
    (-1, 1, 0),
    (5, 7, 12)
])
def test_add_numbers_param(a, b, expected):
    assert add_numbers(a, b) == expected
```

#### 3. 测试异常

你可以测试代码是否抛出了预期的异常。

```python
def divide_numbers(a, b):
    if b == 0:
        raise ValueError("Cannot divide by zero!")
    return a / b

def test_divide_by_zero():
    with pytest.raises(ValueError):
        divide_numbers(1, 0)
```

#### 4. 使用 Fixtures

Fixtures 是 `pytest` 提供的一种机制，用于设置和清理测试环境。它们可以用来共享测试数据、配置等。

```python
import pytest

@pytest.fixture
def sample_data():
    return {'key': 'value'}

def test_sample_data(sample_data):
    assert sample_data['key'] == 'value'
```

#### 5. 使用多个 Fixtures

你可以在同一个测试函数中使用多个 fixtures。

```python
import pytest

@pytest.fixture
def first_fixture():
    return "first"

@pytest.fixture
def second_fixture():
    return "second"

def test_multiple_fixtures(first_fixture, second_fixture):
    assert first_fixture == "first"
    assert second_fixture == "second"
```

#### 6. 自动发现测试

`pytest` 自动查找并运行当前目录及其子目录下的所有符合条件的测试文件（文件名以 `test_` 开头或结尾）和测试函数（函数名以 `test_` 开头）。

只需在项目的根目录下运行：

```bash
pytest
```

#### 7. 标记测试

通过标记（marking）测试，可以将测试分组或过滤特定类型的测试。

```python
import pytest

@pytest.mark.slow
def test_slow_operation():
    # 模拟一个耗时的操作
    pass

def test_fast_operation():
    # 快速操作
    pass
```

你可以只运行标记为 `slow` 的测试：

```bash
pytest -m slow
```

或者跳过这些测试：

```bash
pytest -m "not slow"
```

#### 8. 运行特定测试

你可以通过指定测试函数名来运行特定的测试：

```bash
pytest test_sample.py::test_add_numbers
```

#### 9. 插件系统

`pytest` 支持插件系统，允许扩展其功能。例如，`pytest-cov` 可以用来生成代码覆盖率报告。

安装 `pytest-cov`：

```bash
pip install pytest-cov
```

运行测试并生成覆盖率报告：

```bash
pytest --cov=your_module_name
```

Pytest包

`Matplotlib` 是一个广泛使用的 Python 绘图库，它提供了丰富的工具来创建高质量的图表和可视化图形。无论是简单的折线图、柱状图还是复杂的热力图、3D 图表，`Matplotlib` 都能提供强大的支持。



### 安装

首先，你需要安装 `matplotlib` 包。可以通过 pip 来安装：

```bash
pip install matplotlib
```

### 基本使用示例

以下是一些具体的示例，展示了如何使用 `Matplotlib` 创建各种类型的图表。

#### 1. 简单的折线图

```python
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('Sine Wave')
plt.xlabel('X axis')
plt.ylabel('Y axis')

# 显示图表
plt.show()
```

#### 2. 柱状图

```python
import matplotlib.pyplot as plt

# 创建数据
labels = ['A', 'B', 'C', 'D']
values = [4, 7, 1, 8]

# 创建柱状图
plt.bar(labels, values)

# 添加标题和标签
plt.title('Bar Chart Example')
plt.xlabel('Categories')
plt.ylabel('Values')

# 显示图表
plt.show()
```

#### 3. 散点图

```python
import matplotlib.pyplot as plt
import numpy as np

# 创建数据
x = np.random.rand(50)
y = np.random.rand(50)
colors = np.random.rand(50)
sizes = 1000 * np.random.rand(50)

# 创建散点图
plt.scatter(x, y, c=colors, s=sizes, alpha=0.5)

# 添加标题和标签
plt.title('Scatter Plot Example')
plt.xlabel('X axis')
plt.ylabel('Y axis')

# 显示图表
plt.show()
```

#### 4. 饼图

```python
import matplotlib.pyplot as plt

# 创建数据
labels = ['Frogs', 'Hogs', 'Dogs', 'Logs']
sizes = [15, 30, 45, 10]
explode = (0, 0.1, 0, 0)  # 突出显示第二部分

# 创建饼图
plt.pie(sizes, explode=explode, labels=labels, autopct='%1.1f%%', shadow=True, startangle=90)

# 保证饼图为圆形
plt.axis('equal')

# 添加标题
plt.title('Pie Chart Example')

# 显示图表
plt.show()
```

#### 5. 子图

你可以在一个窗口中创建多个子图：

```python
import matplotlib.pyplot as plt
import numpy as np

# 创建数据
x = np.linspace(0, 10, 100)
y1 = np.sin(x)
y2 = np.cos(x)

# 创建包含两个子图的图表
fig, (ax1, ax2) = plt.subplots(2, 1)

# 第一个子图：正弦波
ax1.plot(x, y1, color='red')
ax1.set_title('Sine Wave')
ax1.set_xlabel('X axis')
ax1.set_ylabel('Y axis')

# 第二个子图：余弦波
ax2.plot(x, y2, color='blue')
ax2.set_title('Cosine Wave')
ax2.set_xlabel('X axis')
ax2.set_ylabel('Y axis')

# 调整布局以避免重叠
plt.tight_layout()

# 显示图表
plt.show()
```

#### 6. 多条折线图

你可以在同一个图表上绘制多条折线：

```python
import matplotlib.pyplot as plt
import numpy as np

# 创建数据
x = np.linspace(0, 10, 100)
y1 = np.sin(x)
y2 = np.cos(x)

# 创建图表并绘制两条折线
plt.plot(x, y1, label='Sine Wave', color='blue')
plt.plot(x, y2, label='Cosine Wave', color='red')

# 添加图例
plt.legend()

# 添加标题和标签
plt.title('Multiple Line Plots')
plt.xlabel('X axis')
plt.ylabel('Y axis')

# 显示图表
plt.show()
```

#### 7. 直方图

直方图用于展示数据的分布情况：

```python
import matplotlib.pyplot as plt
import numpy as np

# 创建数据
data = np.random.randn(1000)

# 创建直方图
plt.hist(data, bins=30, alpha=0.7, color='green')

# 添加标题和标签
plt.title('Histogram Example')
plt.xlabel('Value')
plt.ylabel('Frequency')

# 显示图表
plt.show()
```

#### 8. 热力图（Heatmap）

热力图是一种常用的二维数据可视化方法：

```python
import matplotlib.pyplot as plt
import numpy as np

# 创建数据
data = np.random.rand(10, 10)

# 创建热力图
plt.imshow(data, cmap='hot', interpolation='nearest')

# 添加颜色条
plt.colorbar()

# 添加标题
plt.title('Heatmap Example')

# 显示图表
plt.show()
```

#### 9. 3D 图表

`Matplotlib` 还支持创建三维图表：

```python
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import numpy as np

# 创建数据
x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)
x, y = np.meshgrid(x, y)
z = np.sin(np.sqrt(x**2 + y**2))

# 创建图表
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

# 绘制表面图
ax.plot_surface(x, y, z, cmap='viridis')

# 添加标题和标签
ax.set_title('3D Surface Plot')
ax.set_xlabel('X axis')
ax.set_ylabel('Y axis')
ax.set_zlabel('Z axis')

# 显示图表
plt.show()
```

#### 10. 自定义样式

你可以通过多种方式来自定义图表的样式：

```python
import matplotlib.pyplot as plt
import numpy as np

# 创建数据
x = np.linspace(0, 10, 100)
y = np.sin(x)

# 设置绘图风格
plt.style.use('ggplot')

# 创建图表
plt.plot(x, y, linestyle='--', marker='o', color='b')

# 添加标题和标签
plt.title('Custom Style Example')
plt.xlabel('X axis')
plt.ylabel('Y axis')

# 显示图表
plt.show()
```

#### 11. 保存图表

你可以将生成的图表保存为图片文件：

```python
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('Sine Wave')
plt.xlabel('X axis')
plt.ylabel('Y axis')

# 保存图表为 PNG 文件
plt.savefig('sine_wave.png')

# 显示图表
plt.show()
```

Matplotlib包

`Pandas` 是一个强大的 Python 数据分析库，提供了高性能、易用的数据结构和数据分析工具。



它的核心数据结构是 `DataFrame` 和 `Series`，这两个结构使得处理表格数据变得非常方便。无论是清洗数据、转换数据还是进行复杂的数据分析，`Pandas` 都能提供强有力的支持。

### 安装

首先，你需要安装 `pandas` 包。可以通过 pip 来安装：

```bash
pip install pandas
```

### 基本使用示例

以下是一些具体的示例，展示了如何使用 `Pandas` 进行基本的数据操作，如创建数据结构、读取数据、数据清洗、数据选择与过滤等。

#### 1. 创建数据结构

`Pandas` 提供了两种主要的数据结构：`Series` 和 `DataFrame`。

##### 创建 Series

`Series` 是一维标记数组，能够保存任何数据类型（整数、字符串、浮点数、Python 对象等）。

```python
import pandas as pd

# 从列表创建 Series
s = pd.Series([1, 3, 5, np.nan, 6, 8])
print(s)

# 从字典创建 Series
s2 = pd.Series({'a': 1, 'b': 2, 'c': 3})
print(s2)
```

##### 创建 DataFrame

`DataFrame` 是二维标记数据结构，类似于电子表格或 SQL 表格。

```python
import pandas as pd

# 从字典创建 DataFrame
data = {
    'Name': ['Alice', 'Bob', 'Charlie'],
    'Age': [25, 30, 35],
    'City': ['New York', 'Los Angeles', 'Chicago']
}
df = pd.DataFrame(data)
print(df)

# 从列表创建 DataFrame
data_list = [['Alice', 25, 'New York'], ['Bob', 30, 'Los Angeles'], ['Charlie', 35, 'Chicago']]
df2 = pd.DataFrame(data_list, columns=['Name', 'Age', 'City'])
print(df2)
```

#### 2. 读取和写入数据

`Pandas` 支持多种数据格式的读取和写入，包括 CSV、Excel、SQL 数据库等。

##### 读取 CSV 文件

```python
import pandas as pd

# 读取 CSV 文件
df = pd.read_csv('path/to/your/file.csv')
print(df.head())  # 显示前五行
```

##### 写入 CSV 文件

```python
import pandas as pd

# 创建一个简单的 DataFrame
data = {'Name': ['Alice', 'Bob', 'Charlie'], 'Age': [25, 30, 35]}
df = pd.DataFrame(data)

# 写入 CSV 文件
df.to_csv('output.csv', index=False)
```

##### 读取 Excel 文件

```python
import pandas as pd

# 读取 Excel 文件
df = pd.read_excel('path/to/your/file.xlsx', sheet_name='Sheet1')
print(df.head())
```

##### 写入 Excel 文件

```python
import pandas as pd

# 创建一个简单的 DataFrame
data = {'Name': ['Alice', 'Bob', 'Charlie'], 'Age': [25, 30, 35]}
df = pd.DataFrame(data)

# 写入 Excel 文件
df.to_excel('output.xlsx', index=False)
```

#### 3. 数据查看和描述统计

`Pandas` 提供了许多方法来查看和描述数据。

##### 查看数据

```python
import pandas as pd

# 创建一个简单的 DataFrame
data = {'Name': ['Alice', 'Bob', 'Charlie'], 'Age': [25, 30, 35], 'City': ['New York', 'Los Angeles', 'Chicago']}
df = pd.DataFrame(data)

# 显示前五行
print(df.head())

# 显示后五行
print(df.tail())

# 显示数据的基本信息
print(df.info())

# 显示数据的描述统计信息
print(df.describe())
```

#### 4. 数据选择和过滤

`Pandas` 提供了灵活的方法来选择和过滤数据。

##### 选择列

```python
import pandas as pd

# 创建一个简单的 DataFrame
data = {'Name': ['Alice', 'Bob', 'Charlie'], 'Age': [25, 30, 35], 'City': ['New York', 'Los Angeles', 'Chicago']}
df = pd.DataFrame(data)

# 选择单列
print(df['Name'])

# 选择多列
print(df[['Name', 'Age']])
```

##### 过滤数据

```python
import pandas as pd

# 创建一个简单的 DataFrame
data = {'Name': ['Alice', 'Bob', 'Charlie'], 'Age': [25, 30, 35], 'City': ['New York', 'Los Angeles', 'Chicago']}
df = pd.DataFrame(data)

# 过滤年龄大于等于30的行
filtered_df = df[df['Age'] >= 30]
print(filtered_df)
```

##### 使用条件组合过滤

```python
import pandas as pd

# 创建一个简单的 DataFrame
data = {'Name': ['Alice', 'Bob', 'Charlie'], 'Age': [25, 30, 35], 'City': ['New York', 'Los Angeles', 'Chicago']}
df = pd.DataFrame(data)

# 过滤年龄大于等于30且城市为洛杉矶的行
filtered_df = df[(df['Age'] >= 30) & (df['City'] == 'Los Angeles')]
print(filtered_df)
```

#### 5. 数据清洗

`Pandas` 提供了许多方法来进行数据清洗，如处理缺失值、重复值等。

##### 处理缺失值

```python
import pandas as pd
import numpy as np

# 创建一个包含缺失值的 DataFrame
data = {'Name': ['Alice', 'Bob', np.nan], 'Age': [25, np.nan, 35], 'City': ['New York', 'Los Angeles', np.nan]}
df = pd.DataFrame(data)

# 删除含有缺失值的行
cleaned_df = df.dropna()
print(cleaned_df)

# 填充缺失值
filled_df = df.fillna({'Age': 0, 'City': 'Unknown'})
print(filled_df)
```

##### 删除重复值

```python
import pandas as pd

# 创建一个包含重复值的 DataFrame
data = {'Name': ['Alice', 'Bob', 'Alice'], 'Age': [25, 30, 25], 'City': ['New York', 'Los Angeles', 'New York']}
df = pd.DataFrame(data)

# 删除重复值
deduplicated_df = df.drop_duplicates()
print(deduplicated_df)
```

#### 6. 数据分组和聚合

`Pandas` 提供了 `groupby` 方法来进行数据分组，并支持各种聚合操作。

```python
import pandas as pd

# 创建一个简单的 DataFrame
data = {'Name': ['Alice', 'Bob', 'Charlie', 'Alice'], 'Age': [25, 30, 35, 25], 'City': ['New York', 'Los Angeles', 'Chicago', 'New York']}
df = pd.DataFrame(data)

# 按城市分组并计算每组的平均年龄
grouped_df = df.groupby('City').agg({'Age': 'mean'})
print(grouped_df)
```

#### 7. 数据合并和连接

`Pandas` 提供了多种方法来合并和连接数据集。

##### 合并数据

```python
import pandas as pd

# 创建两个简单的 DataFrame
df1 = pd.DataFrame({'Name': ['Alice', 'Bob'], 'Age': [25, 30]})
df2 = pd.DataFrame({'Name': ['Charlie', 'David'], 'Age': [35, 40]})

# 合并数据
merged_df = pd.concat([df1, df2], ignore_index=True)
print(merged_df)
```

##### 连接数据

```python
import pandas as pd

# 创建两个简单的 DataFrame
df1 = pd.DataFrame({'Name': ['Alice', 'Bob'], 'Age': [25, 30]})
df2 = pd.DataFrame({'Name': ['Alice', 'Bob'], 'City': ['New York', 'Los Angeles']})

# 连接数据
joined_df = pd.merge(df1, df2, on='Name')
print(joined_df)
```

#### 8. 时间序列数据处理

`Pandas` 提供了强大的时间序列处理功能。

##### 创建时间序列

```python
import pandas as pd

# 创建一个日期范围
dates = pd.date_range('20230101', periods=6)
print(dates)

# 创建一个包含时间序列的 DataFrame
df = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=list('ABCD'))
print(df)
```

##### 转换时间戳

```python
import pandas as pd

# 将字符串转换为时间戳
timestamp = pd.to_datetime('2023-01-01')
print(timestamp)

# 将时间戳转换为字符串
string_date = timestamp.strftime('%Y-%m-%d')
print(string_date)
```

Pandas包

`NumPy` 是 Python 中用于科学计算的核心库，它提供了强大的多维数组对象（`ndarray`），以及用于处理这些数组的大量函数。



`NumPy` 的高效性和灵活性使其成为数据分析、机器学习和其他科学计算任务的基础工具。

### 安装

首先，你需要安装 `NumPy` 包。可以通过 pip 来安装：

```bash
pip install numpy
```

### 基本使用示例

以下是一些具体的示例，展示了如何使用 `NumPy` 进行基本的数组操作和一些高级功能。

#### 1. 创建数组

你可以通过多种方式创建 `NumPy` 数组：

```python
import numpy as np

# 从列表创建一维数组
a = np.array([1, 2, 3])
print(a)

# 从列表创建二维数组
b = np.array([[1, 2, 3], [4, 5, 6]])
print(b)

# 使用 arange 函数创建数组
c = np.arange(10)
print(c)

# 使用 linspace 函数创建等间距数组
d = np.linspace(0, 1, 5)  # 在 0 到 1 之间生成 5 个等间距的数
print(d)

# 创建全为零的数组
e = np.zeros((3, 3))
print(e)

# 创建全为一的数组
f = np.ones((3, 3))
print(f)

# 创建对角矩阵
g = np.eye(3)
print(g)

# 创建随机数数组
h = np.random.rand(3, 3)
print(h)
```

#### 2. 数组的基本操作

`NumPy` 提供了丰富的数组操作方法：

```python
import numpy as np

# 创建两个数组
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

# 加法
print(a + b)  # [5 7 9]

# 减法
print(a - b)  # [-3 -3 -3]

# 乘法（元素级）
print(a * b)  # [4 10 18]

# 点积
print(np.dot(a, b))  # 32

# 转置
c = np.array([[1, 2], [3, 4]])
print(c.T)  # [[1 3] [2 4]]

# 形状操作
print(c.shape)  # (2, 2)
print(c.reshape(1, 4))  # [[1 2 3 4]]
```

#### 3. 数组索引和切片

`NumPy` 支持灵活的索引和切片操作：

```python
import numpy as np

# 创建一个二维数组
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# 索引单个元素
print(a[0, 0])  # 1

# 索引一行
print(a[0])  # [1 2 3]

# 切片操作
print(a[0:2, 1:3])  # [[2 3] [5 6]]

# 条件索引
print(a[a > 5])  # [6 7 8 9]
```

#### 4. 统计函数

`NumPy` 提供了许多统计函数来帮助分析数据：

```python
import numpy as np

# 创建一个数组
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# 求和
print(np.sum(a))  # 45

# 按列求和
print(np.sum(a, axis=0))  # [12 15 18]

# 按行求和
print(np.sum(a, axis=1))  # [6 15 24]

# 平均值
print(np.mean(a))  # 5.0

# 最大值和最小值
print(np.max(a))  # 9
print(np.min(a))  # 1

# 标准差
print(np.std(a))  # 2.581988897471611
```

#### 5. 广播机制

`NumPy` 的广播机制允许不同形状的数组进行算术运算：

```python
import numpy as np

# 创建一个二维数组
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# 创建一个一维数组
b = np.array([1, 0, 1])

# 广播加法
print(a + b)
# [[2 2 4]
#  [5 5 7]
#  [8 8 10]]
```

#### 6. 高级索引

`NumPy` 支持布尔索引和整数数组索引：

```python
import numpy as np

# 创建一个数组
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# 布尔索引
print(a[a > 5])  # [6 7 8 9]

# 整数数组索引
indices = np.array([0, 2, 1])
print(a[indices])  # [[1 2 3] [7 8 9] [4 5 6]]
```

#### 7. 数组拼接与分割

`NumPy` 提供了多种方法来拼接和分割数组：

```python
import numpy as np

# 创建两个数组
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6]])

# 水平拼接
print(np.hstack((a, b)))
# [[1 2 5 6]
#  [3 4 0 0]]

# 垂直拼接
print(np.vstack((a, b)))
# [[1 2]
#  [3 4]
#  [5 6]]

# 分割数组
c = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
print(np.hsplit(c, 2))  # 将 c 水平分成两部分
# [array([[1, 2],
#         [5, 6]]), 
#  array([[3, 4],
#         [7, 8]])]

print(np.vsplit(c, 2))  # 将 c 垂直分成两部分
# [array([[1, 2, 3, 4]]), 
#  array([[5, 6, 7, 8]])]
```

#### 8. 文件输入输出

`NumPy` 提供了方便的方法来保存和加载数组：

```python
import numpy as np

# 创建一个数组
a = np.array([[1, 2, 3], [4, 5, 6]])

# 保存到文件
np.save('array.npy', a)

# 从文件加载
b = np.load('array.npy')
print(b)
```

#### 9. 线性代数

`NumPy` 提供了丰富的线性代数功能：

```python
import numpy as np

# 创建两个矩阵
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])

# 矩阵乘法
print(np.dot(a, b))
# [[19 22]
#  [43 50]]

# 计算行列式
print(np.linalg.det(a))  # -2.0

# 计算逆矩阵
print(np.linalg.inv(a))
# [[-2.   1. ]
#  [ 1.5 -0.5]]
```

NumPy包

`PyMySQL` 是一个纯 Python 实现的 MySQL 客户端库，它允许你通过 Python 脚本连接到 MySQL 数据库并执行 SQL 查询。



相比于其他数据库驱动程序，`PyMySQL` 的主要优点是它不需要安装额外的系统依赖项，并且完全用 Python 编写。

### 安装

首先，你需要安装 `PyMySQL` 包。可以通过 pip 来安装：

```bash
pip install pymysql
```

### 基本使用

以下展示了如何使用 `PyMySQL` 进行基本的数据库操作，如连接到数据库、执行查询、插入数据等。

#### 1. 连接到 MySQL 数据库

要连接到 MySQL 数据库，可以使用 `pymysql.connect()` 方法：

```python
import pymysql

# 创建数据库连接
connection = pymysql.connect(
    host='localhost',
    user='your_username',
    password='your_password',
    database='your_database',
    charset='utf8mb4',
    cursorclass=pymysql.cursors.DictCursor  # 返回结果为字典形式
)

try:
    with connection.cursor() as cursor:
        # 执行 SQL 查询
        sql = "SELECT DATABASE();"
        cursor.execute(sql)
        result = cursor.fetchone()
        print(f"当前数据库: {result}")
finally:
    # 关闭数据库连接
    connection.close()
```

#### 2. 创建表

你可以通过执行 SQL 语句来创建表：

```python
import pymysql

# 创建数据库连接
connection = pymysql.connect(
    host='localhost',
    user='your_username',
    password='your_password',
    database='your_database',
    charset='utf8mb4',
    cursorclass=pymysql.cursors.DictCursor
)

try:
    with connection.cursor() as cursor:
        # 创建表
        sql = '''
        CREATE TABLE IF NOT EXISTS users (
            id INT AUTO_INCREMENT PRIMARY KEY,
            name VARCHAR(255) NOT NULL,
            age INT NOT NULL
        );
        '''
        cursor.execute(sql)
        
        # 提交更改
        connection.commit()
finally:
    # 关闭数据库连接
    connection.close()
```

#### 3. 插入数据

使用 `INSERT INTO` 语句将数据插入到表中：

```python
import pymysql

# 创建数据库连接
connection = pymysql.connect(
    host='localhost',
    user='your_username',
    password='your_password',
    database='your_database',
    charset='utf8mb4',
    cursorclass=pymysql.cursors.DictCursor
)

try:
    with connection.cursor() as cursor:
        # 插入数据
        sql = "INSERT INTO users (name, age) VALUES (%s, %s)"
        cursor.execute(sql, ('Alice', 30))
        
        # 提交更改
        connection.commit()
finally:
    # 关闭数据库连接
    connection.close()
```

#### 4. 查询数据

使用 `SELECT` 语句从表中检索数据：

```python
import pymysql

# 创建数据库连接
connection = pymysql.connect(
    host='localhost',
    user='your_username',
    password='your_password',
    database='your_database',
    charset='utf8mb4',
    cursorclass=pymysql.cursors.DictCursor
)

try:
    with connection.cursor() as cursor:
        # 查询数据
        sql = "SELECT id, name, age FROM users"
        cursor.execute(sql)
        results = cursor.fetchall()
        
        for row in results:
            print(f"ID: {row['id']}, Name: {row['name']}, Age: {row['age']}")
finally:
    # 关闭数据库连接
    connection.close()
```

#### 5. 更新数据

使用 `UPDATE` 语句更新表中的数据：

```python
import pymysql

# 创建数据库连接
connection = pymysql.connect(
    host='localhost',
    user='your_username',
    password='your_password',
    database='your_database',
    charset='utf8mb4',
    cursorclass=pymysql.cursors.DictCursor
)

try:
    with connection.cursor() as cursor:
        # 更新数据
        sql = "UPDATE users SET age = %s WHERE name = %s"
        cursor.execute(sql, (31, 'Alice'))
        
        # 提交更改
        connection.commit()
finally:
    # 关闭数据库连接
    connection.close()
```

#### 6. 删除数据

使用 `DELETE` 语句删除表中的数据：

```python
import pymysql

# 创建数据库连接
connection = pymysql.connect(
    host='localhost',
    user='your_username',
    password='your_password',
    database='your_database',
    charset='utf8mb4',
    cursorclass=pymysql.cursors.DictCursor
)

try:
    with connection.cursor() as cursor:
        # 删除数据
        sql = "DELETE FROM users WHERE name = %s"
        cursor.execute(sql, ('Alice',))
        
        # 提交更改
        connection.commit()
finally:
    # 关闭数据库连接
    connection.close()
```

#### 7. 使用上下文管理器

为了确保资源被正确释放，你可以使用上下文管理器来处理数据库连接：

```python
import pymysql

with pymysql.connect(
    host='localhost',
    user='your_username',
    password='your_password',
    database='your_database',
    charset='utf8mb4',
    cursorclass=pymysql.cursors.DictCursor
) as connection:
    with connection.cursor() as cursor:
        # 执行 SQL 查询
        sql = "SELECT DATABASE();"
        cursor.execute(sql)
        result = cursor.fetchone()
        print(f"当前数据库: {result}")
```

#### 8. 错误处理

在实际应用中，数据库操作可能会失败，因此需要进行适当的错误处理：

```python
import pymysql

try:
    # 创建数据库连接
    connection = pymysql.connect(
        host='localhost',
        user='your_username',
        password='your_password',
        database='your_database',
        charset='utf8mb4',
        cursorclass=pymysql.cursors.DictCursor
    )

    with connection.cursor() as cursor:
        # 执行 SQL 查询
        sql = "SELECT * FROM non_existent_table"
        cursor.execute(sql)
        results = cursor.fetchall()
        for row in results:
            print(row)

except pymysql.MySQLError as e:
    print(f"MySQL 错误: {e}")
except Exception as e:
    print(f"其他错误: {e}")
finally:
    # 确保连接被关闭
    if 'connection' in locals():
        connection.close()
```
### 使用实例
新建一个文件mysqlclient.py用来配置mysql配置
```
#!/usr/bin/env python
# -*- coding: UTF-8 -*-

import pymysql

conn = pymysql.connect(
          host="127.0.0.1",
          port=3306,
          user="用户",
          password="密码",
          db="data"
       )
```

在使用的py文件引入mysqlclient，并使用
```
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
from mysql.mysqlclient import conn
cur = conn.cursor()


#查询操作（不需要try except）
def select_mysql(username, password):

    sql = "SELECT * FROM app01_userinfo WHERE name ='%s' and password ='%s'" % (username, password)

    cur.execute(sql)

    result = cur.fetchall()

    if (len(result) == 0):
        return False#不存在
    else:
        return result#存在

#插入操作
def insert_mysql(username, password,isadmin):

    sql = "INSERT INTO app01_userinfo(name, password,isadmin) VALUES ('%s','%s','%s')" %(username, password, isadmin)

    try:
        addflag = cur.execute(sql)
        conn.commit()# 对数据库内容有改变，需要commit()
        if (addflag == 1):
            return 1 #注册成功
        else:
            return 0 #注册失败
    except:
        print("系统错误...注册失败！")
        return 0

#更新操作
def updata_mysql(username,oldpassword,newpassword):

    sql2 = "update app01_userinfo set name='%s',password='%s' where password='%s'"%(username, newpassword, oldpassword)

    try:
        resetflag = cur.execute(sql2)
        conn.commit()
        if (resetflag == 1):
            return 1
        else:
            return 0
    except:
        print("系统错误...修改密码失败！")
        return 0

#删除操作
def del_mysql(username, password):

    sql = "Delete FROM app01_userinfo WHERE name ='%s' and password ='%s'" % (username, password)

    try:
        addflag = cur.execute(sql)
        conn.commit()
        if (addflag == 1):
            return 1
        else:
            return 0
    except:
        print("系统错误...添加密码失败！")
        return 0
```