pandas数据分析库

Pandas

Pandas基本介绍

Python在数据处理和准备⽅⾯⼀直做得很好，但在数据分析和建模⽅⾯就差⼀些。pandas帮助填补了这⼀空⽩，使您能够在Python中执⾏整个数据分析⼯作流程，⽽不必切换到更特定于领域的语⾔，如R。

pandas是 Python 的核⼼数据分析⽀持库，提供了快速、灵活、明确的数据结构，旨在简单、直观地处理关系型、标记型数据。pandas是Python进⾏数据分析的必备⾼级⼯具。

pandas的主要数据结构是 Series(⼀维数据)与 DataFrame (⼆维数据)，这两种数据结构⾜以处理⾦融、统计、社会科学、⼯程等领域⾥的⼤多数案例

处理数据⼀般分为⼏个阶段：数据整理与清洗、数据分析与建模、数据可视化与制表，Pandas 是处理数据的理想⼯具。

Pandas的基本数据结构

pandas中有两种常用的基本结构

• Series
  一维数组，与Numpy中的一维array类似，二者与Python基本的数据结构List也很相似。Series能保存不同种数据类型，字符串、boolean值、数字等都能保存在Series种。
• DataFrame
  二维的表格型数据结构，很多功能与R种的data.frame类似。可以将DataFrame理解为Series的容器。

Pandas库的Series类型

一维Series可以用一维列表初始化

Series生成

默认的情况下，Series的下标都是数字（可以使用额外参数指定），类型是统一的。

a=pd.Series([1,3,5,np.nan,6,5])
print(a)
# 输出为：
0    1.0
1    3.0
2    5.0
3    NaN # ⽆论是numpy中的NAN还是Python中的None在pandas中都以缺失数据NaN对待
4    6.0
5    5.0
dtype: float64 # 左边为索引，右边为各个元素对应的取值；
b=pd.Series([1,3,5,np.nan,6,5],index=['a','b','c','d','e','f']) #index设置索引
print(b)
# 输出为：
a    1.0
b    3.0
c    5.0
d    NaN
e    6.0
f    5.0
dtype: float64

Series查看数据

索引——数据行标签：index
取值：values
切片：[开始索引，结尾索引]前闭后开
索引赋值：a.index.name=‘索引’ a.index=list(‘abcdef’)

Pandas库的DataFrame类型

DataFrame初始化

DataFrame是由多种类型的列构成的⼆维标签数据结构，类似于 Excel 、SQL 表，或 Series 对象构成的字典。

# 首先构造一组时间序列，作为第一维的下标
date=pd.date_range('20200101',periods=6) 
print(date)
# 输出为：
DatetimeIndex(['2020-01-01', '2020-01-02', '2020-01-03', '2020-01-04',
               '2020-01-05', '2020-01-06'],
              dtype='datetime64[ns]', freq='D')

# 然后创建一个DataFream结构，不指定任何index参数
df=pd.DataFrame(np.random.randn(6,4))
df    # 默认使用0、1、2.。。作为索引index、columns
# 输出为：
	0   1   2   3
0   -1.490125   1.298987    -0.543361   1.221980
1   -0.849709   0.118608    -0.955715   0.144980
2   -0.599598   -0.756037   -1.795249   -0.282495
3   -0.332586   1.750622    -1.493345   -2.100013
4   -0.905893   -0.254791   -1.476728   -0.001651
5   -1.121065   -1.861881   -0.502420   0.523135

# index参数设置行索引，columns参数设置列索引
df=pd.DataFrame(np.random.randn(6,4),index=date,columns=list('ABCD'))
df   
# 输出为：
A   B   C   D
2020-01-01  0.443978    -0.568280   0.539422    -1.808815
2020-01-02  -0.941946   1.600655    -0.165418   -0.143333
2020-01-03  0.058186    1.299691    -0.722582   -0.258170
2020-01-04  0.912441    -1.347266   -0.827097   -1.189625
2020-01-05  0.427125    0.010411    -0.390411   1.172277
2020-01-06  -0.584286   -0.428119   0.536305    1.327480

 # 使用字典传入数据pd.DataFrame({})
df1=pd.DataFrame({'A':1,'B':pd.Timestamp('20200101'),'C':pd.Series(1,index=list(range(4)),dtype=float),'D':np.array([3]*4,dtype=int),'E':pd.Categorical(['test','train','test','train']),'F':'abc'})
df1
# 输出为：
	A   B   C   D   E   F
0   1   2020-01-01  1.0 3   test    abc
1   1   2020-01-01  1.0 3   train   abc
2   1   2020-01-01  1.0 3   test    abc
3   1   2020-01-01  1.0 3   train   abc
# 字典的每个key代表一列，其value可以是各种能够转化为Series的对象
# 与Series要求所有的类型都一致不同，DataFrame只要求每一列数据的格式相同

DataFrame查看数据

• 头尾数据 :head和tail方法可以分别查看最前面几行和最后面几行的数据（默认为5）
• 下标:使用index属性查看
• 列标:使用columns属性查看
• 数据值:使用values查看
• 查看形状，⾏数和列数:shape
• 查看数据类型:dtypes
• 查看数值型列的汇总统计,计数、平均值、标准差、最⼩值、四分位数、最⼤值：describe()
• 查看列索引、数据类型、⾮空计数和内存信息：info

df.dtypes # 查看整个数组类型
df['列名'].dtype # 查看指定列数值类型

head() # 查看最开始5行数据
tail() # 查看最末尾5行数据

df.index # 查看索引（下标）
df.columns # 查看列的名字（列的表头）

df['列名'] # 查看那列的值
df.values # 查看数据值

Pandas读取数据及数据操作

读取数据

• txt:read_csv()
• csv:read_csv()
• excel:read_excel() # 在使用pandas读取excel文件之前，需要先安装Python读取excel的依赖包：xlrd，可以使用pip命令从豆瓣源上下载：pip install -i https://pypi.douban.com/simple xlrd
  
  地址前添加R，避免系统将地址中的的/认为是转义字符，导致读取失败
• Sql:read_mysql() # 通过pandas来读取student表数据。在读取数据之前，先要安装Python读取mysql的第三方库：pip install -i https://pypi.douban.com/simple pymysql

# 路径一致时
pd.read_excel('文件名.xlsx')
pd.read_csv('文件名.csv',sep='\s+')
pd.read_csv('文件名.txt',engine='python',sep='\s+')

# 路径不一致时
pd.read_excel(r'文件路径.xlsx')

数据查询-行操作

行操作：iloc/loc iloc左必右开，loc全闭
添加行：append
删除行：drop

dit={'名字':'复仇者联盟3',
     '投票人数':123456,
     '类型':'剧情/科幻',
     '产地':'美国',
     '上映时间':'2017-05-04 00:00:00',
     '时长':142,
     '年代':2017,
     '评分':8.7,
     '首映地点':'美国'} # 构建字典数据
s=pd.Series(dit) # 构建一维数组
s.name=38738 # 数据索引号
df_mv=df_mv.append(s) #添加行数据，对原来的数据进行覆盖

数据查询-列操作

增加一列：df_mv[‘序号’]=range(1,len(df_mv)+1) # range(A,B)从A到B，不包含B
删除列：df_mv=df_mv.drop(‘序号’,axis=1) axis=1，告诉软件删除的是一列，axis=0是默认设置，为行

数据清洗通过标签选择数据

df.loc[[index],[column]]通过标签选择数据

条件选择

df_mv[df_mv['产地']=='中国大陆'][:5] # 选取产地为美国的所有电影

df_mv[(df_mv.产地=='美国')&(df_mv.评分>9)].head() # 选取产地为美国，且评分大于9的电影

数据清洗

缺失值处理

处理方法

方法	说明
dropna	根据标签中的缺失值进行过滤，删除缺失值
fillna	对缺失值进行填充
isnull	返回一个布尔值对象，判断哪些值是缺失值
notnull	isnull的否定式

缺失值判断

df_mv[df_mv['名字'].isnull()].head()  #isnull 判断使用

填充缺失值

• df.fillna 如果不指定填充位置，则全部空置进行填充
• 填充字符类:df_mv[‘名字’].fillna(‘未知电影’,inplace=True) 填充的项目，fillna填充函数，inplace=True直接在原始数据上修改
• 填充数值类:df_mv[‘评分’].fillna(np.mean(df_mv[‘评分’]),inplace=True)

删除缺失值

df.dropna()参数

• how=‘all’ 删除全为空值的行或者列
• inplace=ture：覆盖之前的数据
• axis=0/1选择行/列

处理异常值

异常值，即在数据集中存在不合理的值，又称离群点。比如年龄为-1，笔记本电脑重量为1吨等，都属于异常值的范围。

df[df.'投票人数'<0]
df[df['投票人数']%1!==1] 
df[df.条件]

对于异常值，一般来说数量都会很少，在不影响整体数据分布的情况下，我们直接删除就可以了。

其他属性的异常值处理，我们会再格式转换部分，进一步讨论

数据保存

数据处理后，然后将数据重新保存

df.to_execl(表格名称) #没有写路径，默认在本身路径下

Pandas操作

数据格式转换astype()

在做数据分析的时候，原始数据往往会因为各种各样的原因产生各种数据格式的问题。

数据格式是我们非常需要注意的一点，数据格式错误往往会造成扬中的后果

并且，很多异常值也是我们经过格式转换之后才会发现，对我们规整数据，清洗数据有着重要的作用。

查看数据格式dype()

df['投票人数'].dype
df[修改格式索引]=df[修改格式索引].astype(目标格式)

将年份转化为整数格式

df['年代']=df['年代'].astype('int')

运行后，如果存在数据异常，则会报错。

将时长转化为整数格式

df['时长']=df['时长'].astype('int')

排序

默认排序：按照index排序

• 单个要求排序：

df.sort_values(by=变量，ascending=true) # 根据那个变量排序，括号里面就填写那个变量，ascending默认为ture可不写，为升序；修改为false则为降序

• 多个值排序

df.sort_values(by[A,B],asecnding=false) 先按照A，再按照B降序排列

基本统计分析

(1)描述性统计

dataframe.describe():对dataframe中的数值型数据进行描述性统计
# 对df中的数值型数据进行描述性统计，返回均值、标准差、总数、极值等
df.describe()

通过描述性统计，可以发现一些异常值，很多异常值往往是需要我们逐步去发现的。

df.drop(df[df['年代'>2018].index.inplace=true) 
- df[df['年代'>2018]  #查询年代大于2018年的数据
- df[df['年代'>2018].index #获取查询数据对应的行索引
- df.drop 进行删除数据
- inplace=true 覆盖源数据

(2)最值

# 返回某列的最大值
df['列名'].max()

# 返回某列的最小值
df['列名'].min()

(3)均值和中值

df['列名'].mean() # 均值

df['列名'].median() # 中值

(4)方差和标准差

df['列名'].var() # 方差

df['列名'].std() # 标准差

(5)求和

df['列名'].sum()

(6)相关系数，协方差

df[['列名1','列名2']].corr() # 相关系数

df[['列名','列名2']].cov() # 协方差

(7)技数

len(df) # df的长度

df['列名'].unique() # 某列中出现的不重复的值

len(df['列名'].unique()) # 某列中单次出现的值的数量
df['列名'].nunique() #同上

df['列名'].value_counts() # 计算某一列中出现的值各自出现的总数

数据替换

df['产地'].replace('usa','美国',inplace=ture)
df['产地'].replace(['西德','苏联'],['德国','俄罗斯'],inplace=ture)

数据透视

excel中数据透视表的使用非常广泛，其实pandas也提供一个类似的功能，名为pivot_table

pivot_table非常有用，我们将重点解释pandas中的函数pivot_table

使用pandas中pivot_table的一个挑战是，你需要确保你理解你的数据，并清楚地知道你想知道通过透视表解决什么问题。

虽然pivot_table看起来只是一个简单的函数，但是它能够快速地对数据进行强大的分析。

1、基础设置

# 允许显示的最大列
pd.set_option('max_columns',100)

# 允许显示的最大行
pd.set_option('max_rows',500)

# 生成索引为某列名的数据透视表
pd.pivot_table(df.index=['列名'])

2、设置多个索引

pd.pivot_table(df,index=['列名1','列名2'])

3、统计需要汇总的数据

pd.pivot_table(df,index=['列名1','列名2'].values=['列名3'])

4、指定函数统计不同的统计值

pd.pivot_table(df,index=['列名1','列名2'],values=['列名3'],aggfunc=np.sum)

pd.pivot_table(df,index=['列名1'],values=['列名2','列名3'],aggfunc=[np.sum,np.mean])

5、移除非数值（NaN)

# 用'fill_value'将其设置为0
pd.pivot_table(df,index=['列名'],aggfunc=[np.sum,np.mean],fill_value=0)

6、在表格最下方呈现汇总数据

pd.pivot_table(df,index=['列名'],aggfunc=[np.sum,np.mean],fill_value=0,margins=True)

7、对不同值执行不同的函数

# 向aggfunc传递一个字典
pd.pivot_table(df,index=['列名'],values=['列名1','列名2'],aggfunc={'列名1':sum,'列名2':mean})

透视表过滤

#给将筛选结果复制给某个参数
table=pd.pivot_table(df,index=['列名'],values=['列名1','列名2'],aggfunc={'列名1':sum,'列名2':mean})
赋值后操作如dataframe
# 数据透视表结果相当于生成了一个新的dataframe，可对这个dataframe进行查询透视

数据重塑

层次化索引

层次化索引是pandas的一项重要功能，它能使我们在一个轴上拥有多个索引。

(1)series的层次索引

s=pd.Series(np.arange(1,10),index=[['a','a','a','b','b','b','c','c','c'],[1,2,3,1,2,3,1,2,3]])
# 输出结果
a 1 1
  2 2
  3 3
b 1 4
  2 5
  3 6
c 1 7
  2 8
  3 9

# 输出外层索引为'a'的数据
s['a']

# 输出外层索引从a到c的数据
s['a':'c']

# 输出内层索引为1的数据
s[:,1]

# 输出外层索引为b，内存索引为2的数据
s['b',2]

(2)Dataframe的层次索引
对dataframe来说，行和列都能够进行层次化索引。
每一个索引就是一个元组。

# 行和列都可做层次化索引，变索引后，可用.loc方法查找信息

# 行— —
pd.DataFrame(np.arange(12).reshape(4,3),index=[['a','a','b','b'],[1,2,1,2]])

# 列— —
pd.DataFrame(np.arange(12).reshape(4,3),index=[['a','a','b','b'],[1,2,1,2]],columns=[['A','A','B'],['Z','X','C']])

# 给层次化索引命名
data.index.names=['row1','row2']
data.columns.names=['col1','col2']

# 交换行层次化索引
data.swaplevel('row1','row2')

# set_index可以把列变成索引
df.set_index(['列名1','列名2'])

# reset_index把索引变成列，取消索引
df=df.reset_index()

# 查询某个索引对应的数据
df.loc(列索引)

数据转换、数据旋转

dataframe也可以使用stack和UNstack，转换为层次化索引的series

# 行列转换
data.T

# DataFrame转换为多层次化的Series
data.stack() 转为series

s.unstack() # 将Series变成DataFrame

s.unstack().stack() # 将DataFrame转成Series

数据分组

数据分组与分组运算

GroupBy实现数据分组与分组运算，类似于数据透视表
只会对数值变量进行分组运算，将数据格式修改为str格式后，将不能机型分组运算。

# 定义单个分组变量，即为分组依据
group1=df.groupby(df['列名'])

# 根据分组数据求均值
group1.mean()

# 根据某列数据对分组数据运算均值
df['列名'].groupby(df['分组列名']).mean()

# 传入多个分组变量
df.groupby([df['分组列名1'],df['分组列名2']]).mean()

# 根据某列数据对多个分组数据求均值
df['列名'].groupby([df['分组列名1'],df['分组列名2']]).mean()

离散化处理（分组/区间化）

在实际的数据分析项目中，对有的数据属性，我们往往并不关注数据的绝对值，只关注它所处的区间或者等级。

离散化也可称为分组、区间化。
pandas为我们提供了方便的函数cut():
pd.cut(x.bins,right=true,tables=none,retbins=false,precision=3,include_lowest=fase)

x:需要离散化的数组、series、dataframe对象
bins:整数，标量序列或者间隔索引，是进行分组的依据，
如果填入整数n，则表示将x中的数值分成等宽的n份；
如果是标量序列（比如，[0,30,40,70]），序列中的数值表示用来分档的分界值
right=True表示分组右边闭合，right=False表示分组左边闭合，
labels
labels:数组或布尔值，可选.表示分组的自定义标签。
如果是数组，长度要与分箱个数一致，比如“ bins”=[1、2、3、4]表示（1,2]，（2,3],（3,4]一共3个区间，则labels的长度也就是标签的个数也要是3
如果为False，则仅返回分箱的整数指示符，即x中的数据在第几个箱子里
retbins:是否显示分箱的分界值。默认为False，当bins取整数时可以设置retbins=True以显示分界值，得到划分后的区间
precision:整数，默认3，存储和显示分箱标签的精度。
include_lowest:布尔值，表示区间的左边是开还是闭，默认为false，也就是不包含区间左边。
duplicates:如果分箱临界值不唯一，则引发ValueError或丢弃非唯一

df['新列名']=pd.cut(df['列名'],[0,3,5,7,9,10],labels=['E','D','C','B','A'])
# 准备一个以列名的100%等级数据的分组依据
bins=np.percentile(df['列名'],[0,20,40,60,80,100])

df['新列名']=pd.cut(df['列名'],bins,labels=['E','D','C','B','A'])

合并化数据集

append

先把数据集拆分为多个，再进行合并。

# 拆分数组再合并
df1=df[df.列名=='数据1']
df2=df[df.列名=='数据2']
df2.append(df1)

merge

# 横向拼接
pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None,
         left_index=False, right_index=False, sort=True,
         suffixes=('_x', '_y'), copy=True, indicator=False,
         validate=None)

参数如下：
left:拼接的左侧DataFrame对象
right:拼接的右侧DataFrame对象
on:要加入的列或索引级别名称。 必须在左侧和右侧DataFrame对象中找到。 如果未传递且left_index和right_index为False，则DataFrame中的列的交集将被推断为连接键。
left_on:左侧DataFrame中的列或索引级别用作键。 可以是列名，索引级名称，也可以是长度等于DataFrame长度的数组。
right_on:左侧DataFrame中的列或索引级别用作键。 可以是列名，索引级名称，也可以是长度等于DataFrame长度的数组。
left_index:如果为True，则使用左侧DataFrame中的索引（行标签）作为其连接键。 对于具有MultiIndex（分层）的DataFrame，级别数必须与右侧DataFrame中的连接键数相匹配。
right_index: 与left_index功能相似。
how:One of ‘left’, ‘right’, ‘outer’, ‘inner’. 默认inner。inner是取交集，outer取并集。比如left：[‘A’,‘B’,‘C’];right[’'A,‘C’,‘D’]；inner取交集的话，left中出现的A会和right中出现的买一个A进行匹配拼接，如果没有是B，在right中没有匹配到，则会丢失。'outer’取并集，出现的A会进行一一匹配，没有同时出现的会将缺失的部分添加缺失值。
sort:按字典顺序通过连接键对结果DataFrame进行排序。 默认为True，设置为False将在很多情况下显着提高性能。
suffixes:用于重叠列的字符串后缀元组。 默认为（‘x’，’ y’）。
copy:始终从传递的DataFrame对象复制数据（默认为True），即使不需要重建索引也是如此。
indicator:将一列添加到名为_merge的输出DataFrame，其中包含有关每行源的信息。 _merge是分类类型，并且对于其合并键仅出现在“左”DataFrame中的观察值，取得值为left_only，对于其合并键仅出现在“右”DataFrame中的观察值为right_only，并且如果在两者中都找到观察点的合并键，则为left_only。
参考资料:https://blog.csdn.net/brucewong0516/article/details/82707492

concat

# 将多个数据集进行批量合并
df1=df[:10]
df2=df[100:110]
df3=df[200:210]
dff=pd.concat([df1,df2,df3],axis=0)