• NumPy数组与矩阵（二）

    文章目录

    前言

    NumPy中包含了一些函数用于处理数组，大概可以分为以下几类；

    • 修改数组形状；
    • 反转数组；
    • 修改数组维度；
    • 连接数组；
    • 分割数组；
    • 数组元素的添加与删除；

    数组排序；在数据分析的过程中，我们时常要对数据进行排序，NumPy库提供了sort函数、argsort函数和lexsort函数，每个函数的排序功能不同。

    一、数组操作

    1. 修改数组形状

    函数描述
    reshape不改变数据的条件下改变形状
    flat数组元素迭代器
    flatten返回一份数组拷贝，对拷贝所做的修改不会影响原始数组
    ravel返回展开数组
    numpy.reshape(arr, newshape, order='C')

    • 1
    • arr：表示要修改形状的数组名称
    • newshape：整数或者整数数组
    • order：元素排序，C，按行排序，F，按列排序，A按原顺序排序，K，按照元素在内存中出现的舒徐排序
    import numpy as np
a = np.arange(12)
b = a.reshape(3,4)

    • 1
    • 2
    • 3
    返回值：
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

    • 1
    • 2
    • 3
    • 4
    • 5

    2. 反转数组

    函数描述
    transpose兑换数组的维度
    ndarray.T和self.transpose()相同
    rollaxis向后滚动指定的轴
    swapaxes兑换数组中的两个轴
    numpy.transpose(arr, axes)

    • 1
    • arr：要操作的数组
    • axes：整数列表，对应维度，通常所有的维度都会兑换
    a = np.arange(20).reshape(5,4)
b = np.transpose(a)

    • 1
    • 2
    返回值：
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15],
       [16, 17, 18, 19]])
array([[ 0,  4,  8, 12, 16],
       [ 1,  5,  9, 13, 17],
       [ 2,  6, 10, 14, 18],
       [ 3,  7, 11, 15, 19]])

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    a = np.arange(16).reshape(4,4)
a.T

    • 1
    • 2
    返回值：
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15]])
array([[ 0,  4,  8, 12],
       [ 1,  5,  9, 13],
       [ 2,  6, 10, 14],
       [ 3,  7, 11, 15]])

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    3. 修改数组维度

    维度描述
    broadcast产生模仿广播的对象
    broadcast_to将数组广播到新形状
    expand_dims扩展数组的形状
    squeeze从数组的形状中删除一维条目

    NumPy的广播遵循一组严格的的规则，这组规则是为了决定两个数组之间的操作。

    • 规则1：如果两个数组的维度数不相同，那么小维度数组的形状将会在最左边补1；
    • 规则2：如果两个数组的形状在任何一个维度上都不匹配，那么数组的形状会沿着维度为1的维度扩展以匹配另外一个数组的形状；
    • 规则3：如果两个数组的形状在任何一个维度上都不匹配并且没有任何一个维度等于1，那么会引发异常。
    A = np.arange(9).reshape(3, 3)
B = np.arange(3)
A + B
d = np.arange(4).reshape(1,4)
np.broadcast_to(d,(4,4))

    • 1
    • 2
    • 3
    • 4
    • 5
    返回值：
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])
array([0, 1, 2])
array([[ 0,  2,  4],
       [ 3,  5,  7],
       [ 6,  8, 10]])
array([[0, 1, 2, 3]])
array([[0, 1, 2, 3],
       [0, 1, 2, 3],
       [0, 1, 2, 3],
       [0, 1, 2, 3]])

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    4. 连接数组

    函数描述
    concatenate连接沿现有轴的数组序列
    stack沿着新的轴加入一系列数组
    hstack水平堆叠序列中的数组（列方向）
    vstack竖直堆叠序列中的数组（行方向）
    numpy.concatenate((a1,a2,...), axis)

    • 1
    • a1,a2,…：相同类型的数组；
    • axis：沿着它连接数组的轴，默认为0；
    a = np.array([[1,2],[3,4]])
b = np.array([[5,6],[7,8]])
np.concatenate((a,b))

    • 1
    • 2
    • 3
    返回值：
array([[1, 2],
       [3, 4]])
array([[5, 6],
       [7, 8]])
array([[1, 2],
       [3, 4],
       [5, 6],
       [7, 8]])

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    a = np.array([[1,2],[3,4]])
b = np.array([[5,6],[7,8]])
np.stack((a,b),0)
np.stack((a,b),1)

    • 1
    • 2
    • 3
    • 4
    返回值：
array([[[1, 2],
        [3, 4]],
       [[5, 6],
        [7, 8]]])
        
array([[[1, 2],
        [5, 6]],
       [[3, 4],
        [7, 8]]])

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    a = np.array([[1,2],[3,4]])
b = np.array([[5,6],[7,8]])
np.hstack((a,b))

    • 1
    • 2
    • 3
    返回值：
array([[1, 2, 5, 6],
       [3, 4, 7, 8]])

    • 1
    • 2
    • 3
    a = np.array([[1,2],[3,4]])
b = np.array([[5,6],[7,8]])
np.vstack((a,b))

    • 1
    • 2
    • 3
    返回值：
array([[1, 2],
       [3, 4],
       [5, 6],
       [7, 8]])

    • 1
    • 2
    • 3
    • 4
    • 5

    5. 分割数组

    函数数组操作
    split将一个数组分割为多个子数组
    hsplit将一个数组水平分割为多个子数组（按列）
    vsplit将一个数组垂直分割为多个子数组（按行）
    numpy.split(ary, indices_or_sections, axis)

    • 1
    • arr: 被分割的数组；
    • indices_or_sections：如果是整数，就用该数平均切分；如果是一个数组，为沿轴的位置进行切分（左开右闭）；
    • axis:沿着哪个维度进行切分，默认为0，横向切分。为1时，棕向切分。
    a = np.arange(12)
b = np.split(a,4)
np.split(a,[4,7])

    • 1
    • 2
    • 3
    返回值：
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
[array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8]), array([ 9, 10, 11])]
[array([0, 1, 2, 3]), array([4, 5, 6]), array([ 7,  8,  9, 10, 11])]

    • 1
    • 2
    • 3
    • 4

    numpy.hsplit函数用于水平分割数组，通过指定要返回的相同形状的数组数量来拆分原始数组。

    np.floor(100 * np.random.random((3, 9)))
np.hsplit(a,3)

    • 1
    • 2
    返回值：
array([[82., 95., 26., 57., 60., 30., 80., 33., 51.],
       [75.,  5., 70., 43., 64., 29., 67.,  7., 47.],
       [60., 86., 88.,  4., 42.,  0., 22., 28.,  8.]])
[array([0, 1, 2, 3]), array([4, 5, 6, 7]), array([ 8,  9, 10, 11])]

    • 1
    • 2
    • 3
    • 4
    • 5
    a = np.arange(12).reshape(4,3)
b = np.vsplit(a,2)

    • 1
    • 2
    返回值：
array([[ 0,  1,  2],
       [ 3,  4,  5],
       [ 6,  7,  8],
       [ 9, 10, 11]])

[array([[0, 1, 2],
       [3, 4, 5]]), array([[ 6,  7,  8],
       [ 9, 10, 11]])]

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    6. 元素添加和删除

    函数元素及描述
    resize返回指定形状的新数组
    append将值添加到数组末尾
    insert沿指定轴将值插入指定下标之前
    delete删掉某个轴的子数组，并返回删除后的新数组
    unique查找数组内的唯一元素
    a = np.array([[1,2,3],[4,5,6]])
a.shape
b = np.resize(a,(3,2))
b.shape
c = np.resize(a,(3,3))

    • 1
    • 2
    • 3
    • 4
    • 5
    返回值：
array([[1, 2, 3],
       [4, 5, 6]])
(2, 3)
array([[1, 2],
       [3, 4],
       [5, 6]])
(3, 2)
array([[1, 2, 3],
       [4, 5, 6],
       [1, 2, 3]])

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    numpy.append(arr, values, axis=None)

    • 1
    • arr：输入数组；
    • values：要向arr添加的值，需要和arr形状相同（除了要添加的轴）；
    • axis：默认为None，当axis无定义时，是横向加成，返回为一维数组。当axis为0时，（列数要相同），数组添加在下方。当axis为1时，数组是加在右边（行数要相同）
    a = np.array([[1,2,3],[4,5,6]])
np.append(a,[7,8,9])
np.append(a, [[7,8,9]], axis = 0) #沿轴0添加元素
np.append(a, [[5,5,5],[7,8,9]], axis = 1)

    • 1
    • 2
    • 3
    • 4
    返回值：
array([[1, 2, 3],
       [4, 5, 6]])
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
array([[1, 2, 3, 5, 5, 5],
       [4, 5, 6, 7, 8, 9]])

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    numpy.insert(arr, obj, values, axis)

    • 1
    • arr：输入数组；
    • obj：在其之前插入值的索引；
    • values：要插入的值；
    • axis：沿着它插入的轴，如果未提供，则输入数组会被展开；
    a = np.array([[1,2],[3,4],[5,6]])
np.insert(a,3,[11,12])
np.insert(a,1,[11],axis=0)
np.insert(a,1,11,axis=1)

    • 1
    • 2
    • 3
    • 4
    返回值：
array([ 1,  2,  3, 11, 12,  4,  5,  6])
array([[ 1,  2],
       [11, 11],
       [ 3,  4],
       [ 5,  6]])
array([[ 1, 11,  2],
       [ 3, 11,  4],
       [ 5, 11,  6]])

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    numpy.delete(arr, obj, axis)

    • 1
    • arr: 输入数组；
    • obj：指定子数组的位置，可以是切片、整数或者整数数组，表明要从指定位置删除子数组；
    • axis：沿着它删除给定子数组的轴，如果未提供，则输入数组会被展开；
    a = np.arange(15).reshape(3,5)
np.delete(a,8)
np.delete(a,1,axis=1)

    • 1
    • 2
    • 3
    返回值：
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])
array([ 0,  1,  2,  3,  4,  5,  6,  7,  9, 10, 11, 12, 13, 14])
array([[ 0,  2,  3,  4],
       [ 5,  7,  8,  9],
       [10, 12, 13, 14]])

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    numpy.unique(arr, return_index, return_inverse, return_counts)

    • 1
    • arr：输入数组，如果不是一维数组则会展开；
    • return_index：如果为True，返回新列表元素在就列表中的位置（下标），并以列表形式存储；
    • return_inverse：如果为True，返回旧列表元素在新列表中的位置（下标），并以列表形式存储；
    • return_counts：如果为True，返回去重数组中的元素在原数组中的出现次数。
    a = np.array([1,2,3,3,2,4,5,4,8,7,2,2,5,9,6])
np.unique(a)
np.unique(a,return_index = True)
c, indices = np.unique(a,return_counts = True)

    • 1
    • 2
    • 3
    • 4
    返回值：
array([1, 2, 3, 3, 2, 4, 5, 4, 8, 7, 2, 2, 5, 9, 6])
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
(array([1, 2, 3, 4, 5, 6, 7, 8, 9]), array([ 0,  1,  2,  5,  6, 14,  9,  8, 13], dtype=int64)
array([1, 2, 3, 4, 5, 6, 7, 8, 9]) # c
array([1, 4, 2, 2, 2, 1, 1, 1, 1], dtype=int64) # indices 

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    二、数组排序

    1. sort函数

    ndarray.sort(a,axis=-1,kind='quicksort',order=None)

    • 1
    • a: 需要排序的数组；
    • axis: 沿着数组的方向排序，0表示按行，1表示按列；
    • kind: 排序的算法，提供了快排、混排、堆排；
    • order：如果数组包含字段，则是要排序的字段；
    a = np.random.randn(5)
a.sort()
b = np.random.randn(4,5)
np.sort(b)
np.sort(b,axis=0) # 按列排序

    • 1
    • 2
    • 3
    • 4
    • 5
    返回值：
array([ 0.18443112, -1.38944051,  0.90415198, -0.71590079, -0.66183327])

array([-1.38944051, -0.71590079, -0.66183327,  0.18443112,  0.90415198])

array([[ 0.16560108, -0.21907392,  0.84871269,  1.89443371,  0.77757078],
       [ 1.67871265, -0.47794349,  0.19126643,  0.55254205, -0.57946957],
       [-1.20440916,  0.708059  ,  0.06512808,  0.02402871,  0.74404043],
       [-1.66396914,  0.47841347, -1.07146564,  1.21503792,  0.95665346]])
       
array([[-0.21907392,  0.16560108,  0.77757078,  0.84871269,  1.89443371],
       [-0.57946957, -0.47794349,  0.19126643,  0.55254205,  1.67871265],
       [-1.20440916,  0.02402871,  0.06512808,  0.708059  ,  0.74404043],
       [-1.66396914, -1.07146564,  0.47841347,  0.95665346,  1.21503792]])
       
array([[-1.66396914, -0.47794349, -1.07146564,  0.02402871, -0.57946957],
       [-1.20440916, -0.21907392,  0.06512808,  0.55254205,  0.74404043],
       [ 0.16560108,  0.47841347,  0.19126643,  1.21503792,  0.77757078],
       [ 1.67871265,  0.708059  ,  0.84871269,  1.89443371,  0.95665346]])

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    2. argsort函数

    numpy.argsort函数返回的是数组从小到大的索引值，argsort的语法结构和参数说明与sort函数一致，其作用效果是对数组进行排序，返回一个排序后索引，数据没有改变。

    c = np.array([2,1,5,8,-5,4])
c.argsort()
d = np.array([[1,5,3],[6,2,8],[3,6,0]])
np.argsort(d)
np.argsort(d,axis=0)

    • 1
    • 2
    • 3
    • 4
    • 5
    array([ 2,  1,  5,  8, -5,  4])
array([4, 1, 0, 5, 2, 3], dtype=int64)
array([[1, 5, 3],
       [6, 2, 8],
       [3, 6, 0]])
array([[0, 2, 1],
       [1, 0, 2],
       [2, 0, 1]], dtype=int64)       
array([[0, 1, 2],
       [2, 0, 0],
       [1, 2, 1]], dtype=int64)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    3. Lexsort函数

    numpy.lexsort用于对多个序列进行排序，排序时优先照顾靠后的列，比如我们查看某个班级的学生总成绩和数学课成绩，并对总成绩排序后，再对数学课成绩进行排序。

    names = np.array(['Tom','Abe','Lily','Jane','Judy'])
ages = np.array([14,13,15,12,11])
totals_scores = np.array([190, 170, 168, 180, 176])
maths_scores = np.array([88,78,84,98,69])
index_lexsorted = np.lexsort((maths_scores, totals_scores))
names_lexsorted = names[np.lexsort((maths_scores, totals_scores))]

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    返回值：
array([2, 1, 4, 3, 0], dtype=int64)
array(['Lily', 'Abe', 'Judy', 'Jane', 'Tom'], dtype='<U4')

    • 1
    • 2
    • 3
  • 相关阅读:
    基于PHP+MySQL的电子邮件管理系统
    微信支付-无法重写WXPayConfig内的部分抽象方法
    mac建议装双系统吗，详细分析苹果电脑双系统的利弊
    PyCharm配置Jupyter
    deeplab实现自己遥感地质分割数据集
    【vue项目部署】Linux+Nginx实现项目部署及跨域
    外包干了一个月，技术明显进步。。。。。
    进程｜线程
    Redis的常用数据结构之字符串类型
    MySQL主从同步延迟解决方案
  • 原文地址：https://blog.csdn.net/suwuzs/article/details/125452941