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

【日常点滴012】python中pandas入门操作方法整理

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 更改数据

热门文章