Pandas 拼接操作 数据处理

时间：2023-12-20 11:32:44

数据分析

生成器 迭代器 装饰器 (两层传参) 单例模式() ios七层 io多路

数据分析：是把隐藏在一些看似杂乱无章的数据背后的信息提炼出来，总结出所研究对象的内在规律

pandas的拼接操作

  • pandas的拼接分为两种：
    • 级联：pd.concat, pd.append
    • 合并：pd.merge, pd.join

使用pd.concat()级联

pandas使用pd.concat函数，与np.concatenate函数类似，只是多了一些参数：

  • objs

    axis=0

    join='outer' / 'inner':表示的是级联的方式，outer会将所有的项进行级联（忽略匹配和不匹配），而inner只会将匹配的项级联到一起，不匹配的不级联

    ignore_index=False
import pandas as pd

from pandas import Series,DataFrame

import numpy as np

  • 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','b','d'],columns=['A','B','D'])

# 显示两张表

display(df1,df2)
A B C
a 67 93 7
b 84 67 70
c 85 93 7
A B D
a 0 61 32
b 23 44 55
d 99 25 76 
# 将两张表连接在一起

pd.concat([df1,df1],axis=0,join='inner',ignore_index=True)

  • 2) 不匹配级联

  • 不匹配指的是级联的维度的索引不一致。例如纵向级联时列索引不一致，横向级联时行索引不一致

    有2种连接方式：

    • 外连接：补NaN（默认模式）
    • 内连接：只连接匹配的项
# 连接两张不同的表

# 纵向连接 不匹配的 补空

pd.concat([df1,df2],axis=0)

# 纵向连接 内连接  只显示可以比配到的 数据

pd.concat([df1,df2],axis=0,join='inner')

  • 3) 使用df.append()函数添加

由于在后面级联的使用非常普遍，因此有一个函数append专门用于在后面添加

df1.append(df2)

使用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)

    ```{'employee':['Lisa','Bob','Jake'],

     	'hire_date':[2004,2008,2012],

     	'group':['Accounting','Engineering','Engineering'],

    } ```

  • 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)

    {

        'employee':['Lisa','Jake','Jake'],

        'group':['Accounting','Engineering','Engineering'],

        'hire_date':[2004,2016,2016],

        'supervisor':['Carly','Guido','Steve']

    }

  • 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='right')  # how='right'/'lest'  以右 或 左 表的 内容为为准

  • 加载excl数据:pd.read_excel('excl_path',sheetname=1)

pd.read_excel('data.xlsx',sheet_name=1)  # sheet_name=1 指定读取哪张表

  • 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')
  • 当两张表没有可进行连接的列时，可使用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')
  1. 自行练习多对一，多对多的情况
  2. 自学left_index,right_index

  • 5) 内合并与外合并:out取并集 inner取交集

    • 内合并：只保留两者都有的key（默认模式）
df6 = DataFrame({'name':['Peter','Paul','Mary'],

               'food':['fish','beans','bread']}

               )

df7 = DataFrame({'name':['Mary','Joseph'],

                'drink':['wine','beer']})
  • ​ 外合并 how='outer'：补NaN
df6 = DataFrame({'name':['Peter','Paul','Mary'],

               'food':['fish','beans','bread']}

               )

df7 = DataFrame({'name':['Mary','Joseph'],

                'drink':['wine','beer']})

pandas 数据处理-5

1. 删除重复元素

  • 使用duplicated()函数检测重复的行，返回元素为布尔类型的Series对象，每个元素对应一行，如果该行不是第一次出现，则元素为True

    • keep参数：指定保留哪一重复的行数据

  • 使用duplicated()

    import numpy as np
    
import pandas as pd
    
from pandas import DataFrame

#创建一个df
    
df = DataFrame(data=np.random.randint(0,100,size=(10,6)))
    
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]

# 使用duplicated查看所有重复元素行
    
# 查找重复的行 first,last 保留第一个 或最后一个
    
df.duplicated(keep='first')

# 使用 drop() 删除
    
d_index = df.loc[df.duplicated(keep='first')].index
    
df.drop(labels=d_index,axis=0)

  • 使用 drop_duplicates(keep='last')

    # 使用drop_duplicates()函数删除重复的行
    
df.drop_duplicates(keep='last')

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}
    # 将数据中 所有的 6 替换为 333
    
df.replace(to_replace=6,value=333)

# 将数据中的  6, 9  替换为 333
    
df.replace(to_replace=[6,9],value=333)

# 将数据中的  0 替换为 zero
    
df.replace(to_replace={0:'zero'})

# 指定列 替换  第 9 列的 3 替换为 666
    
df.replace(to_replace={9:3},value=666)

    注意：DataFrame中，无法使用method和limit参数

2) map()函数：映射

​ 新建一列 ， map函数并不是df的方法，而是series的方法

  • map() 可以映射新一列数据

  • map() 中可以使用lambd表达式

  • map() 中可以使用方法，可以是自定义的方法

    eg:map({to_replace:value})

  • 注意 map()中不能使用sum之类的函数，for循环

  • 新增一列：给df中，添加一列，该列的值为英文名对应的中文名

    # 数据
    
dic = {
    
    'name':['Jay','Tom','Jay'],
    
    'salary':[7777,6666,7777]
    
}
    
df = DataFrame(data=dic)

#指定一个映射关系表
    
dic = {
    
    'Jay':'张三',
    
    'Tom':'李四'
    
}
    
df['c_name'] = df['name'].map(dic)
    map当做一种运算工具，至于执行何种运算，是由map函数的参数决定的（参数：lambda，函数）
    • 使用自定义函数
    #超过3000部分的钱缴纳50%的税
    
def after_sal(s):
    
    if s <= 3000:
    
        return s
    
    else:
    
        return s - (s-3000)*0.5

df['after_sal'] = df['salary'].map(after_sal)

    注意：并不是任何形式的函数都可以作为map的参数。只有当一个函数具有一个参数且有返回值，那么该函数才可以作为map的参数

3.使用聚合操作

  • 使用聚合操作 对数据异常值检测和过滤

    使用df.std()函数可以求得DataFrame对象每一列的标准差

    • 创建一个1000行3列的df 范围（0-1），求其每一列的标准差
    df = DataFrame(np.random.random(size=(1000,3)),columns=['A','B','C'])
    
df
    # 对df应用筛选条件,去除标准差太大的数据:假设过滤条件为 C列数据大于两倍的C列标准差
    
# 获取  C  列数据标准差
    
c_st = df['C'].std()
    
# 获取所有 大于 C 列数据 两倍的标准差的 数据
    
indexs = df.loc[df['C'] > c_st * 2].index
    
# 删除操作
    
df.drop(labels=indexs,axis=0)

4. 排序

  • 使用.take()函数排序

    • take()函数接受一个索引列表，用数字表示,使得df根据列表中索引的顺序进行排序
    • eg:df.take([1,3,4,2,5])

    np.random.permutation(x)可以生成x个从0-(x-1)的随机数列

    # 普通 排列  指定 隐式索引  对 A B C 排列
    
df.take([2,0,1],axis=1)
    • 随机抽样

      当DataFrame规模足够大时，直接使用np.random.permutation(x)函数，就配合take()函数实现随机抽样

    df_ = df.take(np.random.permutation(1000),axis=0).take(np.random.permutation(3),axis=1)
    
df_[0:100]

5. 数据分类处理【重点】

  • 数据聚合是数据处理的最后一步，通常是要使每一个数组生成一个单一的数值。

    数据分类处理：

    • 分组：先把数据分为几组
    • 用函数处理：为不同组的数据应用不同的函数以转换数据
    • 合并：把不同组得到的结果合并起来
    数据分类处理的核心：
    • groupby()函数
    • groups属性查看分组情况
    • eg: df.groupby(by='item').groups

1) 分组 groupby()

  • 使用groupby实现分组
# 数据

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(by='item',axis=0)
  • 使用groups查看分组情况
#该函数可以进行数据的分组，但是不显示分组情况

df.groupby(by='item',axis=0).groups

  • 分组后的聚合操作：分组后的成员中可以被进行运算的值会进行运算，不能被运算的值不进行运算

  • 平均值 mean()

#给df创建一个新列，内容为各个水果的平均价格

# df.groupby(by='item').mean()

# df.groupby(by='item').mean()['price']

mean_price_s = df.groupby(by='item')['price'].mean()

dic = mean_price_s.to_dict()

# 使用映射添加到原表中

df['mean_price'] = df['item'].map(dic)

# 计算出苹果的平均价格

df.groupby(by='item')['price'].mean()['Apple']

6. 高级数据聚合

  • 使用groupby分组后，也可以使用transform和apply提供自定义函数实现更多的运算

    • df.groupby('item')['price'].sum() <==> df.groupby('item')['price'].apply(sum)
    • transform和apply都会进行运算，在transform或者apply中传入函数即可
    • transform和apply也可以传入一个lambda表达式
def fun(s):

    sum = 0

    for i in s:

        sum+=i

    return sum/s.size

#使用apply函数求出水果的平均价格

# 不显示重复行

df.groupby(by='item')['price'].apply(fun)

#使用transform函数求出水果的平均价格

# 显示出每行的 平均值

df.groupby(by='item')['price'].transform(fun)

相关文章