【数据分析】Pandas_DataFrame读写详解：案例解析（第24天）

系列文章目录

一、读写文件数据
二、df查询数据操作
三、df增加列操作
四、df删除行列操作
五、df数据去重操作
六、df数据修改操作

文章目录

系列文章目录
前言
- 一、读写文件数据
- - 1.1 读写excel文件
  - 1.2 读写csv文件
  - 1.3 读写mysql数据库
- 二、df查询数据操作
- - 2.1 查询df子集基本方法
  - 2.2 loc/iloc获取子集
  - - 2.2.1 loc/iloc基本介绍
    - 2.2.2 loc属性获取子集
    - 2.2.3 iloc属性获取子集
  - 2.3 query函数获取子集
  - 2.4 isin函数获取子集
- 三、df增加列操作
- 四、df删除行列操作
- 五、df数据去重操作
- 六、df数据修改操作
- - 6.1 直接修改数据
  - 6.2 replace函数修改
  - 6.3 s对象通过apply函数执行自定义函数
  - 6.4 df对象通过apply函数执行自定义函数
  - 6.5 df对象通过applymap函数执行自定义函数

前言

本文主要详解了Pandas_DataFrame的读写。

提示：以下是本篇文章正文内容，下面案例可供参考

一、读写文件数据

可以参考pandas的官网文档 https://pandas.pydata.org/

1.1 读写excel文件

数据保存到excel文件

# 导入模块
import pandas as pd
# 构造数据集
data = [[1,'张三', '1990-10-02', 34],
        [2, '李四', '2000-03-03', 24],
        [3, '王五', '2005-12-23', 19],
        [4, '隔壁老王', '1982-11-12',42]]
df = pd.DataFrame(data=data, columns=['id', 'name', 'birthday', 'age'])
df
# 存储路径
# sheet名称
# 是否存储行索引作为一列
# 是否存储列名
df.to_excel('./output/student.xls', sheet_name='student',index=True, header=True)

读取excel文件数据

df_excel = pd.read_excel('output/student.xls')
df_excel
# 通过index_col指定某列的值作为行索引, 可以写列名或列下标值
# pd.read_excel('output/student.xls',index_col='id')
pd.read_excel('output/student.xls',index_col=0)

1.2 读写csv文件

数据保存到csv(逗号,分隔符)/tsv(制表符\t分隔符)文件中

# 参数1:存储路径
# index:是否存储行索引值
# mode:存储的方式
df.to_csv('output/student.csv', index=False, mode='w')
# 存储到tsv文件中 \t
# sep:指定列值之间的分隔符 
df.to_csv('output/student.tsv', sep='\t')

读取csv/tsv文件数据

df_csv = pd.read_csv('output/student.csv')
df_csv
# parse_dates: 将指定的列转换成日期时间类型, 可以传入列名或列下标值
# temp_df = pd.read_csv('output/student.csv', parse_dates=['birthday'])
# temp_df = pd.read_csv('output/student.csv', parse_dates=[2])
# parse_dates: 可以传入True或False, 将行索引值转换成日期时间类型, 需要和行索引值进行结合使用
temp_df = pd.read_csv('output/student.csv',index_col='birthday' ,parse_dates=True)
temp_df.info()
# 读取tsv文件数据
pd.read_csv('output/student.tsv', sep='\t', index_col=0)

1.3 读写mysql数据库

保存数据到mysql数据库

from sqlalchemy import create_engine
# 创建数据库链接对象
engine = create_engine('mysql+pymysql://root:123456@192.168.88.100:3306/BI_db')
# name:表名, 表不存在会自动创建
# con:数据库链接对象
# index:是否存储行索引
# if_exists:存储方式, append:追加写 replace:覆盖写
df.to_sql(name='student', con=engine, index=False, if_exists='append')

读取mysql数据库数据

# sql:可以读取表名, 也可以读取sql语句
# columns: 指定读取表中的字段
df_mysql = pd.read_sql(sql='student', con=engine, columns=['name', 'birthday'])
df_mysql
# 读取sql语句
pd.read_sql(sql='select * from student limit 2', con=engine)
# 只能读取sql语句
pd.read_sql_query(sql='select * from student limit 2;',con=engine)
# 只能读取表名
pd.read_sql_table(table_name='student', con=engine)

二、df查询数据操作

2.1 查询df子集基本方法

head()&tail()

import pandas as pd
# 加载数据集, 链家租房数据集
df = pd.read_csv('data/LJdata.csv')
df
df.head()
df.tail()
df.head(n=8)

获取一列或多列数据

# df[列名]或df.列名
# 获取一列数据, 返回s对象
df['价格']
type(df['价格'])
df.价格
# 获取一列数据, 返回df对象
df[['价格']]
# 获取多列数据 df[[列名1, 列名2, ...]]
# 传入列名的列表
df[['区域', '面积', '价格']]

布尔值向量获取行数据

# 布尔值s对象 df['价格']>8000
df[df['价格']>8000]
# 布尔值列表
df_head = df.head()
df_head
# 构建布尔值列表
bool_list = [True,False,True,False,True]
df_head[bool_list]
# 布尔值数组
import numpy as np
n1 = np.array([True,False,True,False,True])
n1
df_head[n1]

行索引下标切片获取行数据

# df[起始行下标值:结束行下标值:步长]  类似于字符串/列表/元组的切片操作
# 下标值(只能是整数)和索引值(整数,字符串,日期时间)不是一个东西
# 左闭右开 -> 包含起始值, 不包含结束值
temp_df = df.head(10)
temp_df
# 获取1,3,5行数据
temp_df[:5:2]
# 获取前3行数据
temp_df[:3]
# 步长为负数, 倒序获取行数据, 下标值可以为负数
temp_df[-1:-3:-1]

2.2 loc/iloc获取子集

2.2.1 loc/iloc基本介绍

loc和iloc是s/df对象的属性

loc是通过索引值(肉眼看到的值), iloc是通过索引下标值(0,1,2,3…) 获取数据

df.loc[行索引值] -> 获取行数据

df.loc[行索引值, 列名] -> 获取行列数据

df.iloc[行索引下标] -> 获取行数据

df.iloc[行索引下标, 列名下标] -> 获取行列数据

2.2.2 loc属性获取子集

# 获取一行数据 df[行索引值]
# 获取第5行数据, 返回s对象
temp_df.loc[4]
# 获取第5行数据, 返回df对象
temp_df.loc[[4]]
# 获取多行数据 df[[行索引值1, 行索引值2, ...]]
# 获取第1, 3, 5行数据
temp_df.loc[[0, 2, 4]]
# 行索引值切片获取行数据
# df.loc[起始索引值:结束索引值:步长]
# 左闭右闭 -> 包含起始值, 包含结束值
# 获取第2,3,4行数据
temp_df.loc[1:3]
# 根据索引下标值
temp_df[1:3]
# 隔一行获取一行数据
temp_df.loc[::2]
# 倒序获取子集, 起始值和结束值要反过来, 步长为负数
temp_df.loc[8:2:-1]
# 布尔值向量获取行数据 df.loc[布尔值向量]
temp_df['朝向']=='南'
temp_df.loc[temp_df['朝向']=='南']
# 布尔值向量结合列名获取行列数据 df.loc[布尔值向量, [列名1, 列名2, ...]]
temp_df.loc[temp_df['朝向']=='南', ['地址', '朝向']]
# 行索引值结合列名获取行列数据 df.loc[[行索引值1, 行索引值2,...],[列名1, 列名2, ...]]
# 获取某个值数据
temp_df.loc[0, '价格']
# 获取多行多列数据
temp_df.loc[[0, 2, 4], ['地址', '户型', '价格']]
# 行索引值切片结合列名获取行列数据 df.loc[起始索引值:结束索引值:步长, [列名1, 列名2, ...]]
temp_df.loc[:4:2, ['地址', '面积', '价格']]

2.2.3 iloc属性获取子集

# 获取一行数据 df.iloc[行下标值]
# 获取第一行数据, 返回s对象
temp_df.iloc[0]
temp_df.iloc[[0]]
# 获取最后一行数据
temp_df.iloc[-1]
# 获取多行数据 df.iloc[[行下标1, 行下标2, ...]]
temp_df.iloc[[0, 2, 4]]
# 行下标切片获取多行数据 df.iloc[起始下标值:结束下标值:步长] 等同于 df[起始下标值:结束下标值:步长]
# 左闭右开
temp_df.iloc[:5:2]
temp_df[:5:2]
# 行列下标切片获取子集 df.iloc[起始下标值:结束下标值:步长, 起始列下标值:结束列下标值:步长]
# 获取1,3,5行, 并且获取地址,面积和朝向列
temp_df.iloc[:5:2, 1:6:2]
# 行下标切片和列下标值获取子集 df.iloc[起始下标值:结束下标值:步长, [列下标1, 列下标2, ...]]
# 获取1,3,5行, 并且获取地址,面积和朝向列
temp_df.iloc[:5:2, [1, 3, 5]]
# 行列下标值获取子集 df.iloc[[行下标值1, 行下标值2, ...], [列下标值1, 列下标值2, ...]]
# 获取1,3,5行, 并且获取地址,面积和朝向列
temp_df.iloc[[0, 2, 4], [1, 3, 5]]
# 行下标值和列下标切片获取子集 df.iloc[[行下标值1, 行下标值2, ...], 起始列下标值:结束列下标值:步长]
# 获取1,3,5行, 并且获取地址,面积和朝向列
temp_df.iloc[[0,2,4],1:6:2]

2.3 query函数获取子集

# df.query(判断表达式) -> 判断表达式和df[布尔值向量]相同
# 获取区域列中为 望京租房 的数据
temp_df['区域'] == '望京租房'
temp_df[temp_df['区域'] == '望京租房']
# sql语句  select * from 表a where 区域 == "望京租房"
temp_df.query('区域 == "望京租房"')
# 判断表达式中有多个判断条件, 可以使用 and(&)或or(|)
# 查询租房区域为望京、天通苑、回龙观并且朝向为东、南的房源数据
# 链式调用, query函数返回新的df, 新的df继续可以调用query()
temp_df.query('区域 in ("望京租房", "天通苑租房", "回龙观租房")').query('朝向 in ("东", "南")')
temp_df.query('(区域 in ("望京租房", "天通苑租房", "回龙观租房")) & (朝向 in ("东", "南"))')
# temp_df.query('(区域 in ("望京租房", "天通苑租房", "回龙观租房")) and (朝向 in ("东", "南"))')

temp_df[((temp_df["区域"]=='望京租房') | (temp_df['区域']=='天通苑租房') | (temp_df['区域']=='回龙观租房')) & 
        ((temp_df['朝向']=='东') | (temp_df['朝向']=='南'))]

2.4 isin函数获取子集

# 判断s或df对象中的数据值是否在values列表中, 如果在返回True, 否则返回False -> s/df.isin(values=[值1, 值2, ...])
# 返回一个布尔值构成的df对象
temp_df.isin(values=['2室1厅','东'])
temp_df[temp_df.isin(values=['2室1厅','东'])]
# 返回布尔值构成的s对象
temp_df['区域'].isin(values=["望京租房", "天通苑租房", "回龙观租房"])
temp_df['区域'][temp_df['区域'].isin(values=["望京租房", "天通苑租房", "回龙观租房"])]
temp_df[temp_df['区域'].isin(values=["望京租房", "天通苑租房", "回龙观租房"])]
# 查询租房区域为望京、天通苑、回龙观并且朝向为东、南的房源数据
temp_df['区域'].isin(values=["望京租房", "天通苑租房", "回龙观租房"]) & temp_df['朝向'].isin(values=['东', '南'])
temp_df[(temp_df['区域'].isin(values=["望京租房", "天通苑租房", "回龙观租房"])) & (temp_df['朝向'].isin(values=['东', '南']))]

三、df增加列操作

# 导入模块
import pandas as pd
import warnings
warnings.filterwarnings('ignore')  # 忽略警告信息
# 加载数据集
df = pd.read_csv('data/LJdata.csv')
# 获取前5行数据
temp_df = df.head().copy()
temp_df
# 在df末尾增加新列数据 df['新列名'] = 常数值/列表/series对象
# 在df末尾新增一列省份列, 值都为北京 -> 常数值
temp_df['省份'] = '北京'
temp_df
# 在df末尾新增一列区县列, 值为['朝阳区', '朝阳区', '西城区', '昌平区', '朝阳区'] -> 列表
# df的行数要和新增列表中的元素个数要相等
temp_df['区县'] = ['朝阳区', '朝阳区', '西城区', '昌平区', '朝阳区']
temp_df
# 在df末尾新增一列新价格列, 在原价格上加1000 -> series对象 (s对象的运算)
temp_df['新价格'] = temp_df['价格'] + 1000
temp_df
# 通过insert()在指定位置新增一列
# df.insert(loc=列下标值, column=新列名, value=常数值/列表/s对象)
# 在区域和地址列之间新增一列国家列, 值都为中国
temp_df.insert(loc=1, column='国家', value='中国')
temp_df
# 在价格新增一列价格2列, 值为 价格和新价格的求和
temp_df.insert(loc=6, column='价格2', value=temp_df['价格'] + temp_df['新价格'])
temp_df

四、df删除行列操作

# df.drop(labels=, axis=, inplace=)
# labels: 根据 行索引值或列名 进行删除
# axis: 按行或列删除, 默认是按行 0或index; 按列 1或columns
# inplace: 是否在源数据集上删除, 默认是False, True
# 删除第1, 3, 5行数据, 默认删除行数据
drop_df = temp_df.drop(labels=[0, 2, 4])
drop_df
# 删除价格2列数据
temp_df.drop(labels='价格2', axis='columns')
# 在源df上删除价格2列数据
temp_df.drop(labels='价格2', axis=1, inplace=True)
# 保留地址, 户型, 面积三列数据
temp_df[['地址', '户型', '面积']]

五、df数据去重操作

# s/df.drop_duplicates(subset=,keep=,inplace=)
# subset: 默认不写, 所有列值都相同的行数据; 可以通过列名列表指定对应列相同的行数据
# keep: 默认保留第一条数据 first, 保留最后一条数据 last, 删除所有重复数据 false
# inplace: 是否在源数据集上修改
# 根据所有列相同的行数据进行去重
temp_df.drop_duplicates()
# 根据户型和朝向列判断是否有重复行数据
# 默认保留第一条重复数据
temp_df.drop_duplicates(subset=['户型', '朝向'])
# 保留最后一条重复数据
temp_df.drop_duplicates(subset=['户型', '朝向'], keep='last')
# 删除重复的数据
temp_df['朝向'].drop_duplicates(keep=False)
# df对象没有unique操作
temp_df['朝向'].unique() # 返回数组
temp_df['朝向'].nunique()  # 去重计数 count(distinct)

六、df数据修改操作

6.1 直接修改数据

# 直接修改数据值 df[列名] = 新值 -> 常数值/列表/s对象
temp_df = df.head().copy()
temp_df
# 修改看房人数列, 改为 100
temp_df['看房人数'] = 100
temp_df
# 修改面积列, 改为 [70, 99, 90, 120, 80] -> df的行数和列表中的元素个数相同
temp_df['面积'] = [70, 99, 90, 120, 80]
temp_df
# 修改价格列, 价格列+1000
temp_df['价格'] = temp_df['价格'] + 1000
temp_df
# 获取s对象
temp_s = temp_df['价格']
temp_s# s[索引下标值] = 新值
temp_s[2] = 20000
temp_s

6.2 replace函数修改

# 通过replace函数实现修改
# s/df.replace(to_replace=, value=, inplace=)
# to_replace:需要替换的值
# value:替换后的值
# 将2室1厅替换成3室2厅
temp_df.replace(to_replace='2室1厅', value='3室2厅', inplace=True)
temp_df
temp_df.replace(to_replace=[20000, 100], value=999)
# 对s对象实现替换操作
temp_df['朝向'].replace(to_replace='东南', value='北')

6.3 s对象通过apply函数执行自定义函数

temp_df = df.head().copy()
temp_df
# 编写自定义函数 根据区域列的值判断是否为天通苑租房, 是返回昌平区, 否返回其他区
# 最少接受一个形参, 形参对应的实参值是s对象中每个值
def func1(x):
    print('x的值是->',x)
    if x == '天通苑租房':
        return '昌平区'
    else:
        return '其他区'
# 通过apply函数调用自定义函数 s/df.apply(自定义函数名)
temp_df['区域'] = temp_df['区域'].apply(func1)
temp_df
temp_df = df.head().copy()
temp_df
# 定义自定义函数式, 可以定义多个形参
def func2(x, arg1, arg2):
#     print('x的值是->', x)
#     print('arg1的值是->', arg1)
#     print('arg2的值是->', arg2)
    if x == '天通苑租房':
        return arg1
    else:
        return arg2
# s对象调用自定义函数
# args=(arg1, arg2)
temp_df['区域'].apply(func2, args=('昌平区', '其他区'))
# 形参名=实参值
temp_df['区域'].apply(func2, arg1='昌平区', arg2='其他区')

6.4 df对象通过apply函数执行自定义函数

按列计算

# df对象调用apply函数来执行自定义函数
# 自定义函数接收的是df中一列或一行数据
# 定义自定义函数
def func3(x, arg1):
    # x是df中一行或一列数据 -> s对象
    print('x的值是->', x)
    print('arg1的值是->', arg1)
    print(x.__dict__)
    # _name:获取当前列的列名, 或者是获取当前行的行索引值
    if x._name == '价格':
        # s对象和数值型变量计算
        return x + arg1
    else:
        return x
    
# 默认是按列进行处理 axis=0
# temp_df.apply(func3, args=(1000,), axis=0)
temp_df.apply(func3, arg1 = 2000, axis=0)

按行计算

# 如果区域列的值为望京租房, 修改价格列的值为arg1
# 自定义函数
def func4(x, arg1):
    print('x的值是->', x)
    # 根据s对象的索引值获取数据值 s[索引值]
    if x['区域']== '望京租房':
        x['价格'] = arg1
        return x
    else:
        return x

# 按行进行处理, axis=1
temp_df.apply(func4, arg1=3000, axis=1)

6.5 df对象通过applymap函数执行自定义函数

# df对象调用applymap函数来执行自定义函数
# 自定义函数中接收的是df中每个值, 不再是一列或一行数据
# 自定义函数
def func5(x):
    print('x的值是->', x)
    if x in ['燕莎租房','望京租房','团结湖租房']:
        return '朝阳区'
    elif x == '天通苑租房':
        return '昌平区'
    elif x == '团结湖租房':
        return '西城区'
    else:
        return x
    
temp_df.applymap(func5)