一.什么是numpy

一个在Python中做科学计算的基础库，重在数值计算，也是大部分PYTHON科学计算库的基础库，多用于在大型、多维数组上执行数值运算.

二.NumPy Ndarray 对象

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

ndarray 对象是用于存放同类型元素的多维数组。

ndarray 中的每个元素在内存中都有相同存储大小的区域。

ndarray 内部由以下内容组成：

• 一个指向数据（内存或内存映射文件中的一块数据）的指针。

• 数据类型或 dtype，描述在数组中的固定大小值的格子。

• 一个表示数组形状（shape）的元组，表示各维度大小的元组。

• 一个跨度元组（stride），其中的整数指的是为了前进到当前维度下一个元素需要"跨过"的字节数。

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

相关参数

一维数组

import numpy as np 
a = np.array([1,2,3])  
a

[1 2 3]

二维数组

import numpy as np 
a = np.array([[1,  2],  [3,  4]])  
a


[[1  2] 
 [3  4]]

多维数组

import numpy as np 
arrnp.array([[1,2,3,4,5],[4,5,6,7,8],[7,8,9,10,11]])
print('n',arr)

[[ 1 2 3 4 5]

[ 4 5 6 7 8]

[ 7 8 9 10 11]]

zeros函数

import numpy as np 
np.zeros((3, 4))

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

#元素值都是0的数组

ones函数

import numpy as np 
np.ones((3, 4))

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

#元素值全是1的数组

empty函数

import numpy as np 
np.empty((5, 2))
array([[6.23042070e-307, 1.69118108e-306],
       [1.86920600e-306, 8.01097889e-307],
       [1.78020169e-306, 7.56601165e-307],
       [1.02359984e-306, 1.33510679e-306],
       [2.22522597e-306, 1.78019761e-306]])

#元素值全是随机数的数组

arange函数

import numpy as np 
np.arange(1, 20, 5)
array([ 1,  6, 11, 16])

#等差数组

NumPy 数据类型

numpy 支持的数据类型比 Python 内置的类型要多很多，基本上可以和 C 语言的数据类型对应上，其中部分类型对应为 Python 内置的类型。下表列举了常用 NumPy 基本类型。

numpy 的数值类型实际上是 dtype 对象的实例，并对应唯一的字符，包括 np.bool_，np.int32，np.float32，等等。

数据类型对象 (dtype)

数据类型对象（numpy.dtype 类的实例）用来描述与数组对应的内存区域是如何使用，它描述了数据的以下几个方面：：

• 数据的类型（整数，浮点数或者 Python 对象）
• 数据的大小（例如， 整数使用多少个字节存储）
• 数据的字节顺序（小端法或大端法）
• 在结构化类型的情况下，字段的名称、每个字段的数据类型和每个字段所取的内存块的部分
• 如果数据类型是子数组，那么它的形状和数据类型是什么。

字节顺序是通过对数据类型预先设定 < 或 > 来决定的。 < 意味着小端法(最小值存储在最小的地址，即低位组放在最前面)。> 意味着大端法(最重要的字节存储在最小的地址，即高位组放在最前面)。

dtype 对象是使用以下语法构造的：

numpy.dtype(object, align, copy)

object - 要转换为的数据类型对象align - 如果为 true，填充字段使其类似 C 的结构体。

copy - 复制 dtype 对象 ，如果为 false，则是对内置数据类型对象的引用

import numpy as np # 使用标量类型 a = np.dtype(np.int32) print(a)

import numpy as np
a = np.dtype(np.int32)
a

int32

每个内建类型都有一个唯一定义它的字符代码，如下：

astype方法

ndarray对象的数据类型进行转换

data = np.array([[1, 2, 3], [4, 5, 6]]) 
data.dtype
# 数据类型转换为float64
float_data = data.astype(np.float64)
float_data.dtype

数组运算

矢量化运算

形状相等的数组之间的任何算术运算都会应用到元素级，即只用于位置相同的元素之间，所得的运算结果组成一个新的数组。

import numpy as np 
 
a = np.arange(9, dtype = np.float_).reshape(3,3)  
print ('第一个数组：')
print (a)
print ('\n')
print ('第二个数组：')
b = np.array([10,10,10])  
print (b)
print ('\n')
print ('两个数组相加：')
print (np.add(a,b))
print ('\n')
print ('两个数组相减：')
print (np.subtract(a,b))
print ('\n')
print ('两个数组相乘：')
print (np.multiply(a,b))
print ('\n')
print ('两个数组相除：')
print (np.divide(a,b))

import numpy as np 
 
a = np.arange(9, dtype = np.float_).reshape(3,3)  
print ('第一个数组：')
print (a)
print ('\n')
print ('第二个数组：')
b = np.array([10,10,10])  
print (b)
print ('\n')
print ('两个数组相加：')
print (np.add(a,b))
print ('\n')
print ('两个数组相减：')
print (np.subtract(a,b))
print ('\n')
print ('两个数组相乘：')
print (np.multiply(a,b))
print ('\n')
print ('两个数组相除：')
print (np.divide(a,b))

广播(Broadcast)

 numpy 对不同形状(shape)的数组进行数值计算的方式， 对数组的算术运算通常在相应的元素上进行。

如果两个数组 a 和 b 形状相同，即满足 a.shape == b.shape，那么 a*b 的结果就是 a 与 b 数组对应位相乘。这要求维数相同，且各维度的长度相同。

import numpy as np 
 
a = np.array([1,2,3,4]) 
b = np.array([10,20,30,40]) 
c = a * b 
print (c)
[ 10  40  90 160]

ndarray的索引和切片

ndarray对象的内容可以通过索引或切片来访问和修改，与 Python 中 list 的切片操作一样。

ndarray 数组可以基于 0 - n 的下标进行索引，切片对象可以通过内置的 slice 函数，并设置 start, stop 及 step 参数进行，从原数组中切割出一个新数组。

import numpy as np
 
a = np.arange(10)
s = slice(2,7,2)   # 从索引 2 开始到索引 7 停止，间隔为2
print (a[s])
[2  4  6]

import numpy as np
 
a = np.arange(10)  
b = a[2:7:2]   # 从索引 2 开始到索引 7 停止，间隔为 2
print(b)

[2  4  6]

多维数组

import numpy as np
 
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print(a)
# 从某个索引处开始切割
print('从数组索引 a[1:] 处开始切割')
print(a[1:])

[[1 2 3]
 [3 4 5]
 [4 5 6]]
从数组索引 a[1:] 处开始切割
[[3 4 5]
 [4 5 6]]

mport numpy as np
 
a = np.array([[1,2,3],[3,4,5],[4,5,6]])  
print (a[...,1])   # 第2列元素
print (a[1,...])   # 第2行元素
print (a[...,1:])  # 第2列及剩下的所有元素


[2 4 5]
[3 4 5]
[[2 3]
 [4 5]
 [5 6]]

NumPy 高级索引

import numpy as np 
 
x = np.array([[1,  2],  [3,  4],  [5,  6]]) 
y = x[[0,1,2],  [0,1,0]]  
y

[1  4  5]

数组的转置和轴对称

数组的转置指的是将数组中的每个元素按照一定的规则进行位置变换。

NumPy提供了两种实现方式：

T属性

transpose()方法

简单的转置可以使用T属性，它其实就是进行轴对换而已。

 当使用transpose()方法对数组的shape进行调换时，需要以元组的形式传入shape的编号，比如(1,0,2)。

 如果我们不输入任何参数，直接调用transpose()方法，则其执行的效果就是将数组进行转置，作用等价于transpose(2,1,0)。

有时可能只需要转换其中的两个轴，这时可以使用swapaxes()方法实现，该方法需要接受一对轴编号，比如(1,0)。

NumPy通用函数

通用函数（ufunc）是一种针对ndarray中的数据执行元素级运算的函数，函数返回的是一个新的数组。

我们将ufunc中接收一个数组参数的函数称为一元通用函数，接受两个数组参数的则称为二元通用函数。

常见的一元通用函数如下表：

常见的二元通用函数如下表：

 利用NumPy数组进行数据处理

NumPy的where()函数是三元表达式x if condition else y的矢量化版本

arr_x = np.array([1, 5, 7])
arr_y = np.array([2, 6, 8])
arr_con = np.array([True, False, True])
result = np.where(arr_con, arr_x, arr_y)

array([1, 6, 7])

 通过NumPy库中的相关方法，我们可以很方便地运用Python进行数组的统计汇总。

 如果希望对NumPy数组中的元素进行排序，可以通过sort()方法实现。

arr = np.array([[6, 2, 7], 
                         [3, 6, 2], 
                         [4, 3, 2]])
arr.sort()

array([[2, 6, 7],
             [2, 3, 6],
              [2, 3, 4]])

如果希望对任何一个轴上的元素进行排序，则需要将轴的编号作为sort()方法的参数传入。

arr = np.array([[6, 2, 7], 
                         [3, 6, 2], 
                         [4, 3, 2]])
# 沿着编号为0的轴对元素排序
arr.sort(0)

array([[3, 2, 2],
             [4, 3, 2],
              [6, 6, 7]])

all()函数用于判断整个数组中的元素的值是否全部满足条件，如果满足条件返回True，否则返回False。

arr = np.array([[1, -2, -7], 
                         [-3, 6, 2], 
                         [-4, 3, 2]])
# arr的所有元素是否都大于0
np.all(arr > 0)

False

any()函数用于判断整个数组中的元素至少有一个满足条件就返回True，否则就返回False。

arr = np.array([[1, -2, -7], 
                         [-3, 6, 2], 
                         [-4, 3, 2]])
# arr的所有元素是否有一个大于0
np.any(arr > 0)

True

针对一维数组，NumPy提供了unique()函数来找出数组中的唯一值，并返回排序后的结果。

arr = np.array([12, 11, 34, 23, 12, 8, 11])
np.unique(arr)

array([ 8, 11, 12, 23, 34])

in1d()函数用于判断数组中的元素是否在另一个数组中存在，该函数返回的是一个布尔型的数组。

arr = np.array([12, 11, 34, 23, 12, 8, 11])
np.in1d(arr, [11, 12])

array([ True,  True, False, False,      
      True, False,  True])

NumPy提供的有关集合的函数还有很多，常见的函数如下表所示。

 线性代数模块

NumPy 提供了线性代数函数库 linalg，该库包含了线性代数所需的所有功能，可以看看下面的说明：

numpy.dot()

numpy.dot() 对于两个一维的数组，计算的是这两个数组对应下标元素的乘积和(数学上称之为内积)；对于二维数组，计算的是两个数组的矩阵乘积；对于多维数组，它的通用计算公式如下，即结果数组中的每个元素都是：数组a的最后一维上的所有元素与数组b的倒数第二位上的所有元素的乘积和： dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])。

参数说明：

• a : ndarray 数组
• b : ndarray 数组
• out : ndarray, 可选，用来保存dot()的计算结果

 随机数模块

与Python的random模块相比，NumPy的random模块功能更多，它增加了一些可以高效生成多种概率分布的样本值的函数。

除此之外，random模块中还包括了可以生成服从多种概率分布随机数的其它函数。 

seed( )函数可以保证生成的随机数具有可预测性，也就是说产生的随机数相同。

上述函数中只有一个seed参数，用于指定随机数生成时所用算法开始的整数值。

当调用seed()函数时，如果传递给seed参数的值相同，则每次生成的随机数都是一样的。

当传递的参数值不同或者不传递参数时，则seed()函数的作用跟rand()函数相同，即多次生成随机数且每次生成的随机数都不同。