Series是NumPy中的一维数组，是表示其列的DataFrame的基本组成部分。尽管与DataFrame相比，它的实际重要性正在降低(你可以在不知道Series是什么的情况下完美地解决许多实际问题)，但如果不首先学习Series和Index，你可能很难理解DataFrame是如何工作的。

在内部，Series将值存储在普通的NumPy vector中。因此，它继承了它的优点(紧凑的内存布局、快速的随机访问)和缺点(类型同质、缓慢的删除和插入)。最重要的是，Series允许使用类似于字典的结构index通过label访问它的值。标签可以是任何类型(通常是字符串和时间戳)。它们不必是唯一的，但唯一性是提高查找速度所必需的，许多操作都假定唯一性。

如你所见，现在每个元素都可以通过两种替代方式寻址：通过label(=使用索引)和通过position(=不使用索引)：

按“位置”寻址有时被称为“位置索引”，这只是增加了混淆。

一对方括号是不够的。特别是：

S[2:3]不是解决元素2最方便的方式
如果名称恰好是整数，s[1:3]就会产生歧义。它可能意味着名称1到3包含或位置索引1到3不包含。
为了解决这些问题，Pandas还有两种“风格”的方括号，可以在下面看到：

.loc总是使用标号，并且包含间隔的两端。
.iloc总是使用“位置索引”并排除右端。
使用方括号而不是圆括号的目的是为了访问Python的切片约定：你可以使用单个或双冒号，其含义是熟悉的start:stop:step。像往常一样，缺少开始(结束)意味着从序列的开始(到结束)。step参数允许使用s.iloc[::2]引用偶数行，并使用s['Paris':'Oslo':-1]以相反的顺序获取元素。
它们还支持布尔索引(使用布尔数组进行索引)，如下图所示：

可以在下图中看到它们如何支持fancy indexing(用整数数组进行索引)：

Series最糟糕的地方在于它的视觉表现：出于某种原因，它没有一个很好的富文本外观，所以与DataFrame相比，它感觉像是二等公民：

对这个Series做了补丁，让它看起来更好，如下所示：
垂直线表示这是一个Series，而不是一个DataFrame。Footer在这里被禁用了，但它可以用于显示dtype，特别是分类类型。
还可以使用pdi.sidebyside(obj1, obj2，…)并排显示多个Series或dataframe：

pdi(代表pandas illustrated)是github上的一个开源库，具有本文所需的这个和其他功能。要使用它，就要写

pip install pandas-illustrated

索引(Index)

负责通过标签获取元素的对象称为index。它非常快：无论你有5行还是50亿行，你都可以在常量时间内获取一行数据。

指数是一个真正的多态生物。默认情况下，当创建一个没有索引的序列(或DataFrame)时，它会初始化为一个惰性对象，类似于Python的range()。和range一样，几乎不使用任何内存，并且与位置索引无法区分。让我们用下面的代码创建一个包含一百万个元素的序列：

>>> s = pd.Series(np.zeros(10**6))
>>> s.index
RangeIndex(start=0, stop=1000000, step=1)
>>> s.index.memory_usage()       # in bytes
128                    # the same as for Series([0.])
现在，如果删除一个元素，索引隐式地转换为类似于dict的结构，如下所示：

>>> s.drop(1, inplace=True)
>>> s.index
Int64Index([     0,      2,      3,      4,      5,      6,      7,
            ...
            999993, 999994, 999995, 999996, 999997, 999998, 999999],
           dtype='int64', length=999999)
>>> s.index.memory_usage()
7999992
该结构消耗8Mb内存!为了摆脱它，回到轻量级的类range结构，添加如下代码：

>>> s.reset_index(drop=True, inplace=True)
>>> s.index
RangeIndex(start=0, stop=999999, step=1)
>>> s.index.memory_usage()
128

如果你不熟悉Pandas，你可能想知道为什么Pandas自己没有做到这一点?好吧，对于非数字标签，有一点很明显：为什么(以及如何)Pandas在删除一行后，会重新标记所有后续的行?对于数值型标签，答案就有点复杂了。

首先，正如我们已经看到的，Pandas允许您纯粹按位置引用行，因此，如果您想在删除第3行之后定位第5行，则可以无需重新索引(这就是iloc的作用)。

其次，保留原始标签是一种与过去时刻保持联系的方法，就像“保存游戏”按钮一样。假设您有一个100x1000000的大表，需要查找一些数据。你正在一个接一个地进行几次查询，每次都缩小了搜索范围，但只查看了一小部分列，因为同时查看数百个字段是不切实际的。现在您已经找到感兴趣的行，您希望在原始表中查看有关它们的所有信息。数字索引可以帮助您立即获得它，而无需任何额外的努力。

一般来说，在索引中保持值的唯一性是一个好主意。例如，在索引中存在重复值时，查找速度不会得到提升。Pandas不像关系型数据库那样有“唯一约束”(该功能仍然是实验性的)，但它有检查索引中的值是否唯一的函数，并以各种方式消除重复。

有时，一列不足以唯一标识一行。例如，同一个名字的城市有时会碰巧出现在不同的国家，甚至是同一个国家的不同地区。所以(城市，州)是一个比城市更好的标识一个地方的候选者。在数据库中，这被称为“复合主键”。在Pandas中，它被称为多索引(参见下面的第4部分)，索引中的每一列都被称为“级别”。

索引的另一个重要特性是不可变。与DataFrame中的普通列不同，你不能就地更改它。索引中的任何更改都涉及从旧索引中获取数据，修改它，并将新数据作为新索引重新附加。通常情况下，它是透明的，这就是为什么不能直接写df.City.name ='city'，而必须写一个不那么明显的df.rename(columns={'A':'A'}, inplace=True)

Index有一个名称(在MultiIndex的情况下，每个级别都有一个名称)。不幸的是，这个名称在Pandas中没有得到充分使用。一旦你在索引中包含了这一列，就不能再使用df了。不再使用列名表示法，并且必须恢复为可读性较差的df。指数还是更通用的df。loc对于多索引，情况更糟。一个明显的例外是df。Merge -你可以通过名称指定要合并的列，无论它是否在索引中。

同样的索引机制用于标记dataframe的行和列，以及序列。

按值查找元素

Series内部由一个NumPy数组和一个类似数组的结构index组成，如下所示：

Index提供了一种通过标签查找值的方便方法。那么如何通过值查找标签呢?

s.index[s.tolist().find(x)]           # faster for len(s) < 1000
s.index[np.where(s.values==x)[0][0]]  # faster for len(s) > 1000
编写了find()和findall()两个简单的封装器，它们运行速度快(因为它们会根据序列的大小自动选择实际的命令)，而且使用起来更方便。代码如下所示：

>>> import pdi
>>> pdi.find(s, 2)
'penguin'
>>> pdi.findall(s, 4)
Index(['cat', 'dog'], dtype='object')

缺失值

Pandas开发人员特别关注缺失值。通常，通过向read_csv提供一个标志来接收一个带有NaNs的dataframe。否则，可以在构造函数或赋值运算符中使用None(尽管不同数据类型的实现略有不同，但它仍然有效)。这张图片有助于解释这个概念：

你可以使用NaNs做的第一件事是了解你是否有NaNs。从上图可以看出，isna()生成了一个布尔数组，而.sum()给出了缺失值的总数。

现在你知道了它们的存在，你可以选择用常量值填充它们或通过插值来一次性删除它们，如下所示：

另一方面，你可以继续使用它们。大多数Pandas函数会很高兴地忽略缺失值，如下图所示：

更高级的函数(median、rank、quantile等)也可以做到这一点。

算术运算与索引对齐：

如果索引中存在非唯一值，则结果不一致。不要对索引不唯一的序列使用算术运算。

比较

比较有缺失值的数组可能会比较棘手。下面是一个例子：

>>> np.all(pd.Series([1., None, 3.]) ==
           pd.Series([1., None, 3.]))
False
>>> np.all(pd.Series([1, None, 3], dtype='Int64') ==
           pd.Series([1, None, 3], dtype='Int64'))
True
>>> np.all(pd.Series(['a', None, 'c']) ==
           pd.Series(['a', None, 'c']))
False

为了正确地比较nan，需要用数组中一定没有的元素替换nan。例如，使用-1或∞：

>>> np.all(s1.fillna(np.inf) == s2.fillna(np.inf))   # works for all dtypes
True

或者，更好的做法是使用NumPy或Pandas的标准比较函数：

>>> s = pd.Series([1., None, 3.])
                   >>> np.array_equal(s.values, s.values, equal_nan=True)
                   True
                   >>> len(s.compare(s)) == 0
                   True

这里，compare函数返回一个差异列表(实际上是一个DataFrame)， array_equal则直接返回一个布尔值。

当比较混合类型的DataFrames时，NumPy比较失败(issue #19205)，而Pandas工作得很好。如下所示：

>>> df = pd.DataFrame({'a': [1., None, 3.], 'b': ['x', None, 'z']})
>>> np.array_equal(df.values, df.values, equal_nan=True)
TypeError
<...>
>>> len(df.compare(df)) == 0
True

追加、插入、删除

虽然Series对象被认为是size不可变的，但它可以在原地追加、插入和删除元素，但所有这些操作都是：

慢，因为它们需要为整个对象重新分配内存和更新索引。
非常不方便。
下面是插入值的一种方式和删除值的两种方式：

第二种删除值的方法(通过drop)比较慢，并且在索引中存在非唯一值时可能会导致复杂的错误。
Pandas有df.insert方法，但它只能将列(而不是行)插入到dataframe中(并且对series不起作用)。
添加和插入的另一种方法是使用iloc对DataFrame进行切片，应用必要的转换，然后使用concat将其放回。我实现了一个名为insert的函数，可以自动执行这个过程：
注意(就像在df.insert中一样)插入位置由位置0<=i<=len(s)指定，而不是索引中元素的标签。如下所示：

要按元素的名称插入，可以合并pdi。用pdi查找。插入，如下所示：

请注意，unlikedf.insert、pdi.insert返回一个副本，而不是原地修改Series/DataFrame

统计数据

Pandas提供了全方位的统计函数。它们可以让您了解百万元素序列或DataFrame中的内容，而无需手动滚动数据。

所有Pandas统计函数都会忽略NaNs，如下所示：

注意，Pandas std给出的结果与NumPy std不同，如下所示：

>>> pd.Series([1, 2]).std()
0.7071067811865476
>>> pd.Series([1, 2]).values.std()
0.5
这是因为NumPy std默认使用N作为分母，而Pandas std默认使用N-1作为分母。两个std都有一个名为ddof (delta degrees of freedom)的参数，NumPy默认为0,Pandas默认为1，这可以使结果一致。N-1是你通常想要的值(在均值未知的情况下估计样本的偏差)。这里有一篇维基百科的文章详细介绍了贝塞尔的修正。
由于序列中的每个元素都可以通过标签或位置索引访问，因此argmin (argmax)有一个姐妹函数idxmin (idxmax)，如下图所示：
下面是Pandas的自描述统计函数供参考：

std：样本标准差
var，无偏方差
sem，均值的无偏标准误差
quantile分位数，样本分位数(s.quantile(0.5)≈s.median())
oode是出现频率最高的值
默认为Nlargest和nsmallest，按出现顺序排列
diff，第一个离散差分
cumsum 和 cumprod、cumulative sum和product
cummin和cummax，累积最小值和最大值
以及一些更专业的统计函数：
pct_change，当前元素与前一个元素之间的变化百分比
skew偏态，无偏态(三阶矩)
kurt或kurtosis，无偏峰度(四阶矩)
cov、corr和autocorr、协方差、相关和自相关
rolling滚动窗口、加权窗口和指数加权窗口

重复数据

在检测和处理重复数据时需要特别小心，如下图所示：

drop_duplicates和duplication可以保留最后一次出现的副本，而不是第一次出现的副本。

请注意，s.a uint()比np快。唯一性(O(N) vs O(NlogN))，它会保留顺序，而不会返回排序结果。独特的。

缺失值被视为普通值，有时可能会导致令人惊讶的结果。

如果你想排除nan，需要显式地这样做。在这个例子中，是s.lopdropna().is_unique == True。

还有一类单调函数，它们的名字是自描述的：

s.is_monotonic_increasing()
s.is_monotonic_decreasing()
s._strict_monotonic_increasing()
s._string_monotonic_decreasing()
s.is_monotonic()。这是意料之外的，出于某种原因，这是s.is_monotonic_increasing()。它只对单调递减序列返回False。

分组

在数据处理中，一个常见的操作是计算一些统计量，不是针对整个数据集，而是针对其中的某些组。第一步是通过提供将一系列(或一个dataframe)分解为组的标准来定义一个“智能对象”。这个智能对象没有立即的表示，但可以像Series一样查询它，以获得每个组的某个属性，如下图所示：

在这个例子中，根据数值除以10的整数部分将序列分成三组。对于每个组，我们请求每个组中元素的和、元素的数量以及平均值。

除了这些聚合函数，还可以根据特定元素在组中的位置或相对值访问它们。如下所示：

也可以使用g.ag (['min'，'max'])一次调用计算多个函数，或者使用g.c describe()一次显示一堆统计函数。

如果这些还不够，你还可以通过自己的Python函数传递数据。它可以是：

一个函数f，它接受一个组x(一个Series对象)并生成一个值(例如sum())与g.eapply (f)一起使用。

一个函数f，它接受一个组x(一个Series对象)，并与g.transform(f)生成一个大小与x相同的Series对象(例如cumsum())。

在上面的例子中，输入数据是有序的。groupby不需要这样做。实际上，如果分组中的元素不是连续存储的，它也同样有效，因此它更接近于collections.defaultdict，而不是itertools.groupby。它总是返回一个没有重复项的索引。

与defaultdict和关系数据库GROUP BY子句不同，Pandas groupby按组名对结果进行排序。可以用sort=False来禁用它。

免责声明：实际上，g.apply(f)比上面描述的更通用：

如果f(x)返回与x大小相同的序列，它可以模拟transform
如果f(x)返回一系列不同大小或不同的dataframe，则会得到一个具有相应多索引的序列。
但文档警告说，这些使用方法可能比相应的transform和agg方法慢，所以要小心。