Python | numpy相关函数的使用教程+简单实例汇总

我在开水团做运筹

已于 2023-10-23 14:17:40 修改

阅读量2.4k

点赞数 3

分类专栏： # 工程化文章标签： python numpy 开发语言

于 2021-04-07 17:04:35 首次发布

本文链接：https://blog.csdn.net/taozibaby/article/details/115322476

版权

工程化专栏收录该内容

5 篇文章 0 订阅

订阅专栏

NumPy(Numerical Python) 是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。本文将结合实际编程需要，持续更新内容。

以下内容，都需要首先导入numpy工具包

import numpy as np

初始化

zeros

zeros（(m,n)）生成m行n列的0矩阵。需要注意的是，输入的是(m,n)，括号不能省略，否则会报错。ones是生成1矩阵，用法与zeros完全相同，此处不再重复。

np.zeros((2,3))
Out[3]: 
array([[0., 0., 0.],
       [0., 0., 0.]])
       
np.zeros((2,3),dtype=int)  # dtype强制修改数据类型，默认为float
Out[4]: 
array([[0, 0, 0],
       [0, 0, 0]])

np.zeros(4)
Out[5]: array([0., 0., 0., 0.])

np.zeros(4,1)
	TypeError: Cannot interpret '1' as a data type

full

full((m,n),x)生成一个m行n列，值全为x的矩阵。

np.full((2,3),1.414)
Out[9]: 
array([[1.414, 1.414, 1.414],
       [1.414, 1.414, 1.414]])

arange

arange(x, y, p)生成等差数列，x开始，y结束，公差为p。需要特别注意的是，y本身不包含在内。

np.arange(1, 10, 2)
Out[10]: array([1, 3, 5, 7, 9])

np.arange(2, 10, 2)  # 不包含10
Out[11]: array([2, 4, 6, 8])

linspace

linspace(x, y, p)也生成等差数列，x开始，y结束，总个数为p。与arange不同的是，数列中包含y。

np.linspace(0, 1, 11)
Out[14]: array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ])

eye

eye(x,y)产生“单位”矩阵，即对角值为1，其他为0。此处与zeros不同，x,y外面不需要括号。如果只输入一个参数，则是标准的单位矩阵。

np.eye(2,3)
Out[15]: 
array([[1., 0., 0.],
       [0., 1., 0.]])

np.eye(3)
Out[16]: 
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])

其他数据类型转换为numpy

列表list

numpy.array(list)用于将列表list转换为numpy数组。list中的内容不要求有相同的数据结构。如果list中空数组，会有额外警告。此时，增加dtype=object即可避开警告。

list0 = [78, 3, 'python', {'name': 'Su'}]
list0
Out[8]: [78, 3, 'python', {'name': 'Su'}]
np.array(list0)
Out[6]: array([78, 3, 'python', {'name': 'Su'}], dtype=object)

list1 = [78, 3, 'python', [], {'name': 'Su'}]
np.array(list1)
<ipython-input-11-92f6503f0b1d>:1: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray
  np.array(list1)
Out[11]: array([78, 3, 'python', list([]), {'name': 'Su'}], dtype=object)
np.array(list1, dtype=object)
Out[13]: array([78, 3, 'python', list([]), {'name': 'Su'}], dtype=object)

字典dict

如果是要保存字典dict的值，可以先保存在列表list中，然后再使用上述的方法转化为numpy数组。

David = {'Gender': 'Male', 'Age': 20, 'Score': 95}
list_david_values = []
for value in David:
    list_david_values.append(value)
np.array(list_david_values)
Out[36]: array(['Male', '20', '95'], dtype='<U4')

一维数组，查找最大值，最小值和对应位置

max/min

x.max/min用于返回矩阵x的最大值/最小值。x可以是一维数组，也可以是多维矩阵。

x = np.array([1, 2, 3, 4, 5])

x.min()
Out[3]: 1
x.max()
Out[5]: 5

x = np.array([[2, 1, 3], [4, 5, 6]])
x
Out[29]: 
array([[2, 1, 3],
       [4, 5, 6]])
x.max()
Out[30]: 6
x.min()
Out[31]: 1

argmax/argmin

x.argmax/argmin用于返回矩阵x的最大值/最小值对应的编号。如果x是多维矩阵，编号从左往右，从上到下计算。

x = np.array([1, 2, 3, 4, 5])
x.argmin()
Out[4]: 0
x.argmax()
Out[6]: 4

x = np.array([[2, 1, 3], [4, 5, 6]])
x
Out[29]: 
array([[2, 1, 3],
       [4, 5, 6]])
x.argmin()
Out[32]: 1
x.argmax()
Out[33]: 5

随机数生成

random

random.random()用于生成一个0到1的随机符点数: 0 <= n < 1.0

np.random.random()  # 不加参数，默认生成1个随机数
Out[8]: 0.47834571749034993

np.random.random((2, 3))  # 输入元组，生成2*3的矩阵
Out[9]: 
array([[0.34929946, 0.84751733, 0.75463665],
       [0.55898319, 0.0073236 , 0.59299813]])

normal

random.normal(a,b,(m,n))，用于生成m行n列的正态分布随机矩阵，其中，均值为a，方差为b。

np.random.normal(0,1,(3,4))
Out[28]: 
array([[ 0.34968572, -1.1434212 , -0.97359849, -0.79628415],
       [ 1.61939817, -0.26816321,  0.81202747, -0.31763743],
       [-0.32555471,  0.35261017,  0.44191673, -1.23340666]])

uniform

random.uniform(a, b)，用于生成一个指定范围内的随机符点数，两个参数其中一个是上限，一个是下限。如果a > b，则生成的随机数n: a <= n <= b。如果 a <b，则 b <= n <= a。简单点理解，a和b的大小前后顺序，不影响。如果a=b，不报错，输出结果一直为a。

np.random.uniform(10,20) # 输入两个参数，默认生成1个随机数
Out[11]: 13.96870158628323
np.random.uniform(20,10)
Out[12]: 12.30359930116726

np.random.uniform(20,10,(2,3)) # 输入三个参数，随机数维度为2*3
Out[13]: 
array([[17.47191268, 15.75893318, 10.09790952],
       [16.16676461, 19.70001767, 17.83134362]])
       
np.random.uniform(20,20)
Out[14]: 20.0

randint

random.randint(a, b)，用于生成一个指定范围内的整数。其中参数a是下限，参数b是上限，生成的随机数n: a <= n <= b。如果a>b，程序会报错。

np.random.randint(10,20)
Out[23]: 12

np.random.randint(10,20,(2,3))
Out[24]: 
array([[19, 14, 15],
       [10, 17, 12]])
       
np.random.randint(10,10)
	ValueError: low >= high

choice

random.choice从序列中获取一个随机元素。其函数原型为：random.choice(sequence)。参数sequence表示一个有序类型。此处，sequence必须是整数，或者一维数组（list和numpy格式都可以）。

np.random.choice(10)
Out[51]: 8
np.random.choice(["JGood", "is", "a", "handsome", "boy"])

Out[52]: 'is'
x = np.array([1, 2, 3, 4, 5])
np.random.choice(x)
Out[54]: 4

x = np.random.randint(2, 10, (3,4))  # 生成3*4的二维数组
np.random.choice(x)
	ValueError: x must be 1-dimensional
	
np.random.choice("学习Python")
	ValueError: a must be 1-dimensional or an integer

shuffle

random.shuffle(x）用于将一个x中的元素打乱。该函数无返回值，直接改变x中的顺序。x可以为list或numpy。如果x为2维数组，按列分别打乱，由于改变了相互行列之间的联系，此情况要小心使用。

x = np.array([1, 2, 3, 4, 5])
print(np.random.shuffle(x))
None
print(x)
[3 2 1 5 4]

x = ["JGood", "is", "a", "handsome", "boy"]
print(np.random.shuffle(x))
None
x
Out[71]: ['boy', 'JGood', 'handsome', 'is', 'a']

x = np.random.randint(2, 10, (3,4))
np.random.shuffle(x)
x
Out[74]: 
array([[8, 9, 4, 8],
       [3, 9, 7, 7],
       [8, 4, 2, 3]])
np.random.shuffle(x)
x
Out[76]: 
array([[8, 4, 2, 3],
       [3, 9, 7, 7],
       [8, 9, 4, 8]])
np.random.shuffle(x)
x
Out[78]: 
array([[8, 9, 4, 8],
       [3, 9, 7, 7],
       [8, 4, 2, 3]])
np.random.shuffle(x)
x
Out[80]: 
array([[3, 9, 7, 7],
       [8, 4, 2, 3],
       [8, 9, 4, 8]])

增加、删除矩阵的行与列

delete

numpy.delete(x, k, axis=0)用于删除矩阵x的第k行数据；如果axis=1，删除的是第k列数据；如果axis缺省，删除的是第k个元素，从行开始数个数。

x = np.random.random((2, 3))
x
Out[31]: 
array([[0.90442519, 0.7076176 , 0.22142417],
       [0.52503652, 0.07413326, 0.76197919]])

y = np.delete(x, 0, axis=0)
y
Out[32]: array([[0.52503652, 0.07413326, 0.76197919]])

y = np.delete(x, 0, axis=1)
y
Out[33]: 
array([[0.7076176 , 0.22142417],
       [0.07413326, 0.76197919]])    
         
y = np.delete(x, 1)  # 删除第0行第1列的元素
y
Out[34]: array([0.90442519, 0.22142417, 0.52503652, 0.07413326, 0.76197919])

where

numpy.where用于查找矩阵中满足特定条件的编号，配合delete可以删除满足特定条件的行（axis=0）或者列（axis=1）。

x = np.random.random((3,4))
x
Out[5]: 
array([[0.61055991, 0.81689467, 0.84516727, 0.55910933],
       [0.12714296, 0.05058757, 0.80175304, 0.59154968],
       [0.38883073, 0.3500439 , 0.27685047, 0.11430788]])

np.where(x[0, :] > 0.8)  # 查找矩阵x中第0行大于0.8的编号，为第1列和第2列
Out[17]: (array([1, 2], dtype=int64),) 

y = np.delete(x, np.where(x[0,:] > 0.8), axis=1)
y
Out[15]: 
array([[0.61055991, 0.55910933],
       [0.12714296, 0.59154968],
       [0.38883073, 0.11430788]])

hstack

用于将多个小数组，沿着水平（horizontally）方向，组合成一个大的数组，即行不变，列增加。

x = np.random.random((2, 3))
x
Out[19]: 
array([[0.28521827, 0.27011631, 0.65448758],
       [0.84018638, 0.85537349, 0.45101044]])
y = np.random.random((2, 3))
y
Out[21]: 
array([[0.95680477, 0.66569346, 0.01197921],
       [0.06090398, 0.19703335, 0.40314531]])
np.hstack((x, y))
Out[22]: 
array([[0.28521827, 0.27011631, 0.65448758, 0.95680477, 0.66569346, 0.01197921],
       [0.84018638, 0.85537349, 0.45101044, 0.06090398, 0.19703335, 0.40314531]])

vstack

用于将多个小数组，沿着垂直（vertically）方向，组合成一个大的数组，即行增加，列不变。

np.vstack((x, y))  # 沿用hstack中的x和y数据
Out[23]: 
array([[0.28521827, 0.27011631, 0.65448758],
       [0.84018638, 0.85537349, 0.45101044],
       [0.95680477, 0.66569346, 0.01197921],
       [0.06090398, 0.19703335, 0.40314531]])

排序

sort

np.sort(a, axis)，表示将a按照行/列进行排序。默认axis=1,按行排列；axis=0，按列排列；axis=None，转换为1维数组，重新排列。
特别提醒，sort函数会打断原有的顺序，不建议随意使用。

a = [[3, 1, 2], [4, 5, 3], [7, 8, 9]]
a = np.array(a)
np.sort(a, axis=1)
Out[8]: 
array([[1, 2, 3],
       [3, 4, 5],
       [7, 8, 9]])
np.sort(a, axis=0)
Out[9]: 
array([[3, 1, 2],
       [4, 5, 3],
       [7, 8, 9]])
np.sort(a, axis=None)
Out[10]: array([1, 2, 3, 3, 4, 5, 7, 8, 9])
np.sort(a)
Out[11]: 
array([[1, 2, 3],
       [3, 4, 5],
       [7, 8, 9]])

lexsort

np.lexsort([a, b])返回一组编号，首先按b升序排列，如果b的数值相同，再以a升序排列。常用来对某个数组按多列顺序排列。a和b外的[]不能缺少，即使只有1个，也必须存在。

x = np.array([[1, 2, 3], [4, 1, 3], [5, 6, 1], [3, 2, 2]])
x
Out[17]: 
array([[1, 2, 3],
       [4, 1, 3],
       [5, 6, 1],
       [3, 2, 2]])
sorted_index = np.lexsort([x[:, 1], x[:, 2]])  # 先按x的第二列排序，再按第一列排序
x[sorted_index]
Out[25]: 
array([[5, 6, 1],
       [3, 2, 2],
       [4, 1, 3],
       [1, 2, 3]])
sorted_index = np.lexsort([x[:, 1]])
x[sorted_index]
Out[27]: 
array([[4, 1, 3],
       [1, 2, 3],
       [3, 2, 2],
       [5, 6, 1]])