55、Python 数据处理与可视化全攻略

Python 数据处理与可视化全攻略

1. Python 中的数据集合

在 Python 里，NumPy 数组是用于数值计算的重要数据集合。由于 NumPy 的广泛使用，许多 Python 库的函数都要求输入 NumPy 数组。

要使用 NumPy 数组，首先要确保安装了 NumPy 库。若使用 Anaconda，通常已预装；否则，可在终端使用 pip install numpy 进行安装。安装完成后，在 Python 程序中导入 NumPy，传统做法是使用别名 np ：

import numpy as np

创建 NumPy 数组很简单，只需将可迭代对象传递给 np.array 函数：

>>> np.array([1,2,3,4,5,6])
array([1, 2, 3, 4, 5, 6])

np.arange 是常用的 NumPy 函数，类似于 Python 内置的 range 函数，但支持浮点数。传入两个参数时，其功能与 range 相同，不过返回的是 NumPy 数组：

>>> np.arange(0,10)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

传入第三个参数可指定步长，步长可以是浮点数。以下代码生成一个从 0 到 10，步长为 0.1 的 NumPy 数组，共 100 个数字：

>>> np.arange(0,10,0.1)
array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. , 1.1, 1.2,
       1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2. , 2.1, 2.2, 2.3, 2.4, 2.5,
       2.6, 2.7, 2.8, 2.9, 3. , 3.1, 3.2, 3.3, 3.4, 3.5, 3.6, 3.7, 3.8,
       3.9, 4. , 4.1, 4.2, 4.3, 4.4, 4.5, 4.6, 4.7, 4.8, 4.9, 5. , 5.1,
       5.2, 5.3, 5.4, 5.5, 5.6, 5.7, 5.8, 5.9, 6. , 6.1, 6.2, 6.3, 6.4,
       6.5, 6.6, 6.7, 6.8, 6.9, 7. , 7.1, 7.2, 7.3, 7.4, 7.5, 7.6, 7.7,
       7.8, 7.9, 8. , 8.1, 8.2, 8.3, 8.4, 8.5, 8.6, 8.7, 8.8, 8.9, 9. ,
       9.1, 9.2, 9.3, 9.4, 9.5, 9.6, 9.7, 9.8, 9.9])
>>> len(np.arange(0,10,0.1))
100

2. 字典

字典是一种与列表、元组或生成器不同的数据集合。它通过键（通常是字符串）来访问元素，而非数字索引。以下代码定义了一个名为 dog 的字典，包含两个键值对：

dog = {"name" : "Melba", "age" : 2}

为使字典更易读，可添加额外空格，将每个键值对单独写在一行：

dog = {
    "name" : "Melba",
    "age" : 2
}

访问字典的值时，使用类似列表索引的语法，但传入的是键：

>>> dog["name"]
'Melba'
>>> dog["age"]
2

若要获取字典的所有键值对，可使用 items 方法，返回一个可迭代的元组序列。需注意，字典中的元素没有固定顺序：

>>> list(dog.items())
[('name', 'Melba'), ('age', 2)]

3. 有用的集合函数

Python 提供了许多处理可迭代对象的内置函数，特别是针对数字可迭代对象。常见的有 len 函数用于获取长度， zip 函数用于合并多个可迭代对象。此外，还有一些函数值得一提：
- sum 函数：对可迭代的数字求和。
- max 函数：返回可迭代对象中的最大值。
- min 函数：返回可迭代对象中的最小值。

以下是这些函数的使用示例：

>>> sum([1,2,3])
6
>>> max([1,2,3])
3
>>> min([1,2,3])
1

sorted 函数返回一个排序后的新列表，原列表顺序不受影响：

>>> q = [3,4,1,2,5]
>>> sorted(q)
[1, 2, 3, 4, 5]
>>> q
[3, 4, 1, 2, 5]

reversed 函数返回一个反转后的可迭代对象，同样不改变原对象顺序。由于返回的是可迭代对象而非列表，需转换后查看结果：

>>> q
[3, 4, 1, 2, 5]
>>> reversed(q)
<list_reverseiterator at 0x15fb652eb70>
>>> list(reversed(q))
[5, 2, 1, 4, 3]

若要直接对列表进行排序或反转，可使用 sort 和 reverse 方法，如 q.sort() 或 q.reverse() 。

4. 函数的使用

Python 函数如同小型程序，可接受输入参数，进行计算并返回输出结果。我们可以使用 def 关键字定义自己的函数。以下是一个名为 square 的函数，用于计算输入值的平方：

def square(x):
    y = x * x
    return y

调用该函数：

>>> square(5)
25

4.1 函数接受更多输入

函数可以接受任意数量的输入参数。例如， add3 函数接受三个参数并将它们相加：

def add3(x,y,z):
    return x + y + z

有时，我们希望函数能接受可变数量的参数。可以使用 *args 语法，它会将所有输入值存储在一个元组中。以下是一个 add 函数，用于对所有传入的参数求和：

def add(*args):
    total = 0
    for x in args:
        total += x
    return total

调用示例：

>>> add(1,2,3,4,5)
15
>>> add()
0

add 函数与之前的 sum 函数不同， sum 接受一个可迭代对象，而 add 直接接受参数。此外， * 运算符还可将列表转换为函数的参数：

>>> p = [1,2,3,4,5]
>>> add(*p)
15

4.2 关键字参数

除了使用 *args 处理可变参数，还可以使用关键字参数。以下是一个带有两个可选关键字参数 name 和 age 的 birthday 函数，用于生成生日祝福语：

def birthday(name="friend", age=None):
    s = "Happy birthday, %s" % name
    if age:
        s += ", you're %d years old" % age
    return s + "!"

由于 name 和 age 是关键字参数，它们都是可选的。 name 默认值为 "friend" ， age 默认值为 None 。以下是不同调用方式的示例：

>>> birthday()
'Happy birthday, friend!'
>>> birthday('Melba')
'Happy birthday, Melba!'
>>> birthday(name='Melba')
'Happy birthday, Melba!'
>>> birthday('Melba', 2)
"Happy birthday, Melba, you're 2 years old!"
>>> birthday(age=2)
"Happy birthday, friend, you're 2 years old!"
>>> birthday('Melba', age=2)
"Happy birthday, Melba, you're 2 years old!"
>>> birthday(age=2,name='Melba')
"Happy birthday, Melba, you're 2 years old!"

若有多个参数，可将它们封装在字典中，使用 ** 运算符传递给函数：

>>> dog = {"name" : "Melba", "age" : 2}
>>> birthday(**dog)
"Happy birthday, Melba, you're 2 years old!"

定义函数时，也可使用 **kwargs 语法处理所有关键字参数：

def birthday(**kwargs):
    s = "Happy birthday, %s" % kwargs['name']
    if kwargs['age']:
        s += ", you're %d years old" % kwargs['age']
    return s + "!"

调用方式与之前相同：

>>> birthday(**dog)
"Happy birthday, Melba, you're 2 years old!"
>>> birthday(age=2,name='Melba')
"Happy birthday, Melba, you're 2 years old!"

4.3 函数作为数据

在 Python 中，函数是一等公民，可赋值给变量、作为参数传递给其他函数或作为返回值返回。以下是一个 evaluate 函数，接受一个函数和一个值作为输入，并返回函数调用的结果：

def evaluate(f,x):
    return f(x)

使用之前定义的 square 函数进行测试：

>>> evaluate(square,10)
100

Python 的 map 函数也是一个接受函数作为输入的有用函数，它将函数应用于可迭代对象的每个元素，并返回一个新的可迭代对象。以下是将 square 函数应用于 range(10) 的示例：

>>> map(square,range(10))
<map at 0x15fb752e240>
>>> list(map(square,range(10)))
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

函数还可以返回另一个函数。以下是一个 make_power_function 函数，返回一个将数字提升到指定幂次的函数：

def make_power_function(power):
    def power_function(x):
        return x ** power
    return power_function

使用示例：

>>> square = make_power_function(2)
>>> square(2)
4
>>> cube = make_power_function(3)
>>> cube(2)
8

当 make_power_function 执行完毕后，返回的 power_function 仍然记得传入的 power 变量，这种能记住外部变量的函数称为闭包。

4.4 匿名函数（Lambdas）

使用 lambda 关键字可以创建匿名函数。以下是一个简单的 lambda 函数，用于将输入值加 2：

>>> lambda x: x + 2
<function __main__.<lambda>(x)>

直接调用该 lambda 函数：

>>> (lambda x: x + 2)(7)
9

以下是一个接受两个输入变量的 lambda 函数：

>>> (lambda x,y: x + 2 * y)(2,3)
8

也可以将 lambda 函数绑定到变量，但这在一定程度上违背了使用匿名函数的初衷：

>>> plus2 = lambda x: x + 2
>>> plus2(5)
7

lambda 函数应谨慎使用，若函数功能复杂，最好为其命名。例如， make_power_function 可以用 lambda 函数等价实现：

def make_power_function(p):
    return lambda x: x ** p

测试：

>>> make_power_function(2)(3)
9

此外，lambda 函数还可作为函数的输入。例如，要将 0 到 9 的每个数字加 2，可使用 map 函数：

map(lambda x: x + 2, range(0,9))

要查看结果，需将其转换为列表。不过，在大多数情况下，使用列表推导式更简洁易读：

[x+2 for x in range(0,9)]

4.5 将函数应用于 NumPy 数组

NumPy 提供了一些与 Python 内置数学函数对应的版本，这些函数可同时应用于 NumPy 数组的每个元素。例如， np.sqrt 可计算单个数字或整个 NumPy 数组的平方根：

>>> np.sqrt(np.arange(0,10))
array([0.        , 1.        , 1.41421356, 1.73205081, 2.        ,
       2.23606798, 2.44948974, 2.64575131, 2.82842712, 3.        ])

若要将自定义函数应用于 NumPy 数组的每个元素，可使用 np.vectorize 函数。以下是一个自定义函数及其向量化应用的示例：

def my_function(x):
    if x % 2 == 0:
        return x/2
    else:
        return 0

my_numpy_function = np.vectorize(my_function)
>>> my_numpy_function(np.arange(0,10))
array([0., 0., 1., 0., 2., 0., 3., 0., 4., 0.])

5. 使用 Matplotlib 进行数据可视化

Matplotlib 是 Python 中最流行的绘图库，可用于创建数据集的图表、函数图像和几何图形。若使用 Anaconda，通常已预装 Matplotlib；否则，可使用 pip install matplotlib 进行安装。

5.1 创建散点图

散点图适用于将有序数对 (x, y) 可视化为平面上的点。创建散点图的步骤如下：
1. 安装并导入 Matplotlib 的 pyplot 模块，常用别名 plt ：

import matplotlib.pyplot as plt

2. 定义 x 和 y 值的列表。例如，要绘制 (1, 1) 、 (2, 4) 、 (3, 9) 、 (4, 16) 和 (5, 25) 这些点的散点图：

x_values = [1,2,3,4,5]
y_values = [1,4,9,16,25]

3. 使用 plt.scatter 函数绘制散点图：

plt.scatter(x_values,y_values)

Matplotlib 会自动调整图形范围以适应所有点。还可使用关键字参数自定义散点图的外观，例如设置点的形状和颜色：

plt.scatter(x_values,y_values,marker='x',c='red')

更多关键字参数和自定义选项可参考 Matplotlib 官方文档 。

5.2 创建折线图

使用 plt.plot 函数可将点用线连接起来，形成折线图。例如：

plt.plot(x_values,y_values)

一个实用的应用是指定两个点来绘制线段。以下是一个 plot_segment 函数，用于绘制两点之间的线段：

def plot_segment(p1,p2):
    x1,y1 = p1
    x2,y2 = p2
    plt.plot([x1,x2],[y1,y2],marker='o')

使用示例：

point1 = (0,3)
point2 = (2,1)
plot_segment(point1,point2)

plot_segment 函数是一个包装函数，使用它可以更方便地绘制线段，而无需直接使用 Matplotlib 函数。

综上所述，本文介绍了 Python 中数据集合（如 NumPy 数组和字典）的使用，以及一些有用的集合函数。同时，详细讲解了函数的定义、使用和高级特性，包括可变参数、关键字参数、函数作为数据以及匿名函数。最后，介绍了如何使用 Matplotlib 进行数据可视化，包括创建散点图和折线图。这些知识将帮助你更高效地处理数据和进行可视化分析。

Python 数据处理与可视化全攻略

6. 总结与对比

为了更清晰地理解上述内容，我们可以通过表格对一些重要的概念和函数进行总结对比。

概念/函数	描述	示例代码
NumPy 数组	用于高效数值计算的集合，许多 Python 库函数要求输入该类型	python<br>import numpy as np<br>arr = np.array([1, 2, 3])<br>
字典	通过键来访问元素的数据集合	python<br>dog = {"name": "Melba", "age": 2}<br>
sum 函数	对可迭代的数字求和	python<br>sum([1, 2, 3])<br>
max 函数	返回可迭代对象中的最大值	python<br>max([1, 2, 3])<br>
min 函数	返回可迭代对象中的最小值	python<br>min([1, 2, 3])<br>
sorted 函数	返回一个排序后的新列表，原列表顺序不变	python<br>q = [3, 4, 1, 2, 5]<br>sorted(q)<br>
reversed 函数	返回一个反转后的可迭代对象，原对象顺序不变	python<br>q = [3, 4, 1, 2, 5]<br>list(reversed(q))<br>
add 函数（自定义）	接受可变数量的参数并求和	python<br>def add(*args):<br> total = 0<br> for x in args:<br> total += x<br> return total<br>
birthday 函数（自定义）	接受关键字参数生成生日祝福语	python<br>def birthday(name="friend", age=None):<br> s = "Happy birthday, %s" % name<br> if age:<br> s += ", you're %d years old" % age<br> return s + "!"<br>
evaluate 函数（自定义）	接受一个函数和一个值，返回函数调用结果	python<br>def evaluate(f, x):<br> return f(x)<br>
map 函数	将函数应用于可迭代对象的每个元素	python<br>map(square, range(10))<br>
匿名函数（Lambdas）	使用 lambda 关键字创建的无名称函数	python<br>lambda x: x + 2<br>

7. 操作流程梳理

下面通过 mermaid 格式的流程图来梳理使用 NumPy 数组和 Matplotlib 绘图的基本操作流程。

graph LR
    classDef startend fill:#F5EBFF,stroke:#BE8FED,stroke-width:2px
    classDef process fill:#E5F6FF,stroke:#73A6FF,stroke-width:2px

    A([开始]):::startend --> B(安装 NumPy 和 Matplotlib):::process
    B --> C(导入 NumPy 和 Matplotlib.pyplot):::process
    C --> D(创建 NumPy 数组):::process
    D --> E{是否进行数据处理?}:::process
    E -- 是 --> F(使用 NumPy 函数处理数组):::process
    E -- 否 --> G{是否进行可视化?}:::process
    F --> G
    G -- 是 --> H(准备绘图数据):::process
    G -- 否 --> I([结束]):::startend
    H --> J(选择绘图类型):::process
    J --> K(使用 Matplotlib 函数绘图):::process
    K --> L(自定义绘图外观):::process
    L --> M(显示或保存图形):::process
    M --> I

8. 实际应用场景举例

在实际的数据处理和分析中，上述知识可以应用于多个场景。

8.1 数据分析中的数据预处理

在进行数据分析时，常常需要对数据进行预处理，例如对数据进行排序、求和等操作。以下是一个简单的示例，假设我们有一组学生的成绩数据，需要计算总分和平均分：

scores = [85, 90, 78, 92, 88]

# 计算总分
total_score = sum(scores)

# 计算平均分
average_score = total_score / len(scores)

print(f"总分: {total_score}")
print(f"平均分: {average_score}")

8.2 函数式编程在数据转换中的应用

在函数式编程中，我们可以使用 map 函数和匿名函数对数据进行转换。例如，将一组温度数据从摄氏度转换为华氏度：

celsius_temperatures = [20, 25, 30, 35]

# 定义转换函数
fahrenheit_temperatures = list(map(lambda c: c * 9/5 + 32, celsius_temperatures))

print(f"摄氏度温度: {celsius_temperatures}")
print(f"华氏度温度: {fahrenheit_temperatures}")

8.3 数据可视化在趋势分析中的应用

在分析数据趋势时，我们可以使用 Matplotlib 绘制折线图来直观地展示数据的变化。以下是一个简单的示例，展示某公司每月销售额的变化趋势：

import matplotlib.pyplot as plt

# 每月销售额数据
months = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
sales = [10000, 12000, 13000, 15000, 16000, 18000, 20000, 22000, 23000, 25000, 26000, 28000]

# 绘制折线图
plt.plot(months, sales)

# 设置图表标题和坐标轴标签
plt.title("Monthly Sales Trend")
plt.xlabel("Month")
plt.ylabel("Sales Amount")

# 显示图表
plt.show()

9. 注意事项

在使用上述知识时，还需要注意以下几点：

• NumPy 数组操作 ：在使用 np.arange 函数时，要注意步长的设置，特别是当步长为浮点数时，可能会出现精度问题。
• 字典操作 ：访问字典中不存在的键会引发 KeyError 异常，可使用 get 方法避免该问题，例如 dog.get("breed", "Unknown") 。
• 函数使用 ：在使用可变参数和关键字参数时，要确保函数内部逻辑正确处理这些参数，避免出现意外结果。
• Matplotlib 绘图 ：在绘制图形时，要注意图形的大小、比例和标签的设置，以确保图形的可读性和美观性。

10. 拓展学习建议

如果你想进一步深入学习 Python 数据处理和可视化，可以参考以下建议：

• 学习更多 NumPy 函数 ：NumPy 提供了丰富的函数库，如矩阵运算、统计分析等，可以进一步学习这些函数的使用。
• 掌握 Matplotlib 高级绘图技巧 ：除了散点图和折线图，Matplotlib 还支持绘制柱状图、饼图、箱线图等多种图形，可深入学习这些图形的绘制方法。
• 学习 Pandas 库 ：Pandas 是一个强大的数据处理和分析库，与 NumPy 和 Matplotlib 结合使用，可以更高效地处理和可视化数据。
• 实践项目 ：通过参与实际的数据分析项目，将所学知识应用到实际场景中，提高自己的实践能力。

通过不断学习和实践，你将能够熟练掌握 Python 数据处理和可视化的技能，为数据分析和科学研究提供有力支持。