本节主要介绍numpy中在数组上的一些常规操作，在数组级别上包括数组迭代，数组拼接、数组分割，在元素级别包括元素迭代、元素增加、元素删除等。
本节的内容比较重要，同时也比较基础，是养成良好的编程习惯的重要的一个环节，因为每一个方法都可以通过最笨拙的索引方法去实现，但是这对于代码的可读性和程序的运行速度都是有影响的。
1. 迭代操作
迭代操作是最体现代码水平的，因为总是可以通过索引实现，这里介绍几种迭代的形式。
1.1 for i in a 进行数组的第一维度迭代
例如：
import numpy as np
a = np.arange(16)
a.shape=(4,2,2)
print('a 数据为：',a)
b = np.array([1,2,3,4])
print('b 数组为：',b)
for i in a:
print(i)事实上，
for i in a:
print(i)可以改写为，
for i in range(a.shape[0]):
print(a[i,:,:])他们的结果是一样的。这种方式只能按照数组的第一维度进行迭代，返回的是数组第一维度的值，可能是数组也可能是元素（元素实际上是0维数组）。
1.2 使用numpy提供的迭代器nditer进行迭代。
nditer和python标准的迭代器iter一样，但是它既可以用来迭代数组也可以用来迭代元素，有可选的参数来控制，同时还能调整迭代的顺序，是nnumpy中比较实用的工具。
1) 迭代元素
此时按照默认的存储顺序返回元素：
import numpy as np
a = np.arange(16)
a.shape=(4,4)
print('a 数据为：',a)
b = np.array([1,2,3,4])
print('b 数组为：',b)
for i in np.nditer(a):
print(i)输出：
a 数据为： [[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
b 数组为： [1 2 3 4]
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15而此时，代码块：
for i in np.nditer(a):
print(i)相当于：
for i in range(a.shape[0]):
for j in range(a.shape[1]):
print(a[i,j])至于那种写法比较好，一目了然。
上面是以行优先（第一维度）迭代数据，想要以列优先迭代数据，事实上以’F’顺序迭代就可以：
for i in np.nditer(a, order='F'):
print(i)同样等价于：
for i in range(a.shape[0]):
for j in range(a.shape[1]):
print(a[j,i])默认创建数组的顺序为’c’，默认迭代元素顺序也是’C‘，通过显示的使用order='F'可以改变迭代顺序。
2） 数组迭代
默认迭代返回的是单个元素，使用参数flags = ['external_loop']将返回值变为数组，order='C'时，返回值压缩为一维数组，order='F'，将每一列打包一个数组返回。
import numpy as np
a = np.arange(16)
a.shape=(4,2,2)
print('a 数据为：',a)
# b = np.array([1,2,3,4])
# print('b 数组为：',b)
for i in np.nditer(a, flags = ['external_loop'], order='C'):
print('c顺序')
print(i)
for i in np.nditer(a, flags = ['external_loop'], order='F'):
print('F顺序')
print(i)
输出：
a 数据为： [[[ 0 1]
[ 2 3]]
[[ 4 5]
[ 6 7]]
[[ 8 9]
[10 11]]
[[12 13]
[14 15]]]
c顺序
[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15]
F顺序
[ 0 4 8 12]
F顺序
[ 2 6 10 14]
F顺序
[ 1 5 9 13]
F顺序
[ 3 7 11 15]可以看出，当参数为order='F'每次也是按行迭代，只是迭代了4次。说明nditer是按照内存储存的顺序来迭代的。
1.3 广播迭代
nditer也可以对多个数组同时迭代，当这些数组的维度大小不一样的时候，遵循numpy的广播机制。
import numpy as np
a = np.arange(16)
a.shape=(4,4)
print('a 数据为：',a)
b = np.array([1,2,3,4])
print('b 数组为：',b)
for i,j in np.nditer([a,b]):
print('iter value is %d:%d'%(i,j))输出：
thonFiles\PythonTools\visualstudio_py_launcher.py' 'e:\home\Python\machineLearning' '14039' '34806ad9-833a-4524-8cd6-18ca4aa74f14' 'RedirectOutput,RedirectOutput' 'e:\home\Python\machineLearning\test.py'
a 数据为： [[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
b 数组为： [1 2 3 4]
iter value is 0:1
iter value is 1:2
iter value is 2:3
iter value is 3:4
iter value is 4:1
iter value is 5:2
iter value is 6:3
iter value is 7:4
iter value is 8:1
iter value is 9:2
iter value is 10:3
iter value is 11:4
iter value is 12:1
iter value is 13:2
iter value is 14:3
iter value is 15:41.4 展开为一维数组迭代
迭代后结果为一维数组的迭代器有两个：flatten和ravel,同样两者都可以接受参数order=F，order：’C’ — 按行，’F’ — 按列，’A’ — 原顺序，’k’ — 元素在内存中的出现顺序
import numpy as np
a = np.arange(10).reshape(2,5)
print('数组a为：\n',a)
b = a.flatten()
# 经过flatten迭代器迭代后的结果
print('flat 迭代后的结果：\n', b)
# 与其他迭代器一样，接收参数order,order='F'
c = a.flatten(order='F')
print('order=F迭代结果\n',c)
d = a.ravel()
# 经过ravel迭代
print('ravel 迭代后的结果：\n',d)输出结果：
数组a为：
[[0 1 2 3 4]
[5 6 7 8 9]]
flat 迭代后的结果：
[0 1 2 3 4 5 6 7 8 9]
order=F迭代结果
[0 5 1 6 2 7 3 8 4 9]
ravel 迭代后的结果：
[0 1 2 3 4 5 6 7 8 9]可以看出，两者在功能上是完全一样的，但是两个还是有一个致命的区别：flatten返回的是拷贝，也就是从重新开辟了一块儿内存，与原数组无关。ravel返回的是原始数组的一个视图，结果与原数组是共内存的，修改结果会改变原数组的值，因而在使用上是需要注意的。
2. 数组拼接
在numpy的数组拼接中，常用的以下函数：
| 函数 | 参数 | 功能 |
|---|---|---|
| numpy.concatenate((a1, a2, …), axis) | a1, a2, …：相同类型的数组序列，axis：沿着它连接数组的轴，默认为 0 | 沿着现存的轴连接数据序列，连接后新数组的维度不变 |
| numpy.stack(arrays, axis) | arrays：相同形状的数组序列，axis：返回数组中的轴，输入数组沿着它来堆叠 | 沿着新轴连接数组序列，新数组的维度增加1 |
2.1 numpy.concatenate： 数组的连接是指元素上的连接。 此函数用于沿指定轴连接相同形状的两个或多个数组。连接的数组维度必须一样，连接轴的维度大小必须一样。
import numpy as np
a = np.arange(16)
a.shape=(4,4)
print('a 数据为：',a)
b = np.array([[1,2,3,4]])
print('b 数组为：',b)
c = np.concatenate((a,b))
print(c)输出：
a 数据为： [[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
b 数组为： [[1 2 3 4]]
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]
[ 1 2 3 4]]很显然，这是第一维度（行）拼接。下面是第二维度（列）拼接。
import numpy as np
a = np.arange(16)
a.shape=(4,4)
print('a 数据为：',a)
b = np.array([[1],[2],[3],[4]])
print('b 数组为：',b)
c = np.concatenate((a,b),axis=1)
print(c)输出：
a 数据为： [[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
b 数组为： [[1]
[2]
[3]
[4]]
[[ 0 1 2 3 1]
[ 4 5 6 7 2]
[ 8 9 10 11 3]
[12 13 14 15 4]]注意这两个例子中b数组的维度，拼接轴的维度大小一定要一样。
2.2 numpy.stack: 此函数沿新轴连接数组序列. 新数组的维度比原数组的维度大1。被拼接的数组的维度以及每个维度大小必须一样。
import numpy as np
a = np.arange(4)
a.shape=(2,2)
print('a 数据为：',a)
b = np.array([[5,6],[7,8]])
print('b 数组为：',b)
c = np.stack((a,b),axis=0)
print(c)输出：
a 数据为： [[0 1]
[2 3]]
b 数组为： [[5 6]
[7 8]]
[[[0 1]
[2 3]]
[[5 6]
[7 8]]]原数组是2维，新数组是3维。
将c = np.stack((a,b),axis=0)改为：c = np.stack((a,b),axis=1)
输出：
a 数据为： [[0 1]
[2 3]]
b 数组为： [[5 6]
[7 8]]
[[[0 1]
[5 6]]
[[2 3]
[7 8]]]stack有两个扩充变体：
hstack：水平堆叠序列中的数组(列方向) 与函数np.concatenate((a,b)，axis=1)等价
vstack ：竖直堆叠序列中的数组(行方向) 与函数np.concatenate((a,b)，axis=0)等价
注意这两个函数与stack的不同
3. 数组分割
数组分割常用到以下函数：
| 函数 | 参数 | 功能 |
|---|---|---|
| numpy.split(ary, indices_or_sections, axis) | ary：被分割的输入数组，indices_or_sections：可以是整数，表明要从输入数组创建的，等大小的子数组的数量。 如果此参数是一维数组，则其元素表明要创建新子数组的点，axis：分割轴，默认为 0 | 该函数沿特定的轴将数组分割为子数组 |
import numpy as np
a = np.arange(24)
a.shape=(6,4)
print('a 数据为：',a)
# b = np.array([[5,6],[7,8]])
# print('b 数组为：',b)
c = np.split(a,3)
print(c)输出：
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]]
[array([[0, 1, 2, 3],
[4, 5, 6, 7]]), array([[ 8, 9, 10, 11],
[12, 13, 14, 15]]), array([[16, 17, 18, 19],
[20, 21, 22, 23]])]分割后元素的维度不变。上面是数组按轴等分分割，也可以标明分割位置：
c = np.split(a,[1,3,4])输出：
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]]
[array([[0, 1, 2, 3]]), array([[ 4, 5, 6, 7],
[ 8, 9, 10, 11]]), array([[12, 13, 14, 15]]), array([[16, 17, 18, 19],
[20, 21, 22, 23]])]注意分割[1,3,4]是分割位置，故产生了4个数组。
同样，他有两个变体：
numpy.hsplit是split()函数的特例，其中轴为 1 表示水平分割，无论输入数组的维度是什么。
numpy.vsplit是split()函数的特例，其中轴为 0 表示竖直分割，无论输入数组的维度是什么