数据分析与AI(二) 随机数组抽样/文件I/O创建数组/数组属性/Numpy操作

最新推荐文章于 2024-07-25 23:19:30 发布

刘东灵

最新推荐文章于 2024-07-25 23:19:30 发布

阅读量2.4k

点赞数 1

文章标签： IO anaconda 数据分析

本文链接：https://blog.csdn.net/qq_41637554/article/details/80672265

版权

2.7 随机数组抽样

1.生成随机的整数型矩阵

np.random.randint(low=0,high=150,size=(5,4))

low 表示的是最小值
high 表示最大值
size 是一个元祖类型

# size 矩阵的大小
nd1= np.random.randint(0, 155, size=(5,4))
display(nd1.dtype)
结果是:dtype('int32')

2. 标准的正太分布

np.random.randn(10,5)

没有固定的参数，每多加一个数字，代表多真假一个维度

# 例:大部分人的智力都是90, 小部分人都是低能儿, 小部分人是高智商人.
# 参数d0 dn 代表维度, 多加一个参数就多一个维度
nd2 = np.random.randn(10, 5)
nd2
结果是:
array([[-0.8489571 ,  0.51821312, -0.6550697 , -0.33521889,  0.94651572],
       [ 0.25128899,  0.75854213,  0.73179889, -0.11297148, -0.78149397],
       [ 1.57605235, -0.80053275, -0.0068536 , -0.80854969, -0.2299157 ],
       [ 0.17122183,  0.19824857, -1.16908545, -1.10964545, -1.22386257],
       [ 0.59340472, -0.55875122, -0.65641758, -1.21797026, -0.41746614],
       [-0.32936843,  0.27257721, -1.02884539, -0.57746141,  2.08187182],
       [ 1.54040499,  1.64976728,  0.72227348,  0.35484923,  1.19315074],
       [ 1.31281058,  0.57246404, -1.44762172, -1.33602896,  0.14879116],
       [-0.48039317, -1.87738284,  1.63149452,  1.3489151 , -0.40290169],
       [-0.01723886,  0.81477275,  1.72386292, -0.31939171,  0.4088506 ]])

3.随机抽样

np.random.random(size=(456,730,3)) 默认生成是float64

size 表示形状random随机生成的范围是0-1之间,

nd3.dtype
结果是:
dtype('float64')
-------------------------------------
# png的颜色范围在(0-1)之间
nd3 = np.random.random(size=(456,730,3))
nd3
plt.imshow(nd3)

这里写图片描述

4.标准方差，代表数据的稳定性

np.random.normal(loc=170,scale=100,size=50)

normal也是一个正太分布的方法

生成一个一维数组
- location 是定位的的值
- scale 是波动值
- size 是数据长度

nd4 = np.random.normal(loc=200, scale=100,size=50)
nd4
结果是:
array([180.71156882, 251.05015405, 334.52996995, 223.22199626,
        56.31400958, 128.45016459, 133.16540203, 241.72272411,
       296.19863356, 156.00434429, 125.29330723, 219.17569876,
       191.05367733, 148.42350679, 170.41723537, 339.92909875,
       141.98958125, 152.90126245, 230.65905822, 286.99492214,
       306.97007295, 117.95152467, 382.00208092, 186.5986273 ,
       -89.63654978, 208.08404756, 194.67009455, 215.60317624,
       260.14283542, 111.50755648,  78.00456245,   4.75714254,
       222.70801223, 286.67382188, 215.31854487, 185.53597978,
        88.44333112, 213.4927317 ,  80.26602338, 193.07378751,
       147.7084355 , 249.86773285, 174.78972063, 263.00123775,
       260.11807929, 307.27318389, 121.56349305, 208.06732338,
       170.43848459, 335.338501  ])

5.随机数

每一个数据，都是一个维度

rand 和 random 的区别: random 需要size来描述形状, 而rand只需要我们直接给值, 通过值的数量来确定形状

np.random.rand(d1,d2,dn)

nd5=np.random.rand(456,730,3)
nd5
结果是:
array([[[0.81338378, 0.03740836, 0.3270853 ],
        [0.27245028, 0.56740596, 0.82578736],
        [0.63028577, 0.06605075, 0.74904245],
        ...,
        [0.30721617, 0.115466  , 0.15504922],
        [0.98619599, 0.52817227, 0.61275576],
        [0.37855532, 0.98052484, 0.28738656]],

       [[0.62319226, 0.50358549, 0.95729481],
        [0.80957454, 0.82355522, 0.5109785 ],
        [0.30567372, 0.05171768, 0.47681308],
        ...,
        [0.17513673, 0.48579024, 0.61889992],
        [0.81530782, 0.95324938, 0.58154069],
        [0.76539606, 0.72311614, 0.27481812]],

       [[0.04357083, 0.5916054 , 0.32462856],
        [0.81834577, 0.71680229, 0.74785909],
        [0.35816876, 0.90326284, 0.8787488 ],
        ...,
        [0.39508818, 0.40119848, 0.39892247],
        [0.78144794, 0.61817416, 0.80875489],
        [0.01203324, 0.48362799, 0.61209354]],

       ...,

       [[0.96217852, 0.01214236, 0.79620097],
        [0.3452839 , 0.36247124, 0.78556409],
        [0.89675665, 0.09345151, 0.32433307],
        ...,
        [0.2578449 , 0.98930428, 0.62480416],
        [0.58948533, 0.73419266, 0.78654073],
        [0.62454962, 0.82320083, 0.11942074]],

       [[0.8048578 , 0.06622984, 0.98684006],
        [0.87588824, 0.72121524, 0.58791674],
        [0.16904453, 0.33205887, 0.30523613],
        ...,
        [0.25534536, 0.73197293, 0.98591776],
        [0.94549008, 0.45965548, 0.07481192],
        [0.24002098, 0.93848423, 0.69247494]],

       [[0.17578667, 0.36010804, 0.57344193],
        [0.31283208, 0.56406035, 0.89509084],
        [0.95860462, 0.2623533 , 0.60973316],
        ...,
        [0.25604989, 0.83529158, 0.12301698],
        [0.27790365, 0.00950821, 0.35453816],
        [0.83390323, 0.29364845, 0.37663203]]])
-------------------------------
plt.imshow(nd5)
# 结果是:

这里写图片描述

2.9 linspace 与 logspace

linspace是线性生成的，是全闭区间

nd6 = np.linspace(0,150, num=151)
nd6
# 结果是:
array([  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.,  35.,  36.,  37.,  38.,  39.,  40.,  41.,  42.,  43.,
        44.,  45.,  46.,  47.,  48.,  49.,  50.,  51.,  52.,  53.,  54.,
        55.,  56.,  57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,  65.,
        66.,  67.,  68.,  69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,
        77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,  85.,  86.,  87.,
        88.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,  97.,  98.,
        99., 100., 101., 102., 103., 104., 105., 106., 107., 108., 109.,
       110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120.,
       121., 122., 123., 124., 125., 126., 127., 128., 129., 130., 131.,
       132., 133., 134., 135., 136., 137., 138., 139., 140., 141., 142.,
       143., 144., 145., 146., 147., 148., 149., 150.])

logspace是线性生成，并且以什么为底

start从几开始
stop 到数字结尾
num 生成多少个数
base 表示的是底数默认以10为底

nd7 = np.logspace(0, 20, num=21, base=np.e)
nd7
结果是:
array([1.00000000e+00, 2.71828183e+00, 7.38905610e+00, 2.00855369e+01,
       5.45981500e+01, 1.48413159e+02, 4.03428793e+02, 1.09663316e+03,
       2.98095799e+03, 8.10308393e+03, 2.20264658e+04, 5.98741417e+04,
       1.62754791e+05, 4.42413392e+05, 1.20260428e+06, 3.26901737e+06,
       8.88611052e+06, 2.41549528e+07, 6.56599691e+07, 1.78482301e+08,
       4.85165195e+08])

2.11 diag

np.diag构建对角矩阵构建对角矩阵 np.diag(v,k=0)参数为列表即可

v可以是一维或二维的矩阵
k<0表示斜线在矩阵的下方
k>0表示斜线在矩阵的上方

# 满秩矩阵
np.diag([1,2,3], 0)
# 结果是:
array([[1, 0, 0],
       [0, 2, 0],
       [0, 0, 3]])

2.12 文件 I/O 创建数组

2.12.1CSV

csv,dat是一种常用的数据格式化文件类型，为了从中读取数据，我们使用

#使用 `numpy.savetxt` 我们可以将 Numpy 数组保存到csv文件中:
M = np.random.rand(3,3)
# 不管给什么样的后缀名, 都会以TXT的格式进行储存
np.savetxt("random-matrix.dat", M)
#函数。

# wget http://labfile.oss.aliyuncs.com/courses/348/stockholm_td_adj.dat  
import numpy as np  

data1=np.genfromtxt('./random-matrix.dat')
print(data1.shape) #(3.3)

data2=np.loadtxt('./random-matrix.dat')
print(data2.shape)  #(3.3)

data3=np.mafromtxt('./random-matrix.dat')
print(data3.shape)  #(3.3)

data4=np.ndfromtxt('./random-matrix.dat')
print(data4.shape) #(3.3)

data5=np.recfromtxt('./random-matrix.dat')
print(data5.shape) #(3.3)

2.12.2 Numpy 原生文件类型

使用 numpy.save 与 numpy.load 保存和读取：

a=np.save("random-matrix-1.npy", M)  
np.load("random-matrix-1.npy") 
# 结果是:
array([[0.68592427, 0.72218203, 0.69622066],
       [0.37879551, 0.341962  , 0.72276067],
       [0.4118364 , 0.87964093, 0.9167516 ]])

3、`ndarray` 数组属性

ndim,shape,size

ndim 数组的维度（自己会计算）
shape 形状（5,4，3）
size 数组的总长度
dtype 查看数据类型

[[[1, 2, 3],[1, 2, 3],[1, 2, 3]],[[1, 2, 3],[1, 2, 3],[1, 2, 3]],[[1, 2, 3],[1, 2, 3],[1, 2, 3]]]

nd1 = np.array([[[1, 2, 3],[1, 2, 3],[1, 2, 3]],[[1, 2, 3],[1, 2, 3],[1, 2, 3]],[[1, 2, 3],[1, 2, 3],[1, 2, 3]]])
nd1.shape
结果是:(3, 3, 3)
nd1.dtype
结果是:dtype('int32')
nd1.ndim
结果是:3
nd1.size
结果是:27  (3*3*3)

3.1 `ndarray.T`

ndarray.T用于数组的转置，与 .transpose() 相同。

nd1.T
结果是:
array([[[1, 1, 1],
        [1, 1, 1],
        [1, 1, 1]],

       [[2, 2, 2],
        [2, 2, 2],
        [2, 2, 2]],

       [[3, 3, 3],
        [3, 3, 3],
        [3, 3, 3]]])

3.3`ndarray.imag`

ndarray.imag 用来输出数组包含元素的虚部。

imaginary number 虚数

nd1.imag
结果是:
array([[[0, 0, 0],
        [0, 0, 0],
        [0, 0, 0]],

       [[0, 0, 0],
        [0, 0, 0],
        [0, 0, 0]],

       [[0, 0, 0],
        [0, 0, 0],
        [0, 0, 0]]])

3.4`ndarray.real`

ndarray.real用来输出数组包含元素的实部。

real number 实数

nd1.real
结果是:
array([[[1, 2, 3],
        [1, 2, 3],
        [1, 2, 3]],

       [[1, 2, 3],
        [1, 2, 3],
        [1, 2, 3]],

       [[1, 2, 3],
        [1, 2, 3],
        [1, 2, 3]]])

3.5`ndarray.itemsize`

ndarray.itemsize输出一个数组元素的字节数。

nd1.dtype
结果是: int32
# int32 -- > int 4个字节
nd1.itemsize
结果是: 4

3.6 `ndarray.nbytes`

ndarray.nbytes用来输出数组的元素总字节数。

nd1.size
结果是:27
# 27个基本元素, 每个元素都是int32类型, 占用4个字节,即27*4=108
nd1.nbytes
结果是:108

3.7 `ndarray.strides`

ndarray.strides用来遍历数组时，输出每个维度中步进的字节元组。

nd1.shape
结果是:(3,3,3)
# 第一个是最外层数组, 占用4个字节, 第二维有3个 3*4  第三维也有3个元素 3*4*3
nd1.strides[::-1]
结果是:(4,12,36)

4、Numpy 数组的基本操作

4.0.1索引

一维与列表完全一致

# png的图片的RGB取值范围是0 - 1 之间
# 彩色的图片是三维的数组, 黑白图片是二维的数组
fish = plt.imread('./fish.png')
plt.imshow(fish)
# 结果如下: 这是正常的图片

这里写图片描述

案例：颠倒图片

ndd = np.random.randint(0,155,size=(5,4))
ndd
# 结果如下:
array([[ 60,  62,  62, 104],
       [ 10,  79,  59,  83],
       [136,  96,  51,  48],
       [122, 104,   4, 154],
       [154,  31, 125,  62]])
# 将该二维数组上下颠倒, 左右颠倒
ndd[::-1,::-1]
# 结果如下:
array([[ 62, 125,  31, 154],
       [154,   4, 104, 122],
       [ 48,  51,  96, 136],
       [ 83,  59,  79,  10],
       [104,  62,  62,  60]])
# 将上面的图片鱼左右进行颠倒
fish1 = fish[:,::-1]
plt.imshow(fish1)
# 结果如下:

这里写图片描述

# 把fish1给上下颠倒
fish2 = fish1[::-1]
plt.imshow(fish2)
# 结果如下

这里写图片描述

# RGB进行颠倒, 也就是将第三维进行颠倒
fish3 = fish2[:,:,::-1]
plt.imshow(fish3)
# 结果如下:

这里写图片描述

案例:把鱼头换成狗头

fish = plt.imread('./fish.png')
dog = plt.imread('dog.jpg')
fish.shape
# 结果是(326,243,3)
dog.shape
# 结果是(300,313,3)

#fish是png             #dog是jpg
# 将fish的部分替换成dog的部分, 因为dog是jpg的文件, 要除以255让其RGB在0~1之间
dogface_fish = fish[50:150,70:190] = dog[50:150, 70:190].astype(np.float32)/255

display(fish.dtype, dog.dtype)
# 结果是: dtype('float32') dtype('uint8')
plt.imshow(fish) 
# 结果是:

这里写图片描述

# 生成一张随机的图片, 然后替换到鱼的头部
# randint(0-255, dtype=uint8) 三维
x1 = np.random.randint(0,255,size=(326,243,3))
# 或者x1 = np.random.randint(0,255,size=(100,120,3)) 由 150-50 190-70 得出 
fish[50:150,70:190] = x1[50:150, 70:190].astype(np.float32) /255
plt.imshow(fish)
# 结果是:

这里写图片描述

4.1 重设形状

reshape 可以在不改变数组数据的同时，改变数组的形状。其中，numpy.reshape() 等效于 ndarray.reshape()。reshape方法非常简单：

nd1= np.random.randint(0,150,size=(5,4))
nd1
结果是:
array([[ 32, 136,  49,  64],
       [  6, 120, 114,  66],
       [ 22,  49,  17, 103],
       [130, 147,  47,  76],
       [ 93,  29, 125,  59]])
# reshape(value) val 可以是单个值, 这个值可以是list, 也可以是tuple
# 如果是多个值, 这两个值的乘积要等于以前的值的成绩
nd1.reshape(10,2)
结果是:
array([[ 32, 136],
       [ 49,  64],
       [  6, 120],
       [114,  66],
       [ 22,  49],
       [ 17, 103],
       [130, 147],
       [ 47,  76],
       [ 93,  29],
       [125,  59]])

4.2.1 数组展开

ravel 的目的是将任意形状的数组扁平化，变为 1 维数组。ravel 方法如下：

# 将数组变为一维, 这种方式在数据中叫做扁平化
nd1.ravel()
nd1.reshape(20)一样
# 以上2个方法结果一样
# 结果是:
array([ 94,  74,  36, 148,   7, 142,  74,  61, 145,  10, 107,  26, 128,
        47, 129,  84,  55,  85,  12,  99])

4. 2.2级联

np.concatenate() 级联需要注意的点：
级联的参数是列表：一定要加中括号或小括号
维度必须相同
形状相符
【重点】级联的方向默认是shape这个tuple的第一个值所代表的维度方向
可通过axis参数改变级联的方向，默认为0, （0表示列相连,表示的X轴的事情，1表示行相连,Y轴的事情）

nd2 = np.random.randint(0,15,size=(5,4))
nd3 = np.random.randint(0,15,size=(2,4))
# axis 默认值是0, 表示的是对Y轴进行合并, 或者说是垂直合并
# 垂直合并影响的是列, 那么也就是说, 列的个数必须相等
np.concatenate((nd2,nd3))
# 结果是:
array([[ 6,  0,  3,  2],
       [ 2,  0,  0, 14],
       [ 3,  6,  5, 13],
       [ 3,  4, 12,  0],
       [13, 12,  5,  2],
       [13,  1, 14,  7],
       [11,  1,  9,  8]])
------------------------------
# axis值是1 , 表示的是对X周进行合并, 或者说是水平合并
# 水平合并影响的是行, 那么也就是说, 行的个数必须相等
nd3 = np.random.randint(0,15,size=(5,2))
np.concatenate((nd2,nd3), axis=1)
# 结果是:
array([[ 6,  0,  3,  2, 13, 11],
       [ 2,  0,  0, 14,  9, 14],
       [ 3,  6,  5, 13,  0,  4],
       [ 3,  4, 12,  0, 13,  1],
       [13, 12,  5,  2, 12, 12]])

将猫和狗的图片合并

cat = plt.imread('cat.jpg')
dog = plt.imread('dog.jpg')
cat.shape
# 结果是: (456,730,3)
dog.shape
# 结果是: (300, 313, 3)
------------------------
# 猫和狗怎么进行级联
# 首先把猫的图片进行切割和狗行或者列相同的数组
cat1= cat[50:350,100:413]
cat1.shape
# 结果是: (300,313,3)
cat_dog = np.concatenate((dog,cat1))
plt.imshow(cat_dog)
# 结果如下(垂直合并) 水平合并以此类推:

这里写图片描述

4.2.3 numpy.[hstack|vstack]

分别代表水平级联与垂直级联,填入的参数必须被小括号或中括号包裹

vertical垂直的 horizontal水平的 stack层积

这两个函数的值也是一个list 或 tuple

dc = np.hstack((cat1,dog))
plt.imshow(dc)
# 结果如下:

这里写图片描述

cd = np.vstack((cat1,dog))
plt.imshow(dc)
# 结果如下:

这里写图片描述

4.2.4分割数组

numpy.split(array,[index1,index2,…..]，axis)

axis默认值为0，表示垂直轴，如果值为1，表示水平的轴

注意: indices_or_sections -> [100,200]列表中有两个值, 第一个值代表0: 100, 第二个值代表101:200, 最后一个值代表 201:最后

会产生三个值, 三个值需要三个变量来接收

例题，将猫水平切成3份

# cat1, cat2, cat3 = np.vsplit(cat,[100,200]) 这个方法与下面的方法效果一样
cat1, cat2, cat3 = np.split(cat,[100,200])
# show是用于图形显示的, 不给值就是空的
plt.imshow(cat1)
plt.show()
plt.imshow(cat2)
plt.show()
plt.imshow(cat3)
# 结果如下:

这里写图片描述

例题，将猫垂直切成3份

# cat1,cat2,cat3= np.hsplit(cat,[200,400]) 这个方法与下面方面效果一样
cat1,cat2,cat3= np.split(cat,[200,400], axis=1)
plt.imshow(cat1)
plt.show()
plt.imshow(cat2)
plt.show()
plt.imshow(cat3)
# 结果如下:

这里写图片描述

4.2.5副本

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

可使用ndarray.copy()函数创建副本

cat2 = cat.copy()
display(id(cat2), id(cat))
# 结果如下:
190400912
156310224

4.2.6 ndarray的聚合函数

1. 求和np.sum

ndarray.sum(axis),axis不写则为所有的元素求和，为0表示列求和，1表示行求和

one = np.ones((5,4))
#axis = 0 我们认为是数组的第一层, 1就是数组的第二层关系, 
# axis 不设置值的话就是全部求和
one.sum(axis=1)
# 结果是 array([4., 4., 4., 4., 4.])

1. 求4维矩阵中最后两维的和

one_ = np.ones((3,3,3,3))
# axis的值可以是一个元组, 最后一维我们可以用-1来表示, -2可以用来表示倒数第二维
one_.sum(axis=(-1,-2))
# 结果是:
array([[9., 9., 9.],
       [9., 9., 9.],
       [9., 9., 9.]])

2. 最大最小值：np.max/ np.min

cat.max(axis=0)
# 结果是:
array([[236, 191, 136],
       [235, 190, 135],
       [235, 190, 135],
       ...,
       [191, 102,  67],
       [189, 103,  65],
       [189, 103,  65]], dtype=uint8)
cat.min()
# 结果是:
0

3.平均值:np.mean()

cat.mean(axis=0)
# 结果是:
array([[170.19298246, 116.40570175,  88.49122807],
       [170.52412281, 116.66666667,  88.75877193],
       [171.08991228, 117.36622807,  89.33114035],
       ...,
       [105.55921053,  54.24122807,  47.26754386],
       [100.9122807 ,  50.99122807,  44.29824561],
       [ 98.85087719,  50.05701754,  43.26973684]])

案例:将猫的图片黑白

plt.imshow(cat)
cat.shape
# 结果是: (456,730,3)

#1. 第一种方法, 去掉第三维
cat2 = cat.reshape(456,730*3)
plt.imshow(cat2, cmap='gray')
# 结果如下:

这里写图片描述

#2. 第二种方法, 求cat.的x轴或者y轴的最大值或者最小值,得到返回的结果是一个二维数组
# 图片的第三维中的值怎么给它去掉, 求最大值(偏白, RGB靠近255)
cat3 = cat.max(axis=2)
cat3
# 结果是:
array([[231, 232, 233, ..., 100,  92,  85],
       [232, 232, 233, ..., 100,  92,  84],
       [232, 233, 233, ...,  99,  91,  83],
       ...,
       [199, 199, 200, ..., 189, 187, 187],
       [199, 199, 199, ..., 188, 186, 188],
       [199, 199, 199, ..., 188, 188, 188]], dtype=uint8)

# cmap='color'  黑白图片使用gray
plt.imshow(cat3, cmap='gray')
# 结果如下:

这里写图片描述

# 用最小值处理(偏黑, RGB靠近0)
cat4 = cat.min(axis=2)
plt.imshow(cat4, cmap='gray')
# 结果如下;

这里写图片描述

cmap可选参数:
cmap类型:Accent, Accent_r, Blues, Blues_r, BrBG, BrBG_r, BuGn, BuGn_r, BuPu, BuPu_r, CMRmap, CMRmap_r, Dark2, Dark2_r, GnBu, GnBu_r, Greens, Greens_r, Greys, Greys_r, OrRd, OrRd_r, Oranges, Oranges_r, PRGn, PRGn_r, Paired, Paired_r, Pastel1, Pastel1_r, Pastel2, Pastel2_r, PiYG, PiYG_r, PuBu, PuBuGn, PuBuGn_r, PuBu_r, PuOr, PuOr_r, PuRd, PuRd_r, Purples, Purples_r, RdBu, RdBu_r, RdGy, RdGy_r, RdPu, RdPu_r, RdYlBu, RdYlBu_r, RdYlGn, RdYlGn_r, Reds, Reds_r, Set1, Set1_r, Set2, Set2_r, Set3, Set3_r, Spectral, Spectral_r, Vega10, Vega10_r, Vega20, Vega20_r, Vega20b, Vega20b_r, Vega20c, Vega20c_r, Wistia, Wistia_r, YlGn, YlGnBu, YlGnBu_r, YlGn_r, YlOrBr, YlOrBr_r, YlOrRd, YlOrRd_r, afmhot, afmhot_r, autumn, autumn_r, binary, binary_r, bone, bone_r, brg, brg_r, bwr, bwr_r, cool, cool_r, coolwarm, coolwarm_r, copper, copper_r, cubehelix, cubehelix_r, flag, flag_r, gist_earth, gist_earth_r, gist_gray, gist_gray_r, gist_heat, gist_heat_r, gist_ncar, gist_ncar_r, gist_rainbow, gist_rainbow_r, gist_stern, gist_stern_r, gist_yarg, gist_yarg_r, gnuplot, gnuplot2, gnuplot2_r, gnuplot_r, gray, gray_r, hot, hot_r, hsv, hsv_r, inferno, inferno_r, jet, jet_r, magma, magma_r, nipy_spectral, nipy_spectral_r, ocean, ocean_r, pink, pink_r, plasma, plasma_r, prism, prism_r, rainbow, rainbow_r, seismic, seismic_r, spectral, spectral_r, spring, spring_r, summer, summer_r, tab10, tab10_r, tab20, tab20_r, tab20b, tab20b_r, tab20c, tab20c_r, terrain, terrain_r, viridis, viridis_r, winter, winter_r

#用平均值处理(比较自然)
cat5 = cat.mean(axis=2)
plt.imshow(cat5, cmap='terrain_r')
# 结果如下:

这里写图片描述

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 幂运算
np.argwhere(nd1<0)

nd1= np.random.randint(0,255,size=(5,4))
nd1
# 结果如下:
array([[113, 113,   3, 103],
       [218, 142, 167, 146],
       [218, 163, 253, 198],
       [135, 104,  71, 129],
       [157,  51, 111, 232]])
------------------
cond = nd1.argmax()
nd2 = nd1.reshape(20) 
# 将列表进行平铺后得到的索引值
nd2[cond]
# 结果如下: 253
-----------------------
# argwhere 中 where 相当于mysql中where条件
index = np.argwhere(nd1<104)
index
# 结果如下:
array([[0, 2],
       [0, 3],
       [3, 2],
       [4, 1]], dtype=int64)
# 取出符合条件的值
for i in index:
    print(nd1[i[0], i[1]])
# 结果是:
59
25
7
63
90
39

4.3 轴移动

moveaxis 可以将数组的轴移动到新的位置。其方法如下：

numpy.moveaxis(a, source, destination)

其中：

a：数组。
source：要移动的轴的原始位置。
destination：要移动的轴的目标位置。

nd1= np.array([[1,2,3],[1,2,3],[1,2,3]])
nd1
# 结果是:
array([[1, 2, 3],
       [1, 2, 3],
       [1, 2, 3]])
--------------------
np.moveaxis(nd1,0,1)
# 结果是:
array([[1, 1, 1],
       [2, 2, 2],
       [3, 3, 3]])

4.4 轴交换

和 moveaxis 不同的是，swapaxes 可以用来交换数组的轴。其方法如下：

numpy.swapaxes(a, axis1, axis2)

其中：

a：数组。
axis1：需要交换的轴 1 位置。
axis2：需要与轴 1 交换位置的轴 1 位置。

举个例子：

nd1 = np.random.randint(0,100,size=(5,4,3))
nd1
# 结果是:
array([[[17, 58, 12],
        [27, 83, 68],
        [81,  9, 22],
        [ 2, 91, 92]],

       [[87, 45, 55],
        [79, 89, 12],
        [ 2, 54, 98],
        [28, 19, 21]],

       [[49, 30, 67],
        [73, 64, 94],
        [57, 87, 23],
        [15, 60, 53]],

       [[60,  7, 77],
        [19, 96, 62],
        [25,  7, 62],
        [25, 94, 85]],

       [[ 9, 76, 44],
        [46, 29, 26],
        [39, 21, 98],
        [84, 37, 36]]])
------------------------------
# 将nd1的第1个轴与第3个轴进行交换
np.swapaxes(nd1, 0, 2)
# 结果是:
array([[[17, 87, 49, 60,  9],
        [27, 79, 73, 19, 46],
        [81,  2, 57, 25, 39],
        [ 2, 28, 15, 25, 84]],

       [[58, 45, 30,  7, 76],
        [83, 89, 64, 96, 29],
        [ 9, 54, 87,  7, 21],
        [91, 19, 60, 94, 37]],

       [[12, 55, 67, 77, 44],
        [68, 12, 94, 62, 26],
        [22, 98, 23, 62, 98],
        [92, 21, 53, 85, 36]]])

4.5 数组转置

transpose 类似于矩阵的转置，它可以将 2 维数组的水平轴和垂直交换。其方法如下：

numpy.transpose(a, axes=None)

其中：

a：数组。
axes：该值默认为 none，表示转置。如果有值，那么则按照值替换轴。

# 水平轴和垂直轴进行交换
nd1.transpose()
# 结果是:
array([[[17, 87, 49, 60,  9],
        [27, 79, 73, 19, 46],
        [81,  2, 57, 25, 39],
        [ 2, 28, 15, 25, 84]],

       [[58, 45, 30,  7, 76],
        [83, 89, 64, 96, 29],
        [ 9, 54, 87,  7, 21],
        [91, 19, 60, 94, 37]],

       [[12, 55, 67, 77, 44],
        [68, 12, 94, 62, 26],
        [22, 98, 23, 62, 98],
        [92, 21, 53, 85, 36]]])