NumPy数组与矩阵（二）

---

前言

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

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

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

一、数组操作

1. 修改数组形状

函数	描述
reshape	不改变数据的条件下改变形状
flat	数组元素迭代器
flatten	返回一份数组拷贝，对拷贝所做的修改不会影响原始数组
ravel	返回展开数组

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

• arr：表示要修改形状的数组名称
• newshape：整数或者整数数组
• order：元素排序，C，按行排序，F，按列排序，A按原顺序排序，K，按照元素在内存中出现的舒徐排序

import numpy as np
a = np.arange(12)
b = a.reshape(3,4)

返回值：
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]])

2. 反转数组

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

numpy.transpose(arr, axes)

• arr：要操作的数组
• axes：整数列表，对应维度，通常所有的维度都会兑换

a = np.arange(20).reshape(5,4)
b = np.transpose(a)

返回值：
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]])

a = np.arange(16).reshape(4,4)
a.T

返回值：
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]])

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))

返回值：
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]])

4. 连接数组

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

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

• a1,a2,…：相同类型的数组；
• axis：沿着它连接数组的轴，默认为0；

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

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

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

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

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

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

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

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

5. 分割数组

函数	数组操作
split	将一个数组分割为多个子数组
hsplit	将一个数组水平分割为多个子数组（按列）
vsplit	将一个数组垂直分割为多个子数组（按行）

numpy.split(ary, indices_or_sections, axis)

• arr: 被分割的数组；
• indices_or_sections：如果是整数，就用该数平均切分；如果是一个数组，为沿轴的位置进行切分（左开右闭）；
• axis:沿着哪个维度进行切分，默认为0，横向切分。为1时，棕向切分。

a = np.arange(12)
b = np.split(a,4)
np.split(a,[4,7])

返回值：
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])]

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

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

返回值：
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])]

a = np.arange(12).reshape(4,3)
b = np.vsplit(a,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]])]

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))

返回值：
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]])

numpy.append(arr, values, axis=None)

• 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)

返回值：
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]])

numpy.insert(arr, obj, values, axis)

• 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)

返回值：
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]])

numpy.delete(arr, obj, axis)

• arr: 输入数组；
• obj：指定子数组的位置，可以是切片、整数或者整数数组，表明要从指定位置删除子数组；
• axis：沿着它删除给定子数组的轴，如果未提供，则输入数组会被展开；

a = np.arange(15).reshape(3,5)
np.delete(a,8)
np.delete(a,1,axis=1)

返回值：
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]])

numpy.unique(arr, return_index, return_inverse, return_counts)

• 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)

返回值：
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. sort函数

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

• 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) # 按列排序

返回值：
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]])

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)

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)

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))]

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