Pandas实战-Series的方法

本文将主要介绍以下内容：

1. 导入CSV数据集

2. 排序Series值

3. 修改原Series值

4. 统计Series值

5. apply方法

在介绍Series的方法之前，需要一些现实世界的数据集，本文会使用以下三个CSV文件：

- pokemon.csv，超过800个的Pokémon，这是任天堂最受欢迎的宠物小精灵

- google_stock.csv，Google从2004年8月首次亮相到2019年10月的每日美元价格

- revolutionary_war.csv，美国独立战争期间的战斗记录，由于某些战争没有确定的开始日期或不是发生在美国领土，因此此数据集包含缺失值

1. 导入CSV数据集

首先启动Jupyter Notebook，然后导入pandas库：

In  [1] import pandas as pd

pandas可以导入十几种不同类型的文件。每种文件格式都有一个关联的导入方法，这些方法都以read开头。在下面的例子中，我们会使用read_csv方法。它的第一个参数filepath_or_buffer是文件名的路径，必须包含文件的扩展名，使用相对路径默认是在与Jupyter Notebook相同的目录中查找文件。

In  [2]: # 下面两行代码是相同的pd.read_csv(filepath_or_buffer = "pokemon.csv")pd.read_csv("pokemon.csv")
Out [2]:          Pokemon             Type0    Bulbasaur   Grass / Poison1      Ivysaur   Grass / Poison2     Venusaur   Grass / Poison3   Charmander             Fire4   Charmeleon             Fire…            …                …804    Stakataka     Rock / Steel805  Blacephalon     Fire / Ghost806      Zeraora         Electric807       Meltan            Steel808     Melmetal            Steel809 rows x 2 columns

请注意，输出的格式与Series有所不同，返回的实际上是pandas的DataFrame，它是支持多个行和列的二维数据结构。无论数据集包含多少列，pandas都会默认将导入的数据存储在DataFrame中。

如果要把数据存储在Series中，需要用到read_csv方法的另外两个参数index_col和squeeze。数据集有两列（Pokemon和Type），但是Series只支持一列，这时可以使用index_col参数指定作为索引的列名称，把列之一指定为索引。当使用字符串时，请注意区分大小写，该字符串必须与数据集中的列名完全相同。

In  [3]: pd.read_csv("pokemon.csv", index_col = "Pokemon")
Out [3]:                          TypePokemon                   Bulbasaur    Grass / PoisonIvysaur    Grass / PoisonVenusaur    Grass / PoisonCharmander              FireCharmeleon              Fire...               ...Stakataka      Rock / SteelBlacephalon      Fire / GhostZeraora          ElectricMeltan             SteelMelmetal             Steel809 rows × 1 columns

但是pandas仍然默认将数据存储到DataFrame对象中。毕竟，多列容器仍然可以存储一列数据。为了简单起见，将数据存储在尽可能小的容器中通常是有利的。为了强制将数据存储在Series中，需要使用squeeze参数并设为True：

In  [4]: pd.read_csv("pokemon.csv", index_col = "Pokemon", squeeze = True)
Out [4]: PokemonBulbasaur    Grass / PoisonIvysaur      Grass / PoisonVenusaur     Grass / PoisonCharmander             FireCharmeleon             Fire...Stakataka      Rock / SteelBlacephalon    Fire / GhostZeraora            ElectricMeltan                SteelMelmetal              SteelName: Type, Length: 809, dtype: object

输出揭示了有关数据集的一些重要信息。它显示了文件其余列的名称，这里是Type，数据集有809个值，dtype: object表示值类型是字符串。然后可以将Series分配给变量，以便可以在整个Notebook中重复使用它：

In  [5]: pokemon = pd.read_csv("pokemon.csv", index_col = "Pokemon", squeeze = True)

如果想知道该Series中的值或索引是否有NaN值，可以使用hasnans属性：

In  [6]: pokemon.hasnans
Out [6]: FalseIn  [7]: pokemon.index.hasnans
Out [7]: False

其余的两个数据集则有一些复杂，让我们从google_stock.csv开始，它包含一个Date列，其值采用YYYY-MM-DD格式：

In  [8]: pd.read_csv("google_stocks.csv").head()
Out [8]:           Date   Close0   2004-08-19   49.981   2004-08-20   53.952   2004-08-23   54.503   2004-08-24   52.244   2004-08-25   52.80

导入纯文本文件（例如CSV）时，pandas会为每一列假定最符合逻辑的数据类型。当涉及到日期时，为了安全起见会将其作为字符串导入。但我们也可以使用parse_dates参数

明确把Date列中的值转换为datetime对象。pandas可以识别日期的各种不同字符串格式，包括此例的YYYY-MM-DD格式。

In  [9]: google = pd.read_csv("google_stocks.csv",index_col = "Date",parse_dates = ["Date"],squeeze = True)google.head()
Out [9]: Date2004-08-19    49.982004-08-20    53.952004-08-23    54.502004-08-24    52.242004-08-25    52.80Name: Close, dtype: float64

最后一个数据集是revolutionary_war.csv，让我们预览一下它的数据结构，可以使用read_csv默认返回的DataFrame对象的tail方法查看数据集的最后五行。我们可以看到，在State列中存在缺失值，用NaN表示：

In  [10]: pd.read_csv("revolutionary_war.csv").tail()
Out [10]:                           Battle   Start Date      State227          Siege of Fort Henry    9/11/1782   Virginia228   Grand Assault on Gibraltar    9/13/1782        NaN229    Action of 18 October 1782   10/18/1782        NaN230    Action of 6 December 1782    12/6/1782        NaN231    Action of 22 January 1783    1/22/1783   Virginia

因为Series只能使用其中两列，一列用于值，另一列用于索引。让我们以Start Date作为索引，以State作为值。我们还把Start Date字符串转换为datetime对象。pandas也可以处理M/D/YYYY的日期格式：

In  [11]: pd.read_csv("revolutionary_war.csv",index_col = "Start Date",parse_dates = ["Start Date"]).tail()
Out [11]:                                  Battle      StateStart Date1782-09-11          Siege of Fort Henry   Virginia1782-09-13   Grand Assault on Gibraltar        NaN1782-10-18    Action of 18 October 1782        NaN1782-12-06    Action of 6 December 1782        NaN1783-01-22    Action of 22 January 1783   Virginia

这里仍然返回DataFrame，把squeeze参数设为True也没有用，因为除了索引列之外还有两列。这时我们可以使用usecols参数把导入的列限制为Start Date和State：

In  [12]: pd.read_csv("revolutionary_war.csv",index_col = "Start Date",parse_dates = ["Start Date"],usecols = ["State", "Start Date"],squeeze = True).tail()
Out [12]: Start Date1782-09-11    Virginia1782-09-13         NaN1782-10-18         NaN1782-12-06         NaN1783-01-22    VirginiaName: State, dtype: object

下面是我们从3个CSV数据集创建3个Series的最终代码：

In  [13]: pokemon = pd.read_csv("pokemon.csv",index_col = "Pokemon",squeeze = True)google = pd.read_csv("google_stocks.csv",index_col = "Date",parse_dates = ["Date"],squeeze = True)battles = pd.read_csv("revolutionary_war.csv",index_col = "Start Date",parse_dates = ["Start Date"],usecols = ["State", "Start Date"],squeeze = True)

2. 排序Series值

Series的值和索引都可以按升序或降序排序。

2.1 使用sort_values方法按值排序

sort_values方法返回一个新的Series，其值默认以升序排序，原Series对象不会被修改：

In  [14]: google.sort_values()
Out [14]: Date2004-09-03      49.822004-09-01      49.942004-08-19      49.982004-09-02      50.572004-09-07      50.60...2019-04-23    1264.552019-10-25    1265.132018-07-26    1268.332019-04-26    1272.182019-04-29    1287.58Name: Close, Length: 3824, dtype: float64

对于值为字符串的Series，则按字母顺序排序：

In  [15]: pokemon.sort_values()
Out [15]: PokemonIllumise              BugSilcoon               BugPinsir                BugBurmy                 BugWurmple               Bug...Tirtouga     Water / RockRelicanth    Water / RockCorsola      Water / RockCarracosta   Water / RockEmpoleon    Water / SteelName: Type, Length: 809, dtype: object

在pandas中（与Python一样），小写字母排在大写字母之后。在下例中，字符串adam排在字符串Ben之后：

In  [16]: pd.Series(data = ["Adam", "adam", "Ben"]).sort_values()
Out [16]: 0    Adam2     Ben1    adamdtype: object

排序顺序由ascending参数决定，默认值为True。如果要按降序（或字母反序）排序，只需把此参数设为False：

In  [17]: google.sort_values(ascending = False).head()
Out [17]: Date2019-04-29    1287.582019-04-26    1272.182018-07-26    1268.332019-10-25    1265.132019-04-23    1264.55Name: Close, dtype: float64In  [18]: pokemon.sort_values(ascending = False).head()
Out [18]: PokemonEmpoleon     Water / SteelCarracosta    Water / RockCorsola       Water / RockRelicanth     Water / RockTirtouga      Water / RockName: Type, dtype: object

默认情况下，缺失值会排在已排序Series的末尾：

In  [19]: battles.sort_values()
Out [19]: Start Date1781-09-06   Connecticut1779-07-05   Connecticut1777-04-27   Connecticut1777-09-03      Delaware1777-05-17       Florida...1782-08-08           NaN1782-08-25           NaN1782-09-13           NaN1782-10-18           NaN1782-12-06           NaNName: State, Length: 232, dtype: object

如果要把缺失值排在最前，可以把na_position参数设为first，这将覆盖其默认值last：

In  [20]: battles.sort_values(na_position = "first")
Out [20]: Start Date1775-09-17        NaN1775-12-31        NaN1776-03-03        NaN1776-03-25        NaN1776-05-18        NaN...1781-07-06   Virginia1781-07-01   Virginia1781-06-26   Virginia1781-04-25   Virginia1783-01-22   VirginiaName: State, Length: 232, dtype: object

如果要先去掉NaN值再排序，可以先使用dropna方法，该方法返回一个删除了所有缺失值的新Series：

In  [21]: battles.dropna().sort_values()
Out [21]: Start Date1781-09-06    Connecticut1779-07-05    Connecticut1777-04-27    Connecticut1777-09-03       Delaware1777-05-17        Florida...1782-08-19       Virginia1781-03-16       Virginia1781-04-25       Virginia1778-09-07       Virginia1783-01-22       VirginiaName: State, Length: 162, dtype: object

2.2 使用sort_index方法按索引排序

Series的索引可以使用sort_index方法排序，与调用sort_values方法一样，sort_index方法默认情况下返回一个新的Series对象，原Series对象不会被修改。

In  [22]: pokemon.sort_index()
Out [22]: PokemonAbomasnow      Grass / IceAbra               PsychicAbsol                 DarkAccelgor               BugAegislash    Steel / Ghost...Zoroark               DarkZorua                 DarkZubat      Poison / FlyingZweilous     Dark / DragonZygarde    Dragon / GroundName: Type, Length: 809, dtype: object

当处理日期的数据（例如Google和Battles Series中的索引）时，升序会按最旧到最新的顺序排序，而降序则会按最新到最旧的日期排序：

In  [23]: battles.sort_index(ascending = False, na_position = "first")
Out [23]: Start DateNaT             New JerseyNaT               VirginiaNaT                    NaNNaT                    NaN1783-01-22        Virginia...1775-04-20        Virginia1775-04-19   Massachusetts1775-04-19   Massachusetts1774-12-14   New Hampshire1774-09-01   MassachusettsName: State, Length: 232, dtype: object

请注意，pandas使用另一种对象NaT代替缺少的日期值，这样做是为了维护索引的日期数据类型的完整性。

2.3 使用nsmallest和nlargest方法返回最小和最大值

nlargest方法返回按降序排序的最大值，它的第一个参数n指定返回的数量，默认值为5：

In  [24]: google.nlargest(n = 5) # 这行代码和下行是一样的google.nlargest()
Out [24]: Date2019-04-29    1287.582019-04-26    1272.182018-07-26    1268.332019-10-25    1265.132019-04-23    1264.55Name: Close, dtype: float64

nsmallest方法返回按升序排序的最小值，下例返回6个值：

In  [25]: google.nsmallest(n = 6)
Out [25]: Date2004-09-03    49.822004-09-01    49.942004-08-19    49.982004-09-02    50.572004-09-07    50.602004-08-30    50.81Name: Close, dtype: float64

这两种方法仅适用于数值的Series。

3. 修改原Series值

到目前为止介绍过的所有方法都返回新的Series对象，原Series对象在所有这些操作中均不受影响。我们可以通过比较例如排序之类的操作前后的值来证明这一点：

In  [26]: battles.head(3)
Out [26]: Start Date1774-09-01    Massachusetts1774-12-14    New Hampshire1775-04-19    MassachusettsName: State, dtype: objectIn  [27]: battles.sort_values().head(3)
Out [27]: Start Date1781-09-06    Connecticut1779-07-05    Connecticut1777-04-27    ConnecticutName: State, dtype: objectIn  [28]: battles.head(3)
Out [28]: Start Date1774-09-01    Massachusetts1774-12-14    New Hampshire1775-04-19    MassachusettsName: State, dtype: object

许多Series和DataFrame方法都包含一个inplace参数，该参数的值是布尔值，默认是False。如果把该参数设为True，则该方法会直接修改原对象。在前面的例子中，battles.sort_values() 等同于battles.sort_values(inplace = False)。

在inplace设置为True的方法不会在Jupyter Notebook中产生任何输出，但是我们可以通过随后查看对象来观察变化。下例对battles变量的Series对象进行永久排序：

In  [29]: battles.head(3)
Out [29]: Start Date1774-09-01    Massachusetts1774-12-14    New Hampshire1775-04-19    MassachusettsName: State, dtype: objectIn  [30]: battles.sort_values(inplace = True)In  [31]: battles.head(3)
Out [31]: Start Date1781-09-06    Connecticut1779-07-05    Connecticut1777-04-27    ConnecticutName: State, dtype: object

4. 统计Series值

value_counts方法计算Series中每个唯一值出现的次数。下面让我们用它来计算每种宠物精灵类型的数量：

In  [32]: pokemon.value_counts()
Out [32]: Normal           65Water            61Grass            38Psychic          35Fire             30..Fire / Dragon     1Dark / Ghost      1Steel / Ground    1Fire / Psychic    1Dragon / Ice      1Name: Type, Length: 159, dtype: int64

返回值是一个新的Series对象，索引标签是Pokémon的类型，其值是它们各自的数量。在这种情况下，数据完整性至关重要。单个空格或大小写不同的字符的会被认为是不相等的值并分别进行计数。value_counts返回的Length: 159表示唯一值的数量，提醒一下，这与之前介绍过的nunique方法返回的数量是一样的：

In  [33]: len(pokemon.value_counts())
Out [33]: 159In  [34]: pokemon.nunique()
Out [34]: 159

value_counts方法的ascending参数默认值为False，把它设为True可以按升序对值进行排序：

In  [35]: pokemon.value_counts(ascending = True)
Out [35]: Rock / Poison       1Ghost / Dark        1Ghost / Dragon      1Fighting / Steel    1Rock / Fighting     1..Fire               30Psychic            35Grass              38Water              61Normal             65Name: Type, Length: 159, dtype: int64

normalize参数可以控制返回每个唯一值的出现频率，只需把它设为True。下例使用head方法限制只返回前5个值：

In  [36]: pokemon.value_counts(normalize = True).head()
Out [36]: Normal    0.080346Water     0.075402Grass     0.046972Psychic   0.043263Fire      0.037083Name: Type, dtype: float64

返回Series的值可以乘以100以返回百分比值。提醒一下，通过使用适当的数学运算符，可以对整个Series应用例如乘法之类的算术运算，这是之前介绍过的broadcasting功能。

In  [37]: pokemon.value_counts(normalize = True).head() * 100
Out [37]: Normal    8.034611Water     7.540173Grass     4.697157Psychic   4.326329Fire      3.708282Name: Type, dtype: float64

由此可以看出各类Pokémon占数据集的百分比值。round方法可以舍入Series的值，它的第一个参数decimals表示小数点后要保留的位数。下例限制精度为2：

In  [38]: (pokemon.value_counts(normalize = True) * 100).round(2)
Out [38]: Normal             8.03Water              7.54Grass              4.70Psychic            4.33Fire               3.71...Rock / Fighting    0.12Fighting / Steel   0.12Ghost / Dragon     0.12Ghost / Dark       0.12Rock / Poison      0.12Name: Type, Length: 159, dtype: float64

要统计此类数字Series的趋势，通常最好将值分组为预定义的间隔。让我们从使用max和min方法确定Series中的最小和最大值开始，另一种解决方案是将Series传递给Python的内置max和min函数。

In  [40]: google.max()
Out [40]: 1287.58In  [41]: google.min()
Out [41]: 49.82

假设我们想将股票价格分为每200一个段，从0开始一直到1400。我们可以将这些间隔定义为列表中的值，并将其传递给bins参数，pandas将使用每两个连续的值作为间隔的下限和上限：

In  [42]: buckets = [0, 200, 400, 600, 800, 1000, 1200, 1400]google.value_counts(bins = buckets)
Out [42]: (200.0, 400.0]     1568(-0.001, 200.0]     595(400.0, 600.0]      575(1000.0, 1200.0]    406(600.0, 800.0]      380(800.0, 1000.0]     207(1200.0, 1400.0]     93Name: Close, dtype: int64

请注意，返回的Series按区间值的数量排序，如果我们想按区间排序，可以在value_counts方法返回的Series调用sort_index方法。在一个或多个对象上依次调用多个方法的过程称为方法链接method chaining。

In  [43]: google.value_counts(bins = buckets).sort_index()
Out [43]: (-0.001, 200.0]     595(200.0, 400.0]     1568(400.0, 600.0]      575(600.0, 800.0]      380(800.0, 1000.0]     207(1000.0, 1200.0]    406(1200.0, 1400.0]     93Name: Close, dtype: int64

另一种替代方案是设置value_counts方法的sort参数为False，同样返回相同的结果：

In  [44]: google.value_counts(bins = buckets, sort = False)
Out [44]: (-0.001, 200.0]    595(200.0, 400.0]    1568(400.0, 600.0]     575(600.0, 800.0]     380(800.0, 1000.0]    207(1000.0, 1200.0]   406(1200.0, 1400.0]    93Name: Close, dtype: int64

请注意，第一个区间的下限是-0.001而不是0，这是因为当pandas将Series的值按区间统计时，它可能会在任何区间的下限或上限扩大到0.1％。区间以括号开头和以方括号结尾，它既不是列表也不是元组，而是pandas内部Interval类的实例。括号代表不包含，方括号代表包含，因此，区间 (-0.001, 200.0] 表示大于-0.001且小于或等于200.0的所有值。

一个闭区间是一个包含两个端点的区间，例如 [5, 10] 表示大于或等于5且小于或等于10；开区间是不包含端点的区间，例如 (5, 10) 表示大于5且小于10。使用bins参数的value_counts方法将始终返回半开区间，例如 (-0.001, 200.0]

bins参数还可以使用整数值，pandas会在Series中计算最大值和最小值的差，然后按指定的区间数划分区间。下例将值分成六个区间，注意，bins/buckets的大小可能并不完全相等（由于任何区间的下限或上限可能有0.1％的扩展），但会相当接近。

In  [45]: google.value_counts(bins = 6, sort = False)
Out [45]: (48.581, 256.113]     1204(256.113, 462.407]    1104(462.407, 668.7]       507(668.7, 874.993]       380(874.993, 1081.287]    292(1081.287, 1287.58]    337Name: Close, dtype: int64

接下来我们可以使用value_counts方法来统计revolutionary_war数据集中哪些州的战斗最多。

In  [46]: battles.value_counts().head()
Out [46]: South Carolina    31New York          28New Jersey        24Virginia          21Massachusetts     11Name: State, dtype: int64

返回值会默认忽略NaN值，如果想也统计NaN值，可以把dropna参数设为False：

In  [47]: battles.value_counts(dropna = False).head()
Out [47]: NaN              70South Carolina   31New York         28New Jersey       24Virginia         21Name: State, dtype: int64

Series的索引也支持value_counts方法，接下来让我们统计一下在revolutionary_war数据集中战斗最多的日期。

In  [48]: battles.index
Out [48]: DatetimeIndex(['1774-09-01', '1774-12-14', '1775-04-19', '1775-04-19','1775-04-20', '1775-05-10', '1775-05-27', '1775-06-11','1775-06-17', '1775-08-08',...'1782-08-08', '1782-08-15', '1782-08-19', '1782-08-26','1782-08-25', '1782-09-11', '1782-09-13', '1782-10-18','1782-12-06', '1783-01-22'],dtype='datetime64[ns]', name='Start Date', length=232, freq=None)In  [49]: battles.index.value_counts()
Out [49]: 1775-04-19    21781-05-22    21781-04-15    21782-01-11    21780-05-25    2..1778-05-20    11776-06-28    11777-09-19    11778-08-29    11777-05-17    1Name: Start Date, Length: 217, dtype: int64

5. apply方法

方法可以像Python中的任何其它对象一样对待，这是一个棘手的概念，因为方法比整数或字符串之类的具体值感觉更抽象。最简单的理解方式是，您可以对数字进行的任何操作也同样可以应用到方法。例如，一个方法可以是：

- 作为元素存储在列表中

- 存储为字典键的值

- 作为参数传给函数

- 作为函数的返回值

下面一行代码声明了一个包含3个方法的funcs列表。注意，这些方法没有在列表中调用，它们仅是对方法本身的引用。

In  [50]: funcs = [len, max, min]

让我们使用for循环遍历funcs列表中的每个元素。在总共三个迭代中，变量func分别表示len，max和min方法。对于每次迭代，我们使用Series google参数调用func所引用的当前方法。因此，输出分别为Series的长度以及其最大值和最小值。

In  [51]: funcs = [len, max, min]for func in funcs:print(func(google))
Out [51]: 38241287.5849.82

假设我们想将Series google中的每个浮点值四舍五入到最接近的整数。我们可以使用round方法，它会将大于 0.5的值向上舍入，而小于0.5的值向下舍入：

In  [52]: round(99.2)
Out [52]: 99In  [53]: round(99.49)
Out [53]: 99In  [54]: round(99.5)
Out [54]: 100

如果我们想把round方法应用到每一个值，可以使用Series的apply方法。它将对Series中的每个值都调用一个函数，它返回一个由这些方法调用的返回值组成的新Series，它的第一个参数是一个函数。请记住，您可以像使用任何其它对象一样使用方法，包括将其作为参数传递。

In  [55]: google.apply(func = round) # 此行代码和下面一行代码是一样的google.apply(round)
Out [55]: Date2004-08-19      502004-08-20      542004-08-23      542004-08-24      522004-08-25      53...2019-10-21    12462019-10-22    12432019-10-23    12592019-10-24    12612019-10-25    1265Name: Close, Length: 3824, dtype: int64

apply方法还可以使用自定义的方法。假设我们想找出多少种Pokémon具有一种类型，有多少种具有两种或更多。我们可以自定义一个single_or_multi方法，该方法接受一个Pokémon，返回它是否具有一种或几种类型。具有多种类型的Pokémon是用 / 将它们隔开，例如Fire / Ghost。我们可以使用in运算符来检查输入字符串中是否存在/，如果存在，返回Multi；否则返回字符串Single。

In  [56]: def single_or_multi(types):if "/" in types:return "Multi"return "Single"

现在，我们可以将single_or_multi方法传递给apply方法。下面先让我们回顾一下pokemon数据集的数据：

In  [57]: pokemon.head(4)
Out [57]: PokemonBulbasaur    Grass / PoisonIvysaur      Grass / PoisonVenusaur     Grass / PoisonCharmander             FireName: Type, dtype: object

第一个是Bulbasaur被归类为Grass / Poison。pandas会将Grass / Poison字符串传给single_or_multi方法，因此返回Multi；没有 / 的字符串Charmander将返回Single。该过程将应用于Series中的每个值。

In  [58]: pokemon.apply(single_or_multi)
Out [58]: PokemonBulbasaur      MultiIvysaur        MultiVenusaur       MultiCharmander    SingleCharmeleon    Single...Stakataka      MultiBlacephalon    MultiZeraora       SingleMeltan        SingleMelmetal      SingleName: Type, Length: 809, dtype: object

现在我们有了一个新的Series对象！让我们通过调用value_counts来找出每个分类中有多少个Pokémon：

In  [59]: pokemon.apply(single_or_multi).value_counts()
Out [59]: Multi     405Single    404Name: Type, dtype: int64

END O(∩_∩)O

Pandas实战-Series的方法相关推荐

series 合并pandas_在python中pandas的series合并方法
如下所示: In [3]: import pandas as pd In [4]: a = pd.Series([1,2,3]) In [5]: b = pd.Series([2,3,4]) In [ ...
python 重置索引_python pandas 对series和dataframe的重置索引reindex方法
reindex更多的不是修改pandas对象的索引,而只是修改索引的顺序,如果修改的索引不存在就会使用默认的None代替此行.且不会修改原数组,要修改需要使用赋值语句. series.reindex( ...
pandas取第一行数据_Pandas DataFrame 取一行数据会得到Series的方法
Pandas DataFrame 取一行数据会得到Series的方法 Pandas DataFrame 取一行数据会得到Series的方法如题,想要取如下dataframe的一行数据,以为得到的还是 ...
pandas中series一维数组的创建、索引的更改+索引切片和布尔索引+dataframe二维数组的创建、基本属性、索引方法（传统方法和lociloc）、nan操作、排序+案例
目录一.为什么要学习pandas? 二.pandas的常用数据类型 1.series--一维的且带标签的数组 (1)创建一维数组 (2)通过列表形式创建的series带标签数组可以改变索引,传入索引 ...
dataframe两个表合并_Part25:Pandas基础(Series,DataFrame类的创建、索引、切片、算术方法)...
一.为什么学习pandas numpy已经可以帮助我们进行数据的处理了,那么学习pandas的目的是什么呢? numpy能够帮助我们处理的是数值型的数据,当然在数据分析中除了数值型的数据还有好多其他类 ...
Python 数据分析三剑客之 Pandas（一）：认识 Pandas 及其 Series、DataFrame 对象
CSDN 课程推荐:<迈向数据科学家:带你玩转Python数据分析>,讲师齐伟,苏州研途教育科技有限公司CTO,苏州大学应用统计专业硕士生指导委员会委员:已出版<跟老齐学Python ...
dataframe python格式_python3.6 pandas，Series和DataFrame基础格式与用法，附代码实例
pandas 是基于numpy构建的库,加上numpy,主要用于科学运算和数据处理. 也是一个让我忘记昂贵的MATLAB,并且不得不复习SQL的库.. 一般引入规定: In [105]: from p ...
pythonpandas函数详解_对pandas中Series的map函数详解
Series的map方法可以接受一个函数或含有映射关系的字典型对象. 使用map是一种实现元素级转换以及其他数据清理工作的便捷方式. (DataFrame中对应的是applymap()函数,当然Dat ...
利用Python进行数据分析(7) pandas基础: Series和DataFrame的简单介绍一、pandas 是什么 pandas 是基于 NumPy 的一个 Python 数据分析包，主
利用Python进行数据分析(7) pandas基础: Series和DataFrame的简单介绍一.pandas 是什么 pandas 是基于 NumPy 的一个 Python 数据分析包,主要目 ...
Python之pandas，series，可视化
七月在线之python数据处理 python常用导入函数 ndarray np之常用函数创建 ndarray之聚合操作 pandas pandas之series Series的创建 Series的索引 ...

Pandas实战-Series的方法

Pandas实战-Series的方法相关推荐

最新文章

热门文章