通用函数：快速的元素级数组函数
--------------------------------------------------------------------------------
通用函数（即ufunc）是一种对ndarray中的数据执行元素级运算的函数。你可以将
其看做简单函数（接受一个或多个标量值，并产生一个或多个标量值）的矢量化包装器。
--------------------------------------------------------------------------------
arr = np.arange(10)
np.sqrt(arr)        #每个元素开根号
np.exp(arr)         #科学常数 e 的元素次方
--------------------------------------------------------------------------------
二元通用函数
maximum(arr1, arr2)   # 两个数组对应位置，取出大值，组成新数组
--------------------------------------------------------------------------------
返回多个数组：
modf就是一个例子，它会返回浮点数数组的小数和整数部分

remainder, whole = np.modf(arr)
--------------------------------------------------------------------------------
常用的一元通用函数
abs, fabs     绝对值，整数，浮点，复数， 非复数 使用fabs 更快
sqrt          平方根
square        平方
exp           指数 e 的元素幂
log log10 log2 log1p
sign          符号函数，正1  负-1  0
ceil          大于等于参数的最小整数
floor         小于等于参数的最大整数
rint          四舍五入
modf          整数小数分离
isnan         是不是数字
isfinite isinf   有穷数， 无穷数
cos cosh sin sinh tan tanh  三角函数
arccos arccosh arcsin arcsinh arctan arctanh  反三角
logical_not    相当于去 -arr, 取负数 
--------------------------------------------------------------------------------
常用的二元通用函数
add                            Aarr+Barr
subtract                       Aarr-Barr
multiply                       a * b
divide    floor_divide         a/b   或 向下取整？？
power                          A^B, A元素的B元素次幂
maximum fmax                   最大值， fmax 忽略 NaN
minimum fmin
mod                            模运算
copysign                       把第二个数组的符号给一个数组使用
greater  greate_equal less less_equal
logical_and  logical_or  logic_xor
================================================================================
利用数组进行数据处理:
--------------------------------------------------------------------------------
arr1_2d, arr2_2d = np.meshgrid(arr1_1d, arr2_1d)
传入两个等长的1维数组，返回两个2维的数组

meshgrid 的产生数组说明

arr1_1d 是 1, 2, 3
arr2_1d 是 a, b, c
相互组合成一个二维坐标

   |     1    |     2    |      3
---+----------+----------+-------------
a  |    1,a   |    2,a   |     3,a
b  |    1,b   |    2,b   |     3,b
c  |    1,c   |    2,c   |     3,c

得到一个二维的数组，不过元素是元组(1,a),(2,a) ....
然后再拆分两个，即
arr1_2d 就是拆分后的
[
  [1, 2, 3],
  [1, 2, 3],
  [1, 2, 3]
]
arr2_2d 就是拆分后的
[
  [a, a, a],
  [b, b, b],
  [c, c, c]
]
--------------------------------------------------------------------------------
points = np.arange(-5,5,0.01)
xs, ys = np.meshgrid(points, points)
z = np.sqrt(xs**2 + ys**2)

以原点为中心 x,y 是 -5 到 5 的范围取出1000个点  z 是1000个点所在圆的半径组成的二维数组。

使用画图的方式画出来
import matplotlib.pyplot as plt
plt.imshow(z, cmap=plt.cm.gray)
plt.colorbar()                                                        # 画出，现在还没标题
plt.title("Image plot of $sqrt{x^2 + y^2}$ for a grid of values")    # 图的标题
--------------------------------------------------------------------------------
np.where 接收一个条件数组， 条件OK 返回数组，条件不满足返回另一个数组的元素

a1 = np.array([1,2,3,4,5])
a2 = np.array([11, 12, 13, 14, 15])
cond = np.array([True, True, False, True, False])

#原始做法, 慢，纯 python 的操作
# zap 后变成 [(1,11,True), [2,12,True],......]  对应位置上的元素组合成元组
[(a if c else b) for a, b, c in zip(a1, a2, cond)] 

#np 的做法，结果和上面的一样
np.where(cond, a1, a2)   

输出：array([ 1,  2, 13,  4, 15])
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
arr = np.random.randn(4,4)
np.where(arr > 0, 1, -1)
输出：
array([[-1, -1,  1, -1],
       [-1,  1, -1, -1],
       [-1,  1, -1, -1],
       [ 1,  1,  1,  1]])
       
np.where 第二个，第三个参数可以是数组，可以是标量， 可以是一个是数组，一个标量
--------------------------------------------------------------------------------
数学和统计方法
sum
mean
std 等：


arr = np.arange(20).reshape(4, 5)
arr
输出：
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14],
       [15, 16, 17, 18, 19]])
       
arr.mean()      数组内部方法
np.mean(arr)    顶级函数， 和上面的作用一样，计算均值
arr.sum()
np.sum(arr)     求和

arr.mean()， arr.sum() 里面还有一个参数 axis=0, 或者 axis=1  
axis=0 表示对列统计
axis=1 表示对行统计

arr.mean(axis=1)  求每一行的平均值
arr.mean(axis=0)  求每列的平均值

cumsum    累加  axis=0 列累加， 1行累加
cumprod   累乘  axis=0 列累乘， 1行累乘

这样的方法汇总：
sum               求和
mean              平均
std, var          标准差，方差
min, max          最大，最小
argmin, argmax    最大值 最小值的索引
cumsum            累加
cumprod           累乘
--------------------------------------------------------------------------------
用于bool类型数组的方法：
arr = np.random.randn(100)
(arr > 0).sum()         #满足条件的元素求和
(arr > 0.99).any()      #有一个满足就True
(arr > 0.1).all()       #所有满足才能 True
--------------------------------------------------------------------------------
排序 
arr.sort()
arr.sort(axis=0 或者 axis=1)  多维数组按照列排序还是行排序
排序改变了原数据的样貌，所有返回的是数据副本
--------------------------------------------------------------------------------
唯一化以及其它的集合逻辑
np.unique(arr)   先排序，然后去掉重复的， 返回的是唯一的，有序数组

np.in1d用于测试一个数组中的值在另一个数组中的成员资格，返回一个布尔型数组
values = np.array([6, 0, 0, 3, 2, 5, 6])
np.in1d(values, [2, 3, 6])
输出：
array([ True, False, False,  True,  True, False,  True])

数组的集合运输汇总
unique(arr)                返回有序，唯一元素的数组
intersect1d(arr1, arr2)    交集，有序
union1d(arr1, arr2)        并将，有序
in1d(arr1, arr2)           arr1 元素是否包含于y的bool数组
setdiff1d(arr1, arr2)      arr1-arr2
setxor1d(arr1, arr2)       （arr1并arr2） 减去 （arr1交arr2），也就是两边特有数据
================================================================================
np.save和np.load是读写磁盘数组数据的两个主要函数。默认情况下，数组是以未
压缩的原始二进制格式保存在扩展名为.npy的文件中的

arr = np.arange(10)
np.save('some_array', arr)

np.load('some_array.npy')    #带扩展名
--------------------------------------------------------------------------------
通过np.savez可以将多个数组保存到一个未压缩文件中，将数组以关键字参数的形式传入即可
np.savez('array_archive.npz', a=arr, b=arr)
加载.npz文件时，你会得到一个类似字典的对象，该对象会对各个数组进行延迟加载
arch = np.load('array_archive.npz')
arch['b']
--------------------------------------------------------------------------------
如果要将数据压缩，可以使用numpy.savez_compressed：
np.savez_compressed('arrays_compressed.npz', a=arr, b=arr)
================================================================================
线性代数
--------------------------------------------------------------------------------
矩阵乘法： a * b ， a,b是两个矩阵，不是点乘(对应位置上相乘)， 而是矩阵乘法
矩阵乘法是一行乘以一列....  a(m*n)   b(n*m)   得到的结果是 m*m 的新矩阵，
矩阵乘法要 注意乘数和被乘数的维度要匹配才能进行矩阵乘法
点乘是什么 （arr1 * arr2  这个就是点乘了）

x = np.array([[1., 2., 3.], [4., 5., 6.]])
y = np.array([[6., 23.], [-1, 7], [8, 9]])

#矩阵乘法 下面三者都可以，一样的
x.dot(y)
np.dot(x,y)
x @ y       # @符（类似Python3.5）也可以用作中缀运算符，进行矩阵乘法：
--------------------------------------------------------------------------------
numpy.linalg 中常用的函数
使用方式： from numpy.linalg import inv, qr
inv(arr)    # 对 arr 方阵求逆

方法列表
diag      把方阵的对角线取出组成一维数组返回，或者，把一维数组作为对角线，其他补0，返回一个方阵
dot       矩阵乘法
trace     对角线元素的和
det       矩阵的行列式
eig       方阵的本征值，本征向量
inv       方阵的逆
pinv      伪逆，满秩方阵才可求逆，如果秩不满，或不是方阵，只能是奇异矩阵求逆
qr        Qr分解
svd       计算奇异值分解
solve     解 Ax=b 方程组
lstsq     计算 Ax = b 的最小二乘解
--------------------------------------------------------------------------------
伪随机数生成
samples = np.random.normal(size=(4, 4))    #4*4的伪随机正态分布
随机生成器需要种子，相同的种子，生成的随机数可能相同。
所以要避免使用全局的种子

np.random.seed(1234)   # 指定种子，这样就不太好，大家都指定这个种子，生成的数据是一样的。

所以可以这样，生成一个隔离的种子
rng = np.random.RandomState(1234)
rng.randn(10)
--------------------------------------------------------------------------------
numpy.random 中的函数

seed          设置种子
permutation   返回一个序列的随机排列或者返回一个随机排列的范围
shuffle       对一个序列就地随机排序
rand          均匀样本
randint       给定的范围内随机选取整数
randn         正态分布（平均值为1，标准差为1）的样本
binomial      二项分布样本
normal        正态（高斯）分布
beta          Beta分别
chisquare     卡方分布
gamma         Gamma分布
uniform       [0,1) 均匀分布
--------------------------------------------------------------------------------
随机漫步：
要么向前走1，要么退回1，依据就是随机数

原始的 python 做法：
import random
position = 0
walk = [position]
steps = 1000
for i in range(steps):
  step = 1 if random.randint(0, 1) else -1
  position += step
  walk.append(position)
plt.plot(walk[:100])   #汇总 前100步的轨迹  # 画轨迹图

不好的地方是，每走一步，获取一个随机数， 效率也不高
使用 np 的随机方法，一次生成 100 个随机数，然后对数组操作，避免了循环
nsteps = 1000
draws = np.random.randint(0, 2, size=nsteps)  # 一次生成 100个 0或者1 组成的随机列表
steps = np.where(draws > 0, 1, -1)
walk = steps.cumsum()   #累加，这就是轨迹了
plt.plot(walk)          # 画轨迹图
--------------------------------------------------------------------------------

>> 目录 <<