【日常点滴012】python中pandas入门操作方法整理
2024-05-07 08:35:16
配套数据文件
链接：https://pan.baidu.com/s/1ngzaZygHOIQuNPHtYjpFfA
提取码：lang
pandas 入门
- 1 series
- 1.1 series 创建
- 1.2 获取series数据的值
- 2 DataFrame
- 2.1 创建
- 2.1.1 通过二维列表创建
- 2.1.2 用字典格式创建
- 2.1.3 列表嵌套字典格式创建
- 2.2 获取datafram相关数据
- 2.2.1 loc
- 2.2.2 iloc
- 2.3 数据文件写入和读取
- 2.3.1 写入csv文件
- 2.3.2 读取csv文件
- 2.3.3 读取json数据
- 2.1 创建
- 3 重复数据、空值的处理
- 3.1 空值删除
- 3.1.1 dropna()
- 3.2 空值填充
- 3.2.1 fillna()
- 3.3 删除数据
- 3.3.1 drop()
- 3.4 数据去重
- 3.4.1 duplicated()
- 3.4.2 drop_duplicates()
- 3.1 空值删除
- 4 数据的合并、筛选、排序
- 4.1 合并
- 4.1.1 concat()
- 4.1.1.1 outer()
- 4.1.1.2 inner()
- 4.1.2 merge()
- 4.1.2.1 inner()
- 4.1.2.2 outer()
- 4.1.2.3 left()
- 4.1.2.4 right()
- 4.1.3 合并方法总结：
- 4.1.1 concat()
- 4.2 筛选
- 4.2.1 数据预览
- 4.2.2 开始筛选
- 4.2.2.1 比较运算
- 4.2.2.2 逻辑运算
- 4.3 排序
- 4.3.1 sort_index()
- 4.3.2 sort_values()
- 4.1 合并
- 5 分组和统计
- 5.1 分组
- 5.1.1 groupby('列名')
- 5.1.2 groups.size()
- 5.1.3 groups.get_group()
- 5.1.4 groups.groups
- 5.1.5 多列分组和取值
- 5.2 常用统计函数：mean()、max()、min()
- 5.3 聚合统计agg([])
- 5.4 自定义统计方式
- 5.1 分组
- 6 多层索引操作
- 6.1 创建
- 6.1.1 from_product()
- 6.2 取值
- 6.2.1 loc取值
- 6.2.2 iloc取值
- 6.3 排序
- 6.1 创建
- 7 更改
- 7.1 类型更改
- 7.1.1 to_numeric() 将 字符串类型 转 数字类型
- 7.1.2 to_datetime() 将 字符串类型 转Timestamp类型
- 7.1.3 to_pydatetime() 将 Timestamp类型 转datetime类型
- 7.1.4 astype 强制转换
- 7.2 数据更改
- 7.2.1 案例1
- 7.2.2 案例2
- 7.1 类型更改
- 8 时间序列
- 8.1 datetime库
- 8.1.1 创建日期
- 8.1.2 创建时间
- 8.1.3 创建日期 + 时间
- 8.1.4 时间格式化
- 8.2 pandas的时间设置
- 8.3 pandas生成时间索引的series序列
- 8.4 pandas获取时间索引数据
- 8.1 datetime库
- 9 pandas设置小技巧
- 9.1 设置数据对齐显示
- 10 关于numpy小应用
- 10.1 np.arange() 生成序列数
- 10.2 np.random() 生成随机序列数
- 10.3 多维数组创建 和取值
- 10.3.1 创建全部以0来填充的数组
- 10.3.2 创建全部以1来填充的数组
- 10.3.3 创建指定数据的多维数组
- 10.3.4 取值
- 10.4 从已有的数组创建数组
开讲之前先简单铺垫一下：
series和dataframe是pandas的两种基本数据类型
series就是一列（带索引的）数据，多个series构成dataframe
series
series 创建
Series 由索引（index）和列组成，函数如下：
pandas.Series( data, index, dtype, name, copy)
参数说明：
data：一组数据(ndarray 类型)。
index：数据索引标签，如果不指定，默认从 0 开始。
dtype：数据类型，默认会自己判断。
name：设置名称。
copy：拷贝数据，默认为 False。
# 创建Series，使用默认索引
from pandas import Series,DataFrameser = Series(data=['杨老师',"浪淘三千",183,'python讲师'])
print(ser)# 查看索引
print('-------查看索引-----------')
print(ser.index)
0 杨老师
1 浪淘三千
2 183
3 python讲师
dtype: object
-------查看索引-----------
RangeIndex(start=0, stop=4, step=1)
# 创建Series，使用字典的键作为索引
from pandas import Series,DataFrameser = Series(data={"称呼":"杨老师","昵称":"浪淘三千","身高":183,"职业":"python讲师"})
print(ser)
# 查看索引
print('-------查看索引-- 注意这里和上面不一样---------')
print(ser.index)
称呼 杨老师
昵称 浪淘三千
身高 183
职业 python讲师
dtype: object
-------查看索引-- 注意这里和上面不一样---------
Index(['称呼', '昵称', '身高', '职业'], dtype='object')
# 创建Series，使用字典的键作为索引
from pandas import Series,DataFrameser3 = Series({"称呼":"杨老师","昵称":"浪淘三千","身高":183,"职业":"python讲师"})
print(ser3)
# 查看索引
print('-------查看索引-----------')
print(ser3.index)
称呼 杨老师
昵称 浪淘三千
身高 183
职业 python讲师
dtype: object
-------查看索引-----------
Index(['称呼', '昵称', '身高', '职业'], dtype='object')
获取series数据的值
我们可以通过values、index、items等Series的属性来获取各部分的全部数据。
values、index、items返回的对象分别是numpy.ndarray、Index、Zip类型的数据，为了方便我们使用和观察数据，可以使用series.index.tolist(),ser.values.tolist(),和list(series.items())方法转化成List类型。
# 获取series的索引 和 值
from pandas import Series,DataFrameser = Series(data={"称呼":"杨老师","昵称":"浪淘三千","身高":183,"职业":"python讲师"})
print(ser)# 获取数据的值
print(ser.values,type(ser.values))
print(ser.values.tolist(),type(ser.values.tolist()))
print(list(ser.values),type(list(ser.values)))
# 获取索引的值
print(ser.index,type(ser.index))
print(ser.index.tolist())# 获取每对索引和值
print(list(ser.items()),type(ser.items()))
称呼 杨老师
昵称 浪淘三千
身高 183
职业 python讲师
dtype: object
['杨老师' '浪淘三千' 183 'python讲师'] <class 'numpy.ndarray'>
['杨老师', '浪淘三千', 183, 'python讲师'] <class 'list'>
['杨老师', '浪淘三千', 183, 'python讲师'] <class 'list'>
Index(['称呼', '昵称', '身高', '职业'], dtype='object') <class 'pandas.core.indexes.base.Index'>
['称呼', '昵称', '身高', '职业']
[('称呼', '杨老师'), ('昵称', '浪淘三千'), ('身高', 183), ('职业', 'python讲师')] <class 'zip'>
通过索引下标（标签索引） 和 位置下标（位置索引）都可以获取series种的数据，获取连续数据可以用切片。不连续数据需要用嵌套列表的形式
看下面例子
# 通过索引下标（标签索引） 和 位置下标（位置索引） 获取数据 位置下标是默认就会有的from pandas import Series,DataFrameseries = Series(data={"称呼":"杨老师","昵称":"浪淘三千","身高":183,"职业":"python讲师"})# 使用索引下标（标签索引）获取单个数据
print('\n使用索引下标（标签索引）获取单个数据\n',series['称呼'])
# 使用位置下标获取单个数据
print('\n使用位置下标（位置索引）获取单个数据\n',series[1])# 使用索引下标获取多个不连续的数据
print('使用索引下标获取多个不连续的数据\n',series[['职业','昵称']])
print('\n索引下标切片获取连续数据\n',series['昵称':'职业'])print('----下面通过位置下标取切片获取连续数据')
# 使用位置下标切片获取连续的数据 取前不取后，终点索引超出范围时，默认全部取到
print('\n---位置下标取切片获取连续数据\n',series[1:3])
print('\n---位置下标取切片获取连续数据\n',series[1:6])print('\n---位置下标取切片获取bbb不不uuu连续数据\n',series[[1,3]])
使用索引下标（标签索引）获取单个数据杨老师使用位置下标（位置索引）获取单个数据浪淘三千
使用索引下标获取多个不连续的数据职业 python讲师
昵称 浪淘三千
dtype: object索引下标切片获取连续数据昵称 浪淘三千
身高 183
职业 python讲师
dtype: object
----下面通过位置下标取切片获取连续数据---位置下标取切片获取连续数据昵称 浪淘三千
身高 183
dtype: object---位置下标取切片获取连续数据昵称 浪淘三千
身高 183
职业 python讲师
dtype: object---位置下标取切片获取bbb不不uuu连续数据昵称 浪淘三千
职业 python讲师
dtype: object
DataFrame
DataFrame（数据表）是一种 2 维数据结构，数据以表格的形式存储，分成若干行和列。语法如下
pandas.DataFrame( data, index, columns, dtype, copy)
参数说明：
data：一组数据(ndarray、series, map, lists, dict 等类型)。
index：索引值，或者可以称为行标签。
columns：列标签，默认为 RangeIndex (0, 1, 2, …, n) 。
dtype：数据类型。
copy：拷贝数据，默认为 False。
创建
通过二维列表创建
# 通过二维列表创建选手信息表from pandas import Series,DataFramelol_list = [['上单','TheShy',20],['打野','小天',19],['中单','Faker',23],['ADC','Uzi',22],['辅助','Ming',21]]
# 创建dataframe
df = DataFrame(data=lol_list)
print(df)
0 1 2
0 上单 TheShy 20
1 打野 小天 19
2 中单 Faker 23
3 ADC Uzi 22
4 辅助 Ming 21
用字典格式创建
# 用字典格式创建 字典的值 应该拥有相同的长度
from pandas import Series,DataFrame
import pandas as pd# 设置数据对齐显示
pd.set_option('display.unicode.ambiguous_as_wide', True)
pd.set_option('display.unicode.east_asian_width', True)
# 设置打印宽度 设置后可以避免 内容少但是仍换行显示的情况
# pd.set_option('display.width', 180)
dic={'位置': ['上单', '打野', '中单', 'ADC','辅助'],'ID号': ['TheShy', '小天', 'Faker', 'Uzi', 'Ming'],'year': [20, 19, 23, 22,21]}
df=pd.DataFrame(dic)
print(df)
位置 ID号 year
0 上单 TheShy 20
1 打野 小天 19
2 中单 Faker 23
3 ADC Uzi 22
4 辅助 Ming 21
列表嵌套字典格式创建
# 用字典格式创建2 推荐
# 注意嵌套字典的键保持一致即可
from pandas import Series,DataFrame# 创建列表 然后用同样的字典结构存储选手信息
lol_list = [{'位置':'上单','ID号':'TheShy','年龄':20},{'位置':'打野','ID号':'小天','年龄':19},{'位置':'中单','ID号':'Faker','年龄':23},{'位置':'ADC', 'ID号':'Uzi','年龄':22},{'位置':'辅助','ID号':'Ming','年龄':21}]# 创建dataframe
df = DataFrame(data=lol_list)
print(df)
位置 ID号 年龄
0 上单 TheShy 20
1 打野 小天 19
2 中单 Faker 23
3 ADC Uzi 22
4 辅助 Ming 21
获取datafram相关数据
# 用字典格式创建2 推荐
from pandas import Series,DataFramepd.set_option('display.unicode.ambiguous_as_wide', True)
pd.set_option('display.unicode.east_asian_width', True)
# pd.set_option('display.width', 180) # 设置打印宽度(设置后可以避免 内容少但是仍换行显示的情况）# 创建列表 然后用同样的字典结构存储选手信息
lol_list = [{'位置':'上单','ID号':'清清','年龄':21},{'位置':'打野','ID号':'无畏','年龄':19},{'位置':'中单','ID号':'笑影','年龄':23},{'位置':'ADC', 'ID号':'一诺','年龄':19},{'位置':'辅助','ID号':'爱思','年龄':21},{'位置':'教练','ID号':'lang','年龄':25}]# 创建dataframe 这里手动设置了标签索引
df = DataFrame(data=lol_list,index=['001','002','003','004','005','006'])
print(df)
位置 ID号 年龄
001 上单 清清 21
002 打野 无畏 19
003 中单 笑影 23
004 ADC 一诺 19
005 辅助 爱思 21
006 教练 lang 25
# 获取数据的维度
print('df.ndim获取数据的维度',df.ndim)
df.ndim获取数据的维度 2
# 获取行数和列数
print('df.shape获取行数和列数',df.shape)
df.shape获取行数和列数 (6, 3)
# 获取行索引 有手动设置的话 可以获取行标签索引，没有设置的话 是获取位置索引
print('df.index.tolist()获取行索引',df.index.tolist())
df.index.tolist()获取行索引 ['001', '002', '003', '004', '005', '006']
# 获取列索引
print('df.columns.tolist()获取列索引',df.columns.tolist())
df.columns.tolist()获取列索引 ['位置', 'ID号', '年龄']
# 获取前两条数据
head2 = df.head(2)
print('\ndf.head(2)带参数获取前2条\n',head2)
# 不带参数默认获取前5条数据
head5 = df.head()
print('\n----df.head()不带参数默认获取前5条数据\n',head5)df.head(2)带参数获取前2条位置 ID号 年龄
001 上单 清清 21
002 打野 无畏 19----df.head()不带参数默认获取前5条数据位置 ID号 年龄
001 上单 清清 21
002 打野 无畏 19
003 中单 笑影 23
004 ADC 一诺 19
005 辅助 爱思 21
# 获取后10条 不够的话全部获取
df.tail(10)
| 位置 | ID号 | 年龄 | |
|---|---|---|---|
| 001 | 上单 | 清清 | 21 |
| 002 | 打野 | 无畏 | 19 |
| 003 | 中单 | 笑影 | 23 |
| 004 | ADC | 一诺 | 19 |
| 005 | 辅助 | 爱思 | 21 |
| 006 | 教练 | lang | 25 |
# 同样不传参数是默认获取后5条数据
df.tail()
| 位置 | ID号 | 年龄 | |
|---|---|---|---|
| 002 | 打野 | 无畏 | 19 |
| 003 | 中单 | 笑影 | 23 |
| 004 | ADC | 一诺 | 19 |
| 005 | 辅助 | 爱思 | 21 |
| 006 | 教练 | lang | 25 |
# df不支持直接通过标签索引获取行数据 但是可以用位置索引来获取
# 通过位置索引切片获取1行
print('\ndf[0:1]通过位置索引切片获取1行\n',df[0:1])
print('\n取到切片后再递进取位置列值\n',df[0:1]['位置'])
df[0:1]通过位置索引切片获取1行位置 ID号 年龄
001 上单 清清 21取到切片后再递进取位置列值001 上单
Name: 位置, dtype: object
# 通过位置索引切片获取多行 遵循切片规则
print('\ndf[1:3]通过位置索引切片获取多行\n',df[1:3])# 获取多行里面的某1列 直接递进取列值即可
print("\ndf[1:3]['ID号']获取多行里面的某1列\n",df[1:3]['ID号'])
df[1:3]通过位置索引切片获取多行位置 ID号 年龄
002 打野 无畏 19
003 中单 笑影 23df[1:3]['ID号']获取多行里面的某1列002 无畏
003 笑影
Name: ID号, dtype: object
# 获取多行里面的某几列 注意，多列要《新》写在一个列表里
print("\ndf[1:3][['位置','ID号']]获取多行里面的某几列\n",df[1:3][['位置','ID号']])
df[1:3][['位置','ID号']]获取多行里面的某几列位置 ID号
002 打野 无畏
003 中单 笑影
# 获取DataFrame的列
print("\ndf['位置']获取DataFrame的列\n",df['ID号'])
df['位置']获取DataFrame的列001 清清
002 无畏
003 笑影
004 一诺
005 爱思
006 lang
Name: ID号, dtype: object
# 获取DataFrame的多个列 依旧写在嵌套的列表里
print("\ndf[['位置','ID号']]获取DataFrame的多个列\n",df[['位置','ID号']])
df[['位置','ID号']]获取DataFrame的多个列位置 ID号
001 上单 清清
002 打野 无畏
003 中单 笑影
004 ADC 一诺
005 辅助 爱思
006 教练 lang
# 获取DataFrame的多个列的多个行 递进取值即可 也就是说 可先取到行再递进取列 也可以取到列再递进取行
print("\ndf[['位置','ID号']][1:3]获取DataFrame的多个列的多个行\n",df[['位置','ID号']][1:3])
df[['位置','ID号']][1:3]获取DataFrame的多个列的多个行位置 ID号
002 打野 无畏
003 中单 笑影
–下面是loc 和 iloc 的使用
loc使用标签索引
iloc使用位置索引 -=
loc
# 获取某一行的数据
print("\ndf.loc['标签索引']获取某一行的数据\n",df.loc['001'])
df.loc['标签索引']获取某一行的数据位置 上单
ID号 清清
年龄 21
Name: 001, dtype: object
# 获取某一行某一列的数据
print("\ndf.loc['001','位置']获取某一行某一列的数据\n",df.loc['001','位置'])
df.loc['001','位置']获取某一行某一列的数据上单
# 某一行多列的数据
print("\ndf.loc['001',['位置','ID号']]某一行多列的数据\n",df.loc['001',['位置','ID号']])
df.loc['001',['位置','ID号']]某一行多列的数据位置 上单
ID号 清清
Name: 001, dtype: object
# 一行所有列
print("\ndf.loc['001',:]\n",df.loc['001',:])
df.loc['001',:]位置 上单
ID号 清清
年龄 21
Name: 001, dtype: object
# 选择不连续的多行多列
print("\ndf.loc[['001','003'],['位置','ID号']]选择间隔的多行多列\n",df.loc[['001','003'],['位置','ID号']])
df.loc[['001','003'],['位置','ID号']]选择间隔的多行多列位置 ID号
001 上单 清清
003 中单 笑影
# 选择连续的多行和连续的多列
print("\ndf.loc['001':'003','位置':'ID号']选择连续的多行和间隔的多列\n",df.loc['001':'003','位置':'ID号'])
df.loc['001':'003','位置':'ID号']选择连续的多行和间隔的多列位置 ID号
001 上单 清清
002 打野 无畏
003 中单 笑影
iloc
df
| 位置 | ID号 | 年龄 | |
|---|---|---|---|
| 001 | 上单 | 清清 | 21 |
| 002 | 打野 | 无畏 | 19 |
| 003 | 中单 | 笑影 | 23 |
| 004 | ADC | 一诺 | 19 |
| 005 | 辅助 | 爱思 | 21 |
| 006 | 教练 | lang | 25 |
# 取一行
print("\ndf.iloc[1]取一行\n",df.iloc[1])
df.iloc[1]取一行位置 打野
ID号 无畏
年龄 19
Name: 002, dtype: object
# 取连续多行
print("\ndf.iloc[0:2]取连续多行\n",df.iloc[0:2])
df.iloc[0:2]取连续多行位置 ID号 年龄
001 上单 清清 21
002 打野 无畏 19
# 取指定的多行
print("\ndf.iloc[[0,2],:]取间断的多行\n",df.iloc[[0,2]])
df.iloc[[0,2],:]取间断的多行位置 ID号 年龄
001 上单 清清 21
003 中单 笑影 23
列在中括号里，排第二个参数的位置，跟之前的行参数用逗号隔开
# 取某一列
print("\ndf.iloc[:,1]取某一列\n",df.iloc[:,1])
df.iloc[:,1]取某一列001 清清
002 无畏
003 笑影
004 一诺
005 爱思
006 lang
Name: ID号, dtype: object
# 取某行列交叉形成的一个值
print("\ndf.iloc[1,0]取某行列交叉形成的一个值\n",df.iloc[1,0])
df.iloc[1,0]取某行列交叉形成的一个值打野
# 取多行 多列交叉形成的多个值
print("\ndf.iloc[1,0]取某行列交叉形成的一个值\n",df.iloc[1:3,0:2])
df.iloc[1,0]取某行列交叉形成的一个值位置 ID号
002 打野 无畏
003 中单 笑影
# 逐行获取数据 iterrows()
print("\ndf.iterrows()逐行获取数据----=-=-=-=-=-==----\n")
for index,row_data in df.iterrows():print(index,'\n',row_data)
df.iterrows()逐行获取数据----=-=-=-=-=-==----001 位置 上单
ID号 清清
年龄 21
Name: 001, dtype: object
002 位置 打野
ID号 无畏
年龄 19
Name: 002, dtype: object
003 位置 中单
ID号 笑影
年龄 23
Name: 003, dtype: object
004 位置 ADC
ID号 一诺
年龄 19
Name: 004, dtype: object
005 位置 辅助
ID号 爱思
年龄 21
Name: 005, dtype: object
006 位置 教练
ID号 lang
年龄 25
Name: 006, dtype: object
# 逐列获取数据 iteritems()
print("\ndf.iteritems()逐列获取数据------=-=-=-=----=----\n")
for column_index,column_data in df.iteritems():print(column_index,'\n',column_data)
df.iteritems()逐列获取数据------=-=-=-=----=----位置 001 上单
002 打野
003 中单
004 ADC
005 辅助
006 教练
Name: 位置, dtype: object
ID号 001 清清
002 无畏
003 笑影
004 一诺
005 爱思
006 lang
Name: ID号, dtype: object
年龄 001 21
002 19
003 23
004 19
005 21
006 25
Name: 年龄, dtype: int64
数据文件写入和读取
写入csv文件
df.to_csv(path_or_buf=’./People_Information.csv’,index=False,encoding=‘utf_8_sig’)
path_or_buf为写入文本文件的路径
在to_csv方法中 将参数index设置为False就可以不存储DataFrame的行索引信息。
# 用字典格式创建 推荐 from pandas import Series,DataFrame# 创建列表 然后用同样的字典结构存储选手信息
lol_list = [{'位置':'上单','ID号':'清清','年龄':21},{'位置':'打野','ID号':'无畏','年龄':19},{'位置':'中单','ID号':'笑影','年龄':23},{'位置':'ADC', 'ID号':'一诺','年龄':19},{'位置':'辅助','ID号':'爱思','年龄':21},{'位置':'教练','ID号':'lang','年龄':25}]# 创建dataframe 这里手动设置了标签索引
df = DataFrame(data=lol_list,index=['001','002','003','004','005','006'])# 写入csv，path_or_buf为写入文本文件 windows office excel中显示乱码
df.to_csv(path_or_buf='LOL风云人物utf-8.csv', encoding='utf-8')# 写入csv，path_or_buf为写入文本文件 windows office excel中 正常能中文显示
df.to_csv(path_or_buf='LOL风云人物utf-8-sig.csv', encoding='utf-8-sig')# 写入csv，path_or_buf为写入文本文件 windows office excel中 正常能中文显示
df.to_csv(path_or_buf='LOL风云人物gbk.csv', encoding='gbk')# 以上乱码文件 ，只是在office中乱码。用WPS打开都是正常显示
读取csv文件
read_csv()读取csv文件，read_excel()读取Excel文件,read_json()读取json文件数据，路径可以是URL链接
读取出来的数据是DataFrame类型，默认会将文件中的第一行作为数据的列索引
一个Excel文件可以创建多个表，然后在不同的表中存储不同数据。但是要注意csv文件不存在多个sheet的问题。
参数
skiprows=None 设置跳过开头的几行
skipfooter=0 设置跳过结尾的几行
import pandas as pd
pd.set_option('display.unicode.ambiguous_as_wide', True)
pd.set_option('display.unicode.east_asian_width', True)
# pd.set_option('display.width', 180) # 设置打印宽度(设置后可以避免 内容少但是仍换行显示的情况)df = pd.read_csv('LOL风云人物utf-8.csv')
print(df)print()
print(df.shape)
Unnamed: 0 位置 ID号 年龄
0 1 上单 清清 21
1 2 打野 无畏 19
2 3 中单 笑影 23
3 4 ADC 一诺 19
4 5 辅助 爱思 21
5 6 教练 lang 25(6, 4)
读取json数据
to_string() 用于返回 字符串类型的json数据。
import pandas as pd# 设置打印内容对齐显示
pd.set_option('display.unicode.ambiguous_as_wide', True)
pd.set_option('display.unicode.east_asian_width', True)
# pd.set_option('display.width', 180) # 设置打印宽度(设置后可以避免 内容少但是仍换行显示的情况)df = pd.read_json('hero.json')
print(df,'\n',type(df))print(df.to_string(),'\n',type(df.to_string()))
id name skill likes
0 A001 后羿 射箭 打猎
1 A002 泰罗 变成光 打怪兽
2 A003 孙悟空 72变 打抱不平 <class 'pandas.core.frame.DataFrame'>id name skill likes
0 A001 后羿 射箭 打猎
1 A002 泰罗 变成光 打怪兽
2 A003 孙悟空 72变 打抱不平 <class 'str'>
重复数据、空值的处理
如果文件的单元格中没有值时，在使用pandas读取后就会用NaN表示，也就是我们常说的空值。
空值删除
dropna()
dropna()是删除空值数据的方法，默认将只要含有NaN的整行数据删掉 通过参数设置也可以删除整列
DataFrame.dropna(axis=0, how=‘any’, subset=None, inplace=False)
参数说明：
axis：默认为 0，表示剔除行，如果设置参数 axis＝1 表示去掉整列。
how：默认为 ‘any’ 如果一行（或一列）里任何一个数据有出现 NA 就去掉整行，如果设置 how=‘all’ 一行（或列）都是 NA 才去掉这整行。
subset：设置想要检查的列。如果是多个列，可以使用包含列名的 列表 作为参数。（目前还能用，以后也可以用布尔索引进行这样的操作）
inplace：如果设置 True，将计算得到的值直接覆盖之前的值并返回 None，修改的是源数据。
import pandas as pd
df_csv = pd.read_csv('property-data.csv')
df_csv
| PID | ST_NUM | ST_NAME | OWN_OCCUPIED | NUM_BEDROOMS | NUM_BATH | SQ_FT | |
|---|---|---|---|---|---|---|---|
| 0 | 100001000.0 | 104.0 | PUTNAM | Y | 3 | 1 | 1000 |
| 1 | 100002000.0 | 197.0 | LEXINGTON | N | 3 | 1.5 | -- |
| 2 | 100003000.0 | NaN | LEXINGTON | N | NaN | 1 | 850 |
| 3 | 100004000.0 | 201.0 | BERKELEY | 12 | 1 | NaN | 700 |
| 4 | NaN | 203.0 | BERKELEY | Y | 3 | 2 | 1600 |
| 5 | 100006000.0 | 207.0 | BERKELEY | Y | NaN | 1 | 800 |
| 6 | 100007000.0 | NaN | WASHINGTON | NaN | 2 | HURLEY | 950 |
| 7 | 100008000.0 | 213.0 | TREMONT | Y | 1 | 1 | NaN |
| 8 | 100009000.0 | 215.0 | TREMONT | Y | na | 2 | 1800 |
# 删除带空值的所有的行
df1 = df_csv.dropna()
print('以下是删除带空值的所有的行后的结果')
df1
以下是删除带空值的所有的行后的结果
| PID | ST_NUM | ST_NAME | OWN_OCCUPIED | NUM_BEDROOMS | NUM_BATH | SQ_FT | |
|---|---|---|---|---|---|---|---|
| 0 | 100001000.0 | 104.0 | PUTNAM | Y | 3 | 1 | 1000 |
| 1 | 100002000.0 | 197.0 | LEXINGTON | N | 3 | 1.5 | -- |
| 8 | 100009000.0 | 215.0 | TREMONT | Y | na | 2 | 1800 |
# 删除‘OWN_OCCUPIED’列中带空值的所有的行
df2 = df_csv.dropna(subset = ['OWN_OCCUPIED'],)
print('以下是删除‘OWN_OCCUPIED’列中带空值的所有的行后的结果 注意第6行没了')
df2
以下是删除‘OWN_OCCUPIED’列中带空值的所有的行后的结果
| PID | ST_NUM | ST_NAME | OWN_OCCUPIED | NUM_BEDROOMS | NUM_BATH | SQ_FT | |
|---|---|---|---|---|---|---|---|
| 0 | 100001000.0 | 104.0 | PUTNAM | Y | 3 | 1 | 1000 |
| 1 | 100002000.0 | 197.0 | LEXINGTON | N | 3 | 1.5 | -- |
| 2 | 100003000.0 | NaN | LEXINGTON | N | NaN | 1 | 850 |
| 3 | 100004000.0 | 201.0 | BERKELEY | 12 | 1 | NaN | 700 |
| 4 | NaN | 203.0 | BERKELEY | Y | 3 | 2 | 1600 |
| 5 | 100006000.0 | 207.0 | BERKELEY | Y | NaN | 1 | 800 |
| 7 | 100008000.0 | 213.0 | TREMONT | Y | 1 | 1 | NaN |
| 8 | 100009000.0 | 215.0 | TREMONT | Y | na | 2 | 1800 |
空值填充
fillna()
对于空值我们可以将整条数据删除，也可以使用fillna()方法对空值进行填充。
df.fillna(value=None, method=None, axis=None, inplace=False, limit=None, downcast=None, **kwargs)
注意：method参数不能与value参数同时出现。
import pandas as pd
df = pd.read_csv('property-data.csv')
df| PID | ST_NUM | ST_NAME | OWN_OCCUPIED | NUM_BEDROOMS | NUM_BATH | SQ_FT | |
|---|---|---|---|---|---|---|---|
| 0 | 100001000.0 | 104.0 | PUTNAM | Y | 3 | 1 | 1000 |
| 1 | 100002000.0 | 197.0 | LEXINGTON | N | 3 | 1.5 | -- |
| 2 | 100003000.0 | NaN | LEXINGTON | N | NaN | 1 | 850 |
| 3 | 100004000.0 | 201.0 | BERKELEY | 12 | 1 | NaN | 700 |
| 4 | NaN | 203.0 | BERKELEY | Y | 3 | 2 | 1600 |
| 5 | 100006000.0 | 207.0 | BERKELEY | Y | NaN | 1 | 800 |
| 6 | 100007000.0 | NaN | WASHINGTON | NaN | 2 | HURLEY | 950 |
| 7 | 100008000.0 | 213.0 | TREMONT | Y | 1 | 1 | NaN |
| 8 | 100009000.0 | 215.0 | TREMONT | Y | na | 2 | 1800 |
# 用常数填充fillna
print("\n用常数填充fillna\n")
df.fillna(0)
用常数填充fillna
| PID | ST_NUM | ST_NAME | OWN_OCCUPIED | NUM_BEDROOMS | NUM_BATH | SQ_FT | |
|---|---|---|---|---|---|---|---|
| 0 | 100001000.0 | 104.0 | PUTNAM | Y | 3 | 1 | 1000 |
| 1 | 100002000.0 | 197.0 | LEXINGTON | N | 3 | 1.5 | -- |
| 2 | 100003000.0 | 0.0 | LEXINGTON | N | 0 | 1 | 850 |
| 3 | 100004000.0 | 201.0 | BERKELEY | 12 | 1 | 0 | 700 |
| 4 | 0.0 | 203.0 | BERKELEY | Y | 3 | 2 | 1600 |
| 5 | 100006000.0 | 207.0 | BERKELEY | Y | 0 | 1 | 800 |
| 6 | 100007000.0 | 0.0 | WASHINGTON | 0 | 2 | HURLEY | 950 |
| 7 | 100008000.0 | 213.0 | TREMONT | Y | 1 | 1 | 0 |
| 8 | 100009000.0 | 215.0 | TREMONT | Y | na | 2 | 1800 |
# 用一列的平均值填充
print(df)
print("\n用一列的平均值填充 注意NaN的计算结果还是NaN\n")
df.fillna(df.mean())
PID ST_NUM ST_NAME OWN_OCCUPIED NUM_BEDROOMS NUM_BATH SQ_FT
0 100001000.0 104.0 PUTNAM Y 3 1 1000
1 100002000.0 197.0 LEXINGTON N 3 1.5 --
2 100003000.0 NaN LEXINGTON N NaN 1 850
3 100004000.0 201.0 BERKELEY 12 1 NaN 700
4 NaN 203.0 BERKELEY Y 3 2 1600
5 100006000.0 207.0 BERKELEY Y NaN 1 800
6 100007000.0 NaN WASHINGTON NaN 2 HURLEY 950
7 100008000.0 213.0 TREMONT Y 1 1 NaN
8 100009000.0 215.0 TREMONT Y na 2 1800用一列的平均值填充 注意NaN的计算结果还是NaN
| PID | ST_NUM | ST_NAME | OWN_OCCUPIED | NUM_BEDROOMS | NUM_BATH | SQ_FT | |
|---|---|---|---|---|---|---|---|
| 0 | 100001000.0 | 104.000000 | PUTNAM | Y | 3 | 1 | 1000 |
| 1 | 100002000.0 | 197.000000 | LEXINGTON | N | 3 | 1.5 | -- |
| 2 | 100003000.0 | 191.428571 | LEXINGTON | N | NaN | 1 | 850 |
| 3 | 100004000.0 | 201.000000 | BERKELEY | 12 | 1 | NaN | 700 |
| 4 | 100005000.0 | 203.000000 | BERKELEY | Y | 3 | 2 | 1600 |
| 5 | 100006000.0 | 207.000000 | BERKELEY | Y | NaN | 1 | 800 |
| 6 | 100007000.0 | 191.428571 | WASHINGTON | NaN | 2 | HURLEY | 950 |
| 7 | 100008000.0 | 213.000000 | TREMONT | Y | 1 | 1 | NaN |
| 8 | 100009000.0 | 215.000000 | TREMONT | Y | na | 2 | 1800 |
print("\n用上一行的值来填充\n")
# 用上一行的值来填充 参数值：ffill
df.fillna(method='ffill',axis=0)
用上一行的值来填充
| PID | ST_NUM | ST_NAME | OWN_OCCUPIED | NUM_BEDROOMS | NUM_BATH | SQ_FT | |
|---|---|---|---|---|---|---|---|
| 0 | 100001000.0 | 104.0 | PUTNAM | Y | 3 | 1 | 1000 |
| 1 | 100002000.0 | 197.0 | LEXINGTON | N | 3 | 1.5 | -- |
| 2 | 100003000.0 | 197.0 | LEXINGTON | N | 3 | 1 | 850 |
| 3 | 100004000.0 | 201.0 | BERKELEY | 12 | 1 | 1 | 700 |
| 4 | 100004000.0 | 203.0 | BERKELEY | Y | 3 | 2 | 1600 |
| 5 | 100006000.0 | 207.0 | BERKELEY | Y | 3 | 1 | 800 |
| 6 | 100007000.0 | 207.0 | WASHINGTON | Y | 2 | HURLEY | 950 |
| 7 | 100008000.0 | 213.0 | TREMONT | Y | 1 | 1 | 950 |
| 8 | 100009000.0 | 215.0 | TREMONT | Y | na | 2 | 1800 |
删除数据
drop()
DataFrame.drop(labels=None,axis=0, index=None, columns=None, inplace=False)
参数解释
labels ：就是要删除的行列的名字，用列表给定。
axis：默认为 0，表示对行进行操作，如果设置参数 axis＝1 表示对列进行操作。
index： 直接指定要删除的行。
columns： 直接指定要删除的列。
inplace=False：默认该删除操作不改变原数据，而是返回一个执行删除操作后的新dataframe。
inplace=True：则会直接在原数据上进行删除操作，删除后无法返回。
import pandas as pd
df = pd.read_csv('property-data.csv')
print(df)
PID ST_NUM ST_NAME OWN_OCCUPIED NUM_BEDROOMS NUM_BATH SQ_FT
0 100001000.0 104.0 PUTNAM Y 3 1 1000
1 100002000.0 197.0 LEXINGTON N 3 1.5 --
2 100003000.0 NaN LEXINGTON N NaN 1 850
3 100004000.0 201.0 BERKELEY 12 1 NaN 700
4 NaN 203.0 BERKELEY Y 3 2 1600
5 100006000.0 207.0 BERKELEY Y NaN 1 800
6 100007000.0 NaN WASHINGTON NaN 2 HURLEY 950
7 100008000.0 213.0 TREMONT Y 1 1 NaN
8 100009000.0 215.0 TREMONT Y na 2 1800
# 删除第0行和第1行
print('\n删除第0行和第1行\n')
df2 = df.drop(labels=[0,1],axis=0)
print(df2)
删除第0行和第1行PID ST_NUM ST_NAME OWN_OCCUPIED NUM_BEDROOMS NUM_BATH SQ_FT
2 100003000.0 NaN LEXINGTON N NaN 1 850
3 100004000.0 201.0 BERKELEY 12 1 NaN 700
4 NaN 203.0 BERKELEY Y 3 2 1600
5 100006000.0 207.0 BERKELEY Y NaN 1 800
6 100007000.0 NaN WASHINGTON NaN 2 HURLEY 950
7 100008000.0 213.0 TREMONT Y 1 1 NaN
8 100009000.0 215.0 TREMONT Y na 2 1800
# 删除列名为 NUM_BEDROOMS 的列
print('\n删除名为NUM_BEDROOMS的那一列\n')
df3 = df.drop(axis=1,columns="NUM_BEDROOMS")
print(df3)
删除名为NUM_BEDROOMS的那一列PID ST_NUM ST_NAME OWN_OCCUPIED NUM_BATH SQ_FT
0 100001000.0 104.0 PUTNAM Y 1 1000
1 100002000.0 197.0 LEXINGTON N 1.5 --
2 100003000.0 NaN LEXINGTON N 1 850
3 100004000.0 201.0 BERKELEY 12 NaN 700
4 NaN 203.0 BERKELEY Y 2 1600
5 100006000.0 207.0 BERKELEY Y 1 800
6 100007000.0 NaN WASHINGTON NaN HURLEY 950
7 100008000.0 213.0 TREMONT Y 1 NaN
8 100009000.0 215.0 TREMONT Y 2 1800
数据去重
duplicated()
利用duplicated()函数可以判断每一行是否重复，并返回布尔结果（重复则为True)
注意这个返回值是series类型 ，可以当作整个dataframe的布尔索引
import pandas as pdperson = {"name": ['后羿', '嫦娥', '哪吒', '八戒', '哪吒'],"age": [5000, 4000, 4000, 4300,4000] }df = pd.DataFrame(person)
print(df)
print('以下是 查询 重复值的结果')
print(df.duplicated())
print(type(df.duplicated()))
name age
0 后羿 5000
1 嫦娥 4000
2 哪吒 4000
3 八戒 4300
4 哪吒 4000
以下是 查询 重复值的结果
0 False
1 False
2 False
3 False
4 True
dtype: bool
<class 'pandas.core.series.Series'>
drop_duplicates()
可以使用drop_duplicates()将重复的数据行进行删除，默认全列对比
指定列字段对比 inplace依旧可以设置是生成新的表 还是直接修改原来的表
df.drop_duplicates([‘ST_NAME’],inplace=False)
import pandas as pdperson = {"name": ['后羿', '嫦娥', '哪吒', '八戒', '哪吒'],"age": [5000, 4000, 4000, 4300,4000]}df = pd.DataFrame(person)
print('以下是 去除 重复值的结果')
print(df.drop_duplicates())
以下是 去除 重复值的结果name age
0 后羿 5000
1 嫦娥 4000
2 哪吒 4000
3 八戒 4300
数据的合并、筛选、排序
合并
数据合并主要包括下面两种操作：
轴向连接（concatenation）：pd.concat()可以沿一个轴将多个DataFrame对象连接在一起，形成一个新的DataFrame对象。
融合（merging）：pd.merge()方法可以根据一个或多个键将不同DataFrame中的行连接起来。
concat()
concat()函数可以将数据根据不同的轴进行合并。
参数解释：
objs: series、dataframe或者是panel构成的序列list。
axis： 需要合并链接的轴，0是行，上下摞行，同样列名的会放在同一列，1是列，左右摞列，默认是0。摞不到的地方都默认为NaN
join：连接的方式 inner，或者outer，默认是outer。inner连接后的结果不存在空值
join=‘outer’ 过程是直接合并，缺失的会用NaN填充
join=‘inner’ 过程是直接合并，缺失的会删除
如果两个表的index都没有实际含义，使用ignore_index参数，置true，重新整理一个新的index
pd.concat([df1,df2],axis=0,join=‘outer’,ignore_index=True)
outer()
outer()按行摞列的时候（axis = 0 ），会把同样列名的合在一起，不一样列名的不合在一起，空缺部分用NaN填充。
按行摞列时 可以用ignore_index=True重新排下序号。 按列摞列的时候最好默认False 否则列名也会变成数字索引
# outer()连接import pandas as pd
dict1={'A': ['A0', 'A1', 'A2', 'A3'],'B': ['B0', 'B1', 'B2', 'B3'],'W': ['W0', 'W1', 'W2', 'W3']}
df1=pd.DataFrame(dict1)
print(df1)dict2={'B': ['B0', 'B1', 'B2', 'B3','B4'],'C': ['C0', 'C1', 'C2', 'C3','C4'],'D': ['D0', 'D1', 'D2', 'D3','D4'],'E': ['E0', 'E1', 'E2', 'E3','E4']}
df2=pd.DataFrame(dict2)
print(df2) A B W
0 A0 B0 W0
1 A1 B1 W1
2 A2 B2 W2
3 A3 B3 W3B C D E
0 B0 C0 D0 E0
1 B1 C1 D1 E1
2 B2 C2 D2 E2
3 B3 C3 D3 E3
4 B4 C4 D4 E4
print('下面是df3 concat axis=0 outer的结果 相同字段按行拼接，谁没有那个字段 用NaN填充')
df3 = pd.concat([df1,df2],axis=0,join='outer',ignore_index=True)
print(df3)
下面是df3 concat axis=0 outer的结果 相同字段按行拼接，谁没有那个字段 用NaN填充A B W C D E
0 A0 B0 W0 NaN NaN NaN
1 A1 B1 W1 NaN NaN NaN
2 A2 B2 W2 NaN NaN NaN
3 A3 B3 W3 NaN NaN NaN
4 NaN B0 NaN C0 D0 E0
5 NaN B1 NaN C1 D1 E1
6 NaN B2 NaN C2 D2 E2
7 NaN B3 NaN C3 D3 E3
8 NaN B4 NaN C4 D4 E4
print('下面是df4 concat axis=1 outer的结果')
df5 = pd.concat([df1,df2],axis=1,join='outer')
df5
下面是df4 concat axis=1 outer的结果
| A | B | W | B | C | D | E | |
|---|---|---|---|---|---|---|---|
| 0 | A0 | B0 | W0 | B0 | C0 | D0 | E0 |
| 1 | A1 | B1 | W1 | B1 | C1 | D1 | E1 |
| 2 | A2 | B2 | W2 | B2 | C2 | D2 | E2 |
| 3 | A3 | B3 | W3 | B3 | C3 | D3 | E3 |
| 4 | NaN | NaN | NaN | B4 | C4 | D4 | E4 |
测试
outer的结果 axis = 1 横向摞列时 没什么特殊 就是摞列 然后凑个矩形，凑不上的，用NaN填充成一个矩形
# 测试
dict11={'A': ['A0', 'A1', 'A2', 'A3'],'B': ['B0', 'B1', 'B2', 'B3'],'W': ['W0', 'W1', 'W2', 'W3']}
df11=pd.DataFrame(dict11)
print(df11)
dict22={'B': ['B0', 'B1', 'B2', 'B3'],'C': ['C0', 'C1', 'C2', 'C3'],'D': ['D0', 'D1', 'D2', 'D3'],'E': ['E0', 'E1', 'E2', 'E3']}
df22=pd.DataFrame(dict22)
print(df22)
print('下面是df4 concat axis=1 outer的结果')
df55 = pd.concat([df11,df22],axis=1,join='outer')
df55
A B W
0 A0 B0 W0
1 A1 B1 W1
2 A2 B2 W2
3 A3 B3 W3B C D E
0 B0 C0 D0 E0
1 B1 C1 D1 E1
2 B2 C2 D2 E2
3 B3 C3 D3 E3
下面是df4 concat axis=1 outer的结果
| A | B | W | B | C | D | E | |
|---|---|---|---|---|---|---|---|
| 0 | A0 | B0 | W0 | B0 | C0 | D0 | E0 |
| 1 | A1 | B1 | W1 | B1 | C1 | D1 | E1 |
| 2 | A2 | B2 | W2 | B2 | C2 | D2 | E2 |
| 3 | A3 | B3 | W3 | B3 | C3 | D3 | E3 |
inner()
‘inner() 中不再出现NaN ，因为 有的都删除了’)
# inner()import pandas as pd
dict1={'A': ['A0', 'A1', 'A2', 'A3'],'B': ['B0', 'B1', 'B2', 'B3'],'C': ['C0', 'C1', 'C2', 'C3']}
df1=pd.DataFrame(dict1)
print(df1)dict2={'B': ['B0', 'B1', 'B2', 'B3','B4'],'C': ['C0', 'C1', 'C2', 'C3','C4'],'D': ['D0', 'D1', 'D2', 'D3','D4'],'E': ['E0', 'E1', 'E2', 'E3','E4']}
df2=pd.DataFrame(dict2)
print(df2) A B C
0 A0 B0 C0
1 A1 B1 C1
2 A2 B2 C2
3 A3 B3 C3B C D E
0 B0 C0 D0 E0
1 B1 C1 D1 E1
2 B2 C2 D2 E2
3 B3 C3 D3 E3
4 B4 C4 D4 E4
print('下面是df3的concat axis=0 inner结果 只是把相同列字段拼在一起，并没有对具体数据取交集')
print('也就是相当于在outer()中 所有带NaN的 都删去了')
df3 = pd.concat([df1,df2],axis=0,join='inner',ignore_index=True)
print(df3)
下面是df3的concat axis=0 inner结果 只是把相同列字段拼在一起，并没有对具体数据取交集
也就是相当于在outer()中 所有带NaN的 都删去了B C
0 B0 C0
1 B1 C1
2 B2 C2
3 B3 C3
4 B0 C0
5 B1 C1
6 B2 C2
7 B3 C3
8 B4 C4
print('跟上面一样，不过没有写 ignore_index=True 参数 注意行索引 重复了')
df31 = pd.concat([df1,df2],axis=0,join='inner')
print(df31)
print('-------------')
print(df31[1:6])
跟上面一样，不过没有写 ignore_index=True 参数 注意行索引 重复了B C
0 B0 C0
1 B1 C1
2 B2 C2
3 B3 C3
0 B0 C0
1 B1 C1
2 B2 C2
3 B3 C3
4 B4 C4
-------------B C
1 B1 C1
2 B2 C2
3 B3 C3
0 B0 C0
1 B1 C1
print('下面是df4的concat axis=1 inner结果 只是把都有数据的行和列展示 ，也没有对具体数据取交集')
print('原来outer()时带NaN的 都删除了')
df4 = pd.concat([df1,df2],axis=1,join='inner')
print(df4)df41 = pd.concat([df1,df2],axis=1,join='inner',ignore_index=True)
df41
下面是df4的concat axis=1 inner结果 只是把都有数据的行和列展示 ，也没有对具体数据取交集
原来outer()时带NaN的 都删除了A B C B C D E
0 A0 B0 C0 B0 C0 D0 E0
1 A1 B1 C1 B1 C1 D1 E1
2 A2 B2 C2 B2 C2 D2 E2
3 A3 B3 C3 B3 C3 D3 E3
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | |
|---|---|---|---|---|---|---|---|
| 0 | A0 | B0 | C0 | B0 | C0 | D0 | E0 |
| 1 | A1 | B1 | C1 | B1 | C1 | D1 | E1 |
| 2 | A2 | B2 | C2 | B2 | C2 | D2 | E2 |
| 3 | A3 | B3 | C3 | B3 | C3 | D3 | E3 |
merge()
merge(left, right, how=‘inner’, on=None)
参数介绍：
left和right：两个要合并的DataFrame
how：连接方式，有inner、left、right、outer，默认为inner
on：指的是用于连接的列索引名称，必须存在于左右两个DataFrame中，如果没有指定且其他参数也没有指定，则以两个DataFrame列名交集作为连接键
import pandas as pd
dict1={'A': ['A0', 'A1', 'A2', 'A3'],'B': ['B0', 'B1', 'B2', 'B3'],'C': ['C0', 'C1', 'C2', 'C3']}
df1=pd.DataFrame(dict1)
print(df1)dict2={'B': ['B0', 'B1', 'B2', 'B3','B4'],'C': ['C0', 'C1', 'C2', 'C3','C4'],'D': ['D0', 'D1', 'D2', 'D3','D4'],'E': ['E0', 'E1', 'E2', 'E3','E4']}
df2=pd.DataFrame(dict2)
print(df2) A B C
0 A0 B0 C0
1 A1 B1 C1
2 A2 B2 C2
3 A3 B3 C3B C D E
0 B0 C0 D0 E0
1 B1 C1 D1 E1
2 B2 C2 D2 E2
3 B3 C3 D3 E3
4 B4 C4 D4 E4
inner()
print('下面是df3的merge inner结果')
df3 = pd.merge(df1,df2,how='inner')
print(df3)
下面是df3的merge inner结果A B C D E
0 A0 B0 C0 D0 E0
1 A1 B1 C1 D1 E1
2 A2 B2 C2 D2 E2
3 A3 B3 C3 D3 E3
outer()
print('下面是df4的merge outer结果')
df4 = pd.merge(df1,df2,how='outer')
print(df4)
下面是df4的merge outer结果A B C D E
0 A0 B0 C0 D0 E0
1 A1 B1 C1 D1 E1
2 A2 B2 C2 D2 E2
3 A3 B3 C3 D3 E3
4 NaN B4 C4 D4 E4
left()
df_left = pd.merge(df1,df2,how='left')
print(df_left)
A B C D E
0 A0 B0 C0 D0 E0
1 A1 B1 C1 D1 E1
2 A2 B2 C2 D2 E2
3 A3 B3 C3 D3 E3
right()
df_right = pd.merge(df1,df2,how='right')
print(df_right)
A B C D E
0 A0 B0 C0 D0 E0
1 A1 B1 C1 D1 E1
2 A2 B2 C2 D2 E2
3 A3 B3 C3 D3 E3
4 NaN B4 C4 D4 E4
合并方法总结：
concat()结果 是数据摞列
join：连接的方式 inner，或者outer，默认是outer。inner连接后的结果不存在空值
join=‘outer’ 过程是直接合并，缺失的会用NaN填充
join=‘inner’ 过程是直接合并，缺失的会删除
merge()结果 是数据取并集，inner 时的并集，带空值的整行会删除。outer时， 带空值的用NaN填充
筛选
数据预览
# 数据预览
import pandas as pd
df = pd.read_csv('BOSS直聘岗位数据.csv')
pd.set_option('display.width', 120) # 设置打印宽度(设置后可以避免 内容少但是仍换行显示的情况)
print(df.shape)
print(df.ndim)
print(df)
(7599, 18)
2id search_word city_name position_name company_name areas street company_style scale \
0 11770 岗位 城市 岗位具体名称 公司名称 所在区域 所在街道 公司类型 公司规模
1 11771 python 北京 Python 工程师 爱奇艺 海淀区 中关村 互联网 1000-9999人
2 11772 python 北京 Python 快手 海淀区 上地 社交网络 10000人以上
3 11773 python 北京 初中级Python工程师 智慧星光 NaN NaN 互联网 500-999人
4 11774 python 北京 初中级python工程师 软通动力 大兴区 亦庄 计算机软件 10000人以上
... ... ... ... ... ... ... ... ... ...
7594 19364 java 重庆 Java高级开发工程师 中林广生 九龙坡区 石桥铺 计算机软件 20-99人
7595 19365 java 重庆 Java 创易康软件 NaN NaN 计算机软件 1000-9999人
7596 19366 java 重庆 Java 非鱼计划 NaN NaN 互联网 0-20人
7597 19367 java 重庆 Java 重庆新致金服 渝北区 新牌坊 计算机软件 1000-9999人
7598 19368 java 重庆 JAVA项目经理 德帆科技 南岸区 南坪 计算机软件 100-499人 xue_li work_experience financing_situation \
0 学历要求 工作经验 融资情况
1 本科 经验不限 已上市
2 本科 1-3年 已上市
3 本科 1-3年 未融资
4 大专 1-3年 已上市
... ... ... ...
7594 本科 1-3年 未融资
7595 本科 1-3年 已上市
7596 本科 5-10年 未融资
7597 本科 3-5年 未融资
7598 大专 5-10年 不需要融资 benefits salary \
0 福利待遇 薪资（K）
1 交通补助，加班补助，定期体检，五险一金，零食下午茶，补充医疗保险，餐补，带薪年假...... 20-40
2 全勤奖，节日福利，员工旅游，包吃，加班补助，交通补助，年终奖，零食下午茶，餐补，带薪年假，定... 25-50
3 年终奖，通讯补贴，员工旅游，五险一金，定期体检，带薪年假，股票期权，交通补助，加班补助...... 5-10
4 五险一金，节日福利，员工旅游，定期体检，团建活动，带薪年假，零食下午茶，加班补助，免费班车，... 9-12
... ... ...
7594 年终奖，加班补助，五险一金，定期体检 10-11
7595 带薪年假，餐补，股票期权，节日福利，五险一金，通讯补贴，年终奖，定期体检，交通补助...... 5-9
7596 加班补助，全勤奖，五险一金 10-11
7597 加班补助，员工旅游，定期体检，股票期权，五险一金，带薪年假，节日福利，年终奖...... 9-14
7598 带薪年假，员工旅游，免费班车，节日福利，加班补助，年终奖，五险一金...... 12-18 salary_month salary_min salary_max average_salary
0 发放月数 最低薪资 最高薪资 平均薪资
1 12薪 20 40 30
2 12薪 25 50 37.5
3 12薪 5 10 7.5
4 12薪 9 12 10.5
... ... ... ... ...
7594 12薪 10 11 10.5
7595 12薪 5 9 7
7596 12薪 10 11 10.5
7597 13薪 9 14 11.5
7598 12薪 12 18 15 [7599 rows x 18 columns]
开始筛选
比较运算
import pandas as pd
df = pd.read_csv('BOSS直聘岗位数据.csv')
pd.set_option('display.width', 120) # 设置打印宽度(设置后可以避免 内容少但是仍换行显示的情况)
df.drop( index = [0],inplace = True)
print(df.info())
<class 'pandas.core.frame.DataFrame'>
Int64Index: 7598 entries, 1 to 7598
Data columns (total 18 columns):# Column Non-Null Count Dtype
--- ------ -------------- ----- 0 id 7598 non-null int64 1 search_word 7598 non-null object2 city_name 7598 non-null object3 position_name 7598 non-null object4 company_name 7598 non-null object5 areas 6532 non-null object6 street 6522 non-null object7 company_style 7598 non-null object8 scale 7598 non-null object9 xue_li 7598 non-null object10 work_experience 7598 non-null object11 financing_situation 7598 non-null object12 benefits 7598 non-null object13 salary 7598 non-null object14 salary_month 7598 non-null object15 salary_min 7598 non-null object16 salary_max 7598 non-null object17 average_salary 7598 non-null object
dtypes: int64(1), object(17)
memory usage: 623.3+ KB
None
# 原来的数据类型是字符串的 我们需要跟数字比大小 就要把原来的某列数据转化为数字后再比较
# to_numeric 只能处理字符串型的数字
df['salary_min'] = pd.to_numeric(df['salary_min'])
print('-=-=-------------=-=-=-再次观察数据结构 发现salary_min列数据类型已经成了int64-=-=-------------=-=-=')
print(df.info())
-=-=-------------=-=-=-再次观察数据结构 发现salary_min列数据类型已经成了int64-=-=-------------=-=-=
<class 'pandas.core.frame.DataFrame'>
Int64Index: 7598 entries, 1 to 7598
Data columns (total 18 columns):# Column Non-Null Count Dtype
--- ------ -------------- ----- 0 id 7598 non-null int64 1 search_word 7598 non-null object2 city_name 7598 non-null object3 position_name 7598 non-null object4 company_name 7598 non-null object5 areas 6532 non-null object6 street 6522 non-null object7 company_style 7598 non-null object8 scale 7598 non-null object9 xue_li 7598 non-null object10 work_experience 7598 non-null object11 financing_situation 7598 non-null object12 benefits 7598 non-null object13 salary 7598 non-null object14 salary_month 7598 non-null object15 salary_min 7598 non-null int64 16 salary_max 7598 non-null object17 average_salary 7598 non-null object
dtypes: int64(2), object(16)
memory usage: 653.0+ KB
None
print('-=-=-------------=-=-=筛选出最低薪资大于10K的数据 组成一个布尔类型的series 用作布尔索引-=-=-------------=-=-=--')
salary_bt_10 = df['salary_min'] > 10
print(salary_bt_10)
-=-=-------------=-=-=筛选出最低薪资大于10K的数据 组成一个布尔类型的series 用作布尔索引-=-=-------------=-=-=--
1 True
2 True
3 False
4 False
5 True...
7594 False
7595 False
7596 False
7597 False
7598 True
Name: salary_min, Length: 7598, dtype: bool
print('-=-=-------------=-=-=打印最低薪资大于10K的数据-=-=-=-=--',df[salary_bt_10].shape)
print(df[salary_bt_10])
-=-=-------------=-=-=打印最低薪资大于10K的数据-=-=-=-=-- (5063, 18)id search_word city_name position_name company_name areas street company_style \
1 11771 python 北京 Python 工程师 爱奇艺 海淀区 中关村 互联网
2 11772 python 北京 Python 快手 海淀区 上地 社交网络
5 11775 python 北京 Python 爱奇艺 海淀区 中关村 互联网
6 11776 python 北京 python 开发工程师 (MJ000246) 融360 NaN NaN 互联网金融
7 11777 python 北京 Python 腾讯 昌平区 南邵 互联网
... ... ... ... ... ... ... ... ...
7587 19357 java 重庆 Java架构师 紫光华智 NaN NaN 计算机软件
7589 19359 java 重庆 Java 魔西网络科技 NaN NaN 计算机软件
7591 19361 java 重庆 JAVA架构师 优税猫 NaN NaN 企业服务
7592 19362 java 重庆 Java中高级工程师 拓普森 渝北区 汽博中心 电子商务
7598 19368 java 重庆 JAVA项目经理 德帆科技 南岸区 南坪 计算机软件 scale xue_li work_experience financing_situation \
1 1000-9999人 本科 经验不限 已上市
2 10000人以上 本科 1-3年 已上市
5 1000-9999人 本科 1-3年 已上市
6 1000-9999人 本科 1-3年 已上市
7 10000人以上 本科 3-5年 已上市
... ... ... ... ...
7587 1000-9999人 本科 5-10年 未融资
7589 100-499人 本科 3-5年 不需要融资
7591 500-999人 本科 5-10年 不需要融资
7592 20-99人 大专 5-10年 未融资
7598 100-499人 大专 5-10年 不需要融资 benefits salary \
1 交通补助，加班补助，定期体检，五险一金，零食下午茶，补充医疗保险，餐补，带薪年假...... 20-40
2 全勤奖，节日福利，员工旅游，包吃，加班补助，交通补助，年终奖，零食下午茶，餐补，带薪年假，定... 25-50
5 带薪年假，加班补助，五险一金，零食下午茶，定期体检，交通补助，补充医疗保险，餐补...... 20-40
6 带薪年假，补充医疗保险，交通补助，定期体检，节日福利，通讯补贴，五险一金，餐补...... 15-25
7 带薪年假，餐补，节日福利，五险一金，年终奖，定期体检，补充医疗保险，免费班车...... 19-25
... ... ...
7587 年终奖，节日福利，交通补助，餐补，五险一金，定期体检，零食下午茶，带薪年假，补充医疗保险，通... 17-25
7589 交通补助，定期体检，年终奖，婚礼礼金，生日礼金，带薪年假，五险一金，节日福利，子女出生礼金.... 11-18
7591 定期体检，年终奖，五险一金，员工旅游，零食下午茶，节日福利，带薪年假，交通补助，通讯补贴，餐... 20-30
7592 6险1金，节日福利，零食下午茶，带薪年假，员工旅游，全勤奖，定期体检，餐补，交通补助...... 12-17
7598 带薪年假，员工旅游，免费班车，节日福利，加班补助，年终奖，五险一金...... 12-18 salary_month salary_min salary_max average_salary
1 12薪 20 40 30
2 12薪 25 50 37.5
5 12薪 20 40 30
6 15薪 15 25 20
7 12薪 19 25 22
... ... ... ... ...
7587 14薪 17 25 21
7589 12薪 11 18 14.5
7591 13薪 20 30 25
7592 12薪 12 17 14.5
7598 12薪 12 18 15 [5063 rows x 18 columns]
df['average_salary'] = pd.to_numeric(df['average_salary'])
# 平均薪资大于100K的数据
print(df[df['average_salary'] >= 100])
# 平均薪资小于5K的数据
print(df[df['average_salary'] <= 5])
id search_word city_name position_name company_name areas street company_style \
13 11783 python 北京 python研发实习生 中国科学院软件研究所 NaN NaN 计算机软件
360 12130 python 上海 Python实习生 DaoCloud 杨浦区 五角场 互联网
578 12348 python 广州 Python后端开发实习 钛讯科技 番禺区 大学城 互联网
674 12444 python 广州 兼职粤语python在线老师 傲梦网络科技 NaN NaN 在线教育
750 12520 python 广州 Python爬虫工程师 海胆 番禺区 市桥 互联网
... ... ... ... ... ... ... ... ...
7242 19012 java 郑州 Java程序开发员 宏雨供应链 NaN NaN 互联网
7342 19112 java 重庆 JAVA实习生 小易智能技术有限公司 南岸区 茶园新区 企业服务
7346 19116 java 重庆 Java实习带薪 深圳奇实科技有限公司 渝中区 解放碑 计算机软件
7357 19127 java 重庆 Java初级开发工程师 盛世科技(重庆)... 沙坪坝区 陈家桥 计算机软件
7501 19271 java 重庆 Java 学无悔教育科技有... 江北区 观音桥 在线教育 scale xue_li work_experience financing_situation \
13 1000-9999人 本科 经验不限 不需要融资
360 100-499人 本科 经验不限 C轮
578 0-20人 本科 经验不限 不需要融资
674 500-999人 本科 经验不限 B轮
750 0-20人 学历不限 经验不限 未融资
... ... ... ... ...
7242 0-20人 大专 经验不限 不需要融资
7342 20-99人 大专 经验不限 不需要融资
7346 20-99人 本科 经验不限 不需要融资
7357 20-99人 本科 1-3年 不需要融资
7501 100-499人 本科 1-3年 未融资 benefits salary \
13 年终奖，定期体检，带薪年假，五险一金，节日福利 1-2
360 交通补助，节日福利，股票期权，定期体检，通讯补贴，零食下午茶，补充医疗保险，五险一金，年终奖... 4-5
578 员工旅游，年终奖，零食下午茶，全勤奖，五险，节日福利...... 2-3
674 带薪年假，五险一金，加班补助，十三薪，定期体检，员工旅游，餐补，交通补助，零食下午茶，年终奖... 3-6
750 节日福利，零食下午茶，带薪年假，员工旅游 3-5
... ... ...
7242 全勤奖，节日福利，员工旅游，五险一金，带薪年假，交通补助...... 3-6
7342 带薪年假，五险一金，股票期权 3-5
7346 零食下午茶，年终奖，股票期权，员工旅游，带薪年假，五险一金，生日福利...... 3-5
7357 五险一金，股票期权，年终奖，带薪年假，节日福利 4-6
7501 年终奖，通讯补贴，交通补助，加班补助，带薪年假，全勤奖，股票期权...... 3-6 salary_month salary_min salary_max average_salary
13 12薪 1 2 1.5
360 12薪 4 5 4.5
578 12薪 2 3 2.5
674 12薪 3 6 4.5
750 12薪 3 5 4.0
... ... ... ... ...
7242 12薪 3 6 4.5
7342 12薪 3 5 4.0
7346 12薪 3 5 4.0
7357 12薪 4 6 5.0
7501 12薪 3 6 4.5 [110 rows x 18 columns]
逻辑运算
筛选出 最低薪资大于10K 的 python岗位的数据
同时满足多个条件 用 且 & 连接
任意满足其中一个条件即可 用 或 | 连接
# 多条件筛选 筛选出 最低薪资大于10K 的 python岗位的数据
import pandas as pd
df = pd.read_csv('BOSS直聘岗位数据.csv')
pd.set_option('display.width', 120) # 设置打印宽度(设置后可以避免 内容少但是仍换行显示的情况)
df.drop( index = [0],inplace = True)# 原来的数据类型是字符串的 我们需要跟数字比大小 就要把原来的某列数据转化为数字后再比较
# to_numeric 只能处理字符串型的数字
df['salary_min'] = pd.to_numeric(df['salary_min'])print('-=-=-------------=-=-=打印最低薪资大于10K的数据-=-=-=-=--',df[salary_bt_10].shape)
salary_bt_10 = df['salary_min'] > 10
# print(df[salary_bt_10])position_eq_python = (df['search_word'] == 'python')
print('-=-=-------------=-=-=打印出岗位语言是python的数据-=-=-------------=-=-=--',df[position_eq_python].shape)
# print(df[position_eq_python])print('-=-=-------------=-=-=最低薪资大于10K 且 是python岗位的数据-=-=-------------=-=-=--')
print(df[salary_bt_10 & position_eq_python])
-=-=-------------=-=-=打印最低薪资大于10K的数据-=-=-=-=-- (5063, 18)
-=-=-------------=-=-=打印出岗位语言是python的数据-=-=-------------=-=-=-- (3642, 18)
-=-=-------------=-=-=最低薪资大于10K 且 是python岗位的数据-=-=-------------=-=-=--id search_word city_name position_name company_name areas street \
1 11771 python 北京 Python 工程师 爱奇艺 海淀区 中关村
2 11772 python 北京 Python 快手 海淀区 上地
5 11775 python 北京 Python 爱奇艺 海淀区 中关村
6 11776 python 北京 python 开发工程师 (MJ000246) 融360 NaN NaN
7 11777 python 北京 Python 腾讯 昌平区 南邵
... ... ... ... ... ... ... ...
3638 15408 python 重庆 安卓开发 北京纬创 渝北区 空港新城
3639 15409 python 重庆 Android平台开发工程师 镁佳(北京)科技有限公司 渝北区 空港新城
3640 15410 python 重庆 数据平台运营开发工程师 腾讯 渝北区 冉家坝
3641 15411 python 重庆 高级基础平台研发工程师 美克来福易热尔科技 渝北区 冉家坝
3642 15412 python 重庆 长安软件公司-地图算法开发高级(J13468) 长安软件公司 江北区 鱼嘴 company_style scale xue_li work_experience financing_situation \
1 互联网 1000-9999人 本科 经验不限 已上市
2 社交网络 10000人以上 本科 1-3年 已上市
5 互联网 1000-9999人 本科 1-3年 已上市
6 互联网金融 1000-9999人 本科 1-3年 已上市
7 互联网 10000人以上 本科 3-5年 已上市
... ... ... ... ... ...
3638 计算机软件 1000-9999人 本科 3-5年 不需要融资
3639 互联网 100-499人 本科 1-3年 C轮
3640 互联网 10000人以上 本科 1-3年 已上市
3641 移动互联网 100-499人 本科 5-10年 未融资
3642 汽车生产 500-999人 本科 3-5年 未融资 benefits salary \
1 交通补助，加班补助，定期体检，五险一金，零食下午茶，补充医疗保险，餐补，带薪年假...... 20-40
2 全勤奖，节日福利，员工旅游，包吃，加班补助，交通补助，年终奖，零食下午茶，餐补，带薪年假，定... 25-50
5 带薪年假，加班补助，五险一金，零食下午茶，定期体检，交通补助，补充医疗保险，餐补...... 20-40
6 带薪年假，补充医疗保险，交通补助，定期体检，节日福利，通讯补贴，五险一金，餐补...... 15-25
7 带薪年假，餐补，节日福利，五险一金，年终奖，定期体检，补充医疗保险，免费班车...... 19-25
... ... ...
3638 带薪年假，员工旅游，五险一金，定期体检，节日福利，零食下午茶...... 12-20
3639 年终奖，五险一金，补充医疗保险，节日福利，零食下午茶，股票期权，带薪年假，定期体检，通讯补贴... 11-22
3640 定期体检，年终奖，节日福利，餐补，五险一金，免费班车，补充医疗保险，带薪年假...... 15-30
3641 节日福利，员工旅游，零食下午茶，股票期权，五险一金，年终奖，带薪年假...... 18-25
3642 五险一金，补充医疗保险，带薪年假，定期体检，餐补，节日福利，股票期权，交通补助，年终奖，免费... 12-24 salary_month salary_min salary_max average_salary
1 12薪 20 40 30
2 12薪 25 50 37.5
5 12薪 20 40 30
6 15薪 15 25 20
7 12薪 19 25 22
... ... ... ... ...
3638 12薪 12 20 16
3639 13薪 11 22 16.5
3640 12薪 15 30 22.5
3641 12薪 18 25 21.5
3642 12薪 12 24 18 [2106 rows x 18 columns]
id search_word city_name position_name company_name areas street company_style scale \
4610 16380 java 深圳 Java高级架构师（专家级） 腾讯 南山区 科技园 互联网 10000人以上 xue_li work_experience financing_situation \
4610 本科 5-10年 已上市 benefits salary salary_month \
4610 免费班车，节日福利，五险一金，定期体检，补充医疗保险，年终奖，带薪年假，餐补...... 150-200 16薪 salary_min salary_max average_salary
4610 150 200 175.0 id search_word city_name position_name company_name areas street company_style \
13 11783 python 北京 python研发实习生 中国科学院软件研究所 NaN NaN 计算机软件
360 12130 python 上海 Python实习生 DaoCloud 杨浦区 五角场 互联网
578 12348 python 广州 Python后端开发实习 钛讯科技 番禺区 大学城 互联网
674 12444 python 广州 兼职粤语python在线老师 傲梦网络科技 NaN NaN 在线教育
750 12520 python 广州 Python爬虫工程师 海胆 番禺区 市桥 互联网
... ... ... ... ... ... ... ... ...
7242 19012 java 郑州 Java程序开发员 宏雨供应链 NaN NaN 互联网
7342 19112 java 重庆 JAVA实习生 小易智能技术有限公司 南岸区 茶园新区 企业服务
7346 19116 java 重庆 Java实习带薪 深圳奇实科技有限公司 渝中区 解放碑 计算机软件
7357 19127 java 重庆 Java初级开发工程师 盛世科技(重庆)... 沙坪坝区 陈家桥 计算机软件
7501 19271 java 重庆 Java 学无悔教育科技有... 江北区 观音桥 在线教育 scale xue_li work_experience financing_situation \
13 1000-9999人 本科 经验不限 不需要融资
360 100-499人 本科 经验不限 C轮
578 0-20人 本科 经验不限 不需要融资
674 500-999人 本科 经验不限 B轮
750 0-20人 学历不限 经验不限 未融资
... ... ... ... ...
7242 0-20人 大专 经验不限 不需要融资
7342 20-99人 大专 经验不限 不需要融资
7346 20-99人 本科 经验不限 不需要融资
7357 20-99人 本科 1-3年 不需要融资
7501 100-499人 本科 1-3年 未融资 benefits salary \
13 年终奖，定期体检，带薪年假，五险一金，节日福利 1-2
360 交通补助，节日福利，股票期权，定期体检，通讯补贴，零食下午茶，补充医疗保险，五险一金，年终奖... 4-5
578 员工旅游，年终奖，零食下午茶，全勤奖，五险，节日福利...... 2-3
674 带薪年假，五险一金，加班补助，十三薪，定期体检，员工旅游，餐补，交通补助，零食下午茶，年终奖... 3-6
750 节日福利，零食下午茶，带薪年假，员工旅游 3-5
... ... ...
7242 全勤奖，节日福利，员工旅游，五险一金，带薪年假，交通补助...... 3-6
7342 带薪年假，五险一金，股票期权 3-5
7346 零食下午茶，年终奖，股票期权，员工旅游，带薪年假，五险一金，生日福利...... 3-5
7357 五险一金，股票期权，年终奖，带薪年假，节日福利 4-6
7501 年终奖，通讯补贴，交通补助，加班补助，带薪年假，全勤奖，股票期权...... 3-6 salary_month salary_min salary_max average_salary
13 12薪 1 2 1.5
360 12薪 4 5 4.5
578 12薪 2 3 2.5
674 12薪 3 6 4.5
750 12薪 3 5 4.0
... ... ... ... ...
7242 12薪 3 6 4.5
7342 12薪 3 5 4.0
7346 12薪 3 5 4.0
7357 12薪 4 6 5.0
7501 12薪 3 6 4.5 [110 rows x 18 columns]
排序
可以使用sort_index()、sort_values()两个方法对数据进行排序，并且这两个方法Series和DataFrame都支持。
DataFrame的sort_index( )方法是按照行索引进行排序，（可以用默认的，也可以指定索引）
sort_values(by=‘salary_min’,ascending=False,inplace=True)可以指定具体列进行排序。
sort_index()
import pandas as pd
df = pd.read_csv('BOSS直聘岗位数据.csv',index_col='id') # 这里设置了 数据索引
df.sort_index(inplace=True,ascending=True)
df.head()
| search_word | city_name | position_name | company_name | areas | street | company_style | scale | xue_li | work_experience | financing_situation | benefits | salary | salary_month | salary_min | salary_max | average_salary | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| id | |||||||||||||||||
| 11770 | 岗位 | 城市 | 岗位具体名称 | 公司名称 | 所在区域 | 所在街道 | 公司类型 | 公司规模 | 学历要求 | 工作经验 | 融资情况 | 福利待遇 | 薪资（K） | 发放月数 | 最低薪资 | 最高薪资 | 平均薪资 |
| 11771 | python | 北京 | Python 工程师 | 爱奇艺 | 海淀区 | 中关村 | 互联网 | 1000-9999人 | 本科 | 经验不限 | 已上市 | 交通补助，加班补助，定期体检，五险一金，零食下午茶，补充医疗保险，餐补，带薪年假... | 20-40 | 12薪 | 20 | 40 | 30 |
| 11772 | python | 北京 | Python | 快手 | 海淀区 | 上地 | 社交网络 | 10000人以上 | 本科 | 1-3年 | 已上市 | 全勤奖，节日福利，员工旅游，包吃，加班补助，交通补助，年终奖，零食下午茶，餐补，带薪年假，定... | 25-50 | 12薪 | 25 | 50 | 37.5 |
| 11773 | python | 北京 | 初中级Python工程师 | 智慧星光 | NaN | NaN | 互联网 | 500-999人 | 本科 | 1-3年 | 未融资 | 年终奖，通讯补贴，员工旅游，五险一金，定期体检，带薪年假，股票期权，交通补助，加班补助... | 5-10 | 12薪 | 5 | 10 | 7.5 |
| 11774 | python | 北京 | 初中级python工程师 | 软通动力 | 大兴区 | 亦庄 | 计算机软件 | 10000人以上 | 大专 | 1-3年 | 已上市 | 五险一金，节日福利，员工旅游，定期体检，团建活动，带薪年假，零食下午茶，加班补助，免费班车，... | 9-12 | 12薪 | 9 | 12 | 10.5 |
sort_values()
by:决定了是按数据中的哪一列进行排序，将需要按照某列排序的列名赋值给by即可。多列排序就传列表
ascending=False:将数据按照从大到小的顺序排列。
inplace=True:用来控制是否直接对原始数据进行修改。
import pandas as pd
df = pd.read_csv('BOSS直聘岗位数据.csv')
df.sort_values(by='salary_min',ascending=False,inplace=True)
print(df.head(10))
id search_word city_name position_name company_name areas street \
0 11770 岗位 城市 岗位具体名称 公司名称 所在区域 所在街道
1080 12850 python 深圳 Python高级工程师 考通教育 福田区 岗厦
2396 14166 python 厦门 Python工程师 美怡莱 NaN NaN
5679 17449 java 苏州 Java软件工程师 嘉图科技 苏州工业园区 独墅湖
2774 14544 python 长沙 python开发工程师 领航广州 天心区 铁道
6287 18057 java 厦门 java研发工程师 安胜 思明区 软件园
4221 15991 java 广州 广州 Java 法本信息 黄埔区 科学城
2406 14176 python 厦门 python工程师 外贸牛 湖里区 禾山
3431 15201 python 重庆 Python客户端开发工程师 壹禅科技 渝中区 七星岗
5639 17409 java 西安 JAVA 软通动力信息技术集团 雁塔区 高新软件园 company_style scale xue_li work_experience financing_situation \
0 公司类型 公司规模 学历要求 工作经验 融资情况
1080 培训机构 20-99人 本科 1年以内 不需要融资
2396 电子商务 500-999人 大专 1-3年 不需要融资
5679 计算机软件 100-499人 本科 3-5年 D轮及以上
2774 数据服务 100-499人 大专 经验不限 不需要融资
6287 互联网 100-499人 本科 1-3年 未融资
4221 互联网 1000-9999人 大专 1-3年 已上市
2406 互联网 20-99人 大专 经验不限 不需要融资
3431 游戏 100-499人 本科 1-3年 不需要融资
5639 计算机软件 10000人以上 本科 1-3年 已上市 benefits salary \
0 福利待遇 薪资（K）
1080 全勤奖，员工旅游，零食下午茶，节日福利，年终奖，定期体检，通讯补贴，补充医疗保险，股票期权，... 9-12
2396 五险，交通补助，节日福利，团建旅游，年终奖，带薪年假，全勤奖，加班补助，零食下午茶...... 9-14
5679 加班补助，五险一金，员工旅游，补充医疗保险，股票期权，节日福利，年终奖，定期体检，带薪年假.... 9-13
2774 员工旅游，节日福利，交通补助，通讯补贴，餐补，五险一金...... 9-12
6287 带薪年假，年终奖，免费班车，五险一金，股票期权，补充医疗保险，定期体检...... 9-14
4221 带薪年假，加班补助，五险一金，节日福利，免费班车，定期体检，零食下午茶，年终奖，员工旅游..... 9-13
2406 节日福利，零食下午茶，五险一金，五险，全勤奖，商业险，年终奖，带薪年假...... 9-14
3431 五险一金，加班补助，年终奖 9-14
5639 员工旅游，年终奖，节日福利，餐补，加班补助，带薪年假，零食下午茶，交通补助，五险一金，定期体... 9-14 salary_month salary_min salary_max average_salary
0 发放月数 最低薪资 最高薪资 平均薪资
1080 12薪 9 12 10.5
2396 12薪 9 14 11.5
5679 12薪 9 13 11
2774 13薪 9 12 10.5
6287 13薪 9 14 11.5
4221 12薪 9 13 11
2406 12薪 9 14 11.5
3431 12薪 9 14 11.5
5639 12薪 9 14 11.5
分组和统计
分组
groupby(‘列名’)
groupby()不能链式重复使用 想多重分组 可以用 [‘city_name’,‘work_experience’] 列表当作参数
import pandas as pd
df = pd.read_csv('BOSS直聘岗位数据.csv')
# print(df[df['city_name'] == '城市'])
df.drop(index=[0],inplace = True )
groups = df.groupby('city_name')
print(groups)
<pandas.core.groupby.generic.DataFrameGroupBy object at 0x0099F870>
groups.size()
用groupby的size方法可以查看分组后每组的数量，并返回一个含有分组大小的Series
import pandas as pd
df = pd.read_csv('BOSS直聘岗位数据.csv')
# print(df[df['city_name'] == '城市'])
df.drop(index=[0],inplace = True )
groups = df.groupby('city_name')
print(groups)
print(groups.size())
<pandas.core.groupby.generic.DataFrameGroupBy object at 0x063746F0>
city_name
上海 561
北京 586
厦门 555
天津 527
广州 534
成都 546
杭州 550
武汉 543
深圳 578
苏州 517
西安 560
郑州 484
重庆 515
长沙 542
dtype: int64
import pandas as pd
df = pd.read_csv('BOSS直聘岗位数据.csv')
# print(df[df['city_name'] == '城市'])
df.drop(index=[0],inplace = True )
groups = df.groupby('city_name')
# 取第4行数据
print(groups.size()[3])
# 获取序列索引
print(groups.size().index)527
Index(['上海', '北京', '厦门', '天津', '广州', '成都', '杭州', '武汉', '深圳', '苏州', '西安', '郑州', '重庆', '长沙'], dtype='object', name='city_name')
groups.get_group()
get_group(‘F’)这个方法可以根据具体分组的名字获取，每个组的数据。
import pandas as pd
df = pd.read_csv('BOSS直聘岗位数据.csv')
# print(df[df['city_name'] == '城市'])
df.drop(index=[0],inplace = True )
groups = df.groupby('city_name')
print(groups)
# print(groups.size())
# groups['上海'] 会报错
# groups['上海']
print(groups.get_group('北京'))
<pandas.core.groupby.generic.DataFrameGroupBy object at 0x06384A10>id search_word city_name position_name company_name areas street \
1 11771 python 北京 Python 工程师 爱奇艺 海淀区 中关村
2 11772 python 北京 Python 快手 海淀区 上地
3 11773 python 北京 初中级Python工程师 智慧星光 NaN NaN
4 11774 python 北京 初中级python工程师 软通动力 大兴区 亦庄
5 11775 python 北京 Python 爱奇艺 海淀区 中关村
... ... ... ... ... ... ... ...
3928 15698 java 北京 Java高级工程师 华清远见 NaN NaN
3929 15699 java 北京 中高级java（会php） 妙健康 朝阳区 三元桥
3930 15700 java 北京 Java高级开发工程师 ThoughtWorks 东城区 东直门
3931 15701 java 北京 Java 阿里巴巴集团 朝阳区 望京
3932 15702 java 北京 JAVA高级工程师 用友网络 海淀区 西北旺 company_style scale xue_li work_experience financing_situation \
1 互联网 1000-9999人 本科 经验不限 已上市
2 社交网络 10000人以上 本科 1-3年 已上市
3 互联网 500-999人 本科 1-3年 未融资
4 计算机软件 10000人以上 大专 1-3年 已上市
5 互联网 1000-9999人 本科 1-3年 已上市
... ... ... ... ... ...
3928 培训机构 500-999人 本科 3-5年 不需要融资
3929 互联网 500-999人 本科 3-5年 C轮
3930 互联网 1000-9999人 本科 5-10年 不需要融资
3931 互联网 10000人以上 本科 3-5年 已上市
3932 互联网 10000人以上 本科 3-5年 已上市 benefits salary salary_month \
1 交通补助，加班补助，定期体检，五险一金，零食下午茶，补充医疗保险，餐补，带薪年假 20-40 12薪
2 全勤奖，节日福利，员工旅游，包吃，加班补助，交通补助，年终奖，零食下午茶，餐补，带薪年假，定... 25-50 12薪
3 年终奖，通讯补贴，员工旅游，五险一金，定期体检，带薪年假，股票期权，交通补助，加班补助 5-10 12薪
4 五险一金，节日福利，员工旅游，定期体检，团建活动，带薪年假，零食下午茶，加班补助，免费班车，全勤奖 9-12 12薪
5 带薪年假，加班补助，五险一金，零食下午茶，定期体检，交通补助，补充医疗保险，餐补 20-40 12薪
... ... ... ...
3928 全勤奖，出差补助，定期体检，通讯补贴，带薪年假，零食下午茶，管理层提升培，年终奖，加班补助，... 12-20 12薪
3929 交通补助，年终奖，带薪年假，五险一金，零食下午茶，通讯补贴，餐补，定期体检，补充医疗保险，股... 14-23 13薪
3930 发展基金，补充医疗保险，社区活动，年终奖，带薪年假，节日福利，零食下午茶，定期体检，交通补助... 20-30 14薪
3931 年终奖，加班补助，节日福利，员工旅游，免费班车，餐补，带薪年假，交通补助，补充医疗保险，股票... 20-30 16薪
3932 定期体检，节日福利，带薪年假，员工旅游，交通补助，股票期权，年终奖，餐补，五险一金，通讯补贴 20-30 14薪 salary_min salary_max average_salary
1 20 40 30
2 25 50 37.5
3 5 10 7.5
4 9 12 10.5
5 20 40 30
... ... ... ...
3928 12 20 16
3929 14 23 18.5
3930 20 30 25
3931 20 30 25
3932 20 30 25 [586 rows x 18 columns]
groups.groups
groups.groups 的结果是一个字典，字典的key是分组后每个组的名字，对应的值是分组后的数据索引
注意groups.groups没有括号
import pandas as pd
df = pd.read_csv('BOSS直聘岗位数据.csv')
# print(df[df['city_name'] == '城市'])
df.drop(index=[0],inplace = True)
groups = df.groupby('city_name')print(groups.groups)
{'上海': [297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, ...], '北京': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, ...], '厦门': [2378, 2379, 2380, 2381, 2382, 2383, 2384, 2385, 2386, 2387, 2388, 2389, 2390, 2391, 2392, 2393, 2394, 2395, 2396, 2397, 2398, 2399, 2400, 2401, 2402, 2403, 2404, 2405, 2406, 2407, 2408, 2409, 2410, 2411, 2412, 2413, 2414, 2415, 2416, 2417, 2418, 2419, 2420, 2421, 2422, 2423, 2424, 2425, 2426, 2427, 2428, 2429, 2430, 2431, 2432, 2433, 2434, 2435, 2436, 2437, 2438, 2439, 2440, 2441, 2442, 2443, 2444, 2445, 2446, 2447, 2448, 2449, 2450, 2451, 2452, 2453, 2454, 2455, 2456, 2457, 2458, 2459, 2460, 2461, 2462, 2463, 2464, 2465, 2466, 2467, 2468, 2469, 2470, 2471, 2472, 2473, 2474, 2475, 2476, 2477, ...], '天津': [1374, 1375, 1376, 1377, 1378, 1379, 1380, 1381, 1382, 1383, 1384, 1385, 1386, 1387, 1388, 1389, 1390, 1391, 1392, 1393, 1394, 1395, 1396, 1397, 1398, 1399, 1400, 1401, 1402, 1403, 1404, 1405, 1406, 1407, 1408, 1409, 1410, 1411, 1412, 1413, 1414, 1415, 1416, 1417, 1418, 1419, 1420, 1421, 1422, 1423, 1424, 1425, 1426, 1427, 1428, 1429, 1430, 1431, 1432, 1433, 1434, 1435, 1436, 1437, 1438, 1439, 1440, 1441, 1442, 1443, 1444, 1445, 1446, 1447, 1448, 1449, 1450, 1451, 1452, 1453, 1454, 1455, 1456, 1457, 1458, 1459, 1460, 1461, 1462, 1463, 1464, 1465, 1466, 1467, 1468, 1469, 1470, 1471, 1472, 1473, ...], '广州': [572, 573, 574, 575, 576, 577, 578, 579, 580, 581, 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, 592, 593, 594, 595, 596, 597, 598, 599, 600, 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, ...], '成都': [2900, 2901, 2902, 2903, 2904, 2905, 2906, 2907, 2908, 2909, 2910, 2911, 2912, 2913, 2914, 2915, 2916, 2917, 2918, 2919, 2920, 2921, 2922, 2923, 2924, 2925, 2926, 2927, 2928, 2929, 2930, 2931, 2932, 2933, 2934, 2935, 2936, 2937, 2938, 2939, 2940, 2941, 2942, 2943, 2944, 2945, 2946, 2947, 2948, 2949, 2950, 2951, 2952, 2953, 2954, 2955, 2956, 2957, 2958, 2959, 2960, 2961, 2962, 2963, 2964, 2965, 2966, 2967, 2968, 2969, 2970, 2971, 2972, 2973, 2974, 2975, 2976, 2977, 2978, 2979, 2980, 2981, 2982, 2983, 2984, 2985, 2986, 2987, 2988, 2989, 2990, 2991, 2992, 2993, 2994, 2995, 2996, 2997, 2998, 2999, ...], '杭州': [1099, 1100, 1101, 1102, 1103, 1104, 1105, 1106, 1107, 1108, 1109, 1110, 1111, 1112, 1113, 1114, 1115, 1116, 1117, 1118, 1119, 1120, 1121, 1122, 1123, 1124, 1125, 1126, 1127, 1128, 1129, 1130, 1131, 1132, 1133, 1134, 1135, 1136, 1137, 1138, 1139, 1140, 1141, 1142, 1143, 1144, 1145, 1146, 1147, 1148, 1149, 1150, 1151, 1152, 1153, 1154, 1155, 1156, 1157, 1158, 1159, 1160, 1161, 1162, 1163, 1164, 1165, 1166, 1167, 1168, 1169, 1170, 1171, 1172, 1173, 1174, 1175, 1176, 1177, 1178, 1179, 1180, 1181, 1182, 1183, 1184, 1185, 1186, 1187, 1188, 1189, 1190, 1191, 1192, 1193, 1194, 1195, 1196, 1197, 1198, ...], '武汉': [2128, 2129, 2130, 2131, 2132, 2133, 2134, 2135, 2136, 2137, 2138, 2139, 2140, 2141, 2142, 2143, 2144, 2145, 2146, 2147, 2148, 2149, 2150, 2151, 2152, 2153, 2154, 2155, 2156, 2157, 2158, 2159, 2160, 2161, 2162, 2163, 2164, 2165, 2166, 2167, 2168, 2169, 2170, 2171, 2172, 2173, 2174, 2175, 2176, 2177, 2178, 2179, 2180, 2181, 2182, 2183, 2184, 2185, 2186, 2187, 2188, 2189, 2190, 2191, 2192, 2193, 2194, 2195, 2196, 2197, 2198, 2199, 2200, 2201, 2202, 2203, 2204, 2205, 2206, 2207, 2208, 2209, 2210, 2211, 2212, 2213, 2214, 2215, 2216, 2217, 2218, 2219, 2220, 2221, 2222, 2223, 2224, 2225, 2226, 2227, ...], '深圳': [811, 812, 813, 814, 815, 816, 817, 818, 819, 820, 821, 822, 823, 824, 825, 826, 827, 828, 829, 830, 831, 832, 833, 834, 835, 836, 837, 838, 839, 840, 841, 842, 843, 844, 845, 846, 847, 848, 849, 850, 851, 852, 853, 854, 855, 856, 857, 858, 859, 860, 861, 862, 863, 864, 865, 866, 867, 868, 869, 870, 871, 872, 873, 874, 875, 876, 877, 878, 879, 880, 881, 882, 883, 884, 885, 886, 887, 888, 889, 890, 891, 892, 893, 894, 895, 896, 897, 898, 899, 900, 901, 902, 903, 904, 905, 906, 907, 908, 909, 910, ...], '苏州': [1895, 1896, 1897, 1898, 1899, 1900, 1901, 1902, 1903, 1904, 1905, 1906, 1907, 1908, 1909, 1910, 1911, 1912, 1913, 1914, 1915, 1916, 1917, 1918, 1919, 1920, 1921, 1922, 1923, 1924, 1925, 1926, 1927, 1928, 1929, 1930, 1931, 1932, 1933, 1934, 1935, 1936, 1937, 1938, 1939, 1940, 1941, 1942, 1943, 1944, 1945, 1946, 1947, 1948, 1949, 1950, 1951, 1952, 1953, 1954, 1955, 1956, 1957, 1958, 1959, 1960, 1961, 1962, 1963, 1964, 1965, 1966, 1967, 1968, 1969, 1970, 1971, 1972, 1973, 1974, 1975, 1976, 1977, 1978, 1979, 1980, 1981, 1982, 1983, 1984, 1985, 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, ...], '西安': [1630, 1631, 1632, 1633, 1634, 1635, 1636, 1637, 1638, 1639, 1640, 1641, 1642, 1643, 1644, 1645, 1646, 1647, 1648, 1649, 1650, 1651, 1652, 1653, 1654, 1655, 1656, 1657, 1658, 1659, 1660, 1661, 1662, 1663, 1664, 1665, 1666, 1667, 1668, 1669, 1670, 1671, 1672, 1673, 1674, 1675, 1676, 1677, 1678, 1679, 1680, 1681, 1682, 1683, 1684, 1685, 1686, 1687, 1688, 1689, 1690, 1691, 1692, 1693, 1694, 1695, 1696, 1697, 1698, 1699, 1700, 1701, 1702, 1703, 1704, 1705, 1706, 1707, 1708, 1709, 1710, 1711, 1712, 1713, 1714, 1715, 1716, 1717, 1718, 1719, 1720, 1721, 1722, 1723, 1724, 1725, 1726, 1727, 1728, 1729, ...], '郑州': [3167, 3168, 3169, 3170, 3171, 3172, 3173, 3174, 3175, 3176, 3177, 3178, 3179, 3180, 3181, 3182, 3183, 3184, 3185, 3186, 3187, 3188, 3189, 3190, 3191, 3192, 3193, 3194, 3195, 3196, 3197, 3198, 3199, 3200, 3201, 3202, 3203, 3204, 3205, 3206, 3207, 3208, 3209, 3210, 3211, 3212, 3213, 3214, 3215, 3216, 3217, 3218, 3219, 3220, 3221, 3222, 3223, 3224, 3225, 3226, 3227, 3228, 3229, 3230, 3231, 3232, 3233, 3234, 3235, 3236, 3237, 3238, 3239, 3240, 3241, 3242, 3243, 3244, 3245, 3246, 3247, 3248, 3249, 3250, 3251, 3252, 3253, 3254, 3255, 3256, 3257, 3258, 3259, 3260, 3261, 3262, 3263, 3264, 3265, 3266, ...], '重庆': [3387, 3388, 3389, 3390, 3391, 3392, 3393, 3394, 3395, 3396, 3397, 3398, 3399, 3400, 3401, 3402, 3403, 3404, 3405, 3406, 3407, 3408, 3409, 3410, 3411, 3412, 3413, 3414, 3415, 3416, 3417, 3418, 3419, 3420, 3421, 3422, 3423, 3424, 3425, 3426, 3427, 3428, 3429, 3430, 3431, 3432, 3433, 3434, 3435, 3436, 3437, 3438, 3439, 3440, 3441, 3442, 3443, 3444, 3445, 3446, 3447, 3448, 3449, 3450, 3451, 3452, 3453, 3454, 3455, 3456, 3457, 3458, 3459, 3460, 3461, 3462, 3463, 3464, 3465, 3466, 3467, 3468, 3469, 3470, 3471, 3472, 3473, 3474, 3475, 3476, 3477, 3478, 3479, 3480, 3481, 3482, 3483, 3484, 3485, 3486, ...], '长沙': [2642, 2643, 2644, 2645, 2646, 2647, 2648, 2649, 2650, 2651, 2652, 2653, 2654, 2655, 2656, 2657, 2658, 2659, 2660, 2661, 2662, 2663, 2664, 2665, 2666, 2667, 2668, 2669, 2670, 2671, 2672, 2673, 2674, 2675, 2676, 2677, 2678, 2679, 2680, 2681, 2682, 2683, 2684, 2685, 2686, 2687, 2688, 2689, 2690, 2691, 2692, 2693, 2694, 2695, 2696, 2697, 2698, 2699, 2700, 2701, 2702, 2703, 2704, 2705, 2706, 2707, 2708, 2709, 2710, 2711, 2712, 2713, 2714, 2715, 2716, 2717, 2718, 2719, 2720, 2721, 2722, 2723, 2724, 2725, 2726, 2727, 2728, 2729, 2730, 2731, 2732, 2733, 2734, 2735, 2736, 2737, 2738, 2739, 2740, 2741, ...]}
多列分组和取值
多列分组的分组方式要传入一个列表 列表里的元素是字段名
多列分组的取值方式要传入一个元组 元组里的元素是字段名下面的元素
import pandas as pd
df = pd.read_csv('BOSS直聘岗位数据.csv')
# print(df[df['city_name'] == '城市'])
df.drop(index=[0],inplace = True )
groups = df.groupby(['city_name','work_experience'])
print(groups.size())
# 多列分组的取值方式要传入一个元组 元组里的元素是字段名下面的元素
print(groups.get_group(('上海','1-3年')))
city_name work_experience
上海 1-3年 14210年以上 11年以内 53-5年 2555-10年 74...
长沙 1-3年 1721年以内 123-5年 1505-10年 93经验不限 115
Length: 80, dtype: int64id search_word city_name position_name company_name areas street \
299 12069 python 上海 Python 百度 浦东新区 张江
302 12072 python 上海 Python工程师 第一秒电商 黄浦区 人民广场
303 12073 python 上海 python高级开发工程师 携程集团 NaN NaN
304 12074 python 上海 Python 携程旅行网 长宁区 淞虹路
307 12077 python 上海 python研发工程师 北京百度网讯有限公司 浦东新区 张江
... ... ... ... ... ... ... ...
4133 15903 java 上海 舆情系统开发工程师（java）） 百度 浦东新区 张江
4138 15908 java 上海 Java交付开发工程师-上海 邦盛科技 浦东新区 曹路
4169 15939 java 上海 Java/Go 开发工程师 蚂蚁金服 浦东新区 陆家嘴
4200 15970 java 上海 JAVA研发/高级/专家—上海/杭州/深圳 蚂蚁金服 浦东新区 陆家嘴
4208 15978 java 上海 Java 轻轻教育 徐汇区 徐家汇 company_style scale xue_li work_experience financing_situation \
299 互联网 10000人以上 本科 1-3年 已上市
302 互联网 500-999人 大专 1-3年 A轮
303 互联网 10000人以上 本科 1-3年 已上市
304 互联网 10000人以上 本科 1-3年 已上市
307 互联网 10000人以上 本科 1-3年 已上市
... ... ... ... ... ...
4133 互联网 10000人以上 本科 1-3年 已上市
4138 互联网 500-999人 本科 1-3年 C轮
4169 互联网 10000人以上 本科 1-3年 不需要融资
4200 互联网 10000人以上 本科 1-3年 不需要融资
4208 培训机构 1000-9999人 本科 1-3年 D轮及以上 benefits salary \
299 节日福利，通讯补贴，补充医疗保险，住房补贴，带薪年假，餐补，员工旅游，加班补助，定期体检，年... 20-40
302 员工旅游，定期体检，五险一金，节日福利，带薪年假，年终奖，补充医疗保险...... 10-15
303 五险一金，年终奖 20-35
304 员工旅游，股票期权，带薪年假，餐补，年终奖，五险一金，节日福利，绩效奖金...... 15-30
307 团队nice，不打卡，零食下午茶，五险一金，交通补助，补充医疗保险，年终奖，节日福利，股票期... 15-30
... ... ...
4133 交通补助，老板Nice，五险一金，零食下午茶，餐补，定期体检，员工旅游，带薪年假，年终奖，补... 20-40
4138 加班补助，十三薪，五险一金，餐补，定期体检，股票期权，补充医疗保险，带薪年假，年终奖，节日福... 11-18
4169 股票期权，五险一金，节日福利，补充医疗保险，员工旅游，定期体检，免费班车，年终奖，带薪年假，... 25-40
4200 员工旅游，节日福利，免费班车，股票期权，补充医疗保险，带薪年假，年终奖，包吃，五险一金，定期... 20-40
4208 节日福利，五险一金，带薪年假，年终奖 12-24 salary_month salary_min salary_max average_salary
299 16薪 20 40 30
302 13薪 10 15 12.5
303 15薪 20 35 27.5
304 15薪 15 30 22.5
307 12薪 15 30 22.5
... ... ... ... ...
4133 16薪 20 40 30
4138 13薪 11 18 14.5
4169 16薪 25 40 32.5
4200 16薪 20 40 30
4208 12薪 12 24 18 [142 rows x 18 columns]
常用统计函数：mean()、max()、min()
import pandas as pd
df = pd.read_csv('BOSS直聘岗位数据.csv')
# print(df[df['city_name'] == '城市'])
df.drop(index=[0],inplace = True )
df['average_salary'] = pd.to_numeric(df['average_salary'])
salary = df['average_salary'].max()
salary2 = df['average_salary'].min()
salary3 = df['average_salary'].mean()
salary4 = df['average_salary'].median()
salary5 = df['average_salary'].count()
print(salary)
print(salary2)
print(salary3)
print(salary4)
print(salary5)
175.0
1.5
18.220584364306397
17.0
7598
聚合统计agg([])
就是把多个统计方法 放到一起去处理
import pandas as pd
df = pd.read_csv('BOSS直聘岗位数据.csv')
# print(df[df['city_name'] == '城市'])
df.drop(index=[0],inplace = True )
df['average_salary'] = pd.to_numeric(df['average_salary'])
agg_salary = df['average_salary'].agg(['min','max','mean','count'])
print(agg_salary)
print(type(agg_salary))
print(agg_salary[0],agg_salary[1])
min 1.500000
max 175.000000
mean 18.220584
count 7598.000000
Name: average_salary, dtype: float64
<class 'pandas.core.series.Series'>
1.5 175.0
import pandas as pd
df = pd.read_csv('BOSS直聘岗位数据.csv')
# print(df[df['city_name'] == '城市'])
df.drop(index=[0],inplace = True )
df['average_salary'] = pd.to_numeric(df['average_salary'])
groups = df.groupby('city_name')
for x,y in groups:# x 是组名 y 是 该组的dataframe值print(x,y['average_salary'].agg(['min','max','mean','count']))
# groups2 = groups.agg(['min','max','mean','count'])
# print(groups)
# print(groups2)
上海 min 4.500000
max 50.000000
mean 23.252228
count 561.000000
Name: average_salary, dtype: float64
北京 min 1.500000
max 50.000000
mean 24.743174
count 586.000000
Name: average_salary, dtype: float64
厦门 min 2.500000
max 45.000000
mean 15.430631
count 555.000000
Name: average_salary, dtype: float64
天津 min 1.500000
max 47.500000
mean 13.566414
count 527.000000
Name: average_salary, dtype: float64
广州 min 2.500000
max 75.000000
mean 19.368914
count 534.000000
Name: average_salary, dtype: float64
成都 min 2.000000
max 47.500000
mean 18.356227
count 546.000000
Name: average_salary, dtype: float64
杭州 min 2.500000
max 60.000000
mean 21.978182
count 550.000000
Name: average_salary, dtype: float64
武汉 min 2.500000
max 45.000000
mean 16.986188
count 543.000000
Name: average_salary, dtype: float64
深圳 min 3.500000
max 175.000000
mean 26.203287
count 578.000000
Name: average_salary, dtype: float64
苏州 min 1.500000
max 45.000000
mean 16.139265
count 517.000000
Name: average_salary, dtype: float64
西安 min 2.500000
max 45.000000
mean 17.386607
count 560.000000
Name: average_salary, dtype: float64
郑州 min 3.50000
max 37.50000
mean 11.14876
count 484.00000
Name: average_salary, dtype: float64
重庆 min 2.500000
max 45.000000
mean 14.580583
count 515.000000
Name: average_salary, dtype: float64
长沙 min 1.500000
max 32.500000
mean 13.606089
count 542.000000
Name: average_salary, dtype: float64
import pandas as pd
df = pd.read_csv('BOSS直聘岗位数据.csv')
# print(df[df['city_name'] == '城市'])
df.drop(index=[0],inplace = True )
groups = df.groupby('average_salary')
for x ,y in groups:print(x,type(x))print(y,type(y))break
1.5 <class 'str'>id search_word city_name position_name company_name areas street \
13 11783 python 北京 python研发实习生 中国科学院软件研究所 NaN NaN
2014 13784 python 苏州 Python老师（周末兼职） 青创赢 苏州工业园区 苏州中心商场
5195 16965 java 天津 Java实习生 马尾草 西青区 大学城
6519 18289 java 长沙 Java 思洋 岳麓区 麓谷 company_style scale xue_li work_experience financing_situation \
13 计算机软件 1000-9999人 本科 经验不限 不需要融资
2014 在线教育 20-99人 本科 1-3年 未融资
5195 互联网 20-99人 大专 经验不限 未融资
6519 互联网 100-499人 大专 经验不限 不需要融资 benefits salary salary_month \
13 年终奖，定期体检，带薪年假，五险一金，节日福利 1-2 12薪
2014 五险一金，餐补，年终奖，通讯补贴，交通补助 1-2 12薪
5195 节日福利，年终奖，员工旅游，五险一金，带薪年假 1-2 12薪
6519 年终奖，零食下午茶，节日福利，通讯补贴，带薪年假，交通补助，员工旅游，股票期权...... 1-2 12薪 salary_min salary_max average_salary
13 1 2 1.5
2014 1 2 1.5
5195 1 2 1.5
6519 1 2 1.5 <class 'pandas.core.frame.DataFrame'>
自定义统计方式
import pandas as pd
df = pd.read_csv('BOSS直聘岗位数据.csv')
# print(df[df['city_name'] == '城市'])
df.drop(index=[0],inplace = True )
# 设置数据对齐显示
pd.set_option('display.unicode.ambiguous_as_wide', True)
pd.set_option('display.unicode.east_asian_width', True)
# 设置打印宽度(设置后可以避免 内容少但是仍换行显示的情况)
pd.set_option('display.width', 130)
df['salary_min'] = pd.to_numeric(df['salary_min'])
df['salary_max'] = pd.to_numeric(df['salary_max'])
groups = df.groupby('city_name')def ave(data):# 这个data其实就是传进来的要统计的比如 y['salary_max'] 列的数据return data.max() - data.min() for x,y in groups:print(x,'\n',y['salary_max'].agg(['max','min','mean',ave]))
上海 max 65.000000
min 5.000000
mean 29.434938
ave 60.000000
Name: salary_max, dtype: float64
北京 max 65.000000
min 2.000000
mean 31.389078
ave 63.000000
Name: salary_max, dtype: float64
厦门 max 60.000000
min 3.000000
mean 19.257658
ave 57.000000
Name: salary_max, dtype: float64
天津 max 60.000000
min 2.000000
mean 16.810247
ave 58.000000
Name: salary_max, dtype: float64
广州 max 90.000000
min 3.000000
mean 24.174157
ave 87.000000
Name: salary_max, dtype: float64
成都 max 60.000000
min 3.000000
mean 23.152015
ave 57.000000
Name: salary_max, dtype: float64
杭州 max 70.000000
min 3.000000
mean 27.976364
ave 67.000000
Name: salary_max, dtype: float64
武汉 max 60.000000
min 3.000000
mean 21.303867
ave 57.000000
Name: salary_max, dtype: float64
深圳 max 200.000000
min 4.000000
mean 33.432526
ave 196.000000
Name: salary_max, dtype: float64
苏州 max 60.000000
min 2.000000
mean 19.982592
ave 58.000000
Name: salary_max, dtype: float64
西安 max 60.000000
min 3.000000
mean 21.998214
ave 57.000000
Name: salary_max, dtype: float64
郑州 max 50.000000
min 4.000000
mean 13.665289
ave 46.000000
Name: salary_max, dtype: float64
重庆 max 60.000000
min 3.000000
mean 18.161165
ave 57.000000
Name: salary_max, dtype: float64
长沙 max 40.000000
min 2.000000
mean 16.848708
ave 38.000000
Name: salary_max, dtype: float64
多层索引操作
创建
# 一般方式（比较麻烦点）
import pandas as pd
s = pd.Series([1,2,3,4,5,6],index=[['张三','张三','李四','李四','王五','王五'],['期中','期末','期中','期末','期中','期末']])
print(s)
# Series取值
print(s['张三'])
print(s['张三','期中'])
张三 期中 1期末 2
李四 期中 3期末 4
王五 期中 5期末 6
dtype: int64
期中 1
期末 2
dtype: int64
1
2
from_product()
# 调用方法创建 pd.MultiIndex.from_product([列表])
import pandas as pd
import numpy as npdata = np.random.randint(0,100,size=(6,3))
names = ['张三','李四','王五']
semesters = ['期中','期末']
# 索引会按照顺序创建，修改顺序后会看到另一种效果哦 from_p
# product()，第一个参数是外层索引，第二个是内层，依次类推
index = pd.MultiIndex.from_product([names,semesters])
df = pd.DataFrame(data,index = index,columns=['语文','数学','英语'])
print(df)
语文 数学 英语
张三 期中 10 47 76期末 52 86 0
李四 期中 76 84 79期末 51 78 10
王五 期中 61 62 54期末 67 19 21
取值
loc取值
# 回顾DataFrame 取值
import pandas as pd
import numpy as npdata = np.random.randint(0,100,size=(6,3))
names = ['张三','李四','王五']
semesters = ['期中','期末']
# 索引会按照顺序创建，修改顺序后会看到另一种效果哦 from_p
# product()，第一个参数是外层索引，第二个是内层，依次类推
index = pd.MultiIndex.from_product([names,semesters])
df = pd.DataFrame(data,index = index,columns=['语文','数学','英语'])
print(df) 语文 数学 英语
张三 期中 31 82 25期末 34 39 4
李四 期中 58 67 47期末 89 94 93
王五 期中 11 17 46期末 59 22 67
print(df['语文'])
张三 期中 31期末 34
李四 期中 58期末 89
王五 期中 11期末 59
Name: 语文, dtype: int32
print('\n---切片取值 发现并不是很理想')
print(df[1:3]['数学'])
print('\n---loc取值')
print(df.loc['张三'])
print('\n---loc嵌套取值')
print(df.loc['张三'].loc['期中'])print('\n以下方式推荐使用')
print(df.loc['张三','期中'])
print(123456789887456)
print(df.loc['张三','期中']['语文'])
---切片取值 发现并不是很理想
张三 期末 39
李四 期中 67
Name: 数学, dtype: int32---loc取值语文 数学 英语
期中 31 82 25
期末 34 39 4---loc嵌套取值
语文 31
数学 82
英语 25
Name: 期中, dtype: int32以下方式推荐使用
语文 31
数学 82
英语 25
Name: (张三, 期中), dtype: int32
123456789887456
31
iloc取值
# 回顾DataFrame取值
import pandas as pd
import numpy as npdata = np.random.randint(0,100,size=(6,3))
names = ['张三','李四','王五']
semesters = ['期中','期末']
# 索引会按照顺序创建，修改顺序后会看到另一种效果哦 from_p
# product()，第一个参数是外层索引，第二个是内层，依次类推
index = pd.MultiIndex.from_product([names,semesters])
df = pd.DataFrame(data,index = index,columns=['语文','数学','英语'])
# 取一行
print("\ndf.iloc[1]取一行\n",df.iloc[1])
# 取连续多行
print("\ndf.iloc[0:2]取连续多行\n",df.iloc[0:2])
# 取间断的多行
print("\ndf.iloc[[0,2],:]取间断的多行\n",df.iloc[[0,2],:])
# 取某一列
print("\ndf.iloc[:,1]取某一列\n",df.iloc[:,1])
# 取某一个值
print("\ndf.iloc[1,0]取某一个值\n",df.iloc[1,0])
df.iloc[1]取一行语文 39
数学 28
英语 14
Name: (张三, 期末), dtype: int32df.iloc[0:2]取连续多行语文 数学 英语
张三 期中 61 45 2期末 39 28 14df.iloc[[0,2],:]取间断的多行语文 数学 英语
张三 期中 61 45 2
李四 期中 97 19 27df.iloc[:,1]取某一列张三 期中 45期末 28
李四 期中 19期末 70
王五 期中 19期末 33
Name: 数学, dtype: int32df.iloc[1,0]取某一个值39
排序
import pandas as pd
import numpy as npdata = np.random.randint(0,100,size=(6,3))
names = ['张三','李四','王五']
semesters = ['期中','期末']
# 索引会按照顺序创建，修改顺序后会看到另一种效果哦 from_p
# product()，第一个参数是外层索引，第二个是内层，依次类推
index = pd.MultiIndex.from_product([names,semesters])
df = pd.DataFrame(data,index = index,columns=['语文','数学','英语'])
print(df.sort_index())
print('---------')
print(df.sort_index(level = 0))
print('---------')
print(df.sort_index(level = 1))
语文 数学 英语
张三 期中 82 71 23期末 86 5 92
李四 期中 76 21 53期末 31 14 52
王五 期中 50 37 17期末 90 84 39
---------语文 数学 英语
张三 期中 82 71 23期末 86 5 92
李四 期中 76 21 53期末 31 14 52
王五 期中 50 37 17期末 90 84 39
---------语文 数学 英语
张三 期中 82 71 23
李四 期中 76 21 53
王五 期中 50 37 17
张三 期末 86 5 92
李四 期末 31 14 52
王五 期末 90 84 39
更改
类型更改
to_numeric() 将 字符串类型 转 数字类型
# 字符串类型转数字类型 这样方便比较薪资大小
# 原来的数据类型是字符串的 我们需要跟数字比大小 就要把原来的某列数据转化为数字后再比较
# to_numeric 只能处理字符串型的数字
df['salary_min'] = pd.to_numeric(df['salary_min'])
print('-=-=-------------=-=-=-再次观察数据结构 发现salary_min列数据类型已经成了int64-=-=-------------=-=-=')
print(df.info())
to_datetime() 将 字符串类型 转Timestamp类型
pd.to_datetime(arg,format=None)
arg：需要修改的数据
format：数据的格式
import pandas as pd
pd.to_datetime('20210101')
Timestamp('2021-01-01 00:00:00')
# 字符串日期中包含中文，我们可以这样处理
import pandas as pd
pd.to_datetime('2021年1月1日',format='%Y年%m月%d日')
Timestamp('2021-01-01 00:00:00')
to_pydatetime() 将 Timestamp类型 转datetime类型
pd.to_datetime('2021/1/1').to_pydatetime()# 转成datetime类型后就可以用datetime库的方法处理了
datetime.datetime(2021, 1, 1, 0, 0)
astype 强制转换
常用用的转换对象包括：str | float | int
import pandas as pd
df = pd.DataFrame()
df['金币'] = ['1200','1300','1400','1500','1600','700']
df['金币2'] = ['￥1200','￥1300','￥1400','￥1500','￥1600','￥1700']
print(df)
df.info()
金币 金币2
0 1200 ￥1200
1 1300 ￥1300
2 1400 ￥1400
3 1500 ￥1500
4 1600 ￥1600
5 700 ￥1700
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 6 entries, 0 to 5
Data columns (total 2 columns):# Column Non-Null Count Dtype
--- ------ -------------- ----- 0 金币 6 non-null object1 金币2 6 non-null object
dtypes: object(2)
memory usage: 112.0+ bytes
x = df['金币'].astype(float)
print(x)
0 1200.0
1 1300.0
2 1400.0
3 1500.0
4 1600.0
5 700.0
Name: 金币, dtype: float64
数据更改
案例1
将年薪里的 羊角号去掉 并转换为数字类型
import pandas as pd
df = pd.read_csv('LOL风云人物utf-8.csv')
pd.set_option('display.unicode.ambiguous_as_wide', True)
pd.set_option('display.unicode.east_asian_width', True)
df['年薪'] = ['￥1200','￥1300','￥1400','￥1500','￥1600','￥1700']
df['年薪2'] = ['￥1200','￥1300','￥1400','￥1500','￥1600','￥1700']
print(df)
Unnamed: 0 位置 ID号 年龄 年薪 年薪2
0 1 上单 清清 21 ￥1200 ￥1200
1 2 打野 无畏 19 ￥1300 ￥1300
2 3 中单 笑影 23 ￥1400 ￥1400
3 4 ADC 一诺 19 ￥1500 ￥1500
4 5 辅助 爱思 21 ￥1600 ￥1600
5 6 教练 lang 25 ￥1700 ￥1700
print(df.info())
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 6 entries, 0 to 5
Data columns (total 6 columns):# Column Non-Null Count Dtype
--- ------ -------------- ----- 0 Unnamed: 0 6 non-null int64 1 位置 6 non-null object2 ID号 6 non-null object3 年龄 6 non-null int64 4 年薪 6 non-null object5 年薪2 6 non-null object
dtypes: int64(2), object(4)
memory usage: 256.0+ bytes
None
x = df['年薪2'].str[1:]
print(x,type(x))
print(df.info())
0 1200
1 1300
2 1400
3 1500
4 1600
5 1700
Name: 年薪2, dtype: object <class 'pandas.core.series.Series'>
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 6 entries, 0 to 5
Data columns (total 6 columns):# Column Non-Null Count Dtype
--- ------ -------------- ----- 0 Unnamed: 0 6 non-null int64 1 位置 6 non-null object2 ID号 6 non-null object3 年龄 6 non-null int64 4 年薪 6 non-null object5 年薪2 6 non-null object
dtypes: int64(2), object(4)
memory usage: 256.0+ bytes
None
df['年薪'] = pd.to_numeric(df['年薪'].str[1:])
print(df)
df.info()
Unnamed: 0 位置 ID号 年龄 年薪 年薪2
0 1 上单 清清 21 1200 ￥1200
1 2 打野 无畏 19 1300 ￥1300
2 3 中单 笑影 23 1400 ￥1400
3 4 ADC 一诺 19 1500 ￥1500
4 5 辅助 爱思 21 1600 ￥1600
5 6 教练 lang 25 1700 ￥1700
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 6 entries, 0 to 5
Data columns (total 6 columns):# Column Non-Null Count Dtype
--- ------ -------------- ----- 0 Unnamed: 0 6 non-null int64 1 位置 6 non-null object2 ID号 6 non-null object3 年龄 6 non-null int64 4 年薪 6 non-null int64 5 年薪2 6 non-null object
dtypes: int64(3), object(3)
memory usage: 280.0+ bytes
df['年薪2'] = pd.to_numeric(df['年薪2'].str[1:])
print(df)
df.info()
Unnamed: 0 位置 ID号 年龄 年薪 年薪2
0 1 上单 清清 21 1200.2 1200
1 2 打野 无畏 19 1300.8 1300
2 3 中单 笑影 23 1400.0 1400
3 4 ADC 一诺 19 1500.0 1500
4 5 辅助 爱思 21 1600.0 1600
5 6 教练 lang 25 1700.0 1700
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 6 entries, 0 to 5
Data columns (total 6 columns):# Column Non-Null Count Dtype
--- ------ -------------- ----- 0 Unnamed: 0 6 non-null int64 1 位置 6 non-null object 2 ID号 6 non-null object 3 年龄 6 non-null int64 4 年薪 6 non-null float645 年薪2 6 non-null int64
dtypes: float64(1), int64(3), object(2)
memory usage: 304.0+ bytes
案例2
原理就是 取到值后重新赋值即可
import pandas as pd
import numpy as npdata = np.random.randint(0,100,size=(6,3))
names = ['张三','李四','王五']
semesters = ['期中','期末']
# 索引会按照顺序创建，修改顺序后会看到另一种效果哦 from_p
# product()，第一个参数是外层索引，第二个是内层，依次类推
index = pd.MultiIndex.from_product([names,semesters])
df = pd.DataFrame(data,index = index,columns=['语文','数学','英语'])
print(df) 语文 数学 英语
张三 期中 43 82 74期末 43 95 18
李四 期中 21 87 50期末 14 25 87
王五 期中 77 56 70期末 86 13 26
ying = df['英语']>50
print(ying)
df['英语'][ying] += 80
yu = df['语文']<50
df['语文'][yu] = '我是语文'
print(df)
张三 期中 True期末 False
李四 期中 False期末 True
王五 期中 True期末 False
Name: 英语, dtype: bool语文 数学 英语
张三 期中 我是语文 82 154期末 我是语文 95 18
李四 期中 我是语文 87 50期末 我是语文 25 167
王五 期中 77 56 150期末 86 13 26
时间序列
datetime库
datetime.datetime.now() 获取当前时间
datetime.strftime() 格式化时间为字符串格式
datetime.strptime() 格式化时间字符串为时间格式
创建日期
# 创建日期
import datetime
date = datetime.date(2019, 9, 9)
print(date)
# 获取年
print(date.year)
# 获取月
print(date.month)
# 获取日
print(date.day)
2019-09-09
2019
9
9
创建时间
# 创建时间
import datetime
time = datetime.time(13, 14, 20)
print(time)
# 获取小时
print(time.hour)
# 获取分钟
print(time.minute)
# 获取秒
print(time.second)
13:14:20
13
14
20
创建日期 + 时间
import datetime
date_time = datetime.datetime(2021, 2, 14, 13, 14, 20)
print(type(date_time))
print(date_time)
# 获取年
print(date_time.year)
# 获取月
print(date_time.month)
# 获取日
print(date_time.day)
# 获取小时
print(date_time.hour)
# 获取分钟
print(date_time.minute)
# 获取秒
print(date_time.second)
<class 'datetime.datetime'>
2021-02-14 13:14:20
2021
2
14
13
14
20
时间格式化
格式化当前时间为字符串
import datetime
date_time2 = datetime.datetime.now()
print(date_time2,type(date_time2))
str_time2 = date_time2.strftime('%Y/%m/%d %H:%M')
print(str_time2,type(str_time2))
2021-09-13 15:02:28.813522 <class 'datetime.datetime'>
2021/09/13 15:02 <class 'str'>
格式化指定时间为字符串
import datetime
date_time1 = datetime.datetime(2021, 2, 14, 13, 14, 20)
print(date_time1,type(date_time1))
str_time1 = date_time1.strftime('%Y/%m/%d %H:%M')
print(str_time1,type(str_time1))
2021-02-14 13:14:20 <class 'datetime.datetime'>
2021/02/14 13:14 <class 'str'>
逆向格式化字符串为datetime.datetime类型
strptime()
import datetime
data_time3 = datetime.datetime(2021,2,14,13,14,20)
print(data_time3,type(data_time3))
data_time4 =data_time3.strftime('%Y/%m/%d %H:%M')
print(data_time4,type(data_time4))
data_time5 = datetime.datetime.strptime(data_time4,"%Y/%m/%d %H:%M")
print(data_time5,type(data_time5))
2021-02-14 13:14:20 <class 'datetime.datetime'>
2021/02/14 13:14 <class 'str'>
2021-02-14 13:14:00 <class 'datetime.datetime'>
pandas的时间设置
使用Pandas的date_range()方法可以快速创建出一个日期范围。
一共有4个参数可以用，但是每次最多用三个就行
start:日期范围的开始；
end:日期范围的结束；
periods:要取的日期数据的个数(取几天)；
freq: 步频，或日期偏移量，取值为string, 默认为’D’，即：一天为日期偏移量
import pandas as pd
pd.date_range(start = '20210101',end = '20210130')
DatetimeIndex(['2021-01-01', '2021-01-02', '2021-01-03', '2021-01-04','2021-01-05', '2021-01-06', '2021-01-07', '2021-01-08','2021-01-09', '2021-01-10', '2021-01-11', '2021-01-12','2021-01-13', '2021-01-14', '2021-01-15', '2021-01-16','2021-01-17', '2021-01-18', '2021-01-19', '2021-01-20','2021-01-21', '2021-01-22', '2021-01-23', '2021-01-24','2021-01-25', '2021-01-26', '2021-01-27', '2021-01-28','2021-01-29', '2021-01-30'],dtype='datetime64[ns]', freq='D')
import pandas as pd
pd.date_range(start = '20210101',end = '20210130',freq = 'D')
DatetimeIndex(['2021-01-01', '2021-01-02', '2021-01-03', '2021-01-04','2021-01-05', '2021-01-06', '2021-01-07', '2021-01-08','2021-01-09', '2021-01-10', '2021-01-11', '2021-01-12','2021-01-13', '2021-01-14', '2021-01-15', '2021-01-16','2021-01-17', '2021-01-18', '2021-01-19', '2021-01-20','2021-01-21', '2021-01-22', '2021-01-23', '2021-01-24','2021-01-25', '2021-01-26', '2021-01-27', '2021-01-28','2021-01-29', '2021-01-30'],dtype='datetime64[ns]', freq='D')
import pandas as pd
pd.date_range(start = '20210101',end = '20210130',freq = '5D')
DatetimeIndex(['2021-01-01', '2021-01-06', '2021-01-11', '2021-01-16','2021-01-21', '2021-01-26'],dtype='datetime64[ns]', freq='5D')
import pandas as pd
pd.date_range(start = '20210101',end = '20210130',periods = 3)
DatetimeIndex(['2021-01-01 00:00:00', '2021-01-15 12:00:00','2021-01-30 00:00:00'],dtype='datetime64[ns]', freq=None)
import pandas as pd
pd.date_range(start = '20210101',periods = 3)
DatetimeIndex(['2021-01-01', '2021-01-02', '2021-01-03'], dtype='datetime64[ns]', freq='D')
import pandas as pd
pd.date_range(start = '20210101',periods = 3,freq = '3D')
DatetimeIndex(['2021-01-01', '2021-01-04', '2021-01-07'], dtype='datetime64[ns]', freq='3D')
pandas生成时间索引的series序列
import pandas as pd
import numpy as np
time_data = pd.date_range('20210101','20220303',periods = 30)
time_index = np.random.randint(200,size=len(time_data))
time_series = pd.Series(data = time_index,index = time_data)
print(time_series)
2021-01-01 00:00:00.000000000 42
2021-01-15 16:33:06.206896551 74
2021-01-30 09:06:12.413793103 86
2021-02-14 01:39:18.620689655 96
2021-02-28 18:12:24.827586207 185
2021-03-15 10:45:31.034482759 26
2021-03-30 03:18:37.241379310 45
2021-04-13 19:51:43.448275862 134
2021-04-28 12:24:49.655172414 58
2021-05-13 04:57:55.862068966 163
2021-05-27 21:31:02.068965518 38
2021-06-11 14:04:08.275862070 140
2021-06-26 06:37:14.482758620 170
2021-07-10 23:10:20.689655172 42
2021-07-25 15:43:26.896551724 138
2021-08-09 08:16:33.103448276 184
2021-08-24 00:49:39.310344828 47
2021-09-07 17:22:45.517241380 176
2021-09-22 09:55:51.724137932 73
2021-10-07 02:28:57.931034484 165
2021-10-21 19:02:04.137931036 3
2021-11-05 11:35:10.344827588 158
2021-11-20 04:08:16.551724140 121
2021-12-04 20:41:22.758620692 173
2021-12-19 13:14:28.965517240 193
2022-01-03 05:47:35.172413792 168
2022-01-17 22:20:41.379310344 101
2022-02-01 14:53:47.586206896 118
2022-02-16 07:26:53.793103448 18
2022-03-03 00:00:00.000000000 120
dtype: int32
pandas获取时间索引数据
获取某年的数据
# 根据时间索引获取某年的数据
time_series['2022']
2022-01-03 05:47:35.172413792 19
2022-01-17 22:20:41.379310344 10
2022-02-01 14:53:47.586206896 121
2022-02-16 07:26:53.793103448 29
2022-03-03 00:00:00.000000000 34
dtype: int32
获取某年某月的数据
# 获取某年某月的数据
time_series['2022-01']
2022-01-03 05:47:35.172413792 168
2022-01-17 22:20:41.379310344 158
dtype: int32
可以使用时间戳进行切片获取数据
date_time[‘2021-09-05’:‘2022-02-10’]
time_series['2021-09-05':'2022-02-10']
2021-09-07 17:22:45.517241380 27
2021-09-22 09:55:51.724137932 81
2021-10-07 02:28:57.931034484 97
2021-10-21 19:02:04.137931036 174
2021-11-05 11:35:10.344827588 9
2021-11-20 04:08:16.551724140 154
2021-12-04 20:41:22.758620692 143
2021-12-19 13:14:28.965517240 159
2022-01-03 05:47:35.172413792 168
2022-01-17 22:20:41.379310344 158
2022-02-01 14:53:47.586206896 157
dtype: int32
pandas设置小技巧
设置数据对齐显示
# 设置数据对齐显示
pd.set_option('display.unicode.ambiguous_as_wide', True)
pd.set_option('display.unicode.east_asian_width', True)
# 设置打印宽度 设置后可以避免 内容不够一行但是print时候仍换行显示的情况
# pd.set_option('display.width', 180)
统计频数
Series类型
### Series类型
import pandas as pd
df=pd.Series(['python','java','python','php','php','java','python','java'])
print(df)
print('频数统计如下:\n')
print(df.value_counts())
0 python
1 java
2 python
3 php
4 php
5 java
6 python
7 javadtype: object
频数统计如下:
python 3
java 3
php 2
dtype: int64
DataFrame类型
import pandas as pd
data={'key1':['python','java','python','php'],'key2':['Go','java','python','Go']}
df2=pd.DataFrame(data)
print(df2)
print('频数统计如下:\n')
print(df2.apply(pd.value_counts))
key1 key2
0 python Go
1 java java
2 python python
3 php Go频数统计如下:key1 key2
Go NaN 2.0
java 1.0 1.0
php 1.0 NaN
python 2.0 1.0
关于numpy小应用
np.arange() 生成序列数
np.arange(100) 生成一个序列的100个数据 类似 range()
import numpy as np
a = np.arange(10)
print(len(a),type(a))
print(a)
for i in a:print(i)
b = a[2:7:2] # 从索引 2 开始到索引 7 停止，间隔为 2
print(b)
10 <class 'numpy.ndarray'>
[0 1 2 3 4 5 6 7 8 9]
0
1
2
3
4
5
6
7
8
9
[2 4 6]
np.random() 生成随机序列数
import numpy as np
a2 = np.random.randint(5,size = 20)
print(len(a2),type(a2))
print(a2)a3 = np.random.random(12)
print(len(a3),type(a3))
print(a3)
20 <class 'numpy.ndarray'>
[4 3 1 1 1 1 2 2 2 4 4 3 3 1 3 2 3 3 2 0]
12 <class 'numpy.ndarray'>
[0.21175232 0.19905539 0.03306435 0.81013236 0.29168163 0.695933040.17628424 0.75482027 0.02897187 0.86091275 0.69064357 0.70937504]
多维数组创建 和取值
创建全部以0来填充的数组
shape 数组形状
dtype 数据类型，可选
order 有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。
import numpy as np
shape = (4,3,3)
zero = np.zeros(shape, dtype = float, order = 'C')
print(zero)
[[[0. 0. 0.][0. 0. 0.][0. 0. 0.]][[0. 0. 0.][0. 0. 0.][0. 0. 0.]][[0. 0. 0.][0. 0. 0.][0. 0. 0.]][[0. 0. 0.][0. 0. 0.][0. 0. 0.]]]
创建全部以1来填充的数组
import numpy as np
shape = (4,3,3)
ones = np.ones(shape, dtype = float, order = 'C')
print(ones)
[[[1. 1. 1.][1. 1. 1.][1. 1. 1.]][[1. 1. 1.][1. 1. 1.][1. 1. 1.]][[1. 1. 1.][1. 1. 1.][1. 1. 1.]][[1. 1. 1.][1. 1. 1.][1. 1. 1.]]]
创建指定数据的多维数组
# 三维数组创建 三层列表嵌套
dim3 = np.array([[[100,200,300],[400,500,600],[700,800,900]],[[111,222,333],[444,555,666],[777,888,999]]])
print(dim3,type(dim3))
print('维度',dim3.ndim)
print('形状',dim3.shape,':两块三行三列的数组')
print('类型',dim3.dtype)
[[[100 200 300][400 500 600][700 800 900]][[111 222 333][444 555 666][777 888 999]]] <class 'numpy.ndarray'>
维度 3
形状 (2, 3, 3) :两块三行三列的数组
类型 int32
取值
利用索引取值时
逗号分割的数据块可以理解为是 [ 层 , 行 ,列 ]
然后在每一个数据块里可以使用切片取值
dim3[0][1]
array([400, 500, 600])
dim3[0,0]
array([100, 200, 300])
# 逗号分割的数据块可以理解为是 [ 层 , 行 ,列 ] 然后在每一个数据块里可以使用切片取值
dim3[0:,1,2]
array([600, 666])
dim3[0:,1,]
array([[400, 500, 600],[444, 555, 666]])
从已有的数组创建数组
np.asarray(date, dtype = None, order = None)
date 任意形式的输入参数，可以是，列表, 列表的元组, 元组, 元组的元组, 元组的列表，多维数组
dtype 数据类型，可选。
order 可选，有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。
import numpy as np
date_array = [[1,2],[3,4],[5,6]]
new_date_array = np.asarray(date_array, dtype = int, order = "C")
print(new_date_array)
[[1 2][3 4][5 6]]
下面是截图 就是注意数据的原始样子要是等长的 和正常创建规则一样
文末：为你的学习精神点赞！
学完以后 可以去看下一篇综合练习代码
【日常点滴014】python中学完pandas后的代码练习 附源数据文件
【日常点滴012】python中pandas入门操作方法整理相关推荐
- Python中pandas检查dataframe中是否包含某个字段、或者数据列实战、检查dataframe中是否包含某个字段集合
Python中pandas检查dataframe中是否包含某个字段.或者数据列(column)实战 目录 Python中pandas检查dataframe中是否包含某个字段.或者数据列(column) ...
- python中pandas安装视频教程_详解Python中pandas的安装操作说明(傻瓜版)
很多人来问我pandas的安装(python数据分析里面的必修课) 步骤如下: 安装python的时候,把路径加到系统里,这样,随时可以用pip 路径添加方法: 查找路径: 路径1: 2.例如: 即: ...
- 怎么把竖列中的数相加python_关于python中pandas.DataFrame对行与列求和及添加新行与列示例代码...
pandas是python环境下最有名的数据统计包,而DataFrame翻译为数据框,是一种数据组织方式,这篇文章主要给大家介绍了关于python中pandas.DataFrame对行与列求和及添加新 ...
- python《pandas入门》实现Excel数据字段的拆分
** python<pandas入门>实现Excel数据字段的拆分 ,简单说一下自己为什么写博客,主要原因如下: 1,先简单介绍下自己,我是药学本科毕业,工作几年了.在这几年里做过药物相关 ...
- series 合并pandas_在python中pandas的series合并方法
如下所示: In [3]: import pandas as pd In [4]: a = pd.Series([1,2,3]) In [5]: b = pd.Series([2,3,4]) In [ ...
- python中pandas的数据输出显示设置
python中pandas的数据输出显示设置1 pandas数据分析时经常需要打印输出数据,当数据量大时,输出的展示设置非常重要,好的展示可以帮助更好地理解数据. pandas相关的显示设置函数主要有 ...
- Python中pandas库实现数据缺失值判断isnull()函数
[小白从小学Python.C.Java] [Python全国计算机等级考试] [Python数据分析考试必会题] ● 标题与摘要 Python中pandas库实现数据缺失值判断 isnull()函数 ...
- python中pandas是指什么_Python中的神器Pandas，但是有人说Pandas慢...
原标题:Python中的神器Pandas,但是有人说Pandas慢... 如果你从事大数据工作,用Python的Pandas库时会发现很多惊喜.Pandas在数据科学和分析领域扮演越来越重要的角色,尤 ...
- python中pandas.DataFrame如何对行与列求和以及如何添加新行与列的示例
转载 本文介绍的是python中DataFrame对行与列求和及添加新行与列的相关资料,下面话不多说,来看看详细的介绍吧. 方法如下: 导入模块: from pandas import DataFra ...
最新文章
- mybaties插件生成代码
- fedora22 无法联网的情况下rpm安装gcc5.1
- PostgreSQL教程（二）：SQL语言
- java不同进程的相互唤醒_Java线程生命周期与状态切换
- 与protected成员有关的单元测试方式
- C# JObject转换JSON文件相关处理
- python 列表、字典多排序问题
- android volley 线程,android第三方框架（一）过时的框架volley
- uva 1378 - A Funny Stone Game sg博弈
- 几款脑力训练软件分析与推荐
- WlMAP：突破内网端口转发映射工具
- 【redis】跟我一起动手玩玩redis主从复制和哨兵模式
- 【linux】正点原子linux教程学习
- 西瓜文案：水果西瓜的文案，水果文案西瓜
- 复大华韬会基因博物馆项目论证会在北京大学举行
- luooj1559最强阵容加强版
- 让员工都是决策者！受到丰田集团启发：让企业少花500万的诀窍
- 2017-美团大众点评-安全工程师A/B卷
- 2023河北工业大学计算机考研信息汇总
- egret--龙骨动画的导入和使用
热门文章
- 解决HDF5 library version mismatched error
- python爬虫爬取豆瓣读书
- python语句中的 end=''是什么意思呢
- python爬取cctalk视频_python爬虫urllib使用和进阶 | Python爬虫实战二
- HTML5+CSS3+JS小实例：始终飞向鼠标的纸飞机
- 一位73岁老股民的抄底心经
- 魔兽世界 8.1 服务器维护时间,魔兽世界8.1上线时间 18个主要内容预告
- oracle数据库查看所有表和注释,oracle数据库当前用户下所有表名和表名的注释
- redis连接数合理配置_redis如何进行合理配置，这10种配置参数你必须知道
- 关于windows7开机黑屏的解决办法