Python——Numpy基础分析（2）

Cherry晴

已于 2024-06-17 16:53:08 修改

阅读量36

点赞数

分类专栏： Python 文章标签： python numpy 开发语言

于 2024-05-09 17:56:41 首次发布

本文链接：https://blog.csdn.net/qinftian/article/details/138537827

版权

Python 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

接上文Python——葡萄品质数据Numpy基础分析（1）

三、改变数组阵列

1.对数组进行转置——transpose函数或T方法

方法一：transpose函数

numpy.transpose(arr, axes)

（1）arr：要操作的数组；

（2）axes：整数列表，对应维度，通常所有维度都会对换。

# 1.运用transpose函数将二维数组进行翻转
np.transpose(wines1)  

# 2.得到的结果为
array([[ 7.4  ,  7.8  ,  7.8  , ...,  6.3  ,  5.9  ,  6.   ],
       [ 0.7  ,  0.88 ,  0.76 , ...,  0.51 ,  0.645,  0.31 ],
       [ 0.   ,  0.   ,  0.04 , ...,  0.13 ,  0.12 ,  0.47 ],
       ...,
       [ 0.56 ,  0.68 ,  0.65 , ...,  0.75 ,  0.71 ,  0.66 ],
       [ 9.4  ,  9.8  ,  9.8  , ..., 11.   , 10.2  , 11.   ],
       [ 5.   ,  5.   ,  5.   , ...,  6.   ,  5.   ,  6.   ]])

方法二：T方法

# 1. 运用T方法将二维数组进行翻转
wines1.T  

# 2.得到的结果为
array([[ 7.4  ,  7.8  ,  7.8  , ...,  6.3  ,  5.9  ,  6.   ],
       [ 0.7  ,  0.88 ,  0.76 , ...,  0.51 ,  0.645,  0.31 ],
       [ 0.   ,  0.   ,  0.04 , ...,  0.13 ,  0.12 ,  0.47 ],
       ...,
       [ 0.56 ,  0.68 ,  0.65 , ...,  0.75 ,  0.71 ,  0.66 ],
       [ 9.4  ,  9.8  ,  9.8  , ..., 11.   , 10.2  , 11.   ],
       [ 5.   ,  5.   ,  5.   , ...,  6.   ,  5.   ,  6.   ]])

transpose与T区别在于：transposeNumPy中的一个函数，而T是一个方法。a是一个多维数组，order是可选参数，用于指定数组的展开顺序。默认情况下，order='C'表示按行的顺序展开数组。

2.将多维数组降为一维

方法一：ravel函数

numpy.ravel(a, order='C')

（1）a：是一个多维数组

（2）order【可选】：用于指定数组的展开顺序。默认情况下，order = 'C'，表示按行的顺序展开数组，order = 'F'，表示按列的顺序展开

# 1.运用ravel函数将多维数组降为一维数组
wines1.ravel()   

# 2.得到的结果为
array([ 7.4 ,  0.7 ,  0.  , ...,  0.66, 11.  ,  6.  ])

# 3.修改参数order为'F'按列进行降维，将每一列接在前一列后
wines1.ravel(order='F')

# 4.得到的结果为
array([7.4, 7.8, 7.8, ..., 6. , 5. , 6. ])

方法二：flatten函数

numpy.flatten(order = 'C')

（1）order【可选】：用于指定数组的展开顺序。默认情况下，order = 'C'，表示按行的顺序展开数组，order = 'F'，表示按列的顺序展开

（2）a.flatten()：a是个数组，a.flatten()就是把a降到一维，默认是按行的方向降。

（3）m.flatten()：m是个矩阵，降维后还是个矩阵，m.A（等效于矩阵.getA()）才变成了数组。

# 1.运用flatten函数将多维数组降为一维数组
wines1.flatten()   

# 2.得到的结果为
array([ 7.4 ,  0.7 ,  0.  , ...,  0.66, 11.  ,  6.  ])

# 3.修改参数order为'F'按列进行降维，将每一列接在前一列后
wines1.flatten(order='F')

# 4.得到的结果
array([7.4, 7.8, 7.8, ..., 6. , 5. , 6. ])

两个函数的区别在于：
ravel返回的结果是一个视图，对此进行修改会改变原始数据集
flatten返回的是一个拷贝，对其进行修改不会影响原始数据集

方法三：reshape函数

numpy.reshape(arr, newshape, order='C')

（1）arr：需要修改形状的数组

（2）newshape：整数或整数数组，新的形状应当兼容原有形状

（3）order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'k' -- 元素在内存中的出现顺序

import numpy as np   # 导入numpy库
 
a = np.arange(8)   # 在0-7中随机生成一个一维数组
print ('原始数组：')
print (a)
print ('\n')
 
b = a.reshape(4,2)   # 将其改成4行两列的二维数组，默认按行排列
print ('修改后的数组：')
print (b)
print ('\n')

c = a.reshape(4,2,order = 'F')  # 将其改成4行两列的二维数组，按列排列
print('修改后的数组(按列)：')
print(c)

得到的结果如下图3-1所示：

方法四：flat函数

numpy.ndarray.flat 是一个数组元素迭代器

import numpy as np   # 导入numpy库
 
a = np.arange(9).reshape(3,3)    # 在0-8中随机生成一个三行三列的二维数组
print ('原始数组：')
for row in a:
    print (row)
print('\n')

#对数组中每个元素都进行处理，可以使用flat属性，该属性是一个数组元素迭代器：
print ('迭代后的数组：')
for i in a.flat:
    print (i)

得到的结果如下图3-2所示：

3.将数组修改成特定列数

可以使用reshape和resize将数据重新排列为指定的行列形状

方法一：reshape函数

将降成一维的数据通过reshape函数恢复原来的形状

# 1.将数组降为一维数组
test=wines1.flatten()   # 将数组降为一维数组

# 2.查看结果
test

# 3.得到的结果为
array([ 7.4 ,  0.7 ,  0.  , ...,  0.66, 11.  ,  6.  ])

# 4.通过reshape函数，将数组恢复原来的形状
test.reshape(1599,12)

# 5.得到的结果为
array([[ 7.4  ,  0.7  ,  0.   , ...,  0.56 ,  9.4  ,  5.   ],
       [ 7.8  ,  0.88 ,  0.   , ...,  0.68 ,  9.8  ,  5.   ],
       [ 7.8  ,  0.76 ,  0.04 , ...,  0.65 ,  9.8  ,  5.   ],
       ...,
       [ 6.3  ,  0.51 ,  0.13 , ...,  0.75 , 11.   ,  6.   ],
       [ 5.9  ,  0.645,  0.12 , ...,  0.71 , 10.2  ,  5.   ],
       [ 6.   ,  0.31 ,  0.47 , ...,  0.66 , 11.   ,  6.   ]])

# 6.通过reshape函数，将数组恢复原先的形状，并且通过order参数来调整数据的排列
test.reshape(1599,12,order = 'F')

# 7.得到的结果为
array([[ 7.4  ,  0.7  ,  0.   , ...,  0.56 ,  9.4  ,  5.   ],
       [ 7.8  ,  0.88 ,  0.   , ...,  0.68 ,  9.8  ,  5.   ],
       [ 7.8  ,  0.76 ,  0.04 , ...,  0.65 ,  9.8  ,  5.   ],
       ...,
       [ 6.3  ,  0.51 ,  0.13 , ...,  0.75 , 11.   ,  6.   ],
       [ 5.9  ,  0.645,  0.12 , ...,  0.71 , 10.2  ,  5.   ],
       [ 6.   ,  0.31 ,  0.47 , ...,  0.66 , 11.   ,  6.   ]])

方法二：resize函数

与reshape相比，resize在参数上一致，但没有返回值，即会直接对原始数据进行修改

# 1.通过resize函数，将数组恢复原来的形状，但其没有返回值，直接修改原始数据
test.resize(1599,12)  

# 2.查看结果
test

# 3.得到的结果为
array([[ 7.4  ,  0.7  ,  0.   , ...,  0.56 ,  9.4  ,  5.   ],
       [ 7.8  ,  0.88 ,  0.   , ...,  0.68 ,  9.8  ,  5.   ],
       [ 7.8  ,  0.76 ,  0.04 , ...,  0.65 ,  9.8  ,  5.   ],
       ...,
       [ 6.3  ,  0.51 ,  0.13 , ...,  0.75 , 11.   ,  6.   ],
       [ 5.9  ,  0.645,  0.12 , ...,  0.71 , 10.2  ,  5.   ],
       [ 6.   ,  0.31 ,  0.47 , ...,  0.66 , 11.   ,  6.   ]])

四、数组拼接方法

方法一：hstack函数

假设计划引入一种新的葡萄酒品质打分方法，同时保留原来的品质得分，则要添加一列新值在原始数组后。
假设初始的新得分都为零值，使用zeros生成一列长度为1599，值全为0的数组。

# 1.使用zeros函数直接生成一列长为1599的全为0的数组
np.zeros((1599,1))

# 2.得到的结果为
array([[0.],
       [0.],
       [0.],
       ...,
       [0.],
       [0.],
       [0.]])

numpy.hstack(tup)——按照列方向进行拼接，生成一个新的数组

（1）tup：是一个元组，包含了所有待堆叠的数组

# 1.使用hstack函数将两个数组拼接起来，是在水平方向上平铺
np.hstack((wines1,np.zeros((1599,1))))  

# 2.得到的结果为
array([[ 7.4  ,  0.7  ,  0.   , ...,  9.4  ,  5.   ,  0.   ],
       [ 7.8  ,  0.88 ,  0.   , ...,  9.8  ,  5.   ,  0.   ],
       [ 7.8  ,  0.76 ,  0.04 , ...,  9.8  ,  5.   ,  0.   ],
       ...,
       [ 6.3  ,  0.51 ,  0.13 , ..., 11.   ,  6.   ,  0.   ],
       [ 5.9  ,  0.645,  0.12 , ..., 10.2  ,  5.   ,  0.   ],
       [ 6.   ,  0.31 ,  0.47 , ..., 11.   ,  6.   ,  0.   ]])

方法二：vstack函数

假设有一种新的红葡萄酒的各指标数据，要将其拼接在原始数组后成为新的一行。
同样假设新的数据为零值，使用zeros生成一行长度为12，值全为零的数组。

# 1.# 使用zeros函数直接生成一列长为1599的全为0的数组
np.zeros((1,12))

# 2.得到的结果为
array([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]])

numpy.vstack(tup)——按照行方向进行拼接，生成一个新的数组

（1）tup：是一个元组，包含了所有待堆叠的数组

# 1.使用vstack函数将两个数组拼接起来，是在竖直方向上堆叠
np.vstack((wines1,np.zeros((1,12))))

# 2.得到的结果为
array([[ 7.4  ,  0.7  ,  0.   , ...,  0.56 ,  9.4  ,  5.   ],
       [ 7.8  ,  0.88 ,  0.   , ...,  0.68 ,  9.8  ,  5.   ],
       [ 7.8  ,  0.76 ,  0.04 , ...,  0.65 ,  9.8  ,  5.   ],
       ...,
       [ 5.9  ,  0.645,  0.12 , ...,  0.71 , 10.2  ,  5.   ],
       [ 6.   ,  0.31 ,  0.47 , ...,  0.66 , 11.   ,  6.   ],
       [ 0.   ,  0.   ,  0.   , ...,  0.   ,  0.   ,  0.   ]])

方法三： concatenate函数

numpy.concatenate((a1,a2,...),axis = 0)

（1）(a1,a2,...)：要合并的数组或字符串列表

（2）axis：指定合并的轴向，取值为0或1，默认为0。当axis=0时，表示按行合并；当axis=1时，表示按列合并

concatenate可以实现hstack和vstack的功能，只需要通过调整参数axis即可

# 1.使用concatenate函数将两个数组拼接起来，可以通过asix的值来设定在什么方向上拼接
#   设定axis为1，将按列拼接新列，等同于hstack。
np.concatenate((wines1,np.zeros((1599,1))),axis = 1)

# 2.得到的结果为
array([[ 7.4  ,  0.7  ,  0.   , ...,  9.4  ,  5.   ,  0.   ],
       [ 7.8  ,  0.88 ,  0.   , ...,  9.8  ,  5.   ,  0.   ],
       [ 7.8  ,  0.76 ,  0.04 , ...,  9.8  ,  5.   ,  0.   ],
       ...,
       [ 6.3  ,  0.51 ,  0.13 , ..., 11.   ,  6.   ,  0.   ],
       [ 5.9  ,  0.645,  0.12 , ..., 10.2  ,  5.   ,  0.   ],
       [ 6.   ,  0.31 ,  0.47 , ..., 11.   ,  6.   ,  0.   ]])

# 3.设定axis为0，按行拼接新行，等同于vstack
np.concatenate((wines1,np.zeros((1,12))),axis=0)

# 4.得到的结果为
array([[ 7.4  ,  0.7  ,  0.   , ...,  0.56 ,  9.4  ,  5.   ],
       [ 7.8  ,  0.88 ,  0.   , ...,  0.68 ,  9.8  ,  5.   ],
       [ 7.8  ,  0.76 ,  0.04 , ...,  0.65 ,  9.8  ,  5.   ],
       ...,
       [ 5.9  ,  0.645,  0.12 , ...,  0.71 , 10.2  ,  5.   ],
       [ 6.   ,  0.31 ,  0.47 , ...,  0.66 , 11.   ,  6.   ],
       [ 0.   ,  0.   ,  0.   , ...,  0.   ,  0.   ,  0.   ]])

注意：无论是使用vstack，hstack还是concatenate进行拼接都要注意，传入的数组必须在指定轴上有相同的维度。例如，要拼接新行到葡萄酒数据中，新的数据必须也为12列，行数上则没有要求。同理，若要拼接新列到葡萄酒数据中，则新数据的行数必须为1599，列数上则没有要求。

五、数组计算

1.单列运算

对某个数组和值进行基本数学运算时（如+、−、∗、/），NumPy会将该运算应用于数组中的每个元素。
例如，认为葡萄酒数据中的品质得分普遍偏低，我们打算将所有葡萄酒的品质得分加10。

# 1.将最后一行的数据提取出来都加10
wines1[:,11] + 10

# 2.得到的结果为
array([15., 15., 15., ..., 16., 15., 16.])

这不会对原始数据进行修改，如果要直接修改原始数据，可以使用+=运算

# 3.将最后一行的数据提取出来都加10
wines1[:,11] += 10 

# 4.查看数据
wines1[:,11]

# 5.得到的结果为
array([15., 15., 15., ..., 16., 15., 16.])

与之对应，也可以使用∗=、/=、−=。例如：想将红葡萄酒的品质得分再翻倍。

# 6.将最后一行的数据提取出来都*2
wines1[:,11] *= 2  

# 7.查看数据
wines1[:,11]

# 8.得到的结果为
array([30., 30., 30., ..., 32., 30., 32.])

2.多列运算

可以在数组之间进行数学运算，这会将操作应用于对应元素
例如，还是想将红葡萄酒的品质得分翻倍，也可以使用品质得分列加品质得分列实现

# 1.将第十一列的数据再次相加
wines1[:,11] + wines1[:,11]  

# 2.得到的结果为
array([60., 60., 60., ..., 64., 60., 64.])

假设想要选择最大化酒精含量和品质的葡萄酒，可以计算各葡萄酒酒精度数乘以品质得分的值

# 3.各葡萄酒酒精度数乘以品质得分的值
wines1[:,10] * wines1[:,11]  

# 4.得到的结果为
array([282., 294., 294., ..., 352., 306., 352.])

3.Numpy数组方法

（1）mean方法——平均分

numpy.mean(a, axis=None, dtype=None, out=None, keepdims=<no value>)

（1）a：输入的数据集，可以是数组或列表

（2）axis：沿着数组的轴计算平均值，默认为None，表示计算整个数组的平均值

（3）dtype：指定输出的数据类型，默认为None

（4）out：指定输出的存储位置，默认为None

（5）keepdims：是否保持维度信息

计算所有品质得分的平均数

# 1.计算平均分
wines1[:,11].mean()

# 2.得到的结果为
31.27204502814259

（2）std方法——标准差

numpy.std(a, axis=None, dtype=None, out=None, ddof=0, keepdims)

（1）a：需要计算标准差的数据集，可以是数组或者列表等数据类型

（2）axis：根据该参数指定的维度计算标准差。默认值为one，表示在整个数组上计算标准差

（3）dtype：输出的数据类型，默认情况下与数组数据类型相同

（4）out：用于放置结果的替代输出数组

（5）ddof：:表示计算标准差时应减去自由度的数目，-1表示N-1，其中I是数据集的大小。默认情况下，ddof=0，表示标准差被除以N

计算品质得分数据的标准差

# 1.计算数据的标准差
wines1[:,11].std()

# 2.得到的结果为
1.6146337539279025

计算整个数组的标准差

# 1.计算整个数组的标准差
wines1.std()

# 2.得到的结果为
17.250360153530316

但这样的计算并没有实际意义，我们可能更想了解每一个变量对应数据的标准差，可以通过设定参数axis为0来实现。

# 1.计算每个变量数据对应的标准差，各葡萄酒酒精度数乘以品质得分的值
wines1.std(axis = 0) 

# 2.得到的结果为
array([1.74055180e+00, 1.79003704e-01, 1.94740214e-01, 1.40948711e+00,
       4.70505826e-02, 1.04568856e+01, 3.28850367e+01, 1.88674370e-03,
       1.54338181e-01, 1.69453967e-01, 1.06533430e+00, 1.61463375e+00])

4.数组比较

NumPy可以使用比较操作（如<、>、>=、<=和==）测试是否匹配某些值
例如：想要查看哪些葡萄酒的酒精度数高于10

# 1. 判断第11列哪些数据的值是大于10的，大于的就是True，小于的就是False
wines1[:,10] > 10

# 2.得到的结果为
array([False, False, False, ...,  True,  True,  True])

得到一个布尔数组，告诉我们哪种葡萄酒的酒精度数大于10，可以使用sum统计有多少葡萄酒的酒精度数高于10

# 1.使用sum统计有多少葡萄酒的酒精度数高于10
a = wines1[:,10] > 10   

# 2.查看结果
a.sum()

# 3.得到的结果为
852

5.使用布尔索引筛选子集

可以使用这个布尔数组作为索引，查看酒精度数高于10的葡萄酒数据

# 1.使用这个布尔数组作为索引，查看酒精度数高于10的葡萄酒数据
wines1[wines1[:,10] > 10] 

# 2.得到的数据为
array([[ 7.5  ,  0.5  ,  0.36 , ...,  0.8  , 10.5  , 30.   ],
       [ 7.5  ,  0.5  ,  0.36 , ...,  0.8  , 10.5  , 30.   ],
       [ 8.5  ,  0.28 ,  0.56 , ...,  0.75 , 10.5  , 34.   ],
       ...,
       [ 6.3  ,  0.51 ,  0.13 , ...,  0.75 , 11.   , 32.   ],
       [ 5.9  ,  0.645,  0.12 , ...,  0.71 , 10.2  , 30.   ],
       [ 6.   ,  0.31 ,  0.47 , ...,  0.66 , 11.   , 32.   ]])

注意：本文中数据以及内容若有侵权，请第一时间联系删除。

本文是作者个人学习后的总结，未经作者授权，禁止转载，谢谢配合。