科学计算库Numpy的详细使用方法【很全面】

最新推荐文章于 2024-06-13 00:23:49 发布

不懂__

最新推荐文章于 2024-06-13 00:23:49 发布

阅读量1.5k

点赞数 12

文章标签： numpy

本文链接：https://blog.csdn.net/u014548562/article/details/137874752

版权

NumPy(Numerical Python) 是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。

NumPy 的前身 Numeric 最早是由 Jim Hugunin 与其它协作者共同开发，2005 年，Travis Oliphant 在 Numeric 中结合了另一个同性质的程序库 Numarray 的特色，并加入了其它扩展而开发了 NumPy。NumPy 为开放源代码并且由许多协作者共同维护开发。

NumPy 是一个运行速度非常快的数学库，主要用于数组计算，包含：

一个强大的N维数组对象 ndarray
广播功能函数
整合 C/C++/Fortran 代码的工具
线性代数、傅里叶变换、随机数生成等功能

一、Numpy环境安装

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple numpy

二、NumPy Ndarray 对象

NumPy中的ndarray对象是一个多维数组，它是NumPy库的核心数据结构之一。ndarray提供了许多功能强大的方法和函数，用于在数组上执行各种数学、逻辑和操作。

以下是ndarray对象的一些重要特性：

多维数组: ndarray是一个多维数组，它可以是一维、二维或更高维度的数组。这使得NumPy成为处理多维数据的强大工具，如图像、音频等。
数据类型: ndarray中的元素都是相同数据类型的。这种同质性使得NumPy数组在处理数值数据时非常高效。
形状: ndarray对象具有形状（shape），它表示数组在每个维度上的大小。例如，一个形状为(3, 4)的数组表示有3行和4列。
索引和切片: 类似于Python的列表，你可以使用索引和切片来访问和修改ndarray中的元素。这使得对数组进行各种操作变得非常方便。
广播: NumPy支持广播功能，这意味着在进行算术运算时，可以自动地对两个形状不同但满足一定条件的数组进行操作。
矢量化操作: NumPy中的许多函数和操作都是针对整个数组进行的，而不是单个元素。这种矢量化操作可以使代码更简洁和高效。
广泛的数学函数: NumPy提供了许多数学函数，如求和、平均值、标准差等，这些函数可以直接应用于数组，而无需显式循环。
高级操作: NumPy还提供了各种高级操作，如排序、索引、切片、形状变换等，使得对数组进行复杂操作变得更容易。

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

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

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

ndarray 内部由以下内容组成：

一个指向数据（内存或内存映射文件中的一块数据）的指针。
数据类型或 dtype，描述在数组中的固定大小值的格子。
一个表示数组形状（shape）的元组，表示各维度大小的元组。
一个跨度元组（stride），其中的整数指的是为了前进到当前维度下一个元素需要"跨过"的字节数。

跨度可以是负数，这样会使数组在内存中后向移动，切片中 obj[::-1] 或 obj[:,::-1] 就是如此。

创建一个 ndarray 只需调用 NumPy 的 array 函数即可：

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

参数说明：

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

一个维度 

```python
    import numpy as np 

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

print (a)#[1 2 3]
```



多于一个维度 

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



最小维度  

```python
import numpy as np 
a = np.array([1, 2, 3, 4, 5], ndmin =  2)  
print (a)#[[1 2 3 4 5]]
```



dtype 参数  

```python
import numpy as np 
a = np.array([1,  2,  3], dtype = complex)  
print (a)#[1.+0.j 2.+0.j 3.+0.j]
```

三、NumPy 数据类型

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

名称	描述
bool_	布尔型数据类型（True 或者 False）
int_	默认的整数类型（类似于 C 语言中的 long，int32 或 int64）
intc	与 C 的 int 类型一样，一般是 int32 或 int 64
intp	用于索引的整数类型（类似于 C 的 ssize_t，一般情况下仍然是 int32 或 int64）
int8	字节（-128 to 127）
int16	整数（-32768 to 32767）
int32	整数（-2147483648 to 2147483647）
int64	整数（-9223372036854775808 to 9223372036854775807）
uint8	无符号整数（0 to 255）
uint16	无符号整数（0 to 65535）
uint32	无符号整数（0 to 4294967295）
uint64	无符号整数（0 to 18446744073709551615）
float_	float64 类型的简写
float16	半精度浮点数，包括：1 个符号位，5 个指数位，10 个尾数位
float32	单精度浮点数，包括：1 个符号位，8 个指数位，23 个尾数位
float64	双精度浮点数，包括：1 个符号位，11 个指数位，52 个尾数位
complex_	complex128 类型的简写，即 128 位复数
complex64	复数，表示双 32 位浮点数（实数部分和虚数部分）
complex128	复数，表示双 64 位浮点数（实数部分和虚数部分）

四、NumPy 数组属性

NumPy 数组的维数称为秩（rank），秩就是轴的数量，即数组的维度，一维数组的秩为 1，二维数组的秩为 2，以此类推。

在 NumPy中，每一个线性的数组称为是一个轴（axis），也就是维度（dimensions）。比如说，二维数组相当于是两个一维数组，其中第一个一维数组中每个元素又是一个一维数组。所以一维数组就是 NumPy 中的轴（axis），第一个轴相当于是底层数组，第二个轴是底层数组里的数组。而轴的数量——秩，就是数组的维数。

很多时候可以声明 axis。axis=0，表示沿着第 0 轴进行操作，即对每一列进行操作；axis=1，表示沿着第1轴进行操作，即对每一行进行操作。

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

属性	说明
ndarray.ndim	秩，即轴的数量或维度的数量
ndarray.shape	数组的维度，对于矩阵，n 行 m 列
ndarray.size	数组元素的总个数，相当于 .shape 中 n*m 的值
ndarray.dtype	ndarray 对象的元素类型
ndarray.itemsize	ndarray 对象中每个元素的大小，以字节为单位
ndarray.flags	ndarray 对象的内存信息

1、ndarray.ndim

ndarray.ndim 用于返回数组的维数，等于秩。

mport numpy as np  
a = np.arange(24) 
print (a.ndim)#1             
# a只有一个维度


b = np.array([[1,2],[1,2]])
print (b.ndim)#2             
# b是二维数组

2、ndarray.shape

ndarray.shape 表示数组的维度，返回一个元组，这个元组的长度就是维度的数目，即 ndim 属性(秩)。比如，一个二维数组，其维度表示"行数"和"列数"。

ndarray.shape 也可以用于调整数组大小。

import numpy as np   
a = np.array([[1,2,3],[4,5,6]])  
print(a.shape)#(2, 3)

调整数组大小

import numpy as np  
a = np.array([[1,2,3],[4,5,6]]) 
a.shape = (3,2)  
print(a)#a被调整为里面有3个数组  每个数组有2个元素
"""
输出
[[1 2]
 [3 4]
 [5 6]]
"""

NumPy 也提供了 reshape 函数来调整数组大小。

import numpy as np  
a = np.array([[1,2,3],[4,5,6]]) 
b = a.reshape(3,2)  
print (b)
"""
[[1 2]
 [3 4]
 [5 6]]
"""

五、NumPy 创建数组

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

1、numpy.empty

numpy.empty 方法用来创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组：

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

参数说明：

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

import numpy as np 
x = np.empty([3,2], dtype = int) 
print (x)

注意 − 数组元素为随机值，因为它们未初始化。

2、numpy.zeros

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

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

参数说明：

参数	描述
shape	数组形状
dtype	数据类型，可选
order	'C' 用于 C 的行数组，或者 'F' 用于 FORTRAN 的列数组

import numpy as np
# 默认为浮点数
x = np.zeros(5)
print(x)
# 设置类型为整数
y = np.zeros((5,), dtype = int)
print(y)

3、numpy.ones

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

### 3、numpy.ones

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

参数说明：

参数	描述
shape	数组形状
dtype	数据类型，可选
order	'C' 用于 C 的行数组，或者 'F' 用于 FORTRAN 的列数组

import numpy as np 
# 默认为浮点数
x = np.ones(5) 
print(x) 
# 自定义类型
x = np.ones([2,2], dtype = int)
print(x)

4、numpy.zeros_like

numpy.zeros_like 用于创建一个与给定数组具有相同形状的数组，数组元素以 0 来填充。

numpy.zeros 和 numpy.zeros_like 都是用于创建一个指定形状的数组，其中所有元素都是 0。

它们之间的区别在于：numpy.zeros 可以直接指定要创建的数组的形状，而 numpy.zeros_like 则是创建一个与给定数组具有相同形状的数组。

numpy.zeros_like(a, dtype=None, order='K', subok=True, shape=None)

参数说明：

参数	描述
a	给定要创建相同形状的数组

dtype	创建的数组的数据类型
order	数组在内存中的存储顺序，可选值为 'C'（按行优先）或 'F'（按列优先），默认为 'K'（保留输入数组的存储顺序）
subok	是否允许返回子类，如果为 True，则返回一个子类对象，否则返回一个与 a 数组具有相同数据类型和存储顺序的数组
shape	创建的数组的形状，如果不指定，则默认为 a 数组的形状。

创建一个与 arr 形状相同的，所有元素都为 0 的数组：

import numpy as np 
# 创建一个 3x3 的二维数组
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) 
# 创建一个与 arr 形状相同的，所有元素都为 0 的数组
zeros_arr = np.zeros_like(arr)
print(zeros_arr)

5、numpy.ones_like

numpy.ones_like 用于创建一个与给定数组具有相同形状的数组，数组元素以 1 来填充。

numpy.ones 和 numpy.ones_like 都是用于创建一个指定形状的数组，其中所有元素都是 1。

它们之间的区别在于：numpy.ones 可以直接指定要创建的数组的形状，而 numpy.ones_like 则是创建一个与给定数组具有相同形状的数组。

numpy.ones_like(a, dtype=None, order='K', subok=True, shape=None)

参数说明：

参数	描述
a	给定要创建相同形状的数组
dtype	创建的数组的数据类型
order	数组在内存中的存储顺序，可选值为 'C'（按行优先）或 'F'（按列优先），默认为 'K'（保留输入数组的存储顺序）
subok	是否允许返回子类，如果为 True，则返回一个子类对象，否则返回一个与 a 数组具有相同数据类型和存储顺序的数组
shape	创建的数组的形状，如果不指定，则默认为 a 数组的形状。

创建一个与 arr 形状相同的，所有元素都为 1 的数组：

import numpy as np 
# 创建一个 3x3 的二维数组
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) 
# 创建一个与 arr 形状相同的，所有元素都为 1 的数组
ones_arr = np.ones_like(arr)
print(ones_arr)

六、NumPy 从已有的数组创建数组

1、numpy.asarray

numpy.asarray 类似 numpy.array，但 numpy.asarray 参数只有三个，比 numpy.array 少两个。

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

参数说明：

参数	描述
a	任意形式的输入参数，可以是，列表, 列表的元组, 元组, 元组的元组, 元组的列表，多维数组
dtype	数据类型，可选
order	可选，有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。

将列表转换为 ndarray:

import numpy as np  
x =  [1,2,3] 
a = np.asarray(x)  
print (a)

将元组转换为 ndarray:

import numpy as np  
x =  (1,2,3) 
a = np.asarray(x)  
print (a)

将元组列表转换为 ndarray:

import numpy as np  
x =  [(1,2,3),(4,5)] 
a = np.asarray(x)  
print (a)

转化并且设置 dtype 参数：

import numpy as np  
x =  [1,2,3] 
a = np.asarray(x, dtype =  float)  
print(a)#[ 1.  2.  3.]

2、numpy.fromiter

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

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

参数	描述
iterable	可迭代对象
dtype	返回数组的数据类型
count	读取的数据数量，默认为-1，读取所有数据

import numpy as np
# 使用 range 函数创建列表对象
list=range(5)
it=iter(list)
# 使用迭代器创建 ndarray
x=np.fromiter(it, dtype=float)
print(x)#[0. 1. 2. 3. 4.]

七、NumPy 从数值范围创建数组

1、numpy.arange

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

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

根据 start 与 stop 指定的范围以及 step 设定的步长，生成一个 ndarray。

参数说明：

参数	描述
`start`	起始值，默认为`0`
`stop`	终止值（不包含）
`step`	步长，默认为`1`
`dtype`	返回`ndarray`的数据类型，如果没有提供，则会使用输入数据的类型。

生成 0 到 4 长度为 5 的数组:

import numpy as np 
x = np.arange(5) 
print (x)

设置返回类型位 float:

import numpy as np 
# 设置了 dtype
x = np.arange(5, dtype =  float) 
print (x)

设置了起始值、终止值及步长：

import numpy as np
x = np.arange(10,20,2)  
print (x)

2、numpy.linspace

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

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

参数说明：

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

以下实例用到三个参数，设置起始点为 1 ，终止点为 10，数列个数为 10。

import numpy as np
a = np.linspace(1,10,10)
print(a)#[ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]

设置元素全部是1的等差数列：

import numpy as npa = np.linspace(1,1,10)print(a)#[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]

将 endpoint 设为 false，不包含终止值：

import numpy as np 
a = np.linspace(10, 20,  5, endpoint =  False)  
print(a)#[10. 12. 14. 16. 18.]

以下实例设置间距。

import numpy as np
a =np.linspace(1,10,10,retstep= True)#(array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.]), 1.0) 
print(a)
# 拓展例子
b =np.linspace(1,10,10).reshape([10,1])
print(b)

八、NumPy 切片和索引

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]

以上实例中，我们首先通过 arange() 函数创建 ndarray 对象。然后，分别设置起始，终止和步长的参数为 2，7 和 2。

我们也可以通过冒号分隔切片参数 start:stop:step 来进行切片操作：

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

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

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

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

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

多维数组同样适用上述索引提取方法：

"""
[[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列及剩下的所有元素

九、NumPy 高级索引

NumPy 比一般的 Python 序列提供更多的索引方式。

除了之前看到的用整数和切片的索引外，数组可以由整数数组索引、布尔索引及花式索引。

NumPy 中的高级索引指的是使用整数数组、布尔数组或者其他序列来访问数组的元素。相比于基本索引，高级索引可以访问到数组中的任意元素，并且可以用来对数组进行复杂的操作和修改。

1、整数数组索引

整数数组索引是指使用一个数组来访问另一个数组的元素。这个数组中的每个元素都是目标数组中某个维度上的索引值。

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

import numpy as np  
x = np.array([[1,  2],  [3,  4],  [5,  6]]) 
y = x[[0,1,2],  [0,1,0]]  
print(y)#[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)

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

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)

2、布尔索引

布尔索引也叫逻辑索引

我们可以通过一个布尔数组来索引目标数组。

布尔索引通过布尔运算（如：比较运算符）来获取符合指定条件的元素的数组。

取大于 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])

使用 ~（取补运算符）来过滤 NaN。

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

从数组中过滤掉非复数元素。

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

3、花式索引

花式索引指的是利用整数数组进行索引。

花式索引根据索引数组的值作为目标数组的某个轴的下标来取值。

对于使用一维整型数组作为索引，如果目标是一维数组，那么索引的结果就是对应位置的元素，如果目标是二维数组，那么就是对应下标的行。

花式索引跟切片不一样，它总是将数据复制到新数组中。

4、一维数组

一维数组只有一个轴 axis = 0，所以一维数组就在 axis = 0 这个轴上取值：

import numpy as np
x = np.arange(9)
print(x)
# 一维数组读取指定下标对应的元素
print("-------读取下标对应的元素-------")
x2 = x[[0, 6]] # 使用花式索引
print(x2)
print(x2[0])
print(x2[1])

5、二维数组

1、传入顺序索引数组

import numpy as np  
x=np.arange(32).reshape((8,4))
print(x)# 二维数组读取指定下标对应的行print("-------读取下标对应的行-------")
print (x[[4,2,1,7]])

2、传入倒序索引数组

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

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

np.ix_() 函数就是输入两个数组，产生笛卡尔积的映射关系。

笛卡尔乘积是指在数学中，两个集合 X 和 Y 的笛卡尔积（Cartesian product），又称直积，表示为 X×Y，第一个对象是X的成员而第二个对象是 Y 的所有可能有序对的其中一个成员。

例如 A={a,b}, B={0,1,2}，则：

A×B={(a, 0), (a, 1), (a, 2), (b, 0), (b, 1), (b, 2)} B×A={(0, a), (0, b), (1, a), (1, b), (2, a), (2, b)}

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

十、NumPy 广播(Broadcast)

广播(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)

当运算中的 2 个数组的形状不同时，numpy 将自动触发广播机制。

import numpy as np  
a = np.array([[ 0, 0, 0], [10,10,10],[20,20,20],[30,30,30]])
b = np.array([0,1,2])
print(a + b)

下面的图片展示了数组 b 如何通过广播来与数组 a 兼容。

广播的规则:

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

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

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

若条件不满足，抛出 "ValueError: frames are not aligned" 异常。

十一、Numpy 数组操作

1、修改数组形状

1.1、ndarray.reshape

ndarray.reshape 函数可以在不改变数据的条件下修改形状，格式如下：

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

arr：要修改形状的数组
newshape：整数或者整数数组，新的形状应当兼容原有形状
order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'k' -- 元素在内存中的出现顺序。

import numpy as np 
a = np.arange(8)
print ('原始数组：')
print (a)
print ('\n') 
b = a.reshape(4,2)
print ('修改后的数组：')
print (b)

1.2、ndarray.flat

numpy.ndarray.flat 是一个数组元素迭代器

import numpy as np 
a = np.arange(9).reshape(3,3) 

for row in a:
  print (row)

for element in a.flat:
    print (element)

1.3、ndarray.flatten

ndarray.flatten 返回一份数组拷贝，对拷贝所做的修改不会影响原始数组，格式如下：

ndarray.flatten(order='C')

参数说明：

order(可选)：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'K' -- 元素在内存中的出现顺序。

import numpy as np 
a = np.arange(8).reshape(2,4) 
print ('原数组：')
print (a)
print ('\n')# 默认按行 print ('展开的数组：')
print (a.flatten())
print ('\n') 
print ('以 F 风格顺序展开的数组：')
print (a.flatten(order = 'F'))

1.4、ndarray.ravel

numpy.ravel() 展平的数组元素(扁平化)，顺序通常是"C风格"，返回的是数组视图（view，有点类似 C/C++引用reference的意味），修改会影响原始数组。

该函数接收两个参数：

ndarray.ravel(a, order='C')

参数说明：

order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'K' -- 元素在内存中的出现顺序。

实例

import numpy as np 
a = np.arange(8).reshape(2,4) 
print ('原数组：')
print (a)
print (a.ravel())
print (a.ravel(order = 'F'))

2、翻转数组

函数	描述
`transpose`	转置
`ndarray.T`	转置

2.1、numpy.transpose

numpy.transpose 函数用于对换数组的维度，格式如下：

numpy.transpose(arr, axes)

参数说明:

arr：要操作的数组
axes：整数列表，对应维度，通常所有维度都会对换。

import numpy as np 
a = np.arange(12).reshape(3,4) 
print (a)
print (np.transpose(a))

2.2、ndarray.T

ndarray.T 类似 numpy.transpose：

import numpy as np 
a = np.arange(12).reshape(3,4) 
print ('原数组：')
print (a)
print ('转置数组：')
print (a.T)

3、连接数组

numpy.concatenate

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

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

参数说明：

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

实例

import numpy as np 
a = np.array([[1,2],[3,4]]) 
print (a)
b = np.array([[5,6],[7,8]]) 
print (b)
print (np.concatenate((a,b)))#沿轴 0 连接两个数组
print (np.concatenate((a,b),axis = 1))#沿轴 1 连接两个数组

4、分割数组

函数	数组及操作
`split`	将一个数组分割为多个子数组
`hsplit`	将一个数组水平分割为多个子数组（按列）
`vsplit`	将一个数组垂直分割为多个子数组（按行）

4.1、numpy.split

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

numpy.split(ary, indices_or_sections, axis)

参数说明：

ary：被分割的数组
indices_or_sections：如果是一个整数，就用该数平均切分，如果是一个数组，为沿轴切分的位置（左开右闭）
axis：设置沿着哪个方向进行切分，默认为 0，横向切分，即水平方向。为 1 时，纵向切分，即竖直方向。

实例

import numpy as np a = np.arange(9)
 print (a)
#[0 1 2 3 4 5 6 7 8]
b = np.split(a,3)
#将数组分为三个大小相等的子数组
print (b)#[array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]
b = np.split(a,[4,7])
#将数组在一维数组中表明的位置分割
print (b)#[array([0, 1, 2, 3]), array([4, 5, 6]), array([7, 8])]

axis 为 0 时在水平方向分割，axis 为 1 时在垂直方向分割：

实例

import numpy as np
a = np.arange(16).reshape(4, 4)
print('第一个数组：')
print(a)
print('\n')
print('默认分割（0轴）：')
b = np.split(a,2)
print(b)
print('\n')
print('沿水平方向分割：')
c = np.split(a,2,1)
print(c)
print('\n')
print('沿水平方向分割：')
d= np.hsplit(a,2)
print(d)

4.2、numpy.hsplit

numpy.hsplit 函数用于水平分割数组，通过指定要返回的相同形状的数组数量来拆分原数组。

### 4.2、numpy.hsplit

numpy.hsplit 函数用于水平分割数组，通过指定要返回的相同形状的数组数量来拆分原数组。

4.3、numpy.vsplit

numpy.vsplit 沿着垂直轴分割，其分割方式与hsplit用法相同。

import numpy as np 

a = np.arange(16).reshape(4,4) 
print (a)

b = np.vsplit(a,2)
print (b)

不懂__

关注

12
点赞
踩
38

收藏

觉得还不错? 一键收藏
0
评论
科学计算库Numpy的详细使用方法【很全面】

NumPy(Numerical Python) 是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。NumPy 的前身 Numeric 最早是由 Jim Hugunin 与其它协作者共同开发，2005 年，Travis Oliphant 在 Numeric 中结合了另一个同性质的程序库 Numarray 的特色，并加入了其它扩展而开发了 NumPy。NumPy 为开放源代码并且由许多协作者共同维护开发。
复制链接

扫一扫