#%%
# 用于处理数组，大概可分为以下几类
"""
修改数组形状
翻转数组
修改数组维度
连接数组
分割数组
数组元素的添加与删除
"""
#%% md
## 修改数组形状
#%%
"""
函数	描述
reshape	不改变数据的条件下修改形状
flat	数组元素迭代器
flatten	返回一份数组拷贝，对拷贝所做的修改不会影响原始数组
ravel	返回展开数组
"""
#%% md
### numpy.reshape
numpy.reshape 函数可以在不改变数据的条件下修改形状
#%%
# numpy.reshape(arr, newshape, order='C')
"""
arr：要修改形状的数组
newshape：整数或者整数数组，新的形状应当兼容原有形状
order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'k' -- 元素在内存中的出现顺序
"""
#%%
import numpy as np

a = np.arange(8)
a
#%%
b = a.reshape(4,2) # 4r2c
b
#%% md
### numpy.ndarray.flat
numpy.ndarray.flat 是一个数组元素迭代器
#%%
import numpy as np

a = np.arange(9).reshape(3, 3)
a
#%%
for _ in a: # 进行遍历 并非迭代遍历
    print(_) # 每行数据
#%%
# 迭代遍历
for _ in a.flat:
    print(_, end=', ') # 每个元素 按行顺序
#%% md
### numpy.ndarray.flatten
numpy.ndarray.flatten 返回一份数组拷贝，对拷贝所做的修改不会影响原始数组
#%%
# ndarray.flatten(order='C')
"""
order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'K' -- 元素在内存中的出现顺序
"""
#%%
import numpy as np

a = np.arange(8).reshape(2, 4)
a
#%%
a.flatten() # 展开后数组 nr1c | 水平
#%%
a.flatten(order='F') # 以 F 风格(垂直) 展开后数组 (新数组)
#%% md
### numpy.ravel
numpy.ravel() 展平的数组元素，顺序通常是"C风格"，返回的是数组视图（view，有点类似 C/C++引用reference的意味），修改会影响原始数组
#%%
# numpy.ravel(a, order='C')
"""
order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'K' -- 元素在内存中的出现顺序
"""
#%%
import numpy as np

a = np.arange(8).reshape(2, 4)
a
#%%
a.ravel() #  同样是展开数组 | 水平
#%%
a.ravel(order='F') # 垂直
#%% md
## 翻转数组
#%%
"""
函数	描述
transpose	对换数组的维度
ndarray.T	和 self.transpose() 相同
rollaxis	向后滚动指定的轴
swapaxes	对换数组的两个轴
"""
#%%
# numpy.transpose
# numpy.transpose 函数用于对换数组的维度
"""
numpy.transpose(arr, axes)
arr：要操作的数组
axes：整数列表，对应维度，通常所有维度都会对换
"""
#%%
import numpy as np

a = np.arange(12).reshape(3, 4)
a
#%%
np.transpose(a)
#%%
a.T
#%% md
### numpy.rollaxis
numpy.rollaxis 函数向后滚动特定的轴到一个特定位置
#%%
# numpy.rollaxis(arr, axis, start) | 不好理解
"""
arr：数组
axis：要向后滚动的轴，其它轴的相对位置不会改变
start：默认为零，表示完整的滚动。会滚动到特定位置
"""
#%%
import numpy as np

# 三维的数组
a = np.arange(8).reshape((2, 2, 2)) # 2组2行2列
a[0]
#%%
a[1]
#%%
# 获取其中一个值
print(np.where(a==6)) # 返回索引坐标
a[1,1,0] # 不同维度处理使用, 相同维度处理使用:
#%%
# 将轴 2 滚动到轴 0(宽度到深度)
"""
组行列
b0
000=0 010=2
100=4 110=6
b1
001=1 011=3
101=5 111=7
"""
b = np.rollaxis(a, 2, 0) #
b[0]
#%%
b[1]
#%%
# 将轴 2 滚动到轴 1 (宽度到高度)
"""
组行列
c0
000=0 010=2
001=1 011=3
c1
100=4 110=6
101=5 111=7
"""
c = np.rollaxis(a, 2, 1) # 水平取 垂直放
c[0]
#%%
c[1]
#%%
np.where(c==6)
#%% md
### numpy.swapaxes
numpy.swapaxes 函数用于交换数组的两个轴
#%%
# numpy.swapaxes(arr, axis1, axis2)
"""
arr：输入的数组
axis1：对应第一个轴的整数
axis2：对应第二个轴的整数
"""
#%%
import numpy as np
a = np.arange(8).reshape(2,2,2)
a[0]
#%%
a[1]
#%%
# 现在交换轴 0（深度方向）到轴 2（宽度方向）
b = np.swapaxes(a, 2, 0) # 这个类似水平处理
b[0]
#%%
b[1]
#%%
#  rollaxis 和 swapaxes (后续研究)
# https://zhuanlan.zhihu.com/p/162874970
#%% md
## 修改数组维度
#%%
"""
维度	描述
broadcast	产生模仿广播的对象
broadcast_to	将数组广播到新形状
expand_dims	扩展数组的形状
squeeze	从数组的形状中删除一维条目
"""
#%%
# numpy.broadcast
# numpy.broadcast 用于模仿广播的对象，它返回一个对象，该对象封装了将一个数组广播到另一个数组的结果
#%%
import numpy as np

x = np.array([
    [1],
    [2],
    [3]
])
x
#%%
y = np.array([4, 5, 6])
y
#%%
b = np.broadcast(x, y) # 对 y 广播 x
r,c = b.iters
b, r, c, b.shape # 广播对象的形状
#%%
while True:
    try:
        print('x=%d, y=%d' % (next(r), next(c)))
    except (Exception, BaseException):
        break
#%%
b = np.broadcast(x, y)
c = np.empty(b.shape)

print(c.shape)
c
#%%
c.flat = [u + v for (u, v) in b] # 进行加法运算
c
#%%
# 获得了和 NumPy 内建的广播支持相同的结果
x + y
#%% md
### numpy.broadcast_to
numpy.broadcast_to 函数将数组广播到新形状。它在原始数组上返回只读视图。 它通常不连续。 如果新形状不符合 NumPy 的广播规则，该函数可能会抛出ValueError
#%%
# numpy.broadcast_to(array, shape, subok)
#%%
import numpy as np

a = np.arange(4).reshape((1, 4))
a
#%%
np.broadcast_to(a, (4, 4)) # 广播为4r4c
#%% md
### numpy.expand_dims
numpy.expand_dims 函数通过在指定位置插入新的轴来扩展数组形状
#%%
# numpy.expand_dims(arr, axis)
"""
arr：输入数组
axis：新轴插入的位置
"""
#%%
import numpy as np

x = np.array((
    [1, 2],
    [3, 4]
))
x
#%%
y = np.expand_dims(x, axis=0) # 变3维
y
#%%
x.ndim, y.ndim, x.shape, y.shape
#%% md
### numpy.squeeze
numpy.squeeze 函数从给定数组的形状中删除一维的条目
#%%
# numpy.squeeze(arr, axis)
"""
arr：输入数组
axis：整数或整数元组，用于选择形状中一维条目的子集
"""
#%%
import numpy as np

x = np.arange(9).reshape((1, 3, 3))
x
#%%
y = np.squeeze(x) # 删除一维 原数组最外层应该只有1层
y
#%%
x.shape, y.shape
#%% md
## 连接数组
#%%
"""
函数	描述
concatenate	连接沿现有轴的数组序列
stack	沿着新的轴加入一系列数组。
hstack	水平堆叠序列中的数组（列方向）
vstack	竖直堆叠序列中的数组（行方向）
"""
#%% md
### numpy.concatenate
#%%
# numpy.concatenate((a1, a2, ...), axis)
"""
a1, a2, ...：相同类型的数组
axis：沿着它连接数组的轴，默认为 0
"""
#%%
import numpy as np

a = np.array([
    [1, 2],
    [3, 4]
])
a
#%%
b = np.array([
    [5, 6],
    [7, 8]
])
b
#%%
np.concatenate((a, b)) # 沿着0轴进行连接 垂直连接
#%%
np.concatenate((a, b), axis=1) # 沿轴 1 连接两个数组 水平连接
#%% md
### numpy.stack
numpy.stack 函数用于沿新轴连接数组序列
#%%
# numpy.stack(arrays, axis)
"""
arrays相同形状的数组序列
axis：返回数组中的轴，输入数组沿着它来堆叠
"""
#%%
import numpy as np

a = np.array([
    [1, 2],
    [3, 4]
])
a
#%%
b = np.array([
    [5, 6],
    [7, 8]
])
b
#%%
np.stack((a, b), 0) # 沿轴 0 堆叠两个数组 | 变三维 a b 各一组
#%%
np.stack((a, b), 1) # 沿轴 1 堆叠两个数组 | 变三维 a 与 b 混一起 垂直放
#%% md
### numpy.hstack
numpy.hstack 是 numpy.stack 函数的变体，它通过水平堆叠来生成数组
#%%
import numpy as np

np.hstack((a, b)) # 水平
#%% md
### numpy.vstack
numpy.vstack 是 numpy.stack 函数的变体，它通过垂直堆叠来生成数组
#%%
import numpy as np

np.vstack((a, b)) # 垂直
#%% md
## 分割数组
#%%
"""
函数	数组及操作
split	将一个数组分割为多个子数组
hsplit	将一个数组水平分割为多个子数组（按列）
vsplit	将一个数组垂直分割为多个子数组（按行）
"""
#%% md
### numpy.split
numpy.split 函数沿特定的轴将数组分割为子数组
#%%
# numpy.split(ary, indices_or_sections, axis)
"""
ary：被分割的数组
indices_or_sections：如果是一个整数，就用该数平均切分，如果是一个数组，为沿轴切分的位置（左开右闭）
axis：设置沿着哪个方向进行切分，默认为 0，横向切分，即水平方向。为 1 时，纵向切分，即竖直方向
"""
#%%
import numpy as np

a = np.arange(9)
a
#%%
b = np.split(a, 3) # 分为三个大小相等的子数组
b
#%%
b = np.split(a, [4, 7])# 将数组在一维数组中表明的位置分割 | 取前一个
b
#%%
# axis 为 0 时在水平方向分割，axis 为 1 时在垂直方向分割
import numpy as np

a = np.arange(16).reshape(4, 4)
a
#%%
np.split(a, 2) # 默认分割 (0轴) | 水平 整个分成各2行
#%%
np.split(a, 2, 1) # 垂直 分成 各2列
#%%
np.hsplit(a, 2) #  各2列
#%% md
### numpy.hsplit
#%%
# numpy.hsplit 函数用于水平分割数组，通过指定要返回的相同形状的数组数量来拆分原数组
harr = np.floor(10 * np.random.random((2, 6))) # 随机数 * 10 向下取整
harr
#%%
np.hsplit(harr, 3) # 分3列 01, 23, 45 水平算垂直切, 左到右
#%% md
### numpy.vsplit
#%%
# numpy.vsplit 沿着垂直轴分割，其分割方式与hsplit用法相同
np.vsplit(harr, 2) # 分2行 0,1 垂直算水平切,上下
#%% md
## 数组元素的添加与删除
#%%
"""
函数	元素及描述
resize	返回指定形状的新数组
append	将值添加到数组末尾
insert	沿指定轴将值插入到指定下标之前
delete	删掉某个轴的子数组，并返回删除后的新数组
unique	查找数组内的唯一元素
"""
#%% md
### numpy.resize
numpy.resize 函数返回指定大小的新数组。
如果新数组大小大于原始大小，则包含原始数组中的元素的副本
#%%
import numpy as np

a = np.array([
    [1, 2, 3],
    [4, 5, 6]
])
a
#%%
a.shape
#%%
b = np.resize(a, (3, 2)) # 有点类似 reshape
b
#%%
b.shape
#%%
b = np.resize(a, (3, 3)) # 要注意 a 的第一行在 b 中重复出现，因为尺寸变大了 这个就不像 reshape 了
b
#%% md
### 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时，数组是加在右边（行数要相同）。
"""
#%%
import numpy as np

a = np.array([
    [1, 2, 3],
    [4, 5, 6]
])
a
#%%
np.append(a, [7, 8, 9]) # 向数组添加元素
#%%
np.append(a, [[7, 8, 9]], axis=0) # 向下追加
#%%
np.append(a, [[5,5,5],[7, 8, 9]], axis=1) # 向右追加
#%% md
### numpy.insert
numpy.insert 函数在给定索引之前，沿给定轴在输入数组中插入值。
如果值的类型转换为要插入，则它与输入数组不同。 插入没有原地的，函数会返回一个新数组。 此外，如果未提供轴，则输入数组会被展开
#%%
import numpy as np

a = np.array([
    [1,2],
    [3,4],
    [5, 6]
])
a
#%%
np.insert(a, 3, [11,12]) # 未传递 Axis 参数。 在删除之前输入数组会被展开 | 先转为一维 再进行插入
#%%
# 传递了 Axis 参数。 会广播值数组来配输入数组
np.insert(a, 1, [11], axis=0) # 传递了 Axis 参数。 会广播值数组来配输入数组 | 1这里指行的索引
#%%
np.insert(a, 1, [11], axis=1) # 1这里指列的索引
#%% md
### numpy.delete
numpy.delete 函数返回从输入数组中删除指定子数组的新数组。 与 insert() 函数的情况一样，如果未提供轴参数，则输入数组将展开
#%%
# Numpy.delete(arr, obj, axis)
"""
arr：输入数组
obj：可以被切片，整数或者整数数组，表明要从输入数组删除的子数组
axis：沿着它删除给定子数组的轴，如果未提供，则输入数组会被展开
"""
#%%
import numpy as np

a = np.arange(12).reshape((3, 4))
a
#%%
# 未传递 Axis 参数。 在插入之前输入数组会被展开
np.delete(a, 5) # 索引5的元素没了 后面向前修改
#%%
np.delete(a, 1, axis=0) # 删除第二行 行索引1 4567没了
#%%
np.delete(a, 1, axis=1) # 删除第二列 列索引1 159没了
#%%
# 包含从数组中删除的替代值的切片
a = np.arange(1, 11)
a
#%%
np.delete(a, np.s_[::2]) # 步长2的保留 其余删除
#%% md
### numpy.unique
numpy.unique 函数用于去除数组中的重复元素
#%%
# numpy.unique(arr, return_index, return_inverse, return_counts)
"""
arr：输入数组，如果不是一维数组则会展开
return_index：如果为true，返回新列表元素在旧列表中的位置（下标），并以列表形式储
return_inverse：如果为true，返回旧列表元素在新列表中的位置（下标），并以列表形式储
return_counts：如果为true，返回去重数组中的元素在原数组中的出现次数
"""
#%%
import numpy as np

a = np.array([5,2,6,2,7,6,8,2,9])
a
#%%
u = np.unique(a) # 返回的都不重复的
u
#%%
u, indices = np.unique(a, return_index=True) # 去重数组的索引数组
u
#%%
indices # 不重复的元素的索引
#%%
a[indices] # 使用下标重构原数组
#%%
# 返回去重元素的重复数量
u, indices = np.unique(a, return_counts=True)
u
#%%
a
#%%
indices # 返回去重元素的重复数量
#%%