参考连接

https://www.runoob.com/numpy/numpy-tutorial.html

Numpy简介与应用

numpy是一个运行速度非常快的数学库，通常与Scipy（scientific python）和matplotlib（绘图库）一起使用。
这种组合广泛用于替代 MatLab，是一个强大的科学计算环境，有助于我们通过 Python 学习数据科学或者机器学习。 —-有意思
SciPy 是一个开源的 Python 算法库和数学工具包。
SciPy 包含的模块有最优化、线性代数、积分、插值、特殊函数、快速傅里叶变换、信号处理和图像处理、常微分方程求解和其他科学与工程中常用的计算。
Matplotlib 是 Python 编程语言及其数值数学扩展包 NumPy 的可视化操作界面。它为利用通用的图形用户界面工具包，如 Tkinter, wxPython, Qt 或 GTK+ 向应用程序嵌入式绘图提供了应用程序接口（API）。

Numpy的安装

1.使用已有的发行版本

有些Python的发行版已经包含了所有的关键包

2.pip安装

pip3 install --user numpy scipy matplotlib

—user 表示只安装在当前用户下
如果下载速度慢，可以切换源：

pip3 install numpy scipy matplotlib -i https://pypi.tuna.tsinghua.edu.cn/simple

3.Linux下的安装

ubuntu和 debian

sudo apt-get install python-numpy python-scipy python-matplotlib ipython ipython-notebook python-pandas python-sympy python-nose

Numpy Ndarray对象

ndarray:多为数组对象
创建一个 ndarray 只需调用 NumPy 的 array 函数即可：

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

Numpy的数据类型

数据类型对象（dtype）

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

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

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

numpy.dtype(object, align, copy)

• object - 要转换为的数据类型对象
• align - 如果为 true，填充字段使其类似 C 的结构体。
• copy - 复制 dtype 对象 ，如果为 false，则是对内置数据类型对象的引用

  Numpy数组属性

  | 属性 | 说明 | | —- | —- | | ndarray.ndim | 秩，即轴的数量或维度的数量 | | ndarray.shape | 数组的维度，对于矩阵，n 行 m 列 | | ndarray.size | 数组元素的总个数，相当于 .shape 中 n*m 的值 | | ndarray.dtype | ndarray 对象的元素类型 | | ndarray.itemsize | ndarray 对象中每个元素的大小，以字节为单位 | | ndarray.flags | ndarray 对象的内存信息 | | ndarray.real | ndarray元素的实部 | | ndarray.imag | ndarray 元素的虚部 | | ndarray.data | 包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性。 |

创建数组

1. numpy.ndarray

2. numpy.empty

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

3.numpy.zeros

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

4.numpy.ones

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

从已有数组创建数组

1.numpy.asarray

numpy.asarray(a, dtype = None, order = None)

2.numpy.frombuffer

numpy.frombuffer 用于实现动态数组。
numpy.frombuffer 接受 buffer 输入参数，以流的形式读入转化成 ndarray 对象。

numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)

3.numpy.fromiter

numpy.fromiter 方法从可迭代对象中建立 ndarray 对象，返回一维数组。

numpy.fromiter(iterable, dtype, count=-1)

NumPy 从数值范围创建数组

1.numpy.arange

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

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

#

2.numpy.linspace

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

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

3.numpy.logspace

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

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

切片和索引

基本

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

输出结果为：
[2 4 6]
冒号 : 的解释：如果只放置一个参数，如 [2]，将返回与该索引相对应的单个元素。如果为 [2:]，表示从该索引开始以后的所有项都将被提取。如果使用了两个参数，如 [2:7]，那么则提取两个索引(不包括停止索引)之间的项。

a[2:] #a[2]以后的所有元素
a[2:5] #a[2]（包含） 到 a[5]（不包含）之间的元素

多为数组提取

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]]

切片还可以包括省略号 …，来使选择元组的长度与数组的维度相同。 如果在行位置使用省略号，它将返回包含行中元素的 ndarray。

import 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]]

高级索引

整数数组索引

以下实例获取数组中(0,0)，(1,1)和(2,0)位置处的元素。
实例

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

输出
[[1 2]
[3 4]
[5 6]]

[1 4 5]

以下实例获取了 4X3 数组中的四个角的元素。 行索引是 [0,0] 和 [3,3]，而列索引是 [0,2] 和 [0,2]。

import numpy as np 
x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])  
print ('我们的数组是：' )
print (x)
print ('\n')
rows = np.array([[0,0],[3,3]]) 
cols = np.array([[0,2],[0,2]]) 
y = x[rows,cols]  
print  ('这个数组的四个角元素是：')
print (y)

我们的数组是：
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
这个数组的四个角元素是：
[[ 0 2]
[ 9 11]]

可以借助切片 : 或 … 与索引数组组合

import numpy as np
a = np.array([[1,2,3], [4,5,6],[7,8,9]])
b = a[1:3, 1:3]
c = a[1:3,[1,2]]
d = a[...,1:]
print(b)
print(c)
print(d)

输出结果为：
[[5 6]
[8 9]]
[[5 6]
[8 9]]
[[2 3]
[5 6]
[8 9]]

布尔索引

以下实例获取大于 5 的元素：

import numpy as np 
x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])  
print ('我们的数组是：')
print (x)
print ('\n')
# 现在我们会打印出大于 5 的元素  
print  ('大于 5 的元素是：')
print (x[x >  5])

我们的数组是：
[[ 0 1 2] [ 3 4 5] [ 6 7 8] [ 9 10 11]]
大于 5 的元素是：
[ 6 7 8 9 10 11]

以下实例使用了 ~（取补运算符）来过滤 NaN

import numpy as np 
a = np.array([np.nan,  1,2,np.nan,3,4,5])  
print (a[~np.isnan(a)])

输出结果为：
[ 1. 2. 3. 4. 5.]

以下实例演示如何从数组中过滤掉非复数元素。

import numpy as np 

a = np.array([1,  2+6j,  5,  3.5+5j])  
print (a[np.iscomplex(a)])

[2.0+6.j 3.5+5.j]

花式索引

花式索引指的是利用整数数组进行索引。
花式索引根据索引数组的值作为目标数组的某个轴的下标来取值。对于使用一维整型数组作为索引，如果目标是一维数组，那么索引的结果就是对应下标的行，如果目标是二维数组，那么就是对应位置的元素。
花式索引跟切片不一样，它总是将数据复制到新数组中。

1、传入顺序索引数组

import numpy as np 

x=np.arange(32).reshape((8,4))
print (x[[4,2,1,7]])

[[16 17 18 19] [ 8 9 10 11] [ 4 5 6 7] [28 29 30 31]]

2、传入倒序索引数组

import numpy as np 

x=np.arange(32).reshape((8,4))
print (x[[-4,-2,-1,-7]])

[[16 17 18 19] [24 25 26 27] [28 29 30 31] [ 4 5 6 7]]

3、传入多个索引数组（要使用np.ix_）

import numpy as np 

x=np.arange(32).reshape((8,4))
print (x[np.ix_([1,5,7,2],[0,3,1,2])])

[[ 4 7 5 6] [20 23 21 22] [28 31 29 30] [ 8 11 9 10]]

Numpy的广播

广播的规则:

• 让所有输入数组都向其中形状最长的数组看齐，形状中不足的部分都通过在前面加 1 补齐。
• 输出数组的形状是输入数组形状的各个维度上的最大值。
• 如果输入数组的某个维度和输出数组的对应维度的长度相同或者其长度为 1 时，这个数组能够用来计算，否则出错。
• 当输入数组的某个维度的长度为 1 时，沿着此维度运算时都用此维度上的第一组值。

简单理解：对两个数组，分别比较他们的每一个维度（若其中一个数组没有当前维度则忽略），满足：

• 数组拥有相同形状。
• 当前维度的值相等。
• 当前维度的值有一个是 1。

  Numpy迭代数组

  NumPy 迭代器对象 numpy.nditer 提供了一种灵活访问一个或者多个数组元素的方式。
  迭代器最基本的任务的可以完成对数组元素的访问。

使用nditer对一个2*3的数组进行迭代

import numpy as np

a = np.arange(6).reshape(2,3)
print(a)

print('\n')

for x in np.nditer(a):
    print(x,end = ',')
print('\n')

[[0 1 2]
[3 4 5]]

0,1,2,3,4,5,

控制遍历顺序

• for x in np.nditer(a, order=’F’):Fortran order，即是列序优先；
• for x in np.nditer(a.T, order=’C’):C order，即是行序优先； ```python import numpy as np

a = np.arange(0,60,5) a = a.reshape(3,4)
print (‘原始数组是：’) print (a) print (‘\n’) print (‘原始数组的转置是：’) b = a.T print (b) print (‘\n’) print (‘以 C 风格顺序排序：’) c = b.copy(order=’C’)
print (c) for x in np.nditer(c):
print (x, end=”, “ ) print (‘\n’) print (‘以 F 风格顺序排序：’) c = b.copy(order=’F’)
print (c) for x in np.nditer(c):
print (x, end=”, “ )

原始数组是：<br />[[ 0  5 10 15]<br /> [20 25 30 35]<br /> [40 45 50 55]]


原始数组的转置是：<br />[[ 0 20 40]<br /> [ 5 25 45]<br /> [10 30 50]<br /> [15 35 55]]


以 C 风格顺序排序：<br />[[ 0 20 40]<br /> [ 5 25 45]<br /> [10 30 50]<br /> [15 35 55]]<br />0, 20, 40, 5, 25, 45, 10, 30, 50, 15, 35, 55,

以 F 风格顺序排序：<br />[[ 0 20 40]<br /> [ 5 25 45]<br /> [10 30 50]<br /> [15 35 55]]<br />0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55,

可以通过显式设置，来强制 nditer 对象使用某种顺序：
```python
import numpy as np 

a = np.arange(0,60,5) 
a = a.reshape(3,4)  
print ('原始数组是：')
print (a)
print ('\n')
print ('以 C 风格顺序排序：')
for x in np.nditer(a, order =  'C'):  
    print (x, end=", " )
print ('\n')
print ('以 F 风格顺序排序：')
for x in np.nditer(a, order =  'F'):  
    print (x, end=", " )

原始数组是：
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]

以 C 风格顺序排序：
0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55,

以 F 风格顺序排序：
0, 20, 40, 5, 25, 45, 10, 30, 50, 15, 35, 55,

修改数组元素的值

nditer 对象有另一个可选参数 op_flags。 默认情况下，nditer 将视待迭代遍历的数组为只读对象（read-only），为了在遍历数组的同时，实现对数组元素值得修改，必须指定 read-write 或者 read-only 的模式。

import numpy as np

a = np.arange(0,60,5) 
a = a.reshape(3,4)  
print ('原始数组是：')
print (a)
print ('\n')
for x in np.nditer(a, op_flags=['readwrite']): 
    x[...]=2*x 
print ('修改后的数组是：')
print (a)

原始数组是：
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]

修改后的数组是：
[[ 0 10 20 30]
[ 40 50 60 70]
[ 80 90 100 110]]

Numpy数组操作

修改数组形状

翻转数组

翻转数组翻转

修改数组维度

#

连接数组

分割数组

数组元素添加与删除

Numpy 位运算

Numpy

Numpy字符串函数

Numpy数学函数

三角函数

sin()、cos()、tan()

舍入函数

numpy.around() 函数返回指定数字的四舍五入值。
numpy.around(a,decimals)
参数说明：

• a: 数组
• decimals: 舍入的小数位数。 默认值为0。 如果为负，整数将四舍五入到小数点左侧的位置

numpy.floor()
numpy.floor() 返回小于或者等于指定表达式的最大整数，即向下取整。

numpy.ceil()
numpy.ceil() 返回大于或者等于指定表达式的最小整数，即向上取整。

Numpy 算术函数

简单的加减乘除：add subtract multiply divide

其他：
numpy.reciprocal() 函数返回参数逐元素的倒数.

numpy.power() 函数将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂。

numpy.mod() 计算输入数组中相应元素的相除后的余数。 函数 numpy.remainder() 也产生相同的结果。

Numpy统计函数

numpy.amin()和numpy.amax()

numpy.amin() 用于计算数组中的元素沿指定轴的最小值。
numpy.amax() 用于计算数组中的元素沿指定轴的最大值

numpy.percentile()

百分位数是统计中使用的度量，表示小于这个值的观察值的百分比。 函数numpy.percentile()接受以下参数。
numpy.percentile(a, q, axis)
参数说明：

• a: 输入数组
• q: 要计算的百分位数，在 0 ~ 100 之间
• axis: 沿着它计算百分位数的轴

numpy.median()

numpy.median() 函数用于计算数组 a 中元素的中位数（中值）

numpy.mean()

numpy.mean() 函数返回数组中元素的算术平均值。 如果提供了轴，则沿其计算。
算术平均值是沿轴的元素的总和除以元素的数量。

numpy.average()

numpy.average() 函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。
该函数可以接受一个轴参数。 如果没有指定轴，则数组会被展开。
加权平均值即将各数值乘以相应的权数，然后加总求和得到总体值，再除以总的单位数。
考虑数组[1,2,3,4]和相应的权重[4,3,2,1]，通过将相应元素的乘积相加，并将和除以权重的和，来计算加权平均值。

标准差

标准差是一组数据平均值分散程度的一种度量。
标准差是方差的算术平方根。
标准差公式如下：
std = sqrt(mean((x - x.mean())**2))

方差

统计中的方差（样本方差）是每个样本值与全体样本值的平均数之差的平方值的平均数，即 mean((x - x.mean())** 2)。
换句话说，标准差是方差的平方根。

import numpy as np

print (np.var([1,2,3,4]))

Numpy排序、条件筛选函数

排序

numpy.sort()

numpy.sort() 函数返回输入数组的排序副本。函数格式如下：
numpy.sort(a, axis, kind, order)
参数说明：

• a: 要排序的数组
• axis: 沿着它排序数组的轴，如果没有数组会被展开，沿着最后的轴排序， axis=0 按列排序，axis=1 按行排序
• kind: 默认为’quicksort’（快速排序）
• order: 如果数组包含字段，则是要排序的字段

  numpy.argsort()

  numpy.argsort() 函数返回的是数组值从小到大的索引值。

numpy.lexsort()

numpy.lexsort() 用于对多个序列进行排序。把它想象成对电子表格进行排序，每一列代表一个序列，排序时优先照顾靠后的列

msort、sort_complex、partition、argpartition

筛选函数

numpy.argmax() 和 numpy.argmin()

numpy.argmax() 和 numpy.argmin()函数分别沿给定轴返回最大和最小元素的索引。

numpy.nonzero()

numpy.nonzero() 函数返回输入数组中非零元素的索引。

numpy.where()

numpy.where() 函数返回输入数组中满足给定条件的元素的索引

numpy.extract()

numpy.extract() 函数根据某个条件从数组中抽取元素，返回满条件的元素。

Numpy字节交换

大小端模式

• 大端模式：指数据的高字节保存在内存的低地址中，而数据的低字节保存在内存的高地址中，这样的存储模式有点儿类似于把数据当作字符串顺序处理：地址由小向大增加，而数据从高位往低位放；这和我们的阅读习惯一致。
• 小端模式：指数据的高字节保存在内存的高地址中，而数据的低字节保存在内存的低地址中，这种存储模式将地址的高低和数据位权有效地结合起来，高地址部分权值高，低地址部分权值低。
• 

  numpy.ndarray.byteswap()

  numpy.ndarray.byteswap() 函数将 ndarray 中每个元素中的字节进行大小端转换。 ```python import numpy as np

a = np.array([1, 256, 8755], dtype = np.int16)
print (‘我们的数组是：’) print (a) print (‘以十六进制表示内存中的数据：’) print (map(hex,a))

byteswap() 函数通过传入 true 来原地交换

print (‘调用 byteswap() 函数：’) print (a.byteswap(True)) print (‘十六进制形式：’) print (map(hex,a))

我们可以看到字节已经交换了

我们的数组是：<br /> [   1  256 8755] <br />以十六进制表示内存中的数据：<br /> <map object at 0x104acb400> <br />调用 byteswap() 函数： <br />[  256     1 13090] <br />十六进制形式：<br /> <map object at 0x104acb3c8>

```python
import numpy as np

A = np.array([1, 256, 8755], dtype=np.int16)
print(A)
print(list(map(hex, A)))
print(A.byteswap(inplace=True))
print(list(map(hex, A)))

[ 1 256 8755]
[‘0x1’, ‘0x100’, ‘0x2233’]
[ 256 1 13090]
[‘0x100’, ‘0x1’, ‘0x3322’]

Numpy副本和视图

副本是一个数据的完整的拷贝，如果我们对副本进行修改，它不会影响到原始数据，物理内存不在同一位置。
视图是数据的一个别称或引用，通过该别称或引用亦便可访问、操作原有数据，但原有数据不会产生拷贝。如果我们对视图进行修改，它会影响到原始数据，物理内存在同一位置。
视图一般发生在：

• 1、numpy 的切片操作返回原数据的视图。
• 2、调用 ndarray 的 view() 函数产生一个视图。

副本一般发生在：

• Python 序列的切片操作，调用deepCopy()函数。
• 调用 ndarray 的 copy() 函数产生一个副本。

  Numpy的矩阵库

  NumPy 中包含了一个矩阵库 numpy.matlib，该模块中的函数返回的是一个矩阵，而不是 ndarray 对象。
  一个 的矩阵是一个由行（row）列（column）元素排列成的矩形阵列。

转置矩阵

NumPy 中除了可以使用 numpy.transpose 函数来对换数组的维度，还可以使用 T 属性。。
例如有个 m 行 n 列的矩阵，使用 t() 函数就能转换为 n 行 m 列的矩阵。

import numpy as np

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

print ('原数组：')
print (a)
print ('\n')

print ('转置数组：')
print (a.T)

matlib.empty()

matlib.empty() 函数返回一个新的矩阵，语法格式为：
numpy.matlib.empty(shape, dtype, order)
参数说明：

• shape: 定义新矩阵形状的整数或整数元组
• Dtype: 可选，数据类型
• order: C（行序优先） 或者 F（列序优先）

  numpy.matlib.zeros()

  numpy.matlib.zeros() 函数创建一个以 0 填充的矩阵。

numpy.matlib.ones()

numpy.matlib.ones()函数创建一个以 1 填充的矩阵。

numpy.matlib.eye()

numpy.matlib.eye() 函数返回一个矩阵，对角线元素为 1，其他位置为零。

numpy.matlib.identity()

numpy.matlib.identity() 函数返回给定大小的单位矩阵。
单位矩阵是个方阵，从左上角到右下角的对角线（称为主对角线）上的元素均为 1，除此以外全都为 0。

numpy.matlib.rand()

numpy.matlib.rand() 函数创建一个给定大小的矩阵，数据是随机填充的。

Numpy线性代数

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

NumPy IO

Numpy 可以读写磁盘上的文本数据或二进制数据。
NumPy 为 ndarray 对象引入了一个简单的文件格式：npy。
npy 文件用于存储重建 ndarray 所需的数据、图形、dtype 和其他信息。
常用的 IO 函数有：

• load() 和 save() 函数是读写文件数组数据的两个主要函数，默认情况下，数组是以未压缩的原始二进制格式保存在扩展名为 .npy 的文件中。
• savez() 函数用于将多个数组写入文件，默认情况下，数组是以未压缩的原始二进制格式保存在扩展名为 .npz 的文件中。
• loadtxt() 和 savetxt() 函数处理正常的文本文件(.txt 等)

Numpy Matplotlib

Matplotlib 是 Python 的绘图库。 它可与 NumPy 一起使用，提供了一种有效的 MatLab 开源替代方案。 它也可以和图形工具包一起使用，如 PyQt 和 wxPython。

import numpy as np 
from matplotlib import pyplot as plt 

x = np.arange(1,11) 
y =  2  * x +  5 
plt.title("Matplotlib demo") 
plt.xlabel("x axis caption") 
plt.ylabel("y axis caption") 
plt.plot(x,y) 
plt.show()

import numpy as np 
import matplotlib.pyplot as plt 
# 计算正弦曲线上点的 x 和 y 坐标
x = np.arange(0,  3  * np.pi,  0.1) 
y = np.sin(x)
plt.title("sine wave form")  
# 使用 matplotlib 来绘制点
plt.plot(x, y) 
plt.show()

作业：

# -*- coding:utf-8 -*-

#numpyz作业
#1、创建一个长度为10的一维全为0的ndarray对象，然后让第5个元素等于1

import numpy as np

array1 = np.zeros(10)
print(array1)

array1[5] = 1
print(array1)

#2.创建一个元素为从10到49的ndarray对象
array2 = np.arange(10, 49, 1)
print(array2)
print('\n')

#3、将第2题的所有元素位置反转
array3 = array2[::-1]
print(array3)
print(array2)  #没变
print('\n')


#4、使用np.random.random创建一个10*10的ndarray对象，并打印出最大最小元素
array4 = np.random.random([10, 10])
print(array4)
print('\n')
print('max:')
print(array4.max())
print('\n')
print('min')
print(array4.min())
print('\n')
print('\n')


#5、创建一个10*10的ndarray对象，且矩阵边界全为1，里面全为0

array5 = np.zeros([10, 10])
print(array5)
print('\n')
array5[0,:] = 1
array5[9,:] = 1
array5[:,0] = 1
array5[:,9] = 1 

print(array5)

#