Pandas模块：表计算与数据分析

一 . pandas简单介绍  

1、pandas是一个强大的Python数据分析的工具包。
2、pandas是基于NumPy构建的。

3、pandas的主要功能

• 具备对其功能的数据结构DataFrame、Series
• 集成时间序列功能
• 提供丰富的数学运算和操作
• 灵活处理缺失数据

4、安装方法：pip install pandas
5、引用方法：import pandas as pd

二 . Series  

1 . Series  

　　Series是一种类似于一维数组的对象 , 有下面两部分组成 : 

• • values : 一组数据(ndarray类型)
  • index :  相关的数据索引标签　　　　　　

 

2 . series的创建 

　　1) . 由列表或numpy数组创建  : 默认索引为 0 到 N-1 的整数 

　　2) . 由字典创建 : 不能再使用index , 但是依然存在默认索引

 　　　　注意 : 数据源必须是一维数组

 

 

     二-1 . series特性   

1 . series 的索引

 　　可以使用中括号取单个索引(此时返回的是元素类型) , 或者中括号里一个列表取多个索引(此时返回的是一个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的情况

1、缺失数据：使用NaN（Not a Number）来表示缺失数据。其值等于np.nan。内置的None值也会被当做NaN处理。

2、处理缺失数据的相关方法：

• dropna() 过滤掉值为NaN的行
• fillna() 填充缺失数据
• isnull() 返回布尔数组，缺失值对应为True
• notnull() 返回布尔数组，缺失值对应为False

 

3、过滤缺失数据：sr.dropna() 或 sr[data.notnull()]

4、填充缺失数据：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)
• 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传入的参数是一个列表