NumPy数组的高级操作

最新推荐文章于 2023-04-16 10:19:04 发布

777sea

最新推荐文章于 2023-04-16 10:19:04 发布

阅读量2.9k

点赞数 3

分类专栏：机器学习文章标签： python

本文链接：https://blog.csdn.net/orchid_sea/article/details/120646597

版权

机器学习专栏收录该内容

3 篇文章 1 订阅

订阅专栏

一.堆叠操作

stack（堆叠）：将两个ndarray对象堆叠在一起组合成一个新的ndarray对象。根据堆叠的方向不同分为hstack和wstack两种。

hstack：水平方向堆叠horizontal stack

import numpy as np
a = np.array([[8, 8], [0, 0]])
b = np.array([[1, 8], [0, 4]])
'''
将a和b按元组中的顺序横向拼接
结果为：[[8, 8, 1, 8], 
        [0, 0, 0, 4]]
'''
print(np.hstack((a,b)))

vstack：竖直方向堆叠vertical stack

import numpy as np
a = np.array([[8, 8], [0, 0]])
b = np.array([[1, 8], [0, 4]])
'''
将a和b按元组中的顺序纵向拼接
结果为：[[8, 8]
        [0, 0]
        [1, 8]
        [0, 4]]
'''
print(np.vstack((a,b)))

第一关

import numpy as np


def get_mean(feature1, feature2):
    '''
    将feature1和feature2横向拼接，然后统计拼接后的ndarray中每列的均值
    :param feature1:待`hstack`的`ndarray`
    :param feature2:待`hstack`的`ndarray`
    :return:类型为`ndarray`，其中的值`hstack`后每列的均值
    '''
    #********* Begin *********#
    a = np.hstack((feature1,feature2))
    return a.mean(axis=0)
    #********* End *********#

二.比较、掩码和布尔逻辑

比较

比较运算符	通用函数
==	np.equal
!=	np.not_equal
<	np.less
<=	np.less_equal
>	np.greater
>=	np.greater_equal

比较运算符通用函数可以用于任意形状、大小的数组。

data=np.array([('Alice', 4, 40),('Bob', 11, 85.5),('Cathy', 7, 68.0),('Doug', 9, 60)],dtype=[("name","S10"),("age","int"),("score","float")])  #构造结构化数组

print(data["age"]<10)
'''
输出：array([ True, False,  True,  True])
'''

print((data["age"]/2)==(np.sqrt(data["age"])))
'''
输出:array([ True, False, False, False])
'''

布尔数组作掩码
使用布尔数组作为掩码，通过该掩码选择数据的子数据集

    data=np.array([('Alice', 4, 40), ('Bob', 11, 85.5) ,('Cathy', 7, 68.0),('Doug', 9, 60)],dtype=[("name","S10"),("age","int"),("score","float")])
    
     print(data["score"]>60)  #使用比较运算得的一个布尔数组
    '''
    输出:[False  True  True False]
    '''
     print(data[data["score"]>60])  #进行简单的索引，即掩码操作将值为True的选出
    '''
    输出:[(b'Bob', 11, 85.5) (b'Cathy',  7, 68. )]
    '''

布尔逻辑：结合Python的逐位逻辑运算符一起使用。

逻辑运算符	通用函数
&	np.bitwise_and
竖线	np.bitwise_or
^	np.bitwise_xor
~	np.bitwise_not

    print(np.count_nonzero(data["age"]<10))#统计数组中True的个数
    '''
    输出:3
    '''
    #还可以用np.sum(),输出结果和count_nonzero一样,sum()的好处是可以沿着行或列进行求和
    print(np.sum(data["age"]<10))
    print(np.any(data["score"]<60))#是否有不及格的
    '''
    输出：True
    '''
    print(np.all(data["age"]>10))#是否都大于10岁
    '''
    输出:False
    '''
    print(data[data["age"]>10])#打印年龄大于10的信息
    '''
    输出：array([(b'Bob', 11, 85.5)],
          dtype=[('name', 'S10'), ('age', '<i4'), ('score', '<f8')])
    '''

第二关

import numpy as np


def student(num,input_data):
    result=[]
    # ********* Begin *********#
    #根据输入的数据筛选出大于num的值
    a = np.array(input_data)
    result = a[a > num]


    # ********* End *********#
    return result

三.花式索引与布尔索引

花式索引
花式索引（Fancy Indexing）是NumPy用来描述使用整型数组（这里的数组，可以是NumPy的数组，也可以是python自带的list）作为索引的术语，其意义是根据索引数组的值作为目标数组的某个轴的下标来取值。
使用一维整型数组作为索引，如果被索引数组(ndarray)是一维数组，那么索引的结果就是对应位置的元素；如果被索引数组(ndarray)是二维数组，那么就是对应下标的行。

    import numpy as np
    arr = np.array(['zero','one','two','three','four'])
    '''
    打印arr中索引为1和4的元素，结果为：['one', 'four']
    '''
    print(arr[[1,4]])
    arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
    '''
    打印arr中索引为1和0的行
    结果为：[[4, 5, 6],
            [1, 2, 3]]
    '''
    print(arr[[1, 0]])
    '''
    打印arr中第2行第1列与第3行第2列的元素，结果为：[4, 8]
    '''
    print(arr[[1, 2], [0, 1]])

布尔索引
我们可以通过一个布尔数组来索引目标数组，以此找出与布尔数组中值为True的对应的目标数组中的数据，从而达到筛选出想要的数据的功能。（PS：需要注意的是，布尔数组的长度必须与被索引数组对应的轴的长度一致）
使用布尔索引来达到筛选数据的效果：我们可以想办法根据我们的需求，构造出布尔数组，然后再通过布尔索引来实现筛选数据的功能。

    import numpy as np
    performance = np.array([3.25, 3.5, 3.75, 3.5, 3.25, 3.75])
    '''
    筛选出绩效高于3.5的数据，结果为:[3.75, 3.75]
    '''
    print(performance[performance > 3.5])
    '''
    筛选出绩效高于3.25并且低于4的数据
    注意：&表示并且的意思，可以看成是and。&左右两边必须加上()
    结果为:[3.5  3.75 3.5  3.75]
    '''
    print(performance[(performance > 3.25) & (performance < 4)])

第三关

import numpy as np

def student(input_data):
    result=[]
    #********* Begin *********#
    #根据函数参数input_data过滤出所有的大写字母
    a = np.array(input_data)
    result = a[(a>='A') & (a<='Z')]
    # ********* End *********#
    return result

四.广播机制

广播：两个ndarray对象的相加、相减以及相乘都是对应元素之间的操作。当两个ndarray对象的形状并不相同的时候，我们可以通过扩展数组的方法来实现相加、相减、相乘等操作，这种机制叫做广播（broadcasting）。

    import numpy as np
    # arr为4行3列的ndarray对象
    arr = np.random.randn(4,3)
    # arr_mean为有3个元素的一维ndarray对象
    arr_mean = arr.mean(axis=0)
    # 对arr的每一列进行
    demeaned = arr - arr_mean
    #arr和arr_mean维度并不形同，但是它们可以进行相减操作，这就是通过广播机制来实现的。

广播原则：
如果两个数组的后缘维度（trailing dimension，即从末尾开始算起的维度）的轴长度相符，或其中的一方的长度为1，则认为它们是广播兼容的。
广播会在缺失或长度为1的维度上进行，这句话是理解广播的核心。
广播主要发生在两种情况，一种是两个数组的维数不相等，但是它们的后缘维度的轴长相符，另外一种是有一方的长度为1。

    import numpy as np
    arr1 = np.array([[0, 0, 0],[1, 1, 1],[2, 2, 2], [3, 3, 3]])
    arr2 = np.array([1, 2, 3])
    arr_sum = arr1 + arr2
    print(arr_sum)
    '''
    输入结果如下:
    [[1 2 3]
     [2 3 4]
     [3 4 5]
     [4 5 6]]
    '''
    #arr1的shape为(4,3)，arr2的shape为(3,)。可以说前者是二维的，而后者是一维的。但是它们的后缘维度相等，arr1的第二维长度为3，和arr2的维度相同。
    #arr1和arr2的shape并不一样，但是它们可以执行相加操作，这就是通过广播完成的，在这个例子当中是将arr2沿着0轴进行扩展。

	arr1 = np.array([[0, 0, 0],[1, 1, 1],[2, 2, 2], [3, 3, 3]])   #arr1.shape = (4,3)
	arr2 = np.array([[1],[2],[3],[4]])    #arr2.shape = (4, 1)
	arr_sum = arr1 + arr2
	print(arr_sum)
	'''
	输出结果如下：
	[[1 1 1]
 	[3 3 3]
 	[5 5 5]
 	[7 7 7]]
	'''
	#arr1的shape为(4,3)，arr2的shape为(4,1)，它们都是二维的，但是第二个数组在1轴上的长度为1，所以，可以在1轴上面进行广播。

第四关

import numpy as np

def student(a,b,c):
    result=[]
    # ********* Begin *********#
    #将输入数据转换为array并计算它们的和
    arr1 = np.array(a)
    arr2 = np.array(b)
    arr3 = np.array(c)
    result = arr1+arr2+arr3
    # ********* End *********#
    return result

五.线性代数

numpy的线性代数
线性代数（如矩阵乘法、矩阵分解、行列式以及其他方阵数学等）是任何数组库的重要组成部分，一般我们使用*对两个二维数组相乘得到的是一个元素级的积，而不是一个矩阵点积。因此numpy提供了线性代数函数库linalg，该库包含了线性代数所需的所有功能。

常用的numpy.linalg函数：

函数	说明
dot	矩阵乘法
vdot	两个向量的点积
det	计算矩阵的行列式
inv	计算方阵的逆
svd	计算奇异值分解（SVD）
solve	解线性方程组 Ax=b，A是一个方阵
matmul	两个数组的矩阵积

常用函数:

dot()：该函数返回俩个数组的点积。对于二维向量，效果等于矩阵乘法；对于一维数组，它是向量的内积；对于N维数组，它是a的最后一个轴上的和与b的倒数第二个轴的乘积。

    a=np.array([[1,2],[3,4]])
    a1=np.array([[5,6],[7,8]])
    np.dot(a,a1)
    '''
    输出：array([[19, 22],
           [43, 50]])
    '''

det()：该函数用于计算输入矩阵的行列式。

    a = np.array([[14, 1], [6, 2]])
    a=linalg.det(a)
    print(a)
    '''
    输出：21.999999999999996
    '''

inv()：该函数用于计算方阵的逆矩阵。逆矩阵的定义维如果两个方阵A、B，使得AB = BA = E，则A称为可逆矩阵，B为A的逆矩阵，E为单位矩阵。

     a=np.array([[1,2],[3,4]])
     b=linalg.inv(a)
     print(np.dot(a,b))
    '''
    输出：array([[1.0000000e+00, 0.0000000e+00],
           [8.8817842e-16, 1.0000000e+00]])
    '''

solve()：该函数用于计算线性方程的解。

#假设有如下方程组：3x+2y=7  x+4y=14；
#写成矩阵的形式：[[3,2][1,4]]*[[x],[y]]=[[7],[14]]；

     a=np.array([[3,2], [1,4]])
     b=np.array([[7],[14]])
     linalg.solve(a,b)
    '''
     输出:array([[0. ],
           [3.5]])
     最后解出x=0，y=3.5
    '''

matmul()：函数返回两个数组的矩阵乘积。如果参数中有一维数组，则通过在其维度上附加1来提升为矩阵，并在乘法之后去除。

    a=[[3,4],[5,6]]
    b=[[7,8],[9,10]]
    np.matmul(a,b)
    '''
    输出：array([[ 57,  64],
           [ 89, 100]])
    '''
    b=[7,8]
    np.matmul(a,b)
    '''
    输出：array([53, 83])
    '''

svd()：奇异值分解是一种矩阵分解的方法，该函数用来求解SVD。

    a=[[0,1],[1,1],[1,0]]
    linalg.svd(a)
    '''
    输出:(array([[-4.08248290e-01,  7.07106781e-01,  5.77350269e-01],
           [-8.16496581e-01,  2.64811510e-17, -5.77350269e-01],
           [-4.08248290e-01, -7.07106781e-01,  5.77350269e-01]]), array([1.73205081, 1.        ]), array([[-0.70710678, -0.70710678],
           [-0.70710678,  0.70710678]]))
    '''

第五关

from numpy import linalg
import numpy as np
def student(input_data):
    '''
    将输入数据筛选性别为男，再进行线性方程求解
    :param input_data:类型为`list`的输入数据
    :return:类型为`ndarray`
    '''
    result=[]
    # ********* Begin *********#
    a = np.array(input_data)
    x = []
    y = []
    for i in a:
        if i[0] == "男":
            x.append([int(i[1]),int(i[2])])
            y.append([int(i[-1])])
    if x==[] and y==[]:
        return result
    x = np.array(x)
    y = np.array(y)
    result = linalg.solve(x,y)
    # ********* End *********#
    return result