亚博捕鱼博彩平台是否支持电脑客户端_

 欧博体育欧博体育

学习 Pandas 排序循序 是最先或教训使用 Python进行基本数据分析的好循序。最常见的数据分析是使用电子表格、SQL或pandas 完成的。使用 Pandas 的一大优点是它可以搞定多数数据并提供高性能的数据操作才能。

皇冠信用平台开发

皇冠hg86a

在本教程中，您将学习若何使用.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 的列。关于本教程，您只需要可用列的子集。

2022世界杯彩票玩法

以下是将燃油经济性数据集的磋议列读入 DataFrame 并裸露前五行的号召：

>>> >>> import pandas as pd  >>> column_subset = [ ...     "id", ...     "make", ...     "model", ...     "year", ...     "cylinders", ...     "fuelType", ...     "trany", ...     "mpgData", ...     "city08", ...     "highway08" ... ]  >>> df = pd.read_csv( ...     "https://www.fueleconomy.gov/feg/epadata/vehicles.csv", ...     usecols=column_subset, ...     nrows=100 ... )  >>> df.head()    city08  cylinders fuelType  ...  mpgData            trany  year 0      19          4  Regular  ...        Y     Manual 5-spd  1985 1       9         12  Regular  ...        N     Manual 5-spd  1985 2      23          4  Regular  ...        Y     Manual 5-spd  1985 3      10          8  Regular  ...        N  Automatic 3-spd  1985 4      17          4  Premium  ...        N     Manual 5-spd  1993 [5 rows x 10 columns] 

通过.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：

数据显示，全国法院诉前调解纠纷770.7万件，占诉至法院纠纷量的36%，同比增长41.5%，调解平均时长13.9天。其中，499.6万件调解成功，同比增长51.2%，当事人自动履行率达94.6%。

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

这将使用 中的列值对您的 DataFrame 进行排序city08，领先裸露 MPG 最低的车辆。默许情况下， 按升序 .sort_values()对数据 进行排序 。尽管您莫得为传递给 的参数指命称呼，但.sort_values()您本色上使用了by参数，您将鄙人一个示例中看到该参数。

转变排序规章

的另一个参数.sort_values()是ascending。默许情况下.sort_values()依然ascending竖立True。如若您但愿 DataFrame 按降序排序 ，则可以传递False给此参数：

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

通过传递False到ascending，您可以倒置排序规章。当今，您的 DataFrame 按城市条目下测量的平均 MPG 降序排序。MPG 值最高的车辆在第一溜。

选择排序算法

值得详确的是，pandas 允许您选择不同的排序算法来与.sort_values()和沿途使用.sort_index()。可用的算法quicksort，mergesort和heapsort。磋议这些不同排序算法的更多信息，请检察Python 中的排序算法。

对单列进行排序时默许使用的算法是quicksort。要将其转变为踏实的排序算法，请使用mergesort。您可以使用or 中的kind参数来奉行此操作，如下所示：.sort_values().sort_index()

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

使用kind，您将排序算法竖立为mergesort。之前的输出使用了默许quicksort算法。检察高出裸露的索引，您可以看到行的规章不同。这是因为quicksort不是踏实的排序算法，而是mergesort。

在上一场比赛中，明星球员张三在比赛中受伤，众多球迷心急如焚。但在经过治疗后，张三状态逐渐恢复，为球队重获胜利做出了贡献。据悉，张三本赛季的表现令人惊叹，不少球迷将他视为当之无愧的足球天才。

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

当您对具有相易键的多札记载进行排序时，踏实的排序算法将在排序后保执这些记载的原始规章。因此，如若您缱绻奉行多种排序，则必须使用踏实的排序算法。

在多列上对 DataFrame 进行排序

在数据分析中，频繁但愿字据多列的值对数据进行排序。思象一下，您有一个包含东谈主们名字和姓氏的数据集。先按姓然后按名字排序是专门旨的，这么姓氏相易的东谈主会字据他们的名字按字母规章成列。

在第一个示例中，您在名为 的单个列上对 DataFrame 进行了排序city08。从分析的角度来看，城市条目下的 MPG 是决定汽车受接待历程的蹙迫身分。除了城市条目下的 MPG，您可能还思检察高速公路条目下的 MPG。要按两个键排序，您可以将列名列表传递给by：

>>> >>> df.sort_values( ...     by=["city08", "highway08"] ... )[["city08", "highway08"]]     city08  highway08 80       9         10 47       9         11 99       9         13 1        9         14 58      10         11 ..     ...        ... 9       23         30 10      23         30 8       23         31 76      23         31 2       23         33 [100 rows x 2 columns] 

通过指定列称呼city08和的列表highway08，您可以使用 对两列上的 DataFrame 进行排序.sort_values()。下一个示例将讲解若何指定排序规章以及为什么详确您使用的列名列表很蹙迫。

按升序按多列排序

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

博彩平台是否支持电脑客户端皇冠如何注册

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

当今您的 DataFrame 按升序排序make。如若有两个或更多相易的品牌，则按 排序model。在列表中指定列名的规章对应于 DataFrame 的排序格式。

转变列排序规章

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

>>> >>> df.sort_values( ...     by=["model", "make"] ... )[["make", "model"]]              make        model 18           Audi          100 19           Audi          100 16          Volvo          240 17          Volvo          240 75          Mazda          626 ..            ...          ... 62           Ford  Thunderbird 63           Ford  Thunderbird 88     Oldsmobile     Toronado 42  CX Automotive        XM v6 43  CX Automotive       XM v6a [100 rows x 2 columns] 

您的 DataFrame 当今按model升序按列排序，然后按make是否有两个或更多相易模子进行排序。您可以看到转变列的规章也会转变值的排序规章。

按降序按多列排序

到面前为止，您仅对多列按升序排序。鄙人一个示例中，您将字据make和model列按降序排序。要按降序排序，请竖立ascending为False：

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

该make列中的值按字母规章model倒序成列，关于具有相易make. 关于文本数据，排序差异大小写，这意味着大写文本将领先按升序出现，终末按降序出现。

按具有不同排序规章的多列排序

您可能思知谈是否可以使用多个列进行排序并让这些列使用不同的ascending参数。使用熊猫，欧博体育网站您可以通过单个循序调用来完成此操作。如若要按升序对某些列进行排序，并按降序对某些列进行排序，则可以将布尔值列表传递给ascending.

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

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

当今你的数据帧进行排序make，并model在按升序成列，但与city08按降序成列列。这很有用，因为它按分类规章对汽车进行分组，并领先裸露最高 MPG 的汽车。

字据索引对 DataFrame 进行排序

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

按升序按索引排序

您可以字据行索引对 DataFrame 进行排序.sort_index()。像在前边的示例中雷同按列值排序会再行排序 DataFrame 中的行，因此索引变得横三竖四。当您过滤 DataFrame 或删除或添加行时，也会发生这种情况。

为了清晰 的使用.sort_index()，领先使用以下循序创建一个新的排序 DataFrame .sort_values()：

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

您依然创建了一个使用多个值排序的 DataFrame。请详确行索引是若何莫得特定规章的。要将新 DataFrame 还原到原始规章，您可以使用.sort_index()：

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

当今索引按升序成列。就像in.sort_values()的默许参数是，您可以通过传递 转变为降序。对索引进行排序对数据自己莫得影响，因为值不变。ascending.sort_index()TrueFalse

当您使用. set_index() . 如若要使用make和model列竖立自界说索引，则可以将列表传递给.set_index()：

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

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

吸引力

>>> >>> assigned_index_df.sort_index()                                city08  cylinders  ...            trany  year make       model                                  ... Alfa Romeo Spider Veloce 2000      19          4  ...     Manual 5-spd  1985 Audi       100                     17          6  ...  Automatic 4-spd  1993            100                     17          6  ...     Manual 5-spd  1993 BMW        740i                    14          8  ...  Automatic 5-spd  1993            740il                   14          8  ...  Automatic 5-spd  1993                                ...        ...  ...              ...   ... Volkswagen Golf III / GTI          21          4  ...     Manual 5-spd  1993            Jetta III               18          4  ...  Automatic 4-spd  1993            Jetta III               20          4  ...     Manual 5-spd  1993 Volvo      240                     18          4  ...  Automatic 4-spd  1993            240                     19          4  ...     Manual 5-spd  1993 [100 rows x 8 columns] 

领先使用make和列为 DataFrame 分派一个新索引model，然后使用 对索引进行排序.sort_index()。您可以.set_index()在 pandas 文档中阅读磋议使用的更多信息。

按索引降序排序

关于下一个示例，您将按索引按降序对 DataFrame 进行排序。请记取，通过对 DataFrame 进行排序.sort_values()，您可以通过竖立ascending为来回转排序规章False。此参数也适用于.sort_index()，因此您可以按相背规章对 DataFrame 进行排序，如下所示：

>>> >>> assigned_index_df.sort_index(ascending=False)                                city08  cylinders  ...            trany  year make       model                                  ... Volvo      240                     18          4  ...  Automatic 4-spd  1993            240                     19          4  ...     Manual 5-spd  1993 Volkswagen Jetta III               18          4  ...  Automatic 4-spd  1993            Jetta III               20          4  ...     Manual 5-spd  1993            Golf III / GTI          18          4  ...  Automatic 4-spd  1993                                ...        ...  ...              ...   ... BMW        740il                   14          8  ...  Automatic 5-spd  1993            740i                    14          8  ...  Automatic 5-spd  1993 Audi       100                     17          6  ...  Automatic 4-spd  1993            100                     17          6  ...     Manual 5-spd  1993 Alfa Romeo Spider Veloce 2000      19          4  ...     Manual 5-spd  1985 [100 rows x 8 columns] 

当今您的 DataFrame 按其索引按降序排序。使用.sort_index()and之间的一个区别.sort_values()是它.sort_index()莫得by参数，因为它默许在行索引上对 DataFrame 进行排序。

探索高档索引排序办法

在数据分析中有很厚情况您但愿对分层索引进行排序。你依然看到了若何使用make和model在MultiIndex。关于此数据集，您还可以将该id列用作索引。

将id列竖立为索引可能有助于相接磋议数据集。举例，EPA 的排放数据集也用于id示意车辆记载 ID。这将排放数据与燃油经济性数据磋议起来。在 DataFrame 中对两个数据集的索引进行排序可以使用其他循序（举例.merge(). 要了解磋议在 Pandas 中组合数据的更多信息，请检察在 Pandas 中使用 merge()、.join() 和 concat() 组合数据。

对 DataFrame 的列进行排序

您还可以使用 DataFrame 的列标签对行值进行排序。使用竖立为.sort_index()的可选参数将按列标签对 DataFrame 进行排序。排序算法诳骗于轴标签而不是本色数据。这有助于对 DataFrame 进行目视检查。axis1

使用数据框 axis

当您在.sort_index()不传递任何显式参数axis=0的情况下使用时，它将用作默许参数。DataFrame的轴指的是索引 ( axis=0) 或列 ( axis=1)。您可以使用这两个轴来索引和选择DataFrame 中的数据以及对数据进行排序。

使用列标签进行排序

您还可以使用 DataFrame 的列标签手脚.sort_index(). 竖立字据列标签对 DataFrame 的列axis进行1排序：

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

DataFrame 的列按字母升序从左到右排序。如若要按降序对列进行排序，则可以使用ascending=False：

>>> >>> df.sort_index(axis=1, ascending=False)     year            trany mpgData  ... fuelType cylinders  city08 0   1985     Manual 5-spd       Y  ...  Regular         4      19 1   1985     Manual 5-spd       N  ...  Regular        12       9 2   1985     Manual 5-spd       Y  ...  Regular         4      23 3   1985  Automatic 3-spd       N  ...  Regular         8      10 4   1993     Manual 5-spd       N  ...  Premium         4      17 ..   ...              ...     ...  ...      ...       ...     ... 95  1993  Automatic 3-spd       Y  ...  Regular         6      17 96  1993  Automatic 4-spd       N  ...  Regular         6      17 97  1993  Automatic 4-spd       N  ...  Regular         6      15 98  1993     Manual 5-spd       N  ...  Regular         6      15 99  1993  Automatic 4-spd       N  ...  Premium         8       9 [100 rows x 10 columns] 

使用axis=1in .sort_index()，您可以按升序和降序对 DataFrame 的列进行排序。这在其他数据谐和可能更有用，举例列标签对应于一年中的几个月的数据集。在这种情况下，按月按升序或降序成列数据是专门旨的。

在 Pandas 中排序时搞定丢失的数据

频繁，本质寰球的数据有好多颓势。固然 Pandas 有多种循序可用于在排序前算帐数据，但随机在排序时检察丢失的数据照旧可以的。你可以用 na_position 参数来作念到这小数。

本教程使用的燃油经济性数据子集莫得缺失值。为了清晰 的使用na_position，领先您需要创建一些缺失的数据。以下代码基于现存mpgData列创建了一个新列，映射True了mpgData就是Y和NaN不就是的位置：

>>> >>> df["mpgData_"] = df["mpgData"].map({"Y": True}) >>> df     city08  cylinders fuelType  ...            trany  year mpgData_ 0       19          4  Regular  ...     Manual 5-spd  1985     True 1        9         12  Regular  ...     Manual 5-spd  1985      NaN 2       23          4  Regular  ...     Manual 5-spd  1985     True 3       10          8  Regular  ...  Automatic 3-spd  1985      NaN 4       17          4  Premium  ...     Manual 5-spd  1993      NaN ..     ...        ...      ...  ...              ...   ...      ... 95      17          6  Regular  ...  Automatic 3-spd  1993     True 96      17          6  Regular  ...  Automatic 4-spd  1993      NaN 97      15          6  Regular  ...  Automatic 4-spd  1993      NaN 98      15          6  Regular  ...     Manual 5-spd  1993      NaN 99       9          8  Premium  ...  Automatic 4-spd  1993      NaN [100 rows x 11 columns] 

当今你有一个名为新列mpgData_包含这两个True和NaN值。您将使用此列检察na_position使用这两种排序循序时的成果。要了解磋议使用 的更多信息.map()，您可以阅读Pandas 名堂：使用 Python 和 Pandas 制作得益簿。

了解na_position参数.sort_values()

.sort_values()摄取一个名为 的参数na_position，它有助于在您排序的列中组织缺失的数据。如若您对缺失数据的列进行排序，那么具有缺失值的即将出当今 DataFrame 的末尾。无论您是按升序照旧降序排序，齐会发生这种情况。

皇冠源码

当您对缺失数据的列进行排序时，您的 DataFrame 如下所示：

>>> >>> df.sort_values(by="mpgData_")     city08  cylinders fuelType  ...            trany  year mpgData_ 0       19          4  Regular  ...     Manual 5-spd  1985     True 55      18          6  Regular  ...  Automatic 4-spd  1993     True 56      18          6  Regular  ...  Automatic 4-spd  1993     True 57      16          6  Premium  ...     Manual 5-spd  1993     True 59      17          6  Regular  ...  Automatic 4-spd  1993     True ..     ...        ...      ...  ...              ...   ...      ... 94      18          6  Regular  ...  Automatic 4-spd  1993      NaN 96      17          6  Regular  ...  Automatic 4-spd  1993      NaN 97      15          6  Regular  ...  Automatic 4-spd  1993      NaN 98      15          6  Regular  ...     Manual 5-spd  1993      NaN 99       9          8  Premium  ...  Automatic 4-spd  1993      NaN [100 rows x 11 columns] 

要改变这种活动，并有丢失的数据第一次出当今你的数据帧，可以竖立na_position到first。该na_position参数只摄取值last，这是默许值，和first。以下是若何使用na_postion的.sort_values()：

>>> >>> df.sort_values( ...     by="mpgData_", ...     na_position="first" ... )     city08  cylinders fuelType  ...            trany  year mpgData_ 1        9         12  Regular  ...     Manual 5-spd  1985      NaN 3       10          8  Regular  ...  Automatic 3-spd  1985      NaN 4       17          4  Premium  ...     Manual 5-spd  1993      NaN 5       21          4  Regular  ...  Automatic 3-spd  1993      NaN 11      18          4  Regular  ...  Automatic 4-spd  1993      NaN ..     ...        ...      ...  ...              ...   ...      ... 32      15          8  Premium  ...  Automatic 4-spd  1993     True 33      15          8  Premium  ...  Automatic 4-spd  1993     True 37      17          6  Regular  ...  Automatic 3-spd  1993     True 85      17          6  Regular  ...  Automatic 4-spd  1993     True 95      17          6  Regular  ...  Automatic 3-spd  1993     True [100 rows x 11 columns] 

当今，您用于排序的列中的任何缺失数据齐将裸露在 DataFrame 的顶部。当您第一次最先分析数据何况不驯顺是否存在缺失值时，这脱落有用。

了解na_position参数.sort_index()

.sort_index()也摄取na_position。您的 DataFrame 频繁不会将NaN值手脚其索引的一部分，因此此参数在.sort_index(). 关联词，很雅瞻念知谈，如若您的 DataFrame 如实NaN在行索引或列名中存在，那么您可以使用.sort_index()和快速识别这小数na_position。

默许情况下，此参数竖立为last，将NaN值扬弃在排序结果的末尾。要改变这种活动，并在你的数据帧先有丢失的数据，竖立na_position到first。

使用排序循序修改你的 DataFrame

在整个的例子你迄今所看到的，齐.sort_values()和.sort_index()依然复返数据帧对象时，你叫那些循序。这是因为在熊猫排序不责任到位默许。频繁，这是使用 Pandas 分析数据的最常见和首选循序，因为它会创建一个新的 DataFrame 而不是修改原始数据。这允许您保留从文献中读取数据时的数据情景。

关联词，您可以通过指定inplace值为的可选参数来成功修改原始 DataFrame True。大多数 Pandas 循序齐包含inplace参数。底下，您将看到一些inplace=True用于对 DataFrame 进行妥贴排序的示例。

.sort_values()赶紧使用

跟着inplace竖立为True，您修改原始数据帧，是以排序循序复返None。city08像第一个示例雷同按列的值对 DataFrame 进行排序，但inplace竖立为True：

皇冠客服飞机：@seo3687

>>> >>> df.sort_values("city08", inplace=True) 

请详确调用若何.sort_values()不复返 DataFrame。这是原件的df样子：

>>> >>> df     city08  cylinders fuelType  ...            trany  year mpgData_ 99       9          8  Premium  ...  Automatic 4-spd  1993      NaN 1        9         12  Regular  ...     Manual 5-spd  1985      NaN 80       9          8  Regular  ...  Automatic 3-spd  1985      NaN 47       9          8  Regular  ...  Automatic 3-spd  1985      NaN 3       10          8  Regular  ...  Automatic 3-spd  1985      NaN ..     ...        ...      ...  ...              ...   ...      ... 9       23          4  Regular  ...  Automatic 4-spd  1993     True 8       23          4  Regular  ...     Manual 5-spd  1993     True 7       23          4  Regular  ...  Automatic 3-spd  1993     True 76      23          4  Regular  ...     Manual 5-spd  1993     True 2       23          4  Regular  ...     Manual 5-spd  1985     True [100 rows x 11 columns] 

在df对象中，值当今基于city08列按升序排序。您的原始 DataFrame 已被修改，转变将执续存在。幸免inplace=True用于分析频繁是个好主意，因为对 DataFrame 的转变无法吊销。

.sort_index()赶紧使用

下一个示例清晰这inplace也适用于.sort_index().

由于索引是在您将文献读入 DataFrame 时按升序创建的，因此您可以df再次修改对象以使其还原到驱动规章。使用.sort_index()与inplace竖立为True修改数据框：

>>> >>> df.sort_index(inplace=True) >>> df     city08  cylinders fuelType  ...            trany  year mpgData_ 0       19          4  Regular  ...     Manual 5-spd  1985     True 1        9         12  Regular  ...     Manual 5-spd  1985      NaN 2       23          4  Regular  ...     Manual 5-spd  1985     True 3       10          8  Regular  ...  Automatic 3-spd  1985      NaN 4       17          4  Premium  ...     Manual 5-spd  1993      NaN ..     ...        ...      ...  ...              ...   ...      ... 95      17          6  Regular  ...  Automatic 3-spd  1993     True 96      17          6  Regular  ...  Automatic 4-spd  1993      NaN 97      15          6  Regular  ...  Automatic 4-spd  1993      NaN 98      15          6  Regular  ...     Manual 5-spd  1993      NaN 99       9          8  Premium  ...  Automatic 4-spd  1993      NaN [100 rows x 11 columns] 

当今您的 DataFrame 已使用.sort_index(). 由于您的 DataFrame 仍然具有其默许索引，因此按升序对其进行排序会将数据放回其原始规章。

如若您纯属 Python 的内置函数sort()and sorted()，那么inplacepandas 排序循序中可用的参数可能会嗅觉脱落相似。磋议更多信息，您可以检察如安在 Python 中使用 sorted() 和 sort()。

论断

您当今知谈若何使用 pandas 库的两个中枢循序：.sort_values()和.sort_index(). 有了这些学问，您就可以使用 DataFrame 奉行基本的数据分析。固然这两种循序之间有好多相似之处，但通过检察它们之间的各异，可以明晰地知谈使用哪一种循序来奉行不同的分析任务。

在本教程中，您学习了若何： 按一列或多列的值对Pandas DataFrame进行排序 使用ascending参数转变排序规章 通过index使用对 DataFrame 进行排序.sort_index() 在对值进行排序时组织缺失的数据 使用set to 对DataFrame进行赶紧排序inplaceTrue

这些循序是能干数据分析的蹙迫构成部分。它们将匡助您成立一个弘大的基础，您可以在此基础上奉行更高档的 Pandas 操作。如若您思检察 Pandas 排序循序更高档用法的一些示例，那么 Pandas文档是一个很好的资源。