配套数据文件
链接：https://pan.baidu.com/s/1ngzaZygHOIQuNPHtYjpFfA
提取码：lang
微信号：guoguoma2727扫码免费领取用友软件使用权
复制微信号
开讲之前先简单铺垫一下：
series和dataframe是pandas的两种基本数据类型
series就是一列（带索引的）数据，多个series构成dataframe
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)
# 查看索引
print('-------查看索引-----------')
print(ser.index)
0 杨老师
1 浪淘三千
2 183
3 python讲师
dtype: object
-------查看索引-----------
RangeIndex(start=0, stop=4, step=1)
# 创建Series，使用字典的键作为索引
from pandas import Series,DataFrame
ser = Series(data={"称呼":"杨老师","昵称":"浪淘三千","身高":183,"职业":"python讲师"})
print(ser)
# 查看索引
print('-------查看索引-- 注意这里和上面不一样---------')
print(ser.index)
称呼 杨老师
昵称 浪淘三千
身高 183
职业 python讲师
dtype: object
-------查看索引-- 注意这里和上面不一样---------
Index(['称呼', '昵称', '身高', '职业'], dtype='object')
# 创建Series，使用字典的键作为索引
from pandas import Series,DataFrame
ser3 = Series({"称呼":"杨老师","昵称":"浪淘三千","身高":183,"职业":"python讲师"})
print(ser3)
# 查看索引
print('-------查看索引-----------')
print(ser3.index)
称呼 杨老师
昵称 浪淘三千
身高 183
职业 python讲师
dtype: object
-------查看索引-----------
Index(['称呼', '昵称', '身高', '职业'], dtype='object')
我们可以通过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,DataFrame
ser = 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讲师']
['杨老师', '浪淘三千', 183, 'python讲师']
['杨老师', '浪淘三千', 183, 'python讲师']
Index(['称呼', '昵称', '身高', '职业'], dtype='object')
['称呼', '昵称', '身高', '职业']
[('称呼', '杨老师'), ('昵称', '浪淘三千'), ('身高', 183), ('职业', 'python讲师')]
通过索引下标（标签索引） 和 位置下标（位置索引）都可以获取series种的数据，获取连续数据可以用切片。不连续数据需要用嵌套列表的形式
看下面例子
# 通过索引下标（标签索引） 和 位置下标（位置索引） 获取数据 位置下标是默认就会有的
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])
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（数据表）是一种 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,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
# 用字典格式创建 字典的值 应该拥有相同的长度
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
# 用字典格式创建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)
位置 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)
# 同样不传参数是默认获取后5条数据
df.tail()
# 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 中单 笑影 23
df[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 中单 笑影
df
# 取一行
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
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打开都是正常显示
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)
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变 打抱不平
id name skill likes
0 A001 后羿 射箭 打猎
1 A002 泰罗 变成光 打怪兽
2 A003 孙悟空 72变 打抱不平
如果文件的单元格中没有值时，在使用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
# 删除带空值的所有的行
df1 = df_csv.dropna()
print('以下是删除带空值的所有的行后的结果')
df1
以下是删除带空值的所有的行后的结果
# 删除‘OWN_OCCUPIED’列中带空值的所有的行
df2 = df_csv.dropna(subset = ['OWN_OCCUPIED'],)
print('以下是删除‘OWN_OCCUPIED’列中带空值的所有的行后的结果 注意第6行没了')
df2
以下是删除‘OWN_OCCUPIED’列中带空值的所有的行后的结果
对于空值我们可以将整条数据删除，也可以使用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
# 用常数填充fillna
print("\n用常数填充fillna\n")
df.fillna(0)
用常数填充fillna
# 用一列的平均值填充
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
print("\n用上一行的值来填充\n")
# 用上一行的值来填充 参数值：ffill
df.fillna(method='ffill',axis=0)
用上一行的值来填充
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()函数可以判断每一行是否重复，并返回布尔结果（重复则为True)
注意这个返回值是series类型 ，可以当作整个dataframe的布尔索引
import pandas as pd
person = {
"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
可以使用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
数据合并主要包括下面两种操作：
轴向连接（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 W3
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
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的结果
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 W3
B 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的结果
‘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 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
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
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 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
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
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
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
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)
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]
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())
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
# 原来的数据类型是字符串的 我们需要跟数字比大小 就要把原来的某列数据转化为数字后再比较
# to_numeric 只能处理字符串型的数字
df['salary_min'] = pd.to_numeric(df['salary_min'])
print('-=-=-------------=-=-=-再次观察数据结构 发现salary_min列数据类型已经成了int64-=-=-------------=-=-=')
print(df.info())
-=-=-------------=-=-=-再次观察数据结构 发现salary_min列数据类型已经成了int64-=-=-------------=-=-=
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
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'] 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()
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()不能链式重复使用 想多重分组 可以用 [‘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)
用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())
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')
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('北京'))
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 的结果是一个字典，字典的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年 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 \
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]
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
就是把多个统计方法 放到一起去处理
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
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
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
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
# 调用方法创建 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)
语文 数学 英语
张三 期中 10 47 76
期末 52 86 0
李四 期中 76 84 79
期末 51 78 10
王五 期中 61 62 54
期末 67 19 21
# 回顾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)
语文 数学 英语
张三 期中 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
# 回顾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]取一行
语文 39
数学 28
英语 14
Name: (张三, 期末), dtype: int32
df.iloc[0:2]取连续多行
语文 数学 英语
张三 期中 61 45 2
期末 39 28 14
df.iloc[[0,2],:]取间断的多行
语文 数学 英语
张三 期中 61 45 2
李四 期中 97 19 27
df.iloc[:,1]取某一列
张三 期中 45
期末 28
李四 期中 19
期末 70
王五 期中 19
期末 33
Name: 数学, dtype: int32
df.iloc[1,0]取某一个值
39
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
# 字符串类型转数字类型 这样方便比较薪资大小
# 原来的数据类型是字符串的 我们需要跟数字比大小 就要把原来的某列数据转化为数字后再比较
# to_numeric 只能处理字符串型的数字
df['salary_min'] = pd.to_numeric(df['salary_min'])
print('-=-=-------------=-=-=-再次观察数据结构 发现salary_min列数据类型已经成了int64-=-=-------------=-=-=')
print(df.info())
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')
pd.to_datetime('2021/1/1').to_pydatetime()
# 转成datetime类型后就可以用datetime库的方法处理了
datetime.datetime(2021, 1, 1, 0, 0)
常用用的转换对象包括：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
RangeIndex: 6 entries, 0 to 5
Data columns (total 2 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 金币 6 non-null object
1 金币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
将年薪里的 羊角号去掉 并转换为数字类型
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())
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 object
5 年薪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
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 object
5 年薪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
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 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
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 float64
5 年薪2 6 non-null int64
dtypes: float64(1), int64(3), object(2)
memory usage: 304.0+ bytes
原理就是 取到值后重新赋值即可
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)
语文 数学 英语
张三 期中 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['语文']