1. 基本知识

· Anaconda

定义：

包管理器，附带一大批常用数据科学包，包括conda、Python等
环境管理，解决多版本python并存、切换的问题

· Jupyter notebook

一种Web应用，能让用户将说明文本、数学方程、代码和可视化内容全部组合到一个易于共享的文档中

- 单元格操作

a、命令模式：蓝色
执行代码，快捷键基本用 shift组合

enter：进入 cell 单元编辑

shift+enter：运行当前行并跳转到下一行，没有下一行会创建

ctrl+enter：只运行当前行

alt+enter：运行当前行，并创建一行空行

a：往上插入一行

b：往下插入一行

y：转换为代码

m：转换为Markdown

r：转换为Row NBconvert

x：剪切一行

c：复制一行

v：粘贴剪切/复制行到下一行

shift+v：粘贴剪切/复制行到上一行

dd：删除一行

z：撤销删除

ctrl+z：撤销输入修改，但是要选择具体的单元（除非修改后还没有运行），这个其实是编辑模式的

ctrl+s：保存节点，便于恢复

f：查找和替换

k 键或者方向上键：选择上一行

j 键或者方向下键：选择下一行

shift+k 或者 shift + 方向上键：选择当前行和上一行，一直按会选择很多行

shift+j 或者 shift + 方向下键：选择当前行和下一行
（也可以用 shift 来选择多行，shift +鼠标单击第一行和最后一行来选择）
注意：不能跨行选择，即选择的行都是连续的

shift+m：merge 合并选择的行，如果没有选择多行那么会合并当前行和下一行

space：往下滑动多行

shift+space：往上滑动多行

ctrl+shift+p：进入的界面是将下面这些快捷键又变成了选择按钮了

b、编辑模式：绿色
编写代码，快捷键基本用 ctrl 组合

tab键：代码补全

shift+tab：函数提示

ctrl + ]：缩进，就是往后退格，相当于tab 键的功能，只不过不需要指定在行首输入

ctrl + [：取消缩进

ctrl+a：全选

ctrl+z：撤销

ctrl+shift+z：对撤销的操作进行撤销

ctrl+y：对撤销的操作进行撤销

对cell 单元格内容进行位置定位：

ctrl+home、ctrl+up：定位到当前 cell 单元格所有内容的最前头

ctrl+end、ctrl+down：定位到当前 cell 单元格所有内容的最后头

ctrl+left：定位到当前 cell 单元格光标位置的下一个词语结尾

ctrl+right：定位到当前 cell 单元格光标位置的上一个词语开头
配合shift使用可以快速选中：比如ctrl+shift+left ，可以选中左边数据

ctrl+backspace：删除前一个单词

ctrl+delete：删除后一个单词

ctrl+m、esc：切换到命令模式

使用分号可以阻止该行函数的结果输出，这种需求也可以注释代码来实现
查看函数帮助可以使用多种方法：
1、shift+tab
2、？func
3、help(func)

· Pandas

Pandas是基于Numpy的专业数据分析工具，可以灵活高效的处理各种数据集。
NumPy是用Python进行科学计算的基础软件包，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。
对于两种数据结构的操作：DataFrame和Series

1）Series

相当于列

#默认导入panda包，简称pd
pd.Series([列表数据]，[索引名称])

#另一种指定索引写法，字典
pd.Series({'索引1':数据1，'索引2':数据2})

· 每次使用Series函数只能导入一列数据
· 索引默认为从0开始的数字
· Series转换成DateFrame
S变量名.to_frame()

2）DataFrame

相当于一个表格，有索引、列、行

-1 创建

#默认导入panda包，简称pd
#多维列表创建
pd.DataFrame([列表数据1],[列表数据2],[列表数据3]...)


#另一种指定索引写法，字典创建
pd.DataFrame({'列名1':[列表数据],'列名2':[列表数据],.....index=[索引名称])

· 索引默认为从0开始的数字
· 多维列表创建时，列表名默认为从0开始的数字

-2 获取行列索引
· 获取行索引：表名.index
· 获取列索引/列名：表名.columns
· 同时获取行列索引：表名.axes

-3 重命名行列索引
· 行索引：表名.index = [新索引名称]
· 列索引/列名：表名.columns = [新索引名称]

-4 将某列数据转化为行索引
表名.set_index('指定列的索引/列名')

-5 数据预览
· 表名.info() 👉 获取表的结构信息
· 表名.describe() 👉 获取表中数值列的信息，包括计数、平均值、最小值等
· 表名.head(num) 👉 获取前num的行信息，num默认为5
· 表名.tail(num) 👉 获取倒数num的行信息，num默认为5
· 表名.size 👉 表格包含的数据数量
· 表名.shape 👉 输出（行数，列数）
· 表名.dtypes 👉 输出列的数据类型 int64、object

-6 数据读取
pd.read_格式(fileppath,header输入,skiprows输入)

格式：csv 、excel（文件后缀为.xlsx和.xls）

header：用作列名的行号，默认为0（第一行），如果没有header就应该设置为None

skiprows：跳过文件指定行，以列/数值的形式输出
// skiprows = num 👉 表示直接删除表格里前两行，此时如果有列名行，也会删除掉
// skiprows = [数值列表] 👉 表示删除列表里指定的行

-7 转换空值
如果文件表格里有空值，则输出NaN；如果要取消NaN的出现，则使用 keep_default_na = False
如：
表名.read_格式(fileppath,header输入,skiprows输入,keep_default_na = False)

·pandas的索引和常用操作

索引，指明数据位置的标志。

- 获取

1）选取行
使用 loc 或者 iloc 函数来实现，使用方法基本一致，两者区别：
· loc 是基于索引值的，切片是左闭右闭的，索引值是可以变的，如由序号列转为其它列
· iloc 是基于位置的，切片是左闭右开的，位置是不变，与序号列相同

函数表达:
a: 表名.loc[单个索引数值]
b: 表名.loc[[多个索引数值]] → 列表数值有多个数字组成
c: 表名.loc[num1:num2] → 切片模式，左闭右闭
d: bool 类型索引

# 定义布尔值
bl = 表名['列名'] + 判断条件
表名.loc[bl]

e. 表名[],针对切片模式和布尔模式
表名[num1:num2]
效果等同于表名.iloc[num1:num2] ,左闭右开

表名[表名['列名'] + 判断条件]

2）选取列
表名['列名']
如果输出列为多列，需要用 [] 括起来，

3）选取行列
表名.loc[索引选择表达式，指定输出列]
p.s 如果指定输出列为多列，需要用 [] 括起来，索引表达式同理

iloc函数也如此

- 修改

1）修改列索引
a.再定义覆盖原列名
表名.columns = ['新列1名','新列2名','新列3名'.....]

b.rename函数
表名.rename(columns = {'原列1':'新列1','原列2':'新列2'}....)

2）获取单个整列
表名.列名（名字需由字母数字下划线组成）

3）替换值
表名.replace({'指定列名':{'原值1':'新值1'},inplace=True})

inplace = True 表示永久修改此数据，为Flase则表名临时修改数据，且默认为Flase

- 排序

表名.sort_values('列') → 针对单个列，默认升序，若降序，则在'列'后加ascending=Flase

表名.sort_values([多列列表],ascending=[对应升降序判断])

- 计算

1）查看一列多少个值 👉 表名.列名.unique()
2）对列所包含对的每类值计算 👉 表名.列名.value_counts()
3）求极值 👉 表名.max() 、表名.min()、表名.sum()
求和时，字符串联结
4）累加求和 👉 表名.cumsum()

- 增删改换

1）增加 👉 表名['新列名'] = 默认值
2）删除列 👉 del 表名['列名']
3）删除行列 👉 drop函数
表名.drop('行列名',axis判断行列)
默认 axis=0 删除行，为1删除列
4）修改
👉 某个值，表名.replace({'指定列名':{'原值1':'新值1'},inplace判断})
👉 整列值，表名['列名'].map({'列值类一':'对应新值','列值类一':'对应新值'.....})
需把该列每类值都列举出来，否则默认为NaN

- 列最值得索引位置

表名.idxmax() → 要求整个表都是数值类型
表名[[数值类列表]].idxmax()

- 矩阵间运算

a.相同维度得矩阵加减乘除就是位置一一对应得元素进行操作
b.单个矩阵运算，则是默认个数据都进行该运算

- 数据关联

1）简单拼接 concat函数
A. 上下拼接，列并集

pd.concat([表1,表2....])

拼接后的表的新列由表1、表2组成，并集，如果没有值，则为NaN
拼接后的序号也是拼接的，如果要生成新的序号，语法如下：

pd.concat([表1,表2....],ignore_index=True)

B. 左右拼接，序号并集

pd.concat([表1,表2....],axis=1)

拼接后的表的新序号由表1、表2组成，并集，如果没有值，则为NaN
拼接后的列也是拼接的，不管名字是否相同

2）条件关联 merge函数
A. 等同inner join

pd.merge(表1,表2,on='共同key列名'])

pd.merge(表1,表2,on=['共同key1列名','共同key2列名'])

B. 等同非inner join ，使用how

pd.merge(表1,表2,how='left',on='共同key列名'])

pd.merge(表1,表2,how='right',on='共同key列名'])

pd.merge(表1,表2,how='outer',on='共同key列名'])

当多表的key列名不一致时，语法如下：

pd.merge(表1,表2,表1_on='表1key列名',表2_on='表2key列名')

C. 通过索引来关联
将key连转换为索引，代替序号列，然后再关联

表1.set_index('key1列名',inplace=True)
表2.set_index('key2列名',inplace=True)

pd.merge(表1,表2,表1_index=True,表2_index=True)

- 分组操作

1）获取指定列的分类组成

表名.列名.unique() 👉 输出为一个列，由该列分类项组成
// 列名需为字母、数字、下划线组成
表名.列名.value_counts() 👉 输出为一个列表，展现该列分类以及对应的个数

2）groupby 函数
接收变量 = 表名.groupby('分组参数列名')
A. 接受变量.size()
👇
输出列表（'分组参数列名')，''
分组类别对应个数

B. 接收变量.groups
输出字典
分组类别：组成
// 有点mysql concat的意思

C. len(接收变量) 👉 输出该分组列表的分类种类个数

D. 使用for循环解包
for 变量1，变量2 in 接收变量：
prin(变量1)

// 变量2的输出为在变量1分类下的行组合

E. 分组下的聚合函数

接受变量.mean() 👉 输出每个分类中每个列的平均值
接受变量.mean() 👉 输出每个分类中每个列的总值
接收变量.列名.mean() 👉 输出每个分类中指定列的平均值
作用多个函数
导入numpy
· 接收变量.agg([np.mean,np.sum]) 👉 输出每个分类中每个列的平均值、总值
· 接收变量.列名.agg([np.mean,np.sum]) 👉 输出每个分类中指定列的平均值、总值
· 接收变量.agg({'列1':np.mean,'列2':np.sum}) 👉 输出每个分类中不同列的不同计算值
分组过滤类似having
接收变量.filter(lambda g : g['筛选列'].计算函数+判断式)

- 转换过滤 transform函数

将表内空值转换为指定值，包括数字、字符 👉 表名.fillna(指定值)

transform函数是把分组后的组内计算值赋予给该组类每一行，从而保证输出结果和原表一样的行数

表名.groupby('分组参数列名')['计算列'].transfom('计算表达式')
👇
输出为：
原序列该序号对应分组的计算结果

// 计算表达式有：sum、min、max，更复杂的可以用lambda 参数:参数表达式来使用

- pandas 连接 MySQL

1）连接MySQL

import pandas  as pd

2）写入MySQL

创建列表1
列表1.to_sql('sql文件名',engine,index=False)

numpy

定义：numpy（Numerical Python）提供了python对多维数组对象的支持：ndarray，具有矢量运算能力，快速、节省空间。numpy支持高级大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。

ndarray:N维数组对象（矩阵），所有元素必须是相同类型

1）创建array

列表创建

# -*- coding: utf-8 -*-

import numpy as np

print '使用列表生成一维数组'
data = [1,2,3,4,5,6]
x = numpy.array(data)
print x #打印数组
print x.dtype #打印数组元素的类型

print '使用列表生成二维数组'
data = [[1,2],[3,4],[5,6]]
x = numpy.array(data)
print x #打印数组
print x.ndim #打印数组的维度
print x.shape #打印数组各个维度的长度。shape是一个元组

print'填充指定值创建'
x = np.full([行数,列数],填充值) #创建数组，并且每个位置用指定填充值来填充，填充值可为数值、字符串、True/False

print '使用zero/ones/empty创建数组:根据shape来创建'
x = numpy.zeros(6) #创建一维长度为6的，元素都是0一维数组
print x
x = numpy.zeros((2,3)) #创建一维长度为2，二维长度为3的二维0数组
print x
x = numpy.ones((2,3)) #创建一维长度为2，二维长度为3的二维1数组
print x
x = numpy.empty((3,3)) #创建一维长度为2，二维长度为3,未初始化的二维数组
print x

print '使用arrange生成连续元素'
np.arange(起始值，结束值，步长)  # 左闭右开，步长默认为1 
print numpy.arange(6) # [0,1,2,3,4,5,] 开区间
print numpy.arange(0,6,2)  # [0, 2，4]

print 'arrange输出一维函数，如果要输出多维，使用reshape(行数，列数)'
print numpy.arrange(18).reshape(3,6)

print '随机矩阵'
random.random(行数,列数）#表示要得到一个指定行指定列的矩阵，默认会产生 -1 到 +1 的随机值。

print '平均划分矩阵'
print numpy.linspace(起始值，结束值，划分数) #在 左闭右闭区间，平均生产【划分数】的值

2）numpy 的切片和索引
变量 = np.array(多维列表)

获取数据：变量[行数，列数] 👉 获取位置在第【行数+1】行，第【列数+1】行的值，行数、列数默认从0开始
使用切片：变量[行索引表达式，列索引表示] 👉 表达式可以为切片，也可以是列表

import numpy as np
data = np.array([
                    [5,10,15,12,34], 
                    [20,25,30,23,678],
                    [35,40,45,56,435],
                    [23,56,23,234,212],
                    [67,34,234,575,6786]
                 ])
data[0:3,[0,1]]  #使用切片时，是左闭右开区间
array([[ 5, 10],
       [20, 25],
       [35, 40]])

data[:,0:1] 
array([[ 5],
       [20],
       [35],
       [23],
       [67]])

data[[0,1],[2,3]] # 如果索引表达式均为列表，则类似解包，一一对应输出指定位置，如果列表里数字数量不同，则输出失败
array([15, 23])

布尔索引
设置布尔条件，从而判断序列中的值

vector = np.array([5, 10, 15, 20 ,10])
vector
vector == 10 # 设置布尔条件
equal_to_ten = (vector == 10)
equal_to_ten
输出 ：array([False,  True, False, False,  True], dtype=bool)
vector[equal_to_ten] #判断满足条件的值
输出：array([10, 10])
res = (vector == 10) | (vector == 20)
vector[res]
输出：array([10, 20, 10])

pandas 笔记