NumPy（Numerical Python） 是科学计算基础库，提供大量科学计算相关功能，比如数据统计，随机数生成等。

其提供最核心类型为多维数组类型（ndarray），支持大量的维度数组与矩阵运算，Numpy 支持向量处理 ndarray 对象，提高程序运算速度。

安装： pip install numpy 

import numpy
nums = numpy.arange(10)
print(nums)               # [0 1 2 3 4 5 6 7 8 9]

以上只涉及 numpy 模块中的一个 arange 函数，该函数可以传入一个整数类型的参数 n，函数返回值看着像一个列表，其实返回值类型是 numpy.ndarray。这是Numpy中特有的数组类型。

如果传入 arange 函数的参数值是 n，那么 arange 函数会返回 0 到 n-1 的 ndarray 类型的数组。

1. 数组的创建

  numpy库可以用 array 函数、arange 函数创建数组，用numpy的random模块的random、randint、randn、normal创建不同的随机数，及其他方式创建数据。

1.1 array 创建

  numpy 模块的 array 函数可以生成多维数组。例如，如果要生成一个二维数组，需要向array 函数传递一个列表类型的参数。每一个列表元素是一维的 ndarray 类型数组，作为二维数组的行。

另外，通过 ndarray 类的 shape 属性可以获得数组每一维的元素个数（元组形式），也可以通过 shape[n] 形式获得每一维的元素个数，其中 n 是维度，从0 开始。语法格式如下：

    numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)

• object    数组或嵌套的数列
• dtype    数组元素的数据类型，可选
• copy     对象是否需要复制，可选
• order    创建数组的样式，C为行方向，F为列方向，A为任意方向（默认）
• subok    默认返回一个与基类类型一致的数组
• ndmin    指定生成数组的最小维度

import numpy
nums = numpy.array([1,2,3,4,5,6])
print(nums)
print("nums数组的维度：", nums.shape)

import numpy
nums = numpy.array([[1,2,3],[4,5,6],[7,8,9]])
print(nums)
print("nums数组的维度：", nums.shape)

ndmin参数和dtype参数：

import numpy
nums = numpy.array([1,2,3,4,5,6], ndmin=3)
print(nums)

import numpy
nums = numpy.array([1,2,3,4,5,6], dtype=complex)
print(nums)

1.2 arange创建

  使用 arange 函数创建数值范围并返回 ndarray 对象，函数格式如下：

    numpy.arange(start, stop, step, dtype)

• start ：  起始值，默认为0
• stop ：  终止值（不包括）
• step ：  步长，默认为1
• dtype ：  返回ndarray的数据类型，如果没有给，则会使用输入数据的类型

import numpy
x = numpy.arange(0,6,dtype=int)
print(x)
y = numpy.arange(10,20,2,dtype=float)
print(y)

import numpy as np
x = np.array([np.arange(1,4), np.arange(4,7), np.arange(7,10)])
print(x)
print("x数组的维度：", x.shape)

1.3 随机数创建

numpy.random.random(size=None)  

  该方法返回 [ 0.0, 1.0 ) 范围的随机数。参数 size 为随机数的数量，默认为None数量为1个。

import numpy as np
x = np.random.random(size=4)        # 生成4个[0.0,1.0)之间的随机数
y = np.random.random(size=(3,4))    # 生成3组，每组个[0.0,1.0)之间的随机数
print(x)
print(y)

[0.04562541 0.53471819 0.43092769 0.5599242 ]
[[0.59529002 0.15003052 0.45964074 0.49118845]
 [0.16284768 0.23298388 0.46419951 0.83983963]
 [0.03162865 0.01147148 0.82274122 0.06954801]]

numpy.random.randint()
  该方法有三个参数 low、high、size 三个参数。默认 high 是None,如果只有low，那范围就是 [0,low) 。如果有 high，范围就是 [low,high) 。

import numpy as np
x = np.random.randint(5,size=10)        # 生成10个[0,low)范围的随机整数
print(x)
y = np.random.randint(5,10,size=10)     # 生成10个[low,high)范围的整数
print(y)
z = np.random.randint(5,10,size=(2,4))   # 生成2*4个[low,high)范围的整数
print(z)

 [1 2 1 3 4 1 1 0 0 0]
[6 8 5 9 8 5 8 6 9 5]
[[9 6 9 9]
 [5 6 9 7]]

 numpy.random.randn(d0,d1,…,dn)
  randn 函数返回一个或一组样本，具有标准正态分布（期望为0，方差为1）。dn 表示每个维度，返回值为指定维度的 array

import numpy as np
x = np.random.randn()
print(x)
y = np.random.randn(2,4)
print(y)
z = np.random.randn(2,3,4)
print(z)

0.959216043254367
[[-0.27751908 -0.23905002 -1.68893817  1.00969689]
 [ 0.4015471   0.2082427  -0.24210676  1.23384583]]
[[[-0.43519602  0.10923992 -0.72637305  2.31244038]
  [ 0.60333821  1.18704964 -1.31302688  0.2451942 ]
  [-0.30002402  1.20902392 -0.11996799  1.93968828]]

 [[ 0.23977321 -0.82185041  1.75675118 -0.01669386]
  [ 0.68526545  0.68450452  0.7146507   0.08698484]
  [ 0.61900349 -0.51157511 -0.96765856  0.04767176]]]

numpy.random.normal()  指定期望和方差的正太分布

import numpy
x = numpy.random.normal(loc=3,scale=4,size=(2,2,3))
print(x)

[[[ 4.10836032  2.89186704  1.265006  ]
  [ 4.05894883  6.71475964  1.52367961]]

 [[-1.54105236  0.81934267  4.53406254]
  [ 6.26913631  8.18430261  7.70574038]]]

1.4 ndarray对象

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

• ndarray 对象是用于存放同类型元素的多维数组。
• ndarray 中的每个元素在内存中都有相同存储大小的区域。
• ndarray 内部由以下内容组成：

• •  一个指向数据（内存或内存映射文件中的一块数据）的指针。
  • 数据类型或 dtype，描述在数组中的固定大小值的格子。
  • 一个表示数组形状（shape）的元组，表示各维度大小的元组。

NumPy 的数组中比较重要 ndarray 对象属性有：

ndarray属性示例：

numpy as np
x1 = np.random.randint(10,size=6)
print(x1)
x2 = np.random.randint(10,size=(3,4))
print(x2)
x3 = np.random.randn(3,4,5)
print(" ndim属性".center(20,"*"), "秩，即轴的数量或维度的数量")
print("ndim：", x1.ndim, x2.ndim, x3.ndim)
print(" shape属性".center(20,"*"), "数组的维度，对于矩阵，n 行 m 列")
print("shape：", x1.shape, x2.shape, x3.shape)
print(" dtype属性".center(20,"*"), "ndarray 对象的元素类型")
print("dtype：", x1.dtype, x2.dtype, x3.dtype)
print(" size属性".center(20,"*"), "数组元素的总个数，相当于 .shape 中 n*m 的值")
print("size：", x1.size, x2.size, x3.size)
print(" itemsize属性".center(20,"*"), "ndarray 对象中每个元素的大小，以字节为单位，1个字节是8位")
print("itemsize：", x1.itemsize, x2.itemsize, x3.itemsize)

打印结果：

[3 9 7 6 3 4]
[[8 4 5 3]
 [4 0 5 1]
 [8 7 5 6]]
****** ndim属性******* 秩，即轴的数量或维度的数量
ndim： 1 2 3
****** shape属性****** 数组的维度，对于矩阵，n 行 m 列
shape： (6,) (3, 4) (3, 4, 5)
****** dtype属性****** ndarray 对象的元素类型
dtype： int32 int32 float64
****** size属性******* 数组元素的总个数，相当于 .shape 中 n*m 的值
size： 6 12 60
**** itemsize属性***** ndarray 对象中每个元素的大小，以字节为单位，1个字节是8位
itemsize： 4 4 8

1.5 其他方式创建

  ndarray 数组除了可以使用底层 ndarray 构造器来创建外，也可以通过以下几种方式来创建。

numpy.zeros 创建指定大小的数组，数组元素以 0 来填充：

numpy.zeros(shape, dtype = float, order = 'C')

import numpy
x = numpy.zeros(5)      # 创建5个0的数组，默认为float类型
print(x)
y = numpy.zeros((2,5), dtype=int)    # 创建2组5个0的数组，类型为int
print(y)

numpy.ones 创建指定形状的数组，数组元素以 1 来填充： 

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

import numpy
x = numpy.ones(5)        # 创建5个1的数组，默认类型为float
print(x)
y = numpy.ones((2,4), dtype=int)    # 创建2组4个1的数组，类型为int
print(y)

numpy.empty 方法用来创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组，里面的元素的值是之前内存的值：

numpy.empty(shape, dtype = float, order = 'C')

• shape：  数组形状
• dtype：  数组类型，可选
• order：  有"C"和"F"两个选项，分别代表行优先和列优先，在计算机内存中的存储元素的顺序

import numpy
x = numpy.empty([3,2], dtype=int, order='F')
print(x)

numpy.linspace 函数用于创建一个一维数组，数组是一个等差数列构成的，格式如下：

numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

• start     序列的起始值
• stop     序列的终止值。如果endpoint为True，该值包含于数列中。
• mum      要生成的等步长的样本数量，默认为50。
• endpoint     该值为True时，数列中包含stop值，反之不包含。默认为True。
• retstep    如果为True时，生成的数组中会显示间距，反之不显示。默认为False
• dtype      ndarray的数据类型，默认为float。

import numpy
x = numpy.linspace(1, 10, 10)    # 生成样本数为10，起始为1，终止为10的数据（默认为float）
print(x)

[ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]

import numpy
x = numpy.linspace(10, 15, 10, endpoint=False)        # 生成样本数为10，起始为10，终止为15（不包含）的数据（默认float）
print(x)

[10.  10.5 11.  11.5 12.  12.5 13.  13.5 14.  14.5] 

import numpy
x = numpy.linspace(1, 5, 10, retstep=True, endpoint=True, dtype=int)    # 生成样本数为10，起始为1，终止为5，类型为int 的数据，生成的数据带间距
print(x)

(array([1, 1, 1, 2, 2, 3, 3, 4, 4, 5]), 0.4444444444444444)

numpy.logspace 函数用于创建一个等比数列。格式如下：

numpy.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)

• start    序列的起始值为：base**start
• stop    序列的终止值为：base**stop （如果endpoint为True，该值包含于数列中）
• num    要生成的等步长的样本数量，默认为50
• endpoint  该值为True时，数列中包含stop值，反之不包含。默认为True
• base       对数log的底数
• dtype     ndarray的数据类型，默认为float

import numpy
x = numpy.logspace(0, 9, 10, base=2)    # 创建一个长度为10的等比数列，起始值为2的0次方，终止值为2的9次方
print(x)

[  1.   2.   4.   8.  16.  32.  64. 128. 256. 512.]

2. 切片和索引

   ndarray 对象的内容可以通过索引或切片来访问和修改，与 Python 中list 的切片操作一样。
ndarray 数组可以基于 0 - n 的下标进行索引，并设置 start, stop 及step 参数进行，从原数组中切割出一个新数组。
【示例】一维数组切片和索引的使用

import numpy
x = numpy.arange(10)
y = x[2:8:2]    # 左开右闭原则，含索引为2，不含索引为8的元素
z = x[2:]
print("x = ",x,"\t","y = ",y,"\t","z = ",z)

x =  [0 1 2 3 4 5 6 7 8 9]      y =  [2 4 6]      z =  [2 3 4 5 6 7 8 9]

 【示例】根据索引直接获取

import numpy
x = numpy.arange(1,13)
a = x.reshape(4,3)
print("数组元素：\n", a)
print("获取第二行：", a[1])
print("获取第三行第2列：", a[2][1])

【示例】二维数组切片的使用

import numpy
x = numpy.arange(1,13)
a = x.reshape(4,3)
print("数组元素：\n", a)
print("所有行的第2列：", a[:,1])
print("奇数行第1列：", a[::2,0])

【示例】使用坐标获取数组[x,y] 

import numpy
x = numpy.arange(1,13)
a = x.reshape(4,3)
print("数组元素：\n", a)
print("获取第3行第2列：", a[2,1])
print("同时获取第3行第2列，第4行第1列：（2种方法）")
print(numpy.array([a[2,1], a[3,0]]))
print(a[(2,3), (1,0)])

 【示例】索引为负数来获取

import numpy
x = numpy.arange(1,13)
a = x.reshape(4,3)

print("数组元素：\n", a)

print("获取最后一行：", a[-1])

print("行倒序：\n", a[::-1])

print("行列都倒序：\n", a[::-1,::-1])

所有切片取出来的数组，即使你把它赋值给了新的变量，它仍有全都是原来数组的视图。

【示例】切片数组的复制

import numpy
x = numpy.arange(1,13)
a = x.reshape(3,4)
print(a)
sub_array = a[:2:2]
print(sub_array)
sub_array[0][0] = 1000
print(a)
print(sub_array)
print("########### copy ##########")
sub_array = numpy.copy(a[:2,:2])
print(sub_array)
sub_array[0][0] = 2000
print(a)
print(sub_array)

3. 改变数组的维度

  处理数组的一项重要工作就是改变数组的维度，包含提高数组的维度 和 降低数组的维度，还包括数组的转置。

Numpy 提供的大量 API 可以很轻松地完成这些数组的操作。例如：

• 通过 reshape 方法可以将一维数组变成二维、三维或者多维数组。
• 通过 ravel 方法或 flatten 方法可以将多维数组变成一维数组。
• 改变数组的维度还可以直接设置Numpy 数组的shape属性（元组类型），通过 resize 方法也可以改变数组的维度。

import numpy
# 创建一维数组
a = numpy.arange(24)
print(a)
print("数组a的维度：", a.shape)
print("-"*30)

# 使用reshape将一维数组变成三维数组
b = a.reshape(2,3,4)
print(b)
print("数组b的维度：", b.shape)
print("-"*30)

# 将a变成二维数组
c = a.reshape(3,8)
print(c)
print("数组c的维度：", c.shape)
print("-"*30)

# 使用ravel函数将三维数组的b变成一维数组
a1 = b.ravel()
print(a1)
print("-"*30)

# 使用flatten函数将二维数组c变成一维数组
a2 = c.flatten()
print(a2)
print("-"*30)

4. 数组的拼接

 通过 hstack 函数可以将两个或多个数组水平组合起来形成一个数组。

 通过 vstack 函数可以将两个或多个数组垂直组合起来形成一个数组。

现在有两个 2*3 的数组 A 和 B。使用 hstack() 函数将A和B两个数组水平组合的：C = hstack(A, B)       使用 vstack() 函数将两个数组垂直组合代码：D = vstack(A, B)

多个数组进行水平组合的效果类似。但数组水平组合必须要满足一个条件：就是所有参与水平组合的数组的行数必须相同，否则进行水平组合会抛出异常。

import numpy

a = numpy.array([[0,1,2],[3,4,5]])
print(a)

b = numpy.array([[6,7,8],[9,10,11]])
print(b)

c = numpy.hstack([a,b])
print(c)

d = numpy.vstack([a,b])
print(c)

数组的拼接有3个函数：

• concatenate    连接沿现有轴的数组序列
• hstack       水平堆叠序列中的数组（列方向）
• vstack       竖直堆叠序列中的数组（行方向）

numpy.concatenate 函数用于沿指定轴连接相同形状的两个或多个数组，格式如下：

numpy.concatenate((a1, a2, ...), axis)

参数说明：

• a1, a2, ...：   相同类型的数组
• axis：    沿着它连接数组的轴，默认为 0

import numpy

a = numpy.array([[1,2,3],[4,5,6]])
print(a)

b = numpy.array([["a","b","c"],["d","e","f"]])
print(b)

# 连接沿现有轴的数组序列
print(numpy.concatenate([a,b]))     # axis参数默认为0

print("垂直方向拼接   相当于vstack ")
print(numpy.concatenate([a,b], axis=0))

print("水平方向拼接   相当于hstack ")
print(numpy.concatenate([a,b], axis=1))

注意：如果拼接的行和列数目不同，则会报错

【示例】三维数组的拼接

import numpy
a = numpy.arange(1,37).reshape(3,4,3)
print(a)
b = numpy.arange(101,137).reshape(3,4,3)
print(b)
print("axis=0 "*10)
print(numpy.concatenate((a,b), axis=0))
print("axis=1 "*10)
print(numpy.concatenate((a,b), axis=1))
print("axis=2 "*10)
print(numpy.concatenate((a,b), axis=2))

• axis=0  可以使用 vstack 替换
• axis=1    可以使用 hstack 替换
• axis=2    可以使用 dstack 替换

5. 数组的分隔

5.1 split 分隔

  numpy.split 函数沿特定的轴将数组分割为子数组，格式如下：

numpy.split(ary, indices_or_sections, axis)

参数说明：

• ary：  被分割的数组
• indices_or_sections：  如果是一个整数，就用该数平均切分，如果是一个数组，为沿轴切分的位置。
• axis：  沿着哪个维度进行切向，默认为 0，横向切分。为 1 时，纵向切分。

【示例】split 分隔一维数组

import numpy
x = numpy.arange(1,9)
print(x)
a = numpy.split(x,4)        # 平均分割成4份
print("平均分割成4份:\n", a)
print(a[0], "\t", a[1],"\t", a[2],"\t", a[3])
# 传递数组进行分隔
b = numpy.split(x,[3,5])    # 从索引为3的位置，索引为5的位置进行分隔
print("从索引为3的位置，索引为5的位置进行分隔:\n", b)

【示例】split 分隔二维数组

import numpy

a = numpy.array([[1,2,3],[4,5,6],[11,12,13],[14,15,16]])

print("axis=0 垂直方向 平均分隔")
r = numpy.split(a, 2, axis=0)
print(r[0])
print(r[1])

print("axis=1 水平方向 按位置分隔")
r = numpy.split(a,[2],axis=1)
print(r)

5.2 水平分隔

分隔数组是组合数组的逆过程，与组合数组一样，分隔数组也分为水平分隔数组和垂直分隔数组。水平分隔数组与水平组合数组对应。

水平组合数组是将两个或多个数组水平进行收尾相接，而水平分隔数组是将已经水平组合到一起的数组再分开。

使用 hsplit 函数可以水平分隔数组，该函数有2个参数，第 1 个参数表示待分隔的数组，第 2 个参数表示要将数组水平分隔成几个小数组。

import numpy
x = numpy.array([numpy.arange(1,7), numpy.arange(7,13)])

h1 = numpy.hsplit(x, 2)    # 水平分隔，平均分成2份
h2 = numpy.hsplit(x, 3)    # 水平分隔，平均分成3份

hsplit(X,2) 将数组 X 分隔成了列数相同的2个数组。hsplit(X,3) 将数组 X 分隔成了 3 个列数都为 2 的数组，但是 hsplit(X,4)分隔数组X就会抛出异常，因为数组 X 没有办法被分隔成列数相同的 4 个数组的。

所以使用hsplit函数分隔数组的一个规则就是：第 2 个参数值必须可以整除待分隔数组的列数。

【例子】hsplit 水平分割

import numpy
gg = numpy.arange(16).reshape(4,4)
print("gg：\n", gg)

a,b = numpy.hsplit(gg, 2)    # 水平分隔，平均分成2份
print("a：\n", a)
print("b：\n", b)

5.3 垂直分隔数组

垂直分隔数组是垂直组合数组的逆过程。垂直组合数组是将两个或多个数组垂直进行首尾相接，而垂直分隔数组是将已经垂直组合到一起的数组再分开。
使用 vsplit 函数可以垂直分隔数组，该函数有2个参数，第 1 个参数表示待分隔的数组，第 2 个参数表示将数组垂直分隔成几个小数组。

import numpy
gg = numpy.arange(1,13).reshape(4,3)
print("gg：\n", gg)

a = numpy.vsplit(gg, 2)    # 平均分隔成2份
print(a)
b = numpy.vsplit(gg, 4)    # 平均分隔成4份
print(b)

 第2个参数是整数：平均分隔成几个数组；第2个参数是数组，从索引为多少的位置分隔成多少份。

import numpy
gg = numpy.arange(16).reshape(4,4)
print("gg:\n", gg)
a, b = numpy.vsplit(gg, [3])    # 从索引为3的位置分隔成2份
print("a:\n", a)
print("b:\n", b)

print("*******分隔成三部分********")
x, y, z = numpy.vsplit(gg, [1,3])   # 从索引为1的位置、索引为3的位置分隔成3份
print("x:\n", x)
print("y:\n", y)
print("z:\n", z)

 【示例】transpose 进行转换

import numpy

# 二维转置
a = numpy.arange(1,13).reshape(2,6)
print('原数组a：\n', a)
print('转置后的数组：\n', a.transpose())

# 多维数组转置
aaa = numpy.arange(1,37).reshape(1,3,3,4)
print('原数组aaa：\n', aaa)
# 将1,3,3,4 转换为3,3,4,1
bbb = numpy.transpose(aaa,[1,2,3,0])
print('转置后的数组维度：', bbb.shape)
print('转置后的数组：\n', bbb)