NumPy in Python

本文将帮助你理解Python库中广泛使用的数组处理库 Numpy

一、什么是Numpy?

NumPy是一个通用的数组处理包。 它提供了一个高性能的多维数组对象，以及用于处理这些数组的工具。
它是使用Python进行科学计算的基础包。 它包含各种功能，包括以下重要功能：

• 一个强大的 N 维数组对象
• 复杂的广播（broadcasting）函数
• 可用于集成C / C ++和Fortran代码的工具
• 对于线性代数，傅立叶变换和随机数功能等非常有用

除了明显的科学用途外，NumPy还可以用作通用数据的高效多维数据集成。
可以使用Numpy定义任意数据类型，允许NumPy无缝且快速地与各种数据库集成。

二、安装Numpy：

MAC 和 Linux ：用户可以通过pip命令安装NumPy

pip install numpy

三、Numpy的普遍函数

1. Numpy 中的数组: Numpy主要的对象是一个homogeneous multidimensional array(齐次多维数组)

• 一个列表（元素通常是整数），元素全部是相同类型，以正整数元组索引
• 在 Numpy中维度（dimensions） 称为 轴（axes）， 而轴数（axes） 为 rank 。
• NumPy的数组类称为ndarray。 它也被别名数组所知

举例子说明：

[[ 1, 2, 3],
[ 4, 2, 5]]
这里的 rank = 2 (也可以称它为 2维的或者有2个轴）
一维 dimension(axis :（轴）) 长度 2，第二维度长度 3
整体形状可表示为 ：（2,3）

python程序说明：

# 导入numpy
import numpy as np

# 创建数组对象
arr = np.array([[2, 4, 8],
              [1, 3, 9]])
# 对应数组对象类型。
print("数组对象类型: ", type(arr))

#  数组dimension(axes)
print("维度: ", arr.ndim)

# arr 形状
print("形状: ", arr.shape)

#  arr 大小，即总共有多少个元素。
print("总共有多少个元素: ", arr.size)

# 数组中的元素类型
print("数组中的元素类型: ", arr.dtype)

程序输出

数组对象类型: <class ‘numpy.ndarray’>
维度: 2
形状: (2, 3)
总共有多少个元素: 6
数组中的元素类型: int64

2. 数组创建：有多种方法可以在NumPy中创建数组。

• 例如，您可以使用数组函数从常规Python列表或元组创建数组。得出的数组的类型是从序列中元素的类型推导出来的。
• 通常，数组的元素最初是未知的，但其大小是已知的。 因此，NumPy提供了几个函数来创建具有初始占位符内容的数组。比如 np.zeros, np.ones, np.full, np.empty 等
• 为了创建数字序列，NumPy还提供了一个类似于返回数组而不是列表的范围的函数。
• arange: 返回均匀间隔值。 步长是指定的。
• linspace: 返回给均匀间隔值
• reshape: 使用reshape重建数组。数组的原始大小不会改变。
• flatten: 我们可以使用flatten 方法使数组降维为一维数组。它接受命令行参数，默认用 ‘C’ 为行，“F” 为列。

Note: 创建数组时可以显式定义数组类型

# 导入numpy
import numpy as np

# 从列表中创建类型为float的数组
a = np.array([[1, 2, 4], [5, 8, 7]], dtype = 'float')
print ("从列表中创建类型为float的数组:\n", a)

# 从元组中创建数组
b = np.array((1, 3, 2))
print ("\n从元组中创建数组:\n", b)

# 创建 3 × 4的数组，全部初始化化为 0
c = np.zeros((3,4))
print("\n创建 3 × 4的数组，全部初始化化为 0:\n", c)

# 创建复数类型的数组
d = np.full((2,3), 5, dtype='complex') 
print("\n创建复数类型的数组:\n", d)

# 创建数组随机元素
e = np.random.random((3,4))
print("\n创建数组随机元素:\n", e)

# 创建序列数字
# 从 0 到 10，间隔步长为3
f = np.arange(0, 10, 3)
print("\n创建序列数字步长为3:\n", f)

# 创建10个序列数字，范围在 0 到 5 之间
g = np.linspace(0, 5, 10)
print("\n范围在 0 到 5 之间,创建10个序列数字:\n", g)

# Reshaping 3X4 array to 2X2X3 array 
# 把 3×4 数组修改为 2×2×3 数组
arr = np.array([[1, 2, 3, 4], 
                [5, 2, 4, 2], 
                [1, 2, 0, 1]]) 
  
newarr = arr.reshape(2, 2, 3)
print ("\n原来 array:\n", arr) 
print ("重建reshape array:\n", newarr) 

# 展平（flatten) 数组为一维数组
arr = np.array([[1, 2, 3], [4, 5, 6]]) 
flarr = arr.flatten() 
print ("\n原来 array:\n", arr) 
print ("展平（Fattened） array:\n", flarr) 

输出

从列表中创建类型为float的数组:
[[1. 2. 4.]
[5. 8. 7.]]

从元组中创建数组:
[1 3 2]

创建 3 × 4的数组，全部初始化化为 0:
[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]

创建复数类型的数组:
[[5.+0.j 5.+0.j 5.+0.j]
[5.+0.j 5.+0.j 5.+0.j]]

创建数组随机元素:
[[0.13186259 0.33470702 0.99243607 0.89967356]
[0.166436 0.55366201 0.64702275 0.72892835]
[0.81991832 0.44988572 0.1709421 0.27000915]]

创建序列数字步长为3:
[0 3 6 9]

范围在 0 到 5 之间,创建10个序列数字:
[0. 0.55555556 1.11111111 1.66666667 2.22222222 2.77777778
3.33333333 3.88888889 4.44444444 5. ]

原来 array:
[[1 2 3 4]
[5 2 4 2]
[1 2 0 1]]
重建 array:
[[[1 2 3]
[4 5 2]]

[[4 2 1]
[2 0 1]]]

原来 array:
[[1 2 3]
[4 5 6]]
展平（Fattened） array:
[1 2 3 4 5 6]

3. 数组索引：对于分析和操作数组，知道基本的数组索引是很重要，NumPy提供了很多方法进行数组索引

• 切片(slicing): 就像Python中的列表一样，NumPy 数组也是可以切片的，由于数组可以是多维的，因此你需要为数组的每一个维度指定一个切片
• 整数数组索引： 在此方法中，传递列表以便为每个维度建立索引，完成对应元素的一对一映射方便构造新的任意数组。
• 布尔数组索引：当我们想要从满足某些条件的数组中选择元素时，使用此方法。

# 导入numpy
import numpy as np

# 创建类型
arr = np.array([[1, 2, 4, 11], [5, 8, 7, 13], [7, 9, 14, 17]])

# 切片例子
# 前面两行, 提取下标 0 和 3
temp = arr[:2, ::3]
print("切出前面2行, 提取下标分别为 0 和 3的值:\n", temp)

# 整数数组索引例子
temp = arr[[0, 1, 2], [3, 1, 0]]
print ("\n对应的元素在 (0, 3), (1, 1), (2, 0):\n", temp)

# 布尔数组索引例子
# cond 是一个布尔数组[[False False True]]
cond = arr > 5 
temp = arr[cond] 
print ("\n元素大于5的数 :\n", temp) 

输出

切出前面2行, 提取下标分别为 0 和 3的值:
[[ 1 11]
[ 5 13]]

对应的元素在 (0, 3), (1, 1), (2, 0):
[11 8 7]

元素大于5的数 :
[11 8 7 13 7 9 14 17]

4. 基本的运算：NumPy 提供了许多内置的算术函数

• 单个数组的算术运算：我们可以使用重载算术运算符对数组进行元素操作来创建新数组

# 算术运算
import numpy as np 
  
a = np.array([1, 2, 5, 3]) 

# 每一个元素都加１　
print("每一个元素加 １\n", a + 1)

# 每一个元素都减去１　
print("\n每一个元素减 １\n", a - 1)

# 每一个元素都乘于３　
print("\n每一个元素都乘于 ３\n", a * 3)

# 每一个元素都除以２　
print("\n每一个元素都除以２ ３\n", a / 2)

# 每一个元素都平方
print("\n每一个元素都平方　\n", a ** 2)

# 修改 a
a *= 2
print("\n修改:\n", a)

# 数组，矩阵的转置
arr = np.array([[1, 2, 3], [4, 5, 6]])
print ("\n原始数组:\n", arr) 
print ("转置后的数组:\n", arr.T) 

输出

每一个元素加 １
[2 3 6 4]

每一个元素减 １
[0 1 4 2]

每一个元素都乘于 ３
[ 3 6 15 9]

每一个元素都除以２ ３
[0.5 1. 2.5 1.5]

每一个元素都平方　
[ 1 4 25 9]

修改:
[ 2 4 10 6]

原始数组:
[[1 2 3]
[4 5 6]]
转置后的数组:
[[1 4]
[2 5]
[3 6]]

• 一元（单目）运算：提供了许多一元操作作为ndarray类的方法。 这包括sum，min，max等。通过设置轴参数，也可以按行或列方式应用这些函数。

注意： 我们上面使用重载运算符执行的所有操作都可以使用普遍函数来完成，如np.add，np.subtract，np.multiply，np.divide，np.sum等。

# 单目运算
import numpy as np 
  
arr = np.array([[1, 5, 6], 
                [4, 7, 2], 
                [3, 8, 9]])

# 数组元素中最大的数
print("最大的数:\n", arr.max())
print("每行中最大的数组合\n", arr.max(axis = 1))
print("每列中最大的数组合\n", arr.max(axis = 0))

# 同样，数组元素最小的数
print("\n最小的数:\n", arr.max())
print("每行中最小的数组合\n", arr.max(axis = 1))
print("每列中最小的数组合\n", arr.max(axis = 0))

# 数组元素的和
print("\n数组元素和:\n", arr.sum())

# 每行的累计和
print("\n每个元素，每行的累计和：\n", arr.cumsum(axis = 1))

输出

最大的数:
9
每行中最大的数组合
[6 7 9]
每列中最大的数组合
[4 8 9]

最小的数:
1
每行中最小的数组合
[1 2 3]
每列中最小的数组合
[1 5 2]

数组元素和:
45

每个元素，每行的累计和：
[[ 1 6 12]
[ 4 11 13]
[ 3 11 20]]

• 二元运算：这些操作适用于数组元素，并创建一个新数组。 您可以使用所有基本的算术运算符，如+， - ，/等。如果是+ =， - =，=运算符，则会修改现有数组。

# 二元运算
import numpy as np 
  
a = np.array([[1, 2], 
            [3, 4]]) 
b = np.array([[4, 3], 
            [2, 1]]) 
  
# 两个数组相加
print ("两个数组相加:\n", a + b) 
  
# 数组相乘（元素相乘）
print ("\n数组相乘:\n", a*b) 
  
# 矩阵乘法 
print ("\n矩阵乘法:\n", a.dot(b)) 

输出

两个数组相加:
[[5 5]
[5 5]]

数组相乘:
[[4 6]
[6 4]]

矩阵乘法:
[[ 8 5]
[20 13]]

• 通用功能(universal functions)：NumPy提供熟悉的数学函数，例如sin，cos，exp等。这些函数也在元素上以元素方式运行，产生数组作为输出。

# 通用功能
import numpy as np
  
# 创建一个正弦值数组
a = np.array([0, np.pi/2, np.pi]) 
print ("数组元素的正弦值:\n", np.sin(a)) 
  
# 指数值(即 e) 
a = np.array([0, 1, 2, 3]) 
print ("\n数组元素的指数:\n", np.exp(a)) 
  
# 数组值的平方根 
print ("\n数组元素的平方根:", np.sqrt(a)) 

输出

数组元素的正弦值:
[0.0000000e+00 1.0000000e+00 1.2246468e-16]

数组元素的指数:
[ 1. 2.71828183 7.3890561 20.08553692]

数组元素的平方根: [0. 1. 1.41421356 1.73205081]

• 数组排序：有一个简单的np.sort方法用于排序NumPy数组。 我们来探讨一下吧。

import numpy as np 
  
a = np.array([[1, 4, 2], 
              [3, 4, 6], 
              [0, -1, 5]]) 
  
# 数组排序
print ("按顺序排序的数组元素:\n", 
                np.sort(a, axis = None)) 
  
# 每一行数组元素排序 
print ("\n每一行数组元素排序:\n", 
                np.sort(a, axis = 1)) 
  
# 指定排序算法
print ("\n通过合并排序算法进行每一列排序:\n", 
                np.sort(a, axis = 0, kind = 'mergesort')) 
  
# 显示结构化数组排序的示例：
# 为dtypes设置别名
dtypes = [('name', 'S10'), ('grad_year', int), ('cgpa', float)] 
# 放在数组中的值
values = [('Hrithik', 2009, 8.5), ('Ajay', 2008, 8.7),  
           ('Pankaj', 2008, 7.9), ('Aakash', 2009, 9.0)]        
# 创建数组 
arr = np.array(values, dtype = dtypes) 
print ("\n数组按 name 排序:\n", 
                np.sort(arr, order = 'name'))         
print ("数组按 grad_year 排序，然后是 cgpa:\n", 
                np.sort(arr, order = ['grad_year', 'cgpa'])) 

输出

按顺序排序的数组元素:
[-1 0 1 2 3 4 4 5 6]

每一行数组元素排序:
[[ 1 2 4]
[ 3 4 6]
[-1 0 5]]

通过合并排序算法进行每一列排序:
[[ 0 -1 2]
[ 1 4 5]
[ 3 4 6]]

数组按 name 排序:
[(b’Aakash’, 2009, 9. ) (b’Ajay’, 2008, 8.7) (b’Hrithik’, 2009, 8.5)
(b’Pankaj’, 2008, 7.9)]
数组按 grad_year 排序，然后是 cgpa:
[(b’Pankaj’, 2008, 7.9) (b’Ajay’, 2008, 8.7) (b’Hrithik’, 2009, 8.5)
(b’Aakash’, 2009, 9. )]

四、NumPy的高级方法

1. 堆叠拼接(Stacking)：几个数组可以沿不同的轴(axes)堆叠在一起。

• np.vstack: 沿垂直轴堆叠数组。
• np.hstack: 沿水平轴堆叠数组。
• np.column_stack: 将1-D阵列作为列堆叠成2-D阵列
• np.concatenate 沿指定axis 堆叠数组（axis 作为参数传递）。

import numpy as py

a = np.array([[1, 2],
             [3, 4]])
b = np.array([[5, 6],
             [7, 8]])
print("沿垂直轴拼接：\n", np.vstack((a, b)))
print("\n 沿水平轴拼接：\n", np.hstack((a, b)))

c = [11, 22]
# 对应行拼接
print("\n行拼接:\n", np.column_stack((a, c)))

# 连接 
print("\n连接到第二轴:\n", np.concatenate((b, a), 1)) 

输出

沿垂直轴拼接：
[[1 2]
[3 4]
[5 6]
[7 8]]

沿水平轴拼接：
[[1 2 5 6]
[3 4 7 8]]

行拼接:
[[ 1 2 11]
[ 3 4 22]]

连接到第二轴:
[[5 6 1 2]
[7 8 3 4]]

2. 拆分(Splitting)：

• np.vsplit: 沿垂直轴拆分数组
• np.hsplit: 沿水平轴拆分数组
• np.array_split: 沿指定轴（axis) 拆分数组。

import numpy as np 
  
a = np.array([[1, 3, 5, 7, 9, 11], 
              [2, 4, 6, 8, 10, 12]]) 
  
print("沿水平轴分裂成2个部分:\n", np.hsplit(a, 2)) 
  
print("\n沿垂直轴分裂成2个部分:\n", np.vsplit(a, 2))

输出

沿水平轴分裂成2个部分:
[array([[1, 3, 5],[2, 4, 6]]),
array([[ 7, 9, 11], [ 8, 10, 12]]) ]

沿垂直轴分裂成2个部分:
[array([[ 1, 3, 5, 7, 9, 11]]), array([[ 2, 4, 6, 8, 10, 12]])]

五、最后

这是NumPy库的简短而简洁的介绍和教程。有关更详细的研究，请参阅Numpy官网教程

注:本文主要翻译GeeksforGeeks Python 并做修改解释。