Python与XML深度探索：理想组合与实战应用

4星 · 超过85%的资源需积分: 9 80 浏览量更新于2024-07-20 收藏 6.69MB PDF 举报

《Python与XML》是一本由Christopher A. Jones和Fred L. Drake, Jr. 合著的专业技术书籍，由O'Reilly出版社于2002年首次发行，ISBN号为0-596-00128-2，共384页。本书旨在为读者提供Python与XML语言深度结合的坚实基础，特别适合那些希望在处理XML数据和构建复杂Web应用时提升效率的开发者。本书的核心主题围绕Python作为处理XML的理想工具展开，强调了XML（可扩展标记语言）在数据交换、文档结构化和网络服务中的关键作用。作者首先介绍了XML的关键优势，如其简洁性、可扩展性和平台无关性，以及为何Python与XML结合的强大之处在于Python的灵活性和强大的数据处理能力。章节2深入探讨了XML的基本概念，包括XML的结构概述、文档类型和模式（DTD）、不同类型的符合性，以及XML文档的物理结构。学习者会了解到如何构建XML文档，以及文档类型定义（DTD）在验证文档结构的重要性。此外，书中还会介绍规范外的实践，如Canonical XML，它在确保XML文档的一致性方面扮演着角色。进入第三部分，书中的重点转向了Python与XML的简单API（应用程序编程接口），这是实际操作的基础。这里涵盖了如何利用Python处理XML文档，例如解析XML、创建XML树、以及使用像ElementTree这样的库进行基本操作。更进一步，书中涉及了使用XSLT（可扩展样式表语言）进行XML转换，以及XPath（XML路径语言）用于查询和提取XML数据的高级话题。对于SOAP（简单对象访问协议）和分布式Web服务这样的更高级主题，本书同样有所涉及，展示了如何通过Python将XML应用于复杂的网络环境中，实现跨平台的数据共享和服务交互。《Python与XML》适合任何对这两种技术感兴趣的开发人员，无论是初学者还是有经验的程序员，都能从中找到实用且深入的指导。通过丰富的实践案例和详细的教学内容，读者将掌握如何利用Python的强大功能来优化XML数据的处理和应用程序设计。

Unlike SGML, XML allows itself to be used without defining an explicit markup

language in any formal way. Whether or not this is useful for your applications, it has

greatly accelerated the acceptance of XML-based technologies in some developer

communities. This can happen because of the lower cost of entrance to the XML space. It

is possible to adopt XML without learning some of the more esoteric corners of the

specification, and development prototypes can start using XML technologies without a

lot of advance planning.

Chapter 2 presents the most widely used parts of the specification and goes into more

depth on what are the most important items to most readers of this book. If any of the

details are of particular interest to you, please spend some time reading relevant parts of

the specification. While it is at times a bit convoluted, it is not generally a difficult

specification to read.

1.2.2 Namespaces in XML

While the XML 1.0 recommendation defines specific syntactic aspects of XML and one

way of creating docum

ent types, it does not discuss how to combine components from

multiple document types. The Namespaces in XML recommendation, available at

http://www.w3.org/TR/REC-xml-names

(referred to as Namespaces from now on), deals

with the syntactic and structural mechanics of combining structured components from

different specifications, but is largely silent on the meaning of resulting combinations.

For this, it defers to specifications that had not been written when Namespaces was

published.

This recommendation places some additional constraints on the syntactic construction of

conform

ant documents. It allows a document to specify the source of each element or

attribute by placing it in a namespace. Each namespace provides definitions for elements

and attributes. How the elements and attributes are defined is not covered in this

specification, so the concept of validation of an arbitrary document that uses namespaces

is not entirely clear. It is possible to create a document type using XML 1.0 that has some

support for namespaces, but such a schema loses much of the flexibility offered by the

Namespaces specification. For example, the document type would have to specify the

particular prefixes to which each namespace is bound, while the Namespaces

specification allows prefixes to be determined by the document rather than the schema.

Alternate schema languages that have better support for Namespaces have been defined;

these are discussed briefly in Chapter 2

1.2.3 XML as a Foundation

Like its predecessor SGML, XML provides a way to define languages that fit the

requirements of your application. By specifying the exact syntax of the grammatical

elements (such as the characters used to mark the start of an element), it has reduced the

effort required to build conforming software—the components needed to extract an

application's data from XML are far smaller and simpler to use than the corresponding

components are for SGML.

www.it-ebooks.info

hey321.taobao.com

The additional specifications, which the trade press so enjoy discussing every time a

news release comes out, are generally built by defining new languages using the base

XML and Namespaces recommendations. These are often documented by schema

definitions (the forms that these take are described in Chapter 2

) as well as committee-

driven documents that attempt to explain how the language should be used. Since every

industry has at least one consortium that deals in part with data interchange between

different components of the industry (think of doctors, pharmacies, and hospitals in the

health care field), many standards take this form. Many of the standards for XML are

derived from earlier efforts using older SGML industry-specific languages, and many are

new.

Locating information about the languages that have been defined for your industry may

be easy or it m

ay be difficult. There are many resources you can use to locate relevant

specifications:

http://www.schema.net/

This web site contains information on a range of standards based on XML,

including general business-oriented specifications, industry-specific standards,

interoperable languages for academic research, and general Internet-related

specifications.

http://www.biztalk.com/

Information about the Microsoft-sponsored "BizTalk" range of business

interoperability specifications can be found at this web site.

http://www.ebxml.org/

The "e-business XML" initiative, or ebXML, grows out of the EDI community,

and generally competes with BizTalk.

http://www.w3.org/

For general Internet-related specifications, the World Wide Web Consortium is

perhaps the best place to look; the working groups there have a broad

constituency and the results of their efforts have a high level of uptake wherever

they apply.

http://www.google.com/

If all else fails, try searching here for "XML" and various keywords related to

your industry (especially the names of major industry consortia).

1.3 The Power of Python and XML

www.it-ebooks.info

hey321.taobao.com

Now that we've introduced you to the world of XML, we'll look at what Python brings to

the table. We'll review the Python features that apply to XML, and then we'll give some

specific examples of Python with XML. As a very high-level language, Python includes

many powerful data structures as part of the core language and libraries. The more recent

versions of Python, from 2.0 onward, include excellent support for Unicode and an

impressive range of encodings, as well as an excellent (and fast!) XML parser that

provides character data from XML as Unicode strings. Python's standard library also

contains implementations of the industry-standard DOM and SAX interfaces for working

with XML data, and additional support for alternate parsers and interfaces is available.

Of course, this much could be said of other modern high-level languages as well. Java

certainly includes an im

pressive library of highly usable data structures, and Perl offers

equivalent data structures also. What makes Python preferable to those languages and

their libraries? There are several features, of which we briefly discuss the most important:

• Python source code is easy to read and maintain.

• The interactive interpreter makes it simple to try out code fragments.

• Python is incredibly portable, but does not restrict access to platform-specific

capabilities.

• The object-oriented features are powerful without being obscure.

There are many languages capable of doing what can be done with Python, but it is rare

to find all of the "peripheral" qualities of Python in any single language. These qualities

do not so much make Python more capable, but they make it much easier to apply,

reducing programming hours. This allows more time to be spent finding better ways to

solve real problems or just allows the programmer to move on to the next problem. Here

we discuss these features in more detail.

Easy to read and maintain

As a programming language, Python exhibits a remarkable clarity of expression.

Though som

e programmers accustomed to other languages view Python's use of

significant whitespace with surprise, everyone seems to think it makes Python

source code significantly more readable than languages that require more special

characters to be introduced to mark structure in the source. Python's structures are

not simpler than those of other languages, but the different syntax makes source

code "feel" much cleaner in Python.

The use of whitespace also helps avoid having minor stylistic differences, such as

the placem

ent of structural braces, so there's a greater degree of visual consistency

across code by different programmers. While this may seem like a minor thing to

many programmers, the effect is that maintaining code written by another

programmer becomes much easier simply because its easier to concentrate on the

actual structure and algorithms of the code. For the individual programmer, this is

a nice side benefit, but for a business, this results in lower expenses for code

maintenance.

www.it-ebooks.info

hey321.taobao.com

Exploratory programming in an interactive interpreter

Many modern high-level programming languages offer interpreters, but few have

proved as successful at doing so as Python. Others, such as Java, do not generally

offer interpreters at all. If we consider Perl, a language that is arguably very

capable when used from a command line, we see that it is not equipped with a

rich interpreter. If we start the Perl interpreter without naming a script, it simply

waits for us to type a complete script at the console, and then interprets the script

when we're done. It does allow us to enter a few commands on the command line

directly, but there's no ability to run one statement at a time and inspect the results

as we go in order to determine if each bit of code is doing exactly what we expect.

With Python, the interactive interpreter provides a rich environment for executing

individual statements and testing the results.

Portability without restrictions

The Python interpreter is one of the most portable language interpreters available.

It is known to run on platform

s ranging from PDAs and other embedded systems

to some of the most powerful multiprocessor platforms ever built. It can run on

more operating systems than perhaps any other interpreter. Moreover, carefully

written application code can share much of this portability. Python provides a

great array of abstractions that do just enough to hide platform differences while

allowing the programmer to use the services of specific platforms when

necessary.

When an application requires access to facilities or libraries that Python does not

provide, Python also m

akes it easy to add extensions that take advantage of these

additional facilities. Additional modules can be created (usually in C or C++, but

other languages can be used as well) that allow Python code to call on external

facilities efficiently.

Powerful but accessible object-orientation

At one time, it was common to hear about how object-oriented programming

(OOP) would solve m

ost of the technical problems programmers had to deal with

in their code. Of course, programmers knew better, pushed back, and turned the

concepts into useful tools that could be applied when appropriate (though how and

when it should be applied may always be the subject of debate). Unfortunately,

many languages that have strong support for OOP are either very tedious to work

with (such as C++ or, to a lesser extent, Java), or they have not been as widely

accepted for general use (such as Eiffel).

Python is different. The language supports object orientation without m

uch of the

syntactic overhead found in many widely used object-oriented languages, making

it very easy to define new object types. Unlike many other languages, Python is

highly polymorphic; interfaces are defined in much less stringent ways than in

www.it-ebooks.info

hey321.taobao.com

languages such as C++ and Java. This makes it easy to create useful objects

without having to write code that exists only to conform to an interface, but that

will not actually be used in a particular application. When combined with the

excellent advantage taken by Python's standard library of a variety of common

interfaces, the value of creating reusable objects is easily recognized, all while the

ease of implementing useful interfaces is maintained.

1.3.1 Python Tools for XML

Three major packages provide Python tools for working with XML. These are, from the

ost commonly used to the largest:

1. The Python standard library

2. PyXML, produced by the Python XML Special Interest Group

3. 4Suite, provided by Fourthought, Inc.

The Python standard library provides a minimal but useful set of interfaces to work with

XML, including an interface to the popular Expat XML parser, an im

plementation of the

lightweight Simple API for XML (SAX), and a basic implementation of the core

Document Object Model (DOM). The DOM implementation supports Level 1 and much

of Level 2 of the DOM specification from the W3C, but does not implement most of the

optional features. The material in the standard library was drawn from material originally

in the PyXML package, and additional material was contributed by leading Python XML

developers.

PyXML is a more feature-laden package; it extends the standard library with additional

XML parsers, has a m

uch more substantial DOM implementation (including more

optional features), has adapters to allow more parsers to support the SAX interface,

XPath expression parsing and evaluation, XSLT transformations, and a variety of other

helper modules. The package is maintained as a community effort by many of the most

active Python/XML programmers.

4Suite is not a superset of the other packages, but is intended to be used in addition to

PyXML. It offers additional DOM im

plementations tailored for different applications,

support for the XLink and XPointer specifications, and tools for working with Resource

Description Framework (RDF) data.

These are the packages used throughout the book; see Appendix A

for more information

on obtaining and installing them. Still more are available; see Appendix F for brief

descriptions of several of these and references to more information online.

1.3.2 The SAX and DOM APIs

The two most basic and broadly used APIs to XML data are the SAX and DOM

interfaces. These interfaces differ substantially; learning to determine which of these is

appropriate for your application is an important step to learn.

www.it-ebooks.info

hey321.taobao.com

剩余356页未读，继续阅读

quxue4183

粉丝: 1
资源: 30

Python与XML深度探索：理想组合与实战应用

python 读xml文件

Python和XML编程指南: Python and XML.chm

Python & XML

python and xml

python and XML

Jones, Drake -- Python and XML -- 2002.pdf

Jones, Drake -- Python and XML -- 2002 -- code.7z

Python.XML

python解析xml文件实例分析

Python嵌入式XML和测试自动化

最新资源