学习Numpy(四）

一、复习切片和索引、广播机制

1.切片和索引

ndarray 数组可以基于 0 - n 的下标进行索引；通过冒号分隔切片参数 start:stop:step 来进行切片操作。
b = a[2:7:2] # 从索引 2 开始到索引 7 停止，间隔为 2
冒号 : 的解释：如果只放置一个参数，如 [2]，将返回与该索引相对应的单个元素。如果为 [2:]，表示从该索引开始以后的所有项都将被提取。如果使用了两个参数，如 [2:7]，那么则提取两个索引(不包括停止索引)之间的项。
还有高级索引：1.整数数组索引y = x[[0,1,2], [0,1,0]] #获取数组中(0,0)，(1,1)和(2,0)位置处的元素
2.布尔索引x[x > 5] #获取大于 5 的元素
3.花式索引：和整数索引差不多。

2.广播

广播规则：对两个数组，分别比较他们的每一个维度（若其中一个数组没有当前维度则忽略），满足：

数组拥有相同形状。
当前维度的值相等。
当前维度的值有一个是 1。

二、学习新知识

1.Numpy数组操作

1.1 修改数组形状

numpy.reshape（）

numpy.reshape(arr, newshape, order=‘C’)

arr：要修改形状的数组
newshape：整数或者整数数组，新的形状应当兼容原有形状
order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'k' -- 元素在内存中的出现顺序。

a = np.arange(8)
print ('原始数组：')
print (a)
print ('\n')
 
b = a.reshape(4,2)
print ('修改后的数组：')
print (b)

输出：

原始数组：
[0 1 2 3 4 5 6 7]

修改后的数组：
[[0 1]
 [2 3]
 [4 5]
 [6 7]]

numpy.ndarray.flat

numpy.ndarray.flat是一个数组元素迭代器
实例：
新建一个数组：

a = np.arange(24).reshape(4,6)
print(a)

输出：

[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]

迭代

for item in a.flat:
    print(item)

输出：

6
7
8
9
10
11
0
1
2
3
4
5
12
13
14
15
16
17
18
19
20
21
22
23

也可以：

for i in range(a.size): 
    print(a.flat[i])

或者：

    for item in items:
        print(item)

numpy.ndarray.flatten ()

numpy.ndarray.flatten()返回一份数组拷贝，对拷贝所做的修改不会影响原始数组，
ndarray.flatten(order=‘C’)
例：

a = np.arange(24).reshape(4,6)
a2 = a.flatten()
print(a2)
print(a2.ndim)
print(id(a),id(a2))

输出：

[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]
1
1821482336496 1821482338512

指定顺序：

a = np.arange(8).reshape(2,4)
 
print ('原数组：')
print (a)
print ('\n')
# 默认按行
 
print ('展开的数组：')
print (a.flatten())
print ('\n')
 
print ('以 F 风格顺序展开的数组：')
print (a.flatten(order = 'F'))

输出：

原数组：
[[0 1 2 3]
 [4 5 6 7]]


展开的数组：
[0 1 2 3 4 5 6 7]


以 F 风格顺序展开的数组：
[0 4 1 5 2 6 3 7]

numpy.ravel()

numpy.ravel() 展平数组元素，顺序通常是"C风格"，返回的是数组视图，修改会影响原始数组。

 
a = np.arange(8).reshape(2,4)
 
print ('原数组：')
print (a)
print ('\n')
 
print ('调用 ravel 函数之后：')
print (a.ravel())
print ('\n')
 
print ('以 F 风格顺序调用 ravel 函数之后：')
print (a.ravel(order = 'F'))

输出：

原数组：
[[0 1 2 3]
 [4 5 6 7]]


调用 ravel 函数之后：
[0 1 2 3 4 5 6 7]


以 F 风格顺序调用 ravel 函数之后：
[0 4 1 5 2 6 3 7]

区别

a = np.arange(8).reshape(2,4)
a.flatten()[1] = 99
print(a)
a.ravel()[1] = 100
print(a)

输出：

[[0 1 2 3]
 [4 5 6 7]]  #a没变
[[  0 100   2   3]
 [  4   5   6   7]]   #a变了

1.2 翻转数组

numpy.transpose()

numpy.transpose() 函数用于对换数组的维度，numpy.transpose(arr, axes)
参数说明:

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

a = np.arange(24).reshape(4,6)
print(a)
np.transpose(a,axes=(1,0))

输出：

[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
 array([[ 6,  0, 12, 18],
       [ 7,  1, 13, 19],
       [ 8,  2, 14, 20],
       [ 9,  3, 15, 21],
       [10,  4, 16, 22],
       [11,  5, 17, 23]])

numpy.ndarray.T 类似 numpy.transpose：a.T
输出：

array([[ 6,  0, 12, 18],
       [ 7,  1, 13, 19],
       [ 8,  2, 14, 20],
       [ 9,  3, 15, 21],
       [10,  4, 16, 22],
       [11,  5, 17, 23]])

numpy.rollaxis()

numpy.rollaxis() 函数向后滚动特定的轴到一个特定位置numpy.rollaxis(arr, axis, start)
参数说明：

arr：数组
axis：要向后滚动的轴，其它轴的相对位置不会改变
start：默认为零，表示完整的滚动。会滚动到特定位置。

a = np.arange(8).reshape(2,2,2)
 
print ('原数组：',a)
# 将轴 2 滚动到轴 0（宽度到深度）
b = np.rollaxis(a,2,0)
print ('调用 rollaxis 函数：\n',b)  

 
# 将轴 2 滚动到轴 1：（宽度到高度）
c = np.rollaxis(a,2,1)
print ('调用 rollaxis 函数：\n',c)

输出：
np.rollaxis(a, 2,0),轴2滚动到了轴0前面,其他轴相对2轴位置不变(start默认0),数组下标排序由0,1,2变成了1,2,0,按列分块
同样，np.rollaxis(a,2,1)，数组下标排序由0,1,2变成了0,1,2,
输出：

原数组： [[[0 1]
  [2 3]]

 [[4 5]
  [6 7]]]
调用 rollaxis 函数：
 [[[0 2]
  [4 6]]

 [[1 3]
  [5 7]]]
调用 rollaxis 函数：
 [[[0 2]
  [1 3]]

 [[4 6]
  [5 7]]]

numpy.swapaxes()

numpy.swapaxes ()函数用于交换数组的两个轴numpy.swapaxes(arr, axis1, axis2)

arr：输入的数组
axis1：对应第一个轴的整数
axis2：对应第二个轴的整数

例：

# 创建了三维的 ndarray
a = np.arange(8).reshape(2,2,2)
 
print ('原数组：')
print (a)
print ('\n')
# 现在交换轴 0（深度方向）到轴 2（宽度方向）
 
print ('调用 swapaxes 函数后的数组：')
print (np.swapaxes(a, 2, 0))

输出：

原数组：
[[[0 1]
  [2 3]]

 [[4 5]
  [6 7]]]


调用 swapaxes 函数后的数组：
[[[0 4]
  [2 6]]

 [[1 5]
  [3 7]]]

与transpose相比：transpose可以同时交换3个轴，swapaxes只能交换两个轴，比如：

a = np.arange(8).reshape(2,2,2)
a.transpose(2,1,0)

1.3 连接数组

numpy.concatenate()

numpy.concatenate() 函数用于沿指定轴连接相同形状的两个或多个数组numpy.concatenate((a1, a2, ...), axis)

参数说明：

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

按行拼接：

a = np.arange(24).reshape(4,6)
a2 = np.arange(24).reshape(4,6)
np.concatenate((a,a2))

输出：

array([[ 6,  7,  8,  9, 10, 11],
       [ 0,  1,  2,  3,  4,  5],
       [12, 13, 14, 15, 16, 17],
       [18, 19, 20, 21, 22, 23],
       [ 0,  1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10, 11],
       [12, 13, 14, 15, 16, 17],
       [18, 19, 20, 21, 22, 23]])

按列拼接：

np.concatenate((a,a2),axis=1)

输出：

array([[ 6,  7,  8,  9, 10, 11,  0,  1,  2,  3,  4,  5],
       [ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11],
       [12, 13, 14, 15, 16, 17, 12, 13, 14, 15, 16, 17],
       [18, 19, 20, 21, 22, 23, 18, 19, 20, 21, 22, 23]])

numpy.stack()

numpy.stack() 函数用于沿新轴连接数组序列numpy.stack(arrays, axis)
参数说明：

arrays相同形状的数组序列
axis：返回数组中的轴，输入数组沿着它来堆叠

np.stack((a,a2))

输出：

array([[[ 6,  7,  8,  9, 10, 11],
        [ 0,  1,  2,  3,  4,  5],
        [12, 13, 14, 15, 16, 17],
        [18, 19, 20, 21, 22, 23]],

       [[ 0,  1,  2,  3,  4,  5],
        [ 6,  7,  8,  9, 10, 11],
        [12, 13, 14, 15, 16, 17],
        [18, 19, 20, 21, 22, 23]]])

按列：

np.column_stack((a,a2))

输出：

array([[ 6,  7,  8,  9, 10, 11,  0,  1,  2,  3,  4,  5],
       [ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11],
       [12, 13, 14, 15, 16, 17, 12, 13, 14, 15, 16, 17],
       [18, 19, 20, 21, 22, 23, 18, 19, 20, 21, 22, 23]])

按行：

np.row_stack((a,a2))

输出：

array([[ 6,  7,  8,  9, 10, 11],
       [ 0,  1,  2,  3,  4,  5],
       [12, 13, 14, 15, 16, 17],
       [18, 19, 20, 21, 22, 23],
       [ 0,  1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10, 11],
       [12, 13, 14, 15, 16, 17],
       [18, 19, 20, 21, 22, 23]])

numpy.hstack()：numpy.hstack 是 numpy.stack 函数的变体，它通过水平堆叠来生成数组。
numpy.vstack()：numpy.vstack 是 numpy.stack 函数的变体，它通过垂直堆叠来生成数组。
np.dstack：沿深度堆叠

np.dstack((a,a2))

输出：

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

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

       [[12, 12],
        [13, 13],
        [14, 14],
        [15, 15],
        [16, 16],
        [17, 17]],

       [[18, 18],
        [19, 19],
        [20, 20],
        [21, 21],
        [22, 22],
        [23, 23]]])

1.4分割数组

numpy.split()

numpy.split() 函数沿特定的轴将数组分割为子数组numpy.split(ary, indices_or_sections, axis)
参数说明：

ary：被分割的数组
indices_or_sections：如果是一个整数，就用该数平均切分，如果是一个数组，为沿轴切分的位置（左开右闭）
axis：设置沿着哪个方向进行切分，默认为 0，横向切分，即水平方向。为 1 时，纵向切分，即竖直方向。

例：

print ('\n')
 
print ('将数组分为三个大小相等的子数组：')
b = np.split(a,3)
print (b)
print ('\n')
 
print ('将数组在一维数组中表明的位置分割：')
b = np.split(a,[4,7])
print (b)

输出：

第一个数组：
[0 1 2 3 4 5 6 7 8]


将数组分为三个大小相等的子数组：
[array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]


将数组在一维数组中表明的位置分割：
[array([0, 1, 2, 3]), array([4, 5, 6]), array([7, 8])]

axis 为 0 时在水平方向分割，axis 为 1 时在垂直方向分割。
numpy.hsplit()
numpy.hsplit 函数用于水平分割数组，通过指定要返回的相同形状的数组数量来拆分原数组。

a = np.arange(24).reshape(4,6)
np.hsplit(a,2)

输出：

[array([[ 6,  7,  8],
        [ 0,  1,  2],
        [12, 13, 14],
        [18, 19, 20]]),
 array([[ 9, 10, 11],
        [ 3,  4,  5],
        [15, 16, 17],
        [21, 22, 23]])]

numpy.vsplit() ：垂直分割
例：

a4,a3,a2,a1 = np.vsplit(a,4)
a4

输出：

array([[ 6,  7,  8,  9, 10, 11]])

a3

输出：

array([[0, 1, 2, 3, 4, 5]])

dsplit():

a2 = np.arange(24).reshape(4,6)
a_13 = np.dstack((a,a2))
np.dsplit(a_13,2)

输出：

[array([[[ 6],
         [ 7],
         [ 8],
         [ 9],
         [10],
         [11]],
 
        [[ 0],
         [ 1],
         [ 2],
         [ 3],
         [ 4],
         [ 5]],
 
        [[12],
         [13],
         [14],
         [15],
         [16],
         [17]],
 
        [[18],
         [19],
         [20],
         [21],
         [22],
         [23]]]),
 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]]])]

a_14,a_15 = np.dsplit(a_13,2)
print(a_14.shape)
print(a_14.ndim)

输出：

(4, 6, 1)
3

1.5数组元素的添加与删除

numpy.append()

numpy.append ()函数在数组的末尾添加值。 追加操作会分配整个数组，并把原来的数组复制到新数组中。 此外，输入数组的维度必须匹配否则将生成ValueError。numpy.append(arr, values, axis=None)

参数说明：

arr：输入数组
values：要向arr添加的值，需要和arr形状相同（除了要添加的轴）
axis：默认为 None。当axis无定义时，是横向加成，返回总是为一维数组！当axis有定义的时候，分别为0和1的时候。当axis有定义的时候，分别为0和1的时候（列数要相同）。当axis为1时，数组是加在右边（行数要相同）。

a = np.array([[1,2,3],[4,5,6]])
 
print ('第一个数组：')
print (a)
print ('\n')
 
print ('向数组添加元素：')
print (np.append(a, [7,8,9]))
print ('\n')
 
print ('沿轴 0 添加元素：')
print (np.append(a, [[7,8,9]],axis = 0))
print ('\n')
 
print ('沿轴 1 添加元素：')
print (np.append(a, [[5,5,5],[7,8,9]],axis = 1))

输出：

第一个数组：
[[1 2 3]
 [4 5 6]]


向数组添加元素：
[1 2 3 4 5 6 7 8 9]


沿轴 0 添加元素：
[[1 2 3]
 [4 5 6]
 [7 8 9]]


沿轴 1 添加元素：
[[1 2 3 5 5 5]
 [4 5 6 7 8 9]]

numpy.insert()

numpy.insert ()函数在给定索引之前，沿给定轴在输入数组中插入值。

如果值的类型转换为要插入，则它与输入数组不同。 插入没有原地的，函数会返回一个新数组。 此外，如果未提供轴，则输入数组会被展开。
numpy.insert(arr, obj, values, axis)
参数说明：

arr：输入数组
obj：在其之前插入值的索引
values：要插入的值
axis：沿着它插入的轴，如果未提供，则输入数组会被展开

此外，输入数组的维度必须匹配。

a = np.array([[1,2],[3,4],[5,6]])
 
print ('第一个数组：')
print (a)
print ('\n')
 
print ('未传递 Axis 参数。 在删除之前输入数组会被展开。')
print (np.insert(a,3,[11,12]))
print ('\n')
print ('传递了 Axis 参数。 会广播值数组来配输入数组。')
 
print ('沿轴 0 广播：')
print (np.insert(a,1,[11],axis = 0))
print ('\n')
 
print ('沿轴 1 广播：')
print (np.insert(a,1,11,axis = 1))

输出：

第一个数组：
[[1 2]
 [3 4]
 [5 6]]


未传递 Axis 参数。 在删除之前输入数组会被展开。
[ 1  2  3 11 12  4  5  6]


传递了 Axis 参数。 会广播值数组来配输入数组。
沿轴 0 广播：
[[ 1  2]
 [11 11]
 [ 3  4]
 [ 5  6]]


沿轴 1 广播：
[[ 1 11  2]
 [ 3 11  4]
 [ 5 11  6]]

numpy.delete()

numpy.delete ()函数返回从输入数组中删除指定子数组的新数组。 与 insert() 函数的情况一样，如果未提供轴参数，则输入数组将展开。Numpy.delete(arr, obj, axis)

参数说明：

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

a = np.arange(12).reshape(3,4)
 
print ('第一个数组：')
print (a)
print ('\n')
 
print ('未传递 Axis 参数。 在插入之前输入数组会被展开。')
print (np.delete(a,5))
print ('\n')
 
print ('删除第二列：')
print (np.delete(a,1,axis = 1))
print ('\n')
 
print ('包含从数组中删除的替代值的切片：')
a = np.array([1,2,3,4,5,6,7,8,9,10])
print (np.delete(a, np.s_[::2]))

输出：

第一个数组：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]


未传递 Axis 参数。 在插入之前输入数组会被展开。
[ 0  1  2  3  4  6  7  8  9 10 11]


删除第二列：
[[ 0  2  3]
 [ 4  6  7]
 [ 8 10 11]]


包含从数组中删除的替代值的切片：
[ 2  4  6  8 10]

打印 np.s_[::2]，输出slice(None, None, 2)
相当于取 从0索引开始，步长为2的索引位置的数值。

numpy.unique()

numpy.unique() 函数用于去除数组中的重复元素。

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

参数说明：

arr：输入数组，如果不是一维数组则会展开
return_index：如果为true，返回新列表元素在旧列表中的位置（下标），并以列表形式储
return_inverse：如果为true，返回旧列表元素在新列表中的位置（下标），并以列表形式储
return_counts：如果为true，返回去重数组中的元素在原数组中的出现次数

a = np.array([5,2,6,2,7,5,6,8,2,9])
 
print ('第一个数组：')
print (a)
print ('\n')
 
print ('第一个数组的去重值：')
u = np.unique(a)
print (u)
print ('\n')
 
print ('去重之后数组的索引数组：')
u,indices = np.unique(a, return_index = True)
print (indices)
print ('\n')

print ('去重的数组的索引：')
u,indices = np.unique(a,return_inverse = True)
print (u)
print ('\n')
 
 
print ('返回重复元素的重复数量：')
u,indices = np.unique(a,return_counts = True)
print (u)
print (indices)

输出：

第一个数组：
[5 2 6 2 7 5 6 8 2 9]


第一个数组的去重值：
[2 5 6 7 8 9]


去重之后数组的索引数组：
[1 0 2 4 7 9]


去重的数组的索引：
[2 5 6 7 8 9]


返回重复元素的重复数量：
[2 5 6 7 8 9]
[3 2 2 1 1 1]

2. NumPy 字符串函数

#### #### numpy.char.add()

numpy.char.add() 函数依次对两个数组的元素进行字符串连接。

print ('连接两个字符串：')
print (np.char.add(['hello'],[' xyz']))
print ('\n')
 
print ('连接示例：')
print (np.char.add(['hello', 'hi'],[' abc', ' xyz']))

输出：

连接两个字符串：
['hello xyz']

连接示例：
['hello abc' 'hi xyz']

numpy.char.multiply()

numpy.char.multiply() 函数执行多重连接。

print (np.char.multiply('Runoob ',3))

输出：

Runoob Runoob Runoob 

numpy.char.center()

numpy.char.center() 函数用于将字符串居中，并使用指定字符在左侧和右侧进行填充。np.char.center(str , width,fillchar)

# str: 字符串，width: 长度，fillchar: 填充字符
print (np.char.center('Runoob', 20,fillchar = '*'))

输出：

*******Runoob*******

numpy.char.capitalize()

numpy.char.capitalize() 函数将字符串的第一个字母转换为大写：print (np.char.capitalize('runoob'))
输出：

Runoob

numpy.char.title()

numpy.char.title() 函数将字符串的每个单词的第一个字母转换为大写：print (np.char.title('i like runoob'))
输出：

I Like Runoob

numpy.char.lower()

numpy.char.lower() 函数对数组的每个元素转换为小写。它对每个元素调用 str.lower。

#操作数组
print (np.char.lower(['RUNOOB','GOOGLE']))
 
# 操作字符串
print (np.char.lower('RUNOOB'))

输出：

['runoob' 'google']
runoob

numpy.char.upper()

numpy.char.upper() 函数对数组的每个元素转换为大写。它对每个元素调用 str.upper。

#操作数组
print (np.char.upper(['runoob','google']))
 
# 操作字符串
print (np.char.upper('runoob'))

输出：

['RUNOOB' 'GOOGLE']
RUNOOB

numpy.char.split()

numpy.char.split() 通过指定分隔符对字符串进行分割，并返回数组。默认情况下，分隔符为空格。

# 分隔符默认为空格
print (np.char.split ('i like runoob?'))
# 分隔符为 .
print (np.char.split ('www.runoob.com', sep = '.'))

输出：

输出结果为：

['i', 'like', 'runoob?']
['www', 'runoob', 'com']

numpy.char.splitlines()

numpy.char.splitlines() 函数以换行符作为分隔符来分割字符串，并返回数组。

# 换行符 \n
print (np.char.splitlines('i\nlike runoob?')) 
print (np.char.splitlines('i\rlike runoob?'))

输出：

['i', 'like runoob?']
['i', 'like runoob?']

numpy.char.strip()

numpy.char.strip() 函数用于移除开头或结尾处的特定字符。

# 移除字符串头尾的 a 字符
print (np.char.strip('ashok arunooba','a'))
 
# 移除数组元素头尾的 a 字符
print (np.char.strip(['arunooba','admin','java'],'a'))

输出：

shok arunoob
['runoob' 'dmin' 'jav']

numpy.char.join()

numpy.char.join() 函数通过指定分隔符来连接数组中的元素或字符串

# 操作字符串
print (np.char.join(':','runoob'))
 
# 指定多个分隔符操作数组元素
print (np.char.join([':','-'],['runoob','google']))

输出：

r:u:n:o:o:b
['r:u:n:o:o:b' 'g-o-o-g-l-e']

numpy.char.replace()

numpy.char.replace() 函数使用新字符串替换字符串中的所有子字符串。

print (np.char.replace ('i like runoob', 'oo', 'cc'))

输出：

i like runccb