python数据处理快速入门9~10

9.1简介

pandas提供了一些用于将表格型数据读取为DataFrame对象的函数。下面的图片对它们进行了总结，其中read_csv和read_table可能会是你今后用得最多的。

我将大致介绍一下这些函数在将文本数据转换为DataFrame时所用到的一些技术。这些函数的选项可以划分为以下几个大类：

• 索引：将一个或多个列当做返回的DataFrame处理，以及是否从文件、用户获取列名。
• 类型推断和数据转换：包括用户定义值的转换、和自定义的缺失值标记列表等。
• 日期解析：包括组合功能，比如将分散在多个列中的日期时间信息组合成结果中的单个列。
• 迭代：支持对大文件进行逐块迭代。
• 不规整数据问题：跳过一些行、页脚、注释或其他一些不重要的东西（比如由成千上万个逗号隔开的数值数据）。

因为工作中实际碰到的数据可能十分混乱，一些数据加载函数（尤其是read_csv）的选项逐渐变得复杂起来。面对不同的参数，感到头痛很正常（read_csv有超过50个参数）。pandas文档有这些参数的例子，如果你感到阅读某个文件很难，可以通过相似的足够多的例子找到正确的参数。

其中一些函数，比如pandas.read_csv，有类型推断功能，因为列数据的类型不属于数据类型。也就是说，你不需要指定列的类型到底是数值、整数、布尔值，还是字符串。其它的数据格式，如HDF5、Feather和msgpack，会在格式中存储数据类型。

9.2读取CSV文本文件

日期和其他自定义类型的处理需要多花点工夫才行。首先我们来看一个以逗号分隔的（CSV）文本文件：

!cat /home/ec2-user/jupyter_Code/data/examples/ex1.csv

a,b,c,d,message

1,2,3,4,hello

5,6,7,8,world

9,10,11,12,foo

笔记：这里，我用的是Unix的cat shell命令将文件的原始内容打印到屏幕上。如果你用的是Windows，你可以展示忽略上一步，也可以使用type达到同样的效果。

由于该文件以逗号分隔，所以我们可以使用read_csv将其读入一个DataFrame：

import pandas as pd

import numpy as np

df = pd.read_csv('/home/ec2-user/jupyter_Code/data/examples/ex1.csv')

df

输出结果:

   a   b   c   d message

0  1   2   3   4   hello

1  5   6   7   8   world

2  9  10  11  12     foo

我们还可以使用read_table，并指定分隔符：

pd.read_table('/home/ec2-user/jupyter_Code/data/examples/ex1.csv', sep=',')

输出结果:

   a   b   c   d message

0  1   2   3   4   hello

1  5   6   7   8   world

2  9  10  11  12     foo

并不是所有文件都有标题行。看看下面这个文件：

读入该文件的办法有两个。你可以让pandas为其分配默认的列名，也可以自己定义列名：

pd.read_csv('/home/ec2-user/jupyter_Code/data/examples/ex2.csv', header=None)

输出结果: 

   0   1   2   3      4

0  1   2   3   4  hello

1  5   6   7   8  world

2  9  10  11  12    foo

pd.read_csv('/home/ec2-user/jupyter_Code/data/examples/ex2.csv', names=['a', 'b', 'c', 'd', 'message'])

输出结果: 

   a   b   c   d message

0  1   2   3   4   hello

1  5   6   7   8   world

2  9  10  11  12     foo

假设你希望将message列做成DataFrame的索引。你可以明确表示要将该列放到索引4的位置上，也可以通过index_col参数指定“message”：

names = ['a', 'b', 'c', 'd', 'message']

pd.read_csv('/home/ec2-user/jupyter_Code/data/examples/ex2.csv', names=names, index_col='message')

输出结果: 

         a   b   c   d

message               

hello    1   2   3   4

world    5   6   7   8

foo      9  10  11  12

如果希望将多个列做成一个层次化索引，只需传入由列编号或列名组成的列表即可：

parsed = pd.read_csv('/home/ec2-user/jupyter_Code/data/examples/csv_mindex.csv', index_col=['key1', 'key2'])

parsed

输出结果:

           value1  value2

key1 key2                

one  a          1       2

     b          3       4

     c          5       6

     d          7       8

two  a          9      10

     b         11      12

     c         13      14

     d         15      16

有些情况下，有些表格可能不是用固定的分隔符去分隔字段的（比如空白符或其它模式）。看看下面这个文本文件：

list(open('/home/ec2-user/jupyter_Code/data/examples/ex3.txt'))

输出结果:

['            A         B         C\n',

 'aaa -0.264438 -1.026059 -0.619500\n',

 'bbb  0.927272  0.302904 -0.032399\n',

 'ccc -0.264273 -0.386314 -0.217601\n',

 'ddd -0.871858 -0.348382  1.100491\n']

虽然可以手动对数据进行规整，这里的字段是被数量不同的空白字符间隔开的。这种情况下，你可以传递一个正则表达式作为read_table的分隔符。可以用正则表达式表达为\s+，于是有：

result = pd.read_table('/home/ec2-user/jupyter_Code/data/examples/ex3.txt', sep='\s+')

result

输出结果:

            A         B         C

aaa -0.264438 -1.026059 -0.619500

bbb  0.927272  0.302904 -0.032399

ccc -0.264273 -0.386314 -0.217601

ddd -0.871858 -0.348382  1.100491

这里，由于列名比数据行的数量少，所以read_table推断第一列应该是DataFrame的索引。

这些解析器函数还有许多参数可以帮助你处理各种各样的异形文件格式（表3-2列出了一些）。比如说，你可以用skiprows跳过文件的第一行、第三行和第四行：

pd.read_csv('/home/ec2-user/jupyter_Code/data/examples/ex4.csv', skiprows=[0, 2, 3])

输出结果：

   a   b   c   d message

0  1   2   3   4   hello

1  5   6   7   8   world

2  9  10  11  12     foo

缺失值处理是文件解析任务中的一个重要组成部分。缺失数据经常是要么没有（空字符串），要么用某个标记值表示。默认情况下，pandas会用一组经常出现的标记值进行识别，比如NA及NULL：

result = pd.read_csv('/home/ec2-user/jupyter_Code/data/examples/ex5.csv')

result

输出结果：

  something  a   b     c   d message

0       one  1   2   3.0   4     NaN

1       two  5   6   NaN   8   world

2     three  9  10  11.0  12     foo

pd.isnull(result)

输出结果： 

   something      a      b      c      d  message

0      False  False  False  False  False     True

1      False  False  False   True  False    False

2      False  False  False  False  False    False

na_values可以用一个列表或集合的字符串表示缺失值：

result = pd.read_csv('/home/ec2-user/jupyter_Code/data/examples/ex5.csv', na_values=['NULL'])

result

输出结果： 

  something  a   b     c   d message

0       one  1   2   3.0   4     NaN

1       two  5   6   NaN   8   world

2     three  9  10  11.0  12     foo

字典的各列可以使用不同的NA标记值：

sentinels = {'message': ['foo', 'NA'], 'something': ['two']}

pd.read_csv('/home/ec2-user/jupyter_Code/data/examples/ex5.csv', na_values=sentinels)

输出结果：

something  a   b     c   d message

0       one  1   2   3.0   4     NaN

1       NaN  5   6   NaN   8   world

2     three  9  10  11.0  12     NaN

图片列出了pandas.read_csv和pandas.read_table常用的选项。

9.3逐块读取文本文件

在处理很大的文件时，或找出大文件中的参数集以便于后续处理时，你可能只想读取文件的一小部分或逐块对文件进行迭代。

在看大文件之前，我们先设置pandas显示地更紧些：

pd.options.display.max_rows = 10

然后有：

result = pd.read_csv('/home/ec2-user/jupyter_Code/data/examples/ex6.csv')

result

输出结果： 

           one       two     three      four key

0     0.467976 -0.038649 -0.295344 -1.824726   L

1    -0.358893  1.404453  0.704965 -0.200638   B

2    -0.501840  0.659254 -0.421691 -0.057688   G

3     0.204886  1.074134  1.388361 -0.982404   R

4     0.354628 -0.133116  0.283763 -0.837063   Q

...        ...       ...       ...       ...  ..

9995  2.311896 -0.417070 -1.409599 -0.515821   L

9996 -0.479893 -0.650419  0.745152 -0.646038   E

9997  0.523331  0.787112  0.486066  1.093156   K

9998 -0.362559  0.598894 -1.843201  0.887292   G

9999 -0.096376 -1.012999 -0.657431 -0.573315   0

[10000 rows x 5 columns]

If you want to only read a small

如果只想读取几行（避免读取整个文件），通过nrows进行指定即可：

pd.read_csv('/home/ec2-user/jupyter_Code/data/examples/ex6.csv', nrows=5)

输出结果：  

        one       two     three      four key

0  0.467976 -0.038649 -0.295344 -1.824726   L

1 -0.358893  1.404453  0.704965 -0.200638   B

2 -0.501840  0.659254 -0.421691 -0.057688   G

3  0.204886  1.074134  1.388361 -0.982404   R

4  0.354628 -0.133116  0.283763 -0.837063   Q

要逐块读取文件，可以指定chunksize（行数）：

chunker=pd.read_csv('/home/ec2-user/jupyter_Code/data/examples/ex6.csv',chunksize=1000)

chunker

输出结果：  

 <pandas.io.parsers.TextParser at 0x8398150>

read_csv所返回的这个TextParser对象使你可以根据chunksize对文件进行逐块迭代。比如说，我们可以迭代处理ex6.csv，将值计数聚合到“key”列中，如下所示：

chunker = pd.read_csv('/home/ec2-user/jupyter_Code/data/examples/ex6.csv', chunksize=1000)

tot = pd.Series([])

for piece in chunker:

    tot = tot.add(piece['key'].value_counts(), fill_value=0)

tot = tot.sort_values(ascending=False)

然后有：

tot[:10]

输出结果:

E    368.0

X    364.0

L    346.0

O    343.0

Q    340.0

M    338.0

J    337.0

F    335.0

K    334.0

H    330.0

dtype: float64

TextParser还有一个get_chunk方法，它使你可以读取任意大小的块。

9.4将数据写出到文本格式

数据也可以被输出为分隔符格式的文本。我们再来看看之前读过的一个CSV文件：

data = pd.read_csv('/home/ec2-user/jupyter_Code/data/examples/ex5.csv')

data

输出结果: 

  something  a   b     c   d message

0       one  1   2   3.0   4     NaN

1       two  5   6   NaN   8   world

2     three  9  10  11.0  12     foo

利用DataFrame的to_csv方法，我们可以将数据写到一个以逗号分隔的文件中：

data.to_csv('/home/ec2-user/jupyter_Code/data/out.csv')

当然，还可以使用其他分隔符（由于这里直接写出到sys.stdout，所以仅仅是打印出文本结果而已）：

import sys

data.to_csv(sys.stdout, sep='|')

输出结果: 

|something|a|b|c|d|message

0|one|1|2|3.0|4|

1|two|5|6||8|world

2|three|9|10|11.0|12|foo

缺失值在输出结果中会被表示为空字符串。你可能希望将其表示为别的标记值：

data.to_csv(sys.stdout, na_rep='NULL')

输出结果: 

,something,a,b,c,d,message

0,one,1,2,3.0,4,NULL

1,two,5,6,NULL,8,world

2,three,9,10,11.0,12,foo

如果没有设置其他选项，则会写出行和列的标签。当然，它们也都可以被禁用：

data.to_csv(sys.stdout, index=False, header=False)

输出结果:

one,1,2,3.0,4,

two,5,6,,8,world

three,9,10,11.0,12,foo

此外，你还可以只写出一部分的列，并以你指定的顺序排列：

data.to_csv(sys.stdout, index=False, columns=['a', 'b', 'c'])

输出结果:

a,b,c

1,2,3.0

5,6,

9,10,11.0

Series也有一个to_csv方法：

dates = pd.date_range('1/1/2000', periods=7)

ts = pd.Series(np.arange(7), index=dates)

ts.to_csv('/home/ec2-user/jupyter_Code/data/tseries.csv')

9.5处理分隔符格式

大部分存储在磁盘上的表格型数据都能用pandas.read_table进行加载。然而，有时还是需要做一些手工处理。由于接收到含有畸形行的文件而使read_table出毛病的情况并不少见。

对于任何单字符分隔符文件，可以直接使用Python内置的csv模块。将任意已打开的文件或文件型的对象传给csv.reader：

import csv

f = open('/home/ec2-user/jupyter_Code/data/examples/ex7.csv')

reader = csv.reader(f)

对这个reader进行迭代将会为每行产生一个元组（并移除了所有的引号）：

for line in reader:

   print(line)

输出结果：

['a', 'b', 'c']

['1', '2', '3']

['1', '2', '3']

现在，为了使数据格式合乎要求，你需要对其做一些整理工作。我们一步一步来做。首先，读取文件到一个多行的列表中：

with open('/home/ec2-user/jupyter_Code/data/examples/ex7.csv') as f:

    lines = list(csv.reader(f))

然后，我们将这些行分为标题行和数据行：

header, values = lines[0], lines[1:]

然后，我们可以用字典构造式和zip(*values)，后者将行转置为列，创建数据列的字典：

data_dict = {h: v for h, v in zip(header, zip(*values))}

data_dict

输出结果:

 {'a': ('1', '1'), 'b': ('2', '2'), 'c': ('3', '3')}

CSV文件的形式有很多。只需定义csv.Dialect的一个子类即可定义出新格式（如专门的分隔符、字符串引用约定、行结束符等）：

f = open('/home/ec2-user/jupyter_Code/data/examples/ex7.csv')

class my_dialect(csv.Dialect):

    lineterminator = '\n'

    delimiter = ';'

    quotechar = '"'

    quoting = csv.QUOTE_MINIMAL

reader = csv.reader(f, dialect=my_dialect)

各个CSV语支的参数也可以用关键字的形式提供给csv.reader，而无需定义子类：

reader = csv.reader(f, delimiter='|')

可用的选项（csv.Dialect的属性）及其功能如下图所示。

笔记：对于那些使用复杂分隔符或多字符分隔符的文件，csv模块就无能为力了。这种情况下，你就只能使用字符串的split方法或正则表达式方法re.split进行行拆分和其他整理工作了。

要手工输出分隔符文件，你可以使用csv.writer。它接受一个已打开且可写的文件对象以及跟csv.reader相同的那些语支和格式化选项：

with open('mydata.csv', 'w') as f:

    writer = csv.writer(f, dialect=my_dialect)

    writer.writerow(('one', 'two', 'three'))

    writer.writerow(('1', '2', '3'))

    writer.writerow(('4', '5', '6'))

    writer.writerow(('7', '8', '9'))

9.6JSON数据

JSON（JavaScript Object Notation的简称）已经成为通过HTTP请求在Web浏览器和其他应用程序之间发送数据的标准格式之一。它是一种比表格型文本格式（如CSV）灵活得多的数据格式。下面是一个例子：

obj = """

{"name": "Wes",

 "places_lived": ["United States", "Spain", "Germany"],

 "pet": null,

 "siblings": [{"name": "Scott", "age": 30, "pets": ["Zeus", "Zuko"]},

              {"name": "Katie", "age": 38,

               "pets": ["Sixes", "Stache", "Cisco"]}]

}

"""

除其空值null和一些其他的细微差别（如列表末尾不允许存在多余的逗号）之外，JSON非常接近于有效的Python代码。基本类型有对象（字典）、数组（列表）、字符串、数值、布尔值以及null。对象中所有的键都必须是字符串。许多Python库都可以读写JSON数据。我将使用json，因为它是构建于Python标准库中的。通过json.loads即可将JSON字符串转换成Python形式：

import json

result = json.loads(obj)

result

输出结果:

{'name': 'Wes',

 'pet': None,

 'places_lived': ['United States', 'Spain', 'Germany'],

 'siblings': [{'age': 30, 'name': 'Scott', 'pets': ['Zeus', 'Zuko']},

  {'age': 38, 'name': 'Katie', 'pets': ['Sixes', 'Stache', 'Cisco']}]}

json.dumps则将Python对象转换成JSON格式：

asjson = json.dumps(result)

如何将（一个或一组）JSON对象转换为DataFrame或其他便于分析的数据结构就由你决定了。最简单方便的方式是：向DataFrame构造器传入一个字典的列表（就是原先的JSON对象），并选取数据字段的子集：

siblings = pd.DataFrame(result['siblings'], columns=['name', 'age'])

siblings

输出结果: 

    name  age

0  Scott   30

1  Katie   38

pandas.read_json可以自动将特别格式的JSON数据集转换为Series或DataFrame。
pandas.read_json的默认选项假设JSON数组中的每个对象是表格中的一行：

data = pd.read_json('/home/ec2-user/jupyter_Code/data/examples/example.json')

data

输出结果:

   a  b  c

0  1  2  3

1  4  5  6

2  7  8  9

如果你需要将数据从pandas输出到JSON，可以使用to_json方法：

print(data.to_json())

输出结果:

{"a":{"0":1,"1":4,"2":7},"b":{"0":2,"1":5,"2":8},"c":{"0":3,"1":6,"2":9}}

print(data.to_json(orient='records'))

输出结果:

[{"a":1,"b":2,"c":3},{"a":4,"b":5,"c":6},{"a":7,"b":8,"c":9}]

9.7二进制数据格式读写

实现数据的高效二进制格式存储最简单的办法之一是使用Python内置的pickle序列化。pandas对象都有一个用于将数据以pickle格式保存到磁盘上的to_pickle方法：

frame = pd.read_csv('/home/ec2-user/jupyter_Code/data/examples/ex1.csv')

frame

输出结果:

   a   b   c   d message

0  1   2   3   4   hello

1  5   6   7   8   world

2  9  10  11  12     foo

frame.to_pickle('/home/ec2-user/jupyter_Code/data/frame_pickle')

你可以通过pickle直接读取被pickle化的数据，或是使用更为方便的pandas.read_pickle：

pd.read_pickle('/home/ec2-user/jupyter_Code/data/frame_pickle')

输出结果: 

   a   b   c   d message

0  1   2   3   4   hello

1  5   6   7   8   world

2  9  10  11  12     foo

注意：pickle仅建议用于短期存储格式。其原因是很难保证该格式永远是稳定的；今天pickle的对象可能无法被后续版本的库unpickle出来。

10.4重命名轴索引

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

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

跟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

10.5离散化和面元划分

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

ages = [20, 22, 25, 27, 21, 23, 37, 31, 61, 45, 41, 32]

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

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]]

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

cats.codes

输出结果:

 array([0, 0, 0, 1, 0, 0, 2, 1, 3, 2, 2, 1], dtype=int8)

cats.categories

输出结果: 

IntervalIndex([(18, 25], (25, 35], (35, 60], (60, 100]]

              closed='right',

              dtype='interval[int64]')

pd.value_counts(cats)

输出结果:

(18, 25]     5

(35, 60]     3

(25, 35]     3

(60, 100]    1

dtype: int64

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

跟“区间”的数学符号一样，圆括号表示开端，而方括号则表示闭端（包括）。哪边是闭端可以通过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, Mid

dleAged, YoungAdult]

Length: 12

Categories (4, object): [Youth < YoungAdult < MiddleAged < Senior]

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

data = np.random.rand(20)

pd.cut(data, 4, precision=2)

输出结果: 

[(0.34, 0.55], (0.34, 0.55], (0.76, 0.97], (0.76, 0.97], (0.34, 0.55], ..., (0.34

, 0.55], (0.34, 0.55], (0.55, 0.76], (0.34, 0.55], (0.12, 0.34]]

Length: 20

Categories (4, interval[float64]): [(0.12, 0.34] < (0.34, 0.55] < (0.55, 0.76] < 

(0.76, 0.97]]

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

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

data = np.random.randn(1000)  # Normally distributed

cats = pd.qcut(data, 4)  # Cut into quartiles

cats

输出结果:

[(-0.0265, 0.62], (0.62, 3.928], (-0.68, -0.0265], (0.62, 3.928], (-0.0265, 0.62]

, ..., (-0.68, -0.0265], (-0.68, -0.0265], (-2.95, -0.68], (0.62, 3.928], (-0.68,

 -0.0265]]

Length: 1000

Categories (4, interval[float64]): [(-2.95, -0.68] < (-0.68, -0.0265] < (-0.0265,

 0.62] <

                                    (0.62, 3.928]]

pd.value_counts(cats)

输出结果:

(0.62, 3.928]       250

(-0.0265, 0.62]     250

(-0.68, -0.0265]    250

(-2.95, -0.68]      250

dtype: int64

与cut类似，你也可以传递自定义的分位数（0到1之间的数值，包含端点）：

pd.qcut(data, [0, 0.1, 0.5, 0.9, 1.])

输出结果:

[(-0.0265, 1.286], (-0.0265, 1.286], (-1.187, -0.0265], (-0.0265, 1.286], (-0.026

5, 1.286], ..., (-1.187, -0.0265], (-1.187, -0.0265], (-2.95, -1.187], (-0.0265, 

1.286], (-1.187, -0.0265]]

Length: 1000

Categories (4, interval[float64]): [(-2.95, -1.187] < (-1.187, -0.0265] < (-0.026

5, 1.286] <

                                    (1.286, 3.928]]

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

10.1移除重复数据

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

import numpy as np

import pandas as pd

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方法，它会返回一个DataFrame，重复的数组会标为False：

data.drop_duplicates()

输出结果:

    k1  k2

0  one   1

1  two   1

2  one   2

3  two   3

4  one   3

5  two   4

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

data['v1'] = range(7)

data.drop_duplicates(['k1'])

输出结果:

    k1  k2  v1

0  one   1   0

1  two   1   1

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

data.drop_duplicates(['k1', 'k2'], keep='last')

输出结果: 

    k1  k2  v1

0  one   1   0

1  two   1   1

2  one   2   2

3  two   3   3

4  one   3   4

6  two   4   6

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

对于许多数据集，你可能希望根据数组、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'

}

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

lowercased = data['food'].str.lower()

lowercased

输出结果: 

0          bacon

1    pulled pork

2          bacon

3       pastrami

4    corned beef

5          bacon

6       pastrami

7      honey ham

8       nova lox

Name: food, dtype: object

data['animal'] = lowercased.map(meat_to_animal)

data

输出结果:  

          food  ounces  animal

0        bacon     4.0     pig

1  pulled pork     3.0     pig

2        bacon    12.0     pig

3     Pastrami     6.0     cow

4  corned beef     7.5     cow

5        Bacon     8.0     pig

6     pastrami     3.0     cow

7    honey ham     5.0     pig

8     nova lox     6.0  salmon

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

data['food'].map(lambda x: meat_to_animal[x.lower()])

输出结果:   

0       pig

1       pig

2       pig

3       cow

4       cow

5       pig

6       cow

7       pig

8    salmon

Name: food, dtype: object

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

10.3替换值

利用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

-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

笔记：data.replace方法与data.str.replace不同，后者做的是字符串的元素级替换。

10.6检测和过滤异常值

过滤或变换异常值（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.049091     0.026112    -0.002544    -0.051827

std       0.996947     1.007458     0.995232     0.998311

min      -3.645860    -3.184377    -3.745356    -3.428254

25%      -0.599807    -0.612162    -0.687373    -0.747478

50%       0.047101    -0.013609    -0.022158    -0.088274

75%       0.756646     0.695298     0.699046     0.623331

max       2.653656     3.525865     2.735527     3.366626

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

col = data[2]

col[np.abs(col) > 3]

输出结果:

41    -3.399312

136   -3.745356

Name: 2, dtype: float64

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

data[(np.abs(data) > 3).any(1)]

输出结果:

            0         1         2         3

41   0.457246 -0.025907 -3.399312 -0.974657

60   1.951312  3.260383  0.963301  1.201206

136  0.508391 -0.196713 -3.745356 -1.520113

235 -0.242459 -3.056990  1.918403 -0.578828

258  0.682841  0.326045  0.425384 -3.428254

322  1.179227 -3.184377  1.369891 -1.074833

544 -3.548824  1.553205 -2.186301  1.277104

635 -0.578093  0.193299  1.397822  3.366626

782 -0.207434  3.525865  0.283070  0.544635

803 -3.645860  0.255475 -0.549574 -1.907459

根据这些条件，就可以对值进行设置。下面的代码可以将值限制在区间－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.050286     0.025567    -0.001399    -0.051765

std       0.992920     1.004214     0.991414     0.995761

min      -3.000000    -3.000000    -3.000000    -3.000000

25%      -0.599807    -0.612162    -0.687373    -0.747478

50%       0.047101    -0.013609    -0.022158    -0.088274

75%       0.756646     0.695298     0.699046     0.623331

max       2.653656     3.000000     2.735527     3.000000

根据数据的值是正还是负，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

10.7排列和随机采样

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

df = pd.DataFrame(np.arange(5 * 4).reshape((5, 4)))

sampler = np.random.permutation(5)

sampler

输出结果:

 array([3, 1, 4, 2, 0])

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

df

输出结果:

    0   1   2   3

0   0   1   2   3

1   4   5   6   7

2   8   9  10  11

3  12  13  14  15

4  16  17  18  19

df.take(sampler)

输出结果:

    0   1   2   3

3  12  13  14  15

1   4   5   6   7

4  16  17  18  19

2   8   9  10  11

0   0   1   2   3

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

df.sample(n=3)

输出结果:

    0   1   2   3

3  12  13  14  15

4  16  17  18  19

2   8   9  10  11

要通过替换的方式产生样本（允许重复选择），可以传递replace=True到sample：

choices = pd.Series([5, 7, -1, 6, 4])

draws = choices.sample(n=10, replace=True)

draws

输出结果:

4    4

1    7

4    4

2   -1

0    5

3    6

1    7

4    4

0    5

4    4

dtype: int64

10.8计算指标/哑变量

另一种常用于统计建模或机器学习的转换方式是：将分类变量（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中的某行同属于多个分类，则事情就会有点复杂。

mnames = ['movie_id', 'title', 'genres']

movies = pd.read_table('/home/ec2-user/jupyter_Code/data/movielens/movies.dat', sep='::', header=None, names=mnames)

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

输出结果: 

array(['Animation', "Children's", 'Comedy', 'Adventure', 'Fantasy',

       'Romance', 'Drama', 'Action', 'Crime', 'Thriller','Horror',

       'Sci-Fi', 'Documentary', 'War', 'Musical', 'Mystery', 'Film-Noir',

       'Western'], dtype=object)

构建指标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('|')

输出结果:

 ['Animation', "Children's", 'Comedy']

dummies.columns.get_indexer(gen.split('|'))

输出结果:

 array([0, 1, 2])

然后，根据索引，使用.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

Genre_Children's                               1

Genre_Comedy                                   1

Genre_Adventure                                0

Genre_Fantasy                                  0

Genre_Romance                                  0

Genre_Drama                                    0

                                ...             

Genre_Crime                                    0

Genre_Thriller                                 0

Genre_Horror                                   0

Genre_Sci-Fi                                   0

Genre_Documentary                              0

Genre_War                                      0

Genre_Musical                                  0

Genre_Mystery                                  0

Genre_Film-Noir                                0

Genre_Western                                  0

Name: 0, Length: 21, dtype: object

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

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

np.random.seed(12345)

values = np.random.rand(10)

values

输出结果:

array([ 0.9296,  0.3164,  0.1839,  0.2046,  0.5677,  0.5955,  0.9645,

        0.6532,  0.7489,  0.6536])

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，使这个例子具有确定性。