PythonNumPy模块详解

NumPy模块

openCV中NumPy模块使用详解见我另一篇博客。
Windows下Python-openCV学习(三)-------像素获取和NumPy模块
什么是NumPy？

NumPy 是一个 Python 包。 它代表 “Numeric Python”。 它是一个由多维数组对象和用于处理数组的例程集合组成的库。
Numeric，即 NumPy 的前身，是由 Jim Hugunin 开发的。 也开发了另一个包 Numarray ，它拥有一些额外的功能。 2005年，Travis Oliphant 通过将 Numarray 的功能集成到 Numeric 包中来创建 NumPy 包。 这个开源项目有很多贡献者。

NumPy是C语言实现的，所以其运算速度非常快。具体功能如下：

1、有一个强大的N维数组对象ndarray
2、广播功能方法
3、线性代数、傅里叶变换、随机数生成、图形操作等
4、整合C/C++/Fortran代码工具

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_	
float_ 是float64 类型的简写
---------------------------------------------------------------------------------------------
float16
半精度浮点数，包括：1 个符号位，5 个指数位，10 个尾数位
float32
单精度浮点数，包括：1 个符号位，8 个指数位，23 个尾数位
float64
双精度浮点数，包括：1 个符号位，11 个指数位，52 个尾数位
complex_
complex128 类型的简写，即 128 位复数
complex64
复数，表示双 32 位浮点数（实数部分和虚数部分）
complex128
复数，表示双 64 位浮点数（实数部分和虚数部分）

使用NumPy创建数组
1、常规array方法

numpy.array(object,dtype,copy,order,subok,ndmin)
参数：
		object ：任何具有数组接口方法的对象
		dtype : 数据类型
		copy ： 布尔型，可选参数。默认值为True,则object参数被复制;否则，只有当__array__返回副本，
				object参数为嵌套序列，或者需要副本满足数据类型和顺序要求时，才会生成副本。
		order ： 元素在内存中出现的顺序，其值为K,A,C,F。如果object参数不是数组，则新创建的数组将按行排
		         列(C)，如果值为F，按列排列;如果object参数是一个数组，则以下顺序成立：
		         C(按行)  F(按列)  A(原顺序)  F(元素在内存中出现的位置)。
	    subok ： 默认情况下，返回的数组被强制为基类数组。 如果为true，则返回子类。
	    ndmin ： 指定生成数组的最小维数

下面我们来看几个小例子：

1.1 创建一维数组和二维数组

import numpy as np
n1=np.array([1,2,3])
n2=np.array([[1,2],[3,4]])
print("一维数组")
print(n1)
print("二维数组")
print(n2)

输出：

一维数组
[1 2 3]
二维数组
[[1 2]
 [3 4]]

1.2 创建指定类型数组

#创建浮点类型数组
import numpy as np
stl=[1,2,3]
n1=np.array(stl,dtype=np.float_)
print(n1)

输出

[1. 2. 3.]

1.2 创建三维数组
方法一

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

方法二

import numpy as np
n1=np.array([1,2,3],ndmin=3)
print(n1)

输出

[[[1 2 3]]]

2、创建指定维度和数据类型未初始化数组

numpy.empty(shape, dtype, order)
参数：
			
		shape ：int 或 int的tuple
				空数组的Shape，例如，(2, 3)或2

		dtype ：data-type, 可选

				数组所需的输出数据类型，例如， numpy.int8 默认值为numpy.float64.

		order ：{‘C’, ‘F’}, 可选, 默认: ‘C’

				是否以行优先（C样式）或列优先（Fortran样式）的顺序存储多维数据在内存中。

创建一个未初始化的，两行三列未初始化，int类型数组

import numpy as np
n1=np.empty((2,3),dtype=np.int_)
print(n1)

输出

[[-707327008      32764 -707322496]
 [     32764          0          0]]

3、创建纯0填充的数组

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

参数：
			
		shape：int或int元组

			新阵列的形状，例如，或。(2, 3)2

		dtype：数据类型，可选

			数组的所需数据类型，例如numpy.int8。默认是 numpy.float64。

		order ： {'C'，'F'}，可选，默认：'C'

			是否在内存中以行主（C风格）或列主（Fortran风格）顺序存储多维数据。

创建三行三列数据类型为无符号整形的纯0数组

import numpy as np
n1=np.zeros((3,3),dtype=np.uint8)
print(n1)

输出：

[[0 0 0]
 [0 0 0]
 [0 0 0]]

4、创建纯1填充数组

numpy.ones(shape, dtype=float, order='C')
	
		shape ： int或int的序列

			新数组的形状，例如，(2, 3)或2

		dtype ： 数据类型，可选

			数组的所需数据类型，例如numpy.int8。默认是 numpy.float64。

		order ： {'C'，'F'}，可选，默认值：C

			是否在内存中以行主（C-风格）或列主（Fortran-风格）顺序存储多维数据。

创建三行三列数据类型为无符号整形的纯1数组

import numpy as np
n1=np.ones([3,3],dtype=np.uint8)
print(n1)

输出

[[1 1 1]
 [1 1 1]
 [1 1 1]]

5、创建随机数组

np.random.randint(low,high,size)

参数：
		low:随机数最小取值范围
		high：可选参数，随机数最大取值范围，若high为空，取值范围为(0,low),不为空为(low,high).
		      high>low
		size:可选参数，数组维度

随机生成10个1~3且不包括3的整数

import numpy as np
n1=np.random.randint(1,3,10)
print(n1)

输出

[2 1 1 2 2 2 1 1 1 2]

随机生成1~3，以内的二维数组

import numpy as np
n1=np.random.randint(1,3,size=(2,3))#两行三列
print(n1)

输出：

[[1 2 2]
 [2 2 1]]

操作数组
1、加减乘除幂运算

import numpy as np
n1=np.array([1,2],dtype=np.float_)
n2=np.array([3,4],dtype=np.float_)
print(f'n1:\n{n1}')
print(f'n2:\n{n2}')
print('----')
print(f'n1+n2 \n{n1+n2}')
print('----')
print(f'n2-n1 \n{n2-n1}')
print('----')
print(f'n1*n2 \n{n1*n2}')
print('----')
print(f'n2/n1 \n{n2/n1}')
print('----')
print(f'n1**n2 \n{n1**n2}')

输出

n1:
[1. 2.]
n2:
[3. 4.]
----
n1+n2 
[4. 6.]
----
n2-n1 
[2. 2.]
----
n1*n2 
[3. 8.]
----
n2/n1 
[3. 2.]
----
n1**n2 
[ 1. 16.]

2、比较运算

import numpy as np
n1=np.array([1,2,3])
n2=np.array([4,5,6])
print(n1>=n2)
print(n1<=n2)
print(n1==n2)
print(n1!=n2)

输出

[False False False]
[ True  True  True]
[False False False]
[ True  True  True]

3、数组的复制

import numpy as np
n1=np.array([1,2,3])
n2=np.array(n1,copy=True)
print(n2==n1)
n2[1]=0
print(n1)
print(n2)
n2=n1.copy()#这种方法比较常用
print(n1==n2)

输出

[ True  True  True]
[1 2 3]
[1 0 3]
[ True  True  True]

数组的索引
1、一维数组索引

import numpy as np
n1=np.array([1,2,3])
n2=n1[0]
print(n2)

输出

1

2、一维数组切片索引

[起始索引,终止索引,步长]

起始索引 ：不写任何值表示从0开始
终止索引 ：不写任何值表示到末尾全部索引

[起始索引，终止索引)，注意是左闭右开

示例

import numpy as np
n1=np.array([0,1,2,3,4,5,6,7,8,9])
print(n1)
print(n1[:3])
print(n1[3:6])
print(n1[5:])
print(n1[3:6:2])
print(n1[::])
print(n1[:])
print(n1[::2])
print(n1[2::2])
print(n1[::-1])
print(n1[-1:-4:-1])#n1[-1:-4]这种写法是错误的，步长默认是1不是-1
print(n1[-3::-1])

输出

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

3、二维数组索引

arry[n,m]
n:行
m:列

示例

import numpy as np
n1=np.array([[0,1,2,3],[4,5,6,7],[8,9,10,11]])
print(n1)
print('-------')
print(n1[1])
print(n1[1,2])
print(n1[-1])
print(n1[-1,-1])
print('-------')
print(n1[:2,1:])
print('-------')
print(n1[1,:2])
print('-------')
print(n1[:2,2])
print('-------')
print(n1[:,:1])

输出

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