前⾯部分关注于不同类型的数据规整流程和NumPy、pandas与其它库的特点。随着时间的发展，pandas发展出了更多适合⾼级⽤户的功能。本篇就深⼊学习pandas的⾼级功能。
一、分类数据
接下来要说的是pandas的分类类型。通过使⽤它，可提⾼性能和内存的使⽤率。后面还会介绍⼀些在统计和机器学习中使⽤分类数据的⼯具。
1、背景和⽬的
表中的⼀列通常会有重复的包含不同值的⼩集合的情况。前面已经学过了unique和value_counts，它们可以从数组提取出不同的值，并分别计算频率：
import numpy as np; import pandas as pd
values = pd.Series(['apple', 'orange', 'apple', 'apple'] *2 )
values # 输出如下：
0 apple
1 orange
2 apple
3 apple
4 apple
5 orange
6 apple
7 apple
dtype: object
pd.unique(values) # 输出如下：唯一值
array(['apple', 'orange'], dtype=object)
pd.value_counts(values) # 输出如下：计数
apple 6
orange 2
dtype: int64
许多数据系统（数据仓库、统计计算或其它应⽤）都发展出了特定的表征重复值的⽅法，以进⾏⾼效的存储和计算。在数据仓库中，最好的⽅法是使⽤所谓的包含不同值的维表(Dimension Table)，将主要的参数存储为引⽤维表整数键：
values = pd.Series([0, 1, 0, 0] * 2)
dim = pd.Series(['apple', 'orange'])
values # 输出如下：
0 0
1 1
2 0
3 0
4 0
5 1
6 0
7 0
dtype: int64
dim # 输出如下：
0 apple
1 orange
dtype: object
可以使⽤take⽅法存储原始的字符串Series：
dim.take(values) # 输出如下：apple对应0，orange对应1
0 apple
1 orange
0 apple
0 apple
0 apple
1 orange
0 apple
0 apple
dtype: object
这种⽤整数表示的⽅法称为分类或字典编码表示法。不同值的数组称为分类、字典或数据级。在这里，我们使⽤分类的说法。表示分类的整数值称为分类编码或简单地称为编码。
分类表示可以在进⾏分析时⼤⼤的提⾼性能。你也可以在保持编码不变的情况下，对分类进⾏转换。⼀些相对简单的转变例⼦包括：
重命名分类。
加⼊⼀个新的分类，不改变已经存在的分类的顺序或位置。
2、pandas的分类类型
pandas有⼀个特殊的分类类型，⽤于保存使⽤整数分类表示法的数据。看⼀个之前的Series例⼦：
fruits = ['apple', 'orange', 'apple', 'apple'] * 2
N = len(fruits)
df = pd.DataFrame({'fruit': fruits,
'basket_id': np.arange(N),
'count': np.random.randint(3, 15, size=N),
'weight': np.random.uniform(0, 4, size=N)},
columns=['basket_id', 'fruit', 'count', 'weight'])
df # 输出如下：
basket_id fruit count weight
0 0 apple 5 2.508993
1 1 orange 5 0.287797
2 2 apple 14 2.049163
3 3 apple 12 1.112467
4 4 apple 7 2.525591
5 5 orange 7 3.651966
6 6 apple 5 1.222066
7 7 apple 14 0.769359
这⾥，df['fruit']是⼀个Python字符串对象的数组。我们可以通过调⽤它，将它转变为分类：
fruit_cat = df['fruit'].astype('category') # 使用astype设置类型
fruit_cat # 输出如下：
0 apple
1 orange
2 apple
3 apple
4 apple
5 orange
6 apple
7 apple
Name: fruit, dtype: category
Categories (2, object): [apple, orange]
fruit_cat的值不是NumPy数组，⽽是⼀个pandas.Categorical实例：
c = fruit_cat.values
type(c) # 输出：pandas.core.arrays.categorical.Categorical
分类对象有categories和codes属性：
c.categories # 输出：Index(['apple', 'orange'], dtype='object')
c.codes # 输出：array([0, 1, 0, 0, 0, 1, 0, 0], dtype=int8)
你可将DataFrame的列通过分配转换结果，转换为分类：
df['fruit'] = df['fruit'].astype('category')
df.fruit # 输出如下：（将fruit列转换为分类）
0 apple
1 orange
2 apple
3 apple
4 apple
5 orange
6 apple
7 apple
Name: fruit, dtype: category
Categories (2, object): [apple, orange]
你还可以从其它Python序列直接创建pandas.Categorical：
my_categories = pd.Categorical(['foo', 'bar', 'baz', 'foo', 'bar'])
my_categories # 输出如下：
[foo, bar, baz, foo, bar]
Categories (3, object): [bar, baz, foo]
如果你已经从其它源获得了分类编码，你还可以使⽤from_codes构造器：
categories = ['foo', 'bar', 'baz']
codes = [0, 1, 2, 0, 0, 1]
my_cats_2 = pd.Categorical.from_codes(codes, categories)
my_cats_2 # 输出如下：
[foo, bar, baz, foo, foo, bar]
Categories (3, object): [foo, bar, baz]
与显式指定不同，分类变换不认定指定的分类顺序。因此取决于输⼊数据的顺序，categories数组的顺序会不同。当使⽤from_codes或其它的构造器时，你可以指定分类⼀个有意义的顺序：
ordered_cat = pd.Categorical.from_codes(codes, categories, ordered=True)
ordered_cat # 输出如下：
[foo, bar, baz, foo, foo, bar]
Categories (3, object): [foo < bar < baz]
输出[foo < bar < baz]指明‘foo’位于‘bar’的前⾯，以此类推。⽆序的分类实例可以通过as_ordered排序：
my_cats_2.as_ordered() # 输出如下：通过as_ordered()方法排序
[foo, bar, baz, foo, foo, bar]
Categories (3, object): [foo < bar < baz]
最后要注意，分类数据不需要字符串，尽管这里仅仅展示了字符串的例⼦。分类数组可以包括任意不可变类型。
3、⽤分类进⾏计算
与⾮编码版本（⽐如字符串数组）相⽐，使⽤pandas的Categorical有些类似。某些pandas组件，⽐如groupby函数，更适合进⾏分类。还有⼀些函数可以使⽤有序标志位。
来看⼀些随机的数值数据，使⽤pandas.qcut⾯元函数。它会返回pandas.Categorical，我们之前使⽤过pandas.cut，但没解释分类是如何⼯作的：
np.random.seed(12345)
draws = np.random.randn(1000)
draws[:5] # 输出：array([-0.2047, 0.4789, -0.5194, -0.5557, 1.9658])
计算这个数据的分位⾯元，提取⼀些统计信息：
bins = pd.qcut(draws, 4) # 平均分成4个面元
bins # 输出如下：
[(-0.684, -0.0101], (-0.0101, 0.63], (-0.684, -0.0101], (-0.684, -0.0101], (0.63, 3.928], ..., (-0.0101, 0.63], (-0.684, -0.0101], (-2.95, -0.684], (-0.0101, 0.63], (0.63, 3.928]]
Length: 1000
Categories (4, interval[float64]): [(-2.95, -0.684] < (-0.684, -0.0101] < (-0.0101, 0.63] < (0.63, 3.928]]
虽然有⽤，确切的样本分位数与分位的名称相⽐，不利于⽣成汇总。我们可以使⽤qcut的labels参数，实现⽬的：
bins = pd.qcut(draws, 4, labels=['Q1', 'Q2', 'Q3', 'Q4']) # 指定各个面元的标签
bins # 输出如下：
[Q2, Q3, Q2, Q2, Q4, ..., Q3, Q2, Q1, Q3, Q4]
Length: 1000
Categories (4, object): [Q1 < Q2 < Q3 < Q4]
bins.codes[:10] # 输出：array([1, 2, 1, 1, 3, 3, 2, 2, 3, 3], dtype=int8)
加上标签的⾯元分类不包含数据⾯元边界的信息，因此可以使⽤groupby提取⼀些汇总信息：
bins = pd.Series(bins, name='quartile')
results = (pd.Series(draws)
.groupby(bins)
.agg(['count', 'min', 'max'])
.reset_index())
results # 输出如下：
quartile count min max
0 Q1 250 -2.949343 -0.685484
1 Q2 250 -0.683066 -0.010115
2 Q3 250 -0.010032 0.628894
3 Q4 250 0.634238 3.927528
分位数列保存了原始的⾯元分类信息，包括排序：
results['quartile'] # 输出如下：
0 Q1
1 Q2
2 Q3
3 Q4
Name: quartile, dtype: category
Categories (4, object): [Q1 < Q2 < Q3 < Q4]
4、⽤分类提⾼性能
如果你是在⼀个特定数据集上做⼤量分析，将其转换为分类可以极⼤地提⾼效率。DataFrame列的分类使⽤的内存通常少的多。来看⼀些包含⼀千万元素的Series，和⼀些不同的分类：
N = 10000000
draws = pd.Series(np.random.randn(N))
labels = pd.Series(['foo', 'bar', 'baz', 'qux'] * (N // 4))
现在，将标签转换为分类：
categories = labels.astype('category')
这时，可以看到标签使⽤的内存远⽐分类多：
labels.memory_usage() # 标签使用内存，输出：80000080
categories.memory_usage() # 分类使用内存，输出：10000272
转换为分类不是没有代价的，但这是⼀次性的代价：
%time _ = labels.astype('category') # 输出：Wall time: 562 ms
GroupBy操作明显⽐分类快，是因为底层的算法使⽤整数编码数组，⽽不是字符串数组。
5、分类⽅法
包含分类数据的Series有⼀些特殊的⽅法，类似于Series.str字符串⽅法。它还提供了⽅便的分类和编码的使⽤⽅法。看下⾯的Series：
s = pd.Series(['a', 'b', 'c', 'd'] * 2)
cat_s = s.astype('category')
cat_s # 输出如下：
0 a
1 b
2 c
3 d
4 a
5 b
6 c
7 d
dtype: category
Categories (4, object): [a, b, c, d]
特别的cat属性提供了分类⽅法的⼊⼝：
cat_s.cat.codes
0 0
1 1
2 2
3 3
4 0
5 1
6 2
7 3
dtype: int8
cat_s.cat.categories # 输出：Index(['a', 'b', 'c', 'd'], dtype='object')
假设我们知道这个数据的实际分类集，超出了数据中的四个值。我们可以使⽤set_categories⽅法改变它们：
actual_categories = ['a', 'b', 'c', 'd', 'e'] # 实际分类集
cat_s2 = cat_s.cat.set_categories(actual_categories)
cat_s2 # 输出如下：
0 a
1 b
2 c
3 d
4 a
5 b
6 c
7 d
dtype: category
Categories (5, object): [a, b, c, d, e]
虽然数据看起来没变，新的分类将反映在它们的操作中。例如，如果有的话，value_counts表示分类：
cat_s.value_counts() # 统计每个分类的数量，输出如下：
d 2
c 2
b 2
a 2
dtype: int64
cat_s2.value_counts() # 输出如下：
d 2
c 2
b 2
a 2
e 0
dtype: int64
在大数据集中，分类经常作为节省内存和⾼性能的便捷⼯具。过滤完⼤DataFrame或Series之后，许多分类可能不会出现在数据中。我们可以使⽤remove_unused_categories⽅法删除没看到的分类：
cat_s3 = cat_s[cat_s.isin(['a', 'b'])]
cat_s3 # 输出如下：
0 a
1 b
4 a
5 b
dtype: category
Categories (4, object): [a, b, c, d]
cat_s3.cat.remove_unused_categories() # 输出如下：（注意cat是入口）
0 a
1 b
4 a
5 b
dtype: category
Categories (2, object): [a, b]
表12-1列出了可⽤的分类⽅法。
表12-1 pandas的Series的分类⽅法（cat是这些方法的入口）
方法 说明
add_categories 在已存在的分类后面添加新的（未使用的）分类
as_ordered 使分类有序
as_unordered 使分类无序
remove_categories 移除分类，设置任何被移除的值为null
remove_unused_categories 移除任意不出现在数据中的分类值
rename_categories 用指定的新分类的名字替换分类；不能改变分类的数目
reorder_categories 与rename_categories很像，但是可以改变结果，使分类有序
set_categories 用指定的新分类的名字捡的分类；可以添加或删除分类
6、为建模创建虚拟变量
当你使⽤统计或机器学习⼯具时，通常会将分类数据转换为虚拟变量，也称为one-hot编码。这包括创建⼀个不同
类别的列的DataFrame；这些列包含给定分类的1s，其它为0。
看前⾯的例⼦：
cat_s = pd.Series(['a', 'b', 'c', 'd'] * 2, dtype='category')
前⾯的第7篇提到过，pandas.get_dummies函数可以转换这个分类数据为包含虚拟变量的DataFrame：
pd.get_dummies(cat_s)
a b c d
0 1 0 0 0
1 0 1 0 0
2 0 0 1 0
3 0 0 0 1
4 1 0 0 0
5 0 1 0 0
6 0 0 1 0
7 0 0 0 1
二、GroupBy⾼级应⽤
尽管在第10篇已经深度学习了Series和DataFrame的Groupby⽅法，还有⼀些⽅法也是很有⽤的。
在第10篇，在分组操作中学习了apply⽅法，进⾏转换。还有另⼀个transform⽅法，它与apply很像，但是对使
⽤的函数有⼀定限制：
它可以产⽣向分组形状⼴播标量值
它可以产⽣⼀个和输⼊组形状相同的对象
它不能修改输⼊
来看⼀个简单的例⼦：
df = pd.DataFrame({'key': ['a', 'b', 'c'] * 4,
'value': np.arange(12.)})
df # 输出如下：
key value
0 a 0.0
1 b 1.0
2 c 2.0
3 a 3.0
4 b 4.0
5 c 5.0
6 a 6.0
7 b 7.0
8 c 8.0
9 a 9.0
10 b 10.0
11 c 11.0
按键进⾏分组平均：
g = df.groupby('key').value # 将df数据按key列进行分组，值是value列
g.mean()
key
a 4.5
b 5.5
c 6.5
Name: value, dtype: float64
假设我们想产⽣⼀个和df['value']形状相同的Series，但值替换为按键分组的平均值。我们可以传递函
数lambda x: x.mean()进⾏转换：
g.transform(lambda x: x.mean()) # 输出如下：
0 4.5
1 5.5
2 6.5
3 4.5
4 5.5
5 6.5
6 4.5
7 5.5
8 6.5
9 4.5
10 5.5
11 6.5
Name: value, dtype: float64
对于内置的聚合函数，我们可以传递⼀个字符串假名作为GroupBy的agg⽅法：
g.transform('mean') # 输出如下：
0 4.5
1 5.5
2 6.5
3 4.5
4 5.5
5 6.5
6 4.5
7 5.5
8 6.5
9 4.5
10 5.5
11 6.5
Name: value, dtype: float64
与apply类似，transform的函数会返回Series，但是结果必须与输⼊⼤⼩相同。举个例⼦，我们可以⽤
lambda函数将每个分组乘以2：
g.transform(lambda x: x * 2) # 参数x对应每个分组中的元素，输出如下：
0 0.0
1 2.0
2 4.0
3 6.0
4 8.0
5 10.0
6 12.0
7 14.0
8 16.0
9 18.0
10 20.0
11 22.0
Name: value, dtype: float64
可进一步对不同分组的元素乘以不同的数字：
g.transform(lambda x: x * 2 if x.name == 'a' else x * 3 if x.name == 'b' else x * 4) # 输出如下：
0 0.0
1 3.0
2 8.0
3 6.0
4 12.0
5 20.0
6 12.0
7 21.0
8 32.0
9 18.0
10 30.0
11 44.0
Name: value, dtype: float64
上面的一行式代码不便于阅读，可定义一个函数实现相同的功能，函数定义如下：
def by(x):
if x.name == 'a':
return x * 2
elif x.name == 'b':
return x * 3
elif x.name == 'c':
return x * 4
g.transform(by) # 输出如下：输出的结果与一行式代码的结果一样
0 0.0
1 3.0
2 8.0
3 6.0
4 12.0
5 20.0
6 12.0
7 21.0
8 32.0
9 18.0
10 30.0
11 44.0
Name: value, dtype: float64
再举⼀个复杂的例⼦，我们可以计算每个分组的降序排名：
g.transform(lambda x: x.rank(ascending=False)) # 输出如下：
0 4.0
1 4.0
2 4.0
3 3.0
4 3.0
5 3.0
6 2.0
7 2.0
8 2.0
9 1.0
10 1.0
11 1.0
Name: value, dtype: float64
看⼀个由简单聚合构造的分组转换函数：
def normalize(x):
return (x - x.mean()) / x.std()
我们⽤transform或apply可以获得等价的结果：
g.transform(normalize) # 输出如下：
0 -1.161895
1 -1.161895
2 -1.161895
3 -0.387298
4 -0.387298
5 -0.387298
6 0.387298
7 0.387298
8 0.387298
9 1.161895
10 1.161895
11 1.161895
Name: value, dtype: float64
g.apply(normalize) # 输出如下：
0 -1.161895
1 -1.161895
2 -1.161895
3 -0.387298
4 -0.387298
5 -0.387298
6 0.387298
7 0.387298
8 0.387298
9 1.161895
10 1.161895
11 1.161895
Name: value, dtype: float64
内置的聚合函数，⽐如mean或sum，通常⽐apply函数快，也⽐transform快。这允许我们进⾏⼀个所谓的
解封（unwrapped）分组操作：
g.transform('mean') # 输出如下：
0 4.5
1 5.5
2 6.5
3 4.5
4 5.5
5 6.5
6 4.5
7 5.5
8 6.5
9 4.5
10 5.5
11 6.5
Name: value, dtype: float64
normalized = (df['value'] - g.transform('mean')) / g.transform('std')
normalized # 输出如下：与g.transform(normalize)的输出一样
0 -1.161895
1 -1.161895
2 -1.161895
3 -0.387298
4 -0.387298
5 -0.387298
6 0.387298
7 0.387298
8 0.387298
9 1.161895
10 1.161895
11 1.161895
Name: value, dtype: float64
解封分组操作可能包括多个分组聚合，但是⽮量化操作还是会带来收益。
2、分组的时间重采样
对于时间序列数据，resample⽅法从语义上是⼀个基于内在时间的分组操作。下⾯是⼀个示例表：
N = 15
times = pd.date_range('2017-05-20 00:00', freq='1min', periods=N)
df = pd.DataFrame({'time': times, 'value': np.arange(N)})
df # 输出如下：
time value
0 2017-05-20 00:00:00 0
1 2017-05-20 00:01:00 1
2 2017-05-20 00:02:00 2
3 2017-05-20 00:03:00 3
4 2017-05-20 00:04:00 4
5 2017-05-20 00:05:00 5
6 2017-05-20 00:06:00 6
7 2017-05-20 00:07:00 7
8 2017-05-20 00:08:00 8
9 2017-05-20 00:09:00 9
10 2017-05-20 00:10:00 10
11 2017-05-20 00:11:00 11
12 2017-05-20 00:12:00 12
13 2017-05-20 00:13:00 13
14 2017-05-20 00:14:00 14
这⾥，我们可以⽤time作为索引，然后重采样：
df.set_index('time').resample('5min').count() # 输出如下：set_index()方法重设行索引
value
time
2017-05-20 00:00:00 5
2017-05-20 00:05:00 5
2017-05-20 00:10:00 5
假设DataFrame包含多个时间序列，⽤⼀个额外的分组键的列进⾏标记：
df2 = pd.DataFrame({'time': times.repeat(3),
'key': np.tile(['a', 'b', 'c'], N),
'value': np.arange(N * 3.)})
times.repeat(3)方法对times列表中的每个元素重复3次，np.tile(['a', 'b', 'c'], N)相当于['a', 'b', 'c'] * N
df2[:7] # 前7行输出如下：
time key value
0 2017-05-20 00:00:00 a 0.0
1 2017-05-20 00:00:00 b 1.0
2 2017-05-20 00:00:00 c 2.0
3 2017-05-20 00:01:00 a 3.0
4 2017-05-20 00:01:00 b 4.0
5 2017-05-20 00:01:00 c 5.0
6 2017-05-20 00:02:00 a 6.0
要对每个key值进⾏相同的重采样，我们引⼊pandas.TimeGrouper对象：
time_key = pd.TimeGrouper('5min')
然后我们设定时间索引，⽤key和time_key分组，然后聚合：
resampled = (df2.set_index('time')
.groupby(['key', time_key])
.sum())
resampled # 输出如下：
value
key time
a 2017-05-20 00:00:00 30.0
2017-05-20 00:05:00 105.0
2017-05-20 00:10:00 180.0
b 2017-05-20 00:00:00 35.0
2017-05-20 00:05:00 110.0
2017-05-20 00:10:00 185.0
c 2017-05-20 00:00:00 40.0
2017-05-20 00:05:00 115.0
2017-05-20 00:10:00 190.0
resampled.reset_index() # 重设为默认行索引
key time value
0 a 2017-05-20 00:00:00 30.0
1 a 2017-05-20 00:05:00 105.0
2 a 2017-05-20 00:10:00 180.0
3 b 2017-05-20 00:00:00 35.0
4 b 2017-05-20 00:05:00 110.0
5 b 2017-05-20 00:10:00 185.0
6 c 2017-05-20 00:00:00 40.0
7 c 2017-05-20 00:05:00 115.0
8 c 2017-05-20 00:10:00 190.0
使⽤TimeGrouper的限制是时间必须是Series或DataFrame的索引。
三、链式编程技术
当对数据集进⾏⼀系列变换时，你可能发现创建的多个临时变量其实并没有在分析中⽤到。看下⾯的例⼦：
df = load_data()
df2 = df[df['col2'] < 0]
df2['col1_demeaned'] = df2['col1'] - df2['col1'].mean()
result = df2.groupby('key').col1_demeaned.std()
虽然这⾥没有使⽤真实的数据，这个例⼦却指出了⼀些新⽅法。⾸先，DataFrame.assign⽅法是⼀个df[k] = v形式的函数式的列分配⽅法。它不是就地修改对象，⽽是返回新的修改过的DataFrame。因此，下⾯的语句是等价的：
# Usual non-functional way
df2 = df.copy()
df2['k'] = v
# Functional assign way
df2 = df.assign(k=v)
就地分配可能会⽐assign快，但是assign可以⽅便地进⾏链式编程：
result = (df2.assign(col1_demeaned=df2.col1 - df2.col2.mean())
.groupby('key')
.col1_demeaned.std())
这里使⽤外括号，这样便于添加换⾏符。
使⽤链式编程时要注意，你可能会需要涉及临时对象。在前⾯的例⼦中，我们不能使⽤load_data的结果，直到它被赋值给临时变量df。为了这么做，assign和许多其它pandas函数可以接收类似函数的参数，即可调⽤对象（callable）。为了展示可调⽤对象，看⼀个前⾯例⼦的⽚段：
df = load_data()
df2 = df[df['col2'] < 0]
它可以重写为：
df = (load_data()
[lambda x: x['col2'] < 0])
这⾥，load_data的结果没有赋值给某个变量，因此传递到[ ]的函数在这⼀步被绑定到了对象。
我们可以把整个过程写为⼀个单链表达式：
result = (load_data()
[lambda x: x.col2 < 0]
.assign(col1_demeaned=lambda x: x.col1 - x.col1.mean())
.groupby('key')
.col1_demeaned.std())
是否将代码写成这种形式只是习惯⽽已，将它分开成若⼲步可以提⾼可读性。
1、管道⽅法
可以⽤Python内置的pandas函数和⽅法，⽤带有可调⽤对象的链式编程做许多⼯作。但是，有时你需要使⽤⾃⼰的函数，或是第三⽅库的函数。这时就要⽤到管道⽅法。
看下⾯的函数调⽤：
a = f(df, arg1=v1)
b = g(a, v2, arg3=v3)
c = h(b, arg4=v4)
当使⽤接收、返回Series或DataFrame对象的函数式，你可以调⽤pipe将其重写：
result = (df.pipe(f, arg1=v1)
.pipe(g, v2, arg3=v3)
.pipe(h, arg4=v4))
f(df)和df.pipe(f)是等价的，但是pipe使得链式声明更容易。
pipe的另⼀个有⽤的地⽅是提炼操作为可复⽤的函数。看⼀个从列减去分组⽅法的例⼦：
g = df.groupby(['key1', 'key2'])
df['col1'] = df['col1'] - g.transform('mean') # 注意先分组后才可调用transform()方法
假设你想转换多列，并修改分组的键。另外，你想⽤链式编程做这个转换。下⾯就是⼀个⽅法：
def group_demean(df, by, cols):
result = df.copy()
g = df.groupby(by)
for c in cols:
result[c] = df[c] - g[c].transform('mean')
return result
然后可以写为：
result = (df[df.col1 < 0]
.pipe(group_demean, ['key1', 'key2'], ['col1']))
四、总结：
pandas和其它开源项目一样，在不断的变化和进步中，这里重点是放在接下来几年不会发生什么改变且稳定的功能。进一步学习pandas，可以阅读官方文档，并阅读开发团队发布的更新文档。
pandas官网：http://pandas.pydata.org/