只需8招，搞定Pandas数据筛选与查询
今天聊聊Pandas数据筛选与查询的一些操作，在数据分析的过程中通常要对数据进行清洗与处理，而其中比较重要和常见的操作就有对数据进行筛选与查询。
目录：
1. 案例数据预览
2. 基础操作
2.1. 切片[]
2.2. 索引选择.iloc与.loc
2.3. 元素选择.iat与.at
2.4. get与truncate
3. 进阶操作
3.1. 逻辑筛选
3.2. 函数筛选
3.3. query
3.4. filter
1. 案例数据预览
本次案例，我们继续采用之前用到过的各地区GDP数据，数据信息大致如下，后台回复GDP可以获取哈。
In [1]: import pandas as pd
In [2]: df = pd.read_excel(r'各地区生产总值.xlsx')
In [3]: df.head()
Out[3]:
地区 2020年 2019年 2018年 2017年 2016年
0 北京市 36102.6 35445.1 33106.0 29883.0 27041.2
1 天津市 14083.7 14055.5 13362.9 12450.6 11477.2
2 河北省 36206.9 34978.6 32494.6 30640.8 28474.1
3 山西省 17651.9 16961.6 15958.1 14484.3 11946.4
4 内蒙古自治区 17359.8 17212.5 16140.8 14898.1 13789.3
In [4]: df.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 32 entries, 0 to 31
Data columns (total 6 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 地区 32 non-null object
1 2020年 31 non-null float64
2 2019年 31 non-null float64
3 2018年 31 non-null float64
4 2017年 31 non-null float64
5 2016年 31 non-null float64
dtypes: float64(5), object(1)
memory usage: 1.6+ KB
我们看看描述统计情况，然后在后续做筛选查询的时候好演示
In [5]: df.describe()
Out[5]:
2020年 2019年 2018年 2017年 2016年
count 31.000000 31.000000 31.000000 31.000000 31.000000
mean 32658.551613 31687.758065 29487.661290 26841.819355 24224.148387
std 26661.811640 25848.652250 24136.181387 22161.575235 20008.278500
min 1902.700000 1697.800000 1548.400000 1349.000000 1173.000000
25% 13940.650000 13826.300000 13104.700000 12381.800000 11634.800000
50% 25115.000000 24667.300000 22716.500000 20210.800000 18388.600000
75% 42612.500000 41110.350000 37508.750000 33835.250000 30370.250000
max 110760.900000 107986.900000 99945.200000 91648.700000 82163.200000
可以看到，有效数据有30多条，为了让数据显示好一点，我们可以设置最多显示6行
In [6]: pd.set_option('display.max_rows', 6) #最多显示6行
In [7]: df
Out[7]:
地区 2020年 2019年 2018年 2017年 2016年
0 北京市 36102.6 35445.1 33106.0 29883.0 27041.2
1 天津市 14083.7 14055.5 13362.9 12450.6 11477.2
2 河北省 36206.9 34978.6 32494.6 30640.8 28474.1
.. ... ... ... ... ... ...
29 宁夏回族自治区 3920.5 3748.5 3510.2 3200.3 2781.4
30 新疆维吾尔自治区 13797.6 13597.1 12809.4 11159.9 9630.8
31 台湾省 NaN NaN NaN NaN NaN
[32 rows x 6 columns]
接下来，我们开始演示数据的筛选与查询吧
2. 基础操作
一般来说，数据筛选有选择行、列或者指定位置的值等
2.1. 切片[]
切片这玩意就和python的列表数据的切片操作很相似
选择某一列
注意：如果列名为 2020年或者2020 年，则无法采用属性形式，因为这种操作的变量名不能以数字开头或存在空格
df['地区'] # 切片形式
Out[8]:
0 北京市
1 天津市
2 河北省
29 宁夏回族自治区
30 新疆维吾尔自治区
31 台湾省
Name: 地区, Length: 32, dtype: object
In [9]: df.地区 # 属性形式
Out[9]:
0 北京市
1 天津市
2 河北省
...
29 宁夏回族自治区
30 新疆维吾尔自治区
31 台湾省
Name: 地区, Length: 32, dtype: object
In [10]: # 如果列名为 2020年或者2020 年，则无法采用属性形式，因为这种操作的变量名不能以数字开头或存在空格
...: df.2020年
File "C:\Users\Gdc\AppData\Local\Temp/ipykernel_6832/3948025585.py", line 2
df.2020年
^
SyntaxError: invalid syntax
切片操作
切片里是索引位置，筛选的是对应的行 同样如果我们在切片里是列名组成的列表，则可以筛选出这些列 对于只有一列的情况，切片 []是列名构成的列表返回结果类型分别是DataFrame，反之则是Series
In [11]: df[:2] # 前两行数据
Out[11]:
地区 2020年 2019年 2018年 2017年 2016年
0 北京市 36102.6 35445.1 33106.0 29883.0 27041.2
1 天津市 14083.7 14055.5 13362.9 12450.6 11477.2
In [12]: df[6:8] # 索引6-7 行数据（注意这里索引是从0开始的）
Out[12]:
地区 2020年 2019年 2018年 2017年 2016年
6 吉林省 12311.3 11726.8 11253.8 10922.0 10427.0
7 黑龙江省 13698.5 13544.4 12846.5 12313.0 11895.0
In [13]: df[:16:2] # 前15行 隔2行取
Out[13]:
地区 2020年 2019年 2018年 2017年 2016年
0 北京市 36102.6 35445.1 33106.0 29883.0 27041.2
2 河北省 36206.9 34978.6 32494.6 30640.8 28474.1
4 内蒙古自治区 17359.8 17212.5 16140.8 14898.1 13789.3
.. ... ... ... ... ... ...
10 浙江省 64613.3 62462.0 58002.8 52403.1 47254.0
12 福建省 43903.9 42326.6 38687.8 33842.4 29609.4
14 山东省 73129.0 70540.5 66648.9 63012.1 58762.5
[8 rows x 6 columns]
In [14]: df[::-1] # 倒序
Out[14]:
地区 2020年 2019年 2018年 2017年 2016年
31 台湾省 NaN NaN NaN NaN NaN
30 新疆维吾尔自治区 13797.6 13597.1 12809.4 11159.9 9630.8
29 宁夏回族自治区 3920.5 3748.5 3510.2 3200.3 2781.4
.. ... ... ... ... ... ...
2 河北省 36206.9 34978.6 32494.6 30640.8 28474.1
1 天津市 14083.7 14055.5 13362.9 12450.6 11477.2
0 北京市 36102.6 35445.1 33106.0 29883.0 27041.2
[32 rows x 6 columns]
In [15]: # 我们看到刚才在上述切片里是索引位置，筛选的是对应的行；同样如果我们在切片里是列名组成的列表，则可以筛选出这些列
...: df[['地区','2016年']]
Out[15]:
地区 2016年
0 北京市 27041.2
1 天津市 11477.2
2 河北省 28474.1
.. ... ...
29 宁夏回族自治区 2781.4
30 新疆维吾尔自治区 9630.8
31 台湾省 NaN
[32 rows x 2 columns]
In [16]: # 对于只有一列的情况，以下两种形式下返回结果类型分别是DataFrame和Series
...: df[['地区']]
Out[16]:
地区
0 北京市
1 天津市
2 河北省
.. ...
29 宁夏回族自治区
30 新疆维吾尔自治区
31 台湾省
[32 rows x 1 columns]
In [17]: df['地区']
Out[17]:
0 北京市
1 天津市
2 河北省
...
29 宁夏回族自治区
30 新疆维吾尔自治区
31 台湾省
Name: 地区, Length: 32, dtype: object
2.2. 索引选择.iloc与.loc
按照索引有两种筛选方式，iloc和loc
df.iloc[行表达式, 列表达式]，两个表达式只支持数字切片形式：行表达式筛选行、列表达式筛选列df.loc[行表达式, 列表达式]，两个表达式其实是对行列索引名称的选择：行表达式筛选行、列表达式筛选列
当然，这两种筛选方式的表达式也支持条件
iloc[]
大家可以根据方法名称来区分是针对自然索引位置 还是 索引名称，比如iloc多个i嘛，i就是数字码，所以它针对的是自然索引位置
In [18]: df.iloc[0] # 返回是Series，0是自然索引位置
Out[18]:
地区 北京市
2020年 36102.6
2019年 35445.1
2018年 33106.0
2017年 29883.0
2016年 27041.2
Name: 0, dtype: object
In [19]: df.iloc[[0]] # 返回是一行，0是自然索引位置
Out[19]:
地区 2020年 2019年 2018年 2017年 2016年
0 北京市 36102.6 35445.1 33106.0 29883.0 27041.2
In [20]: df.iloc[:2] # 前两行数据
Out[20]:
地区 2020年 2019年 2018年 2017年 2016年
0 北京市 36102.6 35445.1 33106.0 29883.0 27041.2
1 天津市 14083.7 14055.5 13362.9 12450.6 11477.2
In [21]: df.iloc[:2,[0,1,3]] # 前两行，第0-1-3列数据
Out[21]:
地区 2020年 2018年
0 北京市 36102.6 33106.0
1 天津市 14083.7 13362.9
In [22]: df.iloc[1,1] # 自然索引为1，第1列的数据（也就是天津2020年的gdp），一般用 .iat
Out[22]: 14083.7
loc[]
区别于iloc，它根据索引的名称来进行筛选，如果没有设置索引一般就是自然索引
In [23]: df1 = df.set_index('地区') # 我们设置 地区字段 列 为索引
In [24]: df1
Out[24]:
2020年 2019年 2018年 2017年 2016年
地区
北京市 36102.6 35445.1 33106.0 29883.0 27041.2
天津市 14083.7 14055.5 13362.9 12450.6 11477.2
河北省 36206.9 34978.6 32494.6 30640.8 28474.1
... ... ... ... ... ...
宁夏回族自治区 3920.5 3748.5 3510.2 3200.3 2781.4
新疆维吾尔自治区 13797.6 13597.1 12809.4 11159.9 9630.8
台湾省 NaN NaN NaN NaN NaN
[32 rows x 5 columns]
In [25]: df1.loc['北京市'] # 选择 索引名为北京市的数据
Out[25]:
2020年 36102.6
2019年 35445.1
2018年 33106.0
2017年 29883.0
2016年 27041.2
Name: 北京市, dtype: float64
In [26]: df1.loc['北京市':'河北省','2020年'] # 选择 索引名称 在北京市到河北省，列名为 2020年的数据
Out[26]:
地区
北京市 36102.6
天津市 14083.7
河北省 36206.9
Name: 2020年, dtype: float64
In [27]: df1.loc['北京市':'河北省','2019年':] # 选择 索引名称 在北京市到河北省，列名在 2019年及之后的数据
Out[27]:
2019年 2018年 2017年 2016年
地区
北京市 35445.1 33106.0 29883.0 27041.2
天津市 14055.5 13362.9 12450.6 11477.2
河北省 34978.6 32494.6 30640.8 28474.1
In [28]: df1.loc[['北京市','上海市','重庆市','天津市'],['2020年','2019年']] # 选择索引名为 北京、上海、重庆、天津 2020年及2019年数据
Out[28]:
2020年 2019年
地区
北京市 36102.6 35445.1
上海市 38700.6 37987.6
重庆市 25002.8 23605.8
天津市 14083.7 14055.5
In [29]: df1.loc['北京市','2020年'] # 选择 索引名为 北京市，列名为2020年 额数据（就是坐标元素值）
Out[29]: 36102.6
2.3. 元素选择.iat与.at
按坐标其实可以通过上述的按索引进行，这里还可以用.iat和.at来实现，和按索引类型一个是自然索引值一个是索引名称
In [30]: df.iat[0,2]
Out[30]: 35445.1
In [31]: df1.at['北京市','2019年']
Out[31]: 35445.1
In [32]: df.地区.at[3]
Out[32]: '山西省'
In [33]: # 其实还有以下方式
...: df1['2019年']['北京市']
Out[33]: 35445.1
In [34]: df['2019年'][0]
Out[34]: 35445.1
2.4. get与truncate
df.get(key, default=None)类似python字典里的get方法
df.truncate(before=None, after=None, axis=None, copy: 'bool_t' = True)，返回区间数据
get()
对于DataFrame数据来说返回key列的值，如果key不存在就返回默认值。
Signature: df.get(key, default=None)
Docstring:
Get item from object for given key (ex: DataFrame column).
Returns default value if not found.
对于Series数据来说，返回key索引的值，不存在就返回默认值。
In [35]: df.get('地区','无数据')
Out[35]:
0 北京市
1 天津市
2 河北省
...
29 宁夏回族自治区
30 新疆维吾尔自治区
31 台湾省
Name: 地区, Length: 32, dtype: object
In [36]: df.get('2015年','无数据')
Out[36]: '无数据'
In [37]: df.地区.get(0,'无数据')
Out[37]: '北京市'
In [38]: df.地区.get(100,'无数据')
Out[38]: '无数据'
truncate()
将索引代入before和after，截取这区间的数据，支持对行和列操作
In [39]: df.truncate(before=0,after=4)
Out[39]:
地区 2020年 2019年 2018年 2017年 2016年
0 北京市 36102.6 35445.1 33106.0 29883.0 27041.2
1 天津市 14083.7 14055.5 13362.9 12450.6 11477.2
2 河北省 36206.9 34978.6 32494.6 30640.8 28474.1
3 山西省 17651.9 16961.6 15958.1 14484.3 11946.4
4 内蒙古自治区 17359.8 17212.5 16140.8 14898.1 13789.3
In [40]: df.truncate(before='2018年',after='2020年',axis=1)
Out[40]:
2020年 2019年 2018年
0 36102.6 35445.1 33106.0
1 14083.7 14055.5 13362.9
2 36206.9 34978.6 32494.6
.. ... ... ...
29 3920.5 3748.5 3510.2
30 13797.6 13597.1 12809.4
31 NaN NaN NaN
[32 rows x 3 columns]
以上属于数据筛选与查询的基础操作，接下来我们介绍进阶操作
3. 进阶操作
基础操作部分我们介绍的是比较简单的数据筛选操作，实际的数据清洗与处理时我们更多的是需要根据更加复杂的组合条件来查询数据进行筛选。这一节，我们就来一一介绍一下。
3.1. 逻辑筛选
逻辑刷选这里是指按照一定的逻辑条件来进行数据的筛选，比如满足某条件的行、列数据等等
In [41]: df[df['地区'] == '北京市'] # 地区是北京市的数据
Out[41]:
地区 2020年 2019年 2018年 2017年 2016年
0 北京市 36102.6 35445.1 33106.0 29883.0 27041.2
In [42]: df[df['地区'].str.contains('市')] # 地区名称 含关键字 市 的数据
Out[42]:
地区 2020年 2019年 2018年 2017年 2016年
0 北京市 36102.6 35445.1 33106.0 29883.0 27041.2
1 天津市 14083.7 14055.5 13362.9 12450.6 11477.2
8 上海市 38700.6 37987.6 36011.8 32925.0 29887.0
21 重庆市 25002.8 23605.8 21588.8 20066.3 18023.0
In [43]: df[df['地区'].str.contains('市|自治区')] # 地区名称含关键字 市或自治区 的数据
Out[43]:
地区 2020年 2019年 2018年 2017年 2016年
0 北京市 36102.6 35445.1 33106.0 29883.0 27041.2
1 天津市 14083.7 14055.5 13362.9 12450.6 11477.2
4 内蒙古自治区 17359.8 17212.5 16140.8 14898.1 13789.3
.. ... ... ... ... ... ...
25 西藏自治区 1902.7 1697.8 1548.4 1349.0 1173.0
29 宁夏回族自治区 3920.5 3748.5 3510.2 3200.3 2781.4
30 新疆维吾尔自治区 13797.6 13597.1 12809.4 11159.9 9630.8
[9 rows x 6 columns]
In [44]: df[df['地区'].isin(['北京市','湖北省','江苏省'])] # 地区名称 在北京市、湖北省、江苏省的数据
Out[44]:
地区 2020年 2019年 2018年 2017年 2016年
0 北京市 36102.6 35445.1 33106.0 29883.0 27041.2
9 江苏省 102719.0 98656.8 93207.6 85869.8 77350.9
16 湖北省 43443.5 45429.0 42022.0 37235.0 33353.0
In [45]: df[~df['地区'].isin(['北京市','湖北省','江苏省'])] # 地区名称 不在北京市、湖北省、江苏省的数据
Out[45]:
地区 2020年 2019年 2018年 2017年 2016年
1 天津市 14083.7 14055.5 13362.9 12450.6 11477.2
2 河北省 36206.9 34978.6 32494.6 30640.8 28474.1
3 山西省 17651.9 16961.6 15958.1 14484.3 11946.4
.. ... ... ... ... ... ...
29 宁夏回族自治区 3920.5 3748.5 3510.2 3200.3 2781.4
30 新疆维吾尔自治区 13797.6 13597.1 12809.4 11159.9 9630.8
31 台湾省 NaN NaN NaN NaN NaN
[29 rows x 6 columns]
除了上面用切片[]的形式，同样可以用loc[]的形式
In [46]: df.loc[df['地区'].isin(['北京市','湖北省','江苏省'])]
Out[46]:
地区 2020年 2019年 2018年 2017年 2016年
0 北京市 36102.6 35445.1 33106.0 29883.0 27041.2
9 江苏省 102719.0 98656.8 93207.6 85869.8 77350.9
16 湖北省 43443.5 45429.0 42022.0 37235.0 33353.0
对于iloc[]来说，则需要是对自然索引值的判断
In [47]: df.iloc[df.index==9]
Out[47]:
地区 2020年 2019年 2018年 2017年 2016年
9 江苏省 102719.0 98656.8 93207.6 85869.8 77350.9
我们还可以进行更复杂的逻辑判断去筛选想要的数据，在进行 或（|） 且（&） 非（~） 逻辑判断的时候，每个独立的逻辑判断需要用括号括起来
In [48]: df[df['2020年']'2019年']] # 2020年GDP小于2019年GDP的省份
Out[48]:
地区 2020年 2019年 2018年 2017年 2016年
16 湖北省 43443.5 45429.0 42022.0 37235.0 33353.0
In [49]: df[(df['2020年']>30000) &
...: (df['2019年']>30000)
...: ] # 最近连续2年GDP超过3万亿的地区
Out[49]:
地区 2020年 2019年 2018年 2017年 2016年
0 北京市 36102.6 35445.1 33106.0 29883.0 27041.2
2 河北省 36206.9 34978.6 32494.6 30640.8 28474.1
8 上海市 38700.6 37987.6 36011.8 32925.0 29887.0
.. ... ... ... ... ... ...
17 湖南省 41781.5 39894.1 36329.7 33828.1 30853.5
18 广东省 110760.9 107986.9 99945.2 91648.7 82163.2
22 四川省 48598.8 46363.8 42902.1 37905.1 33138.5
[13 rows x 6 columns]
我们还可以通过any和all对逻辑判断后结果进行再次判断，对于all来说需要都满足才行，对于any来说只需要满足一个即可，需要注意的是默认是0列方向，1是行方向
In [50]: df[(df[['2020年','2019年']]>30000).all(1)] # 最近连续2年GDP超过3万亿的地区
Out[50]:
地区 2020年 2019年 2018年 2017年 2016年
0 北京市 36102.6 35445.1 33106.0 29883.0 27041.2
2 河北省 36206.9 34978.6 32494.6 30640.8 28474.1
8 上海市 38700.6 37987.6 36011.8 32925.0 29887.0
.. ... ... ... ... ... ...
17 湖南省 41781.5 39894.1 36329.7 33828.1 30853.5
18 广东省 110760.9 107986.9 99945.2 91648.7 82163.2
22 四川省 48598.8 46363.8 42902.1 37905.1 33138.5
[13 rows x 6 columns]
In [51]: df[(df[['2020年','2019年']]>100000).all(1)] # 最近2年有1年GDP超过10万亿
Out[51]:
地区 2020年 2019年 2018年 2017年 2016年
18 广东省 110760.9 107986.9 99945.2 91648.7 82163.2
3.2. 函数筛选
函数筛选是指 我们在不管是切片还是索引选择方式中，表达式还可以是lambda函数；此外，pandas也提供了一些比较函数可以用来进行数据筛选。
自定义lambda函数
df.loc[lambda x : x['2020年']>50000, ['地区','2020年','2019年']] # 筛选2020年GDP超过5万亿且只选 地区、2020年和2019年数据
Out[53]:
地区 2020年 2019年
9 江苏省 102719.0 98656.8
10 浙江省 64613.3 62462.0
14 山东省 73129.0 70540.5
15 河南省 54997.1 53717.8
18 广东省 110760.9 107986.9
In [54]: import re
In [55]: df.loc[:, lambda x : [i for i in df.columns[1:] if int(re.findall('\d+',i)[0])<2020]] # 筛选列名满足条件的列
Out[55]:
2019年 2018年 2017年 2016年
0 35445.1 33106.0 29883.0 27041.2
1 14055.5 13362.9 12450.6 11477.2
2 34978.6 32494.6 30640.8 28474.1
.. ... ... ... ...
29 3748.5 3510.2 3200.3 2781.4
30 13597.1 12809.4 11159.9 9630.8
31 NaN NaN NaN NaN
[32 rows x 4 columns]
比较函数
panda有一些比较函数，我们可以将逻辑表达式替换为比较函数形式
In [56]: df[df['地区'].eq('北京市')] # 等于
Out[56]:
地区 2020年 2019年 2018年 2017年 2016年
0 北京市 36102.6 35445.1 33106.0 29883.0 27041.2
In [57]: df[df['地区'].ne('北京市')] # 不等于
Out[57]:
地区 2020年 2019年 2018年 2017年 2016年
1 天津市 14083.7 14055.5 13362.9 12450.6 11477.2
2 河北省 36206.9 34978.6 32494.6 30640.8 28474.1
3 山西省 17651.9 16961.6 15958.1 14484.3 11946.4
.. ... ... ... ... ... ...
29 宁夏回族自治区 3920.5 3748.5 3510.2 3200.3 2781.4
30 新疆维吾尔自治区 13797.6 13597.1 12809.4 11159.9 9630.8
31 台湾省 NaN NaN NaN NaN NaN
[31 rows x 6 columns]
In [58]: df[df['2020年'].lt(10000)] # 小于
Out[58]:
地区 2020年 2019年 2018年 2017年 2016年
20 海南省 5532.4 5330.8 4910.7 4497.5 4090.2
25 西藏自治区 1902.7 1697.8 1548.4 1349.0 1173.0
27 甘肃省 9016.7 8718.3 8104.1 7336.7 6907.9
28 青海省 3005.9 2941.1 2748.0 2465.1 2258.2
29 宁夏回族自治区 3920.5 3748.5 3510.2 3200.3 2781.4
In [59]: df[df['2020年'].le(5532.4)] # 小于等于
Out[59]:
地区 2020年 2019年 2018年 2017年 2016年
20 海南省 5532.4 5330.8 4910.7 4497.5 4090.2
25 西藏自治区 1902.7 1697.8 1548.4 1349.0 1173.0
28 青海省 3005.9 2941.1 2748.0 2465.1 2258.2
29 宁夏回族自治区 3920.5 3748.5 3510.2 3200.3 2781.4
In [60]: df[df['2020年'].gt(50000)] # 大于
Out[60]:
地区 2020年 2019年 2018年 2017年 2016年
9 江苏省 102719.0 98656.8 93207.6 85869.8 77350.9
10 浙江省 64613.3 62462.0 58002.8 52403.1 47254.0
14 山东省 73129.0 70540.5 66648.9 63012.1 58762.5
15 河南省 54997.1 53717.8 49935.9 44824.9 40249.3
18 广东省 110760.9 107986.9 99945.2 91648.7 82163.2
In [61]: df[df['2020年'].ge(62462.0)] # 大于等于
Out[61]:
地区 2020年 2019年 2018年 2017年 2016年
9 江苏省 102719.0 98656.8 93207.6 85869.8 77350.9
10 浙江省 64613.3 62462.0 58002.8 52403.1 47254.0
14 山东省 73129.0 70540.5 66648.9 63012.1 58762.5
18 广东省 110760.9 107986.9 99945.2 91648.7 82163.2
对于isin()，还可以传入字典，key为列名，value为待匹配的值（这个大家可以构建数据试试）
3.3. query
Signature: df.query(expr: 'str', inplace: 'bool' = False, **kwargs)
Docstring:
Query the columns of a DataFrame with a boolean expression.
query()的很高校的查询方法，其表达式是一个字符串，我们在《再推荐几个好用的pandas函数，继续加快你数据处理的速度》介绍过，大家可前往了解，这里稍微介绍下
在引号中，如果列名是数字开头或者含有空格，则需要用`反引号标识 其他情况下的列名直接写即可，用于筛选对比的对象如果是字符串则需要用引号 我们还可以通过 @来引入变量
In [62]: df.query('地区=="北京市"') # 地区为北京市的数据
Out[62]:
地区 2020年 2019年 2018年 2017年 2016年
0 北京市 36102.6 35445.1 33106.0 29883.0 27041.2
In [63]: df.query('`2020年`<`2019年`') # 2020年GDP小于2019年GDP的数据
Out[63]:
地区 2020年 2019年 2018年 2017年 2016年
16 湖北省 43443.5 45429.0 42022.0 37235.0 33353.0
In [64]: mean_gdp = df['2020年'].mean()
In [64]: mean_gdp
Out[65]: 32658.55161290323
In [66]: df.query('`2020年` > @mean_gdp') # @ 引入变量
Out[66]:
地区 2020年 2019年 2018年 2017年 2016年
0 北京市 36102.6 35445.1 33106.0 29883.0 27041.2
2 河北省 36206.9 34978.6 32494.6 30640.8 28474.1
8 上海市 38700.6 37987.6 36011.8 32925.0 29887.0
.. ... ... ... ... ... ...
17 湖南省 41781.5 39894.1 36329.7 33828.1 30853.5
18 广东省 110760.9 107986.9 99945.2 91648.7 82163.2
22 四川省 48598.8 46363.8 42902.1 37905.1 33138.5
[13 rows x 6 columns]
3.4. filter
Signature:
df.filter(
items=None,
like: 'str | None' = None,
regex: 'str | None' = None,
axis=None,
) -> 'FrameOrSeries'
Docstring:
Subset the dataframe rows or columns according to the specified index labels.
Note that this routine does not filter a dataframe on its
contents. The filter is applied to the labels of the index.
df.filter()可以对行和列名进行筛选，支持模糊匹配和正则表达式
In [67]: df.filter(items=['2020年','2016年']) # 选择两列
Out[67]:
2020年 2016年
0 36102.6 27041.2
1 14083.7 11477.2
2 36206.9 28474.1
.. ... ...
29 3920.5 2781.4
30 13797.6 9630.8
31 NaN NaN
[32 rows x 2 columns]
In [68]: df.filter(regex='年') # 列名称含 年 的列
Out[68]:
2020年 2019年 2018年 2017年 2016年
0 36102.6 35445.1 33106.0 29883.0 27041.2
1 14083.7 14055.5 13362.9 12450.6 11477.2
2 36206.9 34978.6 32494.6 30640.8 28474.1
.. ... ... ... ... ...
29 3920.5 3748.5 3510.2 3200.3 2781.4
30 13797.6 13597.1 12809.4 11159.9 9630.8
31 NaN NaN NaN NaN NaN
[32 rows x 5 columns]
In [69]: df1.filter(regex='市', axis=0) # 索引名含 市 的数据
Out[69]:
2020年 2019年 2018年 2017年 2016年
地区
北京市 36102.6 35445.1 33106.0 29883.0 27041.2
天津市 14083.7 14055.5 13362.9 12450.6 11477.2
上海市 38700.6 37987.6 36011.8 32925.0 29887.0
重庆市 25002.8 23605.8 21588.8 20066.3 18023.0
In [70]: df1.filter(regex='^江', axis=0) # 索引名中以江开头的
Out[70]:
2020年 2019年 2018年 2017年 2016年
地区
江苏省 102719.0 98656.8 93207.6 85869.8 77350.9
江西省 25691.5 24667.3 22716.5 20210.8 18388.6
In [71]: df1.filter(regex='自治区$', axis=0) # 索引名中以自治区结尾的
Out[71]:
2020年 2019年 2018年 2017年 2016年
地区
内蒙古自治区 17359.8 17212.5 16140.8 14898.1 13789.3
广西壮族自治区 22156.7 21237.1 19627.8 17790.7 16116.6
西藏自治区 1902.7 1697.8 1548.4 1349.0 1173.0
宁夏回族自治区 3920.5 3748.5 3510.2 3200.3 2781.4
新疆维吾尔自治区 13797.6 13597.1 12809.4 11159.9 9630.8
In [72]: df1.filter(like='北',axis=0) # 索引名中有 北 的
Out[72]:
2020年 2019年 2018年 2017年 2016年
地区
北京市 36102.6 35445.1 33106.0 29883.0 27041.2
河北省 36206.9 34978.6 32494.6 30640.8 28474.1
湖北省 43443.5 45429.0 42022.0 37235.0 33353.0
以上就是本次全部内容，希望对你有所帮助，如果你喜欢的话还希望能给个三连呀！欢迎在留言区吱一声哦，说说你的想法哦。我们月底会给经常来留言打卡的同学送书10本，记得常来指导工作哦！
推荐阅读:
入门: 最全的零基础学Python的问题 | 零基础学了8个月的Python | 实战项目 |学Python就是这条捷径
量化: 定投基金到底能赚多少钱？ | 我用Python对去年800只基金的数据分析
干货:爬取豆瓣短评，电影《后来的我们》 | 38年NBA最佳球员分析 | 从万众期待到口碑扑街！唐探3令人失望 | 笑看新倚天屠龙记 | 灯谜答题王 ｜用Python做个海量小姐姐素描图 ｜碟中谍这么火，我用机器学习做个迷你推荐系统电影
趣味:弹球游戏 | 九宫格 | 漂亮的花 | 两百行Python《天天酷跑》游戏!
AI: 会做诗的机器人 | 给图片上色 | 预测收入 | 碟中谍这么火，我用机器学习做个迷你推荐系统电影
小工具: Pdf转Word，轻松搞定表格和水印！ | 一键把html网页保存为pdf！| 再见PDF提取收费！ | 用90行代码打造最强PDF转换器，word、PPT、excel、markdown、html一键转换 | 制作一款钉钉低价机票提示器！ ｜60行代码做了一个语音壁纸切换器天天看小姐姐！｜
评论