Python Pandas 数据选择：灵活筛选和操作数据的多种方式

本文详细介绍了在 Pandas 中如何进行数据选择与筛选，涵盖了 loc、iloc、条件过滤等多种操作方式。通过示例展示了如何选择单列、多列、特定行，以及基于标签和位置的选择方式。文中还介绍了 Series 与 DataFrame 的数据选择方法，结合 NumPy 数据与 Pandas 的互操作性，使数据处理更加灵活高效。此外，文章展示了如何利用条件过滤进行数据筛选，并通过使用 ~、| 和 & 操作符优化选择操作。这些技巧适用于需要高效处理数据的分析任务。

文章目录

Python Pandas 数据选择：灵活筛选和操作数据的多种方式
- - 一多种数据选择方式
  - - 构建表格数据
    - 选择单列数据
    - 选择多个列数据
  - 二使用 `loc` 选择数据
  - - NumPy 取数
    - DataFrame 取数
    - 选择特定行
    - 不按顺序设置索引
  - 三使用 `iloc` 按位置选择数据
  - 四 `loc` 和 `iloc` 混合使用
  - - 获取行标签
    - 根据标签选择列
    - 获取标签对应的索引
    - 获取标签对应的行索引
  - 五条件过滤数据
  - 六 Series 与 DataFrame 类似
  - 七完整代码示例
  - 八源码地址

导入依赖库

import pandas as pd
import numpy as np

一多种数据选择方式

构建表格数据

首先，我们构建一个包含 6 行 4 列的表格数据：

data = np.arange(-12, 12).reshape((6, 4))
df = pd.DataFrame(data, index=list("abcdef"), columns=list("ABCD"))
print(df)

选择单列数据

要选择单个列，例如列 “B”：

print(df["B"])

选择多个列数据

可以使用 NumPy 或 Pandas 选择多个列的数据：

print("numpy:\n", data[:, [2, 1]])
print("\ndf:\n", df[["C", "B"]])

二使用 `loc` 选择数据

loc 提供了基于标签的选择方式。

NumPy 取数

print(data[2:3, 1:3])

DataFrame 取数

print(df.loc["c":"d", "B":"D"])

选择特定行

可以选择特定的多行数据：

print("numpy:\n", data[[3, 1], :])
print("\ndf:\n", df.loc[["d", "b"], :])

不按顺序设置索引

创建一个不按顺序设置索引的 DataFrame：

df2 = pd.DataFrame(data, index=list("beacdf"), columns=list("ABCD"))
print(df2)
print(df2.loc["e":"c"])

三使用 `iloc` 按位置选择数据

iloc 用于基于整数位置选择数据。

print("numpy:\n", data[2:3, 1:3])
print("\ndf:\n", df.iloc[2:3, 1:3])
print("numpy:\n", data[[3, 1], :])
print("\ndf:\n", df.iloc[[3, 1], :])

四 `loc` 和 `iloc` 混合使用

获取行标签

首先使用序号索引转换成 loc 的标签索引：

row_labels = df.index[2:4]
print("row_labels:\n", row_labels)
print("\ndf:\n", df.loc[row_labels, ["A", "C"]])

根据标签选择列

col_labels = df.columns[[0, 3]]
print("col_labels:\n", col_labels)
print("\ndf:\n", df.loc[row_labels, col_labels])

获取标签对应的索引

使用标签获取对应的索引，并在 iloc 中使用：

col_index = df.columns.get_indexer(["A", "B"])
print("col_index:\n", col_index)
print("\ndf:\n", df.iloc[:2, col_index])

获取标签对应的行索引

print(df.index.get_indexer(["a", "b"]))

五条件过滤数据

可以基于条件筛选数据：

# 选择列 "A" 中小于 0 的数据
print(df[df["A"] < 0])

# 选择第一行数据不小于 -10 的列
print("~:\n", df.loc[:, ~(df.iloc[0] < -10)])
print("\n>=:\n", df.loc[:, df.iloc[0] >= -10])

# 选择第一行数据不小于 -10 或小于 -11 的列
print(df.loc[:, ~(df.iloc[0] < -10) | (df.iloc[0] < -11)])

loc 更适用于基于标签或条件的选择，而 iloc 更适用于基于位置的选择。

~ 表示 “非” 或者 “取反”。
| 表示 “或”（or）。
& 表示 “与”（and）。

六 Series 与 DataFrame 类似

Series 对象的使用与 DataFrame 非常相似：

list_data = list(range(-4, 4))
s = pd.Series(list_data, index=list("abcdefgh"))
print(s)

# 使用标签筛选数据
print(s.loc[["a", "g", "c"]], "\n")
print(s.loc["c": "f"])

# 使用索引位置筛选数据
print(s.iloc[[3, 1, 5]], "\n")
print(s.iloc[2: 4])

# 混合使用 `iloc` 和 `loc`
print(s.iloc[s.index.get_indexer(["c", "d"])] , "\n")
print(s.loc[s.index[[3, 2]]])

# 按条件过滤数据
print(s.loc[s < 3], "\n")
print(s.loc[(s < 0) & (s > -2)], "\n")
print(s.loc[(s < 0) | (s > 2)], "\n")

NumPy 数据和 Pandas 数据可以互相转换，方便数据处理。

七完整代码示例

# This is a sample Python script.

# Press ⌃R to execute it or replace it with your code.
# Press Double ⇧ to search everywhere for classes, files, tool windows, actions, and settings.
import pandas as pd
import numpy as np


def print_hi(name):
    # Use a breakpoint in the code line below to debug your script.
    print(f'Hi, {name}')  # Press ⌘F8 to toggle the breakpoint.
    # 主要方法
    # 选Column
    # loc
    # iloc
    # loc和iloc混搭
    # 条件过滤筛选
    # Series和DataFrame类似

    # 多种选取方式
    # 构建Excel 型的表格数据

    data = np.arange(-12, 12).reshape((6, 4))
    df = pd.DataFrame(
        data,
        index=list("abcdef"),
        columns=list("ABCD"))
    print(df)
    # 选Column
    print(df["B"])
    # 多选几个列
    print("numpy:\n", data[:, [2, 1]])
    print("\ndf:\n", df[["C", "B"]])

    # loc，像Excel一样取数
    # numpy取数
    print(data[2:3, 1:3])
    # DataFrame 取数
    print(df.loc["c":"d", "B":"D"])
    # 单行取数
    print("numpy:\n", data[[3, 1], :])
    print("\ndf:\n", df.loc[["d", "b"], :])
    # 不按顺序设置索引
    df2 = pd.DataFrame(
        data,
        index=list("beacdf"),
        columns=list("ABCD"))
    print(df2)
    print(df2.loc["e":"c"])

    # iloc，按数据位置取数
    print("numpy:\n", data[2:3, 1:3])
    print("\ndf:\n", df.iloc[2:3, 1:3])
    print("numpy:\n", data[[3, 1], :])
    print("\ndf:\n", df.iloc[[3, 1], :])

    # loc和iloc混搭
    # 序号索引转换成 .loc 的标签索引，根据索引获取标签
    row_labels = df.index[2:4]
    print("row_labels:\n", row_labels)
    print("\ndf:\n", df.loc[row_labels, ["A", "C"]])
    # labels 取 Column
    col_labels = df.columns[[0, 3]]
    print("col_labels:\n", col_labels)
    print("\ndf:\n", df.loc[row_labels, col_labels])
    # 把索引找出来放到 iloc 里用，根据标签获取索引
    col_index = df.columns.get_indexer(["A", "B"])
    print("col_index:\n", col_index)
    print("\ndf:\n", df.iloc[:2, col_index])
    # label 对应的 index
    print(df.index.get_indexer(["a", "b"]))

    # 条件过滤筛选
    # 选在 A Column 中小于 0 的那些数据
    print(df[df["A"] < 0])
    # 选在第一行数据不小于 -10 的数据 ，~ 来表示 非 或者 取反，第二种是直接用 >=-10 来筛选。
    print("~:\n", df.loc[:, ~(df.iloc[0] < -10)])
    print("\n>=:\n", df.loc[:, df.iloc[0] >= -10])
    # 选在第一行数据不小于 - 10 或小于 - 11 的数据
    # 或 | 来表示 or 的意思, & 表述 and
    print()
    i0 = df.iloc[0]
    print(i0)
    print(df.loc[:, ~(i0 < -10) | (i0 < -11)])
    print(~(df.iloc[0] < -10))
    # 基于标签或条件来选择数据，应该使用.loc；基于位置或已知的行列索引列表来选择数据，应该使用.iloc。

    # Series和DataFrame类似
    list_data = list(range(-4, 4))
    s = pd.Series(
        list_data,
        index=list("abcdefgh"))
    print(s)
    # 标签筛选数据.loc
    print(s.loc[["a", "g", "c"]], "\n")
    print(s.loc["c": "f"])
    # index 筛选数据.iloc
    print(s.iloc[[3, 1, 5]], "\n")
    print(s.iloc[2: 4])
    # iloc 和 loc 互相混用
    print(s.iloc[s.index.get_indexer(["c", "d"])], "\n")
    print(s.loc[s.index[[3, 2]]])
    # 按条件过滤筛选
    print(s.loc[s < 3], "\n")
    print(s.loc[(s < 0) & (s > -2)], "\n")
    print(s.loc[(s < 0) | (s > 2)], "\n")
    #  Numpy数据可以和Pandas数据 互转


if __name__ == '__main__':
    print_hi('选取数据')

# See PyCharm help at https://www.jetbrains.com/help/pycharm/

复制粘贴并覆盖到你的 main.py 中运行，运行结果如下。

Hi, 选取数据
    A   B   C   D
a -12 -11 -10  -9
b  -8  -7  -6  -5
c  -4  -3  -2  -1
d   0   1   2   3
e   4   5   6   7
f   8   9  10  11
a   -11
b    -7
c    -3
d     1
e     5
f     9
Name: B, dtype: int64
numpy:
 [[-10 -11]
 [ -6  -7]
 [ -2  -3]
 [  2   1]
 [  6   5]
 [ 10   9]]

df:
     C   B
a -10 -11
b  -6  -7
c  -2  -3
d   2   1
e   6   5
f  10   9
[[-3 -2]]
   B  C  D
c -3 -2 -1
d  1  2  3
numpy:
 [[ 0  1  2  3]
 [-8 -7 -6 -5]]

df:
    A  B  C  D
d  0  1  2  3
b -8 -7 -6 -5
    A   B   C   D
b -12 -11 -10  -9
e  -8  -7  -6  -5
a  -4  -3  -2  -1
c   0   1   2   3
d   4   5   6   7
f   8   9  10  11
   A  B  C  D
e -8 -7 -6 -5
a -4 -3 -2 -1
c  0  1  2  3
numpy:
 [[-3 -2]]

df:
    B  C
c -3 -2
numpy:
 [[ 0  1  2  3]
 [-8 -7 -6 -5]]

df:
    A  B  C  D
d  0  1  2  3
b -8 -7 -6 -5
row_labels:
 Index(['c', 'd'], dtype='object')

df:
    A  C
c -4 -2
d  0  2
col_labels:
 Index(['A', 'D'], dtype='object')

df:
    A  D
c -4 -1
d  0  3
col_index:
 [0 1]

df:
     A   B
a -12 -11
b  -8  -7
[0 1]
    A   B   C  D
a -12 -11 -10 -9
b  -8  -7  -6 -5
c  -4  -3  -2 -1
~:
     C   D
a -10  -9
b  -6  -5
c  -2  -1
d   2   3
e   6   7
f  10  11

>=:
     C   D
a -10  -9
b  -6  -5
c  -2  -1
d   2   3
e   6   7
f  10  11

A   -12
B   -11
C   -10
D    -9
Name: a, dtype: int64
    A   C   D
a -12 -10  -9
b  -8  -6  -5
c  -4  -2  -1
d   0   2   3
e   4   6   7
f   8  10  11
A    False
B    False
C     True
D     True
Name: a, dtype: bool
a   -4
b   -3
c   -2
d   -1
e    0
f    1
g    2
h    3
dtype: int64
a   -4
g    2
c   -2
dtype: int64 

c   -2
d   -1
e    0
f    1
dtype: int64
d   -1
b   -3
f    1
dtype: int64 

c   -2
d   -1
dtype: int64
c   -2
d   -1
dtype: int64 

d   -1
c   -2
dtype: int64
a   -4
b   -3
c   -2
d   -1
e    0
f    1
g    2
dtype: int64 

d   -1
dtype: int64 

a   -4
b   -3
c   -2
d   -1
h    3
dtype: int64