• 6.1 读写文本格式的数据
    • 逐块读取文本文件
    • 将数据写出到文本格式
    • 处理分隔符格式
    • JSON数据
    • XML和HTML:Web信息收集
    • 利用lxml.objectify解析XML

    6.1 读写文本格式的数据

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

    表6-1 pandas中的解析函数

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

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

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

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

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

    1. In [8]: !cat examples/ex1.csv
    2. a,b,c,d,message
    3. 1,2,3,4,hello
    4. 5,6,7,8,world
    5. 9,10,11,12,foo

    笔记:这里,我用的是Unix的cat shell命令将文件的原始内容打印到屏幕上。如果你用的是Windows,你可以使用type达到同样的效果。

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

    1. In [9]: df = pd.read_csv('examples/ex1.csv')
    2. In [10]: df
    3. Out[10]:
    4. a b c d message
    5. 0 1 2 3 4 hello
    6. 1 5 6 7 8 world
    7. 2 9 10 11 12 foo

    我们还可以使用read_table,并指定分隔符:

    1. In [11]: pd.read_table('examples/ex1.csv', sep=',')
    2. Out[11]:
    3. a b c d message
    4. 0 1 2 3 4 hello
    5. 1 5 6 7 8 world
    6. 2 9 10 11 12 foo

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

    1. In [12]: !cat examples/ex2.csv
    2. 1,2,3,4,hello
    3. 5,6,7,8,world
    4. 9,10,11,12,foo

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

    1. In [13]: pd.read_csv('examples/ex2.csv', header=None)
    2. Out[13]:
    3. 0 1 2 3 4
    4. 0 1 2 3 4 hello
    5. 1 5 6 7 8 world
    6. 2 9 10 11 12 foo
    7. In [14]: pd.read_csv('examples/ex2.csv', names=['a', 'b', 'c', 'd', 'message'])
    8. Out[14]:
    9. a b c d message
    10. 0 1 2 3 4 hello
    11. 1 5 6 7 8 world
    12. 2 9 10 11 12 foo

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

    1. In [15]: names = ['a', 'b', 'c', 'd', 'message']
    2. In [16]: pd.read_csv('examples/ex2.csv', names=names, index_col='message')
    3. Out[16]:
    4. a b c d
    5. message
    6. hello 1 2 3 4
    7. world 5 6 7 8
    8. foo 9 10 11 12

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

    1. In [17]: !cat examples/csv_mindex.csv
    2. key1,key2,value1,value2
    3. one,a,1,2
    4. one,b,3,4
    5. one,c,5,6
    6. one,d,7,8
    7. two,a,9,10
    8. two,b,11,12
    9. two,c,13,14
    10. two,d,15,16
    11. In [18]: parsed = pd.read_csv('examples/csv_mindex.csv',
    12. ....: index_col=['key1', 'key2'])
    13. In [19]: parsed
    14. Out[19]:
    15. value1 value2
    16. key1 key2
    17. one a 1 2
    18. b 3 4
    19. c 5 6
    20. d 7 8
    21. two a 9 10
    22. b 11 12
    23. c 13 14
    24. d 15 16

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

    1. In [20]: list(open('examples/ex3.txt'))
    2. Out[20]:
    3. [' A B C\n',
    4. 'aaa -0.264438 -1.026059 -0.619500\n',
    5. 'bbb 0.927272 0.302904 -0.032399\n',
    6. 'ccc -0.264273 -0.386314 -0.217601\n',
    7. 'ddd -0.871858 -0.348382 1.100491\n']

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

    1. In [21]: result = pd.read_table('examples/ex3.txt', sep='\s+')
    2. In [22]: result
    3. Out[22]:
    4. A B C
    5. aaa -0.264438 -1.026059 -0.619500
    6. bbb 0.927272 0.302904 -0.032399
    7. ccc -0.264273 -0.386314 -0.217601
    8. ddd -0.871858 -0.348382 1.100491

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

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

    1. In [23]: !cat examples/ex4.csv
    2. # hey!
    3. a,b,c,d,message
    4. # just wanted to make things more difficult for you
    5. # who reads CSV files with computers, anyway?
    6. 1,2,3,4,hello
    7. 5,6,7,8,world
    8. 9,10,11,12,foo
    9. In [24]: pd.read_csv('examples/ex4.csv', skiprows=[0, 2, 3])
    10. Out[24]:
    11. a b c d message
    12. 0 1 2 3 4 hello
    13. 1 5 6 7 8 world
    14. 2 9 10 11 12 foo

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

    1. In [25]: !cat examples/ex5.csv
    2. something,a,b,c,d,message
    3. one,1,2,3,4,NA
    4. two,5,6,,8,world
    5. three,9,10,11,12,foo
    6. In [26]: result = pd.read_csv('examples/ex5.csv')
    7. In [27]: result
    8. Out[27]:
    9. something a b c d message
    10. 0 one 1 2 3.0 4 NaN
    11. 1 two 5 6 NaN 8 world
    12. 2 three 9 10 11.0 12 foo
    13. In [28]: pd.isnull(result)
    14. Out[28]:
    15. something a b c d message
    16. 0 False False False False False True
    17. 1 False False False True False False
    18. 2 False False False False False False

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

    1. In [29]: result = pd.read_csv('examples/ex5.csv', na_values=['NULL'])
    2. In [30]: result
    3. Out[30]:
    4. something a b c d message
    5. 0 one 1 2 3.0 4 NaN
    6. 1 two 5 6 NaN 8 world
    7. 2 three 9 10 11.0 12 foo

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

    1. In [31]: sentinels = {'message': ['foo', 'NA'], 'something': ['two']}
    2. In [32]: pd.read_csv('examples/ex5.csv', na_values=sentinels)
    3. Out[32]:
    4. something a b c d message
    5. 0 one 1 2 3.0 4 NaN
    6. 1 NaN 5 6 NaN 8 world
    7. 2 three 9 10 11.0 12 NaN

    表6-2列出了pandas.read_csv和pandas.read_table常用的选项。

    6.1 读写文本格式的数据 - 图2

    6.1 读写文本格式的数据 - 图3

    6.1 读写文本格式的数据 - 图4

    逐块读取文本文件

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

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

    1. In [33]: pd.options.display.max_rows = 10

    然后有:

    1. In [34]: result = pd.read_csv('examples/ex6.csv')
    2. In [35]: result
    3. Out[35]:
    4. one two three four key
    5. 0 0.467976 -0.038649 -0.295344 -1.824726 L
    6. 1 -0.358893 1.404453 0.704965 -0.200638 B
    7. 2 -0.501840 0.659254 -0.421691 -0.057688 G
    8. 3 0.204886 1.074134 1.388361 -0.982404 R
    9. 4 0.354628 -0.133116 0.283763 -0.837063 Q
    10. ... ... ... ... ... ..
    11. 9995 2.311896 -0.417070 -1.409599 -0.515821 L
    12. 9996 -0.479893 -0.650419 0.745152 -0.646038 E
    13. 9997 0.523331 0.787112 0.486066 1.093156 K
    14. 9998 -0.362559 0.598894 -1.843201 0.887292 G
    15. 9999 -0.096376 -1.012999 -0.657431 -0.573315 0
    16. [10000 rows x 5 columns]
    17. If you want to only read a small

    如果只想读取几行(避免读取整个文件),通过nrows进行指定即可:

    1. In [36]: pd.read_csv('examples/ex6.csv', nrows=5)
    2. Out[36]:
    3. one two three four key
    4. 0 0.467976 -0.038649 -0.295344 -1.824726 L
    5. 1 -0.358893 1.404453 0.704965 -0.200638 B
    6. 2 -0.501840 0.659254 -0.421691 -0.057688 G
    7. 3 0.204886 1.074134 1.388361 -0.982404 R
    8. 4 0.354628 -0.133116 0.283763 -0.837063 Q

    要逐块读取文件,可以指定chunksize(行数):

    1. In [874]: chunker = pd.read_csv('ch06/ex6.csv', chunksize=1000)
    2. In [875]: chunker
    3. Out[875]: <pandas.io.parsers.TextParser at 0x8398150>

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

    1. chunker = pd.read_csv('examples/ex6.csv', chunksize=1000)
    2. tot = pd.Series([])
    3. for piece in chunker:
    4. tot = tot.add(piece['key'].value_counts(), fill_value=0)
    5. tot = tot.sort_values(ascending=False)

    然后有:

    1. In [40]: tot[:10]
    2. Out[40]:
    3. E 368.0
    4. X 364.0
    5. L 346.0
    6. O 343.0
    7. Q 340.0
    8. M 338.0
    9. J 337.0
    10. F 335.0
    11. K 334.0
    12. H 330.0
    13. dtype: float64

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

    将数据写出到文本格式

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

    1. In [41]: data = pd.read_csv('examples/ex5.csv')
    2. In [42]: data
    3. Out[42]:
    4. something a b c d message
    5. 0 one 1 2 3.0 4 NaN
    6. 1 two 5 6 NaN 8 world
    7. 2 three 9 10 11.0 12 foo

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

    1. In [43]: data.to_csv('examples/out.csv')
    2. In [44]: !cat examples/out.csv
    3. ,something,a,b,c,d,message
    4. 0,one,1,2,3.0,4,
    5. 1,two,5,6,,8,world
    6. 2,three,9,10,11.0,12,foo

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

    1. In [45]: import sys
    2. In [46]: data.to_csv(sys.stdout, sep='|')
    3. |something|a|b|c|d|message
    4. 0|one|1|2|3.0|4|
    5. 1|two|5|6||8|world
    6. 2|three|9|10|11.0|12|foo

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

    1. In [47]: data.to_csv(sys.stdout, na_rep='NULL')
    2. ,something,a,b,c,d,message
    3. 0,one,1,2,3.0,4,NULL
    4. 1,two,5,6,NULL,8,world
    5. 2,three,9,10,11.0,12,foo

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

    1. In [48]: data.to_csv(sys.stdout, index=False, header=False)
    2. one,1,2,3.0,4,
    3. two,5,6,,8,world
    4. three,9,10,11.0,12,foo

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

    1. In [49]: data.to_csv(sys.stdout, index=False, columns=['a', 'b', 'c'])
    2. a,b,c
    3. 1,2,3.0
    4. 5,6,
    5. 9,10,11.0

    Series也有一个to_csv方法:

    1. In [50]: dates = pd.date_range('1/1/2000', periods=7)
    2. In [51]: ts = pd.Series(np.arange(7), index=dates)
    3. In [52]: ts.to_csv('examples/tseries.csv')
    4. In [53]: !cat examples/tseries.csv
    5. 2000-01-01,0
    6. 2000-01-02,1
    7. 2000-01-03,2
    8. 2000-01-04,3
    9. 2000-01-05,4
    10. 2000-01-06,5
    11. 2000-01-07,6

    处理分隔符格式

    大部分存储在磁盘上的表格型数据都能用pandas.read_table进行加载。然而,有时还是需要做一些手工处理。由于接收到含有畸形行的文件而使read_table出毛病的情况并不少见。为了说明这些基本工具,看看下面这个简单的CSV文件:

    1. In [54]: !cat examples/ex7.csv
    2. "a","b","c"
    3. "1","2","3"
    4. "1","2","3"

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

    1. import csv
    2. f = open('examples/ex7.csv')
    3. reader = csv.reader(f)

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

    1. In [56]: for line in reader:
    2. ....: print(line)
    3. ['a', 'b', 'c']
    4. ['1', '2', '3']
    5. ['1', '2', '3']

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

    1. In [57]: with open('examples/ex7.csv') as f:
    2. ....: lines = list(csv.reader(f))

    然后,我们将这些行分为标题行和数据行:

    1. In [58]: header, values = lines[0], lines[1:]

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

    1. In [59]: data_dict = {h: v for h, v in zip(header, zip(*values))}
    2. In [60]: data_dict
    3. Out[60]: {'a': ('1', '1'), 'b': ('2', '2'), 'c': ('3', '3')}

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

    1. class my_dialect(csv.Dialect):
    2. lineterminator = '\n'
    3. delimiter = ';'
    4. quotechar = '"'
    5. quoting = csv.QUOTE_MINIMAL
    6. reader = csv.reader(f, dialect=my_dialect)

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

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

    可用的选项(csv.Dialect的属性)及其功能如表6-3所示。

    6.1 读写文本格式的数据 - 图5

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

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

    1. with open('mydata.csv', 'w') as f:
    2. writer = csv.writer(f, dialect=my_dialect)
    3. writer.writerow(('one', 'two', 'three'))
    4. writer.writerow(('1', '2', '3'))
    5. writer.writerow(('4', '5', '6'))
    6. writer.writerow(('7', '8', '9'))

    JSON数据

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

    1. obj = """
    2. {"name": "Wes",
    3. "places_lived": ["United States", "Spain", "Germany"],
    4. "pet": null,
    5. "siblings": [{"name": "Scott", "age": 30, "pets": ["Zeus", "Zuko"]},
    6. {"name": "Katie", "age": 38,
    7. "pets": ["Sixes", "Stache", "Cisco"]}]
    8. }
    9. """

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

    1. In [62]: import json
    2. In [63]: result = json.loads(obj)
    3. In [64]: result
    4. Out[64]:
    5. {'name': 'Wes',
    6. 'pet': None,
    7. 'places_lived': ['United States', 'Spain', 'Germany'],
    8. 'siblings': [{'age': 30, 'name': 'Scott', 'pets': ['Zeus', 'Zuko']},
    9. {'age': 38, 'name': 'Katie', 'pets': ['Sixes', 'Stache', 'Cisco']}]}

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

    1. In [65]: asjson = json.dumps(result)

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

    1. In [66]: siblings = pd.DataFrame(result['siblings'], columns=['name', 'age'])
    2. In [67]: siblings
    3. Out[67]:
    4. name age
    5. 0 Scott 30
    6. 1 Katie 38

    pandas.read_json可以自动将特别格式的JSON数据集转换为Series或DataFrame。例如:

    1. In [68]: !cat examples/example.json
    2. [{"a": 1, "b": 2, "c": 3},
    3. {"a": 4, "b": 5, "c": 6},
    4. {"a": 7, "b": 8, "c": 9}]

    pandas.read_json的默认选项假设JSON数组中的每个对象是表格中的一行:

    1. In [69]: data = pd.read_json('examples/example.json')
    2. In [70]: data
    3. Out[70]:
    4. a b c
    5. 0 1 2 3
    6. 1 4 5 6
    7. 2 7 8 9

    第7章中关于USDA Food Database的那个例子进一步讲解了JSON数据的读取和处理(包括嵌套记录)。

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

    1. In [71]: print(data.to_json())
    2. {"a":{"0":1,"1":4,"2":7},"b":{"0":2,"1":5,"2":8},"c":{"0":3,"1":6,"2":9}}
    3. In [72]: print(data.to_json(orient='records'))
    4. [{"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用到的库:

    1. conda install lxml
    2. pip install beautifulsoup4 html5lib

    如果你用的不是conda,可以使用pip install lxml

    pandas.read_html有一些选项,默认条件下,它会搜索、尝试解析

    标签内的的表格数据。结果是一个列表的DataFrame对象:

    1. In [73]: tables = pd.read_html('examples/fdic_failed_bank_list.html')
    2. In [74]: len(tables)
    3. Out[74]: 1
    4. In [75]: failures = tables[0]
    5. In [76]: failures.head()
    6. Out[76]:
    7. Bank Name City ST CERT \
    8. 0 Allied Bank Mulberry AR 91
    9. 1 The Woodbury Banking Company Woodbury GA 11297
    10. 2 First CornerStone Bank King of Prussia PA 35312
    11. 3 Trust Company Bank Memphis TN 9956
    12. 4 North Milwaukee State Bank Milwaukee WI 20364
    13. Acquiring Institution Closing Date Updated Date
    14. 0 Today's Bank September 23, 2016 November 17, 2016
    15. 1 United Bank August 19, 2016 November 17, 2016
    16. 2 First-Citizens Bank & Trust Company May 6, 2016 September 6, 2016
    17. 3 The Bank of Fayette County April 29, 2016 September 6, 2016
    18. 4 First-Citizens Bank & Trust Company March 11, 2016 June 16, 2016

    因为failures有许多列,pandas插入了一个换行符\。

    这里,我们可以做一些数据清洗和分析(后面章节会进一步讲解),比如计算按年份计算倒闭的银行数:

    1. In [77]: close_timestamps = pd.to_datetime(failures['Closing Date'])
    2. In [78]: close_timestamps.dt.year.value_counts()
    3. Out[78]:
    4. 2010 157
    5. 2009 140
    6. 2011 92
    7. 2012 51
    8. 2008 25
    9. ...
    10. 2004 4
    11. 2001 4
    12. 2007 3
    13. 2003 3
    14. 2000 2
    15. 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记录就是一条月度数据,如下所示:

    1. <INDICATOR>
    2. <INDICATOR_SEQ>373889</INDICATOR_SEQ>
    3. <PARENT_SEQ></PARENT_SEQ>
    4. <AGENCY_NAME>Metro-North Railroad</AGENCY_NAME>
    5. <INDICATOR_NAME>Escalator Availability</INDICATOR_NAME>
    6. <DESCRIPTION>Percent of the time that escalators are operational
    7. systemwide. The availability rate is based on physical observations performed
    8. the morning of regular business days only. This is a new indicator the agency
    9. began reporting in 2009.</DESCRIPTION>
    10. <PERIOD_YEAR>2011</PERIOD_YEAR>
    11. <PERIOD_MONTH>12</PERIOD_MONTH>
    12. <CATEGORY>Service Indicators</CATEGORY>
    13. <FREQUENCY>M</FREQUENCY>
    14. <DESIRED_CHANGE>U</DESIRED_CHANGE>
    15. <INDICATOR_UNIT>%</INDICATOR_UNIT>
    16. <DECIMAL_PLACES>1</DECIMAL_PLACES>
    17. <YTD_TARGET>97.00</YTD_TARGET>
    18. <YTD_ACTUAL></YTD_ACTUAL>
    19. <MONTHLY_TARGET>97.00</MONTHLY_TARGET>
    20. <MONTHLY_ACTUAL></MONTHLY_ACTUAL>
    21. </INDICATOR>

    我们先用lxml.objectify解析该文件,然后通过getroot得到该XML文件的根节点的引用:

    1. from lxml import objectify
    2. path = 'datasets/mta_perf/Performance_MNR.xml'
    3. parsed = objectify.parse(open(path))
    4. root = parsed.getroot()

    root.INDICATOR返回一个用于产生各个XML元素的生成器。对于每条记录,我们可以用标记名(如YTD_ACTUAL)和数据值填充一个字典(排除几个标记):

    1. data = []
    2. skip_fields = ['PARENT_SEQ', 'INDICATOR_SEQ',
    3. 'DESIRED_CHANGE', 'DECIMAL_PLACES']
    4. for elt in root.INDICATOR:
    5. el_data = {}
    6. for child in elt.getchildren():
    7. if child.tag in skip_fields:
    8. continue
    9. el_data[child.tag] = child.pyval
    10. data.append(el_data)

    最后,将这组字典转换为一个DataFrame:

    1. In [81]: perf = pd.DataFrame(data)
    2. In [82]: perf.head()
    3. Out[82]:
    4. Empty DataFrame
    5. Columns: []
    6. Index: []

    XML数据可以比本例复杂得多。每个标记都可以有元数据。看看下面这个HTML的链接标签(它也算是一段有效的XML):

    1. from io import StringIO
    2. tag = '<a href="http://www.google.com">Google</a>'
    3. root = objectify.parse(StringIO(tag)).getroot()

    现在就可以访问标签或链接文本中的任何字段了(如href):

    1. In [84]: root
    2. Out[84]: <Element a at 0x7f6b15817748>
    3. In [85]: root.get('href')
    4. Out[85]: 'http://www.google.com'
    5. In [86]: root.text
    6. Out[86]: 'Google'