some code about numpy

import numpy as np
np.__version__ #版本

#由于python的list不要求存储同样的类型，但是效率不高。

L = [i for i in range(10)]
L[5] = "Asuka"

#而调用array的效率相比更好，但是它没有将数据当做向量或者矩阵，不支持基本运算，会报错。
#建议用numpy中的array
nparr = np.array([i for i in range(10)])

nparr[5] = 100.0 #整数可以换成浮点型

nparr.dtype #数据类型

np.zeros(10)     #0向量
np.zeros(10, dtype=float)
np.zeros((3, 5))     #0矩阵
np.zeros(shape=(3, 5), dtype=int)

np.ones(10)     #单位向量
np.ones((3, 5))    #单位矩阵

np.full((3, 5), 666)    #填充666
np.full(fill_value=666, shape=(3, 5))

np.arange(0, 20, 2)     # 2为step，而且与range相比，是可以用小数的
np.arange(0,10,1.5)

np.linspace(0, 20, 11)    #等分

np.random.randint(0, 10)     #0~10之间的随机数
np.random.randint(0, 10, size=10)      #长度为10的向量
np.random.randint(0, 10, size=(3,5))    #矩阵
np.random.seed(666)   #随机种子，再次调用时会产生相同的随机数
np.random.random()     #返回在[0.0，1.0]之间的随机浮点数
np.random.random((3,5))

np.random.normal()     #均值为0，方差为1，符合正态分布的一个数
np.random.normal(10, 100)    #均值为10，方差为100
np.random.normal(0, 1, (3, 5))

# 查询操作
① np.random.normal?
② help(np.random.normal)

X = np.arange(15).reshape((3, 5))
X.ndim    #维度
X.shape     #形状
X.size     #大小

X[:2, :3]
X[:2][:3] # 与前者结果不同，在numpy中使用","做多维索引
X[:2, ::2]
X[::-1, ::-1]

subX = X[:2, :3].copy()    #副本，数据的变动不会影响原始数据

X.reshape(5, 3)     #换形状
X.reshape(3, -1)
X.reshape(5, -1)

# 向量合并
x = np.array([1, 2, 3])
y = np.array([3, 2, 1])
z = np.array([666, 666, 666])
np.concatenate([x, y, z])

# 矩阵合并
A = np.array([[1, 2, 3],[4, 5, 6]])
np.concatenate([A, A])      # 纵向合并
np.concatenate([A, A], axis=1)    #横向合并

# 但是，concatenate是无法直接对向量和矩阵进行合并的，要讲向量转成矩阵在合并，如下：
np.concatenate([A, z.reshape(1, -1)])

# numpy提供了更便捷的vstack与hstack直接进行垂直or水平合并
np.vstack([A, z])
B = np.full((2,2), 100)
np.hstack([A, B])

# 向量分割
x = np.arange(10)
x1, x2 = np.split(x, [5])      # 01234|56789
x1, x2, x3 = np.split(x, [3, 7])   # 012|3456|789

# 矩阵分割
A = np.arange(16).reshape((4, 4))
A1, A2 = np.split(A, [2])    #垂直方向
A1, A2 = np.split(A, [2], axis=1)     #水平方向

#当然，numpy也提供了直接分割的方法：vsplit/hsplit
upper, lower = np.vsplit(A, [2]).
left, right = np.hsplit(A, [2])

#每个数都乘2
import numpy as np
L = np.arange(10)
%%time
A = np.array(2*e for e in L)   #11ms
%%time 
A = 2 * L    #大概3ms的亚子，这样快

X = np.arange(1, 16).reshape((3, 5))
X + 1   #全部元素+1，减乘除同理
X // 2   #除且取整
X ** 2  #平方
X % 2  #取模
1 / X    #倒数
np.abs(X)  #绝对值
np.exp(X)  #exp
np.exp2(X)   #以2为底，X为幂
np.power(3, X)    #以3为底，X为幂
np.log(X)    #lnx
np.log2(X)
np.log10(X)

# 矩阵运算
A = np.arange(4).reshape(2, 2)
B = np.full((2, 2), 10)
A * B    # 对应位置的元素相乘
A.dot(B)  # 矩阵乘法
A.T  # 转置
invA = np.linalg.inv(A)  #逆矩阵
invA.dot(A)    #原矩阵*逆矩阵=单位阵，前提是方阵，如果不是方阵，则error

# 对于非方阵，需要提及伪逆，即非方阵的求逆
X = np.arange(16).reshape((2, 8))
pinvX = np.linalg.pinv(X)
X.dot(pinvX)

# 向量与矩阵的运算

v = np.array([1, 2])
A = np.arange(4).reshape(2, 2)
v + A   #每一行都加上v，其内在机理是 np.vstack([v] * A.shape[0]) + A
np.tile(v, (2, 1)) + A   #也可这么写
np.tile(v, (2, 2))
v * A     # 对应位置的元素相乘
v.dot(A)    #1×2的v与2×2的A相乘
A.dot(v)    #2×2的A和转置后2×1的v相乘

# 聚合函数
import numpy as np
X = np.arange(16).reshape(4,-1)  
np.sum(X)    #求和
np.sum(X, axis=0)    #按列求和
np.sum(X, axis=1)    #按行求和
np.prod(X)    # X中各元素乘积
np.mean(X)   #均值
np.median(X)    #中位数
big_array = np.random.rand(1000000)
np.percentile(big_array, q=50)   #百分位数
for percent in [0, 25, 50, 75, 100]: #打印四分位数
　　print(np.percentile(big_array, q=percent))
np.var(big_array)    #方差
np.std(big_array)    #标准差
x = np.random.normal(0, 1, 1000000)    #正态分布
np.mean(x)
np.std(x)

np.argmin(x)   #最小值的索引
np.argmax(x)   #最大值的索引

x = np.arange(16)
np.random.shuffle(x)    #乱序
np.sort(x)    #排序，但是x并未改变
x.sort()     #排序
np.argsort(x)   # 排序索引
np.partition(x, 3)    #对指定的标准点3的两侧分别进行排序
np.argpartition(x, 3)     #对指定的标准点3的两侧分别进行排序的索引

#对于矩阵
X = np.random.randint(10, size=(4,4))
np.argsort(X, axis=1)     #水平方向的排序的索引
np.argpartition(X, 2, axis=1)     #带标准点2的水平方向的排序的索引

#比较操作
import numpy as np
x = np.arange(16)
np.random.shuffle(x)
np.count_nonzero( x <= 3)    #统计满足条件的元素数
np.sum(x <= 3)         #统计满足条件的元素数
np.sum((x > 3) & (x < 10))     #不能是&&
np.sum((x % 2 == 0) | (x > 10))        #统计满足条件的元素数
np.sum(~(x == 0))       #统计满足条件的元素数
np.any(x == 0)
np.any(x < 0)
np.all(x > 0)
np.all(x >= 0)
X = x.reshape(4, -1)
np.all(X > 0, axis=1)
np.sum(X % 2 == 0, axis=0)
np.sum(X % 2 == 0, axis=1)