无码无套少妇毛多18p 送你一个Python 数据排序的好圭臬

发布日期:2022-05-10 20:08    点击次数:160

 无码无套少妇毛多18p无码无套少妇毛多18p

学习 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 并深入前五行的号召:无码无套少妇毛多18p

>>> >>> 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:

>>> >>> 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 最低的车辆。默许情况下无码无套少妇毛多18p, 按升序 .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, 俄罗斯处破女a片出血您可能还想查看高速公路条目下的 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无码无套少妇毛多18p,您可以使用 对两列上的 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 进行排序

在对索引进行排序之前无码无套少妇毛多18p,最佳先了解索引代表什么。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():

现在,记事本终于要借着Win11的迭代之际更新了!在去年10月份的时候,就已经有消息透露微软在正为Win11开发一个重新设计、改造的记事本。

51CTO和华为官方合作共建的鸿蒙技术社区

51CTO和华为官方合作共建的鸿蒙技术社区

今日,微软宣布全新的记事本也开始向 Beta 频道用户推送。

在 Linux 中,防火墙是以一个守护进程的方式存在,服务的名字是 firewalld,它能够定义一组规则来控制外部传入系统中的网络流量,规则允许的流量才能进入系统,规则禁止的流量会被拦下

>>> >>> 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列建立自界说索引无码无套少妇毛多18p,则可以将列表传递给.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 的列按字母升序从左到右排序。如若要按降序对列进行排序无码无套少妇毛多18p,则可以使用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:

>>> >>> 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文档是一个很好的资源。