In [1]: import pandas as pd
本教程使用的数据:
  • 本教程使用泰坦尼克号数据集,存储为 CSV。数据由以下数据列组成:

    • PassengerId:每位乘客的 ID。

    • Survived:表示乘客是否幸存。0对于是和1否。

    • Pclass:3 个票价类别之一: Class 1、 Class2和 Class 3

    • 姓名:乘客姓名。

    • 性别:乘客的性别。

    • 年龄:乘客的年龄(岁)。

    • SibSp:船上兄弟姐妹或配偶的数量。

    • Parch:船上父母或儿童的数量。

    • 票号:旅客的票号。

    • 票价:表示票价。

    • 客舱:乘客的客舱编号。

    • 登船:登船港口。

    至原始数据
    In [2]: titanic = pd.read_csv("data/titanic.csv")
    
    In [3]: titanic.head()
    Out[3]: 
       PassengerId  Survived  Pclass  ...     Fare Cabin  Embarked
    0            1         0       3  ...   7.2500   NaN         S
    1            2         1       1  ...  71.2833   C85         C
    2            3         1       3  ...   7.9250   NaN         S
    3            4         1       1  ...  53.1000  C123         S
    4            5         0       3  ...   8.0500   NaN         S
    
    [5 rows x 12 columns]
    

如何选择 a 的子集DataFrame#

如何从 a 中选择特定列DataFrame#

../../_images/03_subset_columns.svg
  • 我对泰坦尼克号乘客的年龄感兴趣。

    In [4]: ages = titanic["Age"]
    
    In [5]: ages.head()
    Out[5]: 
    0    22.0
    1    38.0
    2    26.0
    3    35.0
    4    35.0
    Name: Age, dtype: float64
    

    要选择单个列,请使用方括号[]和感兴趣列的列名称。

a 中的每一列DataFrame都是一个Series.当选择单个列时,返回的对象是 pandas Series。我们可以通过检查输出的类型来验证这一点:

In [6]: type(titanic["Age"])
Out[6]: pandas.core.series.Series

看看shape输出:

In [7]: titanic["Age"].shape
Out[7]: (891,)

DataFrame.shape是 pandas 的一个属性(记住读写教程,不要使用括号作为属性)SeriesDataFrame包含行数和列数:(nrows, ncolumns)。 pandas Series 是一维的,仅返回行数。

  • 我对泰坦尼克号乘客的年龄和性别感兴趣。

    In [8]: age_sex = titanic[["Age", "Sex"]]
    
    In [9]: age_sex.head()
    Out[9]: 
        Age     Sex
    0  22.0    male
    1  38.0  female
    2  26.0  female
    3  35.0  female
    4  35.0    male
    

    要选择多个列,请在选择括号内使用列名称列表[]

笔记

内部方括号定义 带有列名称的Python 列表,而外部方括号用于从 pandas 中选择数据 DataFrame,如上例所示。

返回的数据类型是 pandas DataFrame:

In [10]: type(titanic[["Age", "Sex"]])
Out[10]: pandas.core.frame.DataFrame
In [11]: titanic[["Age", "Sex"]].shape
Out[11]: (891, 2)

选择返回DataFrame891 行 2 列。请记住,a DataFrame是具有行维度和列维度的二维。

转至用户指南

有关索引的基本信息,请参阅用户指南中有关索引和选择数据的部分。

如何从 a 中过滤特定行DataFrame#

../../_images/03_subset_rows.svg
  • 我对 35 岁以上的乘客感兴趣。

    In [12]: above_35 = titanic[titanic["Age"] > 35]
    
    In [13]: above_35.head()
    Out[13]: 
        PassengerId  Survived  Pclass  ...     Fare Cabin  Embarked
    1             2         1       1  ...  71.2833   C85         C
    6             7         0       1  ...  51.8625   E46         S
    11           12         1       1  ...  26.5500  C103         S
    13           14         0       3  ...  31.2750   NaN         S
    15           16         1       2  ...  16.0000   NaN         S
    
    [5 rows x 12 columns]
    

    要根据条件表达式选择行,请在选择括号内使用条件[]

选择括号内的条件检查列 的值大于 35 的行:titanic["Age"] > 35Age

In [14]: titanic["Age"] > 35
Out[14]: 
0      False
1       True
2      False
3      False
4      False
       ...  
886    False
887    False
888    False
889    False
890    False
Name: Age, Length: 891, dtype: bool

条件表达式的输出(>,但也==, !=, <, <=,... 可以工作)实际上是一个Series布尔值(TrueFalse)的 pandas ,其行数与原始 的行数相同DataFrame。这样Series的布尔值可用于DataFrame通过将其放在选择括号之间来过滤[]。仅True 选择值为 的行。

我们之前就知道,原来的泰坦尼克号DataFrame由 891 排组成。让我们通过检查shape结果的属性 来看看满足条件的行数DataFrame above_35

In [15]: above_35.shape
Out[15]: (217, 12)
  • 我对泰坦尼克号客舱 2 级和 3 级的乘客感兴趣。

    In [16]: class_23 = titanic[titanic["Pclass"].isin([2, 3])]
    
    In [17]: class_23.head()
    Out[17]: 
       PassengerId  Survived  Pclass  ...     Fare Cabin  Embarked
    0            1         0       3  ...   7.2500   NaN         S
    2            3         1       3  ...   7.9250   NaN         S
    4            5         0       3  ...   8.0500   NaN         S
    5            6         0       3  ...   8.4583   NaN         Q
    7            8         0       3  ...  21.0750   NaN         S
    
    [5 rows x 12 columns]
    

    与条件表达式类似,条件函数为提供的列表中的每一行isin()返回一个值。True要根据此类函数过滤行,请在选择括号内使用条件函数[]。在本例中,选择括号内的条件检查列为 2 或 3 的行。titanic["Pclass"].isin([2, 3])Pclass

以上相当于按类为 2 或 3 的行进行过滤,并使用|(或)运算符将这两个语句组合起来:

In [18]: class_23 = titanic[(titanic["Pclass"] == 2) | (titanic["Pclass"] == 3)]

In [19]: class_23.head()
Out[19]: 
   PassengerId  Survived  Pclass  ...     Fare Cabin  Embarked
0            1         0       3  ...   7.2500   NaN         S
2            3         1       3  ...   7.9250   NaN         S
4            5         0       3  ...   8.0500   NaN         S
5            6         0       3  ...   8.4583   NaN         Q
7            8         0       3  ...  21.0750   NaN         S

[5 rows x 12 columns]

笔记

当组合多个条件语句时,每个条件都必须用括号括起来()。而且,不能使用 or/,and而需要使用or运算符|and 运算符&

转至用户指南

请参阅用户指南中有关布尔索引isin 函数的专门部分。

  • 我想处理已知年龄的乘客数据。

    In [20]: age_no_na = titanic[titanic["Age"].notna()]
    
    In [21]: age_no_na.head()
    Out[21]: 
       PassengerId  Survived  Pclass  ...     Fare Cabin  Embarked
    0            1         0       3  ...   7.2500   NaN         S
    1            2         1       1  ...  71.2833   C85         C
    2            3         1       3  ...   7.9250   NaN         S
    3            4         1       1  ...  53.1000  C123         S
    4            5         0       3  ...   8.0500   NaN         S
    
    [5 rows x 12 columns]
    

    条件函数为每一行notna()返回一个True值不是值的值Null。因此,这可以与选择括号结合[]来过滤数据表。

您可能想知道到底发生了什么变化,因为前 5 行仍然是相同的值。验证的一种方法是检查形状是否已更改:

In [22]: age_no_na.shape
Out[22]: (714, 12)
转至用户指南

有关缺失值的更多专用函数,请参阅用户指南中有关处理缺失数据的部分。

如何从 中选择特定的行和列DataFrame#

../../_images/03_subset_columns_rows.svg
  • 我对 35 岁以上乘客的姓名感兴趣。

    In [23]: adult_names = titanic.loc[titanic["Age"] > 35, "Name"]
    
    In [24]: adult_names.head()
    Out[24]: 
    1     Cumings, Mrs. John Bradley (Florence Briggs Th...
    6                               McCarthy, Mr. Timothy J
    11                             Bonnell, Miss. Elizabeth
    13                          Andersson, Mr. Anders Johan
    15                     Hewlett, Mrs. (Mary D Kingcome) 
    Name: Name, dtype: object
    

    在这种情况下,行和列的子集是一次性生成的,仅使用选择括号[]是不够的。选择括号前面需要loc/运算符 。使用/时,逗号之前的部分是您想要选择的行,逗号之后的部分是您想要选择的列。iloc[]lociloc

使用列名称、行标签或条件表达式时,请loc在选择括号前面使用运算符[]。对于逗号之前和之后的部分,您可以使用单个标签、标签列表、标签切片、条件表达式或冒号。使用冒号指定您要选择所有行或列。

  • 我对第 10 行到第 25 行和第 3 到第 5 列感兴趣。

    In [25]: titanic.iloc[9:25, 2:5]
    Out[25]: 
        Pclass                                 Name     Sex
    9        2  Nasser, Mrs. Nicholas (Adele Achem)  female
    10       3      Sandstrom, Miss. Marguerite Rut  female
    11       1             Bonnell, Miss. Elizabeth  female
    12       3       Saundercock, Mr. William Henry    male
    13       3          Andersson, Mr. Anders Johan    male
    ..     ...                                  ...     ...
    20       2                 Fynney, Mr. Joseph J    male
    21       2                Beesley, Mr. Lawrence    male
    22       3          McGowan, Miss. Anna "Annie"  female
    23       1         Sloper, Mr. William Thompson    male
    24       3        Palsson, Miss. Torborg Danira  female
    
    [16 rows x 3 columns]
    

    同样,行和列的子集是一次性生成的,仅使用选择括号[]已经不够了。当根据表中的位置对某些行和/或列特别感兴趣时,请iloc在选择括号前面使用运算符[]

loc当使用或选择特定行和/或列时iloc,可以将新值分配给所选数据。例如,要将名称分配anonymous给第四列的前 3 个元素:

In [26]: titanic.iloc[0:3, 3] = "anonymous"

In [27]: titanic.head()
Out[27]: 
   PassengerId  Survived  Pclass  ...     Fare Cabin  Embarked
0            1         0       3  ...   7.2500   NaN         S
1            2         1       1  ...  71.2833   C85         C
2            3         1       3  ...   7.9250   NaN         S
3            4         1       1  ...  53.1000  C123         S
4            5         0       3  ...   8.0500   NaN         S

[5 rows x 12 columns]
转至用户指南

请参阅有关不同索引选择的用户指南部分,以更深入地了解loc和的用法iloc

记住

  • 选择数据子集时,[]使用方括号。

  • 在这些括号内,您可以使用单个列/行标签、列/行标签列表、标签切片、条件表达式或冒号。

  • loc使用行和列名称时选择特定的行和/或列。

  • iloc使用表中的位置时,选择特定的行和/或列。

  • loc您可以根据/为选择分配新值iloc

转至用户指南

关于索引和选择数据的用户指南页面提供了索引的完整概述。