Numpy 数组操作

1修改数组形状

1.1 ndarray.reshape

ndarray.reshape 函数可以在不改变数据的条件下修改形状，格式如下：

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

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

arr=np.arange(12)
print(arr) #[ 0  1  2  3  4  5  6  7  8  9 10 11]
arr2=np.reshape(arr,(3,4)) #把arr改为形状为（3,4）
print(arr2)
'''
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
'''
print(id(arr),id(arr2)) #1574099035376 1574085663824 
arr2[0][0]=12
print(arr) #[12  1  2  3  4  5  6  7  8  9 10 11]

总结：

• （1）reshape() 将原数组形状改变了，会开辟一个新的内存存放新数组，即原数组与改变数组内存不同
• （2）新数组中的元素改变会影响原数组，即内存共享

1.2、ndarray.flat

numpy.ndarray.flat 是一个数组元素迭代器

arr=np.arange(12).reshape(3,4)

for i in arr:
    print(i,end=",")
#[0 1 2 3],[4 5 6 7],[ 8  9 10 11],
for el in arr.flat:
    print(el,end=",") #0,1,2,3,4,5,6,7,8,9,10,11,
'''
内置的迭代器：迭代对象时，只能一层一层的进行输出

numpy.flat:是将数组的每一个元素按顺序输出出来
'''

1.3、ndarray.flatten

ndarray.flatten 返回一份数组拷贝，对拷贝所做的修改不会影响原始数组，格式如下：

ndarray.flatten(order=‘C’)

• order：‘C’ – 按行，‘F’ – 按列，‘A’ – 原顺序，‘k’ – 元素在内存中的出现顺序

arr=np.arange(12).reshape(3,4)
arr2=arr.flatten()
# arr2=np.flatten(arr)
# print(arr)
'''
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
'''
print(arr.flatten())#[ 0  1  2  3  4  5  6  7  8  9 10 11]
print(arr2)#[ 0  1  2  3  4  5  6  7  8  9 10 11]
arr2[2]=666
print(arr)
'''
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
'''

总结：

• （1）numpy.flatten()是将数组里的每个元素一一取出，然后放进一个新的数组中
• （2）新数组元素改变不影响原数组，即内存不共享

1.4、ndarray.ravel

numpy.ravel() 展平的数组元素(扁平化)，顺序通常是"C风格"，返回的是数组视图（view，有点类似 C/C++引用reference的意味），修改会影响原始数组。
该函数接收两个参数：

ndarray.ravel(a, order=‘C’)

• 代码如下：

arr=np.arange(12).reshape(3,4)
arr2=arr.ravel()
print(arr)
'''
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
'''
print(arr2) #[ 0  1  2  3  4  5  6  7  8  9 10 11]
arr2[2]=444
print(arr)
'''
[[  0   1 444   3]
 [  4   5   6   7]
 [  8   9  10  11]]
'''

总结：

• （1）numpy.ravel()是将数组里的每个元素一一取出，然后放进一个新的数组中
• （2）新数组元素改变影响原数组，即内存共享

2.翻转数组

函数	描述
transpose	转置
ndarray.T	转置

2.1 numpy.T

代码如下：

arr=np.arange(6).reshape(3,2)
arr2=arr.T #
print(arr)
'''
[[0 1]
 [2 3]
 [4 5]]
'''
 print(arr2)
'''
[[0 2 4]
 [1 3 5]]
'''
print(id(arr),id(arr.T)) #2206133347184 2206133346992
arr2[0][0]=11
print(arr)
'''
[[11  1]
 [ 2  3]
 [ 4  5]]
'''
print(arr.shape,arr2.shape) #(3, 2) (2, 3)

总结：

• （1）numpy.T是将原数组进行翻转（二维数组就是行变为列），如上代码将原数组的形状（3,2）改变成（2,3）
• （2）原数组和改变的数组内存不同，但内存共享

2.2 numpy.transpose

numpy.transpose 函数用于对换数组的维度，格式如下：

numpy.transpose(arr, axes)

参数说明:

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

arr2=np.transpose(arr)
# print(arr2)
'''
[[0 2 4]
 [1 3 5]]
'''
arr2[0][0]=888
# print(arr)
'''
[[888   1]
 [  2   3]
 [  4   5]]
'''
arr=arr.reshape(1,2,3)
print(arr)
'''
[[[888   1   2]
  [  3   4   5]]]
'''
arr3=np.transpose(arr,[2,1,0])
print(arr3)
'''
[[[888]
  [  3]]

 [[  1]
  [  4]]

 [[  2]
  [  5]]]
'''
print(arr.shape,arr3.shape) #(1, 2, 3) (3, 2, 1)

总结：

• （1）numpy.transpose是将原数组进行翻转（二维数组就是行变为列），如上代码将原数组的形状（3,2）改变成（2,3）
• （2）原数组和改变的数组内存不同，但内存共享
• （3）numpy.transpose的axes参数用列表[ ]表示,[ ]里的参数表示数组的维度的索引从0开始

3.连接数组

numpy.concatenate

numpy.concatenate 函数用于沿指定轴连接相同形状的两个或多个数组，格式如下：

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

参数说明：

• a1, a2, ...：相同类型的数组即相同的形状
• axis：沿着它连接数组的轴，默认为 0为列，1为行
  代码如下：

arr=np.arange(12).reshape(3,4)
arr2=np.arange(1,13).reshape(3,4)
# print(arr)
# print(arr2)
arr3=np.concatenate((arr,arr2),axis=1)
print(arr3)
'''
[[ 0  1  2  3  1  2  3  4]
 [ 4  5  6  7  5  6  7  8]
 [ 8  9 10 11  9 10 11 12]]
'''
x1=np.random.randint(1,10,size=(3,4))
x2=np.random.randint(20,30,size=(1,4))
print("x1\n",x1)
print("x2\n",x2)

x3=np.concatenate([x1,x2],axis=0)
print("x3\n",x3)
'''
x1
 [[4 6 1 5]
 [7 8 4 1]
 [2 1 5 9]]
x2
 [[22 29 26 29]]
x3
 [[ 4  6  1  5]
 [ 7  8  4  1]
 [ 2  1  5  9]
 [22 29 26 29]]
'''

个人理解，二维举例：
a.shape=(3,4）b.shape=(3,4)
c=np.concatenate((a,b),axis=1)
c.shape=(3,8)
c=np.concatenate((a,b),axis=0)
c.shape=(6,4)

4. 数组的分割

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

4.1 numpy.split

numpy.split 函数沿特定的轴将数组分割为子数组，格式如下：

numpy.split(ary, indices_or_sections, axis)

参数说明：

• ary：被分割的数组
• indices_or_sections：如果是一个整数，就用该数平均切分 (这个整数必须能被原数组的总元素个数整除)，如果是一个数组，为沿轴切分的位置（左闭右开）
• axis：设置 沿着哪个方向进行切分，默认为 0，横向切分，即水平方向。为 1 时，纵向切分，即竖直方向。
  代码如下：

import numpy as np

arr=np.arange(12)

print("arr=",arr) #arr= [ 0  1  2  3  4  5  6  7  8  9 10 11]

arr2=np.split(arr,6) 
print(arr2) #[array([0, 1]), array([2, 3]), array([4, 5]), array([6, 7]), array([8, 9]), array([10, 11])]
print()
arr3=np.split(arr,(2,5,8))
print(arr3) #[array([0, 1]), array([2, 3, 4]), array([5, 6, 7]), array([ 8,  9, 10, 11])]
arr3[0][0]=44
print("arr3=",arr3) #arr3= [array([44,  1]), array([2, 3, 4]), array([5, 6, 7]), array([ 8,  9, 10, 11])]
print(arr) #[44  1  2  3  4  5  6  7  8  9 10 11]
print(id(arr),id(np.split(arr,(2,5,8)))) #1623480949744 1623494518720
'''
说明原数组与分割后的数列，内存不同，但它们的内存是共享的
'''
arr=arr.reshape(3,4)
print("arr\n",arr)
'''
arr
 [[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
'''
arr2=np.split(arr,(1,3),axis=1)
print(arr2)
'''

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

总结：

• （1）numpy.split(ary, indices_or_sections, axis) 会使原数组与分割后的数列，内存不同，但它们的内存是共享的
• （2）axis参数的值它是沿着某个方向分割

4.2 numpy.hsplit

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

harr = np.floor(10 * np.random.random((2, 6)))
print(harr)
#[[3. 9. 9. 9. 4. 5.]
#  [9. 4. 4. 4. 2. 3.]]
print(np.hsplit(harr, 3))
# [array([[3., 9.],
#        [9., 4.]]), array([[9., 9.],
#        [4., 4.]]), array([[4., 5.],
#        [2., 3.]])]

相当于numpy.split()的axis=1

4.3、numpy.vsplit

numpy.vsplit 沿着垂直轴分割，其分割方式与hsplit用法相同。

a = np.arange(16).reshape(4,4) 
print (a)
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]
#  [12 13 14 15]]
b = np.vsplit(a,2)
print (b)
b[0][0][0]=44
# [array([[0, 1, 2, 3],
#        [4, 5, 6, 7]]), array([[ 8,  9, 10, 11],
#        [12, 13, 14, 15]])]
print(a)
'''
[[44  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]
'''

相当于numpy.split()的axis=0