Pandas的数据结构
导入pandas：
三剑客
import pandas as pd from pandas import Series,DataFrame import numpy as np
1、Series
Series是一种类似与一维数组的对象，由下面两个部分组成：
-
values：一组数据（ndarray类型）
-
index：相关的数据索引标签
1）Series的创建
两种创建方式：
(1) 由列表或numpy数组创建
默认索引为0到N-1的整数型索引
#使用列表创建Series Series(data=[1,2,3,4],index=['ds','dsa','re','gr'],name='haha')#index参数指定索引 #使用numpy创建Series Series(data=np.arange(10,60,6))
(2) 由字典创建:不能在使用index.但是依然存在默认索引
注意：数据源必须为一维数据
dic = { 'math':100, 'English':50 } Series(data=dic,name='qimo')
2）Series的索引和切片
可以使用中括号取单个索引（此时返回的是元素类型），或者中括号里一个列表取多个索引（此时返回的是一个Series类型）。
(1) 显式索引：
- 使用index中的元素作为索引值 - 使用s.loc[]（推荐）:注意，loc中括号中放置的一定是显示索引
注意，此时是闭区间
s = Series(np.random.randint(60,100,size=(5,)),index=['a','b','c','d','e']) s s['b']
(2) 隐式索引：
- 使用整数作为索引值
- 使用.iloc[]（推荐）:iloc中的中括号中必须放置隐式索引注意，此时是半开区间
s.iloc[1]
s.iloc[[1,2,3]]
切片:隐式索引切片和显示索引切片
- 显示索引切片:index和loc
s.loc['b']
- 隐式索引切片：整数索引值和iloc
s.loc['a':'c']
3）Series的基本概念
可以把Series看成一个定长的有序字典
向Series增加一行：相当于给字典增加一组键值对
s['f'] = 100 s
可以通过shape，size，index,values等得到series的属性
s.index
s.values
s.size
s.shape
可以使用s.head(),tail()分别查看前n个和后n个值
s.head(3)
s.tail(3)
对Series元素进行去重
s = Series(data=[1,1,2,2,3,3,4,4,4,5,6,7,8,7,7,66,43,342,6665,444,333,444]) s.unique() #Series中的去重函数
当索引没有对应的值时，可能出现缺失数据显示NaN（not a number）的情况
-
使得两个Series进行相加
s1 = Series(data=[1,2,3,4,5],index=['a','b','c','d','e']) s2 = Series(data=[1,2,3,4,5],index=['a','b','c','f','g']) s = s1+s2 s
可以使用pd.isnull()，pd.notnull()，或s.isnull(),notnull()函数检测缺失数据
s.loc[s.notnull()] #空值检测,过滤 s.iloc[[True,False,True,True,False,True,True]] #True/False是可以作为Series的索引
4）Series的运算
(1) + - * /
(2) add() sub() mul() div() : s1.add(s2,fill_value=0)
(3) Series之间的运算
- 在运算中自动对齐不同索引的数据
- 如果索引不对应，则补NaN
2、DataFrame
DataFrame是一个【表格型】的数据结构。DataFrame由按一定顺序排列的多列数据组成。设计初衷是将Series的使用场景从一维拓展到多维。DataFrame既有行索引，也有列索引。
-
行索引：index
-
列索引：columns
-
值：values
1）DataFrame的创建
最常用的方法是传递一个字典来创建。DataFrame以字典的键作为每一【列】的名称，以字典的值（一个数组）作为每一列。
此外，DataFrame会自动加上每一行的索引。
使用字典创建的DataFrame后，则columns参数将不可被使用。
同Series一样，若传入的列与字典的键不匹配，则相应的值为NaN。
DataFrame(data=np.random.randint(60,100,size=(3,3)),index=['a','b','c'],columns=['A','B','C'])
DataFrame属性：values、columns、index、shape
df = DataFrame(data=np.random.randint(60,100,size=(3,3)),index=['a','b','c'],columns=['A','B','C']) df df.values df.index df.columns
2）DataFrame的索引
(1) 对列进行索引
- 通过类似字典的方式 df['q'] - 通过属性的方式 df.q
可以将DataFrame的列获取为一个Series。返回的Series拥有原DataFrame相同的索引，且name属性也已经设置好了，就是相应的列名。
df = DataFrame(data=np.random.randint(60,150,size=(4,2)),index=['chinese','math','english','lizong'],columns=['zhangsan','li']) df #修改列索引 df['li'] = [1,2,3,4] df #获取前两列 df[['zhangsan','li']] df.li df['li']
(2) 对行进行索引
- 使用.loc[]加index来进行行索引 - 使用.iloc[]加整数来进行行索引
同样返回一个Series，index为原来的columns。
df.loc['math'] df.iloc[1] # 取出前2行 df.iloc[[0,1]]
(3) 对元素索引的方法
- 使用列索引
- 使用行索引(iloc[3,1] or loc['C','q']) 行索引在前，列索引在后
df.loc['math','zhangsan']
切片：
【注意】 直接用中括号时：
-
索引表示的是列索引
-
切片表示的是行切片
df['math':'lizong']
在loc和iloc中使用切片(切列) ： df.loc['B':'C','丙':'丁']
df.loc[:,'zhangsan':'li']
3）DataFrame的运算
（1） DataFrame之间的运算
同Series一样：
-
在运算中自动对齐不同索引的数据
-
如果索引不对应，则补NaN
示例: 假设ddd是期中考试成绩，ddd2是期末考试成绩，请自由创建ddd2，并将其与ddd相加，求期中期末平均值。 假设张三期中考试数学被发现作弊，要记为0分，如何实现？ 李四因为举报张三作弊立功，期中考试所有科目加100分，如何实现？ 后来老师发现有一道题出错了，为了安抚学生情绪，给每位学生每个科目都加10分，如何实现 df = DataFrame(data=np.random.randint(60,150,size=(4,2)),index=['chinese','math','english','lizong'],columns=['zhangsan','li']) df df1 = df.copy() df1 #假设ddd是期中考试成绩，ddd2是期末考试成绩，请自由创建ddd2，并将其与ddd相加，求期中期末平均值。 df2= df1.copy() df2 (df1+df2)/2 假设张三期中考试数学被发现作弊，要记为0分，如何实现？ df2.loc['math','zhangsan'] =0 df2 # 李四因为举报张三作弊立功，期中考试所有科目加100分，如何实现？ df2.li += 100 df2 # 后来老师发现有一道题出错了，为了安抚学生情绪，给每位学生每个科目都加10分，如何实现？ df2 +=10 df2
处理丢失数据
有两种丢失数据：
- None
- np.nan(NaN)
1. None
None是Python自带的，其类型为python object。因此，None不能参与到任何计算中。
2. np.nan（NaN）
np.nan是浮点类型，能参与到计算中。但计算的结果总是NaN。
import numpy as np import pandas as pd from pandas import DataFrame,Series type(None) type(np.nan)
3. pandas中的None与NaN
1) pandas中None与np.nan都视作np.nan
np.random.seed(10) df = DataFrame(np.random.randint(50,200,size=(6,5)),index=['a','b','c','d','e','f'],columns=['A','B','C','D','E']) df #将某些数组元素赋值为nan df.iloc[1,3] = None df.iloc[2,2] = np.nan df.iloc[4,2] = None df
2) pandas处理空值操作
-
isnull() -
notnull() -
dropna(): 过滤丢失数据 -
fillna(): 填充丢失数据
(1)判断函数
- ``isnull()`` 一般后面往往跟的是any()
- ``notnull()``一般后面往往跟的是all()
df.isnull().any(axis=1) # 只要有一个true 就返回true df.isnull().all(axis=1) #只要有一个False 就返回False,全部位true才返回true df.notnull().all(axis=1)
df.dropna() 可以选择过滤的是行还是列（默认为行）:axis中0表示行，1表示的列
df.dropna(axis=0) # 在drop系列函数中,轴向的参数值0表示的是行,1表示的是列
df.drop(labels='A',axis=1,inplace=True) # drop 可以删除任意的行和列
df1.drop(labels='abbreviation',axis=1,inplace=True) labels='abbreviation'#指定删除的行或列 axis =0 代表行 =1 代表列 inplace = True 删除后写入到原文件
(3) 填充函数 Series/DataFrame
- ``fillna()``:value和method参数
np.random.seed(10) df = DataFrame(np.random.randint(50,200,size=(6,5)),index=['a','b','c','d','e','f'],columns=['A','B','C','D','E']) df #将某些数组元素赋值为nan df.iloc[1,3] = None df.iloc[2,2] = np.nan df.iloc[4,2] = None df df.fillna(value=10)
method 控制填充的方式 bfill后向填充 ffill前向填充,可以选择前向填充还是后向填充
df.fillna(method='ffill',axis=0) df.fillna(method='bfill',axis=0) #连续多个nan df.iloc[1,3] = None df.iloc[4,3] = np.nan df.iloc[3,2] = None df #解决连续nan指定填空几个 limit df.fillna(method='bfill',axis=0,limit=1)
1. 创建多层列索引
1) 隐式构造
最常见的方法是给DataFrame构造函数的index或者columns参数传递两个或更多的数组
import numpy as np import pandas as pd from pandas import DataFrame,Series #创建了一个索引对象，该索引对象为二层索引 df = DataFrame(np.random.randint(60,100,size=(2,4)),index=['tom','jay'],columns=[['qizhong','qimo','qizhong','qimo'],['c','m','c','m']]) df
2) 显示构造pd.MultiIndex.from_
df['qimo']
获取所有学生期末的math的考试成绩
df.qimo['math']
- 获取tom期中所有科目的考试成绩
df.qizhong.loc['tom']
获取tom期末的math成绩
df['qimo'].loc['tom','math']
注意:在对行索引的时候，若一级行索引还有多个，对二级行索引会遇到问题！也就是说，无法直接对二级索引进行索引，必须让二级索引变成一级索引后才能对其进行索引！
切片操作
# 总结： # 访问一列或多列 直接用中括号[columnname] [[columname1,columnname2...]] #访问一行或多行 .loc[indexname] # 访问某一个元素 .loc[indexname,columnname] 获取李四期中的php成绩 # 行切片 .loc[index1:index2] 获取张三李四的期中成绩 # 列切片 .loc[:,column1:column2] 获取张三李四期中的php和c++成 1. 分析比较Series和DataFrame各种索引的方式，熟练掌握.loc()方法 - 在df中索引应用在行 - 在df中切片应用在列
5. 聚合操作
所谓的聚合操作：平均数，方差，最大值，最小值……
# 计算各个科目期中期末平均成绩 df.mean()
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=Falseimport numpy as np import pandas as pd from pandas import DataFrame,Series import matplotlib.pyplot as plt df1 = DataFrame(np.random.randint(0,100,size=(4,4)),index=['a','b','c','d'],columns=['A','B','C','D']) df2 = DataFrame(np.random.randint(0,100,size=(3,4)),index=['a','b','c',],columns=['A','B','C','D']) pd.concat([df1,df1],axis=1,)
2) 不匹配级联
不匹配指的是级联的维度的索引不一致。例如纵向级联时列索引不一致，横向级联时行索引不一致
有2种连接方式：
- 外连接：补NaN（默认模式）outer
- 内连接：只连接匹配的项 inner
pd.concat([df1,df2],axis=1,join='outer') pd.concat([df1,df2],axis=1,join='inner')
3) 使用df.append()函数添加
由于在后面级联的使用非常普遍，因此有一个函数append专门用于在后面添加
df1.append(df2)
2. 使用pd.merge()合并
merge与concat的区别在于，merge需要依据某一共同的列来进行合并
使用pd.merge()合并时，会自动根据两者相同column名称的那一列，作为key来进行合并。
注意每一列元素的顺序不要求一致
参数：
- how：out取并集 inner取交集
-
on：当有多列相同的时候，可以使用on来指定使用那一列进行合并，on的值为一个列表
1.加载本地excl表格数据:pd.read_excel('excel_path',sheetname=0) #sheetname 索引从0开始
1) 一对一合并
df1=pd.read_excel('./data.xlsx',sheet_name=1) df2=pd.read_excel('./data.xlsx',sheet_name=2) df3=pd.read_excel('./data.xlsx',sheet_name=3) df4=pd.read_excel('./data.xlsx',sheet_name=4) pd.merge(df1,df2,how='outer') # how 默认 是inner 内连接
2) 一对多合并
display(df2,df3) pd.merge(df2,df3,how='outer')# 一对多合并
3) 多对多合并
display(df3,df4) pd.merge(df3,df4,on='手机型号',how='outer')
4) key的规范化¶
- 当列冲突时，即有多个列名称相同时，需要使用on=来指定哪一个列作为key，配合suffixes指定冲突列名 (一般用的少)
- 当两张表没有可进行连接的列时，可使用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]})
pd.merge(df1,df5,left_on='employee',right_on='name',how='outer')
- 内合并：只保留两者都有的key（默认模式）
- 外合并 how='outer'：补NaN
df6 = DataFrame({'name':['Peter','Paul','Mary'],
'food':['fish','beans','bread']}
)
df7 = DataFrame({'name':['Mary','Joseph'],
'drink':['wine','beer']})
display(df6,df7)
pandas数据处理
1、删除重复元素
使用duplicated()函数检测重复的行，返回元素为布尔类型的Series对象，每个元素对应一行，如果该行不是第一次出现，则元素为True
- keep参数：指定保留哪一重复的行数据
- 创建具有重复元素行的DataFrame
import numpy as np import pandas as pd from pandas import Series,DataFrame #创建一个df np.random.seed(10) df = DataFrame(np.random.randint(0,100,size=(6,5))) df #手动将df的某几行设置成相同的内容 df.iloc[1]=[4,4,4,4,4] df.iloc[3]=[4,4,4,4,4] df.iloc[4]=[4,4,4,4,4] df
- 使用duplicated查看所有重复元素行
df.duplicated(keep='last') # keep参数有first last False,不指定keep默认first保留重复的第一行
- 删除重复元素的行
indexs=df.loc[df.duplicated()].index
df.drop(labels=indexs,axis=0)
- 使用drop_duplicates()函数删除重复的行 drop_duplicates(keep='first/last'/False)
df.drop_duplicates()
2. 映射
1) replace()函数：替换元素
使用replace()函数，对values进行映射操作
DataFrame替换操作
- 单值替换
- 普通替换： 替换所有符合要求的元素:to_replace=15,value='e'
- 按列指定单值替换： to_replace={列标签：替换值} value='value'
- 多值替换
- 列表替换: to_replace=[] value=[]
- 字典替换（推荐） to_replace={to_replace:value,to_replace:value}
df.replace(to_replace=9,value='nine') # 所有的9替换成nine df.replace(to_replace=[9,4],value='nine') # 多值替换9和4,替换成nine df.replace(to_replace={4:666,9:777}) # 多值字典替换 df.columns=['a','b','c','d','e'] df # 按列指定单值替换： to_replace={列标签(显示索引)：替换值} value='value',这里需要显示索引 df.replace(to_replace={'d':4},value=888) 注意：DataFrame中，无法使用method和limit参数
2) map()函数：新建一列 ， map函数并不是df的方法，而是series的方法
-
map()可以映射新一列数据
-
map()中可以使用lambd表达式
-
map()中可以使用方法，可以是自定义的方法
eg:map({to_replace:value})
-
注意 map()中不能使用sum之类的函数，for循环
- 新增一列：给df中，添加一列，该列的值为中文名对应的英文名
dic={ 'name':['cj','datou','tutou'], 'salary':[14000,6000,7000], 'dep':['sal','dev','sal'] } df=DataFrame(data=dic) df
df['name'].map({'cj':'常建','datou':'许硕','tutou':'吴晓东'}) df['c_name']=df['name'].map({'cj':'常建','datou':'许硕','tutou':'吴晓东'}) df
map当做一种运算工具，至于执行何种运算，是由map函数的参数决定的（参数：lambda，函数）
- 使用自定义函数
#超过3000部分的钱缴纳50%的税 df['salary'].map(aflter_salary) def aflter_salary(s): if s >= 3000: return s-(s-3000)*0.5 return s df['aflter_salary'] = df['salary'].map(aflter_salary) df
- 使用lambda表达式
df['salary'].map(lambda s:s-(s-3000)*0.5)
注意：并不是任何形式的函数都可以作为map的参数。只有当一个函数具有一个参数且有返回值，那么该函数才可以作为map的参数。
3. 使用聚合操作对数据异常值检测和过滤
使用df.std()函数可以求得DataFrame对象每一列的标准差
- 创建一个1000行3列的df 范围（0-1），求其每一列的标准差
df1 =DataFrame(np.random.random(size=(1000,3))) df1 s_std=df1.std(axis=0) #对df应用筛选条件,去除标准差太大的数据:假设过滤条件为 C列数据大于两倍的C列标准差 df1[1]<2*s_std[1] # 取反 ,False作为异常值 df1.loc[df1[1]<2*s_std[1] ]
4. 排序
使用.take()函数排序
- take()函数接受一个索引列表，用数字表示,使得df根据列表中索引的顺序进行排序
- eg:df.take([1,3,4,2,5])可以借助np.random.permutation()函数随机排序
df.take([1,0,2],axis=0)
- np.random.permutation(x)可以生成x个从0-(x-1)的随机数列
n=np.random.permutation(3)
df.take(n,axis=0)
随机抽样
当DataFrame规模足够大时，直接使用np.random.permutation(x)函数，就配合take()函数实现随机抽样
5. 数据分类处理【重点】
数据聚合是数据处理的最后一步，通常是要使每一个数组生成一个单一的数值。
数据分类处理：
- 分组：先把数据分为几组
- 用函数处理：为不同组的数据应用不同的函数以转换数据
- 合并：把不同组得到的结果合并起来
数据分类处理的核心： - groupby()函数 - groups属性查看分组情况 - eg: df.groupby(by='item').groups
分组
from pandas import DataFrame,Series 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实现分组
df.groupby(by='item',axis=0) df.groupby(by='item',axis=0).groups
- 分组后的聚合操作：分组后的成员中可以被进行运算的值会进行运算，不能被运算的值不进行运算
#给df创建一个新列，内容为各个水果的平均价格 df.groupby(by='item',axis=0).mean()['price'] df.groupby(by='item',axis=0)['price'].mean() 计算出苹果的平均价格 df.groupby(by='item',axis=0)['price'].mean()['Apple'] 汇总:将各种颜色水果的平均价格和df进行汇总 df.groupby(by='color',axis=0)['price'].mean() df df['mean_price']=df['color'].map({'red':4,'green':2.75,'yellow':3.50}) df
6.0 高级数据聚合
使用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函数求出水果的平均价格 df.groupby(by='item')['price'].apply(my_mean) # apply结果是经过去重的 def my_mean(s): sum = 0 for i in s: sum += i return sum/s.size #s.size 代表长度和len一样 #使用transform函数求出水果的平均价格 df.groupby(by='item')['price'].transform(my_mean)# transform结果没有去重