Array数组：

# 对于ndarray结构老说，里面所有的 元素必须是同一类型的，如果不是的话，会自动的向下进行转换。
import numpy as np

lxw = [1, 2, 3, 4, 5]
lxw2 = np.array([1, 2, 3, 4, 5])
print(lxw2)
print(type(lxw2))

lxw3 = lxw2 + 1
print(lxw2)
print(lxw3)
print(lxw3+lxw2)

print(lxw3[3])
print(lxw3.shape)

lxw4 = np.array([
    [1, 3, 5],
    [2, 4, 6]
])
print(lxw4)

# 类型
print(lxw4.dtype)

print(lxw4.itemsize)

# 数组个数
print(lxw4.size)

# 维度
print(lxw4.ndim)

# 以0填充
lxw4.fill(0)
print(lxw4)

索引与切片：与python大同小异，还是从0开始

lxw_array = np.array(lxw)
print(lxw_array[0])

print(lxw_array[1:4])

print(lxw_array[-3:])


# 矩阵格式【即多维的形式】
lxw_array2 = np.array([
    [9, 8, 7],
    [6, 5, 4],
    [3, 2, 1]
])

print(lxw_array2)

# 几行几列
print(lxw_array2.shape)

# 数组个数
print(lxw_array2.size)

# 维度几维
print(lxw_array2.ndim)

# 取矩阵行
print(lxw_array2[1])

# 取矩阵列
print(lxw_array2[:, 1])

# 取第二行的第一二个
print(lxw_array2[1, 0:2])

# 修改矩阵最中间的数
lxw_array2[1, 1] = 20
print(lxw_array2)

# 复制矩阵
lxw_array3 = lxw_array2.copy()
print(lxw_array3)

# 修改复制矩阵最中间的数
lxw_array3[1, 1] = 52
print(lxw_array3)


gs = np.arange(0, 100, 10)
print(gs)


mask = np.array([0, 1, 1, 0, 0, 1, 0, 1, 0, 1], dtype=bool)
print(mask)

print(gs[mask])


ran_arr = np.random.rand(8)
print(ran_arr)

mask = ran_arr > 0.5
print(mask)

sz = np.array([12, 23, 34, 45, 56])
print(sz > 36)

# 大于该数的为True，反之，则是False
print(np.where(sz > 36))

# 字节个数
print(sz.nbytes)

# 整数，小数，字符同时存在
sz2 = np.array([1, 23, 6.2, 'str'], dtype=np.object)
print(sz2)
print(sz2*2)

# 转化为浮点型
sz3 = np.asarray(sz, dtype=np.float32)
print(sz3)

# 法2（上）
sz3 = sz.astype(np.float32)
print(sz3)

数值运算–array数组

szjs = np.array([
    [5, 2, 0],
    [1, 3, 2]
])

# 数组内全数相加
print(np.sum(szjs))

# 指定要进行的操作是沿着什么轴（维度）
# 列加：
print(np.sum(szjs, axis=0))

# 法二（同上）：
lj = szjs.sum(axis=0)
print(lj)

# 行加：
print(np.sum(szjs, axis=1))

# 法二（同上）：
hj = szjs.sum(axis=1)
print(hj)

# 列乘：
lc = szjs.prod(axis=0)
print(lc)

# 行乘：
hc = szjs.prod(axis=1)
print(hc)

# szjs当中最小值：
zxz = szjs.min()
print(zxz)

# 哪个位置的数最小
argx = szjs.argmin()
print(argx)

# 列最小值：
lzxz = szjs.min(axis=0)
print(lzxz)

# 行最小值：
hzxz = szjs.min(axis=1)
print(hzxz)

# szjs当中最大值
zdz = szjs.max()
print(zdz)

# 哪个位置的数最大
argd = szjs.argmax()
print(argd)

# 列最大值：
lzdz = szjs.max(axis=0)
print(lzdz)

# 行最大值：
hzdz = szjs.max(axis=1)
print(hzdz)

largd = szjs.argmax(axis=0)
print(largd)

hargd = szjs.argmax(axis=1)
print(hargd)


largx = szjs.argmin(axis=0)
print(largx)

largx = szjs.argmin(axis=1)
print(largx)

# 均值：
jz = szjs.mean()
print(jz)

# 列均值：
ljz = szjs.mean(axis=0)
print(ljz)

# 行均值：
hjz = szjs.mean(axis=1)
print(hjz)


# 标准差:
bzc = szjs.std()
print(bzc)

# 列标准差：
lbzc = szjs.std(axis=0)
print(lbzc)

# 行标准差：
hbzc = szjs.std(axis=1)
print(hbzc)


# 方差：
fc = szjs.var()
print(fc)

# 列方差
lfc = szjs.var(axis=0)
print(lfc)

# 行方差
hfc = szjs.var(axis=1)
print(hfc)

# 限制,大于该数的用指定最大数表示，反之也一样【在区间内的不用管】
xz = szjs.clip(0, 3)
print(xz)

# 小数四舍五入成整数
xsz = np.array([2.6, 1.46, 8.41])
print(xsz.round())

# 四舍五入中指定小数点
print(xsz.round(decimals=1))

排序操作：

pxsz = np.array([
    [3, 8, 2],
    [9, 4, 1],
    [3, 9, 1]
])
# 默认axis=1排序
print(np.sort(pxsz))

print(np.sort(pxsz, axis=0))

# 行逆转
print(np.sort(pxsz)[::-1])

# 排序前的位置
wz = np.argsort(pxsz)
print(wz)

# 插数
pxarr = np.linspace(0, 10, 8)
print(pxarr)

xszz = np.array([5.2, 6.6, 8.9])
print(np.searchsorted(pxarr, xszz))

数组形状操作

larr = np.arange(10)
print(larr)

print(larr.shape)

larr.shape = 2, 5
print(larr)

# 仔细感受其间的区别：
res = larr.reshape(1, 10)
print(res)
print(res.shape)

res2 = res[np.newaxis, :]
print(res2)
print(res2.shape)

res3 = res[:, np.newaxis]
print(res3)
print(res3.shape)

res4 = res[:, np.newaxis, np.newaxis]
print(res4)
print(res4.shape)

# 压缩：
res5 = res4.squeeze()
print(res5)

# 转置列行：
print(larr.transpose())

# 法二（同上）：
print(larr.T)

数组的连接：

lj1 = np.array([
    [213, 324, 543],
    [23, 65, 865]
])

lj2 = np.array([
    [343, 654, 234],
    [54, 75, 54]
])

# 列拼接：
llj = np.concatenate((lj1, lj2))
print(llj)

llj2 = np.vstack((lj1, lj2))
print(llj2)

# 行拼接：
hlj = np.concatenate((lj1, lj2), axis=1)
print(hlj)

hlj2 = np.hstack((lj1, lj2))
print(hlj2)

# 拉平：
lp = hlj.flatten()
print(lp)

lp2 = llj.ravel()
print(lp2)

数组生成–构造出来一个数组

sz1 = np.array([5, 2, 0])
print(sz1)

sz2 = np.arange(10)
print(sz2)

sz3 = np.arange(2, 20, 2)
print(sz3)

sz4 = np.arange(2, 20, 2, dtype=np.float32)
print(sz4)

# 区间内构造n个数：
gzs = np.linspace(0, 8, 20)
print(gzs)

# 默认是以10为底的
s = np.logspace(0, 1, 5)
print(s)

x = np.linspace(-10, 10, 5)
print(x)

y = np.linspace(-10, 10, 5)
print(y)

# 构造网格：
x, y = np.meshgrid(x, y)
print(x)
print(y)

hxl = np.r_[0:10:1]
print(hxl)

lxl = np.c_[0:10:1]
print(lxl)

# 更常用的zeros、ones
oo = np.zeros(3)
print(oo)

oo0 = np.zeros((3, 3))
print(oo0)

oo1 = np.ones((3, 3))
print(oo1)

oo8 = np.ones((3, 3)) * 8
print(oo8)

oo5 = np.ones((3, 3), dtype=np.float32)
print(oo5)

k = np.empty(6)
print(k)

k.fill(1)
print(k)

o = np.ones_like(sz1)
print(o)

# 构造矩阵：
print(np.identity(5))