通往人工智能之路（二）

NUMPY
python 的列表(list)可以是单一数据类型的，也可以是异构的。
例如
L=[True,"2",3.0,4]
numpy 为python 的list 数据类型提供了高效的操作。
import numpy as np
创建numpy 数组
np.array([1,4,2,5,3])
numpy数组与python list 不同，numpy 数组必须是相同数据类型。如果数据类型不同numpy就会向上转换，例如整数转浮点，或者数字转字符。
如果要明确定义数组类型用dtype关键字。
np.array([1, 2, 3, 4], dtype='float32')
python list是一维的，但是numpy 可以是多维的。
例如，利用嵌套的列表构成多维数组。
输入：np.array([range(i, i + 3) for i in [2, 4, 6]])
输出：array([[2, 3, 4],
[4, 5, 6],
[6, 7, 8]])
一些特殊的数组
创建一个长度为10的数组，数组的值都是0：
输入：np.zeros(10, dtype=int)
输出：array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
创建一个3×5的浮点型数组，数组的值都是1
输入：np.ones((3, 5), dtype=float)
输出：array([[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.]])
创建一个3×5的浮点型数组，数组的值都是3.14
输入：np.full((3, 5), 3.14)
输出：array([[ 3.14, 3.14, 3.14, 3.14, 3.14],
[ 3.14, 3.14, 3.14, 3.14, 3.14],
[ 3.14, 3.14, 3.14, 3.14, 3.14]])
创建一个3×5的浮点型数组，数组的值是一个线性序列，从0开始，到20结束，步长为2（它和内置的range()函数类似）
输入：np.arange(0, 20, 2)
输出：array([ 0, 2, 4, 6, 8, 10, 12, 14, 16, 18])
创建一个5个元素的数组，这5个数均匀地分配到0~1
输入：np.linspace(0, 1, 5)
输出：array([ 0. , 0.25, 0.5 , 0.75, 1. ])
创建一个3×3的、在0~1均匀分布的随机数组成的数组
输入：np.random.random((3, 3))
输出：array([[ 0.99844933, 0.52183819, 0.22421193],
[ 0.08007488, 0.45429293, 0.20941444],
[ 0.14360941, 0.96910973, 0.946117 ]])
创建一个3×3的、均值为0、方差为1的正态分布的随机数数组
输入：np.random.normal(0, 1, (3, 3))
输出：array([[ 1.51772646, 0.39614948, -0.10634696],
[ 0.25671348, 0.00732722, 0.37783601],
[ 0.68446945, 0.15926039, -0.70744073]])
创建一个3×3的、[0, 10)区间的随机整型数组
输入：np.random.randint(0, 10, (3, 3))
输出：array([[2, 3, 4],
[5, 7, 8],
[0, 5, 0]])
创建一个3×3的单位矩阵
输入：np.eye(3)
输出：array([[ 1., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., 1.]])
创建一个由3个整型数组成的未初始化的数组，数组的值是内存空间中的任意值
输入：np.empty(3)
输出：array([ 1., 1., 1.])
python 的数据类型
数据类型 描述
bool_ 布尔值（真、True 或假、False），用一个字节存储
int_ 默认整型（类似于 C 语言中的 long，通常情况下是 int64 或 int32）
intc 同 C 语言的 int 相同（通常是 int32 或 int64）
intp 用作索引的整型（和 C 语言的 ssize_t 相同，通常情况下是 int32 或int64）
int8 字节（byte，范围从–128 到 127）
int16 整型（范围从–32768 到 32767）
int32 整型（范围从–2147483648 到 2147483647）
int64 整型（范围从–9223372036854775808 到 9223372036854775807）
uint8 无符号整型（范围从 0 到 255）
uint16 无符号整型（范围从 0 到 65535）
uint32 无符号整型（范围从 0 到 4294967295）
uint64 无符号整型（范围从 0 到 18446744073709551615）
float_ float64 的简化形式
float16 半精度浮点型：符号比特位，5 比特位指数（exponent），10 比特位尾数（mantissa）
float32 单精度浮点型：符号比特位，8 比特位指数，23 比特位尾数
float64 双精度浮点型：符号比特位，11 比特位指数，52 比特位尾数
complex_ complex128 的简化形式
complex64 复数，由两个 32 位浮点数表示
complex128 复数，由两个 64 位浮点数表示
Numpy 数组
数组的属性：确定数组的大小、形状、存储大小、数据类型。
数组的索引：获取和设置数组各个元素的值。
数组的切分：在大的数组中获取或设置更小的子数组。
数组的变形：改变给定数组的形状。
数组的拼接和分裂：将多个数组合并为一个，以及将一个数组分裂成多个。
import numpy as np
np.random.seed(0) # 设置随机数种子
x1 = np.random.randint(10, size=6) # 一维数组
x2 = np.random.randint(10, size=(3, 4)) # 二维数组
x3 = np.random.randint(10, size=(3, 4, 5)) # 三维数组
#每个数组有 nidm（数组的维度）、shape（数组每个维度的大小）和size（数组的总大小）。
print("x3 ndim: ", x3.ndim)
print("x3 shape:", x3.shape)
print("x3 size: ", x3.size)
输出：
x3 ndim: 3
x3 shape: (3, 4, 5)
x3 size: 60
数组从右到左相当于x,y,z轴，例如size=(3,4,5)就是x =5， y=4，z=3，还可以有大于三维的数组，例如四维，五维等等。
数组的属性有： nidm（数组的维度）、shape（数组每个维度的大小）、size（数组的总大小）、dtype（数据类型）、itemsize（每个元素的字节大小）、nbytes（总字节大小）。
数组索引
numpy 索引与python 列表索引一样。
x1=array([5, 0, 3, 3, 7, 9])
x1[0]就是5，x[5]就是9，从左到右是从0开始依次递增。
x1[-1]是9，x[-6]是5，负数索引是从最右边开始。
可以这么理解，数组的第一个元素位于坐标轴的0位置，往右数，就依次增加一，往左数是负数-1，相当于数组左边没有数组，指向数组[0]位置的指针跳到了数组的尾端，相当于尾端开始向右检索。
二维数组与一位数组类似
array([[3, 5, 2, 4],
[7, 6, 8, 8],
[1, 6, 7, 7]])
相对应的左上角为[0,0]，[竖直，水平]
切片获取子数组
x[start:stop:step]
如果缺省start 代表从第一个元素开始，缺省stop代表到最后一个元素为止，缺省step代表步长为1.
多维数组则是针对每个维度来检索。
x[start:stop:step,start:stop:step]
可以把数组的切片赋予一个变量，但是如果你更改这个变量的值，那么数组的值也会跟着改变。很明显，这里的赋值并不是从新给变量分配一个内存空间来存储数值，而是给存储这些数值的内存空间又赋予了一个名字。
例如
print(x2)
[[12 5 2 4]
[ 7 6 8 8]
[ 1 6 7 7]]
x2_sub = x2[:2, :2]
print(x2_sub)
[[12 5]
[ 7 6]]
当我们更改x2_sub[0,0]=0后，x2变成了
[[0 5 2 4]
[ 7 6 8 8]
[ 1 6 7 7]]
如何让我们对于新数组的更改不会影响到旧数组的值呢？我们可以用.copy。
x2_sub = x2[:2, :2].copy()
这样就生成了一个独立的数组。
数组的变形
利用resharp()函数实现。
例如x=np.arange(1,10)，生成了一个从1到9的一维数组，一共9个数字。
我们把它转换成3x3的矩阵，只需要x=x.reshape((3,3))就可以了。
如果把一维数组转至，可以使用np.newaxis，
例如x=np.array([1,2,3])
x[:,np.newaxis]
([[1],
[2],
[3]])
数组的拼接
np.concatenate 把两个数组拼接在一起，一位数组是沿着水平方向拼接，二维以上数组沿着竖直方向拼接。如果二维以上数组需要延水平方向拼接需要加上axis=1.
例如np.concatenate([x,y],axis=1)
np.vstack 两个数组延竖直方向拼接
np.hstack 两个数组延水平方向拼接
np.dstack是延第三个维度拼接数组
数组的分裂
np.split，np.hsplit，np.vsplit
例如
x=np.arange(1:20)
x1,x2,x3 = np.split(x,[3,5]) 其中[3,5]是数组的分裂点。N个分裂点会得到N+1个子数组。
np,dsplit是将数组沿第三个维度分裂。
数组的运算
numpy 实现的算术运算
运算符 对应的通用函数 描述
+ np.add 加法运算（即 1 + 1 = 2）
- np.subtract 减法运算（即 3 - 2 = 1）
- np.negative 负数运算（ 即 -2）
* np.multiply 乘法运算（即 2 \* 3 = 6）
/ np.divide 除法运算（即 3 / 2 = 1.5）
// np.floor_divide 地板除法运算（floor division，即 3 // 2 = 1）
** np.power 指数运算（即 2 ** 3 = 8）
% np.mod 模 / 余数（ 即 9 % 4 = 1）
绝对值
abs(), np.abs(), np.absolute()
三角函数
np.sin()
np.cos()
np.tan()
反三角函数
np.arcsin()
np.srccos()
np.arctan()
指数
np.exp()
np.exp2()
np.power(n,x)（x的n次幂）
对数
np.log()
np.log2()
np.log10()
专用函数
from scipy import special
gamma函数
special.gamma()
special.gammaln()
special.beta(x,n)
高级的通用函数特性
指定输出out
例如：
x = np.arange(5)
y = np.empty(5)
np.multiply(x, 10, out=y)
print(y)
[ 0. 10. 20. 30. 40.]
x为0到4的数组，y是一个有五个元素的空数组
把x乘以10后指定输出到数组y
指定存放的位置
y = np.zeros(10)
np.power(2, x, out=y[::2])
print(y)
[ 1. 0. 2. 0. 4. 0. 8. 0. 16. 0.]
y是一个全零的数组，指定x数组元素间隔的存放在y中就用out=y[::2],从头到尾step = 2的意思。
聚合
reduce，可以对数组中的每个元素操作重复执行，直到得出一个单个结果。
例如x=np.arange(1,6)
np.add.reduce(x)
把x的每个元素相加求和
np.mutiply.reduce(x)
把x的每个元素相乘求积
如果要存储每次计算的中间结果用accumulate()
np.add.accumulate()
np.multiply.accumulate()
外积
x = np.arange(1, 6)
np.multiply.outer(x, x)
最小值，最大值，其他值
对所有元素求和
sum(x)或np.sum(x)
最小值
min()或np.min()
最大值
max()或np.max()
多维函数聚合
M = np.random.random((3, 4))
M.sum()是计算数组M所有元素相加的和。
如果指定沿着行或者列需要用参数axis
M.min(axis=0) 找到每一列的最小值
M.max(axis=1)找到每一行的最大值
其他聚合函数
函数名称 NaN安全版本 描述
np.sum np.nansum 计算元素的和
np.prod np.nanprod 计算元素的积
np.mean np.nanmean 计算元素的平均值
np.std np.nanstd 计算元素的标准差
np.var np.nanvar 计算元素的方差
np.min np.nanmin 找出最小值
np.max np.nanmax 找出最大值
np.argmin np.nanargmin 找出最小值的索引
np.argmax np.nanargmax 找出最大值的索引
np.median np.nanmedian 计算元素的中位数
np.percentile np.nanpercentile 计算基于元素排序的统计值
np.any N/A 验证任何一个元素是否为真
np.all N/A 验证所有元素是否为真
数组的计算：广播
广播允许不同大小的数组进行运算
例如
a = np.array([0, 1, 2])
a+5 相当于把5扩展成[5,5,5]，在执行加法计算。
比较操作返回的是bool 型
例如
x < 3
array([ True, True, False, False, False], dtype=bool)
利用符合表达式实现对两个数组的逐个元素比较
(2 * x) == (x ** 2)
array([False, True, False, False, False], dtype=bool)
运算符 对应的通用函数
== np.equal
!= np.not_equal
< np.less
<= np.less_equal
> np.greater
>= np.greater_equal
统计bool数组中true记录的个数，np.count_nonzero 函数
np.count_nonzero(x < 6)
在bool数组中true值为一，false值为ling
可以使用np.sum来统计true的个数
np.sum(x<6)
使用sum的好处是可以沿着一个数组的行或者列进行统计。
每行有多少值小于6的
np.sum(x < 6, axis=1)
np.any(x < 6) 或 np.all(x < 6)：任意 < 6或者所有< 6
np.all() 和n p.any() 也可以用于沿着特定的坐标轴。
bool运算符对应的函数
运算符 对应通用函数
& np.bitwise_and
| np.bitwise_or
^ np.bitwise_xor
~ np.bitwise_not
掩码操作
x[x < 5]
筛选出来小于5的值
花哨的检索
通过列表来检索数组
例如检索数组中第3,7,2个元素的值
ind = [3,7,2]
x[ind]
结果的形状与索引数组一致，而不是与被索引数组一致。
例如x为[51 92 14 71 60 20 82 86 74 74]
ind = np.array([[3, 7],[4, 5]])#索引为一个二维数组
x[ind]
array([[71, 86],[60, 20]])检索后也输出一个二维数组。
对于高维数组
array([[ 0, 1, 2, 3],[ 4, 5, 6, 7],[ 8, 9, 10, 11]])
row = np.array([0, 1, 2])
col = np.array([2, 1, 3])
X[row, col]#是按照行列组合检索的（0,2）（1,1）（2,3）
array([ 2, 5, 11])
如果要将列向量和行向量组合索引，利用广播规则
X[row[:, np.newaxis], col]
array([[ 2, 1, 3],[ 6, 5, 7],[10, 9, 11]])
组合索引
例如
x为
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
X[2, [2, 0, 1]]选第三列，按照 [2, 0, 1]索引。
array([10, 8, 9])
花哨索引和切片组合使用
x[1:, [2, 0, 1]]选第二列到最后一列，按照 [2, 0, 1]索引。
array([[ 6, 4, 5],
[10, 8, 9]])
也可以花哨索引与掩码组合使用
mask = np.array([1, 0, 1, 0], dtype=bool)
X[row[:, np.newaxis], mask]
array([[ 0, 2],
[ 4, 6],
[ 8, 10]])
数组的排序
np.sort和np.argsort
第一个是对数组排序，返回排序后的数组。第二个是返回排序后数组的索引序列。