Python | Pandas | 筛选

已于 2023-08-05 16:29:46 修改
阅读量1.3k 收藏 5
点赞数 2
分类专栏： Pandas Python 数据分析 文章标签： pandas python 数据分析
于 2022-06-22 00:01:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MissMango0820/article/details/125394523
版权
Python 同时被 3 个专栏收录
44 篇文章 0 订阅
订阅专栏
Pandas
16 篇文章 3 订阅
订阅专栏
数据分析
12 篇文章 0 订阅
订阅专栏

本文主要介绍如何使用 Pandas 对值进行筛选。

Updated: 2023 / 08 / 05

Python | Pandas | 筛选

以下面的3个 dataframe 为例对如何针对性筛选数据的方法进行说明 1’ 2：

  1. 原始数据文件参考此处，如下所示：
df1 = pd.read_csv('dtype_RawData.csv')
#    Customer Number     Customer Name         2016  ... Month   Day Active
# 0             1002  Quest industries  ¥125,000.00  ...     1  2015      Y
# 1           552278    Smith Plumbing  ¥920,000.00  ...     6  2014      Y
# 2            23477   ACME Industrial   ¥50,000.00  ...     3  2016      Y
# 3            24900        Brekke LTD  ¥350,000.00  ...    10  2015      Y
# 4           651029         Harbor Co   ¥15,000.00  ...     2  2014      N
#
# [5 rows x 9 columns]
#
# Customer Number     int64
# Customer Name      object
# 2016               object
# 2017               object
# Percent Growth     object
# Jan Units          object
# Month               int64
# Day                 int64
# Active             object
# dtype: object

df2 = {
    'number': [1, 2, 3, 4, 5],
    'sex': ['male', 'female', 'female', 'male', 'male'],
    'name': ['Jacob', 'Sam', 'Jane', 'Smith', 'Einstein'],
    'age': ['', '31.0', '', '21.0', np.nan],
    'education': ['master', 'bachelor', 'master', 'PhD', 'bachelor']
}

df2 = pd.DataFrame(df2)
#    number     sex      name   age education
# 0       1    male     Jacob          master
# 1       2  female       Sam  31.0  bachelor
# 2       3  female      Jane          master
# 3       4    male     Smith  21.0       PhD
# 4       5    male  Einstein   NaN  bachelor
#
# number        int64
# sex          object
# name         object
# age          object
# education    object
# dtype: object

df3 = pd.DataFrame(
    data={"data_provider": ["prov_1", "prov_1", "prov_2", "prov_2", "prov_3", "prov_3"],
          "indicator": ["ind_a", "ind_a", "ind_a", "ind_b", "ind_b", "ind_b"],
          "unit": ["EUR", "EUR", "EUR", "EUR", "EUR", "EUR"],
          "year": ["2017", "2018","2019", "2017","2018","2019"],
          "country1": [1, 2, 3, 2, 4, 6],
          "country2": [4, 5, 6, 40, 50, 60]}
)

df3 = pd.pivot_table(data=df3,
                     index=['data_provider', 'indicator'],
                     columns=['year', 'country1'],
                     fill_value=30)
#                         country2
# year                        2017     2018     2019
# country1                       1   2    2   4    3   6
# data_provider indicator
# prov_1        ind_a            4  30    5  30   30  30
# prov_2        ind_a           30  30   30  30    6  30
#               ind_b           30  40   30  30   30  30
# prov_3        ind_b           30  30   30  50   30  60
#
# MultiIndex([('prov_1', 'ind_a'),
#             ('prov_2', 'ind_a'),
#             ('prov_2', 'ind_b'),
#             ('prov_3', 'ind_b')],
#            names=['data_provider', 'indicator'])
#
# MultiIndex([('country2', '2017', 1),
#             ('country2', '2017', 2),
#             ('country2', '2018', 2),
#             ('country2', '2018', 4),
#             ('country2', '2019', 3),
#             ('country2', '2019', 6)],
#            names=[None, 'year', 'country1'])

数字

方法

方法说明
df.select_dtypes(include=None, exclude=None)
pd.to_numeric(arg, errors="raise", downcast=None)

示例

df.select_dtypes
int1 = df1.select_dtypes(include='int')
#    Customer Number  Month   Day
# 0             1002      1  2015
# 1           552278      6  2014
# 2            23477      3  2016
# 3            24900     10  2015
# 4           651029      2  2014

print(int1.dtypes)
# Customer Number    int64
# Month              int64
# Day                int64
# dtype: object

int2 = df2.select_dtypes(include='int')
#    number
# 0       1
# 1       2
# 2       3
# 3       4
# 4       5

print(int2.dtypes)
# number    int64
# dtype: object

pd.to_numeric
df1nums = []
for col in df1.columns:
    df1num = pd.to_numeric(df1[col], errors='coerce')
    df1nums.append(df1num)
df1nums = pd.concat(dfnums, axis=1, ignore_index=True)
df1nums.columns = df1.columns
#    Customer Number  Customer Name  2016  2017  ...  Jan Units  Month   Day  Active
# 0             1002            NaN   NaN   NaN  ...      500.0      1  2015     NaN
# 1           552278            NaN   NaN   NaN  ...      700.0      6  2014     NaN
# 2            23477            NaN   NaN   NaN  ...      125.0      3  2016     NaN
# 3            24900            NaN   NaN   NaN  ...       75.0     10  2015     NaN
# 4           651029            NaN   NaN   NaN  ...        NaN      2  2014     NaN
#
# [5 rows x 9 columns]

print(df1nums.dtypes)
# Customer Number      int64
# Customer Name      float64
# 2016               float64
# 2017               float64
# Percent Growth     float64
# Jan Units          float64
# Month                int64
# Day                  int64
# Active             float64
# dtype: object

df2nums = []
for col in df2.columns:
    df2num = pd.to_numeric(df2[col], errors='coerce', downcast='integer')
    df2nums.append(df2num)
df2nums = pd.concat(df2nums, axis=1, ignore_index=True)
#    0   1   2     3   4
# 0  1 NaN NaN   NaN NaN
# 1  2 NaN NaN  31.0 NaN
# 2  3 NaN NaN   NaN NaN
# 3  4 NaN NaN  21.0 NaN
# 4  5 NaN NaN   NaN NaN

print(df2nums.dtypes)
# 0       int8
# 1    float64
# 2    float64
# 3    float64
# 4    float64
# dtype: object

列

方法

前提方法说明
已有目标列标签 [^pandas读取或选择多列]pd.Dataframe(df, columns=labels)
df[['col1', 'col2']]
df.loc[:, ['col1', 'col2']]
df.loc[:, df.columns.isin(['col1', 'col2', 'col3'])]
df.filter(items=['col1', 'col2', 'col3'], axis=1)
已有符合特定模式的目标列标签df.columns.str.contains(‘keyword’)
df.filter(like='keyword', axis=1)根据指定的索引标签对数据框的行或列进行子集化。请注意，此例程不会根据其内容过滤数据框。过滤器应用于索引的标签。
df.loc[:, df.columns.str.startswith('keyword')]
已有目标列索引 [^pandas读取或选择多列]df.iloc[:, [x, y]]

df.filter
DataFrame.filter(items=None, like=None, regex=None, axis=None)

返回和输入数据同类型的数据 3’ 4。

参数说明
items列表式，按 items 中给出的轴标签进行数据的保留。
like字符串，按给定的轴方向和标签中含有 like 所给出标签进行数据的保留。
regex字符串 (常规表达式)，按轴方向上满足 re.search(regex, label) == True 条件的标签进行数据的保留。
axis{0 or ‘index’, 1 or ‘columns’, None}, default None，要过滤的轴，表示为索引 (int) 或轴名称 (str)。

默认情况下，这是信息轴，DataFrame 的 列。对于系列，此参数未使用，默认为无。

items、like 和 regex 参数强制互斥。


示例

列标签
目标列标签
collabels = ['2016', 'Day']
df1cols = pd.DataFrame(df1, columns=collabels)
#           2016   Day
# 0  ¥125,000.00  2015
# 1  ¥920,000.00  2014
# 2   ¥50,000.00  2016
# 3  ¥350,000.00  2015
# 4   ¥15,000.00  2014
#
# Index(['2016', 'Day'], dtype='object')
#
# RangeIndex(start=0, stop=5, step=1)

collabels = ['2016', 'Day']
df1cols = df1[collabels]

collabels = ['2016', 'Day']
df1cols = df1.loc[:, collabels]

df2cols = df2.loc[:, df2.columns.isin(['gender', 'name', 'education'])]
#        name education
# 0     Jacob    master
# 1       Sam  bachelor
# 2      Jane    master
# 3     Smith       PhD
# 4  Einstein  bachelor

df2cols = df2.filter(items=['gender', 'name', 'education'], axis=1)

符合特定模式目标列标签
    1. 含有特定关键字
df2cols = df2.loc[:, df2.columns.str.contains('ex')]
#       sex
# 0    male
# 1  female
# 2  female
# 3    male
# 4    male

df2cols = df2.filter(like='am', axis=1)
#        name
# 0     Jacob
# 1       Sam
# 2      Jane
# 3     Smith
# 4  Einstein

df2cols = df2.loc[:, df2.columns.str.startswith('n')]
#    number      name
# 0       1     Jacob
# 1       2       Sam
# 2       3      Jane
# 3       4     Smith
# 4       5  Einstein

df2cols = df2.filter(like='n', axis=1)
#    number      name education
# 0       1     Jacob    master
# 1       2       Sam  bachelor
# 2       3      Jane    master
# 3       4     Smith       PhD
# 4       5  Einstein  bachelor

列索引

目标列索引如下，

colidx = [3, 4]

根据目标列索引选取指定列的方式如下，

df1cols = df1.iloc[:, colidx]
#             2017 Percent Growth
# 0    ¥162,500.00         30.00%
# 1  ¥1,012,000.00         10.00%
# 2     ¥62,500.00         25.00%
# 3    ¥490,000.00          4.00%
# 4     ¥12,750.00        -15.00%
#
# Index(['2017', 'Percent Growth'], dtype='object')
#
# RangeIndex(start=0, stop=5, step=1)

行

方法

前提方法说明
已有符合特定条件的值的所在行df.loc[df.column1.isin([val1, val2, val3])] 5col1 列中等于 val1，val2 或者 val3 的值所在的行 6
已有目行索引df.iloc[[x, y], :]第 x、y 行

示例

符合特定条件的值所在行
df2filtered = df2.loc[df2.age.isin(['', np.nan])]
#    number     sex      name  age education
# 0       1    male     Jacob         master
# 2       3  female      Jane         master
# 4       5    male  Einstein  NaN  bachelor

目标行索引
df2filtered = df2.iloc[[0, 3, 4], :]
#    number   sex      name   age education
# 0       1  male     Jacob          master
# 3       4  male     Smith  21.0       PhD
# 4       5  male  Einstein   NaN  bachelor
#
# Int64Index([0, 3, 4], dtype='int64')

值

方法

方法说明
df.loc[row_indexer,col_indexer]
df[df[col].isna()] 7选取列表签为 col 的列中值为 NaN 的所在行
df.query() 81. 写类似于 sql 语句或者表达式

df.query('Q1 > Q2 > 90')
df.query('Q1 + Q2 > 180')
df.query('Q1 == Q2')
df.query('(Q1<50) & (Q2>40) and (Q3>90)')
df.query('Q1 > Q2 > Q3 > Q4')
2. 表达式

df.query('team != "C"')
df.query('team in ["A","B"]')
df.query('team not in ("E","A","B")')
df.query('team == ["A","B"]')
df.query('team != ["A","B"]')
df.query('name.str.contains("am")')
3. 空值 9

engine = 'python' 的作用是以 python 方式解读表达式，而不是以 pandas。对于是否添加 engine = 'python' 取决于所筛选列的值的数据类型。如果是 floats, 它具备原生 NaN, 则可以不添加; 如果是 str 或者 int，则需添加。

df.query('col1.isnull()', engine='python')

df.query('col1.notnull()', engine='python')

在 pandas 和 numpy 中，NaN 不等于 NaN。所以如果想检验一个单元格是否有 NaN 值，可以通过以下方式：
cell_value != cell_value
该表达式只对 NaN 值成立
( 3 !=3 是 False 的 但是 NaN != NaN 是 True 的)，所以 query 只会返回 NaNs。
cell_value == cell_value
该表达式只对非 NaNs 值成立 ( 3 == 3 是 True 的 但是 NaN == NaN 是 False 的), 所以 query 只会返回非 NaNs。
df.query('col1 == col')
df.query('col1 != col1')
4. 含有空格的值

df.query('B == "team name"')
5. 传入变量

a = df.Q1.mean()
df.query('Q1 > @a+40')
df.query('Q1 > Q2 + @a')
df.lt(value) 10lt 表示 less than，表示在 df 的值是否小于 value
df.gt(value) 10ge 表示 greater than，表示在 df 的值是否大于 value
df.le(value) 10le 表示 less than or equal to，表示在 df 的值是否小于等于 value
df.ge(value) 10ge 表示 greater than or equal to，表示在 df 的值是否大于等于 value
df.eq(value) 10eq 表示 equal，表示在 df 的值是否等于 value
df.ne(value) 10ne 表示 not equal to，表示在 df 的值是否不等于 value
df['col].between(value1, value2)col 列中的值在 value1 到 value2 中

between

数据分箱（ Data Binning ）是指将数据放入离散区间或段/箱的过程。我们可以使用 between 方法来对数据进行分箱操作。

between 方法检查数据是否在两个值之间，其语法为：

between(left, right, inclusive='both')

其余更多细节，可参考这里 11。


示例

特定值所在行
  • 筛选出列标签为 age 的列中值为 或者 NaN 的所有行；
idx = df2.age.isin(['', np.nan])
# 0     True
# 1    False
# 2     True
# 3    False
# 4     True
# Name: age, dtype: bool
#
# <class 'pandas.core.series.Series'>

df2filtered = df2.loc[df2.age.isin(['', np.nan]), :]
#    number     sex      name  age education
# 0       1    male     Jacob         master
# 2       3  female      Jane         master
# 4       5    male  Einstein  NaN  bachelor
# 
# <class 'pandas.core.frame.DataFrame'>

也可以使用 isna() 用以筛选值为 NaN 或者 None 的所有行，

idx = df2.age.isna()
# 0    False
# 1    False
# 2    False
# 3    False
# 4     True
# Name: age, dtype: bool
#
# <class 'pandas.core.series.Series'>

df2filtered = df2[df2.age.isna()]
#    number   sex      name  age education
# 4       5  male  Einstein  NaN  bachelor
#
# <class 'pandas.core.frame.DataFrame'>

也可以使用 query 用以筛选值为 NaN 或者 None 的所有行，

df2filtered = df2.query('age.isnull()', engine='python')
#    number   sex      name  age education
# 4       5  male  Einstein  NaN  bachelor

又或者反过来，筛选值不为 NaN 或者 None 的所在行，

idx = df2.age.notna()
# 0     True
# 1     True
# 2     True
# 3     True
# 4    False
# Name: age, dtype: bool
#
# <class 'pandas.core.series.Series'>

df2filtered = df2[df2.age.notna()]
#    number     sex   name   age education
# 0       1    male  Jacob          master
# 1       2  female    Sam  31.0  bachelor
# 2       3  female   Jane          master
# 3       4    male  Smith  21.0       PhD
#
# <class 'pandas.core.frame.DataFrame'>

筛选出列标签为 age 的列中值为 或者 NaN 的并以特定值进行赋值替换 12’ 13；

df2filtered = df2.loc[df2.age.isin(['', np.nan]), 'age']
# 0
# 2
# 4    NaN
# Name: age, dtype: object
#
# <class 'pandas.core.series.Series'>

df2.loc[df2.age.isin(['', np.nan]), 'age'] = ['new value']*df2.loc[df2.age.isin(['', np.nan]), 'age'].shape[0]
#    number     sex      name        age education
# 0       1    male     Jacob  new value    master
# 1       2  female       Sam       31.0  bachelor
# 2       3  female      Jane  new value    master
# 3       4    male     Smith       21.0       PhD
# 4       5    male  Einstein  new value  bachelor
#
# <class 'pandas.core.frame.DataFrame'>

符合某一范围
单索引
print(df2.number.dtypes)
# int64

idx = (5 > df2.number) & (df2.number > 2)
# 0    False
# 1    False
# 2     True
# 3     True
# 4    False
# Name: number, dtype: boo

df2filtered = df2[(5 > df2.number) & (df2.number > 2)]
#    number     sex   name   age education
# 2       3  female   Jane          master
# 3       4    male  Smith  21.0       PhD

print(df2filtered.number.values)
# [3 4]

又或者 14，

idx = df2.number.between(2, 4)
# 0    False
# 1     True
# 2     True
# 3     True
# 4    False
# Name: number, dtype: bool


df2filtered = df2[df2.number.between(2, 4)]
#    number     sex   name   age education
# 1       2  female    Sam  31.0  bachelor
# 2       3  female   Jane          master
# 3       4    male  Smith  21.0       PhD

print(df2filtered.number.values)
# [2 3 4]

又或者，

idx = df2.number.isin(range(2,5))
# 0    False
# 1     True
# 2     True
# 3     True
# 4    False
# Name: number, dtype: bool

df2filtered = df2[idx]
#    number     sex   name   age education
# 1       2  female    Sam  31.0  bachelor
# 2       3  female   Jane          master
# 3       4    male  Smith  21.0       PhD

print(df2filtered.number.values)
# [2 3 4]

多索引
con = (df3[('country2', '2017', 2)] <= 30) & (df3[('country2', '2018', 2)] <= 30)
# data_provider  indicator
# prov_1         ind_a         True
# prov_2         ind_a         True
#                ind_b        False
# prov_3         ind_b         True
# dtype: bool
#
# <class 'pandas.core.series.Series'>
#
# MultiIndex([('prov_1', 'ind_a'),
#             ('prov_2', 'ind_a'),
#             ('prov_2', 'ind_b'),
#             ('prov_3', 'ind_b')],
#            names=['data_provider', 'indicator'])

df3filtered = df3[con]
#                         country2
# year                        2017     2018     2019
# country1                       1   2    2   4    3   6
# data_provider indicator
# prov_1        ind_a            4  30    5  30   30  30
# prov_2        ind_a           30  30   30  30    6  30
# prov_3        ind_b           30  30   30  50   30  60
#
# <class 'pandas.core.frame.DataFrame'>
#
# MultiIndex([('prov_1', 'ind_a'),
#             ('prov_2', 'ind_a'),
#             ('prov_3', 'ind_b')],
#            names=['data_provider', 'indicator'])
#
# MultiIndex([('country2', '2017', 1),
#             ('country2', '2017', 2),
#             ('country2', '2018', 2),
#             ('country2', '2018', 4),
#             ('country2', '2019', 3),
#             ('country2', '2019', 6)],
#            names=[None, 'year', 'country1'])

# keys = df3filtered.columns.get_loc(key=('country2',:, 2))
# print(keys)

可以根据列标签对其对应的值进行排序，参考这里15，如下：

df3sorted = df3filtered.sort_values([('country2', '2017', 2), ('country2', '2018', 2)], ascending=[False, False])
#                         country2
# year                        2017     2018     2019
# country1                       1   2    2   4    3   6
# data_provider indicator
# prov_2        ind_a           30  30   30  30    6  30
# prov_3        ind_b           30  30   30  50   30  60
# prov_1        ind_a            4  30    5  30   30  30
#
# <class 'pandas.core.frame.DataFrame'>
#
# MultiIndex([('prov_2', 'ind_a'),
#             ('prov_3', 'ind_b'),
#             ('prov_1', 'ind_a')],
#            names=['data_provider', 'indicator'])
#
# MultiIndex([('country2', '2017', 1),
#             ('country2', '2017', 2),
#             ('country2', '2018', 2),
#             ('country2', '2018', 4),
#             ('country2', '2019', 3),
#             ('country2', '2019', 6)],
#            names=[None, 'year', 'country1'])

符合某一大小或相等/不等的关系

此处以 df.lq 举例说明。

df.lt 等的用法与其相似，此处不再赘述


单索引

只能对 df2 中 dtypes 为数字类型的列进行关系方面的条件筛选，如下：

print(df2.dtypes)
# number        int64
# sex          object
# name         object
# age          object
# education    object

idx = df2[['number']].le(3)
#   number
# 0    True
# 1    True
# 2    True
# 3   False
# 4   False
#
# <class 'pandas.core.frame.DataFrame'>

print(idx.dtypes)
# number    bool
# dtype: object

df2filtered = df2[idx]
#    number  sex name  age education
# 0     1.0  NaN  NaN  NaN       NaN
# 1     2.0  NaN  NaN  NaN       NaN
# 2     3.0  NaN  NaN  NaN       NaN
# 3     NaN  NaN  NaN  NaN       NaN
# 4     NaN  NaN  NaN  NaN       NaN

多索引

由于 df3 中所有列的数据类型均为数字类型，所以可以直接使用 df3.le(value)，如下：

print(df3.dtypes)
#           year  country1
# country2  2017  1           int64
#                 2           int64
#           2018  2           int64
#                 4           int64
#           2019  3           int64
#                 6           int64
# dtype: object

idx = df3.le(10)
#                         country2
# year                        2017     2018     2019
# country1                       1   2    2   4    3   6
# data_provider indicator
# prov_1        ind_a          4.0 NaN  5.0 NaN  NaN NaN
# prov_2        ind_a          NaN NaN  NaN NaN  6.0 NaN
#               ind_b          NaN NaN  NaN NaN  NaN NaN
# prov_3        ind_b          NaN NaN  NaN NaN  NaN NaN
#
# <class 'pandas.core.frame.DataFrame'>

print(idx.dtypes)
#           year  country1
# country2  2017  1           bool
#                 2           bool
#           2018  2           bool
#                 4           bool
#           2019  3           bool
#                 6           bool
# dtype: object

df3filtered = df3[idx]
#                         country2
# year                        2017     2018     2019
# country1                       1   2    2   4    3   6
# data_provider indicator
# prov_1        ind_a          4.0 NaN  5.0 NaN  NaN NaN
# prov_2        ind_a          NaN NaN  NaN NaN  6.0 NaN
#               ind_b          NaN NaN  NaN NaN  NaN NaN
# prov_3        ind_b          NaN NaN  NaN NaN  NaN NaN

参考链接

  1. How to filter a Pandas DataFrame ↩︎

  2. pandas 筛选数据的 8 个骚操作 ↩︎

  3. pandas.DataFrame.filter ↩︎

  4. DataAnalysis/Pandas/Filter/Filter_RowOrCol.py ↩︎

  5. pandas通过list筛选行 ↩︎

  6. pandas通过list筛选行 ↩︎

  7. 【pandas】dataframe根据某列是否是null筛选数据 ↩︎

  8. pandas query() 表达式查询 ↩︎

  9. Querying for NaN and other names in Pandas ↩︎

  10. 常用大于等于小于的特殊标记LT、LE、EQ、NE、GE、GT ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎

  11. pandas基础：使用between方法进行数据分箱（Binning Data） ↩︎

  12. 请教用pandas处理数据时，如何对行数据进行筛选并赋值处理？ ↩︎

  13. pandas 用 .loc[,]=value 筛选并原地赋值回原来的 DataFrame ↩︎

  14. select range of values for all columns in pandas dataframe ↩︎

  15. How to Sort Multiple Columns in pandas DataFrame ↩︎

MissMango0820
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python-pandas-例子.docx
06-11
python pandas 例子 Python Pandas是一个强大的数据分析工具，它提供了丰富的数据结构和数据处理函数，可以帮助我们轻松地进行数据清洗、数据分析和数据可视化等工作。... 数据筛选 Pandas可以轻松地筛选Dat
Python Pandas条件筛选
热门推荐
Ghjkku的博客
03-06 13万+
筛选是在平时的工作中使用非常频繁的功能了 一、准备数据 import pandas as pd data = pd.read_excel(r'销售数据.xlsx') print(data) 数据如下： 二、以>，<，==，>=，<=来进行选择（“等于”一定是用‘==’，如果用‘=’就不是判断大小了）： 例如：筛选销售员是马姐的数据 df = data[data['销售员'] == '马姐'] 例如：筛选销售员是马姐的数据且天河店销量大于100的数据 .
pandas系列1——Series
m0_71772987的博客
06-09 2319
pandas入门笔记1
Python中pandas.Dataframe数据筛选
Desperdo
11-23 3万+
Dataframe可以实现强大的数据筛选功能，下面简单句几个例子： # 创建一个Dataframe： &amp;amp;amp;gt;&amp;amp;amp;gt;&amp;amp;amp;gt;import pandas as pd &amp;amp;amp;gt;
python中series按值选行_利用Python进行数据分析(第三篇上)
weixin_39821378的博客
02-03 1313
上一篇文章我记录了自己在入门 Python 学习的一些基础内容以及实际操作代码时所碰到的一些问题。这篇我将会记录我在学习和运用 Python 进行数据分析的过程：介绍 Numpy 和 Pandas 两个包运用 Numpy 和 Pandas 分析一维、二维数据数据分析的基本过程实战项目【用 Python 分析朝阳医院2018季度的药物销售数据】一、简单介绍 Numpy 和 Pandas 两个包Num...
pandas实现筛选功能方式
路在脚下
03-20 1万+
pandas实现筛选功能方式
Python：使用pandas对excel数据筛选选择
07-17
使用pandas对excel数据筛选选择素材资源
Python pandas.DataFrame 找出有空值的行
12-25
pandas中DataFrame类型中，找出所有有空值的行，可以使用.isnull()方法和.any()方法。 1.找出含有空值的行 方法：DataFrame[DataFrame.isnull().T.any()] 其中，isnull()能够判断数据中元素是否为空值；T为转置；any...
Python的Pandas库处理excel文件
12-22
 通过DataFrame筛选、过滤数据 生成新的excel  import pandas as pd #读取哪几列 columns=['姓名','失效时间'] #源文件地址 file_loc = "C:\\Users\\fang\\Desktop\\source.xlsx" df = pd.read_excel(file_loc,...
python中pandas.DataFrame排除特定行方法示例
12-24
大家在使用Python进行数据分析时，经常要使用到的一个数据结构就是pandas的DataFrame，关于python中pandas.DataFrame的基本操作，大家可以查看这篇文章。 pandas.DataFrame排除特定行 如果我们想要像Excel的筛选那样...
【Python】数据分析+数据挖掘——探索Pandas中的数据筛选
知识虔诚的信徒，探索所有未知是信徒毕生的信仰
07-29 1万+
当涉及数据处理和分析时，Pandas是Python编程语言中最强大、灵活且广泛使用的工具之一。Pandas提供了丰富的功能和方法，使得数据的选择、筛选和处理变得简单而高效。在本博客中，我们将重点介绍Pandas中数据筛选的关键知识点，包括条件索引、逻辑操作符、`query()`方法以及其他一些常用技巧~
【Python】pandas 筛选数据的 8 个骚操作
fengdu78的博客
06-13 4129
肝了一个月的pandas进阶小册子出炉了????「pandas进阶宝典」日常用Python做数据分析最常用到的就是查询筛选了，按各种条件、各种维度以及组合挑出我们想要的数据，以方便我们分析挖掘。东哥总结了日常查询和筛选常用的种骚操作，供各位学习参考。本文采用sklearn的boston数据举例介绍。fromsklearnimportdatasets importpandasaspd bos...
Python数据分析 2-2 Series对象 其他 本实验主要介绍Series对象相关的操作，包括Series对象的结构、创建、数据索引和筛选、算术运算、数值统计等。
m0_65523585的博客
02-24 744
numpy的基本用法 全全全
dataframe 筛选_Python学习第124课--筛选(或访问)series的两种方式和注意事项
weixin_39609953的博客
11-29 1642
【每天几分钟，从零入门python编程的世界！】我们可以把dataframe看做Excel中整个的一个数据表。●筛选某一列的head还是以上节的代码为例。筛选H这一列的head，可以这样写：运行结果：●筛选(访问)series的方式筛选或者说访问series的方式有两种：①dataframeName['seriesName']②dataframeName.seriesName大家可以自行敲代码试验...
python如何筛选出一个series中value大于1的值和索引
weixin_35757531的博客
01-05 1185
在 python 中使用 pandas 库可以很方便地处理数据。 首先需要导入 pandas 库： import pandas as pd 然后可以创建一个 series： s = pd.Series([0, 1, 2, 3, 4]) 现在，你可以使用类似于列表推导式的语法来筛选 series 中大于 1 的值： filtered_s = s[s > 1] print(filtered_...
Python数据分析 2-2 Series对象 其他 本实验主要介绍Series对象相关的操作，包括Series对象的结构、创建、数据索引和筛选、算术运算、数值统计等。 (2)
m0_65523585的博客
02-25 239
pandas 基本内容 全全全
pandas 筛选数据的 8 个骚操作
Elvis Hu的博客
09-12 587
日常用Python做数据分析最常用到的就是查询筛选了，按各种条件、各种维度以及组合挑出我们想要的数据，以方便我们分析挖掘。东哥总结了日常查询和筛选常用的种骚操作，供各位学习参考。本文采用sklearn的boston数据举例介绍。
【Python】Python中变量或者函数加下划线‘_‘的含义
yangweipeng708的博客
05-14 678
理解这些约定可以帮助Python开发者编写更清晰、更Pythonic的代码，并理解其他Python代码中的命名习惯。）通常用来指示特定的编程约定或用法，这些约定主要关乎变量和函数的可访问性以及预期的使用范围。在Python中，变量或函数前面加一个下划线（
python数据分析numpy基础之intersect1d求数组交集
最新发布
sinat_34735632的博客
05-19 194
python的numpy库的intersect1d(x,y)函数，计算x和y的公共元素，并返回去重后的有序结果。相当于求两个数组中的交集，并且进行去重和排序。numpy.intersect1()查找两个数组的公共元素，并且返回去重后的有序结果。ar1，ar2：必选，列表、元组、数组；如果是多维则自动转一维数组；assume_unique：可选，bool，默认False，若为True则可以加快计算素材，此时ar1和ar2需为元素唯一的数组，否则结果不会去重；
python pandas筛选空值
03-23
在Python的pandas库中，可以使用notnull()函数来筛空值。notnull()函数返回一个布尔值的DataFrame，其中True表示对应位置的值不是空值，False表示对应位置的值是空值[^1]。 以下是一个示例代码，演示如何使用not...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值