送你一个Python数据排序的好方法

学习 Pandas 排序方法 是开始或练习使用 Python进行基本数据分析的好方法。最常见的数据分析是使用电子表格、SQL或pandas 完成的。使用 Pandas 的一大优点是它可以处理大量数据并提供高性能的数据操作能力。

在本教程中，您将学习如何使用.sort_values()和.sort_index()，这将使您能够有效地对 DataFrame 中的数据进行排序。

在本教程结束时，您将知道如何：

  • 按一列或多列的值对Pandas DataFrame进行排序
  • 使用ascending参数更改排序顺序
  • 通过index使用对 DataFrame 进行排序.sort_index()
  • 在对值进行排序时组织缺失的数据
  • 使用set to 对DataFrame进行就地排序inplaceTrue

要学习本教程，您需要对Pandas DataFrames有基本的了解，并对从文件中读取数据有一定的了解。

Pandas 排序方法入门

快速提醒一下， DataFrame 是一种数据结构，行和列都带有标记的轴。您可以按行或列值以及行或列索引对 DataFrame 进行排序。

行和列都有索引，它是数据在 DataFrame 中位置的数字表示。您可以使用 DataFrame 的索引位置从特定行或列中检索数据。默认情况下，索引号从零开始。您也可以手动分配自己的索引。

准备数据集

在本教程中，您将使用美国环境保护署 (EPA) 为 1984 年至 2021 年间制造的车辆编制的燃油经济性数据。EPA 燃油经济性数据集非常棒，因为它包含许多不同类型的信息，您可以对其进行排序上，从文本到数字数据类型。该数据集总共包含八十三列。

要继续，您需要安装pandas Python 库。本教程中的代码是使用 pandas 1.2.0 和Python 3.9.1 执行的。

注意：整个燃油经济性数据集约为 18 MB。将整个数据集读入内存可能需要一两分钟。限制行数和列数有助于提高性能，但下载数据仍需要几秒钟的时间。

出于分析目的，您将按品牌、型号、年份和其他车辆属性查看车辆的 MPG（每加仑英里数）数据。您可以指定要读入 DataFrame 的列。对于本教程，您只需要可用列的子集。

以下是将燃油经济性数据集的相关列读入 DataFrame 并显示前五行的命令：

 
 
 
 
    
  
  
  
  
  1. >>>
    2. 
  
  
  
  
  2. >>> import pandas as pd
    3. 
  
  
  
  
  3. 
  
  
  
  
  4. >>> column_subset = [
    5. 
  
  
  
  
  5. ...     "id",
    6. 
  
  
  
  
  6. ...     "make",
    7. 
  
  
  
  
  7. ...     "model",
    8. 
  
  
  
  
  8. ...     "year",
    9. 
  
  
  
  
  9. ...     "cylinders",
    10. 
  
  
  
  
  10. ...     "fuelType",
    11. 
  
  
  
  
  11. ...     "trany",
    12. 
  
  
  
  
  12. ...     "mpgData",
    13. 
  
  
  
  
  13. ...     "city08",
    14. 
  
  
  
  
  14. ...     "highway08"
    15. 
  
  
  
  
  15. ... ]
    16. 
  
  
  
  
  16. 
  
  
  
  
  17. >>> df = pd.read_csv(
    18. 
  
  
  
  
  18. ...     "https://www.fueleconomy.gov/feg/epadata/vehicles.csv",
    19. 
  
  
  
  
  19. ...     usecols=column_subset,
    20. 
  
  
  
  
  20. ...     nrows=100
    21. 
  
  
  
  
  21. ... )
    22. 
  
  
  
  
  22. 
  
  
  
  
  23. >>> df.head()
    24. 
  
  
  
  
  24.    city08  cylinders fuelType  ...  mpgData            trany  year
    25. 
  
  
  
  
  25. 0      19          4  Regular  ...        Y     Manual 5-spd  1985
    26. 
  
  
  
  
  26. 1       9         12  Regular  ...        N     Manual 5-spd  1985
    27. 
  
  
  
  
  27. 2      23          4  Regular  ...        Y     Manual 5-spd  1985
    28. 
  
  
  
  
  28. 3      10          8  Regular  ...        N  Automatic 3-spd  1985
    29. 
  
  
  
  
  29. 4      17          4  Premium  ...        N     Manual 5-spd  1993
    30. 
  
  
  
  
  30. [5 rows x 10 columns]
    31.

通过.read_csv()使用数据集 URL 进行调用，您可以将数据加载到 DataFrame 中。缩小列会导致更快的加载时间和更少的内存使用。为了进一步限制内存消耗并快速了解数据，您可以使用 指定要加载的行数nrows。

熟悉 .sort_values()

您用于.sort_values()沿任一轴（列或行）对 D​​ataFrame 中的值进行排序。通常，您希望通过一列或多列的值对 DataFrame 中的行进行排序：

上图显示了使用.sort_values()根据highway08列中的值对 DataFrame 的行进行排序的结果。这类似于使用列对电子表格中的数据进行排序的方式。

熟悉 .sort_index()

您用于.sort_index()按行索引或列标签对 DataFrame 进行排序。与 using 的不同之处.sort_values()在于您是根据其行索引或列名称对 DataFrame 进行排序，而不是根据这些行或列中的值：

DataFrame 的行索引在上图中以蓝色标出。索引不被视为一列，您通常只有一个行索引。行索引可以被认为是从零开始的行号。

在单列上对 DataFrame 进行排序

要根据单列中的值对 DataFrame 进行排序，您将使用.sort_values(). 默认情况下，这将返回一个按升序排序的新 DataFrame。它不会修改原始 DataFrame。

按升序按列排序

要使用.sort_values()，请将单个参数传递给包含要作为排序依据的列的名称的方法。在此示例中，您按city08列对 DataFrame 进行排序，该列表示纯燃料汽车的城市 MPG：

 
 
 
 
    
  
  
  
  
  1. >>>
    2. 
  
  
  
  
  2. >>> df.sort_values("city08")
    3. 
  
  
  
  
  3.     city08  cylinders fuelType  ...  mpgData            trany  year
    4. 
  
  
  
  
  4. 99       9          8  Premium  ...        N  Automatic 4-spd  1993
    5. 
  
  
  
  
  5. 1        9         12  Regular  ...        N     Manual 5-spd  1985
    6. 
  
  
  
  
  6. 80       9          8  Regular  ...        N  Automatic 3-spd  1985
    7. 
  
  
  
  
  7. 47       9          8  Regular  ...        N  Automatic 3-spd  1985
    8. 
  
  
  
  
  8. 3       10          8  Regular  ...        N  Automatic 3-spd  1985
    9. 
  
  
  
  
  9. ..     ...        ...      ...  ...      ...              ...   ...
    10. 
  
  
  
  
  10. 9       23          4  Regular  ...        Y  Automatic 4-spd  1993
    11. 
  
  
  
  
  11. 8       23          4  Regular  ...        Y     Manual 5-spd  1993
    12. 
  
  
  
  
  12. 7       23          4  Regular  ...        Y  Automatic 3-spd  1993
    13. 
  
  
  
  
  13. 76      23          4  Regular  ...        Y     Manual 5-spd  1993
    14. 
  
  
  
  
  14. 2       23          4  Regular  ...        Y     Manual 5-spd  1985
    15. 
  
  
  
  
  15. [100 rows x 10 columns]
    16.

这将使用 中的列值对您的 DataFrame 进行排序city08，首先显示 MPG 最低的车辆。默认情况下， 按升序 .sort_values()对数据 进行排序 。尽管您没有为传递给 的参数指定名称，但.sort_values()您实际上使用了by参数，您将在下一个示例中看到该参数。

更改排序顺序

的另一个参数.sort_values()是ascending。默认情况下.sort_values()已经ascending设置True。如果您希望 DataFrame 按降序排序 ，则可以传递False给此参数：

 
 
 
 
    
  
  
  
  
  1. >>>
    2. 
  
  
  
  
  2. >>> df.sort_values(
    3. 
  
  
  
  
  3. ...     by="city08",
    4. 
  
  
  
  
  4. ...     ascending=False
    5. 
  
  
  
  
  5. ... )
    6. 
  
  
  
  
  6.     city08  cylinders fuelType  ...  mpgData            trany  year
    7. 
  
  
  
  
  7. 9       23          4  Regular  ...        Y  Automatic 4-spd  1993
    8. 
  
  
  
  
  8. 2       23          4  Regular  ...        Y     Manual 5-spd  1985
    9. 
  
  
  
  
  9. 7       23          4  Regular  ...        Y  Automatic 3-spd  1993
    10. 
  
  
  
  
  10. 8       23          4  Regular  ...        Y     Manual 5-spd  1993
    11. 
  
  
  
  
  11. 76      23          4  Regular  ...        Y     Manual 5-spd  1993
    12. 
  
  
  
  
  12. ..     ...        ...      ...  ...      ...              ...   ...
    13. 
  
  
  
  
  13. 58      10          8  Regular  ...        N  Automatic 3-spd  1985
    14. 
  
  
  
  
  14. 80       9          8  Regular  ...        N  Automatic 3-spd  1985
    15. 
  
  
  
  
  15. 1        9         12  Regular  ...        N     Manual 5-spd  1985
    16. 
  
  
  
  
  16. 47       9          8  Regular  ...        N  Automatic 3-spd  1985
    17. 
  
  
  
  
  17. 99       9          8  Premium  ...        N  Automatic 4-spd  1993
    18. 
  
  
  
  
  18. [100 rows x 10 columns]
    19.

通过传递False到ascending，您可以颠倒排序顺序。现在，您的 DataFrame 按城市条件下测量的平均 MPG 降序排序。MPG 值最高的车辆在第一排。

选择排序算法

值得注意的是，pandas 允许您选择不同的排序算法来与.sort_values()和一起使用.sort_index()。可用的算法quicksort，mergesort和heapsort。有关这些不同排序算法的更多信息，请查看Python 中的排序算法。

对单列进行排序时默认使用的算法是quicksort。要将其更改为稳定的排序算法，请使用mergesort。您可以使用or 中的kind参数来执行此操作，如下所示：.sort_values().sort_index()

 
 
 
 
    
  
  
  
  
  1. >>>
    2. 
  
  
  
  
  2. >>> df.sort_values(
    3. 
  
  
  
  
  3. ...     by="city08",
    4. 
  
  
  
  
  4. ...     ascending=False,
    5. 
  
  
  
  
  5. ...     kind="mergesort"
    6. 
  
  
  
  
  6. ... )
    7. 
  
  
  
  
  7.     city08  cylinders fuelType  ...  mpgData            trany  year
    8. 
  
  
  
  
  8. 2       23          4  Regular  ...        Y     Manual 5-spd  1985
    9. 
  
  
  
  
  9. 7       23          4  Regular  ...        Y  Automatic 3-spd  1993
    10. 
  
  
  
  
  10. 8       23          4  Regular  ...        Y     Manual 5-spd  1993
    11. 
  
  
  
  
  11. 9       23          4  Regular  ...        Y  Automatic 4-spd  1993
    12. 
  
  
  
  
  12. 10      23          4  Regular  ...        Y     Manual 5-spd  1993
    13. 
  
  
  
  
  13. ..     ...        ...      ...  ...      ...              ...   ...
    14. 
  
  
  
  
  14. 69      10          8  Regular  ...        N  Automatic 3-spd  1985
    15. 
  
  
  
  
  15. 1        9         12  Regular  ...        N     Manual 5-spd  1985
    16. 
  
  
  
  
  16. 47       9          8  Regular  ...        N  Automatic 3-spd  1985
    17. 
  
  
  
  
  17. 80       9          8  Regular  ...        N  Automatic 3-spd  1985
    18. 
  
  
  
  
  18. 99       9          8  Premium  ...        N  Automatic 4-spd  1993
    19. 
  
  
  
  
  19. [100 rows x 10 columns]
    20.

使用kind，您将排序算法设置为mergesort。之前的输出使用了默认quicksort算法。查看突出显示的索引，您可以看到行的顺序不同。这是因为quicksort不是稳定的排序算法，而是mergesort。

注意：在 Pandas 中，kind当您对多个列或标签进行排序时会被忽略。

当您对具有相同键的多条记录进行排序时，稳定的排序算法将在排序后保持这些记录的原始顺序。因此，如果您计划执行多种排序，则必须使用稳定的排序算法。

在多列上对 DataFrame 进行排序

在数据分析中，通常希望根据多列的值对数据进行排序。想象一下，您有一个包含人们名字和姓氏的数据集。先按姓然后按名字排序是有意义的，这样姓氏相同的人会根据他们的名字按字母顺序排列。

在第一个示例中，您在名为 的单个列上对 DataFrame 进行了排序city08。从分析的角度来看，城市条件下的 MPG 是决定汽车受欢迎程度的重要因素。除了城市条件下的 MPG，您可能还想查看高速公路条件下的 MPG。要按两个键排序，您可以将列名列表传递给by：

 
 
 
 
    
  
  
  
  
  1. >>>
    2. 
  
  
  
  
  2. >>> df.sort_values(
    3. 
  
  
  
  
  3. ...     by=["city08", "highway08"]
    4. 
  
  
  
  
  4. ... )[["city08", "highway08"]]
    5. 
  
  
  
  
  5.     city08  highway08
    6. 
  
  
  
  
  6. 80       9         10
    7. 
  
  
  
  
  7. 47       9         11
    8. 
  
  
  
  
  8. 99       9         13
    9. 
  
  
  
  
  9. 1        9         14
    10. 
  
  
  
  
  10. 58      10         11
    11. 
  
  
  
  
  11. ..     ...        ...
    12. 
  
  
  
  
  12. 9       23         30
    13. 
  
  
  
  
  13. 10      23         30
    14. 
  
  
  
  
  14. 8       23         31
    15. 
  
  
  
  
  15. 76      23         31
    16. 
  
  
  
  
  16. 2       23         33
    17. 
  
  
  
  
  17. [100 rows x 2 columns]
    18.

通过指定列名称city08和的列表highway08，您可以使用 对两列上的 DataFrame 进行排序.sort_values()。下一个示例将解释如何指定排序顺序以及为什么注意您使用的列名列表很重要。

按升序按多列排序

要在多个列上对 DataFrame 进行排序，您必须提供一个列名称列表。例如，要按make和排序model，您应该创建以下列表，然后将其传递给.sort_values()：

 
 
 
 
    
  
  
  
  
  1. >>>
    2. 
  
  
  
  
  2. >>> df.sort_values(
    3. 
  
  
  
  
  3. ...     by=["make", "model"]
    4. 
  
  
  
  
  4. ... )[["make", "model"]]
    5. 
  
  
  
  
  5.           make               model
    6. 
  
  
  
  
  6. 0   Alfa Romeo  Spider Veloce 2000
    7. 
  
  
  
  
  7. 18        Audi                 100
    8. 
  
  
  
  
  8. 19        Audi                 100
    9. 
  
  
  
  
  9. 20         BMW                740i
    10. 
  
  
  
  
  10. 21         BMW               740il
    11. 
  
  
  
  
  11. ..         ...                 ...
    12. 
  
  
  
  
  12. 12  Volkswagen      Golf III / GTI
    13. 
  
  
  
  
  13. 13  Volkswagen           Jetta III
    14. 
  
  
  
  
  14. 15  Volkswagen           Jetta III
    15. 
  
  
  
  
  15. 16       Volvo                 240
    16. 
  
  
  
  
  16. 17       Volvo                 240
    17. 
  
  
  
  
  17. [100 rows x 2 columns]
    18.

现在您的 DataFrame 按升序排序make。如果有两个或更多相同的品牌，则按 排序model。在列表中指定列名的顺序对应于 DataFrame 的排序方式。

更改列排序顺序

由于您使用多列进行排序，因此您可以指定列的排序顺序。如果要更改上一个示例中的逻辑排序顺序，则可以更改传递给by参数的列表中列名的顺序：

 
 
 
 
    
  
  
  
  
  1. >>>
    2. 
  
  
  
  
  2. >>> df.sort_values(
    3. 
  
  
  
  
  3. ...     by=["model", "make"]
    4. 
  
  
  
  
  4. ... )[["make", "model"]]
    5. 
  
  
  
  
  5.              make        model
    6. 
  
  
  
  
  6. 18           Audi          100
    7. 
  
  
  
  
  7. 19           Audi          100
    8. 
  
  
  
  
  8. 16          Volvo          240
    9. 
  
  
  
  
  9. 17          Volvo          240
    10. 
  
  
  
  
  10. 75          Mazda          626
    11. 
  
  
  
  
  11. ..            ...          ...
    12. 
  
  
  
  
  12. 62           Ford  Thunderbird
    13. 
  
  
  
  
  13. 63           Ford  Thunderbird
    14. 
  
  
  
  
  14. 88     Oldsmobile     Toronado
    15. 
  
  
  
  
  15. 42  CX Automotive        XM v6
    16. 
  
  
  
  
  16. 43  CX Automotive       XM v6a
    17. 
  
  
  
  
  17. [100 rows x 2 columns]
    18.

您的 DataFrame 现在按model升序按列排序，然后按make是否有两个或更多相同模型进行排序。您可以看到更改列的顺序也会更改值的排序顺序。

按降序按多列排序

到目前为止，您仅对多列按升序排序。在下一个示例中，您将根据make和model列按降序排序。要按降序排序，请设置ascending为False：

 
 
 
 
    
  
  
  
  
  1. >>>
    2. 
  
  
  
  
  2. >>> df.sort_values(
    3. 
  
  
  
  
  3. ...     by=["make", "model"],
    4. 
  
  
  
  
  4. ...     ascending=False
    5. 
  
  
  
  
  5. ... )[["make", "model"]]
    6. 
  
  
  
  
  6.           make               model
    7. 
  
  
  
  
  7. 16       Volvo                 240
    8. 
  
  
  
  
  8. 17       Volvo                 240
    9. 
  
  
  
  
  9. 13  Volkswagen           Jetta III
    10. 
  
  
  
  
  10. 15  Volkswagen           Jetta III
    11. 
  
  
  
  
  11. 11  Volkswagen      Golf III / GTI
    12. 
  
  
  
  
  12. ..         ...                 ...
    13. 
  
  
  
  
  13. 21         BMW               740il
    14. 
  
  
  
  
  14. 20         BMW                740i
    15. 
  
  
  
  
  15. 18        Audi                 100
    16. 
  
  
  
  
  16. 19        Audi                 100
    17. 
  
  
  
  
  17. 0   Alfa Romeo  Spider Veloce 2000
    18. 
  
  
  
  
  18. [100 rows x 2 columns]
    19.

该make列中的值按字母顺序model倒序排列，对于具有相同make. 对于文本数据，排序区分大小写，这意味着大写文本将首先按升序出现，最后按降序出现。

按具有不同排序顺序的多列排序

您可能想知道是否可以使用多个列进行排序并让这些列使用不同的ascending参数。使用熊猫，您可以通过单个方法调用来完成此操作。如果要按升序对某些列进行排序，并按降序对某些列进行排序，则可以将布尔值列表传递给ascending.

在这个例子中，您排列数据帧由make，model和city08列，与前两列按照升序排序和city08按降序排列。为此，您将列名列表传递给by和布尔值列表传递给ascending：

 
 
 
 
    
  
  
  
  
  1. >>>
    2. 
  
  
  
  
  2. >>> df.sort_values(
    3. 
  
  
  
  
  3. ...     by=["make", "model", "city08"],
    4. 
  
  
  
  
  4. ...     ascending=[True, True, False]
    5. 
  
  
  
  
  5. ... )[["make", "model", "city08"]]
    6. 
  
  
  
  
  6.           make               model  city08
    7. 
  
  
  
  
  7. 0   Alfa Romeo  Spider Veloce 2000      19
    8. 
  
  
  
  
  8. 18        Audi                 100      17
    9. 
  
  
  
  
  9. 19        Audi                 100      17
    10. 
  
  
  
  
  10. 20         BMW                740i      14
    11. 
  
  
  
  
  11. 21         BMW               740il      14
    12. 
  
  
  
  
  12. ..         ...                 ...     ...
    13. 
  
  
  
  
  13. 11  Volkswagen      Golf III / GTI      18
    14. 
  
  
  
  
  14. 15  Volkswagen           Jetta III      20
    15. 
  
  
  
  
  15. 13  Volkswagen           Jetta III      18
    16. 
  
  
  
  
  16. 17       Volvo                 240      19
    17. 
  
  
  
  
  17. 16       Volvo                 240      18
    18. 
  
  
  
  
  18. [100 rows x 3 columns]
    19.

现在你的数据帧进行排序make，并model在按升序排列，但与city08按降序排列列。这很有用，因为它按分类顺序对汽车进行分组，并首先显示最高 MPG 的汽车。

根据索引对 DataFrame 进行排序

在对索引进行排序之前，最好先了解索引代表什么。DataFrame 有一个 .index 属性，默认情况下它是其行位置的数字表示。您可以将索引视为行号。它有助于快速行查找和识别。

按升序按索引排序

您可以根据行索引对 DataFrame 进行排序.sort_index()。像在前面的示例中一样按列值排序会重新排序 DataFrame 中的行，因此索引变得杂乱无章。当您过滤 DataFrame 或删除或添加行时，也会发生这种情况。

为了说明 的使用.sort_index()，首先使用以下方法创建一个新的排序 DataFrame .sort_values()：

 
 
 
 
    
  
  
  
  
  1. >>>
    2. 
  
  
  
  
  2. >>> sorted_df = df.sort_values(by=["make", "model"])
    3. 
  
  
  
  
  3. >>> sorted_df
    4. 
  
  
  
  
  4.     city08  cylinders fuelType  ...  mpgData            trany  year
    5. 
  
  
  
  
  5. 0       19          4  Regular  ...        Y     Manual 5-spd  1985
    6. 
  
  
  
  
  6. 18      17          6  Premium  ...        Y  Automatic 4-spd  1993
    7. 
  
  
  
  
  7. 19      17          6  Premium  ...        N     Manual 5-spd  1993
    8. 
  
  
  
  
  8. 20      14          8  Premium  ...        N  Automatic 5-spd  1993
    9. 
  
  
  
  
  9. 21      14          8  Premium  ...        N  Automatic 5-spd  1993
    10. 
  
  
  
  
  10. ..     ...        ...      ...  ...      ...              ...   ...
    11. 
  
  
  
  
  11. 12      21          4  Regular  ...        Y     Manual 5-spd  1993
    12. 
  
  
  
  
  12. 13      18          4  Regular  ...        N  Automatic 4-spd  1993
    13. 
  
  
  
  
  13. 15      20          4  Regular  ...        N     Manual 5-spd  1993
    14. 
  
  
  
  
  14. 16      18          4  Regular  ...        Y  Automatic 4-spd  1993
    15. 
  
  
  
  
  15. 17      19          4  Regular  ...        Y     Manual 5-spd  1993
    16. 
  
  
  
  
  16. [100 rows x 10 columns]
    17.

您已经创建了一个使用多个值排序的 DataFrame。请注意行索引是如何没有特定顺序的。要将新 DataFrame 恢复到原始顺序，您可以使用.sort_index()：

 
 
 
 
    
  
  
  
  
  1. >>>
    2. 
  
  
  
  
  2. >>> sorted_df.sort_index()
    3. 
  
  
  
  
  3.     city08  cylinders fuelType  ...  mpgData            trany  year
    4. 
  
  
  
  
  4. 0       19          4  Regular  ...        Y     Manual 5-spd  1985
    5. 
  
  
  
  
  5. 1        9         12  Regular  ...        N     Manual 5-spd  1985
    6. 
  
  
  
  
  6. 2       23          4  Regular  ...        Y     Manual 5-spd  1985
    7. 
  
  
  
  
  7. 3       10          8  Regular  ...        N  Automatic 3-spd  1985
    8. 
  
  
  
  
  8. 4       17          4  Premium  ...        N     Manual 5-spd  1993
    9. 
  
  
  
  
  9. ..     ...        ...      ...  ...      ...              ...   ...
    10. 
  
  
  
  
  10. 95      17          6  Regular  ...        Y  Automatic 3-spd  1993
    11. 
  
  
  
  
  11. 96      17          6  Regular  ...        N  Automatic 4-spd  1993
    12. 
  
  
  
  
  12. 97      15          6  Regular  ...        N  Automatic 4-spd  1993
    13. 
  
  
  
  
  13. 98      15          6  Regular  ...        N     Manual 5-spd  1993
    14. 
  
  
  
  
  14. 99       9          8  Premium  ...        N  Automatic 4-spd  1993
    15. 
  
  
  
  
  15. [100 rows x 10 columns]
    16.

现在索引按升序排列。就像in.sort_values()的默认参数是，您可以通过传递 更改为降序。对索引进行排序对数据本身没有影响，因为值不变。ascending.sort_index()TrueFalse

当您使用. set_index() . 如果要使用make和model列设置自定义索引，则可以将列表传递给.set_index()：

 
 
 
 
    
  
  
  
  
  1. >>>
    2. 
  
  
  
  
  2. >>> assigned_index_df = df.set_index(
    3. 
  
  
  
  
  3. ...     ["make", "model"]
    4. 
  
  
  
  
  4. ... )
    5. 
  
  
  
  
  5. >>> assigned_index_df
    6. 
  
  
  
  
  6.                                   city08  cylinders  ...            trany  year
    7. 
  
  
  
  
  7. make        model                                    ...
    8. 
  
  
  
  
  8. Alfa Romeo  Spider Veloce 2000        19          4  ...     Manual 5-spd  1985
    9. 
  
  
  
  
  9. Ferrari     Testarossa                 9         12  ...     Manual 5-spd  1985
    10. 
  
  
  
  
  10. Dodge       Charger                   23          4  ...     Manual 5-spd  1985
    11. 
  
  
  
  
  11.             B150/B250 Wagon 2WD       10          8  ...  Automatic 3-spd  1985
    12. 
  
  
  
  
  12. Subaru      Legacy AWD Turbo          17          4  ...     Manual 5-spd  1993
    13. 
  
  
  
  
  13.                                   ...        ...  ...              ...   ...
    14. 
  
  
  
  
  14. Pontiac     Grand Prix                17          6  ...  Automatic 3-spd  1993
    15. 
  
  
  
  
  15.             Grand Prix                17          6  ...  Automatic 4-spd  1993
    16. 
  
  
  
  
  16.             Grand Prix                15          6  ...  Automatic 4-spd  1993
    17. 
  
  
  
  
  17.             Grand Prix                15          6  ...     Manual 5-spd  1993
    18. 
  
  
  
  
  18. Rolls-Royce Brooklands/Brklnds L       9          8  ...  Automatic 4-spd  1993
    19. 
  
  
  
  
  19. [100 rows x 8 columns]
    20.

使用此方法，您可以用两个轴标签替换默认的基于整数的行索引。这被认为是一个MultiIndex或一个 层次索引 。您的 DataFrame 现在由多个键索引，您可以使用.sort_index()以下键进行排序：

 
 
 
 
    
  
  
  
  
  1. >>>
    2. 
  
  
  
  
  2. >>> assigned_index_df.sort_index()
    3. 
  
  
  
  
  3.                                city08  cylinders  ...            trany  year
    4. 
  
  
  
  
  4. make       model                                  ...
    5. 
  
  
  
  
  5. Alfa Romeo Spider Veloce 2000      19          4  ...     Manual 5-spd  1985
    6. 
  
  
  
  
  6. Audi       100                     17          6  ...  Automatic 4-spd  1993
    7. 
  
  
  
  
  7.            100                     17          6  ...     Manual 5-spd  1993
    8. 
  
  
  
  
  8. BMW        740i                    14          8  ...  Automatic 5-spd  
                新闻名称：送你一个Python数据排序的好方法
                
    
                网址分享：http://www.mswzjz.cn/qtweb/news1/466551.html
            
    
            
    
                攀枝花网站建设、攀枝花网站运维推广公司-贝锐智能，是专注品牌与效果的网络营销公司；服务项目有等
                                
    
            
    
                广告
                
            
    
            
    
                声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：
                贝锐智能

贝锐智能技术为您推荐以下文章

企业网站制作知识

分类信息网站

域名注册　　 　网站制作　　 　APP定制开发　　 　微信小程序开发　　 　网站建设公司　　 　成都小程序开发　　 　成都展柜设计公司　　 　微信小程序　　 　云主机　　 　成都广告设计公司　　 　雕琢时光茶叶　　 　深圳纱窗安装　　 　wap网站建设　　 　成都翻译公司　　 　香港四川國際商會　　 　网站托管运营　　 　成都服务器托管　　 　固迪佳新材料　　 　成都二枢电信服务器托管　　 　营山网站建设