• 7.2 数据转换
    • 移除重复数据
    • 利用函数或映射进行数据转换
    • 替换值
    • 重命名轴索引
    • 离散化和面元划分
    • 检测和过滤异常值
    • 排列和随机采样
    • 计算指标/哑变量

    7.2 数据转换

    本章到目前为止介绍的都是数据的重排。另一类重要操作则是过滤、清理以及其他的转换工作。

    移除重复数据

    DataFrame中出现重复行有多种原因。下面就是一个例子:

    1. In [45]: data = pd.DataFrame({'k1': ['one', 'two'] * 3 + ['two'],
    2. ....: 'k2': [1, 1, 2, 3, 3, 4, 4]})
    3. In [46]: data
    4. Out[46]:
    5. k1 k2
    6. 0 one 1
    7. 1 two 1
    8. 2 one 2
    9. 3 two 3
    10. 4 one 3
    11. 5 two 4
    12. 6 two 4

    DataFrame的duplicated方法返回一个布尔型Series,表示各行是否是重复行(前面出现过的行):

    1. In [47]: data.duplicated()
    2. Out[47]:
    3. 0 False
    4. 1 False
    5. 2 False
    6. 3 False
    7. 4 False
    8. 5 False
    9. 6 True
    10. dtype: bool

    还有一个与此相关的drop_duplicates方法,它会返回一个DataFrame,重复的数组会标为False:

    1. In [48]: data.drop_duplicates()
    2. Out[48]:
    3. k1 k2
    4. 0 one 1
    5. 1 two 1
    6. 2 one 2
    7. 3 two 3
    8. 4 one 3
    9. 5 two 4

    这两个方法默认会判断全部列,你也可以指定部分列进行重复项判断。假设我们还有一列值,且只希望根据k1列过滤重复项:

    1. In [49]: data['v1'] = range(7)
    2. In [50]: data.drop_duplicates(['k1'])
    3. Out[50]:
    4. k1 k2 v1
    5. 0 one 1 0
    6. 1 two 1 1

    duplicated和drop_duplicates默认保留的是第一个出现的值组合。传入keep=’last’则保留最后一个:

    1. In [51]: data.drop_duplicates(['k1', 'k2'], keep='last')
    2. Out[51]:
    3. k1 k2 v1
    4. 0 one 1 0
    5. 1 two 1 1
    6. 2 one 2 2
    7. 3 two 3 3
    8. 4 one 3 4
    9. 6 two 4 6

    利用函数或映射进行数据转换

    对于许多数据集,你可能希望根据数组、Series或DataFrame列中的值来实现转换工作。我们来看看下面这组有关肉类的数据:

    1. In [52]: data = pd.DataFrame({'food': ['bacon', 'pulled pork', 'bacon',
    2. ....: 'Pastrami', 'corned beef', 'Bacon',
    3. ....: 'pastrami', 'honey ham', 'nova lox'],
    4. ....: 'ounces': [4, 3, 12, 6, 7.5, 8, 3, 5, 6]})
    5. In [53]: data
    6. Out[53]:
    7. food ounces
    8. 0 bacon 4.0
    9. 1 pulled pork 3.0
    10. 2 bacon 12.0
    11. 3 Pastrami 6.0
    12. 4 corned beef 7.5
    13. 5 Bacon 8.0
    14. 6 pastrami 3.0
    15. 7 honey ham 5.0
    16. 8 nova lox 6.0

    假设你想要添加一列表示该肉类食物来源的动物类型。我们先编写一个不同肉类到动物的映射:

    1. meat_to_animal = {
    2. 'bacon': 'pig',
    3. 'pulled pork': 'pig',
    4. 'pastrami': 'cow',
    5. 'corned beef': 'cow',
    6. 'honey ham': 'pig',
    7. 'nova lox': 'salmon'
    8. }

    Series的map方法可以接受一个函数或含有映射关系的字典型对象,但是这里有一个小问题,即有些肉类的首字母大写了,而另一些则没有。因此,我们还需要使用Series的str.lower方法,将各个值转换为小写:

    1. In [55]: lowercased = data['food'].str.lower()
    2. In [56]: lowercased
    3. Out[56]:
    4. 0 bacon
    5. 1 pulled pork
    6. 2 bacon
    7. 3 pastrami
    8. 4 corned beef
    9. 5 bacon
    10. 6 pastrami
    11. 7 honey ham
    12. 8 nova lox
    13. Name: food, dtype: object
    14. In [57]: data['animal'] = lowercased.map(meat_to_animal)
    15. In [58]: data
    16. Out[58]:
    17. food ounces animal
    18. 0 bacon 4.0 pig
    19. 1 pulled pork 3.0 pig
    20. 2 bacon 12.0 pig
    21. 3 Pastrami 6.0 cow
    22. 4 corned beef 7.5 cow
    23. 5 Bacon 8.0 pig
    24. 6 pastrami 3.0 cow
    25. 7 honey ham 5.0 pig
    26. 8 nova lox 6.0 salmon

    我们也可以传入一个能够完成全部这些工作的函数:

    1. In [59]: data['food'].map(lambda x: meat_to_animal[x.lower()])
    2. Out[59]:
    3. 0 pig
    4. 1 pig
    5. 2 pig
    6. 3 cow
    7. 4 cow
    8. 5 pig
    9. 6 cow
    10. 7 pig
    11. 8 salmon
    12. Name: food, dtype: object

    使用map是一种实现元素级转换以及其他数据清理工作的便捷方式。

    替换值

    利用fillna方法填充缺失数据可以看做值替换的一种特殊情况。前面已经看到,map可用于修改对象的数据子集,而replace则提供了一种实现该功能的更简单、更灵活的方式。我们来看看下面这个Series:

    1. In [60]: data = pd.Series([1., -999., 2., -999., -1000., 3.])
    2. In [61]: data
    3. Out[61]:
    4. 0 1.0
    5. 1 -999.0
    6. 2 2.0
    7. 3 -999.0
    8. 4 -1000.0
    9. 5 3.0

    -999这个值可能是一个表示缺失数据的标记值。要将其替换为pandas能够理解的NA值,我们可以利用replace来产生一个新的Series(除非传入inplace=True):

    1. In [62]: data.replace(-999, np.nan)
    2. Out[62]:
    3. 0 1.0
    4. 1 NaN
    5. 2 2.0
    6. 3 NaN
    7. 4 -1000.0
    8. 5 3.0
    9. dtype: float64

    如果你希望一次性替换多个值,可以传入一个由待替换值组成的列表以及一个替换值::

    1. In [63]: data.replace([-999, -1000], np.nan)
    2. Out[63]:
    3. 0 1.0
    4. 1 NaN
    5. 2 2.0
    6. 3 NaN
    7. 4 NaN
    8. 5 3.0
    9. dtype: float64

    要让每个值有不同的替换值,可以传递一个替换列表:

    1. In [64]: data.replace([-999, -1000], [np.nan, 0])
    2. Out[64]:
    3. 0 1.0
    4. 1 NaN
    5. 2 2.0
    6. 3 NaN
    7. 4 0.0
    8. 5 3.0
    9. dtype: float64

    传入的参数也可以是字典:

    1. In [65]: data.replace({-999: np.nan, -1000: 0})
    2. Out[65]:
    3. 0 1.0
    4. 1 NaN
    5. 2 2.0
    6. 3 NaN
    7. 4 0.0
    8. 5 3.0
    9. dtype: float64

    笔记:data.replace方法与data.str.replace不同,后者做的是字符串的元素级替换。我们会在后面学习Series的字符串方法。

    重命名轴索引

    跟Series中的值一样,轴标签也可以通过函数或映射进行转换,从而得到一个新的不同标签的对象。轴还可以被就地修改,而无需新建一个数据结构。接下来看看下面这个简单的例子:

    1. In [66]: data = pd.DataFrame(np.arange(12).reshape((3, 4)),
    2. ....: index=['Ohio', 'Colorado', 'New York'],
    3. ....: columns=['one', 'two', 'three', 'four'])

    跟Series一样,轴索引也有一个map方法:

    1. In [67]: transform = lambda x: x[:4].upper()
    2. In [68]: data.index.map(transform)
    3. Out[68]: Index(['OHIO', 'COLO', 'NEW '], dtype='object')

    你可以将其赋值给index,这样就可以对DataFrame进行就地修改:

    1. In [69]: data.index = data.index.map(transform)
    2. In [70]: data
    3. Out[70]:
    4. one two three four
    5. OHIO 0 1 2 3
    6. COLO 4 5 6 7
    7. NEW 8 9 10 11

    如果想要创建数据集的转换版(而不是修改原始数据),比较实用的方法是rename:

    1. In [71]: data.rename(index=str.title, columns=str.upper)
    2. Out[71]:
    3. ONE TWO THREE FOUR
    4. Ohio 0 1 2 3
    5. Colo 4 5 6 7
    6. New 8 9 10 11

    特别说明一下,rename可以结合字典型对象实现对部分轴标签的更新:

    1. In [72]: data.rename(index={'OHIO': 'INDIANA'},
    2. ....: columns={'three': 'peekaboo'})
    3. Out[72]:
    4. one two peekaboo four
    5. INDIANA 0 1 2 3
    6. COLO 4 5 6 7
    7. NEW 8 9 10 11

    rename可以实现复制DataFrame并对其索引和列标签进行赋值。如果希望就地修改某个数据集,传入inplace=True即可:

    1. In [73]: data.rename(index={'OHIO': 'INDIANA'}, inplace=True)
    2. In [74]: data
    3. Out[74]:
    4. one two three four
    5. INDIANA 0 1 2 3
    6. COLO 4 5 6 7
    7. NEW 8 9 10 11

    离散化和面元划分

    为了便于分析,连续数据常常被离散化或拆分为“面元”(bin)。假设有一组人员数据,而你希望将它们划分为不同的年龄组:

    1. In [75]: ages = [20, 22, 25, 27, 21, 23, 37, 31, 61, 45, 41, 32]

    接下来将这些数据划分为“18到25”、“26到35”、“35到60”以及“60以上”几个面元。要实现该功能,你需要使用pandas的cut函数:

    1. In [76]: bins = [18, 25, 35, 60, 100]
    2. In [77]: cats = pd.cut(ages, bins)
    3. In [78]: cats
    4. Out[78]:
    5. [(18, 25], (18, 25], (18, 25], (25, 35], (18, 25], ..., (25, 35], (60, 100], (35,60], (35, 60], (25, 35]]
    6. Length: 12
    7. Categories (4, interval[int64]): [(18, 25] < (25, 35] < (35, 60] < (60, 100]]

    pandas返回的是一个特殊的Categorical对象。结果展示了pandas.cut划分的面元。你可以将其看做一组表示面元名称的字符串。它的底层含有一个表示不同分类名称的类型数组,以及一个codes属性中的年龄数据的标签:

    1. In [79]: cats.codes
    2. Out[79]: array([0, 0, 0, 1, 0, 0, 2, 1, 3, 2, 2, 1], dtype=int8)
    3. In [80]: cats.categories
    4. Out[80]:
    5. IntervalIndex([(18, 25], (25, 35], (35, 60], (60, 100]]
    6. closed='right',
    7. dtype='interval[int64]')
    8. In [81]: pd.value_counts(cats)
    9. Out[81]:
    10. (18, 25] 5
    11. (35, 60] 3
    12. (25, 35] 3
    13. (60, 100] 1
    14. dtype: int64

    pd.value_counts(cats)是pandas.cut结果的面元计数。

    跟“区间”的数学符号一样,圆括号表示开端,而方括号则表示闭端(包括)。哪边是闭端可以通过right=False进行修改:

    1. In [82]: pd.cut(ages, [18, 26, 36, 61, 100], right=False)
    2. Out[82]:
    3. [[18, 26), [18, 26), [18, 26), [26, 36), [18, 26), ..., [26, 36), [61, 100), [36,
    4. 61), [36, 61), [26, 36)]
    5. Length: 12
    6. Categories (4, interval[int64]): [[18, 26) < [26, 36) < [36, 61) < [61, 100)]

    你可 以通过传递一个列表或数组到labels,设置自己的面元名称:

    1. In [83]: group_names = ['Youth', 'YoungAdult', 'MiddleAged', 'Senior']
    2. In [84]: pd.cut(ages, bins, labels=group_names)
    3. Out[84]:
    4. [Youth, Youth, Youth, YoungAdult, Youth, ..., YoungAdult, Senior, MiddleAged, Mid
    5. dleAged, YoungAdult]
    6. Length: 12
    7. Categories (4, object): [Youth < YoungAdult < MiddleAged < Senior]

    如果向cut传入的是面元的数量而不是确切的面元边界,则它会根据数据的最小值和最大值计算等长面元。下面这个例子中,我们将一些均匀分布的数据分成四组:

    1. In [85]: data = np.random.rand(20)
    2. In [86]: pd.cut(data, 4, precision=2)
    3. Out[86]:
    4. [(0.34, 0.55], (0.34, 0.55], (0.76, 0.97], (0.76, 0.97], (0.34, 0.55], ..., (0.34
    5. , 0.55], (0.34, 0.55], (0.55, 0.76], (0.34, 0.55], (0.12, 0.34]]
    6. Length: 20
    7. Categories (4, interval[float64]): [(0.12, 0.34] < (0.34, 0.55] < (0.55, 0.76] <
    8. (0.76, 0.97]]

    选项precision=2,限定小数只有两位。

    qcut是一个非常类似于cut的函数,它可以根据样本分位数对数据进行面元划分。根据数据的分布情况,cut可能无法使各个面元中含有相同数量的数据点。而qcut由于使用的是样本分位数,因此可以得到大小基本相等的面元:

    1. In [87]: data = np.random.randn(1000) # Normally distributed
    2. In [88]: cats = pd.qcut(data, 4) # Cut into quartiles
    3. In [89]: cats
    4. Out[89]:
    5. [(-0.0265, 0.62], (0.62, 3.928], (-0.68, -0.0265], (0.62, 3.928], (-0.0265, 0.62]
    6. , ..., (-0.68, -0.0265], (-0.68, -0.0265], (-2.95, -0.68], (0.62, 3.928], (-0.68,
    7. -0.0265]]
    8. Length: 1000
    9. Categories (4, interval[float64]): [(-2.95, -0.68] < (-0.68, -0.0265] < (-0.0265,
    10. 0.62] <
    11. (0.62, 3.928]]
    12. In [90]: pd.value_counts(cats)
    13. Out[90]:
    14. (0.62, 3.928] 250
    15. (-0.0265, 0.62] 250
    16. (-0.68, -0.0265] 250
    17. (-2.95, -0.68] 250
    18. dtype: int64

    与cut类似,你也可以传递自定义的分位数(0到1之间的数值,包含端点):

    1. In [91]: pd.qcut(data, [0, 0.1, 0.5, 0.9, 1.])
    2. Out[91]:
    3. [(-0.0265, 1.286], (-0.0265, 1.286], (-1.187, -0.0265], (-0.0265, 1.286], (-0.026
    4. 5, 1.286], ..., (-1.187, -0.0265], (-1.187, -0.0265], (-2.95, -1.187], (-0.0265,
    5. 1.286], (-1.187, -0.0265]]
    6. Length: 1000
    7. Categories (4, interval[float64]): [(-2.95, -1.187] < (-1.187, -0.0265] < (-0.026
    8. 5, 1.286] <
    9. (1.286, 3.928]]

    本章稍后在讲解聚合和分组运算时会再次用到cut和qcut,因为这两个离散化函数对分位和分组分析非常重要。

    检测和过滤异常值

    过滤或变换异常值(outlier)在很大程度上就是运用数组运算。来看一个含有正态分布数据的DataFrame:

    1. In [92]: data = pd.DataFrame(np.random.randn(1000, 4))
    2. In [93]: data.describe()
    3. Out[93]:
    4. 0 1 2 3
    5. count 1000.000000 1000.000000 1000.000000 1000.000000
    6. mean 0.049091 0.026112 -0.002544 -0.051827
    7. std 0.996947 1.007458 0.995232 0.998311
    8. min -3.645860 -3.184377 -3.745356 -3.428254
    9. 25% -0.599807 -0.612162 -0.687373 -0.747478
    10. 50% 0.047101 -0.013609 -0.022158 -0.088274
    11. 75% 0.756646 0.695298 0.699046 0.623331
    12. max 2.653656 3.525865 2.735527 3.366626

    假设你想要找出某列中绝对值大小超过3的值:

    1. In [94]: col = data[2]
    2. In [95]: col[np.abs(col) > 3]
    3. Out[95]:
    4. 41 -3.399312
    5. 136 -3.745356
    6. Name: 2, dtype: float64

    要选出全部含有“超过3或-3的值”的行,你可以在布尔型DataFrame中使用any方法:

    1. In [96]: data[(np.abs(data) > 3).any(1)]
    2. Out[96]:
    3. 0 1 2 3
    4. 41 0.457246 -0.025907 -3.399312 -0.974657
    5. 60 1.951312 3.260383 0.963301 1.201206
    6. 136 0.508391 -0.196713 -3.745356 -1.520113
    7. 235 -0.242459 -3.056990 1.918403 -0.578828
    8. 258 0.682841 0.326045 0.425384 -3.428254
    9. 322 1.179227 -3.184377 1.369891 -1.074833
    10. 544 -3.548824 1.553205 -2.186301 1.277104
    11. 635 -0.578093 0.193299 1.397822 3.366626
    12. 782 -0.207434 3.525865 0.283070 0.544635
    13. 803 -3.645860 0.255475 -0.549574 -1.907459

    根据这些条件,就可以对值进行设置。下面的代码可以将值限制在区间-3到3以内:

    1. In [97]: data[np.abs(data) > 3] = np.sign(data) * 3
    2. In [98]: data.describe()
    3. Out[98]:
    4. 0 1 2 3
    5. count 1000.000000 1000.000000 1000.000000 1000.000000
    6. mean 0.050286 0.025567 -0.001399 -0.051765
    7. std 0.992920 1.004214 0.991414 0.995761
    8. min -3.000000 -3.000000 -3.000000 -3.000000
    9. 25% -0.599807 -0.612162 -0.687373 -0.747478
    10. 50% 0.047101 -0.013609 -0.022158 -0.088274
    11. 75% 0.756646 0.695298 0.699046 0.623331
    12. max 2.653656 3.000000 2.735527 3.000000

    根据数据的值是正还是负,np.sign(data)可以生成1和-1:

    1. In [99]: np.sign(data).head()
    2. Out[99]:
    3. 0 1 2 3
    4. 0 -1.0 1.0 -1.0 1.0
    5. 1 1.0 -1.0 1.0 -1.0
    6. 2 1.0 1.0 1.0 -1.0
    7. 3 -1.0 -1.0 1.0 -1.0
    8. 4 -1.0 1.0 -1.0 -1.0

    排列和随机采样

    利用numpy.random.permutation函数可以轻松实现对Series或DataFrame的列的排列工作(permuting,随机重排序)。通过需要排列的轴的长度调用permutation,可产生一个表示新顺序的整数数组:

    1. In [100]: df = pd.DataFrame(np.arange(5 * 4).reshape((5, 4)))
    2. In [101]: sampler = np.random.permutation(5)
    3. In [102]: sampler
    4. Out[102]: array([3, 1, 4, 2, 0])

    然后就可以在基于iloc的索引操作或take函数中使用该数组了:

    1. In [103]: df
    2. Out[103]:
    3. 0 1 2 3
    4. 0 0 1 2 3
    5. 1 4 5 6 7
    6. 2 8 9 10 11
    7. 3 12 13 14 15
    8. 4 16 17 18 19
    9. In [104]: df.take(sampler)
    10. Out[104]:
    11. 0 1 2 3
    12. 3 12 13 14 15
    13. 1 4 5 6 7
    14. 4 16 17 18 19
    15. 2 8 9 10 11
    16. 0 0 1 2 3

    如果不想用替换的方式选取随机子集,可以在Series和DataFrame上使用sample方法:

    1. In [105]: df.sample(n=3)
    2. Out[105]:
    3. 0 1 2 3
    4. 3 12 13 14 15
    5. 4 16 17 18 19
    6. 2 8 9 10 11

    要通过替换的方式产生样本(允许重复选择),可以传递replace=True到sample:

    1. In [106]: choices = pd.Series([5, 7, -1, 6, 4])
    2. In [107]: draws = choices.sample(n=10, replace=True)
    3. In [108]: draws
    4. Out[108]:
    5. 4 4
    6. 1 7
    7. 4 4
    8. 2 -1
    9. 0 5
    10. 3 6
    11. 1 7
    12. 4 4
    13. 0 5
    14. 4 4
    15. dtype: int64

    计算指标/哑变量

    另一种常用于统计建模或机器学习的转换方式是:将分类变量(categorical variable)转换为“哑变量”或“指标矩阵”。

    如果DataFrame的某一列中含有k个不同的值,则可以派生出一个k列矩阵或DataFrame(其值全为1和0)。pandas有一个get_dummies函数可以实现该功能(其实自己动手做一个也不难)。使用之前的一个DataFrame例子:

    1. In [109]: df = pd.DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'b'],
    2. .....: 'data1': range(6)})
    3. In [110]: pd.get_dummies(df['key'])
    4. Out[110]:
    5. a b c
    6. 0 0 1 0
    7. 1 0 1 0
    8. 2 1 0 0
    9. 3 0 0 1
    10. 4 1 0 0
    11. 5 0 1 0

    有时候,你可能想给指标DataFrame的列加上一个前缀,以便能够跟其他数据进行合并。get_dummies的prefix参数可以实现该功能:

    1. In [111]: dummies = pd.get_dummies(df['key'], prefix='key')
    2. In [112]: df_with_dummy = df[['data1']].join(dummies)
    3. In [113]: df_with_dummy
    4. Out[113]:
    5. data1 key_a key_b key_c
    6. 0 0 0 1 0
    7. 1 1 0 1 0
    8. 2 2 1 0 0
    9. 3 3 0 0 1
    10. 4 4 1 0 0
    11. 5 5 0 1 0

    如果DataFrame中的某行同属于多个分类,则事情就会有点复杂。看一下MovieLens 1M数据集,14章会更深入地研究它:

    1. In [114]: mnames = ['movie_id', 'title', 'genres']
    2. In [115]: movies = pd.read_table('datasets/movielens/movies.dat', sep='::',
    3. .....: header=None, names=mnames)
    4. In [116]: movies[:10]
    5. Out[116]:
    6. movie_id title genres
    7. 0 1 Toy Story (1995) Animation|Children's|Comedy
    8. 1 2 Jumanji (1995) Adventure|Children's|Fantasy
    9. 2 3 Grumpier Old Men (1995) Comedy|Romance
    10. 3 4 Waiting to Exhale (1995) Comedy|Drama
    11. 4 5 Father of the Bride Part II (1995) Comedy
    12. 5 6 Heat (1995) Action|Crime|Thriller
    13. 6 7 Sabrina (1995) Comedy|Romance
    14. 7 8 Tom and Huck (1995) Adventure|Children's
    15. 8 9 Sudden Death (1995)
    16. Action
    17. 9 10 GoldenEye (1995) Action|Adventure|Thriller

    要为每个genre添加指标变量就需要做一些数据规整操作。首先,我们从数据集中抽取出不同的genre值:

    1. In [117]: all_genres = []
    2. In [118]: for x in movies.genres:
    3. .....: all_genres.extend(x.split('|'))
    4. In [119]: genres = pd.unique(all_genres)

    现在有:

    1. In [120]: genres
    2. Out[120]:
    3. array(['Animation', "Children's", 'Comedy', 'Adventure', 'Fantasy',
    4. 'Romance', 'Drama', 'Action', 'Crime', 'Thriller','Horror',
    5. 'Sci-Fi', 'Documentary', 'War', 'Musical', 'Mystery', 'Film-Noir',
    6. 'Western'], dtype=object)

    构建指标DataFrame的方法之一是从一个全零DataFrame开始:

    1. In [121]: zero_matrix = np.zeros((len(movies), len(genres)))
    2. In [122]: dummies = pd.DataFrame(zero_matrix, columns=genres)

    现在,迭代每一部电影,并将dummies各行的条目设为1。要这么做,我们使用dummies.columns来计算每个类型的列索引:

    1. In [123]: gen = movies.genres[0]
    2. In [124]: gen.split('|')
    3. Out[124]: ['Animation', "Children's", 'Comedy']
    4. In [125]: dummies.columns.get_indexer(gen.split('|'))
    5. Out[125]: array([0, 1, 2])

    然后,根据索引,使用.iloc设定值:

    1. In [126]: for i, gen in enumerate(movies.genres):
    2. .....: indices = dummies.columns.get_indexer(gen.split('|'))
    3. .....: dummies.iloc[i, indices] = 1
    4. .....:

    然后,和以前一样,再将其与movies合并起来:

    1. In [127]: movies_windic = movies.join(dummies.add_prefix('Genre_'))
    2. In [128]: movies_windic.iloc[0]
    3. Out[128]:
    4. movie_id 1
    5. title Toy Story (1995)
    6. genres Animation|Children's|Comedy
    7. Genre_Animation 1
    8. Genre_Children's 1
    9. Genre_Comedy 1
    10. Genre_Adventure 0
    11. Genre_Fantasy 0
    12. Genre_Romance 0
    13. Genre_Drama 0
    14. ...
    15. Genre_Crime 0
    16. Genre_Thriller 0
    17. Genre_Horror 0
    18. Genre_Sci-Fi 0
    19. Genre_Documentary 0
    20. Genre_War 0
    21. Genre_Musical 0
    22. Genre_Mystery 0
    23. Genre_Film-Noir 0
    24. Genre_Western 0
    25. Name: 0, Length: 21, dtype: object

    笔记:对于很大的数据,用这种方式构建多成员指标变量就会变得非常慢。最好使用更低级的函数,将其写入NumPy数组,然后结果包装在DataFrame中。

    一个对统计应用有用的秘诀是:结合get_dummies和诸如cut之类的离散化函数:

    1. In [129]: np.random.seed(12345)
    2. In [130]: values = np.random.rand(10)
    3. In [131]: values
    4. Out[131]:
    5. array([ 0.9296, 0.3164, 0.1839, 0.2046, 0.5677, 0.5955, 0.9645,
    6. 0.6532, 0.7489, 0.6536])
    7. In [132]: bins = [0, 0.2, 0.4, 0.6, 0.8, 1]
    8. In [133]: pd.get_dummies(pd.cut(values, bins))
    9. Out[133]:
    10. (0.0, 0.2] (0.2, 0.4] (0.4, 0.6] (0.6, 0.8] (0.8, 1.0]
    11. 0 0 0 0 0 1
    12. 1 0 1 0 0 0
    13. 2 1 0 0 0 0
    14. 3 0 1 0 0 0
    15. 4 0 0 1 0 0
    16. 5 0 0 1 0 0
    17. 6 0 0 0 0 1
    18. 7 0 0 0 1 0
    19. 8 0 0 0 1 0
    20. 9 0 0 0 1 0

    我们用numpy.random.seed,使这个例子具有确定性。本书后面会介绍pandas.get_dummies。