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相关数据
- 3.1 数据文件写入和读取
- 3.1.1 写入csv文件
- 3.1.2 读取csv文件
- 3.1.2 读取json数据
- 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()
- 4.数据的合并、筛选、排序
- 4.1 合并
- 4.1.1 concat()
- 4.1.2 merge()
- 4.1.3 合并方法总结:
- 4.2 筛选
- 4.2.1 数据预览
- 4.2.2 开始筛选
- 4.2.3 数据类型转换 to_numeric
- 4.3 排序
- 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 自定义统计方式
- 6.多层索引操作
- 6.1创建
- 6.2 取值
- 6.2.1 loc取值
- 6.2.2 iloc取值
- 6.3 排序
- 7 更改数据
1.series
1.1 series 创建
Series 由索引(index)和列组成,函数如下:
pandas.Series( data, index, dtype, name, copy)
参数说明:
data:一组数据(ndarray 类型)。
index:数据索引标签,如果不指定,默认从 0 开始。
dtype:数据类型,默认会自己判断。
name:设置名称。
copy:拷贝数据,默认为 False。
# 创建Series,使用默认索引
from pandas import Series,DataFrame
ser = Series(data=['杨老师',"浪淘三千",183,'python讲师'])
print(ser)
0 杨老师
1 浪淘三千
2 183
3 python讲师
dtype: object
# 创建Series,使用字典的键作为索引
from pandas import Series,DataFrame
ser = Series(data={"称呼":"杨老师","昵称":"浪淘三千","身高":183,"职业":"python讲师"})
print(ser)
称呼 杨老师
昵称 浪淘三千
身高 183
职业 python讲师
dtype: object
1.2 获取series数据的值
我们可以通过values、index、items等Series的属性来获取各部分的全部数据。
values、index、items返回的对象分别是List、Index、Zip类型的数据,为了方便我们使用和观察数据,可以使用series.index.tolist()和list(series.items())方法转化成List类型。
# 获取series的索引 和 值
from pandas import Series,DataFrame
ser = Series(data={"称呼":"杨老师","昵称":"浪淘三千","身高":183,"职业":"python讲师"})
print(ser)
# 获取数据的值
print(ser.values)
# 获取索引的值
print(ser.index)
print(ser.index.tolist())
# 获取每对索引和值
print(list(ser.items()))
称呼 杨老师
昵称 浪淘三千
身高 183
职业 python讲师
dtype: object
['杨老师' '浪淘三千' 183 'python讲师']
Index(['称呼', '昵称', '身高', '职业'], dtype='object')
['称呼', '昵称', '身高', '职业']
[('称呼', '杨老师'), ('昵称', '浪淘三千'), ('身高', 183), ('职业', 'python讲师')]
# 通过索引下标 和 位置下标 获取数据 位置下标是默认就会有的
from pandas import Series,DataFrame
series = 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])
使用索引下标获取单个数据
杨老师
使用位置下标获取单个数据
浪淘三千
使用索引下标获取多个不连续的数据
职业 python讲师
昵称 浪淘三千
dtype: object
索引下标切片获取连续数据
昵称 浪淘三千
身高 183
职业 python讲师
dtype: object
----下面通过位置下标取切片获取连续数据
---位置下标取切片获取连续数据
昵称 浪淘三千
身高 183
dtype: object
---位置下标取切片获取连续数据
昵称 浪淘三千
身高 183
职业 python讲师
dtype: object
2. 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。
2.1 创建
2.1.1通过二维列表创建
# 通过二维列表创建选手信息表
from pandas import Series,DataFrame
lol_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
2.1.2 用字典格式创建
# 用字典格式创建
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.1.3 列表嵌套字典格式创建
# 用字典格式创建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
2.2 获取datafram相关数据
# 用字典格式创建2 推荐
from pandas import Series,DataFrame
pd.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.info())
# 获取行数和列数
print('df.shape获取行数和列数',df.shape)
# 获取行索引 有手动设置的话 可以获取标签索引,没有设置的话 是获取位置索引
print('df.index.tolist()获取行索引',df.index.tolist())
# 获取列索引
print('df.columns.tolist()获取列索引',df.columns.tolist())
# 获取数据的维度
print('df.ndim获取数据的维度',df.ndim)
# 获取首尾数据 不传入参数默认获取5条
# 获取前两条
head2 = df.head(2)
print('\ndf.head(2)获取前两条\n',head2)
print()
# 获取后10条 不够的话全部获取
df.tail(10)
# df不支持直接通过标签索引获取行数据 但是可以用位置索引来获取
# 通过位置索引切片获取一行
print('\ndf[0:1]通过位置索引切片获取一行\n',df[0:1])
# 通过位置索引切片获取多行 遵循切片规则
print('\ndf[1:3]通过位置索引切片获取多行\n',df[1:3])
# 获取多行里面的某1列 直接取列值即可
print("\ndf[1:3]['ID号']获取多行里面的某1列\n",df[1:3]['ID号'])
# 获取多行里面的某几列 多列要新写在一个列表里
print("\ndf[1:3][['位置','ID号']]获取多行里面的某几列\n",df[1:3][['位置','ID号']])
# 获取DataFrame的列
print("\ndf['位置']获取DataFrame的列\n",df['ID号'])
# 获取DataFrame的多个列 依旧写在嵌套的列表里
print("\ndf[['位置','ID号']]获取DataFrame的多个列\n",df[['位置','ID号']])
# 获取DataFrame的多个列的多个行 递进取值即可 也就是说 可先取到行再递进取列 也可以取到列再递进取行
print("\ndf[['位置','ID号']]获取DataFrame的多个列的多个行\n",df[['位置','ID号']][1:3])
print('\n-----=-=-==---下面是loc 和 iloc 的使用 loc使用标签索引 iloc使用位置索引 -=-=-----\n')
# 获取某一行某一列的数据
print("\ndf.loc['001','位置']获取某一行某一列的数据\n",df.loc['001','位置'])
# 某一行多列的数据
print("\ndf.loc['001',['位置','ID号']]某一行多列的数据\n",df.loc['001',['位置','ID号']])
# 一行所有列
print("\ndf.loc['001',:]\n",df.loc['001',:])
# 选择间隔的多行多列
print("\ndf.loc[['001','003'],['位置','ID号']]选择间隔的多行多列\n",df.loc[['001','003'],['位置','ID号']])
# 选择连续的多行和间隔的多列
print("\ndf.loc['001':'003','位置':'ID号']选择连续的多行和间隔的多列\n",df.loc['001':'003','位置':'ID号'])
# 取一行
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])
# 逐行获取数据 iterrows()
print("\ndf.iterrows()逐行获取数据----=-=-=-=-=-==----\n")
for index,row_data in df.iterrows():
print(index,'\n',row_data)
# 逐列获取数据 iteritems()
print("\ndf.iteritems()逐列获取数据------=-=-=-=----=----\n")
for column_index,column_data in df.iteritems():
print(column_index,'\n',column_data)
<class 'pandas.core.frame.DataFrame'>
Index: 6 entries, 001 to 006
Data columns (total 3 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 位置 6 non-null object
1 ID号 6 non-null object
2 年龄 6 non-null int64
dtypes: int64(1), object(2)
memory usage: 120.0+ bytes
None
df.shape获取行数和列数 (6, 3)
df.index.tolist()获取行索引 ['001', '002', '003', '004', '005', '006']
df.columns.tolist()获取列索引 ['位置', 'ID号', '年龄']
df.ndim获取数据的维度 2
df.head(2)获取前两条
位置 ID号 年龄
001 上单 清清 21
002 打野 无畏 19
df[0:1]通过位置索引切片获取一行
位置 ID号 年龄
001 上单 清清 21
df[1:3]通过位置索引切片获取多行
位置 ID号 年龄
002 打野 无畏 19
003 中单 笑影 23
df[1:3]['ID号']获取多行里面的某1列
002 无畏
003 笑影
Name: ID号, dtype: object
df[1:3][['位置','ID号']]获取多行里面的某几列
位置 ID号
002 打野 无畏
003 中单 笑影
df['位置']获取DataFrame的列
001 清清
002 无畏
003 笑影
004 一诺
005 爱思
006 lang
Name: ID号, dtype: object
df[['位置','ID号']]获取DataFrame的多个列
位置 ID号
001 上单 清清
002 打野 无畏
003 中单 笑影
004 ADC 一诺
005 辅助 爱思
006 教练 lang
df[['位置','ID号']]获取DataFrame的多个列的多个行
位置 ID号
002 打野 无畏
003 中单 笑影
-----=-=-==---下面是loc 和 iloc 的使用 loc使用标签索引 iloc使用位置索引 -=-=-----
df.loc['001','位置']获取某一行某一列的数据
上单
df.loc['001',['位置','ID号']]某一行多列的数据
位置 上单
ID号 清清
Name: 001, dtype: object
df.loc['001',:]
位置 上单
ID号 清清
年龄 21
Name: 001, dtype: object
df.loc[['001','003'],['位置','ID号']]选择间隔的多行多列
位置 ID号
001 上单 清清
003 中单 笑影
df.loc['001':'003','位置':'ID号']选择连续的多行和间隔的多列
位置 ID号
001 上单 清清
002 打野 无畏
003 中单 笑影
df.iloc[1]取一行
位置 打野
ID号 无畏
年龄 19
Name: 002, dtype: object
df.iloc[0:2]取连续多行
位置 ID号 年龄
001 上单 清清 21
002 打野 无畏 19
df.iloc[[0,2],:]取间断的多行
位置 ID号 年龄
001 上单 清清 21
003 中单 笑影 23
df.iloc[:,1]取某一列
001 清清
002 无畏
003 笑影
004 一诺
005 爱思
006 lang
Name: ID号, dtype: object
df.iloc[1,0]取某一个值
打野
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
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
3.1 数据文件写入和读取
3.1.1 写入csv文件
df.to_csv(path_or_buf=’./People_Information.csv’,index=False,encoding=‘utf_8_sig’)
path_or_buf为写入文本文件的路径
在to_csv方法中 将参数index设置为False就可以不存储DataFrame的行索引信息。
# 用字典格式创建2 推荐
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显示乱码
df.to_csv(path_or_buf='LOL风云人物.csv', encoding='utf-8')
# 写入csv,path_or_buf为写入文本文件 windows正常能中文显示
df.to_csv(path_or_buf='LOL风云人物2.csv', encoding='utf-8-sig')
# 写入csv,path_or_buf为写入文本文件 windows正常能中文显示
df.to_csv(path_or_buf='LOL风云人物3.csv', encoding='gbk')
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-w29TwGQ3-1628503054924)(attachment:image.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AvbdFAym-1628503054928)(attachment:image-2.png)]
3.1.2 读取csv文件
read_csv()读取csv文件,read_excel()读取Excel文件,read_json()读取json文件数据,路径可以是URL链接
读取出来的数据是DataFrame类型,默认会将文件中的第一行作为数据的列索引
一个Excel文件可以创建多个表,然后在不同的表中存储不同数据。但是要注意csv文件不存在多个sheet的问题。
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风云人物2.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)
3.1.2 读取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'>
3.重复数据、空值的处理
如果文件的单元格中没有值时,在使用pandas读取后就会用NaN表示,也就是我们常说的空值。
3.1 空值删除
3.1.1 dropna()
dropna()是删除空值数据的方法,默认将只要含有NaN的整行数据删掉 通过参数设置也可以删除整列
DataFrame.dropna(axis=0, how=‘any’, thresh=None, subset=None, inplace=False)
参数说明:
axis:默认为 0,表示逢空值剔除整行,如果设置参数 axis=1 表示逢空值去掉整列。
how:默认为 ‘any’ 如果一行(或一列)里任何一个数据有出现 NA 就去掉整行,如果设置 how=‘all’ 一行(或列)都是 NA 才去掉这整行。
thresh:设置需要多少非空值的数据才可以保留下来的。
subset:设置想要检查的列。如果是多个列,可以使用列名的 list 作为参数。
inplace:如果设置 True,将计算得到的值直接覆盖之前的值并返回 None,修改的是源数据。
import pandas as pd
df = pd.read_csv('property-data.csv')
print(df)
df1 = df.dropna()
print('以下是删除带空值的所有的行后的结果')
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 --
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
以下是删除带空值的所有的行后的结果
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
3.2 空值填充
3.2.1 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')
print(df)
# 用常数填充fillna
print("\n用常数填充fillna\n")
print(df.fillna(0))
# 用一列的平均值填充
print("\n用一列的平均值填充 注意NaN的计算结果还是NaN\n")
print(df.fillna(df.mean()))
print("\n用上一行的值来填充\n")
# 用上一行的值来填充 参数值:ffill
print(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 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
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
用一列的平均值填充
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
用上一行的值来填充
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
3.3.删除数据
3.3.1 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)
# 删除第0行和第1行
print('\n删除第0行和第1行\n')
df2 = df.drop(labels=[0,1],axis=0)
print(df2)
# 删除列名为1990的列
print('\n删除名为NUM_BEDROOMS的那一列\n')
df3 = df.drop(axis=1,columns="NUM_BEDROOMS")
print(df3)
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行
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的那一列
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
3.4.数据去重
3.4.1 duplicated()|
利用duplicated()函数可以返回每一行判断是否重复的结果(重复则为True)
import pandas as pd
person = {
"name": ['后羿', '嫦娥', '哪吒', '八戒', '哪吒'],
"age": [5000, 4000, 4000, 4300,4000] }
df = pd.DataFrame(person)
print(df)
print('以下是 查询 重复值的结果')
print(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
3.4.2 drop_duplicates()
可以使用drop_duplicates()将重复的数据行进行删除,默认全列对比
指定列字段对比 inplace依旧可以设置是生成新的表 还是直接修改原来的表
df.drop_duplicates([‘ST_NAME’],inplace=False)
import pandas as pd
person = {
"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
4.数据的合并、筛选、排序
4.1 合并
数据合并主要包括下面两种操作:
轴向连接(concatenation):pd.concat()可以沿一个轴将多个DataFrame对象连接在一起,形成一个新的DataFrame对象。
融合(merging):pd.merge()方法可以根据一个或多个键将不同DataFrame中的行连接起来。
4.1.1 concat()
concat()函数可以将数据根据不同的轴进行合并。join=‘outer’ 过程是取并集,缺失的会用NaN填充
如果两个表的index都没有实际含义,使用ignore_index参数,置true,重新整理一个新的index
pd.concat([df1,df2],axis=0,join=‘outer’,ignore_index=True)
参数解释:
objs: series、dataframe或者是panel构成的序列list。
axis: 需要合并链接的轴,0是行,上下摞行,同样列名的会放在同一列,1是列,左右摞列,默认是0。摞不到的地方都默认为NaN
join:连接的方式 inner,或者outer,默认是outer。inner连接后的结果不存在空值
# outer()连接
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)
print('下面是df3 concat axis=0 outer的结果')
df3 = pd.concat([df1,df2],axis=0,join='outer',ignore_index=True)
print(df3)
print('下面是df4 concat axis=1 outer的结果')
df4 = pd.concat([df1,df2],axis=1,join='outer',ignore_index=True)
print(df4)
A B C
0 A0 B0 C0
1 A1 B1 C1
2 A2 B2 C2
3 A3 B3 C3
B 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
下面是df3 concat axis=0 outer的结果
A B C D E
0 A0 B0 C0 NaN NaN
1 A1 B1 C1 NaN NaN
2 A2 B2 C2 NaN NaN
3 A3 B3 C3 NaN NaN
4 NaN B0 C0 D0 E0
5 NaN B1 C1 D1 E1
6 NaN B2 C2 D2 E2
7 NaN B3 C3 D3 E3
8 NaN B4 C4 D4 E4
下面是df4 concat axis=1 outer的结果
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
4 NaN NaN NaN B4 C4 D4 E4
# 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)
print('下面是df3的concat axis=0 inner结果 只是把相同列字段取交集,并没有对具体数据取交集')
df3 = pd.concat([df1,df2],axis=0,join='inner',ignore_index=True)
print(df3)
print('下面是df4的concat axis=1 inner结果 只是把都有数据的行和列展示 ,也没有对具体数据取交集')
df4 = pd.concat([df1,df2],axis=1,join='inner',ignore_index=True)
print(df4)
A B C
0 A0 B0 C0
1 A1 B1 C1
2 A2 B2 C2
3 A3 B3 C3
B 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
下面是df3的concat axis=0 inner结果 只是把相同列字段取交集,并没有对具体数据取交集
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
下面是df4的concat axis=1 inner结果 只是把都有数据的行和列展示 ,也没有对具体数据取交集
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
4.1.2 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)
print('下面是df3的merge inner结果')
df3 = pd.merge(df1,df2,how='inner')
print(df3)
print('下面是df4的merge outer结果')
df4 = pd.merge(df1,df2,how='outer')
print(df4)
A B C
0 A0 B0 C0
1 A1 B1 C1
2 A2 B2 C2
3 A3 B3 C3
B 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
下面是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
下面是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
4.1.3 合并方法总结:
concat()结果 是数据摞列,inner 时只取字段交集,不取相应的数据交集。 outer时 不取字段交集,也不取数据并集,只是简单摞列,没有的用NaN填充
merge()结果 是数据交集,inner 时既取字段交集,也取相应的数据交集。outer时 取完字段交集,再取相应数据并集,没有的用NaN填充
4.2 筛选
4.2.1 数据预览
# 数据预览
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)
2
id 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]
4.2.2 开始筛选
# 筛选出 最低薪资大于10K的数据
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())
# 原来的数据类型是字符串的 我们需要跟数字比大小 就要把原来的某列数据转化为数字后再比较
# to_numeric 只能处理字符串型的数字
df['salary_min'] = pd.to_numeric(df['salary_min'])
print('-=-=-------------=-=-=-再次观察数据结构 发现salary_min列数据类型已经成了int64-=-=-------------=-=-=')
print(df.info())
print('-=-=-------------=-=-=筛选出最低薪资大于10K的数据-=-=-------------=-=-=--')
salary_bt_10 = df['salary_min'] > 10
print(salary_bt_10)
print('-=-=-------------=-=-=打印最低薪资大于10K的数据-=-=-=-=--',df[salary_bt_10].shape)
print(df[salary_bt_10])
<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 object
2 city_name 7598 non-null object
3 position_name 7598 non-null object
4 company_name 7598 non-null object
5 areas 6532 non-null object
6 street 6522 non-null object
7 company_style 7598 non-null object
8 scale 7598 non-null object
9 xue_li 7598 non-null object
10 work_experience 7598 non-null object
11 financing_situation 7598 non-null object
12 benefits 7598 non-null object
13 salary 7598 non-null object
14 salary_month 7598 non-null object
15 salary_min 7598 non-null object
16 salary_max 7598 non-null object
17 average_salary 7598 non-null object
dtypes: int64(1), object(17)
memory usage: 623.3+ KB
None
-=-=-------------=-=-=-再次观察数据结构 发现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 object
2 city_name 7598 non-null object
3 position_name 7598 non-null object
4 company_name 7598 non-null object
5 areas 6532 non-null object
6 street 6522 non-null object
7 company_style 7598 non-null object
8 scale 7598 non-null object
9 xue_li 7598 non-null object
10 work_experience 7598 non-null object
11 financing_situation 7598 non-null object
12 benefits 7598 non-null object
13 salary 7598 non-null object
14 salary_month 7598 non-null object
15 salary_min 7598 non-null int64
16 salary_max 7598 non-null object
17 average_salary 7598 non-null object
dtypes: int64(2), object(16)
memory usage: 653.0+ KB
None
-=-=-------------=-=-=筛选出最低薪资大于10K的数据-=-=-------------=-=-=--
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
-=-=-------------=-=-=打印最低薪资大于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]
# 多条件筛选 筛选出 最低薪资大于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])
4.2.3 数据类型转换 to_numeric
字符串类型转数字类型 这样方便比较薪资大小
# 原来的数据类型是字符串的 我们需要跟数字比大小 就要把原来的某列数据转化为数字后再比较
# to_numeric 只能处理字符串型的数字
df['salary_min'] = pd.to_numeric(df['salary_min'])
print('-=-=-------------=-=-=-再次观察数据结构 发现salary_min列数据类型已经成了int64-=-=-------------=-=-=')
print(df.info())
4.3 排序
可以使用sort_index()、sort_values()两个方法对数据进行排序,并且这两个方法Series和DataFrame都支持。
DataFrame的sort_index( )方法是按照行索引进行排序,sort_values()可以指定具体列进行排序。
import pandas as pd
df = pd.read_csv('BOSS直聘岗位数据.csv',index_col='salary_min')
df.sort_index(inplace=True,ascending=True)
df.head()
id | search_word | city_name | position_name | company_name | areas | street | company_style | scale | xue_li | work_experience | financing_situation | benefits | salary | salary_month | salary_max | average_salary | |
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
salary_min | |||||||||||||||||
1 | 16894 | java | 天津 | Java | 中子星 | 西青区 | 侯台 | 计算机软件 | 0-20人 | 大专 | 经验不限 | 不需要融资 | 五险一金,带薪年假,年终奖,全勤奖 | 1-3 | 12薪 | 3 | 2 |
1 | 16965 | java | 天津 | Java实习生 | 马尾草 | 西青区 | 大学城 | 互联网 | 20-99人 | 大专 | 经验不限 | 未融资 | 节日福利,年终奖,员工旅游,五险一金,带薪年假 | 1-2 | 12薪 | 2 | 1.5 |
1 | 13784 | python | 苏州 | Python老师(周末兼职) | 青创赢 | 苏州工业园区 | 苏州中心商场 | 在线教育 | 20-99人 | 本科 | 1-3年 | 未融资 | 五险一金,餐补,年终奖,通讯补贴,交通补助 | 1-2 | 12薪 | 2 | 1.5 |
1 | 18020 | java | 厦门 | Java实习生 | 谷点教育科技 | 思明区 | 软件园 | 互联网 | 20-99人 | 本科 | 经验不限 | 不需要融资 | 节日福利,全勤奖,年终奖,加班补助,五险一金,餐补,零食下午茶,员工旅游,股票期权,住房补贴... | 1-6 | 12薪 | 6 | 3.5 |
1 | 11783 | python | 北京 | python研发实习生 | 中国科学院软件研究所 | NaN | NaN | 计算机软件 | 1000-9999人 | 本科 | 经验不限 | 不需要融资 | 年终奖,定期体检,带薪年假,五险一金,节日福利 | 1-2 | 12薪 | 2 | 1.5 |
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
5.分组和统计
5.1 分组
5.1.1 groupby(‘列名’)
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>
5.1.2 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
5.1.3 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())
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]
5.1.4 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, ...]}
5.1.5 多列分组和取值
多列分组的分组方式要传入一个列表 列表里的元素是字段名
多列分组的取值方式要传入一个元组 元组里的元素是字段名下面的元素
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年')))
# 会报错
# groups['上海']
city_name work_experience
上海 1-3年 142
10年以上 1
1年以内 5
3-5年 255
5-10年 74
...
长沙 1-3年 172
1年以内 12
3-5年 150
5-10年 93
经验不限 115
Length: 80, dtype: int64
id search_word city_name position_name company_name areas street company_style \
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 轻轻教育 徐汇区 徐家汇 培训机构
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 salary_month \
299 节日福利,通讯补贴,补充医疗保险,住房补贴,带薪年假,餐补,员工旅游,加班补助,定期体检,年... 20-40 16薪
302 员工旅游,定期体检,五险一金,节日福利,带薪年假,年终奖,补充医疗保险...... 10-15 13薪
303 五险一金,年终奖 20-35 15薪
304 员工旅游,股票期权,带薪年假,餐补,年终奖,五险一金,节日福利,绩效奖金...... 15-30 15薪
307 团队nice,不打卡,零食下午茶,五险一金,交通补助,补充医疗保险,年终奖,节日福利,股票期... 15-30 12薪
... ... ... ...
4133 交通补助,老板Nice,五险一金,零食下午茶,餐补,定期体检,员工旅游,带薪年假,年终奖,补... 20-40 16薪
4138 加班补助,十三薪,五险一金,餐补,定期体检,股票期权,补充医疗保险,带薪年假,年终奖,节日福... 11-18 13薪
4169 股票期权,五险一金,节日福利,补充医疗保险,员工旅游,定期体检,免费班车,年终奖,带薪年假,... 25-40 16薪
4200 员工旅游,节日福利,免费班车,股票期权,补充医疗保险,带薪年假,年终奖,包吃,五险一金,定期... 20-40 16薪
4208 节日福利,五险一金,带薪年假,年终奖 12-24 12薪
salary_min salary_max average_salary
299 20 40 30
302 10 15 12.5
303 20 35 27.5
304 15 30 22.5
307 15 30 22.5
... ... ... ...
4133 20 40 30
4138 11 18 14.5
4169 25 40 32.5
4200 20 40 30
4208 12 24 18
[142 rows x 18 columns]
5.2 常用统计函数:mean()、max()、min()
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ymXOb823-1628503054930)(attachment:image.png)]
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)
print(df[df['average_salary'] >= 100])
print(df[df['average_salary'] <= 5])
175.0
1.5
18.220584364306397
17.0
7598
id search_word city_name position_name company_name areas street \
4610 16380 java 深圳 Java高级架构师(专家级) 腾讯 南山区 科技园
company_style scale xue_li work_experience financing_situation \
4610 互联网 10000人以上 本科 5-10年 已上市
benefits salary salary_month salary_min \
4610 免费班车,节日福利,五险一金,定期体检,补充医疗保险,年终奖,带薪年假,餐补 150-200 16薪 150
salary_max average_salary
4610 200 175.0
id search_word city_name position_name company_name areas street \
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 学无悔教育科技有... 江北区 观音桥
company_style 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 salary_month \
13 年终奖,定期体检,带薪年假,五险一金,节日福利 1-2 12薪
360 交通补助,节日福利,股票期权,定期体检,通讯补贴,零食下午茶,补充医疗保险,五险一金,年终奖... 4-5 12薪
578 员工旅游,年终奖,零食下午茶,全勤奖,五险,节日福利 2-3 12薪
674 带薪年假,五险一金,加班补助,十三薪,定期体检,员工旅游,餐补,交通补助,零食下午茶,年终奖... 3-6 12薪
750 节日福利,零食下午茶,带薪年假,员工旅游 3-5 12薪
... ... ... ...
7242 全勤奖,节日福利,员工旅游,五险一金,带薪年假,交通补助 3-6 12薪
7342 带薪年假,五险一金,股票期权 3-5 12薪
7346 零食下午茶,年终奖,股票期权,员工旅游,带薪年假,五险一金,生日福利 3-5 12薪
7357 五险一金,股票期权,年终奖,带薪年假,节日福利 4-6 12薪
7501 年终奖,通讯补贴,交通补助,加班补助,带薪年假,全勤奖,股票期权 3-6 12薪
salary_min salary_max average_salary
13 1 2 1.5
360 4 5 4.5
578 2 3 2.5
674 3 6 4.5
750 3 5 4.0
... ... ... ...
7242 3 6 4.5
7342 3 5 4.0
7346 3 5 4.0
7357 4 6 5.0
7501 3 6 4.5
[110 rows x 18 columns]
5.3 聚合统计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:
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)
print(y)
break
1.5
id search_word city_name position_name company_name areas \
13 11783 python 北京 python研发实习生 中国科学院软件研究所 NaN
2014 13784 python 苏州 Python老师(周末兼职) 青创赢 苏州工业园区
5195 16965 java 天津 Java实习生 马尾草 西青区
6519 18289 java 长沙 Java 思洋 岳麓区
street company_style scale xue_li work_experience \
13 NaN 计算机软件 1000-9999人 本科 经验不限
2014 苏州中心商场 在线教育 20-99人 本科 1-3年
5195 大学城 互联网 20-99人 大专 经验不限
6519 麓谷 互联网 100-499人 大专 经验不限
financing_situation benefits salary \
13 不需要融资 年终奖,定期体检,带薪年假,五险一金,节日福利 1-2
2014 未融资 五险一金,餐补,年终奖,通讯补贴,交通补助 1-2
5195 未融资 节日福利,年终奖,员工旅游,五险一金,带薪年假 1-2
6519 不需要融资 年终奖,零食下午茶,节日福利,通讯补贴,带薪年假,交通补助,员工旅游,股票期权 1-2
salary_month salary_min salary_max average_salary
13 12薪 1 2 1.5
2014 12薪 1 2 1.5
5195 12薪 1 2 1.5
6519 12薪 1 2 1.5
5.4 自定义统计方式
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其实就是传进来的要统计的某一列的数据
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
6.多层索引操作
6.1创建
# 一般方式(比较麻烦点)
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
# 调用方法创建 pd.MultiIndex.from_product([列表])
import pandas as pd
import numpy as np
data = 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)
语文 数学 英语
张三 期中 57 20 4
期末 51 67 99
李四 期中 79 97 94
期末 79 72 56
王五 期中 26 5 38
期末 5 62 68
6.2 取值
6.2.1 loc取值
# 回顾DataFrame 取值
import pandas as pd
import numpy as np
data = 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)
print(df['语文'])
print('\n---切片取值 发现并不是很理想')
print(df[1:3]['数学'])
print('\n---loc取值')
print(df.loc['张三'])
print('\n---loc嵌套取值')
print(df.loc['张三'].loc['期中'])
print(df.loc['张三','期中'])
print(123456789887456)
print(df.loc['张三','期中']['语文'])
语文 数学 英语
张三 期中 56 5 37
期末 49 41 86
李四 期中 12 30 90
期末 57 68 74
王五 期中 51 63 14
期末 18 95 47
张三 期中 56
期末 49
李四 期中 12
期末 57
王五 期中 51
期末 18
Name: 语文, dtype: int32
---切片取值 发现并不是很理想
张三 期末 41
李四 期中 30
Name: 数学, dtype: int32
---loc取值
语文 数学 英语
期中 56 5 37
期末 49 41 86
---loc嵌套取值
语文 56
数学 5
英语 37
Name: 期中, dtype: int32
语文 56
数学 5
英语 37
Name: (张三, 期中), dtype: int32
123456789887456
56
6.2.2 iloc取值
# 回顾DataFrame取值
import pandas as pd
import numpy as np
data = 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]取一行
语文 57
数学 32
英语 7
Name: (张三, 期末), dtype: int32
df.iloc[0:2]取连续多行
语文 数学 英语
张三 期中 21 89 80
期末 57 32 7
df.iloc[[0,2],:]取间断的多行
语文 数学 英语
张三 期中 21 89 80
李四 期中 29 36 73
df.iloc[:,1]取某一列
张三 期中 89
期末 32
李四 期中 36
期末 85
王五 期中 34
期末 66
Name: 数学, dtype: int32
df.iloc[1,0]取某一个值
57
6.3 排序
import pandas as pd
import numpy as np
data = 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
7 更改数据
原理就是 取到值后重新赋值即可
import pandas as pd
import numpy as np
data = 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)
ying = df['英语']>50
print(ying)
df['英语'][ying] += 80
yu = df['语文']<50
df['语文'][yu] = '我是语文'
print(df)
语文 数学 英语
张三 期中 44 13 27
期末 45 92 91
李四 期中 85 0 83
期末 51 20 55
王五 期中 11 25 49
期末 7 1 36
张三 期中 False
期末 True
李四 期中 True
期末 True
王五 期中 False
期末 False
Name: 英语, dtype: bool
语文 数学 英语
张三 期中 我是语文 13 27
期末 我是语文 92 171
李四 期中 85 0 163
期末 51 20 135
王五 期中 我是语文 25 49
期末 我是语文 1 36