numpy模块常用函数解析

https://blog.csdn.net/lm_is_dc/article/details/81098805

numpy模块
以下命令都是在浏览器中输入。
cmd命令窗口输入：jupyter notebook
后打开浏览器输入网址http://localhost:8888/

一、导入模块
import numpy as np
1
查看numpy版本

np.__version__
1
Numpy可以提供数组支持以及相应的高效处理函数，是Python数据分析的基础，也是SciPy、Pandas等数据处理和科学计算库最基本的函数功能库，且其数据类型对Python数据分析十分有用。

二、创建数组(ndarray)
1. 使用np.array()
参数为列表： 如[1, 4, 2, 5, 3]

arr1=np.array([1,2,3,4])
arr1 #点击shift + Enter后可直接查看数组
1
2
1.1 查看变量的数据类型
type(arr1)
输出：numpy.ndarray
1
2
1.2 创建二维数组
arr2= np.array([[1,2,3],[4,5,6],[7,8,9]])
arr2
1
2
1.3 创建多维数组
如创建三维数组：

arry3=np.array([[[1,2,3],[4,5,6],[7,8,9]]])
arry3
1
2
1.4 注意
numpy默认ndarray的所有元素的类型是相同的
如果传进来的列表中包含不同的类型，则统一为同一类型，优先级：str>float>int
如：

np.array([1,2,'a'])
输出：array(['1', '2', 'a'],
dtype='<U11')
1
2
3
shape的使用:shape返回的是ndarray的数组形状(返回类型是元组)。返回值的数据个数表示的就是数组的维度
arr2.shape
输出：(3, 3) #意思是arr2是一个3行3列的数组
1
2
2、使用matplotlib.pyplot获取一个numpy数组，数据来源于一张图片
2.1、导入模块
import matplotlib.pyplot as plt
1
2.2 读取图片
img=plt.imread(r'./虎.jpg') #img此时就是numpy.ndarray
img.shape
输出：(369, 389, 3) #img形状为三维数组，369*389像素，3代表颜色维度
1
2
3
type(img)
输出：numpy.ndarray
1
2
2.3显示图片
plt.imshow(img)
plt.show()
1
2
2.4修改图片
img_ecg=img-50 #img-50意思是每个元素减去50，数组值改变，图片自然会改变
plt.imshow(img_ecg)
plt.show()
1
2
3
3、使用numpy的常见函数创建
包含以下常见创建方法：

3.1 np.ones(shape, dtype=None, order=’C’)
#创建2行2列的全部数值都为1的二维数组
arr= np.ones(shape=(2,2),dtype=int)
arr
输出：array([[1, 1],
[1, 1]])
1
2
3
4
5
3.2 np.zeros(shape, dtype=None, order=’C’)
#创建2行3列的全部数值都为0的二维数组
arr=np.zeros([2,3])
arr
输出：array([[ 0., 0., 0.],
[ 0., 0., 0.]])
1
2
3
4
5
3.3 np.full(shape, fill_value, dtype=None, order=’C’)
#创建2行3列的全部数值都为10的二维数组
#fill_value参数为数组填充的值
arr=np.full(shape=(2,4),fill_value=10,dtype=int)
arr
输出：array([[10, 10, 10, 10],
[10, 10, 10, 10]])
1
2
3
4
5
6
3.4 np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None) 等差数列
#数组初值为0，有10个值，终值为9
arr_linspace=np.linspace(start=0,stop=10,num=10,endpoint=False)
arr_linspace
输出：array([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])
1
2
3
4
3.5 np.arange([start, ]stop, [step, ]dtype=None)
##数组初值为0，有5(10除以2)个值，终值为8，只能创建一维数组
arr_arange=np.arange(0,10,2)
arr_arange
输出：array([0, 2, 4, 6, 8])
1
2
3
4
3.6 np.random.randint(low, high=None, size=None, dtype=’l’)
#创建一个随机数在[10,90)的3行4列二维数组
#size=[3]则是一个一维数组，size=[3,4,5]则是三维数组
#随机原理：根据当前系统的时间产生随机数
#可以固定种子，使用seed(种子)函数
#np.random.seed(1)
np.random.randint(10,90,size=[3,4])
1
2
3
4
5
6
3.7 np.random.randn(d0, d1, …, dn) 标准正太分布
#创建一个10个元素的一维数组
np.random.randn(10)
1
2
#创建一个多维数组
#如创建10行，10列的数组
np.random.randn((10,10))
1
2
3
3.8 np.random.random(size=None)
生成[0,1)的随机数

#创建一个2行2列的数值在[0,1)的二维数组
np.random.random(size=[2,2])
1
2
3.9 np.random.rand(d0,d1,…dn )
以给定的形状创建一个数组，并在数组中加入在[0,1)之间均匀分布的随机样本。

np.random.rand(10)
1

np.random.rand(2,2)
1

3.10 np.eye(N, M=None, k=0, dtype=float)

#创建一个对角线为1的矩阵（二维数组）
arr_eys=np.eye(4)
arr_eys
输出：
array([[ 1., 0., 0., 0.],
[ 0., 1., 0., 0.],
[ 0., 0., 1., 0.],
[ 0., 0., 0., 1.]])
1
2
3
4
5
6
7
8
9
三、ndarray的属性
4个必记参数：

ndim：维度

shape：形状（各维度的长度）

size：总长度

dtype：元素类型

arr_eys.ndim
输出：2
1
2
arr_eys.shape
输出：(4, 4) #4行4列的二维数组
1
2
arr_eys.size
输出：16
1
2
arr_eys.dtype
输出：dtype('float64')
1
2
type(arr_eys)
输出：numpy.ndarray
1
2
四、ndarray的基本操作
1、 索引
通过下标来获取元素。一维与列表完全一致 多维时同理 。

np.random.seed(10)
arr=np.random.randint(10,50,size=(3,4))
arr
输出：
array([[19, 46, 25, 10],
[38, 35, 39, 39],
[18, 19, 10, 46]])
1
2
3
4
5
6
7
#索引
arr[1][2]
输出：39
1
2
3
也根据索引修改数据 。

2 、切片
2.1 一个冒号:进行切片
通过冒号来切片，通过逗号来区分维度。一维与列表完全一致 多维时同理 。

#获取前两行数据
arr[0:2]
输出：
array([[19, 46, 25, 10],
[38, 35, 39, 39]])
1
2
3
4
5
6
#获取前两行的前两列数据
arr[0:2,0:2]
输出：
array([[19, 46],
[38, 35]])
1
2
3
4
5
逗号左边切的是第一个维度（行），逗号右边切的是第二个维度（列）

#获取二维数组前两列数据
arr[:,0:2]
输出：
array([[19, 46],
[38, 35],
[18, 19]])
1
2
3
4
5
6
2.2 两个冒号::进行切片
一维

将数据反转，例如[1,2,3]—->[3,2,1

#创建一维数组
arr=np.arange(0,10)
arr
输出：
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
1
2
3
4
5
#反转
arr[::-1]
输出：
array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])
1
2
3
4
二维

#创建一个3行3列的二维数组
arr=np.linspace(0,9,num=9,endpoint=False).reshape((3,3))
arr
输出：
array([[ 0., 1., 2.],
[ 3., 4., 5.],
[ 6., 7., 8.]])
1
2
3
4
5
6
7
#将数组的行倒序
arr[::-1]
输出：
array([[ 6., 7., 8.],
[ 3., 4., 5.],
[ 0., 1., 2.]])
1
2
3
4
5
6
#将数组的列倒序
arr[:,::-1]
输出：
array([[ 2., 1., 0.],
[ 5., 4., 3.],
[ 8., 7., 6.]])
1
2
3
4
5
6
#全倒置
arr[::-1,::-1]
输出：
array([[ 8., 7., 6.],
[ 5., 4., 3.],
[ 2., 1., 0.]])
1
2
3
4
5
6
3、 图片倒置
读取图片

import matplotlib.pyplot as plt
img=plt.imread(r'./虎.jpg')
type(img)
输出：
numpy.ndarray
1
2
3
4
5
#显示图片
plt.imshow(img)
plt.show()
1
2
3

左右倒置图片

img_lr=img[::,::-1]
plt.imshow(img_lr)
plt.show()
1
2
3

上下倒置图片

img_ab=img[::-1]
plt.imshow(img_ab)
plt.show()
1
2
3

全倒置图片

img_all=img[::-1,::-1]
plt.imshow(img_all)
plt.show()
1
2
3

4、变形
使用arr.reshape()函数，注意参数是一个tuple(元组)！

基本使用
4.1 将一维数组变形成多维数组
#创建一个随机数在[1,800)的10个元素的一维数组
arr=np.random.randint(1,800,size=(10,))
arr.shape
输出：(10,)
1
2
3
4
#将一维数组变形成2行5列的二维数组
arr2=arr.reshape((2,5))
arr2.shape
输出：
(2, 5)
1
2
3
4
5
使用-1自动计算行数(或列数)

#将一维数组变形成2行5列的二维数组
arr2=arr.reshape((-1,5))
arr2.shape
输出：
(2, 5)
1
2
3
4
5
#将一维数组变形成2行5列的二维数组
arr2=arr.reshape((2,-1))
arr2.shape
输出：
(2, 5)
1
2
3
4
5
4.2 将多维数组变形成一维数组
#将arr2变形成一维数组
arr3=arr2.reshape(10)
arr3.shape
输出：(10,)
1
2
3
4
使用-1自动计算元素个数

arr=arr2.reshape(-1)
arr.shape
输出：(10,)
1
2
3
5、级联
np.concatenate()
5.1、一维，二维，多维数组的级联
一维

a1=np.array([1,2,3])
np.concatenate([a1,a1])
输出：
array([1, 2, 3, 1, 2, 3])
1
2
3
4
#创建两个二维数组
a1=np.random.randint(0,100,size=(3,4))
a2=np.random.randint(0,100,size=(3,4))
1
2
3
二维

#创建两个二维数组
a1=np.random.randint(0,100,size=(3,4))
a2=np.random.randint(0,100,size=(3,4))
1
2
3
a1
输出：
array([[18, 53, 32, 84],
[93, 28, 41, 26],
[30, 20, 47, 6]])
1
2
3
4
5
a2
输出：
array([[14, 35, 15, 73],
[90, 16, 58, 51],
[69, 41, 4, 60]])
1
2
3
4
5
列跟列连在一起

#axis=0表示纵向（列跟列连接在一起）级联
np.concatenate([a1,a2],axis=0)
输出：
array([[18, 53, 32, 84],
[93, 28, 41, 26],
[30, 20, 47, 6],
[14, 35, 15, 73],
[90, 16, 58, 51],
[69, 41, 4, 60]])
1
2
3
4
5
6
7
8
9
行与行连接在一起

#axis=1表示横向（行跟行连接在一起）级联
np.concatenate([a1,a2],axis=1)
输出：
array([[18, 53, 32, 84, 14, 35, 15, 73],
[93, 28, 41, 26, 90, 16, 58, 51],
[30, 20, 47, 6, 69, 41, 4, 60]])
1
2
3
4
5
6
axis参数的取值范围：取值范围是由级联的数组维度决定的 （0-（维度-1））

级联需要注意的点：

级联的参数是列表：一定要加中括号或小括号
维度必须相同
形状相符:在维度保持一致的前提下，如果进行横向（axis=1）级联，必须保证进行级联的数组行数保持一致。如果进行纵向（axis=0）级联，必须保证进行级联的数组列数保持一致。
可通过axis参数改变级联的方向
5.2 np.hstack与np.vstack
水平级联与垂直级联，代替axis参数。

np.hstack((a1,a2))
输出：
array([[18, 53, 32, 84, 14, 35, 15, 73],
[93, 28, 41, 26, 90, 16, 58, 51],
[30, 20, 47, 6, 69, 41, 4, 60]])
1
2
3
4
5
np.vstack((a1,a2))
输出：
array([[18, 53, 32, 84],
[93, 28, 41, 26],
[30, 20, 47, 6],
[14, 35, 15, 73],
[90, 16, 58, 51],
[69, 41, 4, 60]])
1
2
3
4
5
6
7
8
6、 合并照片
img=plt.imread(r'./虎.jpg')
img.shape
输出：
(738, 389, 3)
1
2
3
4
plt.imshow(img)
plt.show()
1
2

#上下合并
img_v=np.concatenate((img,img),axis=0)
img_v.shape
输出：
(738, 389, 3)
1
2
3
4
5
plt.imshow(img_v)
plt.show()
1
2

#左右合并
img_h=np.concatenate((img,img),axis=1)
img_h.shape
输出：
(369, 778, 3)
1
2
3
4
5
plt.imshow(img_h)
plt.show()
1
2

7、 切分
与级联类似，三个函数完成切分工作：

np.split(arr,行／列号，轴):参数2是一个列表类型
np.vsplit(arr,行／列号) 水平切
np.hsplit(arr,行／列号) 垂直切
返回值是一个列表
arr=np.array([[3,2,4],[9,5,8],[2,7,1]])
arr
输出：
array([[3, 2, 4],
[9, 5, 8],
[2, 7, 1]])
1
2
3
4
5
6
np.split()

#切分第1、2列(下标从0开始),切两刀，返回一个列表
np.split(arr,[1,2],axis=1)
输出：
[array([[3],
[9],
[2]]), array([[2],
[5],
[7]]), array([[4],
[8],
[1]])]
1
2
3
4
5
6
7
8
9
10
np.vsplit(）

#切分第1行(下标从0开始),切一刀，返回一个列表
np.vsplit(arr,[1])
输出：
[array([[3, 2, 4]]), array([[9, 5, 8],
[2, 7, 1]])]
1
2
3
4
5
np.hsplit(）

#切分第1列(下标从0开始),切一刀，返回一个列表
np.hsplit(arr,[1])
输出：
[array([[3],
[9],
[2]]), array([[2, 4],
[5, 8],
[7, 1]])]
1
2
3
4
5
6
7
8
8、 切分照片
#axis=0，水平切
img=plt.imread(r'./虎.jpg')
img.shape
输出：
(369, 389, 3)
1
2
3
4
5
img_list=np.split(img,[170],axis=0)
plt.imshow(img_list[0])
plt.show()
1
2
3

9、 副本
所有赋值运算不会为ndarray的任何元素创建副本。对赋值后的对象的操作也对原来的对象生效。

a=np.array([1,2,3,4,5])
a1=a
a[1]=222
a
输出：
array([ 1, 222, 3, 4, 5])
1
2
3
4
5
6
a1
输出：
array([ 1, 222, 3, 4, 5])
1
2
3
可使用copy()函数创建副本

a=np.array([1,2,3,4,5])
a1=a.copy()
1
2
a[1]=222
a
输出：
array([ 1, 222, 3, 4, 5])
1
2
3
4
a1
输出：
array([1, 2, 3, 4, 5])
1
2
3
10、 ravel() 数组扁平化
方式1：np.ravel(a，order=’C’)

方式2：ndarray.racel(order=’C’)

把多维数组扁平化成一维数组。参数’C’表示按行进行扁平，’F’表示按列进行扁平。

#创建二维数组
arr1=np.array([[1,2],[3,4]])
arr1
1
2
3

arr1.ravel(order='C')
1

arr1.ravel(order='F')
1

np.ravel(arr1)
1

np.ravel(arr1,order='F')
1

11、np.c_[arr1,arr2,…] 数组合并
把多个数组合并成一个数组。

arr1=np.array([1,2,3,4])
arr1
结果为：
array([1, 2, 3, 4])
1
2
3
4
np.c_[arr1,arr1]
结果为：
array([[1, 1],
[2, 2],
[3, 3],
[4, 4]])
1
2
3
4
5
6
多维数组：

#创建三维数组
arr2=np.array([[[1,2,3],[4,5,6],[7,8,9]]])
arr2
结果为：
array([[[1, 2, 3],
[4, 5, 6],
[7, 8, 9]]])
1
2
3
4
5
6
7
np.c_[arr2,arr2,arr2]
结果为：
array([[[1, 2, 3, 1, 2, 3, 1, 2, 3],
[4, 5, 6, 4, 5, 6, 4, 5, 6],
[7, 8, 9, 7, 8, 9, 7, 8, 9]]])
1
2
3
4
5
12、获取数组不重复的值
np.unique(ar,return_counts=False)

参数ar：数组

参数return_counts：返回每个元素出现的次数

返回值是一个 元组。

arr=np.array([11,1,2,3,4,11,3,5])
np.unique(arr,return_counts=True)
1
2

13、使用dispkay()显示多个数组
#导入包
from IPython.display import display
1
2
a=np.array([1,2,3,4])
b=np.array([5,6,7])
display(a,b)
1
2
3

五、ndarray的聚合操作
1、 求和np.sum
一维

arr=np.linspace(0,10,10,endpoint=False)
arr
输出：
array([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])
1
2
3
4
np.sum(arr,axis=0)
输出：
45.0
1
2
3
二维

np.random.seed(8)
arr2=np.random.randint(0,10,size=(3,4))
arr2
输出：
array([[3, 4, 1, 9],
[5, 8, 3, 8],
[0, 5, 1, 3]])
1
2
3
4
5
6
7
axis=0,列相加

np.sum(arr2,axis=0)
输出：
array([ 8, 17, 5, 20])
1
2
3
axis=1,行相加

np.sum(arr2,axis=1)
输出：
array([17, 24, 9])
1
2
3
2、 最大最小值：np.max/ np.min
np.random.seed(8)
arr2=np.random.randint(0,10,size=(3,4))
arr2
输出：
array([[3, 4, 1, 9],
[5, 8, 3, 8],
[0, 5, 1, 3]])
1
2
3
4
5
6
7
axis=0,列最小值

np.min(arr2,axis=0)
输出：
array([0, 4, 1, 3])
1
2
3
axis=1,行最小值

np.min(arr2,axis=1)
输出：
array([1, 3, 0])
1
2
3
3、 平均值：np.mean()
arr2=np.array([[1,2,3],[3,4,5]])
arr2
输出：
array([[1, 2, 3],
[3, 4, 5]])
1
2
3
4
5
axis=0,列平均值

np.mean(arr2,axis=0)
输出：
array([ 2., 3., 4.])
1
2
3
axis=1,行平均值

np.mean(arr2,axis=1)
输出：
array([ 2., 4.])
1
2
3
4、 其他聚合操作
Function Name NaN-safe Version Description
np.sum np.nansum Compute sum of elements
np.prod np.nanprod Compute product of elements
np.mean np.nanmean Compute mean of elements
np.std np.nanstd Compute standard deviation
np.var np.nanvar Compute variance
np.min np.nanmin Find minimum value
np.max np.nanmax Find maximum value
np.argmin np.nanargmin Find index of minimum value
np.argmax np.nanargmax Find index of maximum value
np.median np.nanmedian Compute median of elements
np.percentile np.nanpercentile Compute rank-based statistics of elements
np.any N/A Evaluate whether any elements are true
np.all N/A Evaluate whether all elements are true
np.power 幂运算
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
六、ndarray的矩阵操作
1、 基本矩阵操作
1.1算术运算符：
加减乘除
#创建一个3行3列的二维数组x1
x1 = np.arange(9.0).reshape((3, 3))
x1
输出：
array([[ 0., 1., 2.],
[ 3., 4., 5.],
[ 6., 7., 8.]])
1
2
3
4
5
6
7
#创建一个3个元素的一维数组x2
x2 = np.arange(3.0)
x2
输出：
array([ 0., 1., 2.])
1
2
3
4
5
x1+x2

x1+x2
输出：
array([[ 0., 2., 4.],
[ 3., 5., 7.],
[ 6., 8., 10.]])
1
2
3
4
5
x2会自动补全成

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

再和x1相加，对应的元素相加。【广播机制】

1.2 矩阵积np.dot()
两个集合中，a的行数和b的列数必须保持一致

arr1=np.array([[1,2],[3,4]])
arr1
输出：
array([[1, 2],
[2, 3]])
1
2
3
4
5
arr2=np.array([[5,6],[7,8]])
arr2
输出：
array([[5, 6],
[7, 8]])
1
2
3
4
5
np.dot(arr1,arr2)
输出：
array([[19, 22],
[31, 36]])
1
2
3
4
1.3 逆矩阵
函数np.linalg.inv()
矩阵相乘：行和列相同，行乘列。

#导包
import numpy as np
from IPython.display import display
1
2
3
# 创建两个二维数组
a = np.random.randint(0,10,size = (2,3))

b = np.random.randint(0,10,size = (3,4))
display(a,b)
1
2
3
4
5

#矩阵点乘：行乘列：8*0+4*8+4*4 = 48
np.dot(a,b)
1
2

#单元矩阵：a_T*a
unit_a = np.dot(a_T,a)
# 逆矩阵的求解：
nverse_matrix = np.linalg.inv(unit_a)
nverse_matrix
1
2
3
4
5

2、广播机制
【重要】ndarray广播机制的三条规则:缺失维度的数组将维度补充为进行运算的数组的维度。缺失的数组元素使用已有元素进行补充。

规则一：为缺失的维度补1(进行运算的两个数组之间的维度只能相差一个维度)
规则二：缺失元素用已有值填充
规则三：缺失维度的数组只能有一行或者一列
例1： m = np.ones((2, 3)) a = np.arange(3) 求m+a

m=np.ones((2,3))
a=np.arange(3)
1
2
m
输出：
array([[ 1., 1., 1.],
[ 1., 1., 1.]])
1
2
3
4
a
输出：
array([0, 1, 2])
1
2
3
m+a
输出：
array([[ 1., 2., 3.],
[ 1., 2., 3.]])
1
2
3
4
七、ndarray的排序
1、快速排序
1.1 np.sort()不改变输入
1.2 ndarray.sort()本地处理，不占用空间，但改变输入
np.random.seed(3)
arr=np.random.randint(0,10,size=(3,4))
arr
输出：
array([[8, 9, 3, 8],
[8, 0, 5, 3],
[9, 9, 5, 7]])
1
2
3
4
5
6
7
#默认排序，对行进行从小到大的排序，参数axis默认为-1
np.sort(arr)
输出：
array([[3, 8, 8, 9],
[0, 3, 5, 8],
[5, 7, 9, 9]])
1
2
3
4
5
6
#np.sort(arr)不改变arr,arr和原来一样
arr
输出：
array([[8, 9, 3, 8],
[8, 0, 5, 3],
[9, 9, 5, 7]])
1
2
3
4
5
6
#axis=0，按列进行排序
np.sort(arr,axis=0)
输出：
array([[8, 0, 3, 3],
[8, 9, 5, 7],
[9, 9, 5, 8]])
1
2
3
4
5
6
#按行进行排序
np.sort(arr,axis=1)
输出：
array([[3, 8, 8, 9],
[0, 3, 5, 8],
[5, 7, 9, 9]])
1
2
3
4
5
6
arr.sort()会改变arr

#有一个参数axis,默认为-1，按行排序
arr.sort()
arr
输出：
array([[3, 8, 8, 9],
[0, 3, 5, 8],
[5, 7, 9, 9]])
1
2
3
4
5
6
7
2、部分排序
np.partition(a,k)

有的时候我们不是对全部数据感兴趣，我们可能只对最小或最大的一部分感兴趣。

当k为正时，我们想要得到最小的k个数
当k为负时，我们想要得到最大的k个数
np.random.seed(3)
arr=np.random.randint(0,10,size=(3,4))
arr
输出：
array([[8, 9, 3, 8],
[8, 0, 5, 3],
[9, 9, 5, 7]])
1
2
3
4
5
6
7
np.partition(arr,-3)
输出：
array([[3, 8, 9, 8],
[0, 3, 5, 8],
[5, 7, 9, 9]])
---------------------
作者：微信1257309054
来源：CSDN
原文：https://blog.csdn.net/lm_is_dc/article/details/81098805
版权声明：本文为博主原创文章，转载请附上博文链接！