矩阵

    当做多维列表，层级嵌套，便于理解。

    也可以当做：属性+样本。二维的容易理解，更高维度的属性当做多维属性即可。

    向量理解：各组向量合成统一值。低维度向量合成高维度向量，然后组合。

    矩阵理解：抽取简单逻辑，复杂数据由矩阵代替，关心关系而非细节计算。

创建

    指定

data = numpy.array([[1,2,3],[4,5,6],[7,8,9]])

    随机

data = np.random.random([3, 4])

data = np.arange(0, 100, 10)

data = np.arange(0, 100, 10)
# 属性折叠自身值变化
data.shape = 2, 5
# 方法折叠生成新矩阵，自身不变
new = data.reshape((2, 5))
# 指定一边-1，表示自动计算
b = data.reshape((5, -1))

    拉平

# 多维
data = np.array([[1, 2, 3], [4, 5, 6]])
# 长条一维
a = data.ravel()

    分割

data = np.linspace(0, 100, 10)

    定值

# 零阵
zeros = np.zeros([2, 2])
'''
[[ 0.  0.]
 [ 0.  0.]]
'''
# 一阵
ones = np.ones([2, 2])
'''
[[ 1.  1.]
 [ 1.  1.]]
'''
# 自定阵
nums = np.tile([3], (2, 2))
'''
[[3 3]
 [3 3]]
'''

    读取

# @1 文件名 
# @2 分割符
# @3 数据类型
data = np.genfromtxt('data.txt', delimiter=',', dtype=str)

属性

    类型

# 数据类型，同一矩阵类型单一统一
data.dtype

    维度

# 维度
data.ndim

# 形状
data.shape

查询

    索引

数字索引

data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# 取第一个
index_0 = data[0]  # [[1, 2, 3]]

布尔索引

data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
bool_index = [False, True, False]
result = data[bool_index] # [[4 5 6]]

    切片

单切片

data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# 前置索引，单切最小维度
# 索引包小不包大
index_1_split_1_2 = data[1, 1:2] # [5]

层切片

data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# 索引是切片特殊单值形态
# 切片是范围索引指定
index_1_split_1_2 = data[0:2, :-1]
'''
[[1 2]
 [4 5]]
'''

拼接

水平拼接

A = np.arange(1, 4)
B = np.arange(4, 7)
# 水平对接，行数相同
h_stack = np.hstack((A, B))
# [1 2 3 4 5 6]

垂直拼接

A = np.arange(1, 4)
B = np.arange(4, 7)
# 垂直对接， 列数相同
v_stack = np.vstack((A, B))
'''
[[1 2 3]
 [4 5 6]]
'''

原子扩展

# 以基本数据为原子， 生成矩阵
# 数据为最低维， 原数组不组合
A = np.arange(1, 4)
base_to_all = np.tile(A, (3, 4))
print(base_to_all)
'''
[[1 2 3 1 2 3 1 2 3 1 2 3]
 [1 2 3 1 2 3 1 2 3 1 2 3]
 [1 2 3 1 2 3 1 2 3 1 2 3]]
'''

切分

    水平切分

b = np.arange(9)
# [0 1 2 3 4 5 6 7 8]
# 判断列宽，平均切割，不均报错
a = np.hsplit(b, 3)
# [array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]

    垂直切分

b = np.arange(9).reshape((3, 3))
'''
[[0 1 2]
 [3 4 5]
 [6 7 8]]
'''
# 判断列高，平均切割，不均报错
print(b)
a = np.vsplit(b, 3)
# [array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])]

复制

    假赋值

A = np.arange(3)
# 直接相等
B = A
# 两个指向同一个实体
print(id(A) == id(B))   # True
# 操作相互等价影响
B[0] = 999
# 引用复制，假复制
print(A is B)           # True

    浅复制

A = np.arange(3)
# view复制
B = A.view()
# 不同实体
print(id(A) == id(B))   # False
# 数据相关
B[0] = 999
# 实体不同，数据相关，浅复制
print(A[0] == B[0])     # True

    深复制

A = np.arange(3)
# view复制
B = A.copy()
# 不同实体
print(id(A) == id(B))   # False
# 数据无关
B[0] = 999
# 实体不同，数据无关，真·复制
print(A[0] == B[0])     # False

排序

自排

# 自排，自身顺序变化
A = np.array([[1, 2, 3], [3, 1, 1], [2, 1, 1]])
# 竖排，行(hang)为集体，上下调整，首位为大
A.sort(axis=1)
'''
[[1 2 3]
 [1 1 3]
 [1 1 2]]
'''
# 横排，列为集体，行序不变，单列上下
A.sort(axis=0)
'''
[[1 1 1]
 [2 1 1]
 [3 2 3]]
'''

外排

# 外排，自身不变，返回排序结果
A = np.array([[1, 2, 3], [3, 1, 1], [2, 1, 1]])
# 竖排，行(hang)为集体，上下调整，首位为大
B = np.sort(A, axis=1)
'''
[[1 2 3]
 [1 1 3]
 [1 1 2]]
'''
# 横排，列为集体，行序不变，单列上下
B = np.sort(A, axis=0)
'''
[[1 1 1]
 [2 1 1]
 [3 2 3]]
'''

索引

# 索引排序
A = np.array([[1, 2, 3], [3, 1, 1], [2, 1, 1]])
# 自索引排序
C = A.argsort(axis=0)
'''
[[0 1 1]
 [2 2 2]
 [1 0 0]]
'''
# 外部索引排序
B = np.argsort(A, axis=1)
'''
[[0 1 2]
 [1 2 0]
 [1 2 0]]
'''
# 索引位置依据排列方向查找

计算

比较

A = np.arange(9).reshape((3, 3))
# 进入内部，最小维度比较
B = A > 4
'''
[[False False False]
 [False False  True]
 [ True  True  True]]
'''

筛选：比较+bool索引

A = np.arange(9).reshape((3, 3))
# 进入内部，最小维度比较
B = A > 4
# bool索引取值
C = A[B]
# [5 6 7 8]

筛选：极值

A = np.arange(9).reshape((3, 3))
# 列，自筛，最大
C = A.max(axis=0)
# [6 7 8]

# 行，外筛，最小 
B = np.min(A, axis=1)
# [0 3 6]

加

# 加
A = np.arange(9).reshape((3, 3))
B = np.ones((3, 3))
# 单值，顺序不论
C = A + 3
'''
[[ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]
'''
# 矩阵，顺序不论
D = B + C
'''
[[  4.   5.   6.]
 [  7.   8.   9.]
 [ 10.  11.  12.]]
'''

减

    同加，顺序不逆

乘

# 乘
A = np.arange(9).reshape((3, 3))
B = np.tile([2], (3, 3))
# 单值乘，顺序不论
C = A * 3
'''
[[ 0  3  6]
 [ 9 12 15]
 [18 21 24]]
'''
# 矩阵点乘，对应相乘，顺序不论
D = B * C
'''
[[ 0  6 12]
 [18 24 30]
 [36 42 48]]
'''
# 矩阵叉乘，横竖交叉，顺序不逆
E = np.multiply(B, C)
'''
[[ 0  6 12]
 [18 24 30]
 [36 42 48]]
'''

除

# 除
A = np.arange(9).reshape((3, 3))
B = np.tile([2], (3, 3))
# 单值除，顺序不逆
C = A / 3
'''
[[ 0.          0.33333333  0.66666667]
 [ 1.          1.33333333  1.66666667]
 [ 2.          2.33333333  2.66666667]]
'''
print(C)
# 矩阵对应相除，顺序不逆
D = C / B
'''
[[ 0.          0.16666667  0.33333333]
 [ 0.5         0.66666667  0.83333333]
 [ 1.          1.16666667  1.33333333]]
'''
print(D)
# 矩阵除法，好吧，暴露自己是假矩阵了
# 转化
E = np.asmatrix(B)
# 新生
F = np.mat(B)
G = np.multiply(B, E.I)
# 结果为1，不过没化简，奇异值矩阵会报错