机器学习工具基础

淡淡的烟草味﹌ 2022-01-26 14:47 1897阅读 0赞

# 人工智能发展历程（了解） #

# 机器学习定义以及应用场景（了解） #

*  人工智能&机器学习&深度学习【了解】  
    人工智能实现的途径之一——机器学习  
    机器学习的方法之一——深度学习
 *  人工智能主要分支【了解】  
    计算机视觉（CV）  
    语音识别  
    文本挖掘/分类  
    机器翻译  
    机器人
 *  人工智能必备三要素【了解】  
    数据  
    算法  
    计算力
 *  cpu与gpu【了解】  
    cpu – IO密集型  
    gpu – 计算密集型,以千为单位。

# 机器学习 #

从**数据**中自动分析获得**规律（模型）**，并利用规律**对未知数据进行预测**

1.  获取数据
2.  数据处理
3.  特征工程
4.  模型训练（机器学习）
5.  模型评估

## 数据 ##

数据：

1.  结构化数据：相当于数据库的一个表——机器学习（表格）
2.  非结构化数据：图片、语音、文字——深度学习

在数据集中一般：

一**行**\--------->一个**样本**（数据库中叫记录。）  
一**列**\---------->一个**特征** （数据库中叫属性）  
**目标值**（标签值）——要干的事情就是目标值。分类结果或回归值。

*  数据类型构成：  
    数据类型一：特征值+目标值（目标值是连续的和离散的）  
    数据类型二：有特征值，无目标值
 *  数据分割：  
    机器学习一般的数据集会划分为两个部分：  
    **训练数据**：用于训练，构建模型  
    **测试数据**：在模型检验时使用，用于评估模型是否有效
 *  划分比例：  
    训练集：70% 80% 75%  
    测试集：30% 20% 25%

## 数据处理 ##

1.  缺失处理
2.  去异常值处理

## 特征工程 ##

使用专业背景知识和技巧处理数据，使得特征能在机器学习算法上发挥更好的作用的过程。  
**意义**：会直接影响机器学习的效果。  
内容：

1.  特征提取
2.  特征预处理 ——比如：去量钢化,把不同数据转化为统一两级的数据。
3.  特征降维——减少特征数量，同时保留原来数据的大部分信息。（PCV主成分分析）

## 完整的机器学习项目流程 ##

1.  抽象成数学问题
2.  获取数据
3.  特征处理与特征选择
4.  训练模型与调优
5.  模型诊断
6.  模型融合
7.  上线运行

## 机器学习算法 ##

## 分类 ##

算法分类的依据：训练模型数据集类型。

根据数据集不同：

*  监督
 *  无监督
 *  半监督
 *  强化

### 1.监督学习 ###

定义：  
输入数据右特征值和目标值（标签）组成  
输出结果：  
连续——回归  
离散——分类

*  In：有标签，Out：有反馈  
    目的：预测结果  
    案例：猫狗分类，房价预测
 *  **分类 k-近邻算法、贝叶斯分类、决策树与随机森林、逻辑回归、神经网络**
 *  **回归 线性回归、岭回归**  
    1.1 回归问题  
    1.2 分类问题

### 2. 无监督学习 ###

定义：  
输入数据只有特征值，无标记。  
样本数据类别未知，需要根据样本间的相似性对样本集进行分类（**聚类**，clustering）试图使类内差距最小化，类间差距最大化。

*  In：无标签，Out：无反馈  
    目的：发现潜在结构  
    案例：“物以类聚，人以群分”
 *  **聚类 k-means，降维**

### 3. 半监督学习 ###

定义：  
训练集中同时包含标记样本和未标记样本。

*  已知：训练样本Data和待分类的类别  
    未知：训练样本有无标签均可  
    应用（案例）：训练数据量过多时，  
    监督学习效果不能满足需求，因此用来增强效果。

### 4.强化学习 ###

没有训练数据，建立模型时通过人为设定好模型可以操作的规则,根据规则不断的进行自我尝试——比如:下棋。  
根据动态数据  
主要关注四个元素：agent,environment, action, reward

*  In：决策流程及激励系统，Out：一系列行动  
    目的：长期利益最大化，回报函数（只会提示你是否在朝着目标方向前进的延迟反映）  
    案例：学下棋  
    **算法：马尔科夫决策，动态规划**

## 模型评估 ##

按照数据集的**目标值**不同，可以把模型评估分为**分类模型评估**和**回归模型评估**。  
目的：看模型的表现是否达到预期，衡量模型质量。

### 模型评估方法 ###

**1. 分类模型评估**  
混淆矩阵(二分类模型)：  
A:正例 ，B:假例  
预测值， 真实值

指标：

*  准确率
 *  精确率
 *  召回率
 *  F1-score
 *  AUC指标  
    ![分类模型评估][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5eF94_size_16_color_FFFFFF_t_70]

\*\* 2. 回归模型评估\*\*  
预测值和真实值平均接近程度。

*  **均方根误差（Root Mean Squared Error，RMSE）**
 *  **相对平方误差（Relative Squared Error，RSE）RMSE）**
 *  **相对绝对误差（Relative Absolute Error，RAE)**
 *  **平均绝对误差（Mean Absolute Error，MAE)**
 *  **决定系数 (Coefficient of Determination)**

**过拟合、欠拟合发生的情况**

--------------------

# 工具篇 #

## jupyter notebook ##

Ipython网页加强版  
优：  
一边写代码，一边调试。按块运行代码 cell  
支持makdown 文档。  
文件格式：.jpynb  
可连接远程服务器（可处理大型数据集） 在本地写代码，远程执行。

和pycharm相比在绘图和数据处理方面更有优势。

### 快捷键操作 ###

*  两种模式通用快捷键  
    **Shift+Enter**，执行本单元代码，并跳转到下一单元  
    **Ctrl+Enter**，执行本单元代码，留在本单元  
    cell行号前的 \* ，表示代码正在运行

**命令模式：按ESC**进入  
Y，cell切换到Code模式  
M，cell切换到Markdown模式  
A，在当前cell的上面添加cell  
B，在当前cell的下面添加cell  
双击D：删除当前cell  
Z，回退  
L，为当前cell加上行号  
编辑模式：按Enter进入  
多光标操作：Ctrl键点击鼠标（Mac:CMD+点击鼠标）  
回退：Ctrl+Z（Mac:CMD+Z）  
重做：Ctrl+Y（Mac:CMD+Y)  
补全代码：变量、方法后跟Tab键  
为一行或多行代码添加/取消注释：Ctrl+/（Mac:CMD+/）  
屏蔽自动输出信息：可在最后一条语句之后加一个分号

## matplotlib ##

*  什么是matplotlib【了解】  
    是专门用于开发2D(3D)图表的包——画图的。
 *  绘制图像流程【掌握】  
    1.创建画布 – plt.figure(figsize=(20,8))  
    2.绘制图像 – plt.plot(x, y)  
    3.显示图像 – plt.show()
 *  matplotlib图像结构【了解】

1.  容器层  
    **Canvas** – 画板  
    是底层实现,不需要关注  
    **Figure** – 画布  
    在使用之前,每次都需要进行实例化  
    **axes** – 坐标系（绘图区域）  
    数据的绘图区域
2.  辅助显示层  
    主要作用添加坐标轴描述,标题等内容。  
    主要包括Axes外观(**facecolor**)、边框线(**spines**)、坐标轴(**axis**)、坐标轴名称(**axis label**)、坐标轴刻度(**tick**)、坐标轴刻度标签(**tick label**)、网格线(**grid**)、图例(**legend**)、标题(**title**)等内容。
3.  图像层  
    设定要画一个什么样的图像:plot,scatter…

--------------------

机器学习数据：文件csv  
mysql:性能瓶颈（数据量增大时读取速度受限）格式不符合机器学习要求的格式。

1.  常见图形绘制：  
    **折线图（plot）、散点图（scatter）、柱状图(bar)、直方图(histogram)、饼图(pie)**。

notes:

*  文件路径要加双引号
 *  figsize 不是函数，figsize=(x,y)
 *  合并多个cell: 选中需要合并的cell —>shift+m
 *  绘图三部曲：
    
     *  创建画布
     *  绘制图像
     *  显示图像
    
    1.  plt.figuer(figsize=(20,8),dpi=100) ,dpi越小，图片越小越模糊。
    2.  plt.plot(x,y) \# x,y对应的个数应该一致。
    3.  plt.savefig()
    4.  plt.show()  
        \# 若在显示图像之后再保存，图像再显示之后会被立即清空。
    
    --------------------
    
    range(60) \#  
    random.unform(15,18)  
    列表生成式：y = \[\]  
    y = \[random.uniform(15,18) for i in x\] —》不写成列表形式肯定会错！！！
    
    --------------------
 *  辅助显示：

**一. 添加描述信息**

*  plt.xlabel(’’,fontsize=20) \# 注：label经常写错。
 *  plt.ylabel(’’,fontsize=20)
 *  plt.title

**二. 添加坐标轴刻度**

*  plt.xticks(x,new\_x,rotation=90) \# 将原来x显示的内容换成new\_x
 *  plt.xticks(x\[起始:结束 :步长\],new\_x\[起始：结束：步长\],rotation=45) \# 隔几个刻度显示一个  
    注意:在传递进去的第一个参数必须是数字,不能是字符串,如果是字符串吗,需要进行替换操作

**三. 添加网格线**

*  plt.grid(linestyle=’–’,alpha=0.8) \# 添加网格，linestyle=网格线样式，alpha=透明度  
    \- 实线  
    – 虚线  
    \-. 点划线  
    ： 点虚线  
    ‘’ 留空

**四.每种线和label都可以设置颜色——c=**

*  红色 r
 *  绿色
 *  蓝色
 *  白色
 *  青色 c
 *  洋红
 *  黄色
 *  黑色 k

--------------------

*  绘制多条折线图  
    一个画布，一个绘图区域。  
    调几次plot就在画布上画几根线，最好指定颜色和名字。
    
     *  添加颜色：c=""
     *  添加图列：legend（指明每条线代表什么）  
        plt.legend(loc=‘best’) \# 1.loc=‘best’loc:控制图列显示位置。 2.设置图列前，必须保证每条线都有label=’’  
        注意:在传递进去的第一个参数必须是数字,不能是字符串,如果是字符串吗,需要进行替换操作

**图列显示位置：**  
best : 右上角  
upper left  
upper right  
lower right  
lower left  
right  
center left

--------------------

**多个坐标系显示 **
     plt.subplots(nrows=, ncols=，第几个)

？？？

1.  画布需要自己创建
2.  一个画布默认只有一个绘图区域
3.  需要画多个图形，就需要使用.subplots(row,col)

fig ,ax = plt,subplots(nrow,ncol,figsize=(x,y)) \# 返回值有两个

--------------------

折线图（plot）: 观察数据的变化趋势

散点图(scatter)：研究数据分布规律，离群点的观察

柱状图(bar)：  
plt.bar(x,y,width,align,)

直方图(hist)：

饼图：

--------------------

**\#\# numpy**  
适用于科学计算  
pandas :读取工具， numpy:快！  
python:动态语言,GIL(全局解释性锁)——慢。

> **静态语言：**  
> 静态语言是在编译时，变量的数据类型即可确定 的语言，多数静态类型语言要求在使用变量之前必须声明数据类型。  
> 例如：C++、Java、Delphi、C\#等。  
> **动态语言:**  
> 动态语言是在运行时确定数据类型的语言。变量使用之前不需要类型声明，通常变量的类型是被赋值的那个值的类型。  
> 例如PHP/ASP/Ruby/Python/Perl/ABAP/SQL/JavaScript/Unix Shell等等。

> **动静、强弱是两个概念！！！**

> **强类型语言:**  
> 一旦变量的类型被确定，就不能转化的语言。实际上所谓的貌似转化，都是通过中间变量来达到，原本的变量的类型肯定是没有变化的。  
> **弱类型语言:**  
> 变量的类型是由其应用上下文确定的。比如语言直接支持字符串和整数可以直接用 + 号搞定。当然，在支持运算符重载的强类型语言中也能通过外部实现的方式在形式上做到这一点，不过这个是完全不一样的内涵  
> 通常的说，java/python都算是强类型的，而VB/Perl/C都是弱类型的.  
> 不过相比于动态/静态语言的分类，强类型/弱类型更多的是一个相对的概念。

numpy : 释放 GIL，真正并行。  
python：为了数据的安全——加GIL锁。一开始问题并未暴露。到很多框架都成熟后才发现问题。（历史遗留问题）

**简介**

1.  开源科学计算库，可快速处理任意维度数组。
2.  支持常见数组和矩阵操作，比使用python简洁
3.  使用ndarray处理多维数组，ndarray是一个快而灵活的大数据容器。

**ndarray**  
numpy提供的n维数组类型，描述相同类型元素集合。  
生成numpy对象：np.array()

### nadrray的优势 ###

*  ndarray中元素类型相同，而python列表中元素类型是任意的。 ndarray在存储元素时，类型可连续。python原生list之恩通过寻址方式找到下一个元素。  
    1.**速度快**： ndarray在存储数据的地址和数据都是连续的。——批量操作数组元素时速度更快

1.  **代码简单**：在科学计算中，Numpy的ndarray就可以省掉很多循环语句，代码使用方面比Python原生list简单的多。
2.  **支持并行化运算**
3.  **效率远高于纯python代码**  
    numpy底层使用C语言编写，内部解除了GIL（全局解释器锁），其对数组的操作速度不受python解释器的限制，所以，其效率远高于纯python 代码。
4.  **缺点**：数据类型相同，在**通用性**方面不及pyhton原生list。

### N维数组-ndarray ###

**nadrray的属性**

ndarray.shape \# 返回值类型为一个元组（元素个数）、（行，列）、（层、行、列）  
ndarray.ndim \# 返回值类型为一个整数  
ndarray.size \#  
ndarray.itemsize  
ndarray.dtype

**nadrray的形状**

**nadrray的类型**

**ndarray基本操作**

#### 1. 生成数组的方法 ####

**1.1 生成全0或全1的数组**

np.ones(\[2,3\]) \# 2行3列1  
np.zeros(\[2,3\])  
np.ones\_like(a) \# 生成和a相同type的，全1数组。  
np.zeros\_like(a)

**1.2从现有数组生成**  
np.array(\[  
\[\[1,2,3\],\[4,5,6\]\],  
\[\[1,2,3\],\[4,5,6\]\],  
\[\[7,8,9\],\[4,5,6\]\]  
\])  
a1 = np.array(a)  
a2 = np.asarray(a)

**array&asarray**  
asarray：会随a的改变而改变  
array不会。

**1.3 生成固定范围的数组**  
得到的都是一维数组：

*  np.linspace(start,stop,num,endpoint) \# num：取元素个数。
 *  numpy.arange(start,stop, step, dtype) \# step：步长 ，后一个数减去前一个数=step。 最后一个不取
 *  numpy.logspace(start,stop, num，base=2) \# 生成等比数列。base=2: base:指定等比数列比列。
 *  np.logspace(1,10,10,base=2)  
    从1得2次方，取到10的2次方。
 *  np.logspace(1,10,20,base=2)  
    array(\[ 2. , 2.77730229, 3.85670399, 5.3556164 ,  
    7.43708284, 10.32751358, 14.34131354, 19.91508143,  
    27.65510059, 38.40328703, 53.32876841, 74.05505519,  
    102.836637 , 142.80421347, 198.30523421, 275.37679007,  
    382.40229418, 531.02338276, 737.40622722, 1024. \])

**1.4 生成随机数组**  
**np.random**  
(1) 均匀分布 —— 在一个范围内随机抽数，抽到该范围的每个数的概率都是相等的。

*  np.random.rand(d0, d1, …, dn)  
    np.random.rand(2,3):  
    从**0-1**范围内抽
 *  np.random.uniform(low=0.0, high=1.0, size=None)
 *  *np.random.unifrom(1,10,(2,3)) \- **np.random.uniform(1,10,10000) \# 这是一维数组**  
    不再是从0-1抽样，而是从**指定范围*\*均匀抽样。
 *  np.random.randint(low, high=None, size=None, dtype=‘l’)
 *  np.randint(1,10,(3,3,))  
    抽样结果为**整数**。

**均匀分布直方图：**

x = np.random.uniform(1,100,1000000)
    plt.figure(figsize=(20,8))
    
    plt.hist(x,bins=10000)  # 把1-100分程10000个区间，统计落到每个区间的数个数
    
    plt.show()

![均匀分布直方图][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5eF94_size_16_color_FFFFFF_t_70 1]

(2) 正态分布——在期望附近概率越大。  
直方图——一分一档。  
标准差、方差 衡量数据离散程度。

1.  np.random.randn(d0, d1, …, dn)  
    **np.random.randn(2,3)**
2.  np.random.normal(loc=0.0, scale=1.0, size=None)  
    \# loc:均值 scale:标准差  
    **np.random.normal(loc=1,scale=1,size=(2,3))**
3.  np.random.standard\_normal(size=None)  
    **np.random.standard\_normal((2,3))**

x = np.random.standard_normal((1000000))
    plt.figure(figsize=(20,8))
    
    plt.hist(x,bins=10000)  # 把1-100分程10000个区间，统计落到每个区间的数个数
    
    plt.show()

![正太分布直方图][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5eF94_size_16_color_FFFFFF_t_70 2]

#### 2. 数组的索引、切片（选取） ####

**一维：**  
\[起始：结束：步长\]  
**二维：**  
\[行 , 列 \]---------》\[起始：结束：步长 ，起始：结束：步长\] **note:步长为1就是连着取，步长为2就是隔一个取一个。**  
\[0 , : \]  
\[2:8:2, :\]  
**三维：**  
\[层，行，列\]

note: 在panda中不能这样（仅一维不会报错）  
…

#### 3. 形状修改 ####

*  ndarray.reshape((type)） \# 生成新数组，不修改原数组——有返回值。
 *  ndarray.resize(type) \# 修改原数组。
 *  修改的时候注意不能有元素的缺失。
 *  ndarray.T \#数组的转置

#### 4. 类型修改 ####

*  ndarray.**astype**(type) eg:np.int32 修改的是元素数据类型。
 *  ndarray.**tostring**() \# 将数组对象转化为字符序列（二进制）  
    如下：

> b’\\x00\\x00\\x00\\x00\\x00\\x00\\xf0?\\x00\\x00\\x00\\x00\\x00\\x00\\x00@\\x00\\x00\\x00\\x00\\x00\\x00\\x08@\\x00\\x00\\x00\\x00\\x00\\x00\\x10@\\x00\\x00\\x00\\x00\\x00\\x00\\x14@\\x00\\x00\\x00\\x00\\x00\\x00\\x18@\\x00\\x00\\x00\\x00\\x00\\x00\\x1c@\\x00\\x00\\x00\\x00\\x00\\x00 @\\x00\\x00\\x00\\x00\\x00\\x00"@\\x00\\x00\\x00\\x00\\x00\\x00$@\\x00\\x00\\x00\\x00\\x00\\x00&@\\x00\\x00\\x00\\x00\\x00\\x00(@’

s = temp.tostring()  
用一变量去保存。在网络中传输等等…  
转换回来：  
np.frombuffer(s)

#### 5. 数组去重 ####

*  np.unique(数组名)

### ndarray运算 ###

#### 逻辑运算 ####

1.  arry\[0:2,0:5\]>5  
    ndarray 逻辑运算符----->每个元素比较 值 ------------>bool类型矩阵

\[\] : 切片 。前闭后开。

data\[逻辑判断结果矩阵\]------->取出结果为True的元素---->组成一个列表

**2. np.all()**

*  np.all(arry\[0:2,0:5\]>5) \# 判断一个数组内元素是否全满足某个条件------->满足时返回True

**3. np.any()**

*  np.any(arry\[0:2,0:5\]>5) \# 判断某个数组中是否有元素满足某个条件------->若有，则返回True

**4. np.where() : 用于数据替换**

*  np.where(arry\[0:2,0:5\]>0, 1, 0) \# 将arry\[0:2,0:5\]>0 这个数组，True替换为1，False替换为0。

**5. 复合逻辑：**  
1. np.logical\_and(多个条件运算)  
2. np.logical\_or(多个条件运算)

eg:  
np.where(np.logical\_and(temp > 0.5, temp < 1), 1, 0)  
np.where(np.logical\_or(temp > 0.5, temp < -0.5), 1, 0)

#### 统计计算 ####

**1. 统计指标**

*  min
 *  max
 *  median: 中位数，把数据有序排列后，位于中间位置的一个元素，或者两个数的平均值。
 *  mean 平均值
 *  std : 标准差
 *  var : 方差

求每一行的最大值：  
np.max(temp,axis=1) \# temp 一个ndarray , axis = 0按列  
求每一行（例）中位数。

*  argmax \# 最大元素对应的下标
 *  argmin \# 最小元素对应的下标  
    返回每行（列）最大（小）的值所在的下标。

#### 矩阵乘法 ####

m x n ✖ n x w

性质：

*  不满足交换律，结合律随便用。
 *  单位矩阵，主对角线全为1，其余全为0。
 *  方阵

#### 数组间的运算 ####

**1. 数组与标量---------->每个元素与对应标量加减乘除**  
arr + 1 ----->每个元素都加1  
arr\_2 = np.linspace(1,12,12).reshape((2,6))

**2. 同型数组相加减乘除------->对应元素相加减乘除**  
**3. 不同型数组相加减乘除------->广播机制转化成两个同型数组加减乘除**

*  **2x1 + 2x6------------> 将2x1扩展（复制列），得到2x6 .在对应元素相加。**
 *  **1x6 + 2x6------------> 将1x6扩展（复制行），得到2x6 .在对应元素相加。**

#### 广播机制 ####

当操作两个数组时，numpy会逐个比较他们的shape,只有满足以下两个条件之一才能进行运算。

1.  形状相同
2.  维度不同，其中一个为1
    
    1.  右对齐--------->第一个维度相等
    2.  右对齐--------->第一个维度不相等，其中一个为1，再匹配第二个若**相等** 或 其中一个**无第二个维度** 则可进行运算。
    3.  右对齐--------->第一个维度不相等，其中一个为1，再匹配第二个若不相等，且其中有一个维度为1，继续第2条 。

如:  
(2,3,1)  
& (1,3)  
可以进行计算！

--------------------

**API**  
举证惩罚

*  np.matmul(,) \# 俩矩阵位置不能变（严格矩阵运算）只能进行内积
 *  np.dot（） \# 可进行标量运算。（矩阵\*标量）

### np函数 ###

1.  **np.genfrontxt(fname, delimiter = " ",dtype = )**  
    官方链接：[https://docs.scipy.org/doc/numpy/reference/generated/numpy.genfromtxt.html][https_docs.scipy.org_doc_numpy_reference_generated_numpy.genfromtxt.html]

## Pandas ##

**适用于数据集的处理**  
**简介**

*  专门用于**数据挖掘**（从数据中挖掘有用信息）的开源python库
 *  以Numpy为基础，借力Numpy模块在计算方面性能高的优势
 *  基于matplotlib，能够简便的画图  
    独特的数据结构

**Panda优势：**

1.  便捷的数据处理能力，适用于数据集的处理
2.  读取文件方便
3.  封装了Matplotlib、Numpy的画图和计算

--------------------

numpy中定义一个数组-------->用一个个中括号来表示\[\[1,2,3\],\[3,4,5\]\]  
缺点：

1.  不方便知道数据是什么类型
2.  不方便获取数据

**让数据更有意义的显示：**  
pd.DataFrame(数据) ------->将数组转换成DataFrame类型之后会增加行索引（index）和列索引（columns）

行索引和列索引默认为从**0**开始递增的**整数**。

0         1         2         3         4
    0  0.456165  0.412092 -0.423105  0.975382 -0.979893
    1 -0.908583  2.169640 -0.215136 -0.588375 -1.010057

**创建DateFrame**

1.  指定数据，默认索引：
    
     *  data = pd.DataFrame(ndarray)
2.  指定数据，指定索引：
    
     *  data = pd.DateFrame(old\_array, index = … ,cloumns = …)

生成一个dataframe:

*  数据：old\_array
 *  行:index
 *  列：clolumns  
    不指定行列默认是从0开始的递增整数。

**notes:**

*  index、columns分别接收一个元素个数为行数、列数的**矩阵**。
 *  data.values
    
     *  data = pd.DateFrame(old\_array, index = … )
     *  data = pd.DateFrame(data, col = … )  
        1. 此时DataFrame中所有元素值为：NAN  
        因为：data 是一个DataFrame类型数据，生成dataframe应该接收三部分内容：数据、行索引、列索引。  
        2. 两个data占用不同的内存空间。  
        (玛德制仗，第一次创建一个DateFrame类型数据，用data指向。第二次创建一个新的DateFrame，data指向了新的DateFrame，这不就是变量赋值吗？)

# 添加列索引（按天递增，除去周末）
    
    # 创建列索引序列
    col = pd.data_range('2019-01-01','2019-06-06', period = data.shape[1],freq = 'B')
    
    data = pd.DateFrame(old_data,index=  ,columns = col)
    
    
    # 
    date_range(start=None,end=None, periods=None, freq='B')
    
        start:开始时间
    
        end:结束时间
    
        periods:时间天数
    
        freq:递进单位，默认1天,'B'默认略过周末

**DataFrame结构：**

*  index
 *  columns
 *  values

**DataFrame结构：**

1.  shape
2.  index
3.  columns
4.  values
5.  T
6.  head(n)
7.  tail(n)

**DataFrame索引设置：1. 修改行列索引值——构造新索引序列，重新赋值。**

index = ['第'+ i + ‘行’ for i in range(data.shape[0]) ] 
    
    data.index = index

**note：** 绝不能直接修改某行或某列索引值。  
但是能直接得到某行某列索引。

data.index[3] = ‘第四行’ （×）

\**2. 重置行索引:data.reset\_index()*

*  data.reset\_index(drop = True)
 *  drop=True: 丢掉原来的索引，新生成的索引为：0123456…
 *  drop=False (默认) **不丢掉原来的索引**

**3. 以某列值设置为新的行索引:set\_index(keys, drop=True)**

*  **keys**: 列索引名成或者列索引名称的列表
 *  **drop** : boolean, default True.当做新的索引，删除原来的列
 *  drop=True (默认) **删掉原来的索引**

df.set\_index(‘month’,drop=“Flase”) 把month作为索引，并保留month  
**若要重置例索引可结合转置**

--------------------

### MultiIndex ###

*  多级或分层索引对象。(有多个索引）

mlt = data.set\_index( \[‘month’,‘year’\] )  
mlt .index  
levels：\[ \[索引1对应的所有可能取值\], \[索引2对应的所有可能取值\] \] 从小到大排列后，剔除所有重复的值。  
codes：\[ \[\],\[\] \]  
names: \[‘索引1’ , ‘索引2’\]

# 把某些列设置为新索引
        res = df.set_index(['month', 'year'])  # 两个索引放在一个列表中
        res.index
        MultiIndex(levels=[[1, 4, 7, 10], [2012, 2013, 2014]],
                   codes=[[0, 1, 2, 3], [0, 2, 1, 2]],  # 第一行的月份，在levels中的下标为0.....,第一行的年份，在levels的第零个位置...第三行2013年，在levels中年份的下标为1处。
                   names=['month', 'year'])

### Panel ###

DataFrame：二维数据容器  
Panel：三维数据容器  
新版本已弃用！

### Seriese结构 ###

DataFrame：二维数据容器  
Seriese：一维数据容器  
一般对应DataFrame中一列。  
无列索引。

构成：

*  values
 *  index

**创建series**

1.  通过已有数据创建：
    
     *  指定内容，默认索引：  
        pd.series(np.range(10))
     *  指定内容，指定索引  
        pd.series(\[1,5,6,8,2,5\],index=\[1,2,3,4,5,6\])
2.  通过字典数据创建：
    
     *  pd.series(\{ ‘red’ : 100, ‘blue’ : 200, ‘green’ : 900\})

**获取series值**

*  index
 *  value

--------------------

## 基本数据操作 ##

### 1.索引操作（切片获取） ###

1.  **先列后行： df.\[列\]\[行\]**  
    (行列名顺序写反会报错！)
    
     *  data\[‘列名’\]
     *  df\[列\] \[行\]
2.  **先行后列： loc\[ 行 , 列 \]、iloc\[ , \]、ix\[ , \]**

*  **loc** – 先行后列,是需要通过索引的**字符串**进行获取  
    data.\[‘行’,‘列1:‘列2’\] ------ >一个中括号，用 ‘逗号 ’隔开，支持切片,也可以传数组
    
     *  **iloc** – 先行后列,是通过**下标**进行索引
     *  **ix** – 先行后列, 可以用上面两种方法**混合**进行索引

data['2019-01-01']   # 列索引直接取一列
    data['第0行']     # 拿不到第0行，还会报错。
    
    # data.loc[  行，  列  ], 支持切片。
    data.loc[:'第2行',:'2019-01-03 ']
    
    # data.iloc[]
    data.iloc[:3,2:4]
    
    #       2019-01-03 00:00:00	2019-01-04 00:00:00
    # 第0行	1.735143    	-2.720271
    # 第1行	-0.063767   	-0.495603
    # 第2行	-0.932807   	0.887615
    
    # data.ix[]
    data.ix[:1,:'2019-01-03 ']

### 2.赋值操作 ###

*  data\[""\] = \*\*
 *  data. =

### 3. 排序 ###

*  dataframe
    
     *  对象.sort\_values(by =‘列名’ ,ascending = ) 按列排序
     *  对象.sort\_index()
 *  series
    
     *  对象.sort\_values()
     *  对象.sort\_index()
    
    --------------------
    
     *  单个键或者多个键进行排序,默认升序
        
         *  ascending=False:降序
         *  ascending=True:升序
         *  by = ‘列名’ / by = \[‘列名1’，‘列名2’\]

--------------------

## DataFrame运算 ##

### 1. 算术运算 ###

*  add(something)

data['age'].add(1)

*  sub(something)
 *  …

### 2. 逻辑运算 ###

逻辑运算返回的结果为逻辑结果：True\\False  
逻辑运算符：

> /><|&  
> data\[(data\[‘p\_change’\] > 2) & (data\[‘open’\] > 15)\] （使用了布尔索引取值）

逻辑运算函数：

*  query(expr)
    
     *  expr:查询字符串
     *  返回满足条件的所有行
     *  eg : data.query(“p\_change > 2 & turnover > 15”)
 *  isin(values) ： 某一列
    
     *  eg : data\[data\[‘turnover’\].isin(\[4.19, 2.39\])\] (使用了布尔索引取值)

### 3. 统计运算 ###

data.describe() \# 返回data每一列对应的所有常用统计运算。------在每一列上把所有的常用统计运算都做一遍。

describe：  
min(最小值), max(最大值), mean(平均值), median(中位数), var(方差), std(标准差),mode(众数),prod(累乘),idmax(最大值下标),idmin(最小值下标)

*  df.max() ---- 返回每一列最大值组成一个数组
 *  df.max(x)-----返回指定列最大值
 *  data.idxmin(axis=0)
 *  data.idxmax(axis=0)

**对于单个函数去进行统计的时候，坐标轴还是按照这些默认为“columns” (axis=0, default)，如果要对行“index” 需要指定(axis=1)**  
np.max(索引（0，1，2，3，…）,axis = 1) \# axis = 1 : 按行运算

### 4. 累计统计函数 ###

函数 作用  
cumsum 计算前1/2/3/…/n个数的和  
cummax 计算前1/2/3/…/n个数的最大值  
cummin 计算前1/2/3/…/n个数的最小值  
cumprod 计算前1/2/3/…/n个数的积

**notes:**

*  累计统计函数，得到的结果是一列。（前面的统计函数得到的是一个数）  
    ![统计函数][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5eF94_size_16_color_FFFFFF_t_70 3]  
    累计统计一般都会结合排序进行运算

# 按照索引(时间)排序
    temp = data.sort_index()
    
    res = temp['price_change'].cumsum()
    
    # 绘制折线图
    res.plot()
    plt.title('股票价格变化图')
    plt.show()

### 5. 自定义运算 ###

*  apply(func, axis=0)  
    ![自定义函数][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5eF94_size_16_color_FFFFFF_t_70 4]  
    appy(函数，axis = 0) \# axis = 0指定按列计算，函数必须接收一个参数—即df中的列数据。

## Pandas画图 ##

**1. pandas.DataFrame.plot**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5eF94_size_16_color_FFFFFF_t_70 5]

## 文件的读取与存储 ##

> 我们的数据大部分存在于文件中，所以pandas会支持复杂的I/O操作。

### 1.CSV ###

**1.1 read\_csv**

*  pandas.read\_csv(‘文件路径’,sep=’ ')
 *  读取文件，指定只获取‘open’,‘close’
    
     *  pd.read\_csv(‘文件路径’, usecols = \[‘open’,‘close’\])

**1.2 to\_csv**

*  保存‘open’列的特征
    
     *  data\[:10\].to\_csv(’./data/test.csv’, cloumns = \[‘open’\])

无./data/test.csv时会新建，已有文件./data/test.csv时，默认会覆盖掉原来的数据。

--------------------

*  DataFrame.to\_csv(path\_or\_buf=None, sep=’, ’, columns=None, header=True, index=True, mode=‘w’, encoding=None)
    
     *  path\_or\_buf :string or file handle, default None
     *  sep :character, default ‘,’
     *  columns :sequence, optional
     *  mode:‘w’：重写, ‘a’ 追加
     *  index:是否写进行索引
     *  header :boolean or list of string, default True,是否写进列索引值

### 2. HDF5 ###

数据集群中要使用的文件，二进制 、表格…  
**HDF5文件的读取和存储需要指定一个键，值为要存储的DataFrame**  
**1. read\_hdf5**

*  pandas.read\_hdf(path\_or\_buf，key =None，\*\* kwargs)
    
     *  key ：一个文件中可能有多张表，用于指定读哪张表。一个表可以不指定

eg: day\_eps\_ttm = pd.read\_hdf("./data/stock\_data/day/day\_eps\_ttm.h5")  
**2. to\_hdf5，需要指定关键字**

*  DataFrame.to\_hdf(path\_or\_buf, key, *\\kwargs*)
    
     *  写表必须指定key

eg :day\_eps\_ttm.to\_hdf("./data/test.h5", key=“day\_eps\_ttm”)

**3. 再次读取,需要指定关键字名字**  
eg : new\_eps = pd.read\_hdf("./data/test.h5", key=“day\_eps\_ttm”)  
**拓展：**  
**优先选择使用HDF5文件存储**

*  HDF5在存储的时候支持压缩，**使用的方式是blosc**，这个是**速度最快**的也是**pandas默认支持**的
 *  使用压缩可以**提升磁盘利用率**，**节省空间**
 *  HDF5还是跨平台的，可以轻松迁移到hadoop 上面

### 3.JSON ###

json : 文本文件

*  pandas.read\_json(path\_or\_buf=None, orient=None, typ=‘frame’, lines=False)
 *  orient:以什么格式存储
    
     *  records :
 *  lines :
    
     *  lines = False \{‘字段名’：‘值’ ,‘字段名’:‘值’…\} ------一行就是一个小样本。
     *  lines = True : 所有数据一行显示

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5eF94_size_16_color_FFFFFF_t_70]: /images/20220126/43dc22311b964c7f91b07f8f0eb69647.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5eF94_size_16_color_FFFFFF_t_70 1]: /images/20220126/6a13e9087dad422fa28270c1a35d5ea1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5eF94_size_16_color_FFFFFF_t_70 2]: /images/20220126/4d6bea04122b44d7ae68b71e91e3ba0a.png
[https_docs.scipy.org_doc_numpy_reference_generated_numpy.genfromtxt.html]: https://docs.scipy.org/doc/numpy/reference/generated/numpy.genfromtxt.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5eF94_size_16_color_FFFFFF_t_70 3]: /images/20220126/e5dcbcca806548b8bd05ee7ddb7b990b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5eF94_size_16_color_FFFFFF_t_70 4]: /images/20220126/ee5dbfad9be04538a8033147bf629247.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5eF94_size_16_color_FFFFFF_t_70 5]: /images/20220126/d31e2a8d37354ea79c35fe0129057ed2.png