numpy数组操作

更改数组形状
import numpy as np

# a = np.arange(8)                          # 创建0-8的一维数组
a = np.array([[1, 2, 3, 4], [3, 4, 5, 6]])
# 修改原数组的形状，即改变行列,order按照什么方式取出，排列，C按行，F按列，K内存中的顺序，A原顺序
a1 = a.reshape(4, 2, order='C')             # 新形状应要兼容原形状，即元素个数要能填充完要求的行列

b = np.arange(10).reshape(5, 2)
for i in b.flat:                            # flat 迭代器，可以迭代数组中的每个元素，不受维度影响
    break

b1 = b.flatten(order='F').reshape(2, 5)     # flatten 返回一份拷贝的数组元素，修改不会影响原数组

b2 = b.ravel(order='C')                     # ravel 展开数组元素成一维数组，修改会影响原数组
b2[1] = 11

c = np.arange(4).reshape(2,1,2)
c1 = c.squeeze()                            # squeeze 去除数组中维度为1的项目，修改会影响原数组
c1[1] = 20
"""
flatten , ravel , squeeze 异同
    都是将多维数组降为一维数组
    flatten 返回的是拷贝，修改不影响原数组
    ravel 返回的是视图view，修改会影响原数组
    squeeze 去除数组中维度为1的项目，修改也会影响原数组
"""

数组翻转
d = np.arange(8).reshape(2,2,2)

d1 = np.transpose(d)                       # transpose 行列转换，行变成列，列变成行
dd1 = d.transpose(2, 1, 0)                 # 带参数时，将轴按参数排列，如例将轴2转到轴0

d2 = d.T                                   # .T 行列转换,和不带参数的transpose一样

d3 = np.rollaxis(d, 2,0)                   # rollaxis 将某个轴移到另一个轴前面，三个参数：数组，要滚动的轴，目标位置（默认为0）

d4 = np.swapaxes(d, 0, 2)                  # swapaxes 将两个轴交换，三个参数：数组，轴，轴

"""
轴：数组从外到里依次为 0 1 2·····
rollaxis：滚动轴位置，就相当于数组里面的元素索引下标改变
    如: 将轴2滚动到轴0前，则索引下标由（001）→（100）
        将轴1滚动到轴0前，则索引下标由（010）→（100）
        将轴2滚动到轴1前，则索引下标由（010）→（001）
swapaxes：将轴位置互换，与带参数的transpose类似
两者区别：rollaxis是将某个轴提到指定轴的前面，swapaxes是将两个轴互换
"""
如例：

e = np.array([[[0,1,2,3],[11,22,33,44],[4,5,6,7]],[[8,9,10,11],[66,77,88,99],[12,13,14,15]]])
print(e)
print(e.shape) # 形状为（2,3,4）
e1 = np.rollaxis(e,2,0) # 滚动轴
print(e1)
print(e1.shape) # 形状为（4, 2，3）
e2 = np.swapaxes(e,2,0) # 交换轴
print(e2.shape) # 形状为（4, 3，2）

修改数组维度
x = np.array([[1],[2],[3]])
y = np.array([11,22,33])
s = np.broadcast(x,y)                       # 对y广播x,得到是对象，可以使用iters迭代
# r,w = s.iters                               # 迭代得到也是对象，使用next()调用
# print(next(r),next(w))                      # 依次将广播的结果迭代出来如（1,11）（1,22）...
z = np.empty(s.shape)                       # 根据指定的形状生成相应形状的空数组
z.flat = [u+v for (u,v) in s]               # u为数组x的元素，v为数组y的元素
print(z)                                    # 结果和x+y广播效果一样

s1 = np.broadcast_to(x,(3,3))               # 将数组广播到指定形状

aa = np.array([[1,2],[3,4]])
aa1 = np.expand_dims(aa,axis=1)             # 将某个数组作为一个整体插入到另外一个数组的某个轴内
print(aa.shape,aa1.shape)                   # 得到的aa1形状是（2,1,2）

连接及分割数组

bb = np.array([[5,6],[7,8]])
ab1 = np.concatenate((aa,bb))               # concatenate ，连接两个或多个数组，注意必须是维度相同的数组
ab2 = np.concatenate((aa,bb),axis=1)        # 参数axis可以指定以哪个轴进行连接

ab3 = np.stack((aa,bb),0)                   # stack 连接维度相同的数组，但是以新增一个轴的方式连接，参数指定以哪个轴堆叠
ab4 = np.hstack((aa,bb))                    # hstack 水平堆叠
ab5 = np.vstack((aa,bb))                    # vstack 垂直堆叠
"""
concatenate：以哪个轴连接时，就将哪个轴里的元素依次添加到另一个数组对应的轴中
        如上例：以轴0连接时结果为  [[1,2],[3,4],[5,6],[7,8]]
               以轴1连接时结果为  [[1,2,5,6],[3,4,7,8]]
        不会增加一个维度，因为轴里的元素是一个一个添加进去的
stack：数组形状必须相同，结果必将多一维
        如上例：以轴0堆叠时结果为  [[[1,2],[3,4]], [[5,6],[7,8]]]
               以轴1堆叠时结果为  [[[1,2],[5,6]], [[3,4],[7,8]]]
        以哪个轴就将这个轴里的元素作为一个整体添加到另一个数组对应的轴中
        
hstack：数组至少两维时，如两维时相当于np.concatenate((aa,bb),axis=1)
        但当只有一维时，则不相同，反而和np.concatenate((aa,bb),axis=0)相同
vstack：数组至少两维时，如两维时相当于np.concatenate((aa,bb),axis=0)
        但当只有一维时，与之不相同,反而类似stack，会整体添加进去，并增加一个维度
        如：a=[1,2,3]     b=[4,5,6] 
            np.vstack((a,b))得到的结果是 [[1,2,3], [4,5,6]]
"""

cc1 = np.split(aa,2)                        # split 分割，参数指定分割成相同的几个部分
cc2 = np.split(aa,[1,2])                    # 参数是数组时，则为指定位置分割

cc3 = np.hsplit(aa,2)                       # hsplit 依据横轴分割，参数为数字等分分割，为数组则指定位置分割
cc4 = np.vsplit(aa,2)                       # vsplit 依据纵轴分割，参数为数字等分分割，为数组则指定位置分割

 如示图：hsplit ：按照横轴竖着分割

　　　　 vsplit ：按照纵轴横着分割

添加与删除 

dd = np.array([1,2,3,4,5,6])
dd1 = np.resize(dd,(2,4))                   # resize 改变数组形状
# dd.resize((2,3))                          # 直接使用数组调用resize时，没有返回值，直接改变原数组形状
dd.resize((2,4))                            # 当改变数组形状，原数组中元素个数不够时，用0补足，多的时候舍去
"""
reshape：不管有无返回值，都不会改变原数组的形状，且里面的元素也不会变化
        变换后的形状要能完全容纳原数组的元素，不能多也不能少
resize：当使用 numpy 调用 resize 时会返回一个指定形状的新数组，此时不会改变原数组的形状
        当直接使用 数组 调用 resize 时，不会返回一个新数组，返回的是none，此时会改变原数组的形状
        当直接数组直接调用且原数组里的 元素不够填充 新形状时，用 0 补足
        当直接调用且原数组里的 元素填充完还有剩余时，舍去多余的元素
"""

ee = np.array([[1,2,3],[4,5,6]])
ee1 = np.append(ee,[11,22])                 # append 向数组尾部添加元素，无定义axis参数时返回必是一维数组
ee2 = np.append(ee,[[11,22,33]],axis=0)     # 当有axis参数时，则添加的元素必须和对应的轴形状相匹配
ee3 = np.append(ee,[[11],[33]],axis=1)      # 如例轴 1 append时，原数组有2行，则必须添加2项
# 注意：axis有定义时添加项需放在array中，且向数组添加时，每个子元素都是作为一个整体进行添加，所以每个子元素是array类型

ff = np.array([[1,2],[3,4],[5,6]])
ff1 = np.insert(ff,2,[11,22])               # insert 在指定位置 之前 插入值，无定义axis时，返回一维数组
ff2 = np.insert(ff,1,[11],axis=0)           # 定义axis参数时，则按照指定轴进行位置索引
ff3 = np.insert(ff,1,[[11],[22]],axis=1)    # 如例axis=1时，索引是1时，则在2,4,6之前都插入个11，22

ff11 = np.delete(ff,3)                      # delete 删除指定位置的元素，未定义axis时返回一维数组
ff22 = np.delete(ff,1,axis=0)               # 定义axis时，则按照指定轴进行位置索引
ff33 = np.delete(ff,np.s_[::2])             # 以步进为二的索引

g = np.array([2,3,1,2,3,5,7,3,4,5,6])
g1 = np.unique(g)                           # unique 去重，返回的是一个无重复元素的数组
g2,u1 = np.unique(g,return_index=True)      # return_index=True 返回去重后的数组每个元素在原数组中的索引下标
g3,u2 = np.unique(g,return_inverse=True)    # return_inverse=True 返回未去重的原数组的每个元素在去重后的数组中的索引下标
gg = g3[u2]                                 # 这样可以用已经去重后的数组重构原数组
g4,u3 = np.unique(g,return_counts=True)     # return_counts=True 返回每个元素重复的个数