9.11.数据处理
Windows 10
Python 3.8.8 @ MSC v.1928 64 bit (AMD64)
Latest build date 2021.02.28
pandas version: 1.2.2
df = DataFrame(np.arange(24).reshape(6,4), columns=["a","b","c","d"])
df.iloc[3] = np.nan
df.loc[2,"a"] = np.nan
df.loc[4,"a"] = np.nan
df.loc[1,"b"] = np.nan
df.loc[5,"c"] = np.nan
df
a b c d
0 0.0 1.0 2.0 3.0
1 4.0 NaN 6.0 7.0
2 NaN 9.0 10.0 11.0
3 NaN NaN NaN NaN
4 NaN 17.0 18.0 19.0
5 20.0 21.0 NaN 23.0
处理缺失值
pandas的DataFrame试图模仿R语言中的data.frame数据结构，但在Python中，pandas建立在numpy之上，而 numpy 只有nan值（Not a Number），因此pandas用nan值表示缺失数据，Python内置的None值在DataFrame中也作为nan值。但在R语言中，NA、NaN、Null有不同的意义：
NA：表示缺失值(Missing value)，是“Not Available”的缩写NaN：表示非数值，是“Not a Number”的缩写NULL：表示空值，即没有内容
因此在pandas中，判断缺失值有两个方法：.isna和isnull，它们的作用是相同的。虽然缺失数据在pandas中呈现的方式有些不完美，但对于大多数用户可以保证功能正常。
下表列出了一些关于缺失数据处理的函数：
| 方法 | 说明 |
|---|---|
isnull、isna |
返回一个含有布尔值的对象，这些布尔值表示哪些值是缺失值/NA，该对象的类型与源类型一样 |
fillna |
用指定值或插值方法（如ffill或bfill）填充缺失数据 |
dropna |
根据各标签的值中是否存在缺失数据对轴标签进行过滤，可通过阈值调节对缺失值的容忍度 |
notnull |
isnull的否定式 |
筛选出缺失数据
df.isna()
a b c d
0 False False False False
1 False True False False
2 True False False False
3 True True True True
4 True False False False
5 False False True False
筛选出有缺失值的样本
df[np.array(df.isna())]
a b c d
1 4.0 NaN 6.0 7.0
2 NaN 9.0 10.0 11.0
3 NaN NaN NaN NaN
3 NaN NaN NaN NaN
3 NaN NaN NaN NaN
3 NaN NaN NaN NaN
4 NaN 17.0 18.0 19.0
5 20.0 21.0 NaN 23.0
print(df.isna().any(axis=1))
df[df.isna().any(axis=1)]
0 False
1 True
2 True
3 True
4 True
5 True
dtype: bool
a b c d
1 4.0 NaN 6.0 7.0
2 NaN 9.0 10.0 11.0
3 NaN NaN NaN NaN
4 NaN 17.0 18.0 19.0
5 20.0 21.0 NaN 23.0
统计有缺失值的样本数
df.isna().any(axis=1).sum()
5
筛选出有缺失值的列
print(df.isna().any(axis=0))
df[np.array(df.isna())]
a True
b True
c True
d True
dtype: bool
a b c d
1 4.0 NaN 6.0 7.0
2 NaN 9.0 10.0 11.0
3 NaN NaN NaN NaN
3 NaN NaN NaN NaN
3 NaN NaN NaN NaN
3 NaN NaN NaN NaN
4 NaN 17.0 18.0 19.0
5 20.0 21.0 NaN 23.0
统计有缺失值的列数
df.isna().any(axis=0).sum()
4
删除缺失数据
dropna(axis=0, how="any", thresh=None, subset=None, inplace=False)
how：how=any，删除存在缺失数据的行或列；how=all，删除所有数据都是缺失数据的行或列。thresh：如果某一行（列）有thresh个非NA值，则不删除该行（列）。subset：删除NA数据时，要考虑的其他轴上的标签。即只要该标签不是NA值，则无需删除。
删除所有存在缺失数据的行或列：
df.dropna(how="any", axis=0)
a b c d
0 0.0 1.0 2.0 3.0
删除所有值都是缺失数据的行或列：
# 因为没有一行或列都是NA值 所以不删除数据
df.dropna(how="all", axis=0)
a b c d
0 0.0 1.0 2.0 3.0
1 4.0 NaN 6.0 7.0
2 NaN 9.0 10.0 11.0
4 NaN 17.0 18.0 19.0
5 20.0 21.0 NaN 23.0
每一行只要有3个值不是NA值，则不删除：
df.dropna(how="any", axis=0, thresh=3)
a b c d
0 0.0 1.0 2.0 3.0
1 4.0 NaN 6.0 7.0
2 NaN 9.0 10.0 11.0
4 NaN 17.0 18.0 19.0
5 20.0 21.0 NaN 23.0
只要列a的值不是NA值，就不删除：
df.dropna(how="any", axis=0, subset=["a"])
a b c d
0 0.0 1.0 2.0 3.0
1 4.0 NaN 6.0 7.0
5 20.0 21.0 NaN 23.0
填充缺失数据
fillna(value=None, method=None, axis=None, inplace=False,
limit=None, downcast=None)
value：scalar, dict, Series, or DataFrame。用于填充的值。如果传入dict、Series、DataFrame，则指定哪个值填充哪个index（对于Series）或哪个值填充哪个列（对于DataFrame）。不在dict、Series、DataFrame中的值将不被填充。method：{'backfill', 'bfill', 'pad', 'ffill', None}。用于填充的方法。backfill和bfill是后向填充（从后向前），pad和ffill是前向填充。limit：int。当指定了method参数时，limit是最大连续填充的数量。当没有指定method参数时，limit是每个轴最大填充数量。downcast：dict of item->dtype，如果可能的话，进行类型转换。
全部NA值填充为10，每个轴最多填充2个NA值：
df.fillna(value=10, limit=2)
a b c d
0 0.0 1.0 2.0 3.0
1 4.0 10.0 6.0 7.0
2 10.0 9.0 10.0 11.0
3 10.0 10.0 10.0 10.0
4 NaN 17.0 18.0 19.0
5 20.0 21.0 10.0 23.0
后向填充NA值，最多连续填充2个NA值：
df.fillna(method="bfill", limit=2)
a b c d
0 0.0 1.0 2.0 3.0
1 4.0 9.0 6.0 7.0
2 NaN 9.0 10.0 11.0
3 20.0 17.0 18.0 19.0
4 20.0 17.0 18.0 19.0
5 20.0 21.0 NaN 23.0
如果想用平均值或中位数进行填充，也是很方便的：
print(df.mean())
df.fillna(df.mean())
a 8.0
b 12.0
c 9.0
d 12.6
dtype: float64
a b c d
0 0.0 1.0 2.0 3.0
1 4.0 12.0 6.0 7.0
2 8.0 9.0 10.0 11.0
3 8.0 12.0 9.0 12.6
4 8.0 17.0 18.0 19.0
5 20.0 21.0 9.0 23.0
移除重复数据
data = pd.DataFrame({'k1': ['one', 'two'] * 3 + ['two'],
'k2': [1, 1, 2, 3, 3, 4, 4]})
data
k1 k2
0 one 1
1 two 1
2 one 2
3 two 3
4 one 3
5 two 4
6 two 4
DataFrame的duplicated方法返回一个布尔型Series，表示各行是否是重复行（前面出现过的行）：
data.duplicated()
0 False
1 False
2 False
3 False
4 False
5 False
6 True
dtype: bool
drop_duplicates方法移除重复数据：
data.drop_duplicates()
k1 k2
0 one 1
1 two 1
2 one 2
3 two 3
4 one 3
5 two 4
这两个方法默认会判断全部列，也可以指定部分列进行重复项判断：
data.duplicated(["k1"])
0 False
1 False
2 True
3 True
4 True
5 True
6 True
dtype: bool
duplicated和drop_duplicates默认保留的是第一个出现的值组合。传入keep='last'则保留最后一个：
data.drop_duplicates(['k1', 'k2'], keep='last')
k1 k2
0 one 1
1 two 1
2 one 2
3 two 3
4 one 3
6 two 4
利用函数或映射进行数据转换
对于许多数据集，你可能希望根据数组、Series或DataFrame列中的值来实现转换工作。
data = pd.DataFrame({'food': ['bacon', 'pulled pork', 'bacon',
'pastrami', 'corned beef', 'bacon',
'pastrami', 'honey ham', 'nova lox'],
'ounces': [4, 3, 12, 6, 7.5, 8, 3, 5, 6]})
data
food ounces
0 bacon 4.0
1 pulled pork 3.0
2 bacon 12.0
3 pastrami 6.0
4 corned beef 7.5
5 bacon 8.0
6 pastrami 3.0
7 honey ham 5.0
8 nova lox 6.0
假设你想要添加一列表示该肉类食物来源的动物类型。我们先编写一个不同肉类到动物的映射：
meat_to_animal = {
'bacon': 'pig',
'pulled pork': 'pig',
'pastrami': 'cow',
'corned beef': 'cow',
'honey ham': 'pig',
'nova lox': 'salmon'
}
data['food'].map(meat_to_animal)
0 pig
1 pig
2 pig
3 cow
4 cow
5 pig
6 cow
7 pig
8 salmon
Name: food, dtype: object
替换值
利用fillna方法填充缺失数据可以看做值替换的一种特殊情况。前面已经看到，map可用于修改对象的数据子集，而replace则提供了一种实现该功能的更简单、更灵活的方式。我们来看看下面这个Series：
data = pd.Series([1., -999., 2., -999., -1000., 3.])
data
0 1.0
1 -999.0
2 2.0
3 -999.0
4 -1000.0
5 3.0
dtype: float64
-999这个值可能是一个表示缺失数据的标记值。要将其替换为pandas能够理解的NA值，我们可以利用replace来产生一个新的Series（除非传入inplace=True）：
data.replace(-999, np.nan)
0 1.0
1 NaN
2 2.0
3 NaN
4 -1000.0
5 3.0
dtype: float64
如果你希望一次性替换多个值，可以传入一个由待替换值组成的列表以及一个替换值：
data.replace([-999, -1000], np.nan)
0 1.0
1 NaN
2 2.0
3 NaN
4 NaN
5 3.0
dtype: float64
要让每个值有不同的替换值，可以传递一个替换列表：
data.replace([-999, -1000], [np.nan, 0])
0 1.0
1 NaN
2 2.0
3 NaN
4 0.0
5 3.0
dtype: float64
传入的参数也可以是字典：
data.replace({-999: np.nan, -1000: 0})
0 1.0
1 NaN
2 2.0
3 NaN
4 0.0
5 3.0
dtype: float64
重命名轴索引
跟Series中的值一样，轴标签也可以通过函数或映射进行转换，从而得到一个新的不同标签的对象。轴还可以被就地修改，而无需新建一个数据结构。接下来看看下面这个简单的例子：
data = pd.DataFrame(np.arange(12).reshape((3, 4)),
index=['Ohio', 'Colorado', 'New York'],
columns=['one', 'two', 'three', 'four'])
data
one two three four
Ohio 0 1 2 3
Colorado 4 5 6 7
New York 8 9 10 11
跟Series一样，轴索引也有一个map方法：
transform = lambda x: x[:4].upper()
data.index.map(transform)
Index(['OHIO', 'COLO', 'NEW '], dtype='object')
你可以将其赋值给index，这样就可以对DataFrame进行就地修改：
data.index = data.index.map(transform)
data
one two three four
OHIO 0 1 2 3
COLO 4 5 6 7
NEW 8 9 10 11
如果想要创建数据集的转换版（而不是修改原始数据），比较实用的方法是rename：
data.rename(index=str.title, columns=str.upper)
ONE TWO THREE FOUR
Ohio 0 1 2 3
Colo 4 5 6 7
New 8 9 10 11
特别说明一下，rename可以结合字典型对象实现对部分轴标签的更新：
data.rename(index={'OHIO': 'INDIANA'},
columns={'three': 'peekaboo'})
one two peekaboo four
INDIANA 0 1 2 3
COLO 4 5 6 7
NEW 8 9 10 11
rename可以实现复制DataFrame并对其索引和列标签进行赋值。如果希望就地修改某个数据集，传入inplace=True即可：
data.rename(index={'OHIO': 'INDIANA'}, inplace=True)
data
one two three four
INDIANA 0 1 2 3
COLO 4 5 6 7
NEW 8 9 10 11
离散化和面元划分
有时候，我们相对连续的数据分组分析，而pandas有一些能根据指定“面元”（bin）或样本分位数将数据拆分成多块的工具（比如pandas.cut()和qcut）。将这些函数跟groupby结合起来，就能非常轻松地实现对数据集的桶（bucket）或分位数（quantile）分析了。
假设有一组人员数据，想将它们划分为“18到25”、“26到35”、“35到60”以及“60以上”4个不同的年龄组：
ages = [20, 22, 25, 27, 21, 23, 37, 31, 61, 45, 41, 32]
bins = [18, 25, 35, 60, 100]
cats = pd.cut(ages, bins)
cats
[(18, 25], (18, 25], (18, 25], (25, 35], (18, 25], ..., (25, 35], (60,
100], (35, 60], (35, 60], (25, 35]]
Length: 12
Categories (4, interval[int64]): [(18, 25] < (25, 35] < (35, 60] <
(60, 100]]
list(cats)
[Interval(18, 25, closed='right'),
Interval(18, 25, closed='right'),
Interval(18, 25, closed='right'),
Interval(25, 35, closed='right'),
Interval(18, 25, closed='right'),
Interval(18, 25, closed='right'),
Interval(35, 60, closed='right'),
Interval(25, 35, closed='right'),
Interval(60, 100, closed='right'),
Interval(35, 60, closed='right'),
Interval(35, 60, closed='right'),
Interval(25, 35, closed='right')]
pandas返回的是一个特殊的Categorical对象。结果展示了pandas.cut划分的面元。你可以将输出结果看做一组表示面元名称的字符串。它的底层含有一个表示不同分类名称的类型数组，以及一个codes属性中的年龄数据的标签：
pprint.pprint(cats.codes)
pprint.pprint(cats.categories)
pd.value_counts(cats)
array([0, 0, 0, 1, 0, 0, 2, 1, 3, 2, 2, 1], dtype=int8)
IntervalIndex([(18, 25], (25, 35], (35, 60], (60, 100]],
closed='right',
dtype='interval[int64]')
(18, 25] 5
(25, 35] 3
(35, 60] 3
(60, 100] 1
dtype: int64
pd.value_counts(cats)是pandas.cut结果的面元计数。
示例：分组进行统计计算
由cut返回的Categorical对象可作为参数传入groupby方法。因此，我们可以像下面这样对ages做一些统计计算：
def get_stats(group):
return {'min': group.min(), 'max': group.max(),
'count': group.count(), 'mean': group.mean()}
grouped = Series(ages).groupby(cats)
grouped.apply(get_stats).unstack()
min max count mean
(18, 25] 20.0 25.0 5.0 22.2
(25, 35] 27.0 32.0 3.0 30.0
(35, 60] 37.0 45.0 3.0 41.0
(60, 100] 61.0 61.0 1.0 61.0
示例：分组填充缺失值
对于缺失数据的填充工作，有时可能会希望用一个由数据集本身所衍生出来的值去填充NA值。例如，用平均值去填充NA值。
假设你需要对不同的分组填充不同的值。一种方法是将数据分组，并使用apply和一个能够对各数据块调用fillna的函数即可。下面是一些有关美国几个州的示例数据，这些州又被分为东部和西部：
data = pd.read_excel(r"..\datasets\example.xlsx", index_col=0)
print(data, "\n")
print(data.groupby("region").mean())
index region
Ohio 22.0 East
New York -2.0 East
Vermont NaN East
Florida 1.0 East
Oregon -8.0 West
Nevada NaN West
California 10.0 West
Idaho NaN West
index
region
East 7.0
West 1.0
我们可以用分组平均值去填充NA值:
fill_mean = lambda g: g.fillna(g.mean())
data.groupby("region").apply(fill_mean)
index region
region
East Ohio 22.0 East
New York -2.0 East
Vermont 7.0 East
Florida 1.0 East
West Oregon -8.0 West
Nevada 1.0 West
California 10.0 West
Idaho 1.0 West
另外，也可以在代码中预定义各组的填充值。由于分组具有一个name属性，所以我们可以拿来用一下：
fill_values = {'East': 0.5, 'West': -1}
fill_func = lambda g: g.fillna(fill_values[g.name])
data.groupby("region").apply(fill_func)
index region
Ohio 22.0 East
New York -2.0 East
Vermont 0.5 East
Florida 1.0 East
Oregon -8.0 West
Nevada -1.0 West
California 10.0 West
Idaho -1.0 West
right和labels参数
跟“区间”的数学符号一样，圆括号表示开端，而方括号则表示闭端（包括）。哪边是闭端可以通过right=False进行修改：
pd.cut(ages, [18, 26, 36, 61, 100], right=False)
[[18, 26), [18, 26), [18, 26), [26, 36), [18, 26), ..., [26, 36), [61,
100), [36, 61), [36, 61), [26, 36)]
Length: 12
Categories (4, interval[int64]): [[18, 26) < [26, 36) < [36, 61) <
[61, 100)]
可以通过传递一个列表或数组到labels参数，设置自己的面元名称：
group_names = ['Youth', 'YoungAdult', 'MiddleAged', 'Senior']
pd.cut(ages, bins, labels=group_names)
['Youth', 'Youth', 'Youth', 'YoungAdult', 'Youth', ..., 'YoungAdult',
'Senior', 'MiddleAged', 'MiddleAged', 'YoungAdult']
Length: 12
Categories (4, object): ['Youth' < 'YoungAdult' < 'MiddleAged' <
'Senior']
cut函数 vs qcut函数
如果向cut传入的是面元的数量而不是确切的面元边界，则它会根据数据的最小值和最大值计算等长面元。下面这个例子中，我们将一些均匀分布的数据分成四组：
data = np.random.rand(20)
pd.cut(data, 4, precision=2)
[(0.75, 0.99], (0.75, 0.99], (0.0074, 0.25], (0.0074, 0.25], (0.25,
0.5], ..., (0.5, 0.75], (0.75, 0.99], (0.5, 0.75], (0.75, 0.99],
(0.0074, 0.25]]
Length: 20
Categories (4, interval[float64]): [(0.0074, 0.25] < (0.25, 0.5] <
(0.5, 0.75] < (0.75, 0.99]]
选项precision=2，限定小数只有两位。
qcut是一个非常类似于cut的函数，它可以根据样本分位数对数据进行面元划分。根据数据的分布情况，cut可能无法使各个面元中含有相同数量的数据点。而qcut由于使用的是样本分位数，因此可以得到大小基本相等的面元：
data = np.random.randn(1000) # Normally distributed
cats = pd.qcut(data, 4) # Cut into quartiles
pd.value_counts(cats)
(-2.9499999999999997, -0.691] 250
(-0.691, -0.0192] 250
(-0.0192, 0.62] 250
(0.62, 3.928] 250
dtype: int64
与cut类似，你也可以传递自定义的分位数（0到1之间的数值，包含端点）：
pd.qcut(data, [0, 0.1, 0.5, 0.9, 1.])
[(1.289, 3.928], (-1.191, -0.0192], (-1.191, -0.0192], (-0.0192,
1.289], (-0.0192, 1.289], ..., (1.289, 3.928], (-1.191, -0.0192],
(-1.191, -0.0192], (-1.191, -0.0192], (-1.191, -0.0192]]
Length: 1000
Categories (4, interval[float64]): [(-2.9499999999999997, -1.191] <
(-1.191, -0.0192] < (-0.0192, 1.289] <
(1.289, 3.928]]
检测和过滤异常值
过滤或变换异常值（outlier）在很大程度上就是运用数组运算。来看一个含有正态分布数据的DataFrame：
data = pd.DataFrame(np.random.randn(1000, 4))
data.describe()
0 1 2 3
count 1000.000000 1000.000000 1000.000000 1000.000000
mean 0.022282 -0.001383 -0.055245 0.043350
std 1.008995 0.995882 0.998735 0.996658
min -3.184377 -3.745356 -3.428254 -3.645860
25% -0.628122 -0.697084 -0.747963 -0.600254
50% -0.016127 -0.026381 -0.096965 0.043663
75% 0.695298 0.699046 0.622384 0.740562
max 3.525865 2.735527 3.366626 2.653656
假设你想要找出某列中绝对值大小超过3的值：
col = data[2]
col[np.abs(col) > 3]
267 -3.428254
644 3.366626
Name: 2, dtype: float64
要选出全部含有“超过3或－3的值”的行，你可以在布尔型DataFrame中使用any方法：
data[(np.abs(data) > 3).any(axis=1)]
0 1 2 3
50 -0.025907 -3.399312 -0.974657 -0.685312
69 3.260383 0.963301 1.201206 -1.852001
145 -0.196713 -3.745356 -1.520113 -0.346839
244 -3.056990 1.918403 -0.578828 1.847446
267 0.326045 0.425384 -3.428254 -0.296336
331 -3.184377 1.369891 -1.074833 -0.089937
552 0.208011 -0.150923 -0.362528 -3.548824
644 0.193299 1.397822 3.366626 -2.372214
791 3.525865 0.283070 0.544635 0.462204
811 -0.450721 -0.080332 0.599947 -3.645860
根据这些条件，就可以对值进行设置。下面的代码可以将值限制在区间－3到3以内：
data[np.abs(data) > 3] = np.sign(data) * 3
data.describe()
0 1 2 3
count 1000.000000 1000.000000 1000.000000 1000.000000
mean 0.021737 -0.000238 -0.055183 0.044545
std 1.005754 0.992064 0.996186 0.992637
min -3.000000 -3.000000 -3.000000 -3.000000
25% -0.628122 -0.697084 -0.747963 -0.600254
50% -0.016127 -0.026381 -0.096965 0.043663
75% 0.695298 0.699046 0.622384 0.740562
max 3.000000 2.735527 3.000000 2.653656
根据数据的值是正还是负，np.sign(data)可以生成1和-1：
np.sign(data).head()
0 1 2 3
0 1.0 1.0 1.0 -1.0
1 1.0 1.0 -1.0 -1.0
2 1.0 -1.0 -1.0 -1.0
3 1.0 1.0 -1.0 1.0
4 -1.0 -1.0 -1.0 -1.0
排列和随机采样
利用numpy.random.permutation函数可以轻松实现对Series或DataFrame的列的排列工作（permuting，随机重排序）。通过需要排列的轴的长度调用permutation，可产生一个表示新顺序的整数数组：
df = pd.DataFrame(np.arange(5 * 4).reshape((5, 4)))
sampler = np.random.permutation(5)
sampler
array([4, 3, 2, 1, 0])
然后就可以在基于iloc的索引操作或take函数中使用该数组了：
df
df.take(sampler)
0 1 2 3
4 16 17 18 19
3 12 13 14 15
2 8 9 10 11
1 4 5 6 7
0 0 1 2 3
如果不想用替换的方式选取随机子集，可以在Series和DataFrame上使用sample方法：
df.sample(n=3)
0 1 2 3
0 0 1 2 3
4 16 17 18 19
1 4 5 6 7
要通过替换的方式产生样本（允许重复选择），可以传递replace=True到sample方法：
choices = pd.Series([5, 7, -1, 6, 4])
draws = choices.sample(n=10, replace=True)
draws
0 5
1 7
3 6
4 4
0 5
0 5
1 7
0 5
0 5
4 4
dtype: int64
计算指标/哑变量
另一种常用于统计建模或机器学习的转换方式是：将分类变量（categorical variable）转换为“哑变量”或“指标矩阵”。
如果DataFrame的某一列中含有k个不同的值，则可以派生出一个k列矩阵或DataFrame（其值全为1和0）。pandas有一个get_dummies函数可以实现该功能（其实自己动手做一个也不难）。使用之前的一个DataFrame例子：
df = pd.DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'b'],
'data1': range(6)})
pd.get_dummies(df['key'])
a b c
0 0 1 0
1 0 1 0
2 1 0 0
3 0 0 1
4 1 0 0
5 0 1 0
有时候，你可能想给指标DataFrame的列加上一个前缀，以便能够跟其他数据进行合并。get_dummies的prefix参数可以实现该功能：
dummies = pd.get_dummies(df['key'], prefix='key')
df_with_dummy = df[['data1']].join(dummies)
df_with_dummy
data1 key_a key_b key_c
0 0 0 1 0
1 1 0 1 0
2 2 1 0 0
3 3 0 0 1
4 4 1 0 0
5 5 0 1 0
如果DataFrame中的某行同属于多个分类，则事情就会有点复杂。看一下MovieLens 1M数据集：
mnames = ['movie_id', 'title', 'genres']
movies = pd.read_table('../datasets/movies.dat', sep='::', header=None,
names=mnames, engine='python')
movies[:10]
movie_id title genres
0 1 Toy Story (1995) Animation|Children's|Comedy
1 2 Jumanji (1995) Adventure|Children's|Fantasy
2 3 Grumpier Old Men (1995) Comedy|Romance
3 4 Waiting to Exhale (1995) Comedy|Drama
4 5 Father of the Bride Part II (1995) Comedy
5 6 Heat (1995) Action|Crime|Thriller
6 7 Sabrina (1995) Comedy|Romance
7 8 Tom and Huck (1995) Adventure|Children's
8 9 Sudden Death (1995) Action
9 10 GoldenEye (1995) Action|Adventure|Thriller
要为每个genre添加指标变量就需要做一些数据规整操作。首先，我们从数据集中抽取出不同的genre值：
all_genres = []
for x in movies.genres:
all_genres.extend(x.split('|'))
genres = pd.unique(all_genres)
现在有：
genres
构建指标DataFrame的方法之一是从一个全零DataFrame开始：
zero_matrix = np.zeros((len(movies), len(genres)))
dummies = pd.DataFrame(zero_matrix, columns=genres)
现在，迭代每一部电影，并将dummies各行的条目设为1。要这么做，我们使用dummies.columns来计算每个类型的列索引：
gen = movies.genres[0]
gen.split('|')
dummies.columns.get_indexer(gen.split('|'))
array([0, 1, 2], dtype=int64)
然后，根据索引，使用.iloc设定值：
for i, gen in enumerate(movies.genres):
indices = dummies.columns.get_indexer(gen.split('|'))
dummies.iloc[i, indices] = 1
然后，和以前样，再将其与movies合并起来：
movies_windic = movies.join(dummies.add_prefix('Genre_'))
movies_windic.iloc[0]
movie_id 1
title Toy Story (1995)
genres Animation|Children's|Comedy
Genre_Animation 1.0
Genre_Children's 1.0
Genre_Comedy 1.0
Genre_Adventure 0.0
Genre_Fantasy 0.0
Genre_Romance 0.0
Genre_Drama 0.0
Genre_Action 0.0
Genre_Crime 0.0
Genre_Thriller 0.0
Genre_Horror 0.0
Genre_Sci-Fi 0.0
Genre_Documentary 0.0
Genre_War 0.0
Genre_Musical 0.0
Genre_Mystery 0.0
Genre_Film-Noir 0.0
Genre_Western 0.0
Name: 0, dtype: object
笔记：对于很大的数据，用这种方式构建多成员指标变量就会变得非常慢。最好使用更低级的函数，将其写入NumPy数组，然后结果包装在DataFrame中。
一个对统计应用有用的秘诀是：结合get_dummies和诸如cut之类的离散化函数：
np.random.seed(12345)
values = np.random.rand(10)
values
bins = [0, 0.2, 0.4, 0.6, 0.8, 1]
pd.get_dummies(pd.cut(values, bins))
(0.0, 0.2] (0.2, 0.4] (0.4, 0.6] (0.6, 0.8] (0.8, 1.0]
0 0 0 0 0 1
1 0 1 0 0 0
2 1 0 0 0 0
3 0 1 0 0 0
4 0 0 1 0 0
5 0 0 1 0 0
6 0 0 0 0 1
7 0 0 0 1 0
8 0 0 0 1 0
9 0 0 0 1 0
我们用numpy.random.seed，使这个例子具有确定性。本书后面会介绍pandas.get_dummies。
# h = H(pd)
# d = h.dicts
# d["function"]
# [i for i in dir(pd) if "na" in i]