数据分析是一个通过统计测量和可视化，从数据中探索、研究和收集洞见的过程。

数据分析的目标是通过揭示趋势、关系和模式来开发一种对数据的理解。

数据分析既是一门科学，也是一门艺术。一方面，它需要你了解统计、可视化技术和数据分析工具，如 Numpy、Pandas 和 Seaborn。

另一方面，它需要你提出有趣的问题来指导研究，然后解释数字和图表以产生有用的见解。

本数据分析教程涵盖以下主题：

1. 什么是数值计算？Python 和 Numpy 入门
2. 如何使用 Python 和 Pandas 分析表格数据
3. 使用 Python、Matplotlib 和 Seaborn 进行数据可视化

什么是数值计算？Python 和 Numpy 入门

上图来源：Elegant Scipy。

你可以跟随教程操作并在此处运行代码：https://jovian.ai/aakashns/python-numerical-computing-with-numpy

本节涵盖以下主题：

• 如何在 Python 中处理数值数据
• 如何将 Python 列表转换为 Numpy 数组
• 多维 Numpy 数组及其优点
• 数组操作、广播、索引和切片
• 如何使用 Numpy 处理 CSV 数据文件

如何在 Python 中处理数值数据

数据分析 中的“数据”通常是指数值数据，如股票价格、销售数据、传感器测量值、体育得分、数据库表等。

Numpy 库为 Python 中的数值计算提供专门的数据结构、函数和其他工具。让我们通过一个例子来看看为何以及如何使用 Numpy 处理数值数据。

假设我们想使用温度、降雨量和湿度这些气象数据来考察一个区域是否适合种苹果。

一个简单的方法是制定苹果的年产量（每公顷吨）与气候条件之间的线性关系，如平均温度（以华氏度为单位）、降雨量（以毫米为单位）和平均相对湿度（以百分比为单位）。

苹果产量 = w1 * 温度 + w2 * 降雨量 + w3 * 湿度

我们将苹果的产量表示为温度、降雨量和湿度的加权和。

这个方程是一个近似值，因为实际关系不一定是线性的，可能还涉及其他因素。但像这样的简单线性模型用在练习中效果较好。

基于一些历史数据的统计分析，我们大致可以为权重w1，w2 和 w3 提供合理的值。下面例举了一组值：

w1, w2, w3 = 0.3, 0.2, 0.5

给定一个地区的一些气候数据，我们就可以预测苹果的产量了。以下是一些示例数据：

首先，我们定义一些变量来记录一个地区的气候数据。

kanto_temp = 73
kanto_rainfall = 67
kanto_humidity = 43

然后，我们就可以将这些变量代入线性方程来预测苹果的产量了。

kanto_yield_apples = kanto_temp * w1 + kanto_rainfall * w2 + kanto_humidity * w3
kanto_yield_apples
# 56.8

print("The expected yield of apples in Kanto region is {} tons per hectare.".format(kanto_yield_apples))
# Kanto 地区苹果的预期产量为每公顷 56.8 吨。

为了能更容易地对多个区域执行上述的计算，我们可以将每个区域的气候数据表示为向量，即数字列表。

kanto = [73, 67, 43]
johto = [91, 88, 64]
hoenn = [87, 134, 58]
sinnoh = [102, 43, 37]
unova = [69, 96, 70]

每个向量中的三个数字分别代表温度、降雨量和湿度数据。

我们还可以将公式中使用的权重集表示为一个向量。

weights = [w1, w2, w3]

现在我们就可以编写一个函数 crop_yield，通过给定的气候数据和相应权重，来计算苹果（或任何其他作物）的产量了。

def crop_yield(region, weights):
    result = 0
    for x, w in zip(region, weights):
        result += x * w
    return result
    
crop_yield(kanto, weights)
# 56.8

crop_yield(johto, weights)
# 76.9

crop_yield(unova, weights)
# 74.9

如何将 Python 列表转换为 Numpy 数组

crop_yield 执行的计算（两个向量的元素相乘并对结果求和）也称为 点积。从 这里 了解更多点积的信息。

Numpy 库提供了一个内置函数来计算两个向量的点积。但是，我们必须先将列表转换为 Numpy 数组才行。

我们使用 pip 包管理器安装 Numpy 库。

!pip install numpy --upgrade --quiet

接下来，让我们导入 numpy 模块。导入 numpy 时通常使用别名 np。

import numpy as np

现在，我们可以使用 np.array 函数创建 Numpy 数组。

kanto = np.array([73, 67, 43])

kanto
# array([73, 67, 43])

weights = np.array([w1, w2, w3])

weights
# array([0.3, 0.2, 0.5])

Numpy 数组的类型为 ndarray。

type(kanto)
# numpy.ndarray

type(weights)
# numpy.ndarray

与列表一样，Numpy 数组也支持索引符号 []。

weights[0]
# 0.3

kanto[2]
#43

如何操作 Numpy 数组

我们可以使用 np.dot 函数来计算两个向量的点积。

np.dot(kanto, weights)
# 56.8

我们可以通过 Numpy 数组支持的底层操作实现相同的结果：执行元素相乘并计算所得数字之和。

(kanto * weights).sum()
# 56.8

如果两个数组的大小相同，* 操作符将执行元素相乘。sum 方法计算数组中数字的总和。

arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])

arr1 * arr2
# array([ 4, 10, 18])

arr2.sum()
# 15

使用 Numpy 数组有什么好处？

与 Python 的列表相比，Numpy 数组在操作数值数据方面具有以下优势：

• **它们很容易 使用：你可以编写像 (kanto * weights).sum() 这样的小型、简洁和直观的数学表达式，而不是使用循环和自定义函数（如 crop_yield）。
• 性能：Numpy 的操作和函数由 C++ 内部实现，这使得它们比使用 Python 的语句和循环快得多，因为后者是在运行时解释的。

以下是对 Python 循环和 Numpy 数组执行的点积的比较，使用两个向量，每个都有一百万个元素。

# Python lists
arr1 = list(range(1000000))
arr2 = list(range(1000000, 2000000))

# Numpy arrays
arr1_np = np.array(arr1)
arr2_np = np.array(arr2)

%%time
result = 0
for x1, x2 in zip(arr1, arr2):
    result += x1*x2
result

# CPU times: user 300 ms, sys: 3.26 ms, total: 303 ms
# Wall time: 302 ms
# 833332333333500000

%%time
np.dot(arr1_np, arr2_np)

# CPU times: user 2.11 ms, sys: 951 µs, total: 3.07 ms
# Wall time: 1.58 ms
# 833332333333500000

如你所见，使用 np.dot 比使用 for 循环快 100 倍。这使得 Numpy 处理非常大的数据集时非常有用，特别是那些具有数万或数百万个数据点时。

多维 Numpy 数组

现在让我们更进一步，使用单个二维 Numpy 数组来表示所有地区的气候数据。

climate_data = np.array([[73, 67, 43],
                         [91, 88, 64],
                         [87, 134, 58],
                         [102, 43, 37],
                         [69, 96, 70]])
                         
climate_data
# array([[ 73,  67,  43],
#        [ 91,  88,  64],
#        [ 87, 134,  58],
#        [102,  43,  37],
#        [ 69,  96,  70]])

如果你在高中时学过线性代数课，你会把上面的二维数组看作是一个五行三列的矩阵。每一行代表一个区域，列分别代表温度、降雨量和湿度。

Numpy 数组可以有任意数量的维度，每个维度可以有不同的长度。可以通过数组的 .shape 属性来检查每个维度的长度。

上图来源：Elegant Scipy。

# 2D array (matrix)
climate_data.shape
# (5, 3)

weights
# array([0.3, 0.2, 0.5])

# 1D array (vector)
weights.shape
# (3,)

# 3D array 
arr3 = np.array([
    [[11, 12, 13], 
     [13, 14, 15]], 
    [[15, 16, 17], 
     [17, 18, 19.5]]])

arr3.shape
# (2, 2, 3)

Numpy 数组中的所有元素都具有相同的数据类型。你可以使用 .dtype 属性检查数组的数据类型。

weights.dtype
# dtype('float64')

climate_data.dtype
# dtype('int64')

如果数组中包含一个浮点数，所有其他元素也会转换为浮点数。

arr3.dtype
# dtype('float64')

通过 climate_data （一个 5x3 的矩阵）和 weights （一个长度为 3 的向量）之间的单一矩阵乘法，我们就可以计算出所预测的苹果产量了。看起来就像下面这样：

通过观看这个 YouTube 播放列表的前 3-4 个视频，你可以学到矩阵及矩阵乘法。

我们可以使用 np.matmul 函数或者 @ 操作符来执行矩阵乘法。

np.matmul(climate_data, weights)
# array([56.8, 76.9, 81.9, 57.7, 74.9])

climate_data @ weights
# array([56.8, 76.9, 81.9, 57.7, 74.9])

如何处理 CSV 数据文件

Numpy 同样提供辅助函数来对文件进行读写。我们来下载一个文件 climate.txt，它包含了 10,000 个气候测量结果（温度、降雨量和湿度），格式如下：

temperature,rainfall,humidity
25.00,76.00,99.00
39.00,65.00,70.00
59.00,45.00,77.00
84.00,63.00,38.00
66.00,50.00,52.00
41.00,94.00,77.00
91.00,57.00,96.00
49.00,96.00,99.00
67.00,20.00,28.00
...

这种存储数据的格式称为 comma-separated values 或者 CSV。

CSVs：逗号分隔值（CSV）文件是使用逗号分隔值的分隔文本文件。文件的每一行就是一条数据记录。每条记录包括一个或多个字段，以逗号隔开。CSV 文件通常以纯文本形式存储表格数据（数字和文本），因此每行都有相同数量的字段。（维基百科）

我们使用 genfromtxt 函数来把这个文件读入一个到 numpy 数组中。

import urllib.request

urllib.request.urlretrieve(
    'https://hub.jovian.ml/wp-content/uploads/2020/08/climate.csv', 
    'climate.txt')
    
climate_data = np.genfromtxt('climate.txt', delimiter=',', skip_header=1)

climate_data
# array([[25., 76., 99.],
#        [39., 65., 70.],
#        [59., 45., 77.],
#        ...,
#        [99., 62., 58.],
#        [70., 71., 91.],
#        [92., 39., 76.]])

climate_data.shape
# (10000, 3)

现在，我们可以使用 @ 运算符执行矩阵乘法，利用给定的权重集预测整个数据集的苹果产量。

weights = np.array([0.3, 0.2, 0.5])

yields = climate_data @ weights
yields
# array([72.2, 59.7, 65.2, ..., 71.1, 80.7, 73.4])

yields.shape
# (10000,)

让我们使用 np.concatenate 函数将产量添加到 climate_data 中，作为第四列。

climate_results = np.concatenate((climate_data, yields.reshape(10000, 1)), axis=1)

climate_results
# array([[25. , 76. , 99. , 72.2],
#        [39. , 65. , 70. , 59.7],
#        [59. , 45. , 77. , 65.2],
#        ...,
#        [99. , 62. , 58. , 71.1],
#        [70. , 71. , 91. , 80.7],
#        [92. , 39. , 76. , 73.4]])

这里有几个微妙之处：

• 由于我们希望添加新列，我们把参数 axis=1 传给 np.concatenate。axis 参数指定了串联的维度。
• 数组必须有相同数量的维度，每个维度长度要相同，除了用于串联的维度。我们使用 np.reshape 函数来将 yields 的形状从 (10000,) 改到 (10000,1)。

以下是在 axis=1 时 np.concatenate 的一个直观解释（你能猜出 axis=0 的结果是什么吗？）：

上图来源：w3resource.com。

理解 Numpy 函数的最好方式是是对其进行试验并阅读文档以了解其参数和返回值。使用下面的单元格来试验 np.concatenate 和 np.reshape。

让我们使用 np.savetxt 函数来将上面计算的最终结果写回到文件中。

np.savetxt('climate_results.txt', 
           climate_results, 
           fmt='%.2f', 
           delimiter=',',
           header='temperature,rainfall,humidity,yeild_apples', 
           comments='')

结果以 CSV 格式写回文件 climate_results.txt。

temperature,rainfall,humidity,yeild_apples
25.00,76.00,99.00,72.20
39.00,65.00,70.00,59.70
59.00,45.00,77.00,65.20
84.00,63.00,38.00,56.80
...

Numpy 提供了数百个用于对数组执行操作的函数。以下是一些常用的函数：

• 数学：np.sum、np.exp、np.round，以及算术运算符
• 数组操作：np.reshape、np.stack、np.concatenate、np.split
• 线性代数：np.matmul、np.dot、np.transpose、np.eigvals
• 统计：np.mean、np.median、np.std、np.max

那么如何找到你需要的函数呢？ 要找到特定操作或用例的正确函数，最简单的方法就是网络搜索。例如，搜索“如何连接 numpy 数组”，就会找到数组连接教程。

你可以在这里找到数组函数的完整列表.

Numpy 算术运算、广播和比较

Numpy 数组支持像 +，-，* 等的算术运算。你可以对一个单一的数字（也称为标量）或者具有同样形状的数组进行算术运算。

运算符让编写具有多维数组的数学表达式变得很容易。

arr2 = np.array([[1, 2, 3, 4], 
                 [5, 6, 7, 8], 
                 [9, 1, 2, 3]])
                 
arr3 = np.array([[11, 12, 13, 14], 
                 [15, 16, 17, 18], 
                 [19, 11, 12, 13]])
                 
# Adding a scalar
arr2 + 3

# array([[ 4,  5,  6,  7],
#        [ 8,  9, 10, 11],
#        [12,  4,  5,  6]])

# Element-wise subtraction
arr3 - arr2

# array([[10, 10, 10, 10],
#        [10, 10, 10, 10],
#        [10, 10, 10, 10]])

# Division by scalar
arr2 / 2

# array([[0.5, 1. , 1.5, 2. ],
#        [2.5, 3. , 3.5, 4. ],
#        [4.5, 0.5, 1. , 1.5]])

# Element-wise multiplication
arr2 * arr3

# array([[ 11,  24,  39,  56],
#        [ 75,  96, 119, 144],
#        [171,  11,  24,  39]])

# Modulus with scalar
arr2 % 4

# array([[1, 2, 3, 0],
#        [1, 2, 3, 0],
#        [1, 1, 2, 3]])

Numpy 数组广播

Numpy 数组也支持 广播，允许在具有不同维数但形状兼容的两个数组之间进行算术运算。让我们通过一个例子来看看它是如何工作的。

arr2 = np.array([[1, 2, 3, 4], 
                 [5, 6, 7, 8], 
                 [9, 1, 2, 3]])               
arr2.shape
# (3, 4)

arr4 = np.array([4, 5, 6, 7])
arr4.shape
# (4,)

arr2 + arr4
# array([[ 5,  7,  9, 11],
#        [ 9, 11, 13, 15],
#        [13,  6,  8, 10]])

当计算表达式 arr2 + arr4 时，arr4 (形状为 (4,)）被复制了三次以匹配 arr2 的形状 (3, 4)。Numpy 执行复制时，并不真实地去创建较小维度数组的三个副本，这样就提高了性能，并使用更少的内存。

上图来源：Python 数学科学手册。

只有当一个数组可以复制以匹配另一个数组的形状时，广播才有效。

arr5 = np.array([7, 8])
arr5.shape
# (2,)

arr2 + arr5
# ValueError: operands could not be broadcast together with shapes (3,4) (2,) 

在上面的例子中，即使 arr5 被复制三次，它并不能匹配 arr2 的形状。所以无法成功计算 arr2 + arr5。在此处学习有关广播的更多信息.

Numpy 数组比较

Numpy 数组也支持像 ==、!=、> 等这样的比较操作符。比较结果是一个布尔值数组。

arr1 = np.array([[1, 2, 3], [3, 4, 5]])
arr2 = np.array([[2, 2, 3], [1, 2, 5]])

arr1 == arr2
# array([[False,  True,  True],
#        [False, False,  True]])

arr1 != arr2
# array([[ True, False, False],
#        [ True,  True, False]])

arr1 >= arr2
# array([[False,  True,  True],
#        [ True,  True,  True]])

arr1 < arr2
# array([[ True, False, False],
#        [False, False, False]])

数组比较经常使用 sum 方法来计算两个数组中相等元素的数量。请记住，在算术运算中使用布尔值时，True 被视为 1，而False 被视为 0。

(arr1 == arr2).sum()
# 3

Numpy 数组索引和切片

Numpy 以一种直观的方式，将 Python 的列表索引符号 [] 扩展到多个维度。你可以提供一个以逗号分隔的索引或范围列表，来从 Numpy 数组中选择一个指定的元素或者一个子数组（也称为切片）。

arr3 = np.array([
    [[11, 12, 13, 14], 
     [13, 14, 15, 19]], 
    
    [[15, 16, 17, 21], 
     [63, 92, 36, 18]], 
    
    [[98, 32, 81, 23],      
     [17, 18, 19.5, 43]]])
     
arr3.shape
# (3, 2, 4)

# Single element
arr3[1, 1, 2]

# 36.0

# Subarray using ranges
arr3[1:, 0:1, :2]

# array([[[15., 16.]],
# 
#        [[98., 32.]]])

# Mixing indices and ranges
arr3[1:, 1, 3]

# array([18., 43.])

arr3[1:, 1, :3]
# array([[63. , 92. , 36. ],
#        [17. , 18. , 19.5]])

# Using fewer indices
arr3[1]

# array([[15., 16., 17., 21.],
#        [63., 92., 36., 18.]])

arr3[:2, 1]
# array([[13., 14., 15., 19.],
#        [63., 92., 36., 18.]])

# Using too many indices
arr3[1,3,2,1]

# IndexError: too many indices for array: array is 3-dimensional, but 4 were indexed

符号及其结果起初看起来会有点困惑，因此请花点时间进行实验并适应它。

请用下面的单元格，使用不同的索引和范围组合，尝试进行数组索引和切片的一些示例。以下是一些直观演示的示例：

上图来源：Scipy 讲座。

如何用其他方法创建 Numpy 数组

Numpy 还提供了一些简便的函数来创建具有固定或随机形状的数组。查阅官方文档或者使用 help 函数来了解更多。

# All zeros
np.zeros((3, 2))

# array([[0., 0.],
#        [0., 0.],
#        [0., 0.]])

# All ones
np.ones([2, 2, 3])

# array([[[1., 1., 1.],
#         [1., 1., 1.]],
#
#        [[1., 1., 1.],
#         [1., 1., 1.]]])

# Identity matrix
np.eye(3)

# array([[1., 0., 0.],
#        [0., 1., 0.],
#        [0., 0., 1.]])

# Random vector
np.random.rand(5)

# array([0.92929562, 0.11301864, 0.64213555, 0.8600434 , 0.53738656])

# Random matrix
np.random.randn(2, 3) # rand vs. randn - what's the difference?

# array([[ 0.09906435, -1.64668094,  0.08073528],
#        [ 0.1437016 ,  0.80715712,  1.27285476]])

# Fixed value
np.full([2, 3], 42)

# array([[42, 42, 42],
#        [42, 42, 42]])

# Range with start, end and step
np.arange(10, 90, 3)

# array([10, 13, 16, 19, 22, 25, 28, 31, 34, 37, 40, 43, 46, 49, 52, 55, 58,
#        61, 64, 67, 70, 73, 76, 79, 82, 85, 88])

# Equally spaced numbers in a range
np.linspace(3, 27, 9)

# array([ 3.,  6.,  9., 12., 15., 18., 21., 24., 27.])

练习

尝试以下练习来熟悉 Numpy 数组，锻炼你的技能：

• Numpy 数组函数的赋值：https://jovian.ml/aakashns/numpy-array-operations
• （选做）100个 Numpy 小练习：https://jovian.ml/aakashns/100-numpy-exercises

总结和进一步阅读

到此，我们完成了用 Numpy 进行数值计算的讨论。本教程的这一部分，我们介绍了以下主题：

• 如何从 Python 列表转到 Numpy 数组
• 如何操作 Numpy 数组
• 相对列表而言，使用 Numpy 数组的优势
• 多维 Numpy 数组
• 如何处理 CSV 数据文件
• 算术运算与广播
• 数组索引和切片
• 创建 Numpy 的其他方法

查阅以下资源以学习更多 Numpy 知识：

• 官方文档
• freeCodeCamp 上的 Numpy 教程
• 高级 Numpy（探索内部结构）

回顾问题以检验你的掌握程度

尝试回答以下问题来测试你对本文前面话题的掌握程度：

1. 什么是向量？
2. 如何用 Python 列表来表示向量？请举例。
3. 什么是两个向量的点积？
4. 写一个函数来计算两个向量的点积。
5. 什么是 Numpy？
6. 如何安装 Numpy？
7. 如何导入 numpy 模块？
8. 用别名导入一个模块意味着什么？请举例。
9. 通常使用的 numpy 别名是什么？
10. 什么是 Numpy 数组？
11. 如何创建 Numpy 数组？请举例。
12. 什么是 Numpy 数组的类型？
13. 如何访问 Numpy 数组的元素？
14. 如何使用 Numpy 计算两个向量的点积？
15. 如果尝试计算具有不同大小的两个向量的点积，会怎么样？
16. 如何计算两个 Numpy 数组的元素乘积？
17. 如何计算 Numpy 数组中所有元素的总和？
18. 相对 Python 列表，使用 Numpy 数组处理数值数据的优势是什么？
19. 为什么 Numpy 数组操作比 Python 函数和循环具有更好的性能？
20. 举例说明 Numpy 数组操作和 Python 循环之间的性能差异。
21. 什么是多维 Numpy 数组？
22. 举例说明如何创建 2、3 和 4 维的 Numpy 数组。
23. 如何查看 Numpy 数组的维度数量以及每个维度的长度？
24. Numpy 数组中的元素可以有不同的数据类型吗？
25. 如何查看 Numpy 数组中元素的数据类型？
26. Numpy 数组的数据类型是什么？
27. 矩阵和二维 Numpy 数组的区别是什么？
28. 如何用 Numpy 执行矩阵乘法？
29. Numpy 中的 @ 操作符用于做什么？
30. 什么是 CSV 文件格式？
31. 如何使用 Numpy 从 CSV 文件中读取数据？
32. 如何连接两个 Numpy 数组？
33. np.concatenate 的 axis 参数的作用是什么？
34. 什么时候两个 Numpy 数组可以兼容连接？
35. 给出一个能进行连接的两个 Numpy 数组的例子。
36. 给出一个不能进行连接的两个 Numpy 数组的例子。
37. np.reshape 函数的作用是什么？
38. “reshape”一个 Numpy 数组是什么意思？
39. 如何将 numpy 数组写入 CSV 文件？
40. 给出一些用于执行数学运算的 Numpy 函数示例。
41. 给出一些用于执行数组操作的 Numpy 函数示例。
42. 给出一些用于执行线性代数的 Numpy 函数示例。
43. 给出一些用于执行统计运算的 Numpy 函数示例。
44. 如何为特定操作或用例找到正确的 Numpy 函数？
45. 在哪里可以看到所有 Numpy 数组函数和操作的列表？
46. Numpy 数组支持哪些算术运算符？举例说明。
47. 什么是数组广播？它如何有用？举例说明。
48. 给出一些兼容广播的数组的例子。
49. 给出一些不兼容广播的数组的例子。
50. Numpy 数组支持哪些比较运算符？举例说明。
51. 如何从 Numpy 数组访问特定的子数组或切片？
52. 通过一些示例说明多维 Numpy 数组中的数组索引和切片。
53. 如何创建一个全为0的给定形状的 Numpy 数组？
54. 如何创建一个全为1的给定形状的 Numpy 数组？
55. 如何创建给定形状的单位矩阵？
56. 如何创建一个给定长度的随机向量？
57. 如何创建给定形状且每个元素具有固定值的Numpy数组？
58. 如何创建给定形状且每个元素具有随机初始值的Numpy数组？
59. np.random.rand 与 np.random.randn 的区别是什么？举例说明。
60. np.arange 与 np.linspace 的区别是什么？举例说明。

现在，你已经准备好进入本教程的下一节了。

如何用 Python 和 Pandas 分析表格数据

按照下面的步骤运行代码：https://jovian.ai/aakashns/python-pandas-data-analysis。

本节包含以下主题：

• 如何将 CSV 文件读入到 Pandas 数据帧
• 如何从 Pandas 数据帧中获得数据
• 如何查询、排序和分析数据
• 如何合并、分组和汇总数据
• 如何从日期中提取有用信息
• 使用直线图和条形图进行基本绘图
• 如何将数据帧写到 CSV 文件中

如何用 Pandas 读取 CSV 文件

Pandas 是一个非常流行的 Python 库，用于处理表格数据（类似于存在电子表格中的数据）。 它提供了辅助函数，用以从各种文件格式（如CSV、Excel电子表格、HTML表格、JSON、SQL等）中读取数据。

我们下载一个文件 italy-covid-daywise.txt，里面包含了意大利每日的 Covid-19 数据，格式如下：

date,new_cases,new_deaths,new_tests
2020-04-21,2256.0,454.0,28095.0
2020-04-22,2729.0,534.0,44248.0
2020-04-23,3370.0,437.0,37083.0
2020-04-24,2646.0,464.0,95273.0
2020-04-25,3021.0,420.0,38676.0
2020-04-26,2357.0,415.0,24113.0
2020-04-27,2324.0,260.0,26678.0
2020-04-28,1739.0,333.0,37554.0
...

这种存储数据的格式被称为 comma-separated values 或者 CSV。如果你需要 CSV 格式的定义，可以参考以下：

CSVs：逗号分隔值（CSV）文件是一种用逗号分隔数值的分隔文本文件。文件中的每一行都是一条数据记录。每一条记录包含一个或多个字段，以逗号隔开。CSV 文件通常以纯文本形式存储表格数据（数字和文本），每一行拥有相同数量的字段。（维基百科）

我们使用 urlretrieve 函数从 urllib.request 模块中下载这个文件。

from urllib.request import urlretrieve

urlretrieve('https://hub.jovian.ml/wp-content/uploads/2020/09/italy-covid-daywise.csv', 'italy-covid-daywise.csv')

要读取文件，我们可以使用 Pandas 的 read_csv 方法。首先，让我们安装 Pandas 库。

!pip install pandas --upgrade --quiet

现在我们可以导入 pandas 模块。按照惯例，导入时会使用别名 pd。

import pandas as pd

covid_df = pd.read_csv('italy-covid-daywise.csv')

文件中的数据被读取并存到 DataFrame 对象——它是 Pandas 中的一个核心数据结构，用于存储和处理表格数据。通常我们在数据帧的变量名称中使用 _df 后缀。

type(covid_df)
# pandas.core.frame.DataFrame

covid_df

以下是我们通过查看数据帧可以得知的信息：

• 该文件提供了意大利新冠肺炎的四项每日计数
• 报告的指标是确诊病例、死亡人数和测试人数
• 提供了248天的数据：从2019年12月12日到2020年9月3日

请记住，这些是官方报告的数字。实际病例和死亡人数可能更高，因为并非所有病例都被诊断出来。

我们可以通过 .info 方法来查看数据帧的一些基本信息。

covid_df.info()

看起来每一列都包含了一种特定数据类型的值。你可以通过 .describe 方法来查看数值列的统计信息（平均值、标准偏差、最小值/最大值和非空值的数量）。

covid_df.describe()

columns 属性包含数据帧中的列列表。

covid_df.columns
# Index(['date', 'new_cases', 'new_deaths', 'new_tests'], dtype='object')

你还可以使用 .shape 方法获取数据帧的行数和列数。

covid_df.shape
# (248, 4)

下面是我们到目前为止所研究的函数和方法的总结：

• pd.read_csv – 将数据从 CSV 文件中读入到 Pandas 的 DataFrame 对象中
• .info() – 查看关于行、列和数据类型的基本信息
• .describe() – 查看数值列的统计信息
• .columns – 获取一个包含列名的列表
• .shape – 获取行数和列数作为一个数组

如何从 Pandas 数据帧中检索数据

你想做的首件事可能是从这个数据帧中检索数据，如一个指定日的计数，或者一个特定列的值列表。

为此，你应该了解数据帧中数据的内部表示方法。从概念上讲，你可以将数据帧视为一个字典列表：键是列名，值是包含相应列数据的列表或数组。

# Pandas format is simliar to this
covid_data_dict = {
    'date':       ['2020-08-30', '2020-08-31', '2020-09-01', '2020-09-02', '2020-09-03'],
    'new_cases':  [1444, 1365, 996, 975, 1326],
    'new_deaths': [1, 4, 6, 8, 6],
    'new_tests': [53541, 42583, 54395, None, None]
}

用上面的格式来表示数据具有以下几个好处：

• 列中的所有值通常具有相同类型的值，因此将它们存储在单个数组中更有效。
• 检索特定行的值只需要从每个列数组中提取给定索引处的元素。
• 与其他格式相比，如对每行数据使用字典，这种表示形式更加紧凑（列名只记录一次）（参见下面的示例）。

# Pandas 格式与此不相似
covid_data_list = [
    {'date': '2020-08-30', 'new_cases': 1444, 'new_deaths': 1, 'new_tests': 53541},
    {'date': '2020-08-31', 'new_cases': 1365, 'new_deaths': 4, 'new_tests': 42583},
    {'date': '2020-09-01', 'new_cases': 996, 'new_deaths': 6, 'new_tests': 54395},
    {'date': '2020-09-02', 'new_cases': 975, 'new_deaths': 8 },
    {'date': '2020-09-03', 'new_cases': 1326, 'new_deaths': 6},
]

与字典列表进行类比，你大概可以猜到如何从数据帧中检索数据。例如，我们可以使用 [] 索引符号来从一个指定列中获取值列表。

covid_data_dict['new_cases']
# [1444, 1365, 996, 975, 1326]

covid_df['new_cases']
# 0         0.0
# 1         0.0
# 2         0.0
# 3         0.0
# 4         0.0
#         ...  
# 243    1444.0
# 244    1365.0
# 245     996.0
# 246     975.0
# 247    1326.0
# Name: new_cases, Length: 248, dtype: float64

每一列都用名为 Series 的数据结构来表示，它本质上是一个包含额外方法和属性的 numpy 数组。

type(covid_df['new_cases'])
# pandas.core.series.Series

与数组一样，你也可以使用索引符号 [] 通过系列检索特定值。

covid_df['new_cases'][246]
# 975.0

covid_df['new_tests'][240]
57640.0

Pandas 还提供了 .at 方法，可直接检索特定行和列的元素。

covid_df.at[246, 'new_cases']
# 975.0

covid_df.at[240, 'new_tests']
# 57640.0

除了使用索引符号 [], Pandas 也允许使用 . 符号来将列作为数据帧的属性进行访问。但是，这个方法仅限于那些不包含空字符或者特殊字符的列。

covid_df.new_cases
# 0         0.0
# 1         0.0
# 2         0.0
# 3         0.0
# 4         0.0
#         ...  
# 243    1444.0
# 244    1365.0
# 245     996.0
# 246     975.0
# 247    1326.0
# Name: new_cases, Length: 248, dtype: float64

更进一步，你可以传递一个列的列表到索引符号 [] 中，用来访问这些列的数据帧的子集。

cases_df = covid_df[['date', 'new_cases']]
cases_df

新的数据帧 cases_df 只是原始数据帧 covid_df 的“视图”。两者都指向计算机内存中相同的数据。在其中一个更改值，另一个相应的值也会被更改。

在数据帧之间共享数据使得 Pandas 中的数据操作速度非常快。每次想要操作现有数据帧来创建新数据帧时，你都不必担心复制数千或数百万行导致的性能开销。

有些时候你需要数据帧的完整副本，这时你可以使用 copy 方法。

covid_df_copy = covid_df.copy()

covid_df_copy 中的数据与 covid_df 的是完全分开的，改变其中一个的值并不会影响另一个。

要访问特定的数据行，Pandas 提供了.loc 方法。

covid_df

covid_df.loc[243]
# date          2020-08-30
# new_cases         1444.0
# new_deaths           1.0
# new_tests        53541.0
# Name: 243, dtype: object

检索到的每一行也是一个 Series 对象。

type(covid_df.loc[243])
# pandas.core.series.Series

我们可以使用 .head 和 .tail 方法查看数据的前几行或最后几行。

covid_df.head(5)

covid_df.tail(4)

要注意的是，在 new_cases 和 new_deaths 列中，刚开始的一些值是 0，但是在 new_tests 列中对应的值是 NaN。那是因为这个 CSV 文件本身并没有特定日期的 new_tests 列的数据（你可以通过查看文件来验证这一点）。这些值可能缺失或未知。

covid_df.at[0, 'new_tests']
# nan

type(covid_df.at[0, 'new_tests'])
# numpy.float64

0 和 NaN 之间的区别很微妙但很重要。在此数据集中，它表示在指定日期没有报告每日测试数量。意大利从 2020 年 4 月 19 日开始报告每日测试数据。在 4 月 19 日之前，他们已经进行了 935,310 次测试。

我们可以使用列的 first_valid_index 方法找到不包含 NaN 值的第一个索引。

covid_df.new_tests.first_valid_index()
# 111

让我们查看此索引前后的几行，以验证值是否从 NaN 更改为实际数字。我们可以向loc传递一个范围来实现查看。

covid_df.loc[108:113]

我们可以使用 .sample 方法从数据帧中获取随机抽样行。

covid_df.sample(10)

注意，尽管我们采取了随机样品，每一行的原始索引都被保留了。这是数据帧非常有用的一个属性。

下面是本节我们看到的函数和方法的总结：

• covid_df['new_cases'] – 使用列名将列当作 Series 来检索
• new_cases[243] – 使用索引从 Series 中检索值
• covid_df.at[243, 'new_cases'] – 从数据帧中检索单个值
• covid_df.copy() – 创建数据帧的深度副本
• covid_df.loc[243] - 从数据帧中检索数据行或数据行范围
• head、tail 和 sample – 从数据帧中检索多行数据
• covid_df.new_tests.first_valid_index – 查找序列中的第一个非空索引

如何分析 Pandas 数据帧中的数据

让我们尝试回答这些数据的一些问题。

问：关于意大利新冠肺炎，总的确诊病例和死亡人数是多少？

与 Numpy 数组类似，Pandas 序列支持 sum 方法，这个问题也就回答了。

total_cases = covid_df.new_cases.sum()
total_deaths = covid_df.new_deaths.sum()

print('The number of reported cases is {} and the number of reported deaths is {}.'.format(int(total_cases), int(total_deaths)))
# The number of reported cases is 271515 and the number of reported deaths is 35497.

问：总的死亡率是多少（报告的死亡数除以确诊病例）？

death_rate = covid_df.new_deaths.sum() / covid_df.new_cases.sum()

print("The overall reported death rate in Italy is {:.2f} %.".format(death_rate*100))
# The overall reported death rate in Italy is 13.07 %.

问：进行测试的总人数是多少？在报告每日测试数量之前，共进行了 935，310 次测试。

initial_tests = 935310
total_tests = initial_tests + covid_df.new_tests.sum()

total_tests
# 5214766.0

问：哪些部分测试结果为阳性？

positive_rate = total_cases / total_tests

print('{:.2f}% of tests in Italy led to a positive diagnosis.'.format(positive_rate*100))
# 5.21% of tests in Italy led to a positive diagnosis.

尝试提问回答关于这些数据更多的问题。

如何在 Pandas 中对行进行查询和排序

假设我们只想查看确诊病例大于 1，000 的日子。那么可以使用布尔表达式来检查哪些行满足此条件。

high_new_cases = covid_df.new_cases > 1000

high_new_cases
# 0      False
# 1      False
# 2      False
# 3      False
# 4      False
#        ...  
# 243     True
# 244     True
# 245    False
# 246    False
# 247     True
# Name: new_cases, Length: 248, dtype: bool

布尔表达式返回一个包含 True 和 False 布尔值的序列。你可以使用这个序列从原始数据帧中选择行的子集，对应于这个序列中的 True 值。

covid_df[high_new_cases]

这个数据帧包含 72 行，但是为了简洁起见，默认情况下 Jupyter 只显示前五行和后五行。我们可以更改一些显示选项，来查看所有行。

high_cases_df = covid_df[covid_df.new_cases > 1000]

high_cases_df

我们还可以制定涉及多个列的更复杂的查询。例如，尝试确定确诊病例除以测试数量的比例高于总的 positive_rate 的日子。

positive_rate
# 0.05206657403227681

high_ratio_df = covid_df[covid_df.new_cases / covid_df.new_tests > positive_rate]

high_ratio_df

对两列进行操作的结果是一个新数列。

covid_df.new_cases / covid_df.new_tests
# 0           NaN
# 1           NaN
# 2           NaN
# 3           NaN
# 4           NaN
#          ...   
# 243    0.026970
# 244    0.032055
# 245    0.018311
# 246         NaN
# 247         NaN
# Length: 248, dtype: float64

我们可以使用该系列为数据帧添加新列。

covid_df['positive_rate'] = covid_df.new_cases / covid_df.new_tests

covid_df

但是，请记住，有时需要一些日子才能获得测试结果，因此，我们不能对同一天的新增病例数和测试数量进行比较。基于 positive_rate 列的任何推断都可能是不正确的。

注意这些微妙的联系是非常重要的，通常 CSV 文件中不会传达这些关系，而需要外部的上下文环境。通读数据集附带的文档或询问更多的信息，不失为一个好主意。

现在，让我们使用 drop 方法来移除 positive_rate 列。

covid_df.drop(columns=['positive_rate'], inplace=True)

你能指出 inplace 参数的目的吗？

如何在 Pandas 中使用列值对行进行排序

你可以使用 .sort_values 通过一个指定的列来对行进行排序。让我们排序以确定病例数最多的天数，然后使用 head 方法将其链接起来，只列出前十个结果。

covid_df.sort_values('new_cases', ascending=False).head(10)

看起来 3 月最后两周的每日病例数最多。让我们来对比所记录的死亡人数最多的日子。

covid_df.sort_values('new_deaths', ascending=False).head(10)

可以发现，每日死亡人数的顶峰出现在每日病例达到顶峰之后的一周。

我们也来看看病例数最少的日子。我们也许会想到一年中最开始的几天会出现在列表上。

covid_df.sort_values('new_cases').head(10)

2020 年 6 月 20 日的新病例数似乎是 -148，一个负数！这跟我们预想的不一样，但这就是现实世界数据的本质。这可能是一个数据输入的错误，或者政府可能为了解决过去的计算错误而作的一个更正。

你能在网上挖掘新闻文章并找出这个数字为什么是负数吗？

让我们再来看看 2020 年 6 月 20 日前后的几天。

covid_df.loc[169:175]

1. 将其替换为 0
2. 将其替换为整列的平均值
3. 将其替换为前后两个日期的平均值
4. 删除该行

选择哪种方法需要有关数据和问题的一些背景信息。在本例中，由于我们正在处理按日期排序的数据，我们可以继续使用第三种方法。

你可以使用 .at 方法来修改数据帧中指定的值。

covid_df.at[172, 'new_cases'] = (covid_df.at[171, 'new_cases'] + covid_df.at[173, 'new_cases'])/2

以下是我们在本节中看到的函数和方法的汇总：

• covid_df.new_cases.sum() – 计算列或系列中值的总和
• covid_df[covid_df.new_cases > 1000] – 使用布尔表达式查询满足所选条件的行子集
• df['pos_rate'] = df.new_cases/df.new_tests – 通过合并现有列中的数据来添加新列
• covid_df.drop('positive_rate') – 从数据帧中删除一列或多列
• sort_values – 使用列值对数据帧的行进行排序
• covid_df.at[172, 'new_cases'] = ... – 替换数据帧中的值

如何处理 Pandas 中的日期

虽然我们已经查看了病例、测试、阳性率等这些总体的数字，但按月研究这些数字也很有用。

date 列在这里可能会派上用场，因为 Pandas 提供了许多用于处理日期的实用程序。

covid_df.date
# 0      2019-12-31
# 1      2020-01-01
# 2      2020-01-02
# 3      2020-01-03
# 4      2020-01-04
#           ...    
# 243    2020-08-30
# 244    2020-08-31
# 245    2020-09-01
# 246    2020-09-02
# 247    2020-09-03
# Name: date, Length: 248, dtype: object

当前日期的数据类型是 object，因此 Pandas 不知道这一列是日期。我们用 pd.to_datetime 方法将它转成 datetime 列。

covid_df['date'] = pd.to_datetime(covid_df.date)

covid_df['date']
# 0     2019-12-31
# 1     2020-01-01
# 2     2020-01-02
# 3     2020-01-03
# 4     2020-01-04
#          ...    
# 243   2020-08-30
# 244   2020-08-31
# 245   2020-09-01
# 246   2020-09-02
# 247   2020-09-03
# Name: date, Length: 248, dtype: datetime64[ns]

现在你可以看到它的数据类型是 datetime64。我们用 DatetimeIndex 类将数据的不同部分提取到单独的列中。(查看文档)。

covid_df['year'] = pd.DatetimeIndex(covid_df.date).year
covid_df['month'] = pd.DatetimeIndex(covid_df.date).month
covid_df['day'] = pd.DatetimeIndex(covid_df.date).day
covid_df['weekday'] = pd.DatetimeIndex(covid_df.date).weekday

covid_df

我们来看一下 5 月份的整体指标。通过查询五月的行，选择其列的子集，并使用 sum 方法来合计每个选定列的值。

# 查询五月份的记录
covid_df_may = covid_df[covid_df.month == 5]

# 提取要汇总的列子集
covid_df_may_metrics = covid_df_may[['new_cases', 'new_deaths', 'new_tests']]

# 按列求和
covid_may_totals = covid_df_may_metrics.sum()

covid_may_totals
# new_cases       29073.0
# new_deaths       5658.0
# new_tests     1078720.0
# dtype: float64

type(covid_may_totals)
# pandas.core.series.Series

我们还可以将上述操作合并为一条语句。

covid_df[covid_df.month == 5][['new_cases', 'new_deaths', 'new_tests']].sum()
# new_cases       29073.0
# new_deaths       5658.0
# new_tests     1078720.0
# dtype: float64

再举一个例子，让我们检查一下周日报告的病例数是否高于每天报告的平均病例数。这次，我们可能要使用 .mean 方法对列进行汇总。

# 总平均值
covid_df.new_cases.mean()

# 1096.6149193548388

# 周日平均数
covid_df[covid_df.weekday == 6].new_cases.mean()

# 1247.2571428571428

与其他日子相比，星期天所报告的病例看起来更多。

尝试提问回答更多的数据中有关日期的问题。

如何在 Pandas 中分组和聚合数据

下一步，如果我们想要汇总逐日的数据，还要创建一个包含逐月数据的新数据帧。我们可以用 groupby 函数来为每一个月创建一个组，然后选择我们想要聚合的列，并用 sum 方法来聚合。

covid_month_df = covid_df.groupby('month')[['new_cases', 'new_deaths', 'new_tests']].sum()

covid_month_df

结果是一个新的数据帧，它使用传递给 groupby 的列中的唯一值作为索引。分组与聚合是非常有用的方法，用于逐步将数据汇总为更小的数据帧。

除了按总和聚合之外，还可以按平均值等其他方式进行聚合。让我们分别来计算每个月每日新增病例、死亡人数和检测数的平均值。

covid_month_mean_df = covid_df.groupby('month')[['new_cases', 'new_deaths', 'new_tests']].mean()

covid_month_mean_df

除了分组之外，另一种聚合形式是计算截止到每行日期的病例、测试或死亡的累积总和。我们可以使用 cumsum 方法计算某一列的累积总和并作为一个新的系列。

我们来添加新的三列：total_cases，total_deaths 和 total_tests。

covid_df['total_cases'] = covid_df.new_cases.cumsum()
covid_df['total_deaths'] = covid_df.new_deaths.cumsum()
covid_df['total_tests'] = covid_df.new_tests.cumsum() + initial_tests

我们还在 total_test 中加入了初始测试次数，以反映每日报告开始前进行的测试。

covid_df

注意 total_tests 列中的 NaN 值是如何保持不被影响的。

如何在 Pandas 中合并来自多个来源的数据

要确定其他指标，例如每百万人口的测试人数、每百万人口的确诊病例数等，我们需要该国家/地区的更多信息，即其人口。

让我们来下载另一个文件 locations.csv，它包含了包括意大利在内的许多国家的健康相关信息。

urlretrieve('https://gist.githubusercontent.com/aakashns/8684589ef4f266116cdce023377fc9c8/raw/99ce3826b2a9d1e6d0bde7e9e559fc8b6e9ac88b/locations.csv', 'locations.csv')

locations_df = pd.read_csv('locations.csv')
locations_df

locations_df[locations_df.location == "Italy"]

通过添加更多的列，我们可以将这些数据合并到先前的数据中。但是，要合并两个数据帧，我们至少需要一个共同的列。因此，我们在 covid_df 数据帧中插入 location 列，并将该列的所有值设为 “Italy”。

covid_df['location'] = "Italy"

covid_df

merged_df = covid_df.merge(locations_df, on="location")

merged_df

在这里查看完整的数据。

在 covid_df 中，每一行都附加上了意大利的位置信息。如果 covid_df 数据帧中包含了多个地区的数据，那么每一行应该附加上相应国家的位置信息。

现在，我们就可以计算每百万人口的病例数、死亡人数以及测试人数这些指标了。

merged_df['cases_per_million'] = merged_df.total_cases * 1e6 / merged_df.population
merged_df['deaths_per_million'] = merged_df.total_deaths * 1e6 / merged_df.population
merged_df['tests_per_million'] = merged_df.total_tests * 1e6 / merged_df.population

merged_df

在这里查看完整的数据。

如何用 Pandas 将数据写回到文件中

在完成分析，添加新列之后，你需要将结果写回到文件中。否则，一旦 Jupter notebook 关闭后，数据就会丢失。

在写入文件之前，让我们先创建一个只包含我们希望记录的列的数据帧。

result_df = merged_df[['date',
                       'new_cases', 
                       'total_cases', 
                       'new_deaths', 
                       'total_deaths', 
                       'new_tests', 
                       'total_tests', 
                       'cases_per_million', 
                       'deaths_per_million', 
                       'tests_per_million']]
                       
result_df

要将数据帧中的数据写入文件，我们可以使用 to_csv 函数。

result_df.to_csv('results.csv', index=None)

to_csv 函数默认还包含一列用于存储数据帧索引的额外列。我们通过 index=None 来关闭这种行为。现在可以验证 results.csv 是否已创建，并包含 CSV 格式数据帧中的数据：

date,new_cases,total_cases,new_deaths,total_deaths,new_tests,total_tests,cases_per_million,deaths_per_million,tests_per_million
2020-02-27,78.0,400.0,1.0,12.0,,,6.61574439992122,0.1984723319976366,
2020-02-28,250.0,650.0,5.0,17.0,,,10.750584649871982,0.28116913699665186,
2020-02-29,238.0,888.0,4.0,21.0,,,14.686952567825108,0.34732658099586405,
2020-03-01,240.0,1128.0,8.0,29.0,,,18.656399207777838,0.47964146899428844,
2020-03-02,561.0,1689.0,6.0,35.0,,,27.93498072866735,0.5788776349931067,
2020-03-03,347.0,2036.0,17.0,52.0,,,33.67413899559901,0.8600467719897585,

奖励：使用 Pandas 进行基本绘图

通常在 Jupyter notebook 中，我们使用像 matplotlib 或 seaborn 这样的库来绘图。但是，Pandas 数据帧和序列提供了便利的 .plot 方法来进行快速简单地绘图。

我们来绘制一个折线图，显示每日病例数如何随时间变化。

result_df.new_cases.plot();

虽然此图显示了整体趋势，但很难判断峰值发生的位置，因为 X 轴上没有日期。我们可以使用 date 列作为数据帧的索引来解决这个问题。

result_df.set_index('date', inplace=True)

result_df

result_df.loc['2020-09-01']
# new_cases             9.960000e+02
# total_cases           2.696595e+05
# new_deaths            6.000000e+00
# total_deaths          3.548300e+04
# new_tests             5.439500e+04
# total_tests           5.214766e+06
# cases_per_million     4.459996e+03
# deaths_per_million    5.868661e+02
# tests_per_million     8.624890e+04
# Name: 2020-09-01 00:00:00, dtype: float64

下面我们将每天的新病例和新死亡人数绘制为折线图。

result_df.new_cases.plot()
result_df.new_deaths.plot();

我们还可以比较总病例数和总死亡人数。

result_df.total_cases.plot()
result_df.total_deaths.plot();

让我们看看死亡率和阳性检测率如何随时间变化的。

death_rate = result_df.total_deaths / result_df.total_cases

death_rate.plot(title='Death Rate');

positive_rates = result_df.total_cases / result_df.total_tests

positive_rates.plot(title='Positive Rate');

最后，我们来绘制逐月数据的条形图，以在更高的层次上查看趋势。

covid_month_df.new_cases.plot(kind='bar');

covid_month_df.new_tests.plot(kind='bar')

Pandas 练习

尝试以下练习，以熟悉 Pandas 数据帧，并锻炼你的技术：

• Pandas 数据帧任务
• Pandas 附加练习
• 尝试从 Kaggle 下载并分析数据

总结及延展阅读

在本教程中，我们涵盖了以下主题：

• 如何将 CSV 文件读入到 Pandas 数据帧中
• 如何从 Pandas 数据帧中检索数据
• 如何查询、排序和分析数据
• 如何合并、分组和聚合数据
• 如何从日期中提取有用的信息
• 使用折线图和条形图进行基本绘图
• 如何将数据帧写入到 CSV 文件中

查看以下资源以了解 Pandas 的更多信息：

• Pandas 用户指南
• Python 数据分析（Wes McKinney 的书 —— 他是 Pandas 的创建者）

查看问题以检验你对 Pandas 的理解

尝试回答以下问题，来测验你对本章所涵盖的主题的理解：

1. Pandas 是什么？有用在哪里？
2. 如何安装 Pandas 库？
3. 如何导入 pandas 模块？
4. 导入 pandas 模块后，它的常用别名是什么？
5. 如果用 Pandas 读入 CSV 文件？请举例。
6. 用 Pandas 还可以读入哪些文件格式？举例说明。
7. Pandas 数据帧是什么？
8. Pandas 数据帧与 Numpy 数组的区别是什么？
9. 在数据帧中如何找到行数和列数？
10. 如何在数据帧中获取列的列表？
11. 数据帧中describe 方法的作用是什么？
12. info 和 describe 这两个数据帧方法的区别是什么？
13. Pandas 数据帧在概念上与字典列表或列表字典相似吗？举例解释。
14. Pandas 中的 Series 是什么？它跟 Numpy 数组的区别是什么？
15. 如何访问数据帧中的列？
16. 如何访问数据帧中的行？
17. 如何访问数据帧中指定的行和列中的元素？
18. 如何创建具有特定列集的数据帧子集？
19. 如何创建具有特定行范围的数据帧子集？
20. 更改数据帧内的值，是否会影响使用行或列的子集所创建的其他数据帧？为什么？
21. 如何创建数据帧的副本？
22. 为什么要避免创建太多的数据帧副本？
23. 如何查看数据帧中的开头几行？
24. 如何查看数据帧中的末尾几行？
25. 如何在数据帧中选择随机行？
26. 数据帧中的“索引”是什么？如何有用？
27. Pandas 数据帧中的 NaN 值代表什么意思？
28. Nan 和 0 的区别是什么？
29. 在 Pandas 序列或列中，如何识别第一个非空行？
30. df.loc and df.at 的区别是什么？
31. 在哪里可以找到 Pandas 中 DataFrame 和 Series 对象所支持的全部方法列表？
32. 如何在数据帧的列中找到数字的总和？
33. 如何找到数据帧列中数字的平均值？
34. 如何找到数据帧列中非空数字的数量？
35. 在布尔表达式中使用 Pandas 列可以得到什么结果？举例说明。
36. 如何选择行子集，使得其指定的列值满足给定的条件？举例说明。
37. 表达式 df[df.new_cases > 100] 的结果是什么？
38. 如何在 Jupyter 单元格输出中显示 pandas 数据帧的所有行？
39. 对数据帧中的两列执行算术运算，会得到什么结果？举例说明。
40. 如何通过组合两个现有列的值，在数据帧中添加新列？举例说明。
41. 如何删除数据帧中的列？举例说明。
42. 在数据帧方法中 inplace 参数的作用是什么？
43. 如何基于一个特定列中的值来对数据帧的行进行排序？
44. 如果利用多个列中的值来对 pandas 数据帧进行排序？
45. 在对 Pandas 数据帧排序时，如何指定是按升序还是降序来排序？
46. 如何修改数据帧中指定的值？
47. 如何将数据帧的列转换成 datetime 数据类型？
48. 使用 datetime 数据类型而不用 object 的好处是什么？
49. 如何将日期列的不同部分（如月、年、月、工作日等）提取到单独的列中？举例说明。
50. 如何聚合数据帧的多个列？
51. 数据帧的 groupby 方法的作用是什么？举例说明。
52. 聚合用 groupby 创建的组有哪些不同的方式？
53. 运行或累积总和是什么意思？
54. 如何创建一个新列，包含另一列的运行或累积总和？
55. Pandas 数据帧还支持哪些其他的累积方法？
56. 合并两个数据帧是什么意思？举例说明。
57. 如何指定用于合并两个数据帧的列？
58. 如何将 Pandas 数据帧的数据写入到 CSV 文件中？请举个例子。
59. 还可以将 Pandas 数据帧写入到哪些文件格式中？举例说明。
60. 如何创建折线图，用于显示数据帧中列的值？
61. 如何将数据帧的列转换为其索引？
62. 数据帧的索引可以是非数字吗？
63. 使用非数字数据帧的好处是什么？举例说明。
64. 如何创建条形图，用于显示数据帧中列的值？
65. Pandas 数据帧和系列还支持哪些其他类型的绘图方法？

你已经准备好进入本教程的下一部分了。

使用 Python、Matplotlib 和 Seaborn 进行数据可视化

Notebook 链接：https://jovian.ai/aakashns/python-matplotlib-data-visualization

数据可视化是对数据的图形化呈现。它生成图片，将要呈现的数据之间的关系传递给读者。

可视化数据是数据分析和机器学习的重要部分。我们将使用 Python 库 Matplotlib 和 Seaborn 来学习和应用一些常用的数据可视化技术。在本教程中，我们会交替使用 chart，plot 和 graph 这三个词。

开始前，我们需要先安装并导入这些库。matplotlib.pyplot 模块用于基本的绘图，如折线图和条形图，导入后通常使用别名 plt 。seaborn 模块用于更高级的绘图，导入后通常使用别名 sns。

!pip install matplotlib seaborn --upgrade --quiet

import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline

注意我们还包含了特殊命令 %matplotlib inline，确保所绘的图内嵌在 Jupyter notebook 中显示。如果不使用这条命令，有时图形会以弹窗显示。

如何在 Python 中创建折线图

折线图是最简单、应用最广泛的数据可视化技术之一。折线图将信息显示为由直线连接的一系列数据点或标记。

你可以自定义线条和标记的形状、大小、颜色和其他美学元素，以获得更好的视觉清晰度。

下面是一个 Python 列表，显示了一个名为 Kanto 的虚构国家在六年内的苹果产量（吨/公顷）。

yield_apples = [0.895, 0.91, 0.919, 0.926, 0.929, 0.931]

我们可以使用折线图来可视化苹果的产量如何随时间变化。我们使用 plt.plot 函数来绘制折线图。

plt.plot(yield_apples)

调用 plt.plot 函数就能绘制预期的折线图，同时它还返回了绘制的绘图列表 [<matplotlib.lines.Line2D at 0x7ff70aa20760>]，会显示在输出区域。我们可以在单元格中最后一条语句的末尾添加分号（;），使得只显示图形而不显示输出内容。

plt.plot(yield_apples);

如何在 MatPlotLib 中自定义 X 轴

当前图形的 X 轴显示了列表元素的索引 0 到 5。如果我们可以显示数据中的年份，这个图形将更具信息性。通过 plt.plot 中的两个参数即可实现。

years = [2010, 2011, 2012, 2013, 2014, 2015]
yield_apples = [0.895, 0.91, 0.919, 0.926, 0.929, 0.931]

plt.plot(years, yield_apples)

通过 plt.xlabel 和 plt.ylabel 这两个函数，我们可以为坐标添加标签，来显示坐标代表的意义。

plt.plot(years, yield_apples)
plt.xlabel('Year')
plt.ylabel('Yield (tons per hectare)');

如何在 MatPlotLib 中绘制多条折线

你可以为每条线调用一次 plt.plot 函数，这样就可以在同一个图形中绘制多条折线。让我们来比较 Kanto 苹果与橘子的产量。

years = range(2000, 2012)
apples = [0.895, 0.91, 0.919, 0.926, 0.929, 0.931, 0.934, 0.936, 0.937, 0.9375, 0.9372, 0.939]
oranges = [0.962, 0.941, 0.930, 0.923, 0.918, 0.908, 0.907, 0.904, 0.901, 0.898, 0.9, 0.896, ]

plt.plot(years, apples)
plt.plot(years, oranges)
plt.xlabel('Year')
plt.ylabel('Yield (tons per hectare)');

MatPlotLib 中的图表标题和图例

为了区分不同的线条，我们可以使用 plt.legend 函数在图形中添加一个图例。我们还可以使用 plt.title 函数来设置图表的标题。

plt.plot(years, apples)
plt.plot(years, oranges)

plt.xlabel('Year')
plt.ylabel('Yield (tons per hectare)')

plt.title("Crop Yields in Kanto")
plt.legend(['Apples', 'Oranges']);

如何在 MatPlotLib 中使用线条标记

通过使用 plt.plot 的marker 参数，我们还可以为每条线上的数据点增添标记。

Matplotlib 提供许多不同的标记，如圆圈、叉号、方块和菱形等。你可以从这个链接找到所有标记类型的列表：https://matplotlib.org/3.1.1/api/markers_api.html 。

plt.plot(years, apples, marker='o')
plt.plot(years, oranges, marker='x')

plt.xlabel('Year')
plt.ylabel('Yield (tons per hectare)')

plt.title("Crop Yields in Kanto")
plt.legend(['Apples', 'Oranges']);

如何在 MatPlotLib 中设置线条和标记的样式

plt.plot 函数提供很多参数用于设置线条和标记的样式：

• color 或 c – 设置线条颜色 (支持的颜色)
• linestyle 或 ls – 选择是实线还是虚线
• linewidth 或 lw – 设置线条宽度
• markersize 或 ms – 设置标记尺寸
• markeredgecolor 或 mec – 设置标记的边缘颜色
• markeredgewidth 或 mew – 设置标记的边缘宽度
• markerfacecolor 或 mfc – 设置标记的填充颜色
• alpha – 图形的不透明度

查阅 plt.plot 的文档以学习更多内容：https://matplotlib.org/api/_as_gen/matplotlib.pyplot.plot.html#matplotlib.pyplot.plot 。

plt.plot(years, apples, marker='s', c='b', ls='-', lw=2, ms=8, mew=2, mec='navy')
plt.plot(years, oranges, marker='o', c='r', ls='--', lw=3, ms=10, alpha=.5)

plt.xlabel('Year')
plt.ylabel('Yield (tons per hectare)')

plt.title("Crop Yields in Kanto")
plt.legend(['Apples', 'Oranges']);

fmt 参数提供了便捷的方法来设置标记的颜色、线条样式和颜色。你可以将它作为 plt.plot 的第三参数。

fmt = '[marker][line][color]'

plt.plot(years, apples, 's-b')
plt.plot(years, oranges, 'o--r')

plt.xlabel('Year')
plt.ylabel('Yield (tons per hectare)')

plt.title("Crop Yields in Kanto")
plt.legend(['Apples', 'Oranges']);

你可以使用 plt.figure 函数来改变图形的大小。

plt.plot(years, oranges, 'or')
plt.title("Yield of Oranges (tons per hectare)");

如何在 MatPlotLib 中更改图形的尺寸

你可以使用 plt.figure 函数来更改图形的尺寸。

plt.figure(figsize=(12, 6))

plt.plot(years, oranges, 'or')
plt.title("Yield of Oranges (tons per hectare)");

如何使用 Seaborn 改进默认样式

使用 Seaborn 库中的一些默认样式，很容易让你的图表看起来更加漂亮。你可以全局使用 sns.set_style 函数。以下是预定义样式的完整列表：https://seaborn.pydata.org/generated/seaborn.set_style.html 。

sns.set_style("whitegrid")
plt.plot(years, apples, 's-b')
plt.plot(years, oranges, 'o--r')

plt.xlabel('Year')
plt.ylabel('Yield (tons per hectare)')

plt.title("Crop Yields in Kanto")
plt.legend(['Apples', 'Oranges']);

sns.set_style("darkgrid")

plt.plot(years, apples, 's-b')
plt.plot(years, oranges, 'o--r')

plt.xlabel('Year')
plt.ylabel('Yield (tons per hectare)')

plt.title("Crop Yields in Kanto")
plt.legend(['Apples', 'Oranges']);

plt.plot(years, oranges, 'or')
plt.title("Yield of Oranges (tons per hectare)");

你还可以通过修改 matplotlib.rcParams 字典直接编辑默认样式。了解更多信息：https://matplotlib.org/3.2.1/tutorials/introductory/customizing.html#matplotlib-rcparams 。

import matplotlib

matplotlib.rcParams['font.size'] = 14
matplotlib.rcParams['figure.figsize'] = (9, 5)
matplotlib.rcParams['figure.facecolor'] = '#00000000'

MatPlotLib 中的散点图

在散点图中，两个变量的值被绘成二维网格上的一个点。此外，你还可以使用第三个变量来确定这些点的大小和颜色。让我们来试一个例子。

鸢尾花卉数据集 提供了三种花的花萼和花瓣的样本测量。该数据集包含了 Seaborn 库，你可以把它当作 Pandas 数据帧来加载。

# 将数据加载到 Pandas 数据帧中
flowers_df = sns.load_dataset("iris")

flowers_df

flowers_df.species.unique()
# array(['setosa', 'versicolor', 'virginica'], dtype=object)

让我们尝试将萼片长度和萼片宽度之间的关系可视化。我们的第一反应可能是使用 plt.plot 创建一个折线图。

plt.plot(flowers_df.sepal_length, flowers_df.sepal_width);

由于数据集中有太多两个属性的组合，因此输出的信息不是很丰富。它们之间看上去并不是简单的关系。

通过 seaborn 模块（以别名 sns 导入）中的 scatterplot 函数，我们用散点图可视化花萼长度和宽度是如何变化的。

sns.scatterplot(x=flowers_df.sepal_length, y=flowers_df.sepal_width);

如何在 MatPlotLib 中添加色调

注意，上图中有些点形成了一些异常值的不同簇。我们可以将这三个花的品种各自当作一个色调来给这些点上色，还可以用 s 参数来放大这些点。

sns.scatterplot(x=flowers_df.sepal_length, y=flowers_df.sepal_width, hue=flowers_df.species, s=100);

添加色调使得图形更具信息性。我们可以立刻看出，刚毛鸢尾的花萼较短，但是较宽。而弗吉尼亚鸢尾正好相反。

如何自定义 Seaborn 图形

由于 Seaborn 内部用的是 Matplotlib 的绘图函数，我们可以使用像 plt.figure 和 plt.title 这样的函数来修改图形。

plt.figure(figsize=(12, 6))
plt.title('Sepal Dimensions')

sns.scatterplot(x=flowers_df.sepal_length, 
                y=flowers_df.sepal_width, 
                hue=flowers_df.species,
                s=100);

如何使用带有 Seaborn 的 Pandas 数据帧绘制数据

Seaborn 内置了对 Pandas 数据帧的支持。你可以提供列名并使用 data 参数来指定数据帧，无需将每一列作为序列来传递。

plt.title('Sepal Dimensions')
sns.scatterplot(x='sepal_length', 
                y='sepal_width', 
                hue='species',
                s=100,
                data=flowers_df);

MatPlotLib 中的直方图

直方图通过沿值的范围创建组距（间隔）并显示垂直条来表示每个组距中的观察数，从而表示变量的分布。

例如，我们要可视化鸢尾花数据集中花萼宽度值的分布。我们可以使用 plt.hist 函数来创建直方图。

# 将数据加载到 Pandas 数据帧中
flowers_df = sns.load_dataset("iris")

flowers_df.sepal_width
# 0      3.5
# 1      3.0
# 2      3.2
# 3      3.1
# 4      3.6
#       ... 
# 145    3.0
# 146    2.5
# 147    3.0
# 148    3.4
# 149    3.0
# Name: sepal_width, Length: 150, dtype: float64

plt.title("Distribution of Sepal Width")
plt.hist(flowers_df.sepal_width);

我们能立马发现花萼的宽度在 2.0 - 4.5 范围内，大约有 35 个落在 2.9 - 3.1 之间，它们似乎是最多的组距。

如何控制组距的大小和数量

我们可以使用组距参数来控制组距的数量以及每个组距的大小。

# Specifying the number of bins
plt.hist(flowers_df.sepal_width, bins=5);

import numpy as np

# Specifying the boundaries of each bin
plt.hist(flowers_df.sepal_width, bins=np.arange(2, 5, 0.25));

# Bins of unequal sizes
plt.hist(flowers_df.sepal_width, bins=[1, 3, 4, 4.5]);

如何在 MatPlotLib 中管理多个直方图

与折线图类似，我们可以在一个图表里绘制多个直方图。我们可以降低每个直方图的不透明度，这样每个直方图里的柱条不会遮住其他的。

让我们来为每一个花的品种绘制自己的直方图。

setosa_df = flowers_df[flowers_df.species == 'setosa']
versicolor_df = flowers_df[flowers_df.species == 'versicolor']
virginica_df = flowers_df[flowers_df.species == 'virginica']

plt.hist(setosa_df.sepal_width, alpha=0.4, bins=np.arange(2, 5, 0.25));
plt.hist(versicolor_df.sepal_width, alpha=0.4, bins=np.arange(2, 5, 0.25));

我们还可以将多个直方图堆叠在一起。

plt.title('Distribution of Sepal Width')

plt.hist([setosa_df.sepal_width, versicolor_df.sepal_width, virginica_df.sepal_width], 
         bins=np.arange(2, 5, 0.25), 
         stacked=True);

plt.legend(['Setosa', 'Versicolor', 'Virginica']);

MatPlotLib 中的条

条形图与折线图很像，都显示一系列的值。只不过，每个值都会显示一个条形，而不是由线连接的点。我们可以使用 plt.bar 函数来绘制条形图。

years = range(2000, 2006)
apples = [0.35, 0.6, 0.9, 0.8, 0.65, 0.8]
oranges = [0.4, 0.8, 0.9, 0.7, 0.6, 0.8]

plt.bar(years, oranges);

与直方图一样，我们可以将条形图堆叠在一起。我们使用 plt.bar 的 bottom 参数来实现这一目的。

plt.bar(years, apples)
plt.bar(years, oranges, bottom=apples);

Seaborn 中包含平均值的条形图

我们来看另一个包含 Seaborn 的样本数据集，名为 tips。这个数据集包含有关一周内访问餐厅的客户的性别、时间、总账单和小费金额的信息。

tips_df = sns.load_dataset("tips");

tips_df

我们可能想要绘制一个条形图来可视化平均账单金额在一周中的不同天数之间的变化。实现的一种方式是计算每日的平均值，然后使用plt.bar（请当做练习来尝试）。

然而，由于这是一个非常普遍的用例，Seaborn 库提供了 barplot 函数，可以自动计算平均值。

sns.barplot(x='day', y='total_bill', data=tips_df);

切割每个条形的线表示值的变化量。例如，看起来总账单的变化在周五相对较高，而在周六较低。

我们还可以指定一个 hue 参数来并排比较基于第三个特征的条形图，例如性别。

sns.barplot(x='day', y='total_bill', hue='sex', data=tips_df);

sns.barplot(x='total_bill', y='day', hue='sex', data=tips_df);

只需切换坐标轴，就能使条形图水平显示。

Seaborn 中的热度

热图用于可视化二维数据，如使用颜色的矩阵或表格。理解它的最好方式就是具体看一个例子。

我们将使用另一个 Seaborn 的样本数据集，叫做 flights，来可视化机场在过去12年中的乘客流量。

flights_df = sns.load_dataset("flights").pivot("month", "year", "passengers")

flights_df

flights_df 是一个矩阵，一行表示一月，一列为一年。值显示了在一年中具体某个月到访机场的乘客数量（以千为计）。我们可以使用 sns.heatmap 函数来可视化机场的客流。

plt.title("No. of Passengers (1000s)")
sns.heatmap(flights_df);

颜色越明亮，表示机场客流量越大。通过这个图，我们可以推断两件事：

• 在所有给定的年份中，机场客流总是在七八月份达到最高。
• 每个月机场的客流量都会逐年增加。

我们还可以通过指定 annot=True 来显示每个块的实际值，使用 cmap 参数来改变调色板。

plt.title("No. of Passengers (1000s)")
sns.heatmap(flights_df, fmt="d", annot=True, cmap='Blues');

MatPlotLib 中的图片

我们还可以用 Matplotlib 来显示图片。我们先从网上下载一张图片。

from urllib.request import urlretrieve

urlretrieve('https://i.imgur.com/SkPbq.jpg', 'chart.jpg');

在显示图像之前，必须使用 PIL 模块将图像读入内存。

from PIL import Image

img = Image.open('chart.jpg')

使用 PIL 加载的图像是一个简单的三维 numpy 数组，包含图像红、绿、蓝（RGB）通道的像素强度。我们可以使用 np.array 将图像转换为数组。

img_array = np.array(img)

img_array.shape
# (481, 640, 3)

我们可以使用 plt.imshow 显示 PIL 图像。

plt.imshow(img);

我们可以使用相关函数关闭坐标轴和网格线，并显示标题。

plt.grid(False)
plt.title('A data science meme')
plt.axis('off')
plt.imshow(img);

要显示图像的一部分，我们只需从 numpy 数组中选择一个片段即可。

plt.grid(False)
plt.axis('off')
plt.imshow(img_array[125:325,105:305]);

MatPlotLib 和 Seaborn 中如何绘制多个图表

Matplotlib 和 Seaborn 还支持在网格中绘制多个图表，通过使用 plt.subplots，返回用于绘图的轴的系列。

以下单个网格中显示了本教材涵盖的各种不同类型的图表。

fig, axes = plt.subplots(2, 3, figsize=(16, 8))

# Use the axes for plotting
axes[0,0].plot(years, apples, 's-b')
axes[0,0].plot(years, oranges, 'o--r')
axes[0,0].set_xlabel('Year')
axes[0,0].set_ylabel('Yield (tons per hectare)')
axes[0,0].legend(['Apples', 'Oranges']);
axes[0,0].set_title('Crop Yields in Kanto')


# Pass the axes into seaborn
axes[0,1].set_title('Sepal Length vs. Sepal Width')
sns.scatterplot(x=flowers_df.sepal_length, 
                y=flowers_df.sepal_width, 
                hue=flowers_df.species, 
                s=100, 
                ax=axes[0,1]);

# Use the axes for plotting
axes[0,2].set_title('Distribution of Sepal Width')
axes[0,2].hist([setosa_df.sepal_width, versicolor_df.sepal_width, virginica_df.sepal_width], 
         bins=np.arange(2, 5, 0.25), 
         stacked=True);

axes[0,2].legend(['Setosa', 'Versicolor', 'Virginica']);

# Pass the axes into seaborn
axes[1,0].set_title('Restaurant bills')
sns.barplot(x='day', y='total_bill', hue='sex', data=tips_df, ax=axes[1,0]);

# Pass the axes into seaborn
axes[1,1].set_title('Flight traffic')
sns.heatmap(flights_df, cmap='Blues', ax=axes[1,1]);

# Plot an image using the axes
axes[1,2].set_title('Data Science Meme')
axes[1,2].imshow(img)
axes[1,2].grid(False)
axes[1,2].set_xticks([])
axes[1,2].set_yticks([])

plt.tight_layout(pad=2);

通过该网页查看支持函数的完整列表：https://matplotlib.org/3.3.1/api/axes_api.html#the-axes-class 。

用 Seaborn 来配对绘图

Seaborn 还提供了一个助手函数 sns.pairplot，用于在一个数据帧内自动绘制多个不同的图表，以显示多个特征对。

sns.pairplot(flowers_df, hue='species');

sns.pairplot(tips_df, hue='sex');

总结及扩展阅读

本教程涵盖了以下主题：

• 如何使用 Matplotlib 来创建和自定义折线图
• 如何使用散点图可视化两个或多个变量之间的关系
• 如何使用直方图和条形图研究变量的分布
• 如何使用热图可视化二维数据
• 如何使用 Matplotlib 的 plt.imshow 显示图像
• 如何在一个网格中显示多个 Matplotlib 和 Seaborn 图表

在本章中，我们学习了使用 Matplotlib 和 Seaborn 进行数据可视化的一些基本概念和常用技术。数据可视化是一个很宽泛的领域，我们在这里几乎还没有触及其表层。查阅以下参考文献来学习探索更多内容：

• 数据可视化备忘单：https://jovian.ml/aakashns/dataviz-cheatsheet
• Seaborn 资料：https://seaborn.pydata.org/examples/index.html
• Matplotlib 资料：https://matplotlib.org/3.1.1/gallery/index.html
• Matplotlib 教程：https://github.com/rougier/matplotlib-tutorial

回顾问题来检验你的掌握程度

尝试回答以下问题来测试你对本文所涵盖的主题的理解程度：

1. 数据可视化是什么？
2. Matplotlib是什么？
3. Seaborn是什么？
4. 如何安装 Matplotlib 和 Seaborn？
5. 如何导入 Matplotlib 和 Seaborn？导入这两个模块时常用的别名是什么？
6. 神奇命令 %matplotlib inline 的作用是什么？
7. 什么是折线图？
8. 如何在 Python 中绘制折线图？举例说明。
9. 如何指定折线图 X 轴的值？
10. 如何为图表的轴指定标签？
11. 如何在同一轴上绘制多个折线图？
12. 如何显示包含多个线条的折线图的图例？
13. 如何设置图表的标题？
14. 如何显示折线图的标记？
15. 折线图中线条和标记的样式有哪些不同的选项？举例说明。
16. plt.plot 中 fmt 参数的作用是什么？
17. 在哪能找到可以被 plt.plot 接受的所有参数的列表？
18. 如何使用 Matplotlib 更改图形的大小？
19. 如何将 Seaborn 的默认样式应用于全局所有的图表？
20. Seaborn 中可用的预定义样式有哪些？举例说明。
21. 什么是散点图？
22. 散点图与折线图有何不同？
23. 如何使用 Seaborn 绘制散点图？举例说明。
24. 如何判断什么时候使用散点图和折线图？
25. 如何使用分类变量为散点图上的点指定颜色？
26. 如何为 Seaborn 绘图自定义标题、图形大小、图例等？
27. 如何使用带有 sns.scatterplot 的 Pandas 数据框？
28. 什么是直方图？
29. 什么时候应该使用直方图和折线图？
30. 如何使用 Matplotlib 绘制直方图？举例说明。
31. 直方图中的“组距”是什么？
32. 如何更改直方图中组距的数量？
33. 如何更改直方图中组距的大小？
34. 如何在同一轴上显示多个直方图？
35. 如何将多个直方图堆叠在一起？
36. 什么是条形图？
37. 如何使用 Matplotlib 绘制条形图？举例说明。
38. 条形图和直方图的区别是什么？
39. 条形图和折线图的区别是什么？
40. 你如何将条形堆叠在一起？
41. plt.bar 和 sns.barplot 的区别是什么？
42. 在 Seaborn 条形图中，分割柱状条的线条代表了什么？
43. 如何并排显示条形图？
44. 如何绘制水平条形图？
45. 什么是热图？
46. 什么类型的数据最好用热图来进行可视化？
47. Pandas 数据帧中的 pivot 方法是干什么用的？
48. 如何用 Seaborn 来绘制热图？举例说明。
49. 如何更改热图的颜色方案？
50. 如何显示热图中数据集的原始值？
51. 如何用 Python 从 URL 下载图片？
52. 如何用 Python 打开图片以用于处理？
53. Python 中 PIL 模块的作用是什么？
54. 如何将 PIL 下载的图片转换成 Numpy 数组？
55. 图片的 Numpy 数组有几维？每个维度代表什么？
56. 图片中的“颜色通道”是什么意思？
57. 什么是 RGB？
58. 如何用 Matplotlib 显示图片？
59. 如何关闭图表中的轴和网格线？
60. 如何使用 Matplotlib 显示部分图片？
61. 如何用 Matplotlib 和 Seaborn 在单个网格中绘制多个图表？举例说明。
62. plt.subplots 函数的作用是什么？
63. 什么是 Seaborn 的配对绘图？举例说明。
64. 如何用 Matplotlib 将图表导出到 PNG 图片？
65. 在哪里可以学到能用 Matplotlib 和 Seaborn创建的不同类型的图表？

祝贺你完成本教程的学习！现在，你可以应用这些技能来分析来自以下来源的真实世界数据集：Kaggle。

如果你想从事数据科学和机器学习的工作，可以考虑加入从零开始数据科学训练营（约维安）。这是一个为期20周的业余课程，你将完成7门课程、12个编码作业和4个真实的项目。你还将获得6个月的职业支持，以帮助你找到第一份数据科学工作。

如果你想更高效地做测试，就需要知道不同的测试类型，以及在什么时候使用它们。

在这篇文章中，我想谈谈其中的一些测试类型，它们能帮助你确保产品或者应用的可操作性、完整性和安全性。

软件测试金字塔

（《软件测试金字塔》 如果觉得这张图片很赞，可以随意分享到你的博客或者推特。）

软件测试金字塔覆盖了整个软件开发生命周期（SDLC）。它从底层的单元测试开始延伸，穿过集成测试，到顶部的功能性测试结束。

然而，这些测试类型并没有固定的套路，相反，你需要自己来决定哪种才最适合你的需求。为了决定选哪一种，你需要综合考虑使用它们所需的费用、时间以及资源。

敏捷软件开发者也常使用软件测试四象限，这个法则根据是面向业务还是面向技术，是评论产品还是支持团队这两个维度来对测试进行归类。

例如，单元测试是一种支持团队的面向技术的测试，而可用性测试是一种发现产品问题的面向业务的测试。

现在让我们一起来看看一些重要的测试类型。

单元测试定义

单元测试是指测试单个代码组件，而不是整块代码。它验证所有组件逻辑的可操作性，以便在软件开发生命周期的早期阶段就发现缺陷，在进一步开发之前，对其进行修复。

单元测试也叫做“白盒”测试，因为需要完全掌握应用程序的结构和环境才能进行。

下面这个单元测试的例子，创建了模拟对象用于测试代码块，如还未生成参数变量的函数。

const mocha = require('mocha')
const chai = require('chai')  // It is an assertion library
describe('Test to check add function', function(){
  it('should add two numbers', function(){
    (add(2,3)).should.equal(5)  //Checking that 2+3 should equal 5 using the given add function
  });
});

集成测试定义

单元测试往上一步就是集成测试，它把各个组件联合起来，作为一个组来进行测试。集成测试用于识别各个组件之间交互时出现的问题，以检验代码是否符合功能说明书。

集成测试区别于单元测试的一个点是，它关注独立工作在整个组里面的模块和组件。而另外一边，单元测试关注于在测试前隔离模块或组件。

集成测试的关键是，在集成后的模块或组件之间，暴露任何软件缺陷或漏洞。

拿一个更为简单的例子来说，如果你正在对刚创建的邮箱服务进行一项集成测试，那么你需要测试各个组件，如撰写邮件、保存草稿、发件、移动到收件箱、登出等等。

在这之前，你得先对单个特性进行一次单元测试，主要是跟集成测试中相关的每个功能函数。

端到端测试定义

金字塔的顶部是端到端测试。如名所示，端到端测试重复应用程序的所有操作，以测试应用程序的连接性和依赖性的方方面面。这包括网络连接、数据访问和外部依赖。

端到端测试在模拟真实用户的环境下进行。

你可以通过某些指标来定义端到端测试是否成功，包括测试状态（用可视化图表来跟踪）和报告状态（用于展示测试执行的状态和已发现的漏洞或缺陷）。

软件测试类型

测试金字塔的每个层级都包含了各式各样的具体流程，用于测试各种应用程序功能和特性，也包括应用程序的完整性和安全性。

应用程序安全性测试定义

应用程序安全性测试是应用程序各种测试类型中最重要的一个。它帮助你识别应用程序漏洞，这些漏洞很有可能被黑客利用，所以要在发布产品或应用之前把它们修复掉。

有很多应用程序安全性测试供你使用，它们可应用于软件开发生命周期中的不同部分。

你可以在测试金字塔的不同层级找到不同类型的应用安全性测试。每种测试都有其自己的优点和缺点。你应该同时使用不同的测试类型，以确保它们整体上的完整性。

静态应用程序安全性测试（SAST）定义

你应该在软件开发生命周期早期使用静态应用程序安全性测试（SAST）。它是单元测试的一个例子。

SAST 反映了开发人员的能力，包括应用程序的通用设计和实现，因此它是白盒测试，或者叫由内而外的测试。

SAST 分析代码本身而不是最终的应用程序，你不需要执行代码就可以运行起来。

图片来源

云防御的安全分析师说，

“SAST 检查你的代码是否违反安全性规则，同时在源分支和目标分支之间比较已发现的漏洞……一旦项目新发现的漏洞会影响项目依赖性，你就会被通知到。”

一旦发现漏洞，你就可以在最终应用程序构建之前把它们解决掉。

你应该在软件项目的开发阶段就将 SAST 应用进去。在设计和编写应用程序时就将 SAST 扫描包含到开发流程中，不失为一个好方法。

动态应用程序安全性测试（DAST）定义

处于另一端的是动态应用程序安全性测试（DAST），它测试完整编译好的应用程序。你设计和运行这些测试时，不需要知道潜在的结构或代码。

因为 DAST 采用黑客视角，它被称为黑盒测试，或由外向内的测试。

DAST 通过攻击运行中的代码以及寻找可利用的潜在漏洞来进行测试。DAST 可能采用跨站点脚本和 SQL 注入等常见攻击技术。

DAST 在软件开发生命周期后面才进行，它是集成安全性测试的一个例子。由于很慢（一整个完整的应用程序的 DAST 测试平均可能需要花 5 到 7 天），它会为你揭示应用程序中黑客最有可能攻击的漏洞。

交互式应用程序安全性测试定义

交互式应用程序安全性测试（IAST）是一种比较新的测试方法，它结合了 SAST 和 DAST 的高效性，同时克服了与这些确立的测试相关联的问题。

IAST 使用一种插入式的监控代理，来对应用程序进行持续实时扫描，从而发现错误和漏洞。尽管 IAST 是在应用程序运行时进行的, 它仍然被当作是一个 SDLC 早期的测试过程。

不管你在寻找什么样的软件进行测试，IAST 最适合在 QA（质量保证）环境中使用，同样，也很适合专门设计出来用于复制客户或者顾客真实使用产品的场景。

兼容性测试定义

兼容性测试评估你的应用程序如何运行，以及它在各种设备和环境（包括移动设备和不同操作系统）上的安全性。

兼容性测试还可以评估当前版本的软件是否与其他软件版本兼容。版本测试可以是朝后或者朝前的。

图片来源

兼容性测试的例子包括：

• 浏览器测试（检查以确保你的网站或移动网址与不同的浏览器完全兼容）
• 移动测试（确保您的应用程序与 iOS 和 Android 兼容）
• 或软件测试（如果你要创建多个需要彼此交互的软件应用程序，那么需要进行兼容性测试以确保它们正常运行）。

软件测试金字塔之外

测试金字塔的修改版本可以包括与端到端测试相邻或之上的层级。此层级包括针对应用程序用户的测试。

性能测试定义

你需要知道应用程序将如何在各种不同的条件下工作，这就是性能测试的目的。性能测试可以对各种负载和压力进行建模，以评估应用程序的稳健性。性能测试的类型基于所应用的条件。

性能测试的一个例子是负载测试，用于确定最大负载，即系统何时会崩溃。

另一方面，另一个例子，如可扩展性测试，将逐渐增加的负载应用于系统，以评估适应增加的系统压力的方法。

尖峰测试用于评估对系统突然施加大负载变化所带来的影响。

在任何软件系统面向市场之前，你都应该对其进行性能测试。测试其稳定性、可扩展性和速度，这样你才可以在上线之前就识别要修复的内容。

可用性测试定义

测试应用程序接口的实际使用是一项重要的任务。理解应用的功能是否按设计运行是一回事，而这个设计本身是否为用户所接受又是另一回事了。这就是可用性测试的出发点。

通过可用性测试，开发人员可以评估用户对特定应用程序特性和功能的反应。这包括你可能事先知道从用户角度来看不太理想的功能，但是这些功能是强安全性和正确操作所必需的（像强密码这种要求）。

可用性测试与外观问题或修复任何书面文本中的语法错误无关（尽管这两个问题本身当然很重要）。相反，它与终端用户使用应用程序的难易程度有关。

结论

测试不仅仅是应用程序开发结束后 QA 部门应该做的事情，它也是软件开发过程的重要组成部分。

了解你可以使用哪些测试以及它们如何工作，将帮助你保证应用程序运行良好、安全并且为最终用户所接受。

原文：What is Software Testing? The 10 Most Common Types of Tests Developers Use in Projects，作者：Nahla Davies

在这篇文章中，我将向你展示，如何用几种不同的方式更改页面的背景颜色。

如何更改一个 HTML 元素的背景色

想要改变一个 HTML 元素的背景色，你可以使用 background-color 这个 CSS 属性，给它赋上一个颜色值。

p {
  background-color: pink;
}

上面的代码给段落设置了粉色的背景。

例如，这份代码将使得 HTML 页面中的所有段落元素拥有一个粉色的背景，因为 background-color 属性的值是 pink。

你可以使用大约 140 种颜色，例如 teal、hotpink、indigo 等等。

注意：如果你给一个元素设置了 background-color，但是没有看到变化，很可能是一个语法错误，也可能是因为没有给这个元素设置宽和高。尝试放一些内容进去，或者通过 CSS 属性 width 和 height 给它设置宽和高。

实际上大概有 1680 万种颜色可供你使用。你可以通过 RGB 值来使用它们。还有 HSL 颜色，大约有 370 万种可供你选择。在下一节中，你将了解所有这些创建颜色的不同方法。

不同的颜色表示

background-color 属性接受颜色作为可能的值。这里，你将看到四种不同的颜色值表示法。

第一种是颜色名称，差不多有 140 个关键字可供你使用。这是最简单的一种选择颜色的方式，因为它不要求掌握特殊符号——但它的选择范围有限。

第二种、第三种命名或者选择颜色的方式分别是用 RGB 值和十六进制值。这两种方式里，颜色由它们包含的红色、绿色和蓝色的数量来标识。

这源自于屏幕显示颜色的工作原理。屏幕由像素组成，每个像素由绿、蓝和红三种不同颜色的 LED 点亮，它们可以发出不同强度的光。

第四种表示法是 HSL 颜色，或者 Hue-Saturation-Lightness。这种表示来自平面设计，因为它反映了人类思考颜色的一种更自然的方式：纯色（色调），其饱和度和亮度可以变化。

你可以使用任意一种方式来给背景设置颜色，但是让我们来看更多的细节，以便你选择你中意的方式。

HTML 颜色名称

HTML 的第一个版本中能识别出 16 种基本颜色。现在你可以使用 140 多种命名颜色。

body {
  background-color: black;
}

这条 CSS 给 body 设置黑色背景。

你可以在文章末尾的附录中看到所有命名的颜色。

RGB 颜色

RGB 代表 Red-Green-Blue。在这种格式下，颜色被写成 rgb(0,0,0)，其中每个值都是介于 0 和 255 之间的数字，分别表示用于组成每种颜色的红色、绿色和蓝色的数量。

例如，rgb(0,0,0) 表示黑色。

要获得红色，你可以写成 rgb(255,0,0)，使得红色最大化为 255，绿色为 0，蓝色为 0。

通过较小数值的绿色和（或）蓝色，以及少一点的红色，你可以得到红色的其他变种。例如，用 rgb(255,69,0) 可以得到橘红色，用 rgb(139,0,0) 可以得到深红色。

div {
  background-color: rgb(139,0,0);
}

给 div 元素设置深红色背景。

上图是一个 HTML 页面的例子，其中 div 元素被赋予了 rgb(139,0,0) 的 background-color

下面的例子展示了，当调整其中两个 RGB 值时，颜色是如何变化的：彩色方块的左上角等于 rgb(0,0,0)，右上角等于 rgb(0,0,255)，左下角等于 rgb(0,255,0)，右下角等于 rgb(0,255,255)。

幸运的是，你不需要靠猜测数值来获得你想要的颜色。你可以在网上找到各种各样的颜色选取器，让你使用滑块（或其他方法）选择颜色并提供给你要使用的 RGB 颜色值。

十六进制颜色

十六进制颜色是编写 RGB 颜色的另一种方式。对于十六进制，依然有三个数字，每种颜色对应一个，每一个数字有 256 种可能的值。

但是，在这种情况下，每种颜色有两个数字，分别从 0 到 F（也就是，0，1，2，3，4，5，6，7，8，9，A，B，C，D，E，F)。一位数字有 16 个可能的值，两位数字有 256 个可能的值，从 00 到 FF（255）。

用十六进制颜色编写时，要在数值的前面加一个 #。例如，红色写成 #FF0000，深红色写成 #8B0000，橘红色写成 #FF4500。

h1 {
  background-color: #FF4500;
}

给 h1 元素设置橘红色背景。

上图是一个 HTML 页面的例子，其中 h1 元素被赋予了 #FF4500 的 background-color

你也可以用颜色选取器来生成十六进制值。

十六进制简写

你可以用简写的形式来写十六进制数值，只用三位数而不是六位数。例如，你可以将红色写成 #F00。这将可能的颜色数量减少到略高于 4000，但写入时间较短，有时这很重要。

每个数字代替两个相同的数字，所以我们无法将 #8B0000 简写，因为 8 和 B 不一样。但是我们可以写 #800，这等价于 #880000，非常接近深红色。橘红色可以写成 #F40（等价于 #FF4400）。

HSL 颜色

HSL 表示 Hue-Saturation-Lightness，这是一种目前为止我们看到的完全不同的颜色书写方式。

HSL 颜色用三个数字表示：色调从 0 到 360，饱和度和亮度从 0 到 100。

色调决定了基色，它的值是一个角度，色轮上的度数。在这种情况下，红色是 0，绿色是 120，蓝色是 240，然后 360 依然还是红色。

饱和度从 0 开始，也就是灰色，到 100，也就是全色。

亮度是添加到颜色中的黑色或白色的数量。0 表示黑色，50 是颜色其本身，100 表示白色。

例如，你要将红色写成 hsl(0,100%,50%)，橘红色写成 hsl(16,100%,50%)，深红色写成 hsl(0,100%,27%)。

相比其他配色方案，使用 HSL 更容易找到相似的颜色。从红色以及它的变种色，你已经看到，要获取更深的红色，你只需要改变亮度的百分比就可以了，而将红色与其他颜色相混，足以改变其色调。

让我们用十六进制的混合颜色来看看它的效果，如橙色（#FFA500 或 rgb(255,166,0)），写成 HSL 就是 hsl(39,100%,50%)。通过提高亮度，你可以得到一个更亮的橙色。

例如，写成 hsl(39,100%,65%) 就能得到更亮的橙色，而用其他表示法，你需要写成 rgb(255,193,77) 或者 #FFC14D。

上面是一个 HTML 页面的例子，其中 main 元素被赋予了 hsl(39, 100%, 65%) 的 background-color

你也可以在网上找到用于 HSL 颜色的选取器。

属性名简写

你也可以使用简写的 background 属性来设置背景色.

p {
  background: pink;
}

body {
  background: black;
}

div {
  background: rgb(139,0,0);
}

h1 {
  background: #FF4500;
}

main {
  background: hsl(39,100%,65%);
}

与前面看到的 CSS 属性一样，只是换成了 background 简写属性。

上面是一个 HTML 页面的例子，其中所有元素都被赋予了一种背景色。

这是一个更通用的属性，因为它是各种 background 属性的简写，如 background-image 和 background-position。当你将它与颜色值一起使用时，它的作用与 background-color 完全一样。

总结

你已经学习了如何给 HTML 元素设置背景色，可以用 background-color 属性以及它的简写属性 background，也学习了不同的颜色表示法。

现在你拥有了为网页添加任何颜色所需的所有工具。好好享受吧！

附录

全部 140 多种命名颜色

拼写的变体

包含单词 “Gray” 的颜色名称，也可以写成像下面这样，拼写成 “Grey”。

原文：CSS Background Color – How to Change the Background Color in HTML，作者：Ilenia Magoni

创建模块可以更好地组织并结构化你的代码库。你可以使用模块来拆解大型程序，拆成更小、更好管理、更独立的代码块，这些代码块执行单一的任务，或者多个相关的任务。

模块应该是:

1. 独立的/自我包含的： 模块必须尽可能与其他依赖项分离。
2. 具体的： 模块要能执行单个或一组相关的任务。最初创建它们的核心本质是创建单独的功能块。一个模块，对应于一个（种）任务。
3. 可重用的： 模块必须能很容易地集成到各种各样的程序来执行其任务。

为了更好地阐述，我给你打个比方：

假设我们想从头开始建造一座大房子。建造房子所需的所有工具都堆放在一个房间里。

在这种情况下，如果想以正确的方式组织这些工具，以便我们开始建造，将会很困难。

不同于将独立的依赖项全部堆放在一个房间里，我们应该将每一系列相关的工具组合，分组放到不同的房间里。每个房间都是独立的，只包含其解决指定任务的工具。

我们可以贴上标签，如：“这些工具用于建屋顶”，“这些工具用于砌砖”，“这些工具用于挖地基”等。

每当我们想要一个工具来执行特定任务时，我们能准确知道应该去哪个房间找它。这样，一切都更有条理，更好定位。

另外，假设我们已经完成了房子的建造，然后决定建造一些不同的东西。我们仍然可以使用相同的工具集。这强化了可重用性的原则。模块可重用，因为它们是独立的。

一个模块的例子

目前在代码环境中，模块非常重要。

让我们来考虑一个电子商务应用程序的简化版例子，它用于个人和企业在线销售产品。这个程序非常典型地由两个或多个不相关的任务组成，例如：

• 创建帐户
• 验证信息
• 处理支付
• 计算用户评分

等等。

不同于把所有不相关的程序放到一个模块\文件中，为这些任务创建若干个文件或者模块才是更好的方式。在这种情况下，模块变成了依赖项。

然后在主应用或者主程序中，你可以简单地导入\载入依赖项（也就是你需要的模块），并相应地执行。由此，你的主应用变得更简洁更小。

例如，假设你需要在代码库的其他应用中处理支付功能，这就变得很容易去重用相同的功能。不需要复制粘贴，也不需要从头编写新功能。

JavaScript 模块

JavaScript 中的模块就是一个包含相关代码的文件。

JavaScript 使用 import 和 export 关键字在不同模块之间进行分享和接受功能块。

• 关键字 export 使得其他模块可以访问变量、函数、类和对象。换句话说，它变成了公共代码。
• 关键字 import 用于从其他模块引入公共代码。

让我们来看一个简单的例子：

function getPower(decimalPlaces) {
	return 10 ** decimalPlaces;
}

function capitalize(word) {
	return word[0].toUpperCase() + word.slice(1);
}

function roundToDecimalPlace(number, decimalPlaces = 2) {
	const round = getPower(decimalPlaces);
	return Math.round(number * round) / round;
}

export { capitalize, roundToDecimalPlace };

这个模块定义了三个函数：

• getPower：此函数获取数字的幂
• capitalize：此函数将单词中的第一个字母大写
• roundToDecimalPlace：此函数将给定的数字四舍五入到指定的小数位数。

在文件的最后，可以看到三个函数中的两个被导出了。换句话说，它们变成了公共函数，可以被其他脚本使用了。

要从三个函数中导出两个，使用 export 关键字，并在后面加上一个对象，包含你想要访问的函数。一旦这样做，该代码库中需要这些函数的任何程序，都可以进行访问了。

让我们看看如何使用它们：

import { capitalize, roundToDecimalPlace } from './main';

function displayTotal(name, total) {
	return `${capitalize(name)}, your total cost is: ${roundToDecimalPlace(total)}`;
}

displayTotal('kingsley', 20.4444444);
// "Kingsley, your total cost is: 20.44"

export { displayTotal };

displayTotal.js 模块没有 capitalize() 和 roundToDecimalPlace()，但是想使用首字母大写的功能和舍入小数位的功能。该怎么引入呢？使用 import！

要实现它，我们使用 import 关键字，并在后面加上我们要想从模块中导入的函数名，在这个例子中也就是 capitalize 和 roundToDecimalPlace。

如果你只是想导入 capitalize 函数到程序呢？

很简单——只导入 capitalize() 即可，像这样：

import { capitalize } from './main';

function warn(name) {
	return `I am warning you, ${capitalize(name)}!`;
}

warn('kingsley');
// I am warning you, Kingsley!

export { warn };

注意：在处理模块时，理解文件结构的工作原理是非常重要的。在上面的例子中，我们只是简单地从同级目录下的文件中导入，因此我们用了符号 './import'。

如果你想从另一个模块中导入所有公共函数，请使用星号 * 关键字:

import * as mainfunctions from './main';

function warn(name) {
return `I am warning you, ${mainfunctions.capitalize(name)}!`;
}
warn('kingsley');
// I am warning you, Kingsley!

export { warn };

提示：如果要导入一个模块的全部函数，你应该使用星号，而不是把所有函数逐个显式地写出来。

你可能注意到 as 关键字。我们用它将公共函数导入到新的对象中，在我们的例子中，这个对象是 mainfunctions。然后就可以在我们的程序中访问和调用这些需要用到的函数了。

到现在为止，我们只考虑了在文件末尾导出的例子。其实你可以在函数、变量或类的定义前注册 export 关键字，这同样可以导出它们。像这样：

function getPower(decimalPlaces) {
	return 10 ** decimalPlaces;
}

export function capitalize(word) {
	return word[0].toUpperCase() + word.slice(1);
}

export function roundToDecimalPlace(number, decimalPlaces = 2) {
	const round = getPower(decimalPlaces);
	return Math.round(number * round) / round;
}

如果和第一个例子进行比较，你会注意到这种语法差异：

• 在第一个例子中，export 关键字用于在脚本的末尾导出两个函数。而在上面的例子中，export 关键字在定义两个函数时被依附在前面。

不过，它们的结果是一样的：capitalize 和 roundToDecimalPlace 都将被导出。

默认导出

如果你要导出全部三个函数，但是想让其中一个作为默认值（也许是因为你最有可能使用那个函数），你只需使用 default 关键字。

默认关键字使得导入一个函数变得更加容易，让我们来考虑下面的例子：

export function getPower(decimalPlaces) {
	return 10 ** decimalPlaces;
	}

export default function capitalize(word) {
	return word[0].toUpperCase() + word.slice(1);
	}

export function roundToDecimalPlace(number, decimalPlaces = 2) {
	const round = getPower(decimalPlaces);
	return Math.round(number * round) / round;
	}

可以看到，我们把 capitalize 作为我们的默认函数。这实质上意味着我们赋予了它某种特权。

现在我们想将模块中的 capitalize 函数导入到另一个程序中。语法非常相似，只是导入的函数不再需要用花括号括起来：

import capitalize from './main';

function warn(name) {
	return `I am warning you, ${capitalize(name)}!`;
}

warn('kingsley');
// I am warning you, Kingsley!

export { warn };

如果要将默认函数与任何其他函数一起导入，就将裸露的“默认”函数与花括号中的其他函数混合在一起导入：

import capitalize, { getPower } from './main';

function warn(name) {
	return `I am warning you, ${capitalize(name)}!`;
}

warn('kingsley');
// I am warning you, Kingsley!

export { warn };

总结

模块是独立且自包含的代码块。将较大的程序拆分为逻辑部分或依赖项，从而创建模块。

模块应该是独立的、专门的和可重用的。

使用 import 和 export 关键字来交换 JavaScript 模块间的功能。

使用 default 关键字来指定那些你要作为首选导入的函数、对象、变量或类。

至此，我们已经涵盖了 JavaScript 模块的基础知识。

希望你能从这篇文章中得到一些有价值的东西。我每周都会在我的个人博客上写与编程相关的文章。

感谢你阅读本文。

附言：如果你正在学习 JavaScript，我创建了一本电子书，用手绘数字笔记的方式教授了 JavaScript 的 50 个主题。点这里查看。

原文：JavaScript Modules – Explained with Examples，作者：Kingsley Ubah

作为开发者，将我们所学到的知识通过发布文章和创建视频内容的形式分享出去，是一个很棒的方式。你可以拥有自己的博客，也可以为专栏撰稿。不管是哪种，你都可以遵循特定的流程来好好创作。

本文将介绍博客写作的基础知识，以帮助开发者撰写出色的文章。

TL;DR

以下高度总结了大部分要点。但是，我们将更详细地讨论一些现实生活中的经验以及学习如何写博客。请继续往下看。

高质量的内容写作是一个过程，它需要：

👉 计划

👉 研究内容

👉 审核

👉 发布时间

👉 最重要的，写作的意图

为产出高质量的内容花一些时间是值得的，不要着急。

— Tapas Adhikary (@tapasadhikary) 2021.04.03

了解你的目的

当我们开始做某事时，都需要一个目的，以及继续做它的动力。我们行动背后的意图和动机，因人而异。你需要找到你的意图或目的，能够解释为什么你要开始创建一个博客或分享内容。

在大多数情况下，简单的答案可能是激情。很有道理！它也可能是一种商业策略，或者你想教别人。也许你想持续学习——不管你是因为什么原因开始写作，都很棒。

作为一个开发者，我们一直在学习新东西。记住我们所学的每一部分知识几乎是不可能的。当我们记录那些教训和信息时，这些知识也就可以被重用了。

这就是为什么写一篇关于你最近学到的东西的文章，是一个很好的主意，这就是一个好的意图。

💡 小提示： 创建一个私人 GitHub 仓库，以及一个 markdown 文件。当你遇到新事物时，在这个文件中添加注释（如果需要的话还可以加代码）。

这个文件的内容将作为你今后文章的优秀资源。出于这个目的，我在维护一个名为 TIL_2021.md 的文件（记录了我 2021 年学到的东西）。

当决定写博客时，我打算通过分享知识来学习。如果你想深入学习一些东西，请开始教别人。写博客就是一个很棒的方式。

找到你的动机

拥有动机可以创造奇迹，但是没有它就很难继续做下去。作为内容创作者，最大的动力无疑是听到读者的反馈。积极的反馈和建设性的批评总是可以帮助你改进创造的内容。

但是有个问题，刚开始，很少有人会给你反馈。如果你是一个个人博主，失望的概率会很高。因此，拥有自我激励，对维持和继续你的工作是很有帮助的。

记住——不要放弃，保持动力。作为开发人员，你有很多东西要学习、分享和撰写。

💡 小提示： 如果你想以开发者的身份开始写博客，开发者社区有助于你保持联系、保持动力。有很多极其精彩的社区，如 Hashnode，Dev.to，Codenewbie，Hackernoon，freeCodeCamp，GirlsWhoCode等，还有很多。

做好你的研究

研究是关键。内容决定一切。

对博客来说，内容为王。作为开发者，我们有各种各样的想法、解决问题的步骤，以及想要掌握的新知识。但是最重要的是能把它们转化为优质的内容。通常，花时间把你的话题彻底研究明白，是很有必要的。

现在我来举一个关于内容研究的例子。假设你用链表解决了一个问题，而且是你第一次使用，你非常激动，想把学到的分享出来，以下是需要考虑的点：

• 你需要大致理解链表以及已经被解决的问题的上下文
• 你需要理解链表的优缺点
• 你需要创建几个例子来演示如何用好它
• 你需要确保清楚地解释了你解决问题的方法，这样读者才能在他们自己的案例中使用

💡 小提示： 一旦明白了你需要知道什么，你就可以从任何完备的资源中进行学习。你可以在 Google，Quora，Reddit 等上面进行搜索。Stackoverflow 同样也是一个优秀的平台，你可以用它来检索你的话题。

确保在取得进步时记下所学的内容，这些笔记最终将转化成你要撰写和发布的文章。

规划你的内容结构

一旦完成了内容研究，下一步就是规划文章的结构。如果你的文章结构不完整而且混乱，那么再好的内容也会被读者忽略。

以下是一些小提示，帮助你用一种可读的方式来构建文章内容：

• 文章标题： 一个引人注目的标题可以吸引很多读者来访问你的文章。不管怎样，人们很难忽视阅读文章的标题。保持标题悦耳易记，能提升文章的流量。
• 封面图片： 一张相关的封面图片使得文章更加具有吸引力。当你在社交媒体上分享文章时，一张创意十足的封面将吸引你的读者。
• 简介： 这部分高度概括了你的文章内容。它可以是第一段，也可以是一个 Tl;DR，用以解释你打算在文章中介绍的内容。
• 段落标题和子标题： 你应该将内容分解成几个关联的子话题。为了达到这个目的，创建几个部分，并提供与之相关的标题和子标题。例如，在这篇文章中，我创建了多个部分，给每个部分配上了标题，如了解你的目的，找到你的动机等。
• 图形： “一张图片胜过千言万语”，因此请考虑用一些图表、图片等来支持你的内容。
• 总结： 最后的总结部分，可帮助你的读者回顾到目前为止他们从文章中学到的东西。同样，对于有些读者，再次过来收集内容时，只要通过快速阅览总结部分就可以了，这很有帮助。
• 重要的链接： 你可能希望以一个参考链接的列表来结束文章，以供读者进一步阅读。你也可以在这一部分列出你以前发布的文章的链接。

💡 小提示：尝试在你的文章中使用一个统一的内容结构，这样你的读者会习惯它，然后会发现很容易理解。

写作工具

创造优质内容很花时间。你可以使用一些免费可用的工具，使自己成为一个多产和高效的内容创造者。这里有一些你可能觉得有用的工具，

⚒️ Notion：这个工具可以帮助你以高效的方式管理个人和专业的工作代办事项。任何时候产生一篇文章的想法或者你解决了一个有趣的问题，在这个工具中创建一项任务。你可以轻松排序，安排时间，分配任务。

⚒️ Grammarly：如果你跟我一样，是一个非英语母语者，有时可能会对语言的语法规则不够熟悉。

在这种情况下，像 Grammarly 这样的工具在各个方面扮演拯救者。它检查语法和拼写错误，建议对复杂句子重新措辞，纠正被动语态为主动语态，等等。你可以先使用试用版本，之后根据你的使用情况来升级到付费版。

⚒️ Hemingway Editor：这是另一个优秀的工具，用于协助你进行英语写作。如果你愿意，可以和 Grammarly 结合使用。副词、主动/被动语态，以及复杂的单词和短语，这些如果使用不当，它都能指出，这一点我很喜欢。

⚒️ Canva：Canva 是进行设计、艺术和释放创造力的工具。在没有任何 Canva 经验的情况下，你依然可以用它来创建封面图像、文章图形、动画 gif 等。它慷慨的免费计划足以让你开始使用。

⚒️ Pixteller：这是用于创建封面图像、图形等的另一个工具。

⚒️ ShareX：它是一款超酷的生产力工具，用于截屏、制作动画图片、文件共享等。

⚒️ OBS Studio：这是一个免费的开源视频录制和流媒体工具。你可能会疑惑，为什么我写博客需要它？

有时，你可能想要创建一段视频，上传到 YouTube 或 Vimeo，并从你的文章中链接到该视频。你可以使用 OBS Studio 创建优质视频，它有很多自定义选项。

⚒️ SERP 片段生成器：SERP（搜索引擎结果页）是我们在 Google 或 Bing 等搜索引擎输入查询后看到的页面。SERP 片段生成器可帮助你在发布文章之前确定合适的标题和元描述。

请参阅下图以找出限制范围内的标题和描述，以正确显示搜索结果。

进行大量审核

你写了一些东西，在发布或分享之前，需要检查错误并审核你的文章。检查，确保你的内容已经准备好进行发布。通常，你应该检查：

• 拼写错误
• 语法错误
• 格式问题
• 标点符号
• 准确性
• 语言一致性

在校对和审核方面，有一句名言可以激发灵感：

“我发现修改你自己的作品的最好方法是假装它是别人写的，然后把它撕掉。” - Don Roff

发布你的文章

如果在审核之后，你对文章很满意，接下来一步自然就是发布它。你可能希望将其安排在一周中的特定日期进行发布，或者你想立即发布——这取决于你自己。

一般而言，最好是在你准备好文章时就发布。同样，你不应该赶着最后期限去匆忙发布。

💡 小提示： 发布你的文章必须是整个计划的一部分。如果你需要在一个特定日期发布文章，那就要你逆向规划相应的内容。千万不要为了匆忙发布，而妥协文章内容的质量。

在社交媒体分享你的文章

社交媒体是一个极其强大的工具。作为博主，你应该积极利用它。

如果你希望文章尽可能多地吸引潜在读者，发表文章可能还不够。因此，在各种社交媒体平台上分享你的文章是个好主意。

你应该分享文章的链接到以下几个平台：

• 推特
• 领英
• 红迪网
• 黑客新闻
• 脸书

还有一些平台，单独分享链接并不会有什么效果。你可以创建适合主题的封面照片或图表，然后把它和链接上传到像 Instagram 和 Pinterest 这样的地方，记得使用正确的主题标签。

💡 小提示：分享博客链接时，请确保你遵守了每个社交媒体平台各自的规则。如果不这么做，你的账号可能会被标记或者被禁掉。

还有另一种令人兴奋的方式来分享你的内容，那就是交叉发布它。如果允许的话，你可以在其他博客平台上重新发布你的文章。例如，一篇发布在 Hashnode 平台上的文章，可以重新发布在 Dev.to 平台上，反之亦然。

💡 小提示： 交叉发布文章时，你可以在原始文章的链接上设置 Canonical URL。这种方式告诉像谷歌这样的搜索引擎，哪个是原始的副本，同时消除重复的内容。

优秀的博客平台

好了，现在我们已经知道了如何写一篇文章并进行分享，以便他人可以阅读。接下来我们来了解一些你可以开始入门的博客平台。

以下是一些平台，你可以开始在上面写博客，进而成为社区的一份子。

• Hashnode
• DEV Community
• freeCodeCamp News
• HACKERnoon
• daily.dev
• Codenewbie Community
• Educative Edpresso Shorts
• CoFoundersTown

很多专栏和组织会雇佣并支付报酬给内容创作者。作为一个开发者博主，这可能会带来很多自由职业的机会，你会因为分享你的内容而获得报酬。你还可以为开源文档和其他项目做出贡献。

总结

总结来说，

• 作为一个开发者，写博客作为一项业余活动，是可以管理的，并不会影响你的工作输出。
• 你已经解决的问题，以及你在 Google、Quora 和 Stackoverflow 上的搜索，很可能成为你的写作灵感来源。
• 在开始写文章之前，确定你的目标。背后的意图可以是琐碎的，也可以是很重要的——无论哪种都可以。
• 保持动力。
• 使用合适的工具，使你成为一个多产的作者。
• 规划内容结构，审核你的文章，然后发布它们。
• 使用社交媒体工具来分享你的文章。
• 有一些很棒的博客平台，尝试一下，成为开发者社区的一份子。
• 保持学习，保持写作，以及保持分享。

在我们结束之前……

我希望这篇指南可以帮助你创作更多好文章。

让我们保持联系。你在可以在 推特 (@tapasadhikary) 上面找到我，请随时关注。

你也许还会喜欢以下文章：

• 如何毫不费力地找到博客内容创意？
• 从哪里开始？给新手的一些实用技巧
• 作为开发者，你为什么需要做业余项目？
• 你可能觉得有用的16个业余项目的 GitHub 仓库
• 作为一个软件开发者，如何每天学点新东西

原文：Technical Blogging Basics – How to Write Articles as a Developer，作者：TAPAS ADHIKARY

TCP 是 Transmission Control Protocol 的首字母缩写词，它是一种传输层协议，允许数据包从一个位置发送到另一个位置。

TCP 是面向连接的协议，也就是说它在网络计算机单元之间的任何通信之前建立连接。由于我们把这个协议与 IP 协议结合使用，我们称其为 TCP/IP。

TCP 是怎么工作的?

TCP 的主要任务是从应用层收集数据。它将数据拆分成多个数据包，为每个数据包分配一个编号，然后将这些数据包发送到它们的目的地。

同样，在将数据包发送到应用层之前，它会重新组合数据包。鉴于 TCP 是面向连接的协议，这个连接将一直保持，直到发送方和接收方完成数据交换。

它是一种可靠的协议。因为，接收方总是会给发送方提供一条关于数据包的确认消息，要么肯定要么否定，因此，发送方总是能知道数据包是否到达它的目的地，还是说需要被重新发送。

它保证了数据能到达其目的地，而且到达的顺序与发送时相同。它有一套内置的错误检查和恢复体系，负责提供端到端通信。TCP 还提供对流量控制和服务质量的访问。

TCP 支持全双工服务器，既可以当接收者，也可以当发送者。它以点对点的客户端/服务器方式运行。

什么是 UDP？

UDP 是 User Datagram Protocol 的首字母缩写词。用户数据报协议（UDP）是 TCP/IP 协议套件的最基本的传输层通信协议。它使用最低限度的通信机制。

UDP 是怎么工作的？

尽管 UDP 被认为是一种不可靠的传输协议，但它通过使用 IP 服务来完成其工作，提供了一种尽力而为的传递方法。

在 UDP 中，接收方不生成数据包的确认，发送方也不等待数据包的确认。正是这个不足，使得该协议虽不可靠但是易于处理。

如果确认是否接收到数据这点并不那么重要，这种情况下，我们使用 UDP。它很适用于单向数据流的场景，最适合基于查询的通信。

UDP 不保证数据包的有序传递。它是无状态的，不提供任何拥塞控制机制。

TCP 与 UDP 的区别

UDP 是一种无连接协议，而 TCP 是一种面向连接的协议。TCP 比 UDP 要慢，这是两种协议的主要区别之一。

总的来说，UDP 是一种更快、更简单、更高效的协议。但是只有 TCP 允许对丢失的数据包进行重新传输。

TCP 和 UDP 的另一个区别是 TCP 可以确保数据从用户到服务器的有序传输（反之亦然）。UDP 不是为端到端通信而设计的，并不会检查接收方的准备情况，因此它需要相对更少的开销并占用更少的空间。

TCP 与 UDP 的总结

连接

TCP 要求在发送方和接收方开始通信之前建立一个良好的连接，它是一个面向连接的协议。

UDP 是一种无连接协议。

保持数据传输的顺序

在 TCP 中，由于事先建立了一个良好的连接，接收方以有序的方式接收数据包。

而在 UDP 中，发送方与接收方之间并没有建立良好的连接，接收方将以无序的方式接收数据包。

可靠性

每当通过 TCP 接收到数据包时，接收方都会向发送方发送一条确认。万一失败，它会请求重新传输。

而使用 UDP，在这种情况下不会发送确认，它依赖于高层协议来确保可靠性。

错误检查

TCP 中有广泛的错误检查规则，而 UDP 中只有基本的错误检查技术，例如校验和。

传输方法

在 TCP 中，数据以字节流的形式读取，消息被发送到段边界。

而在 UDP 中，已定义限制的单个 UDP 数据包被发送，在到达接收方时验证其完整性。

广播

TCP 不支持广播。当你使用它时，发送方和接收方必须先建立一条连接，在传输结束后又必须终止这条连接。

UDP 支持广播。

TCP 与 UDP 的用例

TCP 被用于 HTTPS（安全超文本传输协议）、HTTP（超文本传输协议）、SMTP（简单邮件传输协议）、FTP（文件传输协议）等等。

UDP 用于视频流、视频电话、IP 语音服务（互联网呼叫）、DNS（域名系统）等。

TCP 对比 UDP - 哪个更快?

通常来说，UDP 比 TCP 更快，原因如下：

TCP 与 UDP 报头大小的差异

让我们来分析看看 TCP 数据包和 UDP 数据包各自的报头。

TCP 报头的长度必须至少为 20 字节且不超过 60 字节。

TCP 的报头包括：

1. 源端口 - 表示发送设备的源端口。占 16 位。
2. 目的端口 - 表示接收设备上的目的端口。占 16 位。
3. 序号 - 表示在一个会话中数据段的序号。占 32 位。
4. 确认号 - 该编号包括下一个预期的数据字节的序号，并在 ACK 标志被设置时，用作对先前接收到的数据的确认。占 32 位。
5. 数据偏移 - 该字段表示整个 TCP 报头的大小（32 位字）以及当前数据包在整个 TCP 段上的数据偏移量。占 4 位。
6. 保留 - 供将来使用的位，默认情况下设置为 0。占 3 位。
7. 标志 - 为各种标志保留了 1 位，这些标志有助于 TCP 检查各种活动，例如确认。
8. 校验和 - 该字段包含校验和。
9. 紧急指针 - 如果 URG 标志设置为 1，则指定数据字节。
10. 选项 - 指定了在常规报头中不存在的其他选项。

现在让我们来分析一个 UDP 报头。

UDP 的报头包括：

1. 源端口 - 表示发送设备的源端口。占 16 位。
2. 目的端口 - 表示接收设备上的目的端口。占 16 位。
3. 长度 - 指定 UDP 数据包的整体长度。它是一个 16 位的字段，最小值为 8 字节，等于 UDP 报头本身的大小。
4. 校验和 - 发送方在发送之前创建的校验和存储在此字段中。该字段在 IPv4 中是可选的，因此如果它不包含任何值，则设置为 0，并且其所有位都设置为 0。

我们可以清楚地看到 TCP 报头与 UDP 报头的开销差异。由于 TCP 报头比 UDP 报头大很多, 它需要更多的时间来处理，这使得了 UDP 比 TCP 更快。

TCP 与 UDP 中的确认

在 TCP 中，接收方在接收到的数据段上向发送方发送确认。这确保了数据包已传送到接收方。

如果没有收到确认，发送方会尝试重新传输。这个处理过程使得 TCP 比 UDP 慢得多。别忘了，UDP 不发送任何确认。

规则的例外

在某些情况下，TCP 被证实比 UDP 要快。例如，在一个实验中，在一个最大传输单元为 1500 字节的以太网连接上，发送 300 字节的数据包，TCP 比 UDP 大约快 50%。

这是因为 TCP 会尝试缓存数据，填充到整个网段，从而最大化利用了带宽。而另一边，UDP 立即沿线路发送数据包，这些小数据包很多，堵塞了网络。

结论

TCP 和 UDP 都有各自的用途。如果主要关注数据接收的可靠性和顺序，你会更希望使用 TCP。

另一方面，如果主要关注的是速度，而且某些数据包的受损或丢失并不那么重要，请选择 UDP。

所以可以看到，你不得不在可靠性和速度这两个之间进行妥协。如果提升其中一个，由于前面的限制，另一个会下降。

例如，在 YouTube 视频中，您可能已经注意到，有多种选项用于设置视频的质量。

当提高质量时，视频会占用更多带宽。这是因为画质较低时，即使某些数据包丢失，我们也会忽略它们。但是如果想要高质量的视频，我们便不能丢失数据包。

感谢阅读！希望你对 TCP 与 UDP 有了一个更好的了解。

原文：TCP vs UDP – Which Protocol is Faster?，作者：Prashanth