Pandas模块：表计算与数据分析
一 . pandas简单介绍
一、pandas是一个强大的Python数据分析的工具包。
二、pandas是基于NumPy构建的。php
三、pandas的主要功能html
- 具有对其功能的数据结构DataFrame、Series
- 集成时间序列功能
- 提供丰富的数学运算和操做
- 灵活处理缺失数据
四、安装方法：pip install pandas
五、引用方法：import pandas as pdpython
二 . Series
1 . Series 数组
Series是一种相似于一维数组的对象 , 有下面两部分组成 : 数据结构
-
- values : 一组数据(ndarray类型)
- index : 相关的数据索引标签
2 . series的建立 app
1) . 由列表或numpy数组建立 : 默认索引为 0 到 N-1 的整数 dom
2) . 由字典建立 : 不能再使用index , 可是依然存在默认索引函数
注意 : 数据源必须是一维数组工具
二-1 . series特性
1 . series 的索引ui
可使用中括号取单个索引(此时返回的是元素类型) , 或者中括号里一个列表取多个索引(此时返回的是一个Series类型) .
(1) . 显示索引 :
- 使用 index 中的元素做为索引值
- 使用 s.loc [ ] (推荐) , 注意 : loc 中括号中放置的必定是显示索引
注意 : 此时是闭区间
(2) . 隐式索引 :
- 使用整数做为索引值
- 使用 .iloc [ ] (推荐) : iloc 中的括号中必需要放置隐式索引
注意 : 此时是半开区间
2 . 切片
(1) . 显示索引切片 : index 和 loc
(2) . 隐式索引切片 : 整数索引值 和 iloc
3 . 基本概念
能够把series当作是一个定长的有序字典
(1) . 向Series增长一行 , 至关于给字典增长一组键值对. 能够经过 shape , size , index , values 等获得 series的属性 .
(2) . 可使用 .head() 和 .tail 分别查看前n个和后n个值
4 . 去重
.unique()
二-2 . Series数据对齐
1 . pandas在运算时,会按索引进行对齐而后运算,若是存在不一样的索引,则结果的索引是两个操做索引的并集.
2 . series 之间的运算
1) . + - * /
2) . add() , sub() , mul() , div() ,
注意 : 如何在两个Series对象相加时将缺失值设为0？
sr1.add(sr2, fill_value=0)
3) . 在运算中自动对齐不一样索引的数据 , 若是索引对不齐,则补NaN
二-3 . Series数据缺失
当索引没有对应值的时候,可能会出现缺失数据显示NaN的状况
一、缺失数据：使用NaN（Not a Number）来表示缺失数据。其值等于np.nan。内置的None值也会被当作NaN处理。
二、处理缺失数据的相关方法：
- dropna() 过滤掉值为NaN的行
- fillna() 填充缺失数据
- isnull() 返回布尔数组，缺失值对应为True
- notnull() 返回布尔数组，缺失值对应为False
三、过滤缺失数据：sr.dropna() 或 sr[data.notnull()]
四、填充缺失数据：fillna(0)
三 . DataFrame
DataFrame是一个表格型的数据结构.
DataFrame由必定顺序排列的多列数据组成
DataFrame既有行索引,也有列索引
- 行索引：index
- 列索引：columns
- 值：values
三-1 . DataFrame的建立
导包 : from pandas import DataFrame
最经常使用的方法是传递一个字典来建立。DataFrame以字典的键做为每一【列】的名称，以字典的值（一个数组）做为每一列。
此外，DataFrame会自动加上每一行的索引。
使用字典建立的DataFrame后，则columns参数将不可被使用。
同Series同样，若传入的列与字典的键不匹配，则相应的值为NaN。
1 . 使用 ndarray 建立DataFrame
2 . 使用 字典 建立 DataFrame
三-2 . DataFrame查看数据
查看数据经常使用属性及方法： index 获取索引 T 转置 columns 获取列索引 values 获取值数组 describe() 获取快速统计 DataFrame各列name属性：列名 rename(columns={}) #字典建立不能用
三-3 . DataFrame的索引与切片
DataFrame有行索引和列索引。
DataFrame一样能够经过标签和位置两种方法进行索引和切片。
DataFrame使用索引切片：
- 方法1：两个中括号，先取列再取行。 df['A'][0]
- 方法2（推荐）：使用loc/iloc属性，一个中括号，逗号隔开，先取行再取列。
loc属性：解释为标签
iloc属性：解释为下标
向DataFrame对象中写入值时只使用方法2
行/列索引部分能够是常规索引、切片、布尔值索引、花式索引任意搭配。（注意：两部分都是花式索引时结果可能与预料的不一样）
1 . DataFrame的索引
(1) . 对列进行索引
(2) . 对行进行索引
- 使用 .loc [] 加index来进行索引
- 使用 .iloc [] 加整数来进行索引
一样返回一个 Series , index为原来的 columns
(3) . 对元素进行索引
- 使用列索引
- 使用行索引(iloc[3,1] or loc['C','q']) 行索引在前，列索引在后
2 . 切片
注意 : 直接使用中括号时 :
- 索引表示列索引
- 切片表示行切片
三-4 . DataFrame的运算
DataFrame之间的运算同Series同样
- 在运算中自动对齐不一样索引的数据
- 若是索引不对应,则补NaN
三-5 . DataFrame的数据对齐和数据缺失
DataFrame对象在运算时，一样会进行数据对齐，行索引与列索引分别对齐。
结果的行索引与列索引分别为两个操做数的行索引与列索引的并集。
注意 :
- None
None是Python自带的，其类型为python object。所以，None不能参与到任何计算中。
- np.nan (NaN)
np.nan是浮点类型，能参与到计算中。但计算的结果老是NaN。
案例 :
pandas中None与np.nan都视做np.nan
DataFrame处理缺失数据的相关方法：
- dropna(axis=0,where=‘any’,…) 过滤掉值为NaN的行
- 注意 : 在dropna中, axis=0 表示行,与常规相反
- fillna() 填充缺失数据
- 参数 : method
- bfill : 选择向后填充(和后面数相同) df.fillna(method='bfill',axis=1)
- ffill : 选择向前填充 df.fillna(method='ffill',axis=1)
- 参数 : method
- isnull() 返回布尔数组，缺失值对应为True
- 检查条件 isnull.any(axis=1)
- notnull() 返回布尔数组，缺失值对应为False
- 检查条件 notnull.all(axis=1)
三-6 . 建立多层DataFrame
- 取得列:df['col'] df[[c1,c2]] df.loc[:,col]
- 取行:df.loc['index'] df[index1:inde2]
1 . 隐式构造
最多见的方法是给DataFrame构造函数的index或者columns参数传递两个或更多的数组
DataFrame(data=np.random.randint(0,100,size=(2,2)),columns=[['a','b'],['A','B']])
2 . 显示构造
pd.MultiIndex.from_product
col=pd.MultiIndex.from_product([['qizhong','qimo'], ['chinese','math']]) #建立DF对象 df = DataFrame(data=np.random.randint(60,120,size=(2,4)),index=['tom','jay'], columns=col)
3 . 多层行索引
逐级降层
df['qimo']
df['qimo']['math']
# 获取tom期中全部科目的考试成绩 df['qizhong'].loc['tom']
注意
在对行索引的时候，若一级行索引还有多个，对二级行索引会遇到问题！也就是说，没法直接对二级索引进行索引，必须让
二级索引变成一级索引后才能对其进行索引！
总结：
访问一列或多列 直接用中括号[columnname] [[columname1,columnname2...]]
访问一行或多行 .loc[indexname]
访问某一个元素 .loc[indexname,columnname] 获取李四期中的php成绩
行切片 .[index1:index2] 获取张三李四的期中成绩
列切片 .loc[:,column1:column2] 获取张三李四期中的php和c++成绩
三-7 . 聚合操做
所谓的聚合操做：平均数，方差，最大值，最小值…
df.sum(axis=0)
df.mean()
三-8 . pandas的拼接操做
pandas的拼接分为两种：
- 级联：pd.concat, pd.append
- 合并：pd.merge, pd.join
1 . 使用pd.concat()级联
pandas使用pd.concat函数，与np.concatenate函数相似，只是多了一些参数：
objs axis=0 keys join='outer' / 'inner':表示的是级联的方式，outer会将全部的项进行级联（忽略匹配和不匹配）， 而inner只会将匹配的项级联到一块儿，不匹配的不级联 ignore_index=False
导包 :
import numpy as np import pandas as pd from pandas import Series,DataFrame
(1) . 匹配级联
df1 = DataFrame(data=np.random.randint(0,100,size=(3,3)),index=['a','b','c'],columns=['A','B','C']) df2 = DataFrame(data=np.random.randint(0,100,size=(3,3)),index=['a','d','c'],columns=['A','d','C'])
(2) . 不匹配级联
不匹配指的是级联的维度索引不一致.例如 : 纵向级联时索引不一致,横向级联时索引不一致
链接方式 :
-
-
- 外链接 : 补NaN (默认方式)
- 内链接 : 只链接匹配的项
-
pd.concat((df1,df2),axis=1,join='outer') # 内链接
(3) . 使用df.append() 函数添加
因为在后面级联的使用很是广泛，所以有一个函数append专门用于在后面添加
df1.append(df2) #列索引必须一致
2 . 使用 pd.merge() 合并
merge与concat的区别在于，merge须要依据某一共同的列来进行合并
使用pd.merge()合并时，会自动根据二者相同column名称的那一列，做为key来进行合并。
注意每一列元素的顺序不要求一致
参数：
- how：out取并集 inner取交集
- on：当有多列相同的时候，可使用on来指定使用那一列进行合并，on的值为一个列表
(1) . 一对一合并
df1 = DataFrame({'employee':['Bob','Jake','Lisa'],
'group':['Accounting','Engineering','Engineering'],
})
df2 = DataFrame({'employee':['Lisa','Bob','Jake'],
'hire_date':[2004,2008,2012],
})
pd.merge(df1,df2) #自动找相同的,列进行合并
(2) . 多对一合并
df3 = DataFrame({ 'employee':['Lisa','Jake'], 'group':['Accounting','Engineering'], 'hire_date':[2004,2016]}) df4 = DataFrame({'group':['Accounting','Engineering','Engineering'], 'supervisor':['Carly','Guido','Steve'] }) pd.merge(df3,df4,how='outer')
left right
(3) . 多对多合并
df1 = DataFrame({'employee':['Bob','Jake','Lisa'],
'group':['Accounting','Engineering','Engineering']})
df5 = DataFrame({'group':['Engineering','Engineering','HR'],
'supervisor':['Carly','Guido','Steve']
})
pd.merge(df1,df5,how='left')
left right
(4) . key 的规范化
-
- 当列冲突时，即有多个列名称相同时，须要使用on=来指定哪个列做为key，配合suffixes指定冲突列名
df1 = DataFrame({'employee':['Jack',"Summer","Steve"],
'group':['Accounting','Finance','Marketing']})
df2 = DataFrame({'employee':['Jack','Bob',"Jake"],
'hire_date':[2003,2009,2012],
'group':['Accounting','sell','ceo']})
pd.merge(df1,df2,on='group',how='outer')
-
- 当两张表没有可进行链接的列时，可以使用left_on和right_on手动指定merge中左右两边的哪一列列做为链接的列
df1 = DataFrame({'employee':['Bobs','Linda','Bill'],
'group':['Accounting','Product','Marketing'],
'hire_date':[1998,2017,2018]})
df5 = DataFrame({'name':['Lisa','Bobs','Bill'],
'hire_dates':[1998,2016,2007]})
display(df1,df5)
(5) . 内合并与外合并 : out取并集 , inner取交集
-
- 内合并 : 只保留二者都有的key(默认模式)
df6 = DataFrame({'name':['Peter','Paul','Mary'],
'food':['fish','beans','bread']}
)
df7 = DataFrame({'name':['Mary','Joseph'],
'drink':['wine','beer']})
display(df6,df7)
-
- 外合并 : how='outer' : 补NaN
df6 = DataFrame({'name':['Peter','Paul','Mary'],
'food':['fish','beans','bread']}
)
df7 = DataFrame({'name':['Mary','Joseph'],
'drink':['wine','beer']})
display(df6,df7)
pd.merge()
三-9 . 数据处理
1 . 删除重复元素 : duplicated()
使用duplicated()函数检测重复的行，返回元素为布尔类型的Series对象，每一个元素对应一行，若是该行不是第一次出现，则元素为True
- keep 参数 : 指定保留那一重复的行数据
# 建立具备重复元素行的DataFrame import numpy as np import pandas as pd from pandas import Series,DataFrame # 建立一个 df np.random.seed(1) df = DataFrame(data=np.random.randint(0,100,size=(8,6))) df
#手动将df的某几行设置成相同的内容 df.iloc[1] = [6,6,6,6,6,6] df.iloc[3] = [6,6,6,6,6,6] df.iloc[4] = [6,6,6,6,6,6]
未变以前 改变以后
(1) . 方式一 :
# 使用duplicated查看全部重复元素行 df.duplicated(keep='last')
indexs = df[df.duplicated(keep='last')].index #获取须要删除行的索引 df.drop(labels=indexs,axis=0) #删除重复行
(2) . 方式二 :
使用drop_duplicates()函数删除重复的行
- drop_duplicates(keep='first/last'/False)
df.drop_duplicates() #一步到位
2 . 映射
(1) . replace() 函数 : 替换元素
使用replace()函数，对values进行映射操做
Series替换操做
- 单值替换
- 普通替换
- 字典替换(推荐）
- 多值替换
- 列表替换
- 字典替换（推荐）
- 参数
- to_replace:被替换的元素
replace参数说明：
- method：对指定的值使用相邻的值填充替换
- limit：设定填充次数
DataFrame替换操做
- 单值替换
- 普通替换： 替换全部符合要求的元素:to_replace=15,value='e'
- 按列指定单值替换： to_replace={列标签：替换值} value='value'
- 多值替换
- 列表替换: to_replace=[] value=[]
- 字典替换（推荐） to_replace={to_replace:value,to_replace:value}
注意：DataFrame中，没法使用method和limit参数
df.replace(to_replace=6,value='six') #用'six'代替df中的'6' df.replace(to_replace={3:6},value='six') #用'six'代替df中第4列的'6' df.replace(to_replace={1:'one'}) #用'one'代替df中的''1'
3 . map() 函数 :
新建一列 , map函数并非df的方法 , 而是series的方法
- map()能够映射新一列数据
- map()中可使用lambd表达式
-
map()中可使用方法，能够是自定义的方法
eg:map({to_replace:value})
注意 map()中不能使用sum之类的函数，for循环
dic = { 'name':['周杰伦','李四','王五'], 'salary':[1000,2000,3000] } df = DataFrame(data=dic)
#新增一列：给df中，添加一列，该列的值为中文名对应的英文名 #封装一个映射关系表 dic = { '周杰伦':'jay', '王五':'wangwu', '李四':'lisi' } df['ename'] = df['name'].map(dic) df
(1) . map当作一种运算工具，至于执行何种运算，是由map函数的参数决定的（参数：lambda，函数）
- 使用自定义函数
#自定义函数 def after_salary(s): if s <= 500: return s else: return s - (s-500)*0.5 #超过500部分的钱缴纳50%的税 after_sal = df['salary'].map(after_salary) df['after_salary'] = after_sal df
- 使用lambda表达式
#员工的薪资集体提升500 df['salary'].map(lambda x:x+500)
4 . 数据重排 --- 使用 .take() 函数排序
- take()函数接受一个索引列表，用数字表示,使得df根据列表中索引的顺序进行排序
- eg:df.take([1,3,4,2,5])
- np.random.permutation(x)能够生成x个从0-(x-1)的随机数列
df.take(np.random.permutation(1000),axis=0).take(np.random.permutation(3),axis=1) #np.random.permutation(1000) :把0,1000随机排列成列表
当DataFrame规模足够大时，直接使用np.random.permutation(x)函数，就配合take()函数实现随机抽样
5 . 数据分类处理 [重点]
数据聚合是数据处理的最后一步，一般是要使每个数组生成一个单一的数值。
数据分类处理：
- 分组：先把数据分为几组
- 用函数处理：为不一样组的数据应用不一样的函数以转换数据
- 合并：把不一样组获得的结果合并起来
数据分类处理的核心：
- groupby()函数 - groups属性查看分组状况 - eg: df.groupby(by='item').groups
(1) . 分组
#数据源 df = DataFrame({'item':['Apple','Banana','Orange','Banana','Orange','Apple'], 'price':[4,3,3,2.5,4,2], 'color':['red','yellow','yellow','green','green','green'], 'weight':[12,20,50,30,20,44]}) #分组 df.groupby(by='item') #查看分组状况 df.groupby(by='item').groups
分组后还能够聚合 : sum , mean
#计算出苹果的平均价格 dic = { 'Apple':3, 'Banana':2.75, 'Orange':3.5 } df['mean_price'] = df['item'].map(dic) df.groupby(by='item')['price'].mean()['Apple'] #按颜色查看各类颜色的水果的平均价格 df.groupby(by='color')['price'].mean() dic={ 'green':2.83, 'red':4, 'yellow':3 } df['color_mean_price'] = df['color'].map(dic) df
6 . 高级数据聚合
使用groupby分组后，也可使用transform和apply提供自定义函数实现更多的运算
- df.groupby('item')['price'].sum() <==> df.groupby('item')['price'].apply(sum)
- transform和apply都会进行运算，在transform或者apply中传入函数便可
- transform和apply也能够传入一个lambda表达式
#求出各类水果价格的平均值 df.groupby(by='item')['price'].mean()
apply和transform
#定义执行方法 def fun(s): sum = 0 for i in s: sum+=s return sum/s.size
#使用apply函数求出水果的平均价格 df.groupby(by='item')['price'].apply(fun) #给fun传入的参数是一个列表 #使用transform函数求出水果的平均价格 df.groupby(by='item')['price'].transform(fun) #给fun传入的参数是一个列表