numpy基础

涉及到的随机数生成方法：
numpy.random.randn()用法
如 numpy.random.randn(d0,d1,…,dn)
randn函数返回一个或一组样本，具有标准正态分布。
dn表格每个维度
返回值为指定维度的array

# import
import numpy as np

# array
# array.shape	数组的维度，对于矩阵，n 行 m 列
# array.size	数组元素的总个数，相当于 .shape 中 n*m 的值
# array.dtype	ndarray 对象的元素类型

data = np.array([[1, 2], [3, 4]])
print(data)

print(data.shape)
print(data.dtype)

[[1 2]
 [3 4]]
(2, 2)
int64

# initialization

# zeros()：创建一个矩阵，内部元素均为0，第一个参数提供维度，第二个参数提供类型。
d0 = np.zeros((3, 3))
print(d0)

# ones()：创建一个矩阵，内部元素均为1，第一个参数提供维度，第二个参数提供类型
d1 = np.ones((3, 3), dtype=np.int)
print(d1)

# eyes(): 可以用来构造单位矩阵
di = np.eye(3, dtype=np.int)
print(di)

# numpy.reshape
# numpy.reshape 函数可以在不改变数据的条件下修改形状，格式如下： numpy.reshape(arr, newshape, order='C')
# arr：要修改形状的数组
# newshape：整数或者整数数组，新的形状应当兼容原有形状
# order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'k' -- 元素在内存中的出现顺序。

# numpy 包中的使用 arange 函数创建数值范围并返回 ndarray 对象，函数格式如下：
# numpy.arange(start, stop, step, dtype)
# 根据 start 与 stop 指定的范围以及 step 设定的步长，生成一个 ndarray。
# start	起始值，默认为0
# stop	终止值（不包含）
# step	步长，默认为1
# dtype	返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。

# 即从0开始以步长为1的形式生成9个int数据，并修改形状为3*3的数组
drange = np.arange(9).reshape((3, 3))
print(drange)

# https://blog.csdn.net/u012149181/article/details/78913167
# numpy.random.randn(d0,d1,…,dn)
# randn函数返回一个或一组样本，具有标准正态分布。
# dn表格每个维度
# 返回值为指定维度的array

# 即在标准正态分布中返回9个样本值，并修改为3*3的数组
drandom = np.random.randn(9).reshape((3, 3))
print(drandom)

# numpy.empty 方法用来创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组：
# numpy.empty(shape, dtype = float, order = 'C')
# shape	数组形状
# dtype	数据类型，可选
# order	有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。
dempty = np.empty((2, 2))
print(dempty)

[[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]
[[1 1 1]
 [1 1 1]
 [1 1 1]]
[[1 0 0]
 [0 1 0]
 [0 0 1]]
[[0 1 2]
 [3 4 5]
 [6 7 8]]
[[-0.72283773  0.40997815  0.25098051]
 [ 0.23528151  1.0674242  -0.97231992]
 [-3.07002483  0.88595129 -0.1859575 ]]
[[6.94892067e-310 6.94892067e-310]
 [5.98153058e-154 4.06319587e-320]]

# access with int index
drange = np.arange(9).reshape((3, 3))

print(drange)
print(drange[1, 1])
print(drange[1][1])
print(drange[1])
print(drange[-1])
# ndarray对象的内容可以通过索引或切片来访问和修改，与 Python 中 list 的切片操作一样。
# ndarray 数组可以基于 0 - n 的下标进行索引，切片对象可以通过内置的 slice 函数，并设置 start, stop 及 step 参数进行，从原数组中切割出一个新数组。
# 冒号 : 的解释：如果只放置一个参数，如 [2]，将返回与该索引相对应的单个元素。
# 如果为 [2:]，表示从该索引开始以后的所有项都将被提取。如果使用了两个参数，如 [2:7]，那么则提取两个索引(不包括停止索引)之间的项。
# 即切片操作包括开始索引start，不包括结束索引stop

# numpy的切片操作，一般结构如num[a:b,c:d]，分析时以逗号为分隔符，
# 逗号之前为要取的num行的下标范围(a到b-1)，逗号之后为要取的num列的下标范围(c到d-1)；
# 前面是行索引，后面是列索引。
# 如果是这种num[:b,c:d]，a的值未指定，那么a为最小值0；
# 如果是这种num[a:,c:d]，b的值未指定，那么b为最大值；c、d的情况同理可得。

print(drange[:2]) # view前两行(第0、1 行)
print(drange[-2:]) # view后两行

drange[0, 1] = 11 # 修改值
print(drange)

drange[:2, 1:] = 22 # 前两行（第0/1行）且第1列（包括第1列）以后的值改为22
print(drange)

[[0 1 2]
 [3 4 5]
 [6 7 8]]
4
4
[3 4 5]
[6 7 8]
[[0 1 2]
 [3 4 5]]
[[3 4 5]
 [6 7 8]]
[[ 0 11  2]
 [ 3  4  5]
 [ 6  7  8]]
[[ 0 22 22]
 [ 3 22 22]
 [ 6  7  8]]

# access with bool index
drange = np.arange(9).reshape((3, 3))
drandom = np.random.randn(9).reshape((3, 3))

print(drandom)
print(drandom > 0)

print(drange)
print(drange[drandom > 0])

[[ 2.97956313  0.20275556 -0.01036693]
 [ 0.23932214 -0.63340143 -0.55149689]
 [ 0.61465404  1.00743447 -1.74177278]]
[[ True  True False]
 [ True False False]
 [ True  True False]]
[[0 1 2]
 [3 4 5]
 [6 7 8]]
[0 1 3 6 7]

# array-oriented programming
drange = np.arange(9).reshape((3, 3))

print(drange)
# matrix 矩阵相加
print(d1) # d1是前面生成的3*3的单位阵
print(drange + d1) # more efficient
# vectorization 每一项分别加1
print(drange + 1)
# broadcast
# 每行对应相加[0, 1 ,2]
print(drange + [0, 1, 2])

[[0 1 2]
 [3 4 5]
 [6 7 8]]
[[1 1 1]
 [1 1 1]
 [1 1 1]]
[[1 2 3]
 [4 5 6]
 [7 8 9]]
[[1 2 3]
 [4 5 6]
 [7 8 9]]
[[ 0  2  4]
 [ 3  5  7]
 [ 6  8 10]]

# math operations

drandom = np.arange(9)
print(drandom)

print(drandom.sum())
# 函数原型：numpy.cumsum(a, axis=None, dtype=None, out=None)
# 函数作用：求数组的所有元素的累计和，可通过参数axis指定求某个轴向的统计值。
print(drandom.cumsum())

# numpy.mean() 函数返回数组中元素的算术平均值。 如果提供了轴，则沿其计算。算术平均值是沿轴的元素的总和除以元素的数量。
print(drandom.mean())

# 标准差是一组数据平均值分散程度的一种度量。标准差是方差的算术平方根。
# 标准差公式如下：std = sqrt(mean((x - x.mean())**2))
print(drandom.std())

[0 1 2 3 4 5 6 7 8]
36
[ 0  1  3  6 10 15 21 28 36]
4.0
2.581988897471611

# linear algebra operations
# more from cipy.linalg
drange = np.arange(9).reshape((3, 3))
print(drange)
# 矩阵转置 T
print(drange.T)
# numpy.dot() 对于两个一维的数组，计算的是这两个数组对应下标元素的乘积和(数学上称之为内积)；对于二维数组，计算的是两个数组的矩阵乘积；
# 对于多维数组，它的通用计算公式如下，即结果数组中的每个元素都是：
#     数组a的最后一维上的所有元素与数组b的倒数第二位上的所有元素的乘积和： dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])。
print(drange.dot(drange))

[[0 1 2]
 [3 4 5]
 [6 7 8]]
[[0 3 6]
 [1 4 7]
 [2 5 8]]
[[ 15  18  21]
 [ 42  54  66]
 [ 69  90 111]]

# random operations
# more from np.random
drandom = np.arange(9)
# shuffle() 方法将序列的所有元素随机排序
np.random.shuffle(drandom)

print(drandom)

[8 1 5 6 0 7 3 4 2]