NumPy

Python科学计算领域，几乎所有科学计算库都依赖NumPy

强大的N维数组对象
广播功能
基于C语言，速度快
线性代数、傅里叶变换和随机数能力
numpy.version 查询版本号
查看数组中元素类型：nparr.dtype

对比python list(numpy04.py)

List:对于列表中的每一个元素均需要检查是哪种具体类型，时间损耗大，但可以修改元素。
array库：基于数组(不能进行矩阵运算)，只能存储单一类型元素
numpy.array:只存储单一类型元素，但能进行隐式类型转换（截位），及进行矩阵操作
Numpy:arange 对比List:range
- [i for i in range(0,20,0.2)]，range参数：1.开始点 2.终止点（不包括） 3.步长，且range中不能传入浮点数
- np.arange(0,5,0.2) 可以传入浮点数
- List下直接相乘，只做连接操作：L=[] => 2*L = [0, 1, 2, 3, 0, 1, 2, 3]； numpy下的L可直接看作矩阵，进行矩阵运算:L = np.arange(10) => 2*L=[0, 2, 4, 6]

区分一维向量与二维数组（矩阵）

一维向量：array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) 只有一个维度，十列一行
reshape(1,10)后得到二维数组：array([[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]]) 两个维度，一行十列

基本属性

dtype 数组元素类型：nparr.dtype
ndim 数组维度 []的个数：np.arange(15).reshape((3,5))
shape 返回元组，表示每个维度里的元素个数：x.shape；shape[0] 读取矩阵第一维度的长度
size 元素个数：x.size

数据访问

数组下标读取：x[-1]
多维读取（使用元组方式，元组括号可省略）：x[(0,0)]
切片操作
- x[0:5] 一维数组切片，读取第[0,5)之间
- x[:, 0] 取一列；逗号左边为行数，右边为列数，读取第0列的所有行，可对矩阵转置
- x[:2,:3] 多维读取，逗号前为读取[0,2)行，逗号后为读取[0,3)列；不能使用x[:2][:3] [:3]会取x[:2]得到数组中的前三个元素
- x[:2, ::2] 列步长为2
数据修改
- subx = x[:2,:3] 通过引用方式获取子矩阵；子矩阵、原矩阵互相影响
- x[:2, :3].copy() 创建副本，修改副本值不改变原始数组值

numpy.array创建方式(numpy05.py)

生成元素全为0的：np.aeros(10,dtype=) | np.zeros((3,5), dtype=int)，dtype设置datatype,省略默认生成float类型数据
生成元素全为1的：np.ones(10)
生成其它任意固定数：np.full(shape=, fill_value=,dtype=,order=)

常用函数(numpy01.py)

将数据放在NumPy多维数组对象中ndarray\numpy.array()

导入：import numpy as np
赋值给数组：np.array([1,2,3,4,5,6])
求和、最大值、最小值：np.array().sum()
求平均：np.average(np.array())
N维数组生成
- 大列表中套N维数组：np.array([[1, 2, 3], [4, 5, 6]])
- 强制将一维数组变形成为2行3列二维数组：example_1d.reshape(2, 3)

常用函数2（numpy06.py）

arange：np.arange(0,20,0.2) 按步长0.2，在[0,20）范围内取值
linspace：np.linspace(0,20,10) [0,20]等长截取10个点
random
- 传入第三个参数生成一个数组（向量）：np.random.randint(0, 10, 10)
- 传入元组，生成对应大小矩阵：np.random.randint(4, 8, size=(3,5))
- big_array = np.random.rand(1000000)
- 通过使用seed每次生成同样的随机向量：np.random.seed(600)
- random() 0~1内随机取值：np.random.random((3,5))
- normal() 取符合正态分布的浮点数(均值为0，方差为1)：np.random.normal() | np.random.normal(10,100)
查看帮助文档
- 仅用于Jupyter：np.random.normal?
- help(np.random.normal)
reshape 变形
- np.arange(15).reshape(3,5)：np.arange()创建一维数组，.reshape()转化为二维矩阵形式
- np.arange(10).reshape(10,-1)：-1表示根据所给另一数据自动计算值
合并操作 concatenate()
- np.concatenate([A, B], axis=0) axis表方向，沿着第二个方向（即列的方向）拼接，0：行 1：列
- 不同维度合并（如：A二维矩阵 x一维向量，维数不同不能直接拼接）
  - 现将x变形reshape为二维矩阵：np.concatenate([A, x.reshape(1,-1)])
  - 简易方法（vstack\hstack）：np.vstack([A,x]) 垂直方向堆叠
  - np.tile(v,(2,1)) 向量在行向量上堆叠两次，列向量上堆叠一次
分割操作split（分割点以数组形式传入）
- np.split(x, [3,7]) 根据传入数组，按位置分割
- x1, x2, x3 = np.split(x, [3,7])
- 矩阵分割：A1, A2 = np.split(A, [2], axis=1) axis:分割方向，默认以第一个轴（行）分割
- 矩阵分割2（vsplit/hsplit）：upper, lower = np.vsplit(A,[2]);应用：样本与标签目标值分割；np.hsplit(data, [-1])
聚合操作
sum
- sum(L)
- np.sum(L)
- big_array.sum()
- np.sum(X,axis=0)：沿着行方向压缩，逐列计算； np.sum(X,axis=1)：逐行计算
- min/max
- np.min(big_array)； np.max(big_array)
- big_array.min()； big_array.max()
- prod求元素乘积（python支持大数运算）:np.prod(X+1)
- mean平均值：np.mean(X)
- 中位数：np.median(X)
- 百分位：np.percentile(big_array,q=50) big_array中50%的数据小于等于？；一般通过[0,25,50,75,100]五个百分位点看数据分布
- 方差：np.var(big_array)
- 标准差：np.std(big_array)
- 索引：np.argmin(x)； np.argmax(x)
- 乱序处理shuffle：np.random.shuffle(x) 改变原数组
- 排序
  - np.sort(x) 默认从小到大；np.argsort(x) 按照排序前数组找到对应位置
  - np.partition(x,3) 快排：3为标定点； np.argpartition(X, 2, axis=1)
  - X.sort() 改变原始值； np.sort(X,axis=1) 不改变原始值，按照每一行排序（沿着列），默认axis=1

广播

数组+常数：np.array([[1, 2, 3], [4, 5, 6]]) + 3 == np.array([[1, 2, 3], [4, 5, 6]]) + np.array([[3, 3, 3], [3, 3, 3]]) 广播将数字扩展到数组中的每一个元素中
数组常数：np.array([[1, 2, 3], [4, 5, 6]]) 3
变为以e为底的指数：np.exp(A)
矩阵乘法（左行右列）：np.dot(A, B) | A.dot(B)

向量化计算

最大程度不使用for循环：底层使用python
尽量使用NumPy自带函数：底层使用c
多使用广播

Universal Function（numpy06.py）

x = np.arange(1,16).reshape((3,5))* x + 1； x / 2; x // 2； 1 / x

np.abs(x)； np.sin(x)； np.log2(x)； np.exp(x)； np.power(3,x) 相当于 3**x
矩阵乘法（左行右列）：A.dot(B)； np.dot(A, B)； v.dot(A) 对于一个向量和矩阵乘法，Numpy自动判断向量取行向量还是列向量自动将v转化为相应矩阵
矩阵转置：A.T

Fancy Indexing(numpy08.py)

[x[3], x[5], x[8]]
ind = [3,5,8]; x[ind]; ind = np.array([[0,2],[1,3]]); x[ind]
row = np.array([0, 1, 2]); col = np.array([1, 2, 3]); X[row, col]; 对应三个点(0,1)(1,2)(2,3)
*

numpy.array比较

2 * x == 24 - 4 * x
np.sum(x <= 3)
np.count_nonzero(x <= 3)
np.any(x == 0) x中有任意一个等于0, 即返回true
np.all(x < 0) x中每一个元素x < 0时为true,则结果返回true,否则返回false
np.sum(X % 2 == 0, axis=1)
np.all(X > 0, axis=1)
np.sum((x > 3) & (x < 10))； np.sum((x % 2 == 0) | (x > 10))；两个数组，按照索引，分别进行与或运算，故用位运算符&
np.sum(~(x==0))
x[x < 5] bool数组作为索引数组
X[X[:,3] % 3 == 0, :] 将所有行第三列的值抽出来，选择%3==0的作为行，取所有列

矩阵运算(numpy09.py)

List下直接相乘，只做连接操作：L=[]; => 2*L = [0, 1, 2, 3, 0, 1, 2, 3]
使用for循环实现矩阵运算：for e in L: A.append(2*e)
使用行内运算：A = np.array([2*e for e in L])
numpy下的L可直接看作矩阵，进行矩阵运算:L = np.arange(10) => 2*L=[0, 2, 4, 6]
向量和矩阵的运算：向量和矩阵每一行相应位置做加法，v+A；对应位置相乘，v*A
堆叠成矩阵：np.vstack([v] * A.shape[0]) + A； np.tile(v,(2,1)) 向量在行向量上堆叠两次，列向量上堆叠一次
矩阵的逆AA^(-1)=E: np.linalg.inv(A)；伪逆矩阵：np.linalg.pinv(X)

逻辑回归：dw = 1 / m * np.dot(X, (A-Y).T) .T求转置

逻辑回归损失函数：

pandas

数据分析和计算的第三方库，为python提供了高性能、易使用的数据计算功能

读取数据
- 一：读取列表中的字典 data=[{},{}]; pd.DataFrame(data)
- 二：读取CSV文件 pd.read_csv(‘文件路径’) 返回DataFrame对象
- 三：读取sql import sqlite3
常用函数：选择数据
- 选择某列：df1[‘age’]
- 按条件选择：df1[df1[‘age’] < 100] 、 df1[df1[‘age’] % 2 == 0]
常用函数：去重
- 一：去重，返回数组 df4[‘name’].unique()
- 二：按照name去重，保留第一项，返回DataFrame类型 df4.drop_duplicates(‘name’, keep=’first’)
- 三：保留最后一项 df4.drop_duplicates(‘name’, keep=’last’)
常用函数：GroupBy分组（与MySQL中效果一致）
- df5.groupby(‘sex’).size()
- df5.groupby(‘sex’).size().reset_index(name=’size’) 将得到的结果重新变成DataFrame对象
- 求和：查找dataFrame中可以进行求和的内容(age) df5.groupby(‘sex’).sum()
- 求最大值、最小值：df5.groupby(‘sex’).max() 、 .min()* 求平均值：df5.groupby(‘sex’).mean()
画图：import matplotlib.pyplot as plt （pandas02.py）
- 在使用jupyter notebook 或者 jupyter qtconsole时，使用%matplotlib inline
- %matplotlib：当调用matplotlib.pyplot的绘图函数plot()进行绘图，或者生成一个figure画布，可以直接在console里面生成图像
- plt.plot(x=’name’, y=’age’) 生成图像的x\y轴坐标项
- 生成图像：plt.show()
- 散点图：plt.scatter(x, y, alpha=0.5)； alpha不透明度
- plt.scatter(X[y==0, 0], X[y==0, 1], color=”red”, marker=”o”)
- plt.axis([-1, 11, -2, 2])
- plt.xlabel(“x axis”)
- plt.legend()
- plt.title(“”)

NumPy & pandas