Python数据处理入门教程

内容旨在帮助没有基础的同学 快速掌握 numpy 的常用功能，保证日常绝大多数场景的使用 。可作为机器学习或深度学习的先修课程，也可作为快速备查手册。

值得一提的是， 深度学习的各大框架很多 API 和 numpy 也是一脉相承的哦 ，可以说 numpy 玩儿熟了，几个深度学习框架的不少 API 也同时学会了。 本文是教程的「第一部分」，从实际的代码应用出发，讲解了Numpy创建到统计的操作。

教程原 则如下：

· 偏实用高 频 API

· 展示实际用法

· 简单直接

使用 说明：内容中 :star:（1-5个）表示重要程度，越多越重要；:warning: 表示需要特别注意的

提示：使用过程中无须过多关注 API 各种参数细节，教程提供的用法足以应付绝 大部分场景，更深入的可自行根据需要探索或学习后续的教程。

下面正式开始讲解。

# 导入 library
import numpy as np
# 画图工具
import matplotlib.pyplot as plt

创建和生成

本节主要介绍 array 的创建和生成。为什么会把这个放在最前面呢？主要有以下两个方面原因：

首先，在实际工作过程中，我们时不时需要验证或查看 array 相关的 API 或互操作。同时，有时候在使用 sklearn，matplotlib，PyTorch，Tensorflow 等工具时也需要一些简单的数据进行实验。

所以，先学会如何快速拿到一个 array 是有很多益处的。本节我们主要介绍以下几种常用的创建方式：

• 使用列表或元组

• 使用 arange

• 使用 linspace/logspace

• 使用 ones/zeros

• 使用 random

• 从文件读取

其中，最常用的一般是 linspace/logspace 和 random，前者常常用在画坐标轴上，后者则用于生成「模拟数据」。举例来说，当我们需要画一个函数的图像时，X 往往使用 linspace 生成，然后使用函数公式求得 Y，再 plot；当我们需要构造一些输入（比如 X）或中间输入（比如 Embedding、hidden state）时，random 会异常方便。

从 python 列表或元组创建

:star::star: 重点掌握传入 list 创建一个 array 即可： np.array(list)

:warning: 需要注意的是：「数据类型」。如果您足够仔细的话，可以发现下面第二组代码第 2 个数字是「小数」（注：Python 中 1. == 1.0），而 array 是要保证每个元素类型相同的，所以会帮您把 array 转为一个 float 的类型。

# 一个 list
np.array([1,2,3])

array([1, 2, 3])

# 二维（多维类似）
# 注意，有一个小数哦
np.array([[1, 2., 3], [4, 5, 6]])

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

# 您也可以指定数据类型
np.array([1, 2, 3], dtype=np.float16)

array([1., 2., 3.], dtype=float16)

# 如果指定了 dtype，输入的值都会被转为对应的类型，而且不会四舍五入
lst = [
    [1, 2, 3],
    [4, 5, 6.8]
]
np.array(lst, dtype=np.int32)

array([[1, 2, 3],
       [4, 5, 6]], dtype=int32)

# 一个 tuple
np.array((1.1, 2.2))

array([1.1, 2.2])

# tuple，一般用 list 就好，不需要使用 tuple
np.array([(1.1, 2.2, 3.3), (4.4, 5.5, 6.6)])

array([[1.1, 2.2, 3.3],
       [4.4, 5.5, 6.6]])

# 转换而不是上面的创建，其实是类似的，无须过于纠结
np.asarray((1,2,3))

array([1, 2, 3])

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

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

 

使用 arange 生成

:star::star:

range 是 Python 内置的整数序列生成器，arange 是 numpy 的，效果类似，会生成一维的向量。我们偶尔会需要使用这种方式来构造 array，比如：

• 需要创建一个连续一维向量作为输入（比如编码位置时可以使用）

• 需要观察筛选、抽样的结果时，有序的 array 一般更加容易观察

:warning: 需要注意的是：在 reshape 时，目标的 shape 需要的元素数量一定要和原始的元素数量相等。

np.arange(12).reshape(3, 4)

array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

# 注意，是小数哦
np.arange(12.0).reshape(4, 3)

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

np.arange(100, 124, 2).reshape(3, 2, 2

array([[[100, 102],
[104, 106]],

[[108, 110],
[112, 114]],

[[116, 118],
[120, 122]]])

# shape size 相乘要和生成的元素数量一致
np.arange(100., 124., 2).reshape(2,3,4)

---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

 in 
----> 1 np.arange(100., 124., 2).reshape(2,3,4)


ValueError: cannot reshape array of size 12 into shape (2,3,4)

使用 linspace/logspace 生成

:star::star::star:

OK，这是我们遇到的第一个比较重要的 API，前者需要传入 3 个参数：开头，结尾，数量；后者需要额外传入一个 base，它默认是 10。

:warning: 需要注意的是：第三个参数并 不是 步长。

np.linspace

# 线性
np.linspace(0, 9, 10).reshape(2, 5)

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

np.linspace(0, 9, 6).reshape(2, 3)

array([[0. , 1.8, 3.6],
       [5.4, 7.2, 9. ]])

# 指数 base 默认为 10
np.logspace(0, 9, 6, base=np.e).reshape(2, 3)

array([[1.00000000e+00, 6.04964746e+00, 3.65982344e+01],
       [2.21406416e+02, 1.33943076e+03, 8.10308393e+03]])

# _ 表示上（最近）一个输出
# logspace 结果 log 后就是上面 linspace 的结果
np.log(_)

array([[0. , 1.8, 3.6],
       [5.4, 7.2, 9. ]])

下面我们更进一步看一下：

N = 20
x = np.arange(N)
y1 = np.linspace(0, 10, N) * 100
y2 = np.logspace(0, 10, N, base=2)

plt.plot(x, y2, '*');
plt.plot(x, y1, 'o');

# 检查每个元素是否为 True
# base 的 指数为 linspace 得到的就是 logspace
np.alltrue(2 ** np.linspace(0, 10, N)  == y2)

True
:warning: 补充：关于 array 的条件判断

# 不能直接用 if 判断 array 是否符合某个条件
arr = np.array([1, 2, 3])
cond1 = arr > 2
cond1

array([False, False,  True])

if cond1:
    print("这不行")

---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

 in 
----> 1 if cond1:
      2     print("这不行")


ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()

# 即便你全是 True 它也不行
arr = np.array([1, 2, 3])
cond2 = arr > 0
cond2

array([ True,  True,  True])

if cond2:
    print("这还不行")

---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

 in 
----> 1 if cond2:
      2     print("这还不行")


ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()

# 咱们只能用 any 或 all，这个很容易犯错，请务必注意。
if cond1.any():
    print("只要有一个为True就可以，所以——我可以")

只要有一个为True就可以，所以——我可以

if cond2.all():
    print("所有值为True才可以，我正好这样")

所有值为True才可以，我正好这样

使用 ones/zeros 创建

:star:

创建全 1/0 array 的快捷方式。需要注意的是 np.zeros_like 或 np.ones_like ，二者可以快速生成给定 array 一样 shape 的 0 或 1 向量，这在需要 Mask 某些位置时可能会用到。

:warning: 需要注意的是：创建出来的 array 默认是 float 类型。

np.ones(3)

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

np.ones((2, 3))

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

np.zeros((2,3,4))

array([[[0., 0., 0., 0.],
        [0., 0., 0., 0.],
        [0., 0., 0., 0.]],

       [[0., 0., 0., 0.],
        [0., 0., 0., 0.],
        [0., 0., 0., 0.]]])

# 像给定向量那样的 0 向量（ones_like 是 1 向量）
np.zeros_like(np.ones((2,3,3)))

array([[[0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.]],

       [[0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.]]])

使用 random 生成

:star::star::star::star::star:

如果要在这一节选一个最重要的 API，那一定是 random 无疑了，这里我们只介绍几个比较常用的「生产」数据相关的 API。它们经常用于随机生成训练或测试数据，神经网路初始化等。

:warning: 需要注意的是：这里我们统一推荐使用新的 API 方式创建，即通过 np.random.default_rng() 先生成 Generator ，然后再在此基础上生成各种分布的数据（记忆更加简便清晰）。不过我们依然会介绍就的 API 用法，因为很多代码中使用的还是旧的，您可以混个眼熟。

需要Python免费资料的可以点击传送门领取~