门户网站开发公司平台,分销平台哪个好,wordpress contact 插件,自己怎么申请免费网站文章目录 广播#xff08;broadcast#xff09;迭代数组数组运算修改数组的形状 修改数组维度连接数组分割数组数组元素的添加与删除Numpy算术函数Numpy 统计函数Numpy排序、条件筛选函数条件筛选 import numpy as np
anp.arange(15).reshape(3,5)aarray([[ 0, 1, 2, 3, … 文章目录 广播broadcast迭代数组数组运算修改数组的形状 修改数组维度连接数组分割数组数组元素的添加与删除Numpy算术函数Numpy 统计函数Numpy排序、条件筛选函数条件筛选 import numpy as np
anp.arange(15).reshape(3,5)aarray([[ 0, 1, 2, 3, 4],[ 5, 6, 7, 8, 9],[10, 11, 12, 13, 14]])a.shape(3, 5)a.ndim2a.dtype.nameint64a.itemsize8a.size15type(a)numpy.ndarraybnp.array([6,7,8])barray([6, 7, 8])bnp.array([(1.2,2,3),(4,5,6)])b.ndim2b.shape(2, 3)barray([[1.2, 2. , 3. ],[4. , 5. , 6. ]])np.zeros((3,4))array([[0., 0., 0., 0.],[0., 0., 0., 0.],[0., 0., 0., 0.]])np.ones((2,3,4),dtypenp.int64)array([[[1, 1, 1, 1],[1, 1, 1, 1],[1, 1, 1, 1]],[[1, 1, 1, 1],[1, 1, 1, 1],[1, 1, 1, 1]]])from numpy import pi
np.linspace(0,2,9)array([0. , 0.25, 0.5 , 0.75, 1. , 1.25, 1.5 , 1.75, 2. ])print(np.arange(10000))[ 0 1 2 ... 9997 9998 9999]与许多矩阵语言不同乘积运算符*在NumPy数组中按元素进行运算。矩阵乘积可以使用运算符在python 3.5中或dot函数或方法执行
Anp.array([[1,1],[0,1]])
Bnp.array([[2,0],[3,4]])
A*Barray([[2, 0],[0, 4]])ABarray([[5, 4],[3, 4]])A.dot(B)array([[5, 4],[3, 4]])anp.random.random((2,3))aarray([[0.78801026, 0.48701335, 0.03912818],[0.36542642, 0.99769419, 0.75786037]])a.sum()3.435132775123305a.min()0.03912818216471092a.max()0.9976941879734568numpy.array可以指定沿着对应的轴进行应用操作通过axis参数指定axis0位按照列进行计算axis1为按照行进行计算,cumsum函数是按照指定的轴的方向进行累加
bnp.arange(12).reshape(3,4)
barray([[ 0, 1, 2, 3],[ 4, 5, 6, 7],[ 8, 9, 10, 11]])b.sum(axis0)array([12, 15, 18, 21])b.sum(axis1)array([ 6, 22, 38])b.cumsum(axis1)array([[ 0, 1, 3, 6],[ 4, 9, 15, 22],[ 8, 17, 27, 38]])b.cumsum(axis0)array([[ 0, 1, 2, 3],[ 4, 6, 8, 10],[12, 15, 18, 21]])NumPy提供熟悉的数学函数例如sincos和exp。在NumPy中这些被称为“通函数”ufunc。在NumPy中这些函数在数组上按元素进行运算产生一个数组作为输出。
anp.arange(10)**3
aarray([ 0, 1, 8, 27, 64, 125, 216, 343, 512, 729])#从位置0开始步长为2替换1000
a[:6:2]-1000
aarray([-1000, 1, -1000, 27, -1000, 125, 216, 343, 512,729])aa[::-1]
aarray([ 729, 512, 343, 216, 125, -1000, 27, -1000, 1,-1000])a**(1/3.)/var/folders/cr/2fpn8__12377w89ml3mv5ksw0000gn/T/ipykernel_63544/3446105811.py:1: RuntimeWarning: invalid value encountered in powera**(1/3.)array([ 9., 8., 7., 6., 5., nan, 3., nan, 1., nan])hstack和ystack数组的水平堆叠和垂直堆叠
a1 np.array([1,2,3])
a2np.array([4,5,6])
result_vstacknp.vstack((a1,a2))
result_vstackarray([[1, 2, 3],[4, 5, 6]])result_hstacknp.hstack((a1,a2))
result_hstackarray([1, 2, 3, 4, 5, 6])NumPy提供比常规Python序列更多的索引功能。除了通过整数和切片进行索引之外正如我们之前看到的数组可以由整数数组和布尔数组索引。
anp.arange(12)**2
aarray([ 0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121])inp.array([1,3,5,7])
a[i]array([ 1, 9, 25, 49])jnp.array([[3,4],[9,7]])
a[j]array([[ 9, 16],[81, 49]])palette np.array( [ [0,0,0], # black[255,0,0], # red[0,255,0], # green[0,0,255], # blue[255,255,255] ] )
imagenp.array([[0,1,2,0],[0,3,4,0]])
palette[image]array([[[ 0, 0, 0],[255, 0, 0],[ 0, 255, 0],[ 0, 0, 0]],[[ 0, 0, 0],[ 0, 0, 255],[255, 255, 255],[ 0, 0, 0]]])#为多个维度提供索引。每个维度的索引数组必须具有相同的形状。
a np.arange(12).reshape(3,4)
aarray([[ 0, 1, 2, 3],[ 4, 5, 6, 7],[ 8, 9, 10, 11]])i np.array( [ [0,1], [1,2] ] )
j np.array( [ [2,1], [3,3] ] )a[i,j]array([[ 2, 5],[ 7, 11]])a[:,j]array([[[ 2, 1],[ 3, 3]],[[ 6, 5],[ 7, 7]],[[10, 9],[11, 11]]])#也可以按顺序比如列表放入ij使用列表进行索引
l[i,j]
a[l]/var/folders/cr/2fpn8__12377w89ml3mv5ksw0000gn/T/ipykernel_63544/3994289241.py:3: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use arr[tuple(seq)] instead of arr[seq]. In the future this will be interpreted as an array index, arr[np.array(seq)], which will result either in an error or a different result.a[l]array([[ 2, 5],[ 7, 11]])使用数组索引的另一个常见用法是搜索与时间相关的系列的最大值
time np.linspace(20, 145, 5)
data np.sin(np.arange(20)).reshape(5,4)
print(time)
print(data)[ 20. 51.25 82.5 113.75 145. ]
[[ 0. 0.84147098 0.90929743 0.14112001][-0.7568025 -0.95892427 -0.2794155 0.6569866 ][ 0.98935825 0.41211849 -0.54402111 -0.99999021][-0.53657292 0.42016704 0.99060736 0.65028784][-0.28790332 -0.96139749 -0.75098725 0.14987721]]#记录每一列的最大值的索引位置
ind data.argmax(axis0)
indarray([2, 0, 3, 1])time_maxtime[ind]
data_maxdata[ind,range(data.shape[1])]
print(time_max)
print(data_max)[ 82.5 20. 113.75 51.25]
[0.98935825 0.84147098 0.99060736 0.6569866 ]当我们使用整数索引数组索引数组时我们提供了要选择的索引列表。使用布尔索引方法是不同的; 我们明确地选择我们想要的数组中的哪些项目以及我们不需要的项目。人们可以想到的最自然的布尔索引方法是使用与原始数组具有 相同形状的 布尔数组
a np.arange(12).reshape(3,4)
b a 4
barray([[False, False, False, False],[False, True, True, True],[ True, True, True, True]])#将a数组中大于4的部分打印出来
a[b]array([ 5, 6, 7, 8, 9, 10, 11])使用布尔值进行索引的第二种方法更类似于整数索引; 对于数组的每个维度我们给出一个1D布尔数组选择我们想要的切片请注意1D布尔数组的长度必须与要切片的尺寸或轴的长度一致。在前面的例子中b1具有长度为3的数目 的行 中a和 b2长度4适合于索引的第二轴线列 a。
a np.arange(12).reshape(3,4)aarray([[ 0, 1, 2, 3],[ 4, 5, 6, 7],[ 8, 9, 10, 11]])b1 np.array([False,True,True])
b2 np.array([True,False,True,False])
a[b1,:] array([[ 4, 5, 6, 7],[ 8, 9, 10, 11]])a[:,b2]array([[ 0, 2],[ 4, 6],[ 8, 10]])a[b1,b2]array([ 4, 10])ix_函数可用于组合不同的向量以便获得每个n-uplet的结果。例如如果要计算从每个向量ab和c中取得的所有三元组的所有a b * c
a np.array([2,3,4,5])
b np.array([8,5,4])
c np.array([5,4,6,8,3])
ax,bx,cx np.ix_(a,b,c)
ax.shape, bx.shape, cx.shape((4, 1, 1), (1, 3, 1), (1, 1, 5))result axbx*cx
resultarray([[[42, 34, 50, 66, 26],[27, 22, 32, 42, 17],[22, 18, 26, 34, 14]],[[43, 35, 51, 67, 27],[28, 23, 33, 43, 18],[23, 19, 27, 35, 15]],[[44, 36, 52, 68, 28],[29, 24, 34, 44, 19],[24, 20, 28, 36, 16]],[[45, 37, 53, 69, 29],[30, 25, 35, 45, 20],[25, 21, 29, 37, 17]]])dnp.dtype(int)
np.issubdtype(d,np.floating)Falsenp.power(100,8,dtypenp.int64)10000000000000000np.power(100,8,dtypenp.int32)1874919424from io import BytesIO
data\n.join(str(i) for i in range(10)).encode(utf-8)
np.genfromtxt(BytesIO(data),skip_header3,skip_footer5)array([3., 4.])d1 2 3 \n 4 5 6.encode(utf-8)
np.genfromtxt(BytesIO(d),usecols(0,-1))array([[1., 3.],[4., 6.]])xnp.arange(10)
xarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])x.shape(2,5)
x[0][0]0ynp.arange(35).reshape(5,7)
yarray([[ 0, 1, 2, 3, 4, 5, 6],[ 7, 8, 9, 10, 11, 12, 13],[14, 15, 16, 17, 18, 19, 20],[21, 22, 23, 24, 25, 26, 27],[28, 29, 30, 31, 32, 33, 34]])y[1:5:2,::3]array([[ 7, 10, 13],[21, 24, 27]])#实践中广播的一个例子
xnp.arange(4)
xxx.reshape(4,1)
ynp.ones(5)
znp.ones((3,4))xxarray([[0],[1],[2],[3]])xarray([0, 1, 2, 3])yarray([1., 1., 1., 1., 1.])xxyarray([[1., 1., 1., 1., 1.],[2., 2., 2., 2., 2.],[3., 3., 3., 3., 3.],[4., 4., 4., 4., 4.]])zarray([[1., 1., 1., 1.],[1., 1., 1., 1.],[1., 1., 1., 1.]])xzarray([[1., 2., 3., 4.],[1., 2., 3., 4.],[1., 2., 3., 4.]])datanp.arange(20).reshape(4,5)
dataarray([[ 0, 1, 2, 3, 4],[ 5, 6, 7, 8, 9],[10, 11, 12, 13, 14],[15, 16, 17, 18, 19]])anp.arange(10)
#slice是分割函数从索引2开始到索引7停止步长为2
sslice(2,8,2)
a[s]array([2, 4, 6])广播broadcast
广播的规则
让所有输入数组都向其中形状最长的数组看齐形状中不足的部分都通过在前面加 1 补齐。输出数组的形状是输入数组形状的各个维度上的最大值。如果输入数组的某个维度和输出数组的对应维度的长度相同或者其长度为 1 时这个数组能够用来计算否则出错。当输入数组的某个维度的长度为 1 时沿着此维度运算时都用此维度上的第一组值。
简单理解对两个数组分别比较他们的每一个维度若其中一个数组没有当前维度则忽略满足
数组拥有相同形状。当前维度的值相等。当前维度的值有一个是 1。 若条件不满足抛出 “ValueError: frames are not aligned” 异常。
anp.array([[0,0,0],[10,10,10],[20,20,20],[30,30,30]])
bnp.array([1,2,3])
abarray([[ 1, 2, 3],[11, 12, 13],[21, 22, 23],[31, 32, 33]])迭代数组 NumPy 迭代器对象 numpy.nditer 提供了一种灵活访问一个或者多个数组元素的方式。 迭代器最基本的任务的可以完成对数组元素的访问。 接下来我们使用 arange() 函数创建一个 2X3 数组并使用 nditer 对它进行迭代。
anp.arange(6).reshape(2,3)
print(a)
print(使用nditer 迭代输出元素)
for x in np.nditer(a):print(x,end,)[[0 1 2][3 4 5]]
使用nditer 迭代输出元素
0,1,2,3,4,5,以上实例不是使用标准 C 或者 Fortran 顺序选择的顺序是和数组内存布局一致的这样做是为了提升访问的效率默认是行序优先row-major order或者说是 C-order。 这反映了默认情况下只需访问每个元素而无需考虑其特定顺序。我们可以通过迭代上述数组的转置来看到这一点并与以 C 顺序访问数组转置的 copy 方式做对比如下实例
anp.arange(6).reshape(2,3)
for x in np.nditer(a.T):print(x,end,)
print(\n)
for x in np.nditer(a.T.copy(orderC)):print(x,end,)0,1,2,3,4,5,0,3,1,4,2,5,从上述例子可以看出a 和 a.T 的遍历顺序是一样的也就是他们在内存中的存储顺序也是一样的但是 a.T.copy(order ‘C’) 的遍历结果是不同的那是因为它和前两种的存储方式是不一样的默认是按行访问。 for x in np.nditer(a, order‘F’):Fortran order即是列序优先 for x in np.nditer(a.T, order‘C’):C order即是行序优先 nditer 对象有另一个可选参数 op_flags。 默认情况下nditer 将视待迭代遍历的数组为只读对象read-only为了在遍历数组的同时实现对数组元素值的修改必须指定 readwrite 或者 writeonly 的模式。
import numpy as npa 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]]数组运算
修改数组的形状
函数描述reshape不改变数据的条件下修改形状flat数组元素迭代器flatten返回一份数组拷贝对拷贝所做的修改不会影响原始数组ravel返回展开数组
anp.arange(9).reshape(3,3)
print(原始数组:)
for row in a:print(row)
#对数组中的每个元素进行处理使用flat属性是数组迭代器
print(迭代后的数组:)
for el in a.flat:print(el)原始数组:
[0 1 2]
[3 4 5]
[6 7 8]
迭代后的数组:
0
1
2
3
4
5
6
7
8anp.arange(9).reshape(3,3)
print(原始数组)
print(a)
print(\n)
print(展开的数组)
print(a.flatten())
print(\n)
print(按照F风格列展开的数组)
print(a.flatten(orderF))原始数组
[[0 1 2][3 4 5][6 7 8]]
展开的数组
[0 1 2 3 4 5 6 7 8]
按照F风格列展开的数组
[0 3 6 1 4 7 2 5 8]numpy.ravel() 展平的数组元素顺序通常是C风格返回的是数组视图view有点类似 C/C引用reference的意味修改会影响原始数组。 该函数接收两个参数 numpy.ravel(a, order‘C’) [order‘C’ – 按行‘F’ – 按列‘A’ – 原顺序‘K’ – 元素在内存中的出现顺序。]
anp.arange(9).reshape(3,3)
print(原始数组)
print(a)
print(\n)
print (调用 ravel 函数之后)
print (a.ravel())
print (\n)
print (以 F 风格顺序调用 ravel 函数之后)
print (a.ravel(order F))原始数组
[[0 1 2][3 4 5][6 7 8]]
调用 ravel 函数之后
[0 1 2 3 4 5 6 7 8]
以 F 风格顺序调用 ravel 函数之后
[0 3 6 1 4 7 2 5 8]函数描述transpose对换数组的维度ndarray.T和 self.transpose() 相同rollaxis向后滚动指定的轴swapaxes对换数组的两个轴
修改数组维度
函数描述broadcast产生模仿广播的对象broadcast_to将数组广播到新形状expand_dims扩展数组的形状squeeze从数组的形状中删除一维条目
连接数组
函数描述concatenate连接沿现有轴的数组序列stack沿着新的轴加入一系列数组hstack水平堆叠序列中的数组列方向vstack竖直堆叠序列中的数组行方向
分割数组
函数描述split将一个数组分割为多个子数组hsplit将一个数组水平分割为多个子数组按列vsplit将一个数组垂直分割为多个子数组按行
数组元素的添加与删除
函数描述resize返回指定形状的新数组append将值添加到数组末尾insert沿指定轴将值插入到指定下标之前delete删掉某个轴的子数组并返回删除后的新数组unique查找数组内的唯一元素
a np.array([[1,2],[3,4]])print (第一个数组)
print (a)
print (\n)
b np.array([[5,6],[7,8]])print (第二个数组)
print (b)
print (\n)
# 两个数组的维度相同print (沿轴 0 连接两个数组)
print (np.concatenate((a,b)))
print (\n)print (沿轴 1 连接两个数组)
print (np.concatenate((a,b),axis 1))第一个数组
[[1 2][3 4]]
第二个数组
[[5 6][7 8]]
沿轴 0 连接两个数组
[[1 2][3 4][5 6][7 8]]
沿轴 1 连接两个数组
[[1 2 5 6][3 4 7 8]]a np.array([[1,2],[3,4]])
print (第一个数组)
print (a)
print (\n)
b np.array([[5,6],[7,8]])print (第二个数组)
print (b)
print (\n)print (沿轴 0 堆叠两个数组)
print (np.stack((a,b),0))
print (\n)print (沿轴 1 堆叠两个数组)
print (np.stack((a,b),1))第一个数组
[[1 2][3 4]]
第二个数组
[[5 6][7 8]]
沿轴 0 堆叠两个数组
[[[1 2][3 4]][[5 6][7 8]]]
沿轴 1 堆叠两个数组
[[[1 2][5 6]][[3 4][7 8]]]a np.array([[1,2,3],[4,5,6]])print (第一个数组)
print (a)
print (\n)print (第一个数组的形状)
print (a.shape)
print (\n)
b np.resize(a, (3,2))print (第二个数组)
print (b)
print (\n)print (第二个数组的形状)
print (b.shape)
print (\n)
# 要注意 a 的第一行在 b 中重复出现因为尺寸变大了print (修改第二个数组的大小)
b np.resize(a,(3,3))
print (b)第一个数组
[[1 2 3][4 5 6]]第一个数组的形状
(2, 3)第二个数组
[[1 2][3 4][5 6]]第二个数组的形状
(3, 2)修改第二个数组的大小
[[1 2 3][4 5 6][1 2 3]]# numpy.append 函数在数组的末尾添加值。 追加操作会分配整个数组并把原来的数组复制到新数组中。 此外输入数组的维度必须匹配否则将生成ValueError。
# append 函数返回的始终是一个一维数组。
import numpy as npa np.array([[1,2,3],[4,5,6]])print (第一个数组)
print (a)
print (\n)print (向数组添加元素)
print (np.append(a, [7,8,9]))
print (\n)print (沿轴 0 添加元素)
print (np.append(a, [[7,8,9]],axis 0))
print (\n)print (沿轴 1 添加元素)
print (np.append(a, [[5,5,5],[7,8,9]],axis 1))第一个数组
[[1 2 3][4 5 6]] 向数组添加元素
[1 2 3 4 5 6 7 8 9]沿轴 0 添加元素
[[1 2 3][4 5 6][7 8 9]]沿轴 1 添加元素
[[1 2 3 5 5 5][4 5 6 7 8 9]]#numpy.insert 函数在给定索引之前沿给定轴在输入数组中插入值。
#如果值的类型转换为要插入则它与输入数组不同。 插入没有原地的函数会返回一个新数组。 此外如果未提供轴则输入数组会被展开。a np.array([[1,2],[3,4],[5,6]])print (第一个数组)
print (a)
print (\n)print (未传递 Axis 参数。 在删除之前输入数组会被展开。)
print (np.insert(a,3,[11,12]))
print (\n)
print (传递了 Axis 参数。 会广播值数组来配输入数组。)print (沿轴 0 广播)
print (np.insert(a,1,[11],axis 0))
print (\n)print (沿轴 1 广播)
print (np.insert(a,1,11,axis 1))第一个数组
[[1 2][3 4][5 6]]未传递 Axis 参数。 在删除之前输入数组会被展开。
[ 1 2 3 11 12 4 5 6] 传递了 Axis 参数。 会广播值数组来配输入数组。
沿轴 0 广播
[[ 1 2][11 11][ 3 4][ 5 6]]沿轴 1 广播
[[ 1 11 2][ 3 11 4][ 5 11 6]]# numpy.delete 函数返回从输入数组中删除指定子数组的新数组。 与 insert() 函数的情况一样如果未提供轴参数则输入数组将展开。
import numpy as npa np.arange(12).reshape(3,4)print (第一个数组)
print (a)
print (\n)print (未传递 Axis 参数。 在插入之前输入数组会被展开。)
print (np.delete(a,5))
print (\n)print (删除第二列)
print (np.delete(a,1,axis 1))
print (\n)print (包含从数组中删除的替代值的切片)
a np.array([1,2,3,4,5,6,7,8,9,10])
print (np.delete(a, np.s_[::2]))第一个数组
[[ 0 1 2 3][ 4 5 6 7][ 8 9 10 11]]未传递 Axis 参数。 在插入之前输入数组会被展开。
[ 0 1 2 3 4 6 7 8 9 10 11] 删除第二列
[[ 0 2 3][ 4 6 7][ 8 10 11]]包含从数组中删除的替代值的切片
[ 2 4 6 8 10]#numpy.unique 函数用于去除数组中的重复元素。
#numpy.unique(arr, return_index, return_inverse, return_counts)
#arr输入数组如果不是一维数组则会展开
#return_index如果为true返回新列表元素在旧列表中的位置下标并以列表形式储
#return_inverse如果为true返回旧列表元素在新列表中的位置下标并以列表形式储
#return_counts如果为true返回去重数组中的元素在原数组中的出现次数
a np.array([5,2,6,2,7,5,6,8,2,9])print (第一个数组)
print (a)
print (\n)print (第一个数组的去重值)
u np.unique(a)
print (u)
print (\n)print (去重数组的索引数组)
u,indices np.unique(a, return_index True)
print (indices)
print (\n)print (我们可以看到每个和原数组下标对应的数值)
print (a)
print (\n)print (去重数组的下标)
u,indices np.unique(a,return_inverse True)
print (u)
print (\n)print (下标为)
print (indices)
print (\n)print (使用下标重构原数组)
print (u[indices])
print (\n)print (返回去重元素的重复数量)
u,indices np.unique(a,return_counts True)
print (u)
print (indices)第一个数组
[5 2 6 2 7 5 6 8 2 9] 第一个数组的去重值
[2 5 6 7 8 9]去重数组的索引数组
[1 0 2 4 7 9]我们可以看到每个和原数组下标对应的数值
[5 2 6 2 7 5 6 8 2 9]去重数组的下标
[2 5 6 7 8 9]下标为
[1 0 2 0 3 1 2 4 0 5]使用下标重构原数组
[5 2 6 2 7 5 6 8 2 9]返回去重元素的重复数量
[2 5 6 7 8 9]
[3 2 2 1 1 1]Numpy算术函数
NumPy 算术函数包含简单的加减乘除: add()subtract()multiply() 和 divide()。需要注意的是数组必须具有相同的形状或符合数组广播规则。numpy.reciprocal() 函数返回参数逐元素的倒数。如 1/4 倒数为 4/1numpy.power() 函数将第一个输入数组中的元素作为底数计算它与第二个输入数组中相应元素的幂。numpy.mod() 计算输入数组中相应元素的相除后的余数。 函数 numpy.remainder() 也产生相同的结果。
import numpy as np a np.arange(9, dtype np.float_).reshape(3,3)
print (第一个数组)
print (a)
print (\n)
print (第二个数组)
b np.array([10,10,10])
print (b)
print (\n)
print (两个数组相加)
print (np.add(a,b))
print (\n)
print (两个数组相减)
print (np.subtract(a,b))
print (\n)
print (两个数组相乘)
print (np.multiply(a,b))
print (\n)
print (两个数组相除)
print (np.divide(a,b))第一个数组
[[0. 1. 2.][3. 4. 5.][6. 7. 8.]] 第二个数组
[10 10 10] 两个数组相加
[[10. 11. 12.][13. 14. 15.][16. 17. 18.]]两个数组相减
[[-10. -9. -8.][ -7. -6. -5.][ -4. -3. -2.]] 两个数组相乘
[[ 0. 10. 20.][30. 40. 50.][60. 70. 80.]] 两个数组相除
[[0. 0.1 0.2][0.3 0.4 0.5][0.6 0.7 0.8]]Numpy 统计函数 NumPy 提供了很多统计函数用于从数组中查找最小元素最大元素百分位标准差和方差等。 numpy.amin() 和 numpy.amax() numpy.amin() 用于计算数组中的元素沿指定轴的最小值。 numpy.ptp() 函数计算数组中元素最大值与最小值的差最大值 - 最小值。 numpy.amin(a, axisNone, outNone, keepdimsno value, initialno value, whereno value) numpy.median() 函数用于计算数组 a 中元素的中位数中值 numpy.percentile() 百分位数是统计中使用的度量表示小于这个值的观察值的百分比。 函数numpy.percentile()接受以下参数。 numpy.average() 函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。 np.std 计算标准差 np.var 计算方差 参数说明 a: 输入的数组可以是一个NumPy数组或类似数组的对象。 axis: 可选参数用于指定在哪个轴上计算最小值。如果不提供此参数则返回整个数组的最小值。可以是一个整数表示轴的索引也可以是一个元组表示多个轴。 out: 可选参数用于指定结果的存储位置。 keepdims: 可选参数如果为True将保持结果数组的维度数目与输入数组相同。如果为False默认值则会去除计算后维度为1的轴。 initial: 可选参数用于指定一个初始值然后在数组的元素上计算最小值。 where: 可选参数一个布尔数组用于指定仅考虑满足条件的元素。 numpy.percentile() 参数说明 a: 输入数组 q: 要计算的百分位数在 0 ~ 100 之间 axis: 沿着它计算百分位数的轴 numpy.median() numpy.median(a, axisNone, outNone, overwrite_inputFalse, keepdimsno value) 参数说明 a: 输入的数组可以是一个 NumPy 数组或类似数组的对象。 axis: 可选参数用于指定在哪个轴上计算中位数。如果不提供此参数则计算整个数组的中位数。可以是一个整数表示轴的索引也可以是一个元组表示多个轴。 out: 可选参数用于指定结果的存储位置。 overwrite_input: 可选参数如果为True则允许在计算中使用输入数组的内存。这可能会在某些情况下提高性能但可能会修改输入数组的内容。 keepdims: 可选参数如果为True将保持结果数组的维度数目与输入数组相同。如果为False默认值则会去除计算后维度为1的轴。 numpy.average() numpy.average(a, axisNone, weightsNone, returnedFalse) 该函数可以接受一个轴参数。 如果没有指定轴则数组会被展开。 加权平均值即将各数值乘以相应的权数然后加总求和得到总体值再除以总的单位数。 考虑数组[1,2,3,4]和相应的权重[4,3,2,1]通过将相应元素的乘积相加并将和除以权重的和来计算加权平均值。 参数说明 a: 输入的数组可以是一个 NumPy 数组或类似数组的对象。 axis: 可选参数用于指定在哪个轴上计算加权平均值。如果不提供此参数则计算整个数组的加权平均值。可以是一个整数表示轴的索引也可以是一个元组表示多个轴。 weights: 可选参数用于指定对应数据点的权重。如果不提供权重数组则默认为等权重。 returned: 可选参数如果为True将同时返回加权平均值和权重总和。 a np.array([[3,7,5],[8,4,3],[2,4,9]])
print (我们的数组是)
print (a)
print (\n)
print (调用 amin() 函数)
print (np.amin(a,1))
print (\n)
print (再次调用 amin() 函数)
print (np.amin(a,0))
print (\n)
print (调用 amax() 函数)
print (np.amax(a))
print (\n)
print (再次调用 amax() 函数)
print (np.amax(a, axis 0))我们的数组是
[[3 7 5][8 4 3][2 4 9]]调用 amin() 函数
[3 3 2] 再次调用 amin() 函数
[2 4 3] 调用 amax() 函数
9再次调用 amax() 函数
[8 7 9]Numpy排序、条件筛选函数 NumPy 提供了多种排序的方法。 这些排序函数实现不同的排序算法每个排序算法的特征在于执行速度最坏情况性能所需的工作空间和算法的稳定性。 numpy.sort() 函数返回输入数组的排序副本。函数格式如下 numpy.sort(a, axis, kind, order) 参数说明 a: 要排序的数组 axis: 沿着它排序数组的轴如果没有数组会被展开沿着最后的轴排序 axis0 按列排序axis1 按行排序 kind: 默认为’quicksort’快速排序 order: 如果数组包含字段则是要排序的字段 numpy.argsort() 函数返回的是数组值从小到大的索引值。 numpy.lexsort() numpy.lexsort() 用于对多个序列进行排序。把它想象成对电子表格进行排序每一列代表一个序列排序时优先照顾靠后的列。这里举一个应用场景小升初考试重点班录取学生按照总成绩录取。在总成绩相同时数学成绩高的优先录取在总成绩和数学成绩都相同时按照英语成绩录取…… 这里总成绩排在电子表格的最后一列数学成绩在倒数第二列英语成绩在倒数第三列。 函数描述msort(a)数组按第一个轴排序返回排序后的数组副本。np.msort(a) 相等于 np.sort(a, axis0)sort_complex(a)对复数按照先实部后虚部的顺序进行排序。partition(a, kth[, axis, kind, order])指定一个数对数组进行分区argpartition(a, kth[, axis, kind, order])可以通过关键字 kind 指定算法沿着指定轴对数组进行分区
条件筛选 numpy.argmax() 和 numpy.argmin()函数分别沿给定轴返回最大和最小元素的索引。 numpy.where() 函数返回输入数组中满足给定条件的元素的索引。 numpy.extract() 函数根据某个条件从数组中抽取元素返回满条件的元素。 a np.array([[3,7],[9,1]])
print (我们的数组是)
print (a)
print (\n)
print (调用 sort() 函数)
print (np.sort(a))
print (\n)
print (按列排序)
print (np.sort(a, axis 0))
print (\n)
# 在 sort 函数中排序字段
dt np.dtype([(name, S10),(age, int)])
a np.array([(raju,21),(anil,25),(ravi, 17), (amar,27)], dtype dt)
print (我们的数组是)
print (a)
print (\n)
print (按 name 排序)
print (np.sort(a, order name))我们的数组是
[[3 7][9 1]]调用 sort() 函数
[[3 7][1 9]] 按列排序
[[3 1][9 7]] 我们的数组是
[(braju, 21) (banil, 25) (bravi, 17) (bamar, 27)] 按 name 排序
[(bamar, 27) (banil, 25) (braju, 21) (bravi, 17)]x np.array([3, 1, 2])
print (我们的数组是)
print (x)
print (\n)
print (对 x 调用 argsort() 函数)
y np.argsort(x)
print (y)
print (\n)
print (以排序后的顺序重构原数组)
print (x[y])
print (\n)
print (使用循环重构原数组)
for i in y: print (x[i], end )我们的数组是
[3 1 2] 对 x 调用 argsort() 函数
[1 2 0]以排序后的顺序重构原数组
[1 2 3] 使用循环重构原数组
1 2 3 nm (raju,anil,ravi,amar)
dv (f.y., s.y., s.y., f.y.)
ind np.lexsort((dv,nm))
print (调用 lexsort() 函数)
print (ind)
print (\n)
print (使用这个索引来获取排序后的数据)
print ([nm[i] , dv[i] for i in ind])调用 lexsort() 函数
[3 1 0 2] 使用这个索引来获取排序后的数据
[amar, f.y., anil, s.y., raju, f.y., ravi, s.y.]a np.array([[30,40,70],[80,20,10],[50,90,60]])
print (我们的数组是)
print (a)
print (\n)
print (调用 argmax() 函数)
print (np.argmax(a))
print (\n)
print (展开数组)
print (a.flatten())
print (\n)
print (沿轴 0 的最大值索引)
maxindex np.argmax(a, axis 0)
print (maxindex)
print (\n)
print (沿轴 1 的最大值索引)
maxindex np.argmax(a, axis 1)
print (maxindex)
print (\n)
print (调用 argmin() 函数)
minindex np.argmin(a)
print (minindex)
print (\n)
print (展开数组中的最小值)
print (a.flatten()[minindex])
print (\n)
print (沿轴 0 的最小值索引)
minindex np.argmin(a, axis 0)
print (minindex)
print (\n)
print (沿轴 1 的最小值索引)
minindex np.argmin(a, axis 1)
print (minindex)我们的数组是
[[30 40 70][80 20 10][50 90 60]] 调用 argmax() 函数
7展开数组
[30 40 70 80 20 10 50 90 60] 沿轴 0 的最大值索引
[1 2 0] 沿轴 1 的最大值索引
[2 0 1]调用 argmin() 函数
5 展开数组中的最小值
10 沿轴 0 的最小值索引
[0 1 1]沿轴 1 的最小值索引
[0 2 0]x np.arange(9.).reshape(3, 3)
print (我们的数组是)
print (x)
print ( 大于 3 的元素的索引)
y np.where(x 3)
print (y)
print (使用这些索引来获取满足条件的元素)
print (x[y])我们的数组是
[[0. 1. 2.][3. 4. 5.][6. 7. 8.]]
大于 3 的元素的索引
(array([1, 1, 2, 2, 2]), array([1, 2, 0, 1, 2]))
使用这些索引来获取满足条件的元素
[4. 5. 6. 7. 8.]x np.arange(9.).reshape(3, 3)
print (我们的数组是)
print (x)
# 定义条件, 选择偶数元素
condition np.mod(x,2) 0
print (按元素的条件值)
print (condition)
print (使用条件提取元素)
print (np.extract(condition, x))我们的数组是
[[0. 1. 2.][3. 4. 5.][6. 7. 8.]]
按元素的条件值
[[ True False True][False True False][ True False True]]
使用条件提取元素
[0. 2. 4. 6. 8.]
