之前自己对于numpy和pandas是要用的时候东学一点西一点，直到看到《利用Python进行数据分析·第2版》，觉得只看这一篇就够了。非常感谢原博主的翻译和分享。
访问数据是使用本书所介绍的这些工具的第一步。我会着重介绍pandas的数据输入与输出，虽然别的库中也有不少以此为目的的工具。
输入输出通常可以划分为几个大类：读取文本文件和其他更高效的磁盘存储格式，加载数据库中的数据，利用Web API操作网络资源。
6.1 读写文本格式的数据
pandas提供了一些用于将表格型数据读取为DataFrame对象的函数。表6-1对它们进行了总结，其中read_csv和read_table可能会是你今后用得最多的。
| 函数 | 说明 |
|---|---|
| read_csv | 文件、URL、文件型对象中加载带分隔符的数据。默认分隔符为逗号 |
| read_table | 从文件、URL、文件型对象中加载带分隔符的数据。默认分隔符为制表符(‘t’) |
| read_fwf | 读取定宽列格式数据(也就是说,没有分隔符) |
| read_clipboard | 读取剪贴板中的数据,可以看做 read_table的剪贴板版。在将网页转换为表格时很有用 |
| read_excel | 从 Excel XLS或 XLSX file读取表格数据 |
| read_hdf | 读取 pandas写的HDF5文件 |
| read_html | 读取HTML文档中的所有表格 |
| read_json | 读取JSON( JavaScript Object Notation序字符串中的数据 |
| read_msgpack | 读取二进制格式编码的 pandas数据 |
| read_pickle | 读取 Python pickle格式中存储的任意对象 |
| read_sas | 读取存储于SAS系统自定义存储格式的SAS数据集 |
| read_sql | (使用SQLAlchemy)读取SQL查询结果为 pandas的 DataFrame |
| read_stata | 读取 Stata文件格式的数据集 |
| read_feather | 读取 Feather二进制文件格式 |
我将大致介绍一下这些函数在将文本数据转换为DataFrame时所用到的一些技术。这些函数的选项可以划分为以下几个大类：
- 索引：将一个或多个列当做返回的DataFrame处理，以及是否从文件、用户获取列名。
- 类型推断和数据转换：包括用户定义值的转换、和自定义的缺失值标记列表等。
- 日期解析：包括组合功能，比如将分散在多个列中的日期时间信息组合成结果中的单个列。
- 迭代：支持对大文件进行逐块迭代。
- 不规整数据问题：跳过一些行、页脚、注释或其他一些不重要的东西（比如由成千上万个逗号隔开的数值数据）。
因为工作中实际碰到的数据可能十分混乱，一些数据加载函数（尤其是read_csv）的选项逐渐变得复杂起来。面对不同的参数，感到头痛很正常（read_csv有超过50个参数）。pandas文档有这些参数的例子，如果你感到阅读某个文件很难，可以通过相似的足够多的例子找到正确的参数。
其中一些函数，比如pandas.read_csv，有类型推断功能，因为列数据的类型不属于数据类型。也就是说，你不需要指定列的类型到底是数值、整数、布尔值，还是字符串。其它的数据格式，如HDF5、Feather和msgpack，会在格式中存储数据类型。
日期和其他自定义类型的处理需要多花点工夫才行。首先我们来看一个以逗号分隔的（CSV）文本文件：
In [8]: !cat 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('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('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 |
并不是所有文件都有标题行。看看下面这个文件：
In [12]: !cat examples/ex2.csv
1,2,3,4,hello
5,6,7,8,world
9,10,11,12,foo
读入该文件的办法有两个。你可以让pandas为其分配默认的列名，也可以自己定义列名：
pd.read_csv('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('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('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 |
如果希望将多个列做成一个层次化索引，只需传入由列编号或列名组成的列表即可：
!cat examples/csv_mindex.csv
key1,key2,value1,value2
one,a,1,2
one,b,3,4
one,c,5,6
one,d,7,8
two,a,9,10
two,b,11,12
two,c,13,14
two,d,15,16
parsed=pd.read_csv('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('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']
虽然可以手动对数据进行规整，这里的字段是被数量不同的空白字符间隔开的。这种情况下，你可以传递一个正则表达式作为read_table的分隔符。可以用正则表达式表达为\s+，于是有：
result=pd.read_table('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的索引。
这些解析器函数还有许多参数可以帮助你处理各种各样的异形文件格式（表6-2列出了一些）。比如说，你可以用skiprows跳过文件的第一行、第三行和第四行：
!cat examples/ex4.csv
# hey!
a,b,c,d,message
# just wanted to make things more difficult for you
# who reads CSV files with computers, anyway?
1,2,3,4,hello
5,6,7,8,world
9,10,11,12,foo
pd.read_csv('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：
!cat examples/ex5.csv
something,a,b,c,d,message
one,1,2,3,4,NA
two,5,6,,8,world
three,9,10,11,12,foo
result=pd.read_csv('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’
na_values可以用一个列表或集合的字符串表示缺失值：
result=pd.read_csv('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('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 |
表6-2列出了pandas.read_csv和pandas.read_table常用的选项。
| 参数 | 说明 |
|---|---|
| path | 表示文件系统位置、URL、文件型对象的字符串 |
| sep或 delimiter用于对行中各字段进行拆分的字符序列或正则表达式 | |
| header | 用作列名的行号。默认为0(第一行),如果没有 header行就应该设置为None |
| index_col | 用作行索引的列编号或列名。可以是单个名称/数字或由多个名称/数字组成的列表(层次化索引) |
| names | 用于结果的列名列表,结合 header=None |
| skiprows | 需要忽略的行数(从文件开始处算起),或需要跳过的行号列表(从0开始) |
| na_values | 一组用于替换NA的值 |
| comment | 用于将注释信息从行尾拆分出去的字符(一个或多个) |
| parse_dates | 尝试将数据解析为日期,默认为Fa |
| keep_date_col | 如果连接多列解析日期,则保持参与连接的列。默认为 False |
| converters | 由列号/列名跟函数之间的映射关系组成的字典。例如,{foo’:f}会对foo列的所有值应用函数f |
| dayfirst | 当解析有歧义的日期时,将其看做国际格式(例如,7/6/2012→June 7,2012)。默认为Fase |
| date_parser | 用于解析日期的函数 |
| nrows | 需要读取的行数(从文件开始处算起) |
| iterator | 返回一个 TextParser以便逐块读取文件 |
| chunksize | 文件块的大小(用于迭代) |
| skip_footer | 需要忽略的行数(从文件末尾处算起) |
| verbose | 打印各种解析器输出信息,比如“非数值列中缺失值的数量”等 |
| encoding | 用于 unicode的文本编码格式。例如,“utf-8”表示用UTF-8编码的文本 |
| squeeze | 如果数据经解析后仅含一列,则返回Series |
| thousands | 千分位分隔符,如“,”或“.” |
逐块读取文本文件
在处理很大的文件时，或找出大文件中的参数集以便于后续处理时，你可能只想读取文件的一小部分或逐块对文件进行迭代。
首先使用office打不开；然后在python中使用基本的pandas.read_csv打开文件时：MemoryError；就可以考虑逐块读取。例如数据集是个csv文件，大小为3.7G，并且对于数据一无所知，所以首先打开前5行观察数据的类型，列标签等等.
还可以考虑Python多进程分块读取超大文件。
在看大文件之前，我们先设置pandas显示地更紧些：
pd.options.display.max_rows = 10
result=pd.read_csv('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 × 5 columns
如果只想读取几行（避免读取整个文件），通过nrows进行指定即可：
pd.read_csv('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('examples/ex6.csv',chunksize=1000)#意思是1000行为一块逐块读取
chunker
<pandas.io.parsers.TextFileReader at 0x1ec1f23e208>
read_csv所返回的这个TextParser对象使你可以根据chunksize对文件进行逐块迭代（这个时候并没有真正把数据读到chunker变量中）。比如说，我们可以迭代处理ex6.csv，将值计数聚合到"key"列中，如下所示：
chunker = pd.read_csv('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
E 368.0
X 364.0
L 346.0
O 343.0
Q 340.0
...
5 157.0
2 152.0
0 151.0
9 150.0
1 146.0
Length: 36, dtype: float64
TextParser还有一个get_chunk方法，它使你可以读取任意大小的块。
将数据写出到文本格式
数据也可以被输出为分隔符格式的文本。我们再来看看之前读过的一个CSV文件：
data = pd.read_csv('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('examples/out.csv')
!cat examples/out.csv
,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
当然，还可以使用其他分隔符（由于这里直接写出到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(sys.stdout)
2000-01-01,0
2000-01-02,1
2000-01-03,2
2000-01-04,3
2000-01-05,4
2000-01-06,5
2000-01-07,6
处理分隔符格式
大部分存储在磁盘上的表格型数据都能用pandas.read_table进行加载。然而，有时还是需要做一些手工处理。由于接收到含有畸形行的文件而使read_table出毛病的情况并不少见。为了说明这些基本工具，看看下面这个简单的CSV文件：
!cat examples/ex7.csv
"a","b","c"
"1","2","3"
"1","2","3"
import csv
f=open('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('examples/ex7.csv') as f:
lines=list(csv.reader(f))
然后，我们将这些行分为标题行和数据行：
header, values = lines[0], lines[1:]
list(zip(header,zip(*values)))
[('a', ('1', '1')), ('b', ('2', '2')), ('c', ('3', '3'))]
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的一个子类即可定义出新格式（如专门的分隔符、字符串引用约定、行结束符等）：
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的属性）及其功能如表6-3所示。
| 参数 | 说明 |
|---|---|
| delimiter | 用于分隔字段的单字符字符串。默认为“,” |
| lineterminator | 用于写操作的行结束符,默认为“\r\n”。读操作将忽略此选项,它能认出跨平台的行结束符 |
| quotechar | 用于带有特殊字符(如分隔符)的字段的引用符号。默认为“"” |
| quoting | 引用约定。可选值包括csv. QUOTE_ALL(引用所有字段)、csv.QUOTE_MINMAL(只引用带有诸如分隔符之类特殊字符的字段)、csv.QUOTE_NONNUMERIC以及 CSV.QUOTE_NON(不引用)。完整信息请参考 Python的文档。默认为 QUOTE_MINIMAL |
| skipinitialspace | 忽略分隔符后面的空白符。默认为 False |
| doublequote | 如何处理字段内的引用符号。如果为True,则双写。完整信息及行为请参见在线文档 |
| escapechar | 用于对分隔符进行转义的字符串(如果 quoting被设置为 CSV.QUOTE_NONE的话)。默认禁用 |
笔记：对于那些使用复杂分隔符或多字符分隔符的文件，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'))
JSON数据
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格式：#json格式的字符串？
asjson =json.dumps(result)
asjson
'{"pet": null, "places_lived": ["United States", "Spain", "Germany"], "name": "Wes", "siblings": [{"name": "Scott", "age": 30, "pets": ["Zeus", "Zuko"]}, {"name": "Katie", "age": 38, "pets": ["Sixes", "Stache", "Cisco"]}]}'
如何将（一个或一组）JSON对象转换为DataFrame或其他便于分析的数据结构就由你决定了。最简单方便的方式是：向DataFrame构造器传入一个字典的列表（就是原先的JSON对象），并选取数据字段的子集：
siblings = pd.DataFrame(result['siblings'],columns=['age','name'])
siblings
| age | name | |
|---|---|---|
| 0 | 30 | Scott |
| 1 | 38 | Katie |
pandas.read_json可以自动将特别格式的JSON数据集转换为Series或DataFrame。例如：
!cat examples/example.json
[{"a": 1, "b": 2, "c": 3},
{"a": 4, "b": 5, "c": 6},
{"a": 7, "b": 8, "c": 9}]
pandas.read_json的默认选项假设JSON数组中的每个对象是表格中的一行：
data=pd.read_json('examples/example.json')
data
| a | b | c | |
|---|---|---|---|
| 0 | 1 | 2 | 3 |
| 1 | 4 | 5 | 6 |
| 2 | 7 | 8 | 9 |
第7章中关于USDA Food Database的那个例子进一步讲解了JSON数据的读取和处理（包括嵌套记录）。
如果你需要将数据从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}]
XML和HTML：Web信息收集
Python有许多可以读写常见的HTML和XML格式数据的库，包括lxml、Beautiful Soup和html5lib。lxml的速度比较快，但其它的库处理有误的HTML或XML文件更好。
pandas有一个内置的功能，read_html，它可以使用lxml和Beautiful Soup自动将HTML文件中的表格解析为DataFrame对象。为了进行展示，我从美国联邦存款保险公司下载了一个HTML文件（pandas文档中也使用过），它记录了银行倒闭的情况。首先，你需要安装read_html用到的库：
conda install lxml
pip install beautifulsoup4 html5lib
如果你用的不是conda，可以使用pip install lxml。
pandas.read_html有一些选项，默认条件下，它会搜索、尝试解析
标签内的的表格数据。结果是一个列表的DataFrame对象：tables = pd.read_html('examples/fdic_failed_bank_list.html')
len(tables)
1
failures = tables[0]
failures
| Bank Name | City | ST | CERT | Acquiring Institution | Closing Date | Updated Date | |
|---|---|---|---|---|---|---|---|
| 0 | Allied Bank | Mulberry | AR | 91 | Today's Bank | September 23, 2016 | November 17, 2016 |
| 1 | The Woodbury Banking Company | Woodbury | GA | 11297 | United Bank | August 19, 2016 | November 17, 2016 |
| 2 | First CornerStone Bank | King of Prussia | PA | 35312 | First-Citizens Bank & Trust Company | May 6, 2016 | September 6, 2016 |
| 3 | Trust Company Bank | Memphis | TN | 9956 | The Bank of Fayette County | April 29, 2016 | September 6, 2016 |
| 4 | North Milwaukee State Bank | Milwaukee | WI | 20364 | First-Citizens Bank & Trust Company | March 11, 2016 | June 16, 2016 |
| ... | ... | ... | ... | ... | ... | ... | ... |
| 542 | Superior Bank, FSB | Hinsdale | IL | 32646 | Superior Federal, FSB | July 27, 2001 | August 19, 2014 |
| 543 | Malta National Bank | Malta | OH | 6629 | North Valley Bank | May 3, 2001 | November 18, 2002 |
| 544 | First Alliance Bank & Trust Co. | Manchester | NH | 34264 | Southern New Hampshire Bank & Trust | February 2, 2001 | February 18, 2003 |
| 545 | National State Bank of Metropolis | Metropolis | IL | 3815 | Banterra Bank of Marion | December 14, 2000 | March 17, 2005 |
| 546 | Bank of Honolulu | Honolulu | HI | 21029 | Bank of the Orient | October 13, 2000 | March 17, 2005 |
547 rows × 7 columns
这里，我们可以做一些数据清洗和分析（后面章节会进一步讲解），比如计算按年份计算倒闭的银行数：
close_timestamps = pd.to_datetime(failures['Closing Date'])
close_timestamps
0 2016-09-23
1 2016-08-19
2 2016-05-06
3 2016-04-29
4 2016-03-11
...
542 2001-07-27
543 2001-05-03
544 2001-02-02
545 2000-12-14
546 2000-10-13
Name: Closing Date, Length: 547, dtype: datetime64[ns]
close_timestamps.dt.year.value_counts()
2010 157
2009 140
2011 92
2012 51
2008 25
...
2004 4
2001 4
2007 3
2003 3
2000 2
Name: Closing Date, Length: 15, dtype: int64
利用lxml.objectify解析XML
XML（Extensible Markup Language）是另一种常见的支持分层、嵌套数据以及元数据的结构化数据格式。本书所使用的这些文件实际上来自于一个很大的XML文档。
前面，我介绍了pandas.read_html函数，它可以使用lxml或Beautiful Soup从HTML解析数据。XML和HTML的结构很相似，但XML更为通用。这里，我会用一个例子演示如何利用lxml从XML格式解析数据。
纽约大都会运输署发布了一些有关其公交和列车服务的数据资料（http://www.mta.info/developers/download.html）。这里，我们将看看包含在一组XML文件中的运行情况数据。每项列车或公交服务都有各自的文件（如Metro-North Railroad的文件是Performance_MNR.xml），其中每条XML记录就是一条月度数据，如下所示：
373889 Metro-North Railroad Escalator Availability Percent of the time that escalators are operational systemwide. The availability rate is based on physical observations performed the morning of regular business days only. This is a new indicator the agency began reporting in 2009. 2011 12 Service Indicators M U % 1 97.00 97.00我们先用lxml.objectify解析该文件，然后通过getroot得到该XML文件的根节点的引用：
from lxml import objectify
path = 'datasets/mta_perf/Performance_MNR.xml'
parsed=objectify.parse(open(path))
parsed
<lxml.etree._ElementTree at 0x1ec0eb3df08>
root = parsed.getroot()
root
<Element PERFORMANCE at 0x1ec0eb3df48>
root.INDICATOR返回一个用于产生各个XML元素的生成器。对于每条记录，我们可以用标记名（如YTD_ACTUAL）和数据值填充一个字典（排除几个标记）：
data = []
skip_fields = ['PARENT_SEQ', 'INDICATOR_SEQ',
'DESIRED_CHANGE', 'DECIMAL_PLACES']
for elt in root.INDICATOR:
elt_data = {}
for child in elt.getchildren():
if child.tag in skip_fields:
continue
elt_data[child.tag]=child.pyval
data.append(elt_data)
最后，将这组字典转换为一个DataFrame：
pref=pd.DataFrame(data)
pref.head()
| AGENCY_NAME | CATEGORY | DESCRIPTION | FREQUENCY | INDICATOR_NAME | INDICATOR_UNIT | MONTHLY_ACTUAL | MONTHLY_TARGET | PERIOD_MONTH | PERIOD_YEAR | YTD_ACTUAL | YTD_TARGET | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | Metro-North Railroad | Service Indicators | Percent of commuter trains that arrive at thei... | M | On-Time Performance (West of Hudson) | % | 96.9 | 95 | 1 | 2008 | 96.9 | 95 |
| 1 | Metro-North Railroad | Service Indicators | Percent of commuter trains that arrive at thei... | M | On-Time Performance (West of Hudson) | % | 95 | 95 | 2 | 2008 | 96 | 95 |
| 2 | Metro-North Railroad | Service Indicators | Percent of commuter trains that arrive at thei... | M | On-Time Performance (West of Hudson) | % | 96.9 | 95 | 3 | 2008 | 96.3 | 95 |
| 3 | Metro-North Railroad | Service Indicators | Percent of commuter trains that arrive at thei... | M | On-Time Performance (West of Hudson) | % | 98.3 | 95 | 4 | 2008 | 96.8 | 95 |
| 4 | Metro-North Railroad | Service Indicators | Percent of commuter trains that arrive at thei... | M | On-Time Performance (West of Hudson) | % | 95.8 | 95 | 5 | 2008 | 96.6 | 95 |
XML数据可以比本例复杂得多。每个标记都可以有元数据。看看下面这个HTML的链接标签（它也算是一段有效的XML）：
from io import StringIO
tag = '<a href="http://www.google.com">Google</a>'
root=objectify.parse(StringIO(tag)).getroot()
root
<Element a at 0x1ec0eb2b748>
现在就可以访问标签或链接文本中的任何字段了（如href）：
root.get('href')
'http://www.google.com'
root.text
'Google'
root.tag
'a'
6.2 二进制数据格式
实现数据的高效二进制格式存储最简单的办法之一是使用Python内置的pickle序列化。pandas对象都有一个用于将数据以pickle格式保存到磁盘上的to_pickle方法：
frame = pd.read_csv('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('examples/frame_pickle')
你可以通过pickle直接读取被pickle化的数据，或是使用更为方便的pandas.read_pickle：
pd.read_pickle('examples/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出来。虽然我尽力保证这种事情不会发生在pandas中，但是今后的某个时候说不定还是得“打破”该pickle格式。
pandas内置支持两个二进制数据格式：HDF5和MessagePack。下一节，我会给出几个HDF5的例子，但我建议你尝试下不同的文件格式，看看它们的速度以及是否适合你的分析工作。pandas或NumPy数据的其它存储格式有：
- bcolz：一种可压缩的列存储二进制格式，基于Blosc压缩库。
- Feather：我与R语言社区的Hadley Wickham设计的一种跨语言的列存储文件格式。Feather使用了Apache Arrow的列式内存格式。
使用HDF5格式
HDF5是一种存储大规模科学数组数据的非常好的文件格式。它可以被作为C标准库，带有许多语言的接口，如Java、Python和MATLAB等。HDF5中的HDF指的是层次型数据格式（hierarchical data format）。每个HDF5文件都含有一个文件系统式的节点结构，它使你能够存储多个数据集并支持元数据。与其他简单格式相比，HDF5支持多种压缩器的即时压缩，还能更高效地存储重复模式数据。对于那些非常大的无法直接放入内存的数据集，HDF5就是不错的选择，因为它可以高效地分块读写。
虽然可以用PyTables或h5py库直接访问HDF5文件，pandas提供了更为高级的接口，可以简化存储Series和DataFrame对象。HDFStore类可以像字典一样，处理低级的细节：
frame = pd.DataFrame({'a': np.random.randn(100)})
frame
| a | |
|---|---|
| 0 | 0.635702 |
| 1 | 0.724577 |
| 2 | -1.047759 |
| 3 | 0.244790 |
| 4 | -1.602862 |
| ... | ... |
| 95 | -0.995903 |
| 96 | 0.087939 |
| 97 | 0.112337 |
| 98 | -0.344824 |
| 99 | 0.441054 |
100 rows × 1 columns
store = pd.HDFStore('mydata.h5')
store
<class 'pandas.io.pytables.HDFStore'>
File path: mydata.h5
store['obj1'] = frame
store
<class 'pandas.io.pytables.HDFStore'>
File path: mydata.h5
store['obj1_col'] = frame['a']
store
<class 'pandas.io.pytables.HDFStore'>
File path: mydata.h5
HDF5文件中的对象可以通过与字典一样的API进行获取：
store['obj1']
| a | |
|---|---|
| 0 | 0.635702 |
| 1 | 0.724577 |
| 2 | -1.047759 |
| 3 | 0.244790 |
| 4 | -1.602862 |
| ... | ... |
| 95 | -0.995903 |
| 96 | 0.087939 |
| 97 | 0.112337 |
| 98 | -0.344824 |
| 99 | 0.441054 |
100 rows × 1 columns
HDFStore支持两种存储模式，‘fixed’和’table’。后者通常会更慢，但是支持使用特殊语法进行查询操作：
store.put('obj2', frame, format='table')
store.select('obj2', where=['index >= 10 and index <= 15'])
| a | |
|---|---|
| 10 | -1.888999 |
| 11 | -0.345070 |
| 12 | 0.927707 |
| 13 | -0.098613 |
| 14 | 1.742578 |
| 15 | 0.941341 |
store.close()
put是store[‘obj2’] = frame方法的显示版本，允许我们设置其它的选项，比如格式。
pandas.read_hdf函数可以快捷使用这些工具：
frame.to_hdf('mydata.h5','obj3',format='table')
pd.read_hdf('mydata.h5','obj3',where=['index<5'])#运行出错了
笔记：如果你要处理的数据位于远程服务器，比如Amazon S3或HDFS，使用专门为分布式存储（比如Apache Parquet）的二进制格式也许更加合适。Python的Parquet和其它存储格式还在不断的发展之中，所以这本书中没有涉及。
如果需要本地处理海量数据，我建议你好好研究一下PyTables和h5py，看看它们能满足你的哪些需求。。由于许多数据分析问题都是IO密集型（而不是CPU密集型），利用HDF5这样的工具能显著提升应用程序的效率。
注意：HDF5不是数据库。它最适合用作“一次写多次读”的数据集。虽然数据可以在任何时候被添加到文件中，但如果同时发生多个写操作，文件就可能会被破坏。
读取Microsoft Excel文件
pandas的ExcelFile类或pandas.read_excel函数支持读取存储在Excel 2003（或更高版本）中的表格型数据。这两个工具分别使用扩展包xlrd和openpyxl读取XLS和XLSX文件。你可以用pip或conda安装它们。
要使用ExcelFile，通过传递xls或xlsx路径创建一个实例：
xlsx=pd.ExcelFile('examples/ex1.xlsx')
xlsx
<pandas.io.excel.ExcelFile at 0x1ec20d98780>
存储在表单中的数据可以read_excel读取到DataFrame（原书这里写的是用parse解析，但代码中用的是read_excel，是个笔误：只换了代码，没有改文字
pd.read_excel(xlsx,'Sheet1')
| a | b | c | d | message | |
|---|---|---|---|---|---|
| 0 | 1 | 2 | 3 | 4 | hello |
| 1 | 5 | 6 | 7 | 8 | world |
| 2 | 9 | 10 | 11 | 12 | foo |
如果要读取一个文件中的多个表单，创建ExcelFile会更快，但你也可以将文件名传递到pandas.read_excel：
frame= pd.read_excel('examples/ex1.xlsx','Sheet1')
frame
| a | b | c | d | message | |
|---|---|---|---|---|---|
| 0 | 1 | 2 | 3 | 4 | hello |
| 1 | 5 | 6 | 7 | 8 | world |
| 2 | 9 | 10 | 11 | 12 | foo |
如果要将pandas数据写入为Excel格式，你必须首先创建一个ExcelWriter，然后使用pandas对象的to_excel方法将数据写入到其中：
writer=pd.ExcelWriter('examples/ex2.xlsx')
frame.to_excel(writer,'Sheet1')
writer.save()
你还可以不使用ExcelWriter，而是传递文件的路径到to_excel：
frame.to_excel('examples/ex2.xlsx')
6.3 Web APIs交互
许多网站都有一些通过JSON或其他格式提供数据的公共API。通过Python访问这些API的办法有不少。一个简单易用的办法（推荐）是requests包（http://docs.python-requests.org）。
为了搜索最新的30个GitHub上的pandas主题，我们可以发一个HTTP GET请求，使用requests扩展库：
import requests
url = 'https://api.github.com/repos/pandas-dev/pandas/issues'
resp = requests.get(url)
resp
<Response [200]>
响应对象的json方法会返回一个包含被解析过的JSON字典，加载到一个Python对象中：
data = resp.json()
data[0]['title']
'Option to change pandas.Timestamp format when printing dataframe'
data中的每个元素都是一个包含所有GitHub主题页数据（不包含评论）的字典。我们可以直接传递数据到DataFrame，并提取感兴趣的字段：
issues=pd.DataFrame(data,columns=['number', 'title','labels', 'state'])
issues
| number | title | labels | state | |
|---|---|---|---|---|
| 0 | 23220 | Option to change pandas.Timestamp format when ... | [] | open |
| 1 | 23219 | Unable to merge pandas dataframe with categori... | [] | open |
| 2 | 23218 | de-duplicate generate_range | [] | open |
| 3 | 23217 | TST: Fix improperly defined tests in test_inte... | [{'name': 'Interval', 'id': 150096370, 'color'... | open |
| 4 | 23216 | API: Which DatetimeIndex/TimedeltaIndex ops sh... | [] | open |
| ... | ... | ... | ... | ... |
| 25 | 23194 | [WIP] Validate PEP-8 in docstrings | [] | open |
| 26 | 23192 | API: Unify .update to generic | [{'name': 'Clean', 'id': 211029535, 'color': '... | open |
| 27 | 23191 | Bitwise operations have inconsistent behavior,... | [] | open |
| 28 | 23187 | BUG: sets in str.cat | [] | open |
| 29 | 23186 | BUG: SparseArray.unique with all sparse | [{'name': 'Sparse', 'id': 49182326, 'color': '... | open |
30 rows × 4 columns
花费一些精力，你就可以创建一些更高级的常见的Web API的接口，返回DataFrame对象，方便进行分析。
6.4 数据库交互
在商业场景下，大多数数据可能不是存储在文本或Excel文件中。基于SQL的关系型数据库（如SQL Server、PostgreSQL和MySQL等）使用非常广泛，其它一些数据库也很流行。数据库的选择通常取决于性能、数据完整性以及应用程序的伸缩性需求。
将数据从SQL加载到DataFrame的过程很简单，此外pandas还有一些能够简化该过程的函数。例如，我将使用SQLite数据库（通过Python内置的sqlite3驱动器）：下面的程序很多没运行过。
import sqlite3
query = """
.....: CREATE TABLE test
.....: (a VARCHAR(20), b VARCHAR(20),
.....: c REAL, d INTEGER
.....: );"""
con = sqlite3.connect('mydata.sqlite')
con.execute(query)
#<sqlite3.Cursor at 0x7f6b12a50f10>
con.commit()
然后插入几行数据：
data = [('Atlanta', 'Georgia', 1.25, 6),
.....: ('Tallahassee', 'Florida', 2.6, 3),
.....: ('Sacramento', 'California', 1.7, 5)]
stmt = "INSERT INTO test VALUES(?, ?, ?, ?)"
con.executemany(stmt, data)
# <sqlite3.Cursor at 0x7f6b15c66ce0>
从表中选取数据时，大部分Python SQL驱动器（PyODBC、psycopg2、MySQLdb、pymssql等）都会返回一个元组列表：
cursor = con.execute('select * from test')
rows = cursor.fetchall()
rows
Out[132]:
[('Atlanta', 'Georgia', 1.25, 6),
('Tallahassee', 'Florida', 2.6, 3),
('Sacramento', 'California', 1.7, 5)]
你可以将这个元组列表传给DataFrame构造器，但还需要列名（位于光标的description属性中）：
cursor.description
Out[133]:
(('a', None, None, None, None, None, None),
('b', None, None, None, None, None, None),
('c', None, None, None, None, None, None),
('d', None, None, None, None, None, None))
pd.DataFrame(rows, columns=[x[0] for x in cursor.description])
Out[134]:
a b c d
0 Atlanta Georgia 1.25 6
1 Tallahassee Florida 2.60 3
2 Sacramento California 1.70 5
这种数据规整操作相当多，你肯定不想每查一次数据库就重写一次。SQLAlchemy项目是一个流行的Python SQL工具，它抽象出了SQL数据库中的许多常见差异。pandas有一个read_sql函数，可以让你轻松的从SQLAlchemy连接读取数据。这里，我们用SQLAlchemy连接SQLite数据库，并从之前创建的表读取数据：
import sqlalchemy as sqla
db = sqla.create_engine('sqlite:///mydata.sqlite')
pd.read_sql('select * from test', db)
Out[137]:
a b c d
0 Atlanta Georgia 1.25 6
1 Tallahassee Florida 2.60 3
2 Sacramento California 1.70 5
6.5 总结
访问数据通常是数据分析的第一步。在本章中，我们已经学了一些有用的工具。在接下来的章节中，我们将深入研究数据规整、数据可视化、时间序列分析和其它主题。