NumPy 基础 --- 【使用 NumPy 进行数据分析】

创作背景

最近本菜鸡在整理 NumPy 的知识，写下此篇博客以记录。
如果觉得我这篇文章写的好的话，能不能给我 点个赞 ，评论 、收藏 一条龙(☆▽☆)。如果要点个 关注 的话也不是不可以🤗。
请各位参加一下文末的 投票 哦，如果 有什么不足之处，还 请各位大佬在评论区提出，不胜感激。

学习目标

了解 Ndarray 对象的创建、切片、赋值操作，学习 ndarray 对象形状变换方法和对 ndarray 对象的数据进行操作。

任务描述

今天天气正好，数学家小明应要求要去做核酸检测。到达现场后，他发现人很多，有 100 个人，排成了长长的一列，这就造成了两侧空间的浪费。于是他建议把队伍变为 S 型，每一行有 10 个人，你能帮他排列一下队形吗？

知识准备

Ndarray 多维数组

NumPy 最重要的一个特点是其 N 维数组对象 ndarray，它是一系列 同类型 数据的集合，以 0 下标为开始进行集合中元素的索引。

其具有以下特点：

ndarray 对象是用于存放 同类型元素 的多维数组，这就有一个好处：如果我们知道数组中的元素为某一类型，该数组所需的存储空间就很容易确定下来。

下面我们就来看一下哪些函数可以创建 ndarray 对象。

我们可以通过 arange 函数来生成 等差数列 。

numpy.arange([*start*, ]*stop*, [*step*, ]*dtype=None*, ***, *like=None*)

该函数中第一个参数是等差数列 开始值 ，第二个参数是 结束值 。

eg：

In[]:	print(np.arange(1, 5))
    
Out[]:	array([1, 2, 3, 4])

如果我们想多生成一些数据的话，可以指定步长，也就是第三个参数。

eg：

In[]:	print(np.arange(1, 5, 0.5))
    
Out[]:	array([1. , 1.5, 2. , 2.5, 3. , 3.5])

如果我们要一个全为 1 的多维数组，应该怎么做呢？ ----- 可以使用 ones 函数。

numpy.ones(*shape*, *dtype=None*, *order='C'*, ***, *like=None*)

其中，第一个参数传入数组的 形状 ，例如一个 3x2 的数组，参数 shape 的值就应该是 (3, 2) 。

第二个参数是指定 数据类型，就是我们这个全为 1 的多维数组中，1 的类型是什么。可以是 整形 、浮点型 和 字符型 。

整形是默认的，就不在这里举例了。

浮点型如下：

In[]:	print(np.ones((3, 2), np.float64))
    
Out[]:	array([[1., 1.],
               [1., 1.],
               [1., 1.]])

字符型就是里边的数据全为字符：

In[]:	print(np.ones((3, 2), str))

Out[]:	array([['1', '1'],
               ['1', '1'],
               ['1', '1']], dtype='<U1')

后面的参数一般为默认，在这里不多赘述。

那全为 0 的多维数组呢？使用 zeros 函数，参数和 ones 类似，参考上文。

只有 0 和 只有 1 太单调了，那如果我想生成一个指定值、指定形状的数组应该怎么办呢？那就要用到 full 函数。

numpy.full(shape, fill_value, dtype=None, order='C', *, like=None)

其中，第一个参数仍然是数组的形状，这里就不多说了。

第二个参数就是我们要指定的数据了，如果我想生成一个数据全为 13 的多维数组，就可以使用下述代码实现。

In[]:	print(np.full((3, 2), 13))
    
Out[]:	array([[13, 13],
               [13, 13],
               [13, 13]])

第三个参数也同 ones 函数。

上面生成的多维数组是每个位置上都有数据，且数据都是相同的。

如果我们要生成一个类似于单位矩阵的多维数组应该怎么做呢？你可能会问，不会 NumPy 里有函数能实现这个功能吧？

被你猜对了， eye 函数就是生成一个类似于单位矩阵的多维数组。

numpy.eye(*N*, *M=None*, *k=0*, *dtype=<class 'float'>*, *order='C'*, ***, *like=None*)

其中，前两个参数还是指定单位矩阵的形状，如果不指定第二个参数的话，就默认生成 NxN 的矩阵。

eg：

In[]:	print(np.eye(3))

Out[]:	array([[1., 0., 0.],
               [0., 1., 0.],
               [0., 0., 1.]])

In[]:	print(np.eye(3, 2))

Out[]:	array([[1., 0.],
               [0., 1.],
               [0., 0.]])

参数 k 确定使用哪一对角线，传入的是索引值，默认为 0 ，也就是 主对角线 。正值代表 上对角线 ，反之，负值代表 下对角线 。

eg：

In[]:	print(np.eye(3, k=1))

Out[]:	array([[0., 1., 0.],
               [0., 0., 1.],
               [0., 0., 0.]])
    
In[]:	print(np.eye(3, k=-1))

Out[]:	array([[0., 0., 0.],
               [1., 0., 0.],
               [0., 1., 0.]])

后续参数同 ones 函数。

在 Python 中，0 是没有办法作为 除数 的，会报错，而在 NumPy 中却是可以的。

众所周知，任意非 0 的数与 0 相除的值都是 无穷大 ，而 0 除以 0 为空值。NumPy 中就支持这种表示方法。

In[]:	print(np.array(1) / np.array(0))
    
Out[]:	inf
    
In[]:	print(np.array(0) / np.array(0))

Out[]:	nan

这里的 inf 是单词 Infinity 的缩写，表示 无穷大 ；nan 则表示 空。

reshape 改变数组形状

在 NumPy 中，我们可以使用 reshape 改变数组的形状。

numpy.reshape(a, newshape, order='C')

其中，第一个参数是 要改变形状的数组 。第二个参数是 预期的形状 ，记得要传入的是 元组 对象哦。

eg：

我们可以先创建一个 3x2 的多维数组，并给所有的数据赋值为 13 。

In[]:	array = np.full((3, 2), 13)
    	print(array)

Out[]:	array([[13, 13],
               [13, 13],
               [13, 13]])

如果我们要把上述数组变为只有一行的数组，可以使用 reshape 函数。

In[]:	print(np.reshape(array, (1, 6)))

Out[]:	array([[13, 13, 13, 13, 13, 13]])

上述例子中，我们可以通过 $3\times 2=6$ 来求得数组中总的个数。因为我们确定了新数组中只有 1 行数据，所以可以确定新数组的列数。

可如果我们不知道数组中元素的总数，只知道新数组的行数的话，应该怎么给第二个参数传值呢？

不用担心，NumPy 的作者已经想到这个问题了，我们可以使用 -1 来代替未知的形状数值。

eg：

In[]:	print(np.reshape(array, (1, -1)))

Out[]:	array([[13, 13, 13, 13, 13, 13]])

可以看到，使用 -1 可以达到同样的效果。

注 ：要注意的是，数组的维度参数都必须是 整数 ，如果不是整数的话会报错。

如果我们要查看 ndarray 对象中内置的方法的话，我们可以发现 reshape 函数的踪迹。我们可以使用 Python 中内置的 dir 函数来查看。

In[]:	print(dir(array))
    
Out[]:	[……
    	'reshape',
         ……]

使用方法与 numpy.reshape 类似，不过不用传入第一个参数了。

多维数组的切片

NumPy 数组的切片方式与 Python 中的列表类似。

eg：

创建一个九宫格数组。

In[]:	array = np.arange(1, 10).reshape((3, 3))
    	print(array)
        
Out[]:	array([[1, 2, 3],
               [4, 5, 6],
               [7, 8, 9]])

我们可以使用取出第二行数据，即下标 1。

In[]:	print(array[1])

Out[]:	array([4, 5, 6])

如果要取出最中间的元素，也就是第二行第二个元素，我们可以使用下述代码。

In[]:	print(array[1][1])

Out[]:	5

因为上一步我们通过 array[1] 取出了第二行元素，而第二行元素也是 ndarray 对象，同样可以使用下标 1 来取出第二个元素。而这两个下标可以合并到一个中括号中，即：

In[]:   print(array[1, 1])
    
Out[]:  5

如果我们要让第二行倒序应该怎么做呢？

1. 取出第二行元素。

   In[]:	a = array[1]
       	print(a)
           
   Out[]:	array([4, 5, 6])
   

2. 倒序切片。

   In[]:	print(a[::-1])
   
   Out[]:	array([6, 5, 4])
   

这两步可以合并为一步，如下：

In[]:	print(array[1, ::-1])

Out[]:	array([6, 5, 4])

任务实施

思路

根据需求，我们可以规划一下思路。

1. 第一步，我们需要创建一个 1~100 的等差数列，来代表每个排队的人的序号。
2. 第二步，按照每行 10 人将一维的等差数列转化为多维数组。
3. 第三步，按照 S 的顺序对序号排序。

编写代码

首先，我们需要导入 NumPy 库。

import numpy as np

其次，我们来实现思路的第一步。

按照知识准备中的方法，我们很容易就能创建一个等差数列，代码如下：

queue = np.arange(1, 101)

再次，改变其形状。

queue = queue.reshape((10, 10))

然后，按照 S 的顺序排序。

for i in range(1, queue.shape[0], 2):
    queue[i, :] = queue[i, ::-1]

最后，将结果输出。

print(queue)

---

---

---

结尾

有想要一起学习 python 的小伙伴可以 私信我 进群哦。

以上就是我要分享的内容，因为 学识尚浅，会有不足，还 请各位大佬指正。
有什么问题也可在评论区留言。