本文由 大侠(AhcaoZhu)原创，转载请声明。
链接: https://blog.csdn.net/Ahcao2008

摘要

全文介绍系统内置 xml 模块、函数、类及类的方法和属性。
它通过代码抓取并经AI智能翻译和人工校对。
是一部不可多得的权威字典类工具书。它是系列集的一部分。后续陆续发布、敬请关注。【原创：AhcaoZhu大侠】

模块关系图

xml
	xml.dom
	xml.parsers
	xml.sax
	xml.etree
        xml.etree.ElementPath
        xml.etree.ElementTree
        xml.etree.cElementTree
        xml.etree.ElementInclude

类关系图

◆object
	◆BaseException
		◆Exception
			◆xml.dom.DOMException
				◆xml.dom.DomstringSizeErr
				◆xml.dom.HierarchyRequestErr
				◆xml.dom.IndexSizeErr
				◆xml.dom.InuseAttributeErr
				◆xml.dom.InvalidAccessErr
				◆xml.dom.InvalidCharacterErr
				◆xml.dom.InvalidModificationErr
				◆xml.dom.InvalidStateErr
				◆xml.dom.NamespaceErr
				◆xml.dom.NoDataAllowedErr
				◆xml.dom.NoModificationAllowedErr
				◆xml.dom.NotFoundErr
				◆xml.dom.NotSupportedErr
				◆xml.dom.SyntaxErr
				◆xml.dom.ValidationErr
				◆xml.dom.WrongDocumentErr
			◆xml.sax._exceptions.SAXException
				◆xml.sax._exceptions.SAXNotRecognizedException
				◆xml.sax._exceptions.SAXNotSupportedException
					◆xml.sax._exceptions.SAXReaderNotAvailable
				◆xml.sax._exceptions.SAXParseException
			◆SyntaxError
				◆xml.etree.ElementInclude.FatalIncludeError
				◆xml.etree.ElementTree.ParseError
	◆_io._IOBase
		◆io.IOBase
			◆_io._BufferedIOBase
				◆io.BufferedIOBase
					◆xml.etree.ElementTree._ListDataStream
	◆xml.dom.Node
	◆xml.dom.UserDataHandler
	◆xml.sax.handler.ContentHandler
	◆xml.sax.handler.ErrorHandler
	◆xml.sax.xmlreader.InputSource
	◆xml.etree.ElementPath._SelectorContext
	◆xml.etree.ElementTree.Element
	◆xml.etree.ElementTree.ElementTree
	◆xml.etree.ElementTree.QName
	◆xml.etree.ElementTree.TreeBuilder
	◆xml.etree.ElementTree.XMLParser
	◆xml.etree.ElementTree.XMLPullParser

模块全展开

一、【xml】

xml, fullname=xml, file=xml_init_.py

Python的核心XML支持。
这个包包含四个子包:
dom——W3C文档对象模型。它支持DOM级别1 +名称空间。
parsers——用于XML解析器的Python包装器(目前只支持Expat)。
sax - XML的简单API，由XML- dev开发，由David Megginson领导，并由Lars Marius Garshol移植到Python。它支持SAX 2 API。
etree -元素树XML库。这是完整的ElementTree XML发行版的一个子集。

统计

序号	类别	数量
4	str	5
6	list	2
8	dict	1
9	module	4
13	residual	2
14	system	10
16	all	14

模块

1 xml.dom

dom, fullname=xml.dom, file=xml\dom_init_.py

Python的W3C文档对象模型实现。
文档对象模型的Python映射在Python库参考中xml.dom包的部分有详细的说明。
这个包包含以下模块:
minidom—添加了名称空间支持的1级DOM的简单实现(基于2级规范)和其他次要的2级功能。
pulldom—DOM构建器，支持按需为文档的选定子树构建树。

2 xml.parsers

parsers, fullname=xml.parsers, file=xml\parsers_init_.py

Python接口到XML解析器。
这个包包含一个模块:
expat -用于James Clark的expat解析器的Python包装器，支持命名空间。

3 xml.sax

sax, fullname=xml.sax, file=xml\sax_init_.py

Python的XML (SAX)实现的简单API。
该模块提供了SAX 2接口的实现;关于该接口的Java版本的信息可以在[链接](http://www.megginson.com/SAX/)上找到。
该接口的Python版本在<...>中有文档。
handler -为SAX for Python的“客户端”定义SAX 2 API的基类和常量。
saxutils——通常用于处理SAX的方便类的实现。
xmlreader——定义与SAX for Python一起使用的解析器的SAX 2 API的基类和常量。
expatreader—允许在SAX中使用Expat解析器的驱动程序。

4 xml.etree

etree, fullname=xml.etree, file=xml\etree_init_.py

二、【xml.dom】

dom, fullname=xml.dom, file=xml\dom_init_.py

Python的W3C文档对象模型实现。
文档对象模型的Python映射在Python库参考中xml.dom包部分有详细的说明。
这个包包含以下模块:
minidom—添加了名称空间支持的1级DOM的简单实现(基于2级规范)和其他次要的2级功能。
pulldom—DOM构建器，支持按需为文档的选定子树构建树。

统计

序号	类别	数量
1	int	16
4	str	8
6	list	1
8	dict	1
9	module	1
10	class	19
11	function	2
13	residual	4
14	system	9
16	all	52

常量

int

1 INDEX_SIZE_ERR 1
2 DOMSTRING_SIZE_ERR 2
3 HIERARCHY_REQUEST_ERR 3
4 WRONG_DOCUMENT_ERR 4
5 INVALID_CHARACTER_ERR 5
6 NO_DATA_ALLOWED_ERR 6
7 NO_MODIFICATION_ALLOWED_ERR 7
8 NOT_FOUND_ERR 8
9 NOT_SUPPORTED_ERR 9
10 INUSE_ATTRIBUTE_ERR 10
11 INVALID_STATE_ERR 11
12 SYNTAX_ERR 12
13 INVALID_MODIFICATION_ERR 13
14 NAMESPACE_ERR 14
15 INVALID_ACCESS_ERR 15
16 VALIDATION_ERR 16

str

17 XML_NAMESPACE
18 XMLNS_NAMESPACE
19 XHTML_NAMESPACE

模块

20 xml.dom.domreg

domreg, fullname=xml.dom.domreg, file=xml\dom\domreg.py

DOM的注册工具。
不应直接使用此模块。而是应从xml.dom中导入函数 getDOMImplementation 和 registerDOMImplementation 。

函数

21 getDOMImplementation(name=None, features=())

getDOMImplementation(name=None, features=()), module=xml.dom.domreg, line:39 at xml\dom\domreg.py

getDOMImplementation(name = None, features = ()) -> DOM实现。
返回一个合适的DOM实现。名称或者是众所周知的DOM实现的模块名，或者是None。
如果不是None，则导入相应的模块，如果导入成功则返回DOMImplementation对象。
如果没有给出名称，请考虑可用的实现，以找到具有所需特性集的实现。
如果找不到实现，则引发ImportError。特性列表必须是传递给 hasFeature 的(feature, version)对序列。

22 registerDOMImplementation(name, factory)

registerDOMImplementation(name, factory), module=xml.dom.domreg, line:21 at xml\dom\domreg.py

用名称注册工厂函数。
工厂函数应该返回一个实现DOMImplementation接口的对象。
工厂函数可以返回相同的对象，也可以返回一个新的对象(例如，如果该实现支持一些自定义)。

类

23 xml.dom.Node

Node, xml.dom.Node, module=xml.dom>

类提供NodeType常量。

data

1 ATTRIBUTE_NODE=2 kind:data type:int class:<class ‘xml.dom.Node’>
2 CDATA_SECTION_NODE=4 kind:data type:int class:<class ‘xml.dom.Node’>
3 COMMENT_NODE=8 kind:data type:int class:<class ‘xml.dom.Node’>
4 DOCUMENT_FRAGMENT_NODE=11 kind:data type:int class:<class ‘xml.dom.Node’>
5 DOCUMENT_NODE=9 kind:data type:int class:<class ‘xml.dom.Node’>
6 DOCUMENT_TYPE_NODE=10 kind:data type:int class:<class ‘xml.dom.Node’>
7 ELEMENT_NODE=1 kind:data type:int class:<class ‘xml.dom.Node’>
8 ENTITY_NODE=6 kind:data type:int class:<class ‘xml.dom.Node’>
9 ENTITY_REFERENCE_NODE=5 kind:data type:int class:<class ‘xml.dom.Node’>
10 NOTATION_NODE=12 kind:data type:int class:<class ‘xml.dom.Node’>
11 PROCESSING_INSTRUCTION_NODE=7 kind:data type:int class:<class ‘xml.dom.Node’>
12 TEXT_NODE=3 kind:data type:int class:<class ‘xml.dom.Node’>

24 xml.dom.DOMException

DOMException, xml.dom.DOMException, module=xml.dom>

DOM异常的抽象基类。具有特定代码的异常是该类的专门化。

25 xml.dom.IndexSizeErr

IndexSizeErr, xml.dom.IndexSizeErr, module=xml.dom>

data

1 code=1 kind:data type:int class:<class ‘xml.dom.IndexSizeErr’>

26 xml.dom.DomstringSizeErr

DomstringSizeErr, xml.dom.DomstringSizeErr, module=xml.dom>

data

1 code=2 kind:data type:int class:<class ‘xml.dom.DomstringSizeErr’>

27 xml.dom.HierarchyRequestErr

HierarchyRequestErr, xml.dom.HierarchyRequestErr, module=xml.dom>

data

1 code=3 kind:data type:int class:<class ‘xml.dom.HierarchyRequestErr’>

28 xml.dom.WrongDocumentErr

WrongDocumentErr, xml.dom.WrongDocumentErr, module=xml.dom>

data

1 code=4 kind:data type:int class:<class ‘xml.dom.WrongDocumentErr’>

29 xml.dom.InvalidCharacterErr

InvalidCharacterErr, xml.dom.InvalidCharacterErr, module=xml.dom>

data

1 code=5 kind:data type:int class:<class ‘xml.dom.InvalidCharacterErr’>

30 xml.dom.NoDataAllowedErr

NoDataAllowedErr, xml.dom.NoDataAllowedErr, module=xml.dom>

data

1 code=6 kind:data type:int class:<class ‘xml.dom.NoDataAllowedErr’>

31 xml.dom.NoModificationAllowedErr

NoModificationAllowedErr, xml.dom.NoModificationAllowedErr, module=xml.dom>

data

1 code=7 kind:data type:int class:<class ‘xml.dom.NoModificationAllowedErr’>

32 xml.dom.NotFoundErr

NotFoundErr, xml.dom.NotFoundErr, module=xml.dom>

data

1 code=8 kind:data type:int class:<class ‘xml.dom.NotFoundErr’>

33 xml.dom.NotSupportedErr

NotSupportedErr, xml.dom.NotSupportedErr, module=xml.dom>

data

1 code=9 kind:data type:int class:<class ‘xml.dom.NotSupportedErr’>

34 xml.dom.InuseAttributeErr

InuseAttributeErr, xml.dom.InuseAttributeErr, module=xml.dom>

data

1 code=10 kind:data type:int class:<class ‘xml.dom.InuseAttributeErr’>

35 xml.dom.InvalidStateErr

InvalidStateErr, xml.dom.InvalidStateErr, module=xml.dom>

data

1 code=11 kind:data type:int class:<class ‘xml.dom.InvalidStateErr’>

36 xml.dom.SyntaxErr

SyntaxErr, xml.dom.SyntaxErr, module=xml.dom>

data

1 code=12 kind:data type:int class:<class ‘xml.dom.SyntaxErr’>

37 xml.dom.InvalidModificationErr

InvalidModificationErr, xml.dom.InvalidModificationErr, module=xml.dom>

data

1 code=13 kind:data type:int class:<class ‘xml.dom.InvalidModificationErr’>

38 xml.dom.NamespaceErr

NamespaceErr, xml.dom.NamespaceErr, module=xml.dom>

data

1 code=14 kind:data type:int class:<class ‘xml.dom.NamespaceErr’>

39 xml.dom.InvalidAccessErr

InvalidAccessErr, xml.dom.InvalidAccessErr, module=xml.dom>

data

1 code=15 kind:data type:int class:<class ‘xml.dom.InvalidAccessErr’>

40 xml.dom.ValidationErr

ValidationErr, xml.dom.ValidationErr, module=xml.dom>

data

1 code=16 kind:data type:int class:<class ‘xml.dom.ValidationErr’>

41 xml.dom.UserDataHandler

UserDataHandler, xml.dom.UserDataHandler, module=xml.dom>

为UserDataHandler.handle()提供操作常量的类。

data

1 NODE_CLONED=1 kind:data type:int class:<class ‘xml.dom.UserDataHandler’>
2 NODE_DELETED=3 kind:data type:int class:<class ‘xml.dom.UserDataHandler’>
3 NODE_IMPORTED=2 kind:data type:int class:<class ‘xml.dom.UserDataHandler’>
4 NODE_RENAMED=4 kind:data type:int class:<class ‘xml.dom.UserDataHandler’>

剩余

42 loader <_frozen_importlib_external.SourceFileLoader object at 0x000000000390A488>
43 spec ModuleSpec(name=‘xml.dom’, loader=<_frozen_importlib_external.SourceFileLoader object at 0x000000000390A488>, origin=‘…\lib\xml\dom\init.py’, submodule_search_locations=[‘…\lib\xml\dom’])
44 EMPTY_NAMESPACE None
45 EMPTY_PREFIX None

三、【xml.parsers】

parsers, fullname=xml.parsers, file=xml\parsers_init_.py

Python接口到XML解析器。
这个包包含一个模块:
    expat -用于James Clark的expat解析器的Python包装器，支持命名空间。

统计

序号	类别	数量
4	str	5
6	list	1
8	dict	1
13	residual	2
14	system	9
16	all	9

四、【xml.sax】

sax, fullname=xml.sax, file=xml\sax_init_.py

Python的XML (SAX)实现的简单API。
该模块提供了SAX 2接口的实现;关于该接口的Java版本的信息可以在[链接](http://www.megginson.com/SAX/)上找到。
该接口的Python版本在<…>中有文档。
handler -为SAX for Python的“客户端”定义SAX 2 API的基类和常量。
saxutils——通常用于处理SAX的方便类的实现。
xmlreader——定义与SAX for Python一起使用的解析器的SAX 2 API的基类和常量。
expatreader—允许在SAX中使用Expat解析器的驱动程序。

统计

序号	类别	数量
1	int	1
4	str	6
6	list	2
8	dict	1
9	module	3
10	class	8
11	function	4
13	residual	2
14	system	9
15	private	4
16	all	27

常量

int

1 _false 0

str

2 _key python.xml.sax.parser

list

3 default_parser_list [‘xml.sax.expatreader’]

模块

4 xml.sax.handler

handler, fullname=xml.sax.handler, file=xml\sax\handler.py

此模块包含SAX for Python 2.0版本的核心类。
这个文件只提供了具有绝对最小功能的默认类，驱动程序和应用程序可以从这些类中子类化。
其中许多类是空的，仅作为接口的文档包含。

5 xml.sax._exceptions

_exceptions, fullname=xml.sax._exceptions, file=xml\sax_exceptions.py

不同类型的SAX异常

6 xml.sax.xmlreader

xmlreader, fullname=xml.sax.xmlreader, file=xml\sax\xmlreader.py

XML Reader是XML解析器的SAX 2名称。XML解析器应该基于此代码。

函数

7 parse(source, handler, errorHandler=<xml.sax.handler.ErrorHandler object at 0x000000000393D088>)

parse(source, handler, errorHandler=<xml.sax.handler.ErrorHandler object at 0x000000000393D088>), module=xml.sax, line:29 at xml\sax_init_.py

8 parseString(string, handler, errorHandler=<xml.sax.handler.ErrorHandler object at 0x000000000392D2C8>)

parseString(string, handler, errorHandler=<xml.sax.handler.ErrorHandler object at 0x000000000392D2C8>), module=xml.sax, line:35 at xml\sax_init_.py

9 make_parser(parser_list=[])

make_parser(parser_list=[]), module=xml.sax, line:70 at xml\sax_init_.py

创建并返回SAX解析器。
创建第一个解析器，它能够实例化通过做解析器列表+默认解析器列表创建的列表中给出的解析器。
列表必须包含包含SAX解析器和创建解析器函数的Python模块的名称。

10 _create_parser(parser_name)

create_parser(parser_name), module=xml.sax, line:103 at xml\sax_init.py

类

11 xml.sax.xmlreader.InputSource

InputSource, xml.sax.xmlreader.InputSource, module=xml.sax.xmlreader>

XMLReader读取实体所需的信息的封装。
该类可以包括关于公共标识符、系统标识符、字节流(可能带有字符编码信息)和/或实体的字符流的信息。
应用程序将创建该类的对象，以便在XMLReader中使用。
方法和用于从EntityResolver.resolveEntity返回。
InputSource属于应用程序，XMLReader不允许修改从应用程序传递给它的InputSource对象，尽管它可以复制并修改这些对象。

method

1 getByteStream()

kind=method class=InputSource objtype=function

获取此输入源的字节流。
getEncoding方法将返回此字节流的字符编码，如果未知则返回None。

2 getCharacterStream()

kind=method class=InputSource objtype=function

获取此输入源的字符流。

3 getEncoding()

kind=method class=InputSource objtype=function

获取这个InputSource的字符编码。

4 getPublicId()

kind=method class=InputSource objtype=function

返回此InputSource的公共标识符。

5 getSystemId()

kind=method class=InputSource objtype=function

返回此InputSource的系统标识符。

6 setByteStream()

kind=method class=InputSource objtype=function

设置此输入源的字节流(不执行字节到字符转换的Python类文件对象)。
如果还指定了字符流，SAX解析器将忽略它，但它将优先使用字节流，而不是打开URI连接本身。
如果应用程序知道字节流的字符编码，它应该使用setEncoding方法进行设置。

7 setCharacterStream()

kind=method class=InputSource objtype=function

设置此输入源的字符流。(流必须是Python 2.0 Unicode包装的类文件，执行到Unicode字符串的转换。)
如果指定了字符流，SAX解析器将忽略任何字节流，并且不会尝试打开到系统标识符的URI连接。

8 setEncoding()

kind=method class=InputSource objtype=function

设置此InputSource的字符编码。
编码必须是XML编码声明可接受的字符串(请参阅XML建议的4.3.3节)。
如果InputSource还包含字符流，则忽略InputSource的encoding属性。

9 setPublicId()

kind=method class=InputSource objtype=function

设置此InputSource的公共标识符。

10 setSystemId()

kind=method class=InputSource objtype=function

设置此InputSource的系统标识符。

12 xml.sax.handler.ContentHandler

ContentHandler, xml.sax.handler.ContentHandler, module=xml.sax.handler>

接收逻辑文档内容事件的接口。
这是SAX中的主要回调接口，也是对应用程序最重要的接口。
此接口中的事件顺序反映了文档中信息的顺序。

method

1 characters()

kind=method class=ContentHandler objtype=function

接收字符数据通知。
解析器将调用该方法来报告每个字符数据块。
SAX解析器可以在单个块中返回所有连续的字符数据，也可以将其分成几个块;
但是，任何单个事件中的所有字符都必须来自相同的外部实体，以便Locator提供有用的信息。

2 endDocument()

kind=method class=ContentHandler objtype=function

接收文档结束的通知。
SAX解析器将只调用此方法一次，并且它将是解析期间调用的最后一个方法。
解析器在放弃解析(由于不可恢复的错误)或到达输入结束之前不应该调用此方法。

3 endElement()

kind=method class=ContentHandler objtype=function

以非名称空间模式表示元素的结束。
name参数包含元素类型的名称，就像startElement事件一样。

4 endElementNS()

kind=method class=ContentHandler objtype=function

以名称空间模式表示元素的结束。
name参数包含元素类型的名称，就像startElementNS事件一样。

5 endPrefixMapping()

kind=method class=ContentHandler objtype=function

结束前缀- uri映射的作用域。
详见startPrefixMapping。
该事件总是发生在相应的endElement事件之后，但是endPrefixMapping事件的顺序不能保证。

6 ignorableWhitespace()

kind=method class=ContentHandler objtype=function

接收元素内容中可忽略空白的通知。
验证解析器必须使用此方法报告每个可忽略的空白块(请参阅W3C XML 1.0建议，第2.10节):非验证解析器如果能够解析和使用内容模型，也可以使用此方法。
SAX解析器可以在单个块中返回所有连续的空白，也可以将其分割成几个块;
但是，任何单个事件中的所有字符都必须来自相同的外部实体，以便Locator提供有用的信息。

7 processingInstruction()

kind=method class=ContentHandler objtype=function

接收处理指令的通知。
Parser将为找到的每个处理指令调用此方法一次:注意，处理指令可能出现在主文档元素之前或之后。
SAX解析器不应该使用此方法报告XML声明(XML 1.0，第2.8节)或文本声明(XML 1.0，第4.3.1节)。

8 setDocumentLocator()

kind=method class=ContentHandler objtype=function

由解析器调用，为应用程序提供定位文档事件起源的定位器。
强烈鼓励SAX解析器(尽管不是绝对必需的)提供定位器:如果它这样做，它必须在调用documententhandler接口中的任何其他方法之前，
通过调用此方法向应用程序提供定位器。
定位器允许应用程序确定任何与文档相关的事件的结束位置，即使解析器没有报告错误。
通常，应用程序将使用此信息报告其自身的错误(例如不匹配应用程序业务规则的字符内容)。
定位器返回的信息可能不足以用于搜索引擎。
注意，定位器只有在调用此接口中的事件时才会返回正确的信息。应用程序不应该在任何其他时间尝试使用它。

9 skippedEntity()

kind=method class=ContentHandler objtype=function

接收跳过实体的通知。
解析器将为跳过的每个实体调用此方法一次。
如果未进行验证的处理程序没有看到声明，则可能跳过实体(例如，因为实体是在外部DTD子集中声明的)。
所有处理器都可以跳过外部实体，这取决于[external-general-entities](http://xml.org/sax/features/external-general-entities) 和 [external-parameter-entities](http://xml.org/sax/features/external-parameter-entities) 属性的值。

10 startDocument()

kind=method class=ContentHandler objtype=function

接收文档开始的通知。
SAX解析器将只调用该方法一次，在此接口或DTDHandler中的任何其他方法之前(setDocumentLocator 除外)。

11 startElement()

kind=method class=ContentHandler objtype=function

以非名称空间模式表示元素的开始。
name参数以字符串形式包含元素类型的原始XML 1.0名称，attrs参数包含Attributes类的一个实例，其中包含元素的属性。

12 startElementNS()

kind=method class=ContentHandler objtype=function

表示名称空间模式下元素的开始。
name参数包含元素类型的名称(uri, localname)元组，
qname参数是源文档中使用的原始XML 1.0名称，
attrs参数包含Attributes类的一个实例，其中包含元素的属性。
对于没有名称空间的元素，name元组的uri部分为None。

13 startPrefixMapping()

kind=method class=ContentHandler objtype=function

开始前缀- uri命名空间映射的范围。
来自此事件的信息对于正常的Namespace处理不是必需的:当[namespaces](http://xml.org/sax/features/namespaces) 特性为真(默认值)时，SAX XML读取器将自动替换元素和属性名称的前缀。
然而，在某些情况下，应用程序需要在字符数据或属性值中使用前缀，在这些情况下它们不能安全地自动展开;
start/endPrefixMapping事件向应用程序提供信息，以便在必要时在这些上下文中扩展前缀。
注意，start/endPrefixMapping事件不保证彼此正确嵌套:所有startPrefixMapping事件将发生在相应的startElement事件之前，
所有endPrefixMapping事件将发生在相应的endElement事件之后，但它们的顺序不保证。

13 xml.sax.handler.ErrorHandler

ErrorHandler, xml.sax.handler.ErrorHandler, module=xml.sax.handler>

SAX错误处理程序的基本接口。
如果创建了实现此接口的对象，然后将该对象注册到XMLReader中，解析器将调用对象中的方法以报告所有警告和错误。
有三种级别的错误可用:警告、(可能的)可恢复错误和不可恢复错误。所有方法都将SAXParseException作为唯一参数。

method

1 error()

kind=method class=ErrorHandler objtype=function

处理一个可恢复的错误。

2 fatalError()

kind=method class=ErrorHandler objtype=function

处理一个不可恢复的错误。

3 warning()

kind=method class=ErrorHandler objtype=function

处理警告。

14 xml.sax._exceptions.SAXException

SAXException, xml.sax._exceptions.SAXException, module=xml.sax._exceptions>

封装XML错误或警告。
该类可以包含来自XML解析器或应用程序的基本错误或警告信息:您可以对其进行子类化，以提供额外的功能或添加本地化。
注意，尽管您将接收SAXException作为ErrorHandler接口中处理程序的参数，但实际上并不需要引发异常;相反，您可以简单地阅读其中的信息。

method

1 getException()

kind=method class=SAXException objtype=function

返回嵌入的异常，如果没有则返回None。

2 getMessage()

kind=method class=SAXException objtype=function

返回此异常的消息。

15 xml.sax._exceptions.SAXNotRecognizedException

SAXNotRecognizedException, xml.sax._exceptions.SAXNotRecognizedException, module=xml.sax._exceptions>

无法识别的标识符的异常类。
XMLReader在遇到无法识别的特性或属性时将引发此异常。SAX应用程序和扩展可以出于类似的目的使用该类。

16 xml.sax._exceptions.SAXParseException

SAXParseException, xml.sax._exceptions.SAXParseException, module=xml.sax._exceptions>

封装XML解析错误或警告。
此异常将包括在原始XML文档中定位错误的信息。
注意，尽管应用程序将接收SAXParseException作为ErrorHandler接口中处理程序的参数，但应用程序实际上并不需要引发异常;
相反，它可以简单地读取其中的信息并采取不同的操作。
因为这个异常是SAXException的子类，所以它继承了包装另一个异常的能力。

method

1 getColumnNumber()

kind=method class=SAXParseException objtype=function

发生异常的文本末尾的列号。

2 getLineNumber()

kind=method class=SAXParseException objtype=function

发生异常的文本末尾的行号。

3 getPublicId()

kind=method class=SAXParseException objtype=function

获取发生异常的实体的公共标识符。

4 getSystemId()

kind=method class=SAXParseException objtype=function

获取发生异常的实体的系统标识符。

17 xml.sax._exceptions.SAXNotSupportedException

SAXNotSupportedException, xml.sax._exceptions.SAXNotSupportedException, module=xml.sax._exceptions>

不支持操作的异常类。
当请求无法执行的服务时(特别是设置状态或值)，XMLReader将引发此异常。
SAX应用程序和扩展可以出于类似的目的使用该类。

18 xml.sax._exceptions.SAXReaderNotAvailable

SAXReaderNotAvailable, xml.sax._exceptions.SAXReaderNotAvailable, module=xml.sax._exceptions>

缺少驱动程序的异常类。
XMLReader模块(驱动程序)在第一次导入时应该引发此异常，例如当支持模块不能导入时。
它也可能在解析过程中被引发，例如，如果不允许执行外部程序。

私有或局部

19 _exceptions <module ‘xml.sax._exceptions’ from ‘…\lib\xml\sax\_exceptions.py’>
20 _false 0
21 _key python.xml.sax.parser
22 _create_parser <function _create_parser at 0x0000000003932B88>

五、【xml.etree】

etree, fullname=xml.etree, file=xml\etree_init_.py

统计

序号	类别	数量
4	str	4
6	list	1
8	dict	1
9	module	4
13	residual	3
14	system	9
16	all	13

模块

1 xml.etree.ElementPath

ElementPath, fullname=xml.etree.ElementPath, file=xml\etree\ElementPath.py

2 xml.etree.ElementTree

ElementTree, fullname=xml.etree.ElementTree, file=xml\etree\ElementTree.py

Python的轻量级XML支持。
XML是一种固有的分层数据格式，最自然的表示方法是用树。
这个模块有两个类用于此目的:ElementTree将整个XML文档表示为树和2。元素表示此树中的单个节点。
与整个文档的交互(读取和写入文件)通常在ElementTree级别上完成。
与单个XML元素及其子元素的交互是在element级别上完成的。
Element是一个灵活的容器对象，用于在内存中存储层次数据结构。
它可以被描述为列表和字典之间的交叉。每个元素都有一些与之相关的属性:
'tag' -一个包含元素名称的字符串。
'attributes' -存储元素属性的Python字典。
'text' -包含元素文本内容的字符串。
'tail' -一个可选的字符串，包含元素结束标记之后的文本。以及存储在Python序列中的许多子元素。
要创建元素实例，请使用element构造函数或SubElement工厂函数。您还可以使用ElementTree类来包装元素结构并将其与XML进行转换。

3 xml.etree.cElementTree

cElementTree, fullname=xml.etree.cElementTree, file=xml\etree\cElementTree.py

4 xml.etree.ElementInclude

ElementInclude, fullname=xml.etree.ElementInclude, file=xml\etree\ElementInclude.py

五(1)【xml.etree.ElementPath】

ElementPath, fullname=xml.etree.ElementPath, file=xml\etree\ElementPath.py

统计

序号	类别	数量
4	str	4
8	dict	3
9	module	1
10	class	1
11	function	12
13	residual	4
14	system	8
15	private	2
16	all	25

常量

dict

1 ops {‘’: <function prepare_child at 0x0000000003975438>, ‘*’: <function prepare_star at 0x00000000039754C8>, ‘.’: <function …
2 _cache {}

模块

3 re

re, fullname=re, file=re.py

函数

4 xpath_tokenizer(pattern, namespaces=None)

xpath_tokenizer(pattern, namespaces=None), module=xml.etree.ElementPath, line:73 at xml\etree\ElementPath.py

5 get_parent_map(context)

get_parent_map(context), module=xml.etree.ElementPath, line:87 at xml\etree\ElementPath.py

6 prepare_child(next, token)

prepare_child(next, token), module=xml.etree.ElementPath, line:96 at xml\etree\ElementPath.py

7 prepare_star(next, token)

prepare_star(next, token), module=xml.etree.ElementPath, line:105 at xml\etree\ElementPath.py

8 prepare_self(next, token)

prepare_self(next, token), module=xml.etree.ElementPath, line:111 at xml\etree\ElementPath.py

9 prepare_descendant(next, token)

prepare_descendant(next, token), module=xml.etree.ElementPath, line:116 at xml\etree\ElementPath.py

10 prepare_parent(next, token)

prepare_parent(next, token), module=xml.etree.ElementPath, line:134 at xml\etree\ElementPath.py

11 prepare_predicate(next, token)

prepare_predicate(next, token), module=xml.etree.ElementPath, line:147 at xml\etree\ElementPath.py

12 iterfind(elem, path, namespaces=None)

iterfind(elem, path, namespaces=None), module=xml.etree.ElementPath, line:265 at xml\etree\ElementPath.py

13 find(elem, path, namespaces=None)

find(elem, path, namespaces=None), module=xml.etree.ElementPath, line:306 at xml\etree\ElementPath.py

14 findall(elem, path, namespaces=None)

findall(elem, path, namespaces=None), module=xml.etree.ElementPath, line:312 at xml\etree\ElementPath.py

15 findtext(elem, path, default=None, namespaces=None)

findtext(elem, path, default=None, namespaces=None), module=xml.etree.ElementPath, line:318 at xml\etree\ElementPath.py

类

16 xml.etree.ElementPath._SelectorContext

_SelectorContext, xml.etree.ElementPath._SelectorContext, module=xml.etree.ElementPath

data

1 parent_map=None kind:data type:NoneType class:<class ‘xml.etree.ElementPath._SelectorContext’>

私有或局部

17 _cache {}
18 _SelectorContext <class ‘xml.etree.ElementPath._SelectorContext’>

剩余

19 doc None
20 loader <_frozen_importlib_external.SourceFileLoader object at 0x0000000003970C88>
21 spec ModuleSpec(name=‘xml.etree.ElementPath’, loader=<_frozen_importlib_external.SourceFileLoader object at 0x0000000003970C88>, origin=‘…\lib\xml\etree\ElementPath.py’)
22 xpath_tokenizer_re re.compile(‘(’[^‘]*’|\"[\"]\"|:😐//?|\.\.|\(\)|[/.:\[\]\(\)@=])|((?:\{[^}]+\})?[/\[\]\(\)@=\s]+)|\s+')

函数

13 iselement(element)

iselement(element), module=xml.etree.ElementTree, line:119 at xml\etree\ElementTree.py

如果*element*是一个element，则返回True。

『Return True if *element* appears to be an Element.』

14 Comment(text=None)

Comment(text=None), module=xml.etree.ElementTree, line:462 at xml\etree\ElementTree.py

注释元素工厂。
此函数创建一个特殊元素，标准序列化器将其序列化为XML注释。
*text*是一个包含注释字符串的字符串。

15 ProcessingInstruction(target, text=None)

ProcessingInstruction(target, text=None), module=xml.etree.ElementTree, line:476 at xml\etree\ElementTree.py

加工指令元件工厂。
此函数创建一个特殊元素，标准序列化器将其序列化为XML注释。
*target*是包含处理指令的字符串，
*text*是包含处理指令内容(如果有的话)的字符串。

16 ProcessingInstruction(target, text=None)

ProcessingInstruction(target, text=None), module=xml.etree.ElementTree, line:476 at xml\etree\ElementTree.py

加工指令元件工厂。
此函数创建一个特殊元素，标准序列化器将其序列化为XML注释。
*target*是包含处理指令的字符串，
*text*是包含处理指令内容(如果有的话)的字符串。

17 _get_writer(file_or_filename, encoding)

_get_writer(file_or_filename, encoding), module=xml.etree.ElementTree, line:237 at contextlib.py

18 _namespaces(elem, default_namespace=None)

_namespaces(elem, default_namespace=None), module=xml.etree.ElementTree, line:838 at xml\etree\ElementTree.py

19 _serialize_xml(write, elem, qnames, namespaces, short_empty_elements, **kwargs)

_serialize_xml(write, elem, qnames, namespaces, short_empty_elements, **kwargs), module=xml.etree.ElementTree, line:899 at xml\etree\ElementTree.py

20 _serialize_html(write, elem, qnames, namespaces, **kwargs)

_serialize_html(write, elem, qnames, namespaces, **kwargs), module=xml.etree.ElementTree, line:957 at xml\etree\ElementTree.py

21 _serialize_text(write, elem)

_serialize_text(write, elem), module=xml.etree.ElementTree, line:1007 at xml\etree\ElementTree.py

22 register_namespace(prefix, uri)

register_namespace(prefix, uri), module=xml.etree.ElementTree, line:1022 at xml\etree\ElementTree.py

注册命名空间前缀。
注册表是全局的，给定前缀或名称空间URI的任何现有映射都将被删除。
*prefix*是命名空间前缀，
*uri*是命名空间uri。
如果可能的话，这个名称空间中的标记和属性将使用前缀序列化。
如果前缀被保留或无效，则引发ValueError。

23 _raise_serialization_error(text)

_raise_serialization_error(text), module=xml.etree.ElementTree, line:1056 at xml\etree\ElementTree.py

24 _escape_cdata(text)

_escape_cdata(text), module=xml.etree.ElementTree, line:1061 at xml\etree\ElementTree.py

25 _escape_attrib(text)

_escape_attrib(text), module=xml.etree.ElementTree, line:1077 at xml\etree\ElementTree.py

26 _escape_attrib_html(text)

_escape_attrib_html(text), module=xml.etree.ElementTree, line:1105 at xml\etree\ElementTree.py

27 tostring(element, encoding=None, method=None, *, short_empty_elements=True)

tostring(element, encoding=None, method=None, *, short_empty_elements=True), module=xml.etree.ElementTree, line:1120 at xml\etree\ElementTree.py

生成XML元素的字符串表示形式。
包括所有子元素。如果encoding为"unicode"，则返回一个字符串。否则返回字节串。
*element*是element实例，
*encoding*是可选输出编码，默认为US-ASCII， 
*method*是可选输出，可以是"xml"(默认)、"html"、"text"或"c14n"之一。
返回包含XML数据的编码字符串(可选)。

28 tostringlist(element, encoding=None, method=None, *, short_empty_elements=True)

tostringlist(element, encoding=None, method=None, *, short_empty_elements=True), module=xml.etree.ElementTree, line:1156 at xml\etree\ElementTree.py

29 dump(elem)

dump(elem), module=xml.etree.ElementTree, line:1165 at xml\etree\ElementTree.py

将元素树或元素结构写入sys.stdout。
此函数应仅用于调试。*elem*要么是一个元素树，要么是一个单独的元素。
确切的输出格式取决于实现。在这个版本中，它被编写为普通的XML文件。

30 parse(source, parser=None)

parse(source, parser=None), module=xml.etree.ElementTree, line:1187 at xml\etree\ElementTree.py

将XML文档解析为元素树。
*source*是一个包含XML数据的文件名或文件对象，
*parser*是一个默认为XMLParser的可选解析器实例。
返回一个ElementTree实例。

31 iterparse(source, events=None, parser=None)

iterparse(source, events=None, parser=None), module=xml.etree.ElementTree, line:1201 at xml\etree\ElementTree.py

增量地将XML文档解析为元素树。
这个类还根据初始化时使用的*events*向用户报告正在发生的事情。
支持的事件是字符串"start"， "end"， "start-ns"和"end-ns" ("ns"事件用于获取详细的命名空间信息)。
如果省略*events*，则只报告“end”事件。
*source*是包含XML数据的文件名或文件对象，
*events*是要报告的事件列表，
*parser*是可选的解析器实例。
返回提供(event, elem)对的迭代器。

32 XML(text, parser=None)

XML(text, parser=None), module=xml.etree.ElementTree, line:1302 at xml\etree\ElementTree.py

从字符串常量解析XML文档。此函数可用于在Python代码中嵌入“XML字面量”。
*text*是一个包含XML数据的字符串，
*parser*是一个可选的解析器实例，默认为标准XMLParser。返回一个Element实例。

33 XMLID(text, parser=None)

XMLID(text, parser=None), module=xml.etree.ElementTree, line:1319 at xml\etree\ElementTree.py

从字符串常量解析XML文档的id。
*text*是一个包含XML数据的字符串，
*parser*是一个可选的解析器实例，默认为标准XMLParser。
返回一个(Element, dict)元组，其中dict将元素id:s映射到元素。

34 XML(text, parser=None)

XML(text, parser=None), module=xml.etree.ElementTree, line:1302 at xml\etree\ElementTree.py

从字符串常量解析XML文档。此函数可用于在Python代码中嵌入“XML字面量”。
*text*是一个包含XML数据的字符串，
*parser*是一个可选的解析器实例，默认为标准XMLParser。
返回一个Element实例。

35 fromstringlist(sequence, parser=None)

fromstringlist(sequence, parser=None), module=xml.etree.ElementTree, line:1343 at xml\etree\ElementTree.py

从字符串片段序列解析XML文档。
*sequence*是其他序列的列表，
*parser*是可选的解析器实例，默认为标准XMLParser。
返回一个Element实例。

类

36 xml.etree.ElementTree.ParseError

ParseError, xml.etree.ElementTree.ParseError, module=xml.etree.ElementTree

37 xml.etree.ElementTree.Element

Element, xml.etree.ElementTree.Element, module=xml.etree.ElementTree

data

1 attrib=<attribute ‘attrib’ of ‘xml.etree.ElementTree.Element’ objects> kind:data type:getset_descriptor class:<class ‘xml.etree.ElementTree.Element’>
2 tag=<attribute ‘tag’ of ‘xml.etree.ElementTree.Element’ objects> kind:data type:getset_descriptor class:<class ‘xml.etree.ElementTree.Element’>
3 tail=<attribute ‘tail’ of ‘xml.etree.ElementTree.Element’ objects> kind:data type:getset_descriptor class:<class ‘xml.etree.ElementTree.Element’>
4 text=<attribute ‘text’ of ‘xml.etree.ElementTree.Element’ objects> kind:data type:getset_descriptor class:<class ‘xml.etree.ElementTree.Element’>

method

5 append()

kind=method class=Element objtype=method_descriptor

6 clear()

kind=method class=Element objtype=method_descriptor

7 extend()

kind=method class=Element objtype=method_descriptor

8 find()

kind=method class=Element objtype=method_descriptor

9 findall()

kind=method class=Element objtype=method_descriptor

10 findtext()

kind=method class=Element objtype=method_descriptor

11 get()

kind=method class=Element objtype=method_descriptor

12 getchildren()

kind=method class=Element objtype=method_descriptor

13 getiterator()

kind=method class=Element objtype=method_descriptor

14 insert()

kind=method class=Element objtype=method_descriptor

15 items()

kind=method class=Element objtype=method_descriptor

16 iter()

kind=method class=Element objtype=method_descriptor

17 iterfind()

kind=method class=Element objtype=method_descriptor

18 itertext()

kind=method class=Element objtype=method_descriptor

19 keys()

kind=method class=Element objtype=method_descriptor

20 makeelement()

kind=method class=Element objtype=method_descriptor

21 remove()

kind=method class=Element objtype=method_descriptor

22 set()

kind=method class=Element objtype=method_descriptor

38 xml.etree.ElementTree.QName

QName, xml.etree.ElementTree.QName, module=xml.etree.ElementTree

限定的名称包装器。
该类可用于包装QName属性值，以便在输出时获得适当的名称空间处理。
*text或uri*是以{uri}local形式包含QName值的字符串，如果给出了tag参数，则包含QName的uri部分。
*tag*是一个可选参数，如果给出它，将使第一个参数(text或uri)被解释为uri，而这个参数(标签)被解释为本地名称。

39 xml.etree.ElementTree.ElementTree

ElementTree, xml.etree.ElementTree.ElementTree, module=xml.etree.ElementTree

XML元素层次结构。
该类还提供了与标准XML之间的序列化支持。
*element*是可选的根元素节点，
*file*是可选的XML文件句柄或文件名，其内容将用于初始化树。

method

1 find()

kind=method class=ElementTree objtype=function

根据标记名称或路径查找第一个匹配的元素。
与 geroot().find(path) 一样，也就是 element.find() 
*path*是一个包含元素标记或XPath的字符串，
*namespaces*是从名称空间前缀到全名的可选映射。
返回第一个匹配的元素，如果没有找到元素则返回None。

2 findall()

kind=method class=ElementTree objtype=function

通过标记名称或路径查找所有匹配的子元素。
与geroot().findall(path)相同，也就是Element.findall()。
*path*是一个包含元素标记或XPath的字符串，
*namespaces*是从名称空间前缀到全名的可选映射。
按文档顺序返回所有匹配元素的列表。

3 findtext()

kind=method class=ElementTree objtype=function

根据标记名称或路径查找第一个匹配的元素。
与geroot().findtext(path)(即element.findtext()
*path*是一个包含元素标记或XPath的字符串，
*namespaces*是一个从名称空间前缀到全名的可选映射。
返回第一个匹配的元素，如果没有找到元素则返回None。

4 getiterator()

kind=method class=ElementTree objtype=function

5 getroot()

kind=method class=ElementTree objtype=function

返回此树的根元素。

6 iter()

kind=method class=ElementTree objtype=function

创建并返回根元素的树迭代器。
迭代器按文档顺序遍历树中的所有元素。
*tag*是一个带有要迭代的标记名称的字符串(默认是返回所有元素)。

7 iterfind()

kind=method class=ElementTree objtype=function

通过标记名称或路径查找所有匹配的子元素。
与geroot ().iterfind(path)相同，即element.iterfind() 
*path*是一个包含元素标记或XPath的字符串，
*namespaces*是从名称空间前缀到全名的可选映射。
返回一个可迭代对象，该对象按文档顺序生成所有匹配的元素。

8 parse()

kind=method class=ElementTree objtype=function

加载外部XML文档到元素树中。
*source*是文件名或文件对象，
*parser*是一个可选的解析器实例，默认为XMLParser。
如果解析器未能解析文档，则引发ParseError。
返回给定源文档的根元素。

9 write()

kind=method class=ElementTree objtype=function

将元素树以XML格式写入文件。
参数:
	*file or filename* -文件名或用于写入的文件对象
	*encoding* -输出编码(默认为US-ASCII) 
	*xml_declaration* - bool表示是否应该在输出中添加xml声明。
			如果为None，则如果encoding不是US-ASCII, UTF-8或Unicode中的任何一个，则添加XML声明
	*default_namespace* -设置默认的XML名称空间(用于“xmlns”)*方法* -“XML”(默认)，“html”，“text”，或“c14n”
	*short_empty_elements* -控制不包含内容的元素的格式。如果为True(默认值)，它们将作为单个自关闭标记发出，否则它们将作为一对开始/结束标记发出

10 write_c14n()

kind=method class=ElementTree objtype=function

40 xml.etree.ElementTree._ListDataStream

_ListDataStream, xml.etree.ElementTree._ListDataStream, module=xml.etree.ElementTree

累积到列表引用中的辅助流。

method

1 seekable()

kind=method class=_ListDataStream objtype=function

2 tell()

kind=method class=_ListDataStream objtype=function

3 writable()

kind=method class=_ListDataStream objtype=function

4 write()

kind=method class=_ListDataStream objtype=function

41 xml.etree.ElementTree.XMLPullParser

XMLPullParser, xml.etree.ElementTree.XMLPullParser, module=xml.etree.ElementTree

method

1 close()

kind=method class=XMLPullParser objtype=function

完成向解析器提供数据。
与XMLParser不同，它不返回根元素。使用read事件()来使用XMLPullParser中的元素。

2 feed()

kind=method class=XMLPullParser objtype=function

向解析器提供编码数据。

3 read_events()

kind=method class=XMLPullParser objtype=function

返回当前可用(event, elem)对的迭代器。
从迭代器检索事件时，从内部事件队列中消费事件。

42 xml.etree.ElementTree.TreeBuilder

TreeBuilder, xml.etree.ElementTree.TreeBuilder, module=xml.etree.ElementTree

method

1 close()

kind=method class=TreeBuilder objtype=method_descriptor

2 data()

kind=method class=TreeBuilder objtype=method_descriptor

3 end()

kind=method class=TreeBuilder objtype=method_descriptor

4 start()

kind=method class=TreeBuilder objtype=method_descriptor

43 xml.etree.ElementTree.XMLParser

XMLParser, xml.etree.ElementTree.XMLParser, module=xml.etree.ElementTree

method

1 close()

kind=method class=XMLParser objtype=method_descriptor

2 doctype()

kind=method class=XMLParser objtype=method_descriptor

3 feed()

kind=method class=XMLParser objtype=method_descriptor

44 xml.etree.ElementTree.Element

Element, xml.etree.ElementTree.Element, module=xml.etree.ElementTree

一个XML元素。
该类是Element接口的参考实现。
一个元素的长度是它的子元素的数目。
这意味着如果你想检查一个元素是否真的为空，你应该同时检查它的长度和它的文本属性。
元素标记、属性名和属性值可以是字节或字符串。
*tag*是元素名称。
*attrib*是一个包含元素属性的可选字典。
*extra*是作为关键字参数给出的额外元素属性。
表单示例:<tag attrib>text<child/>...</tag>tail

data

1 attrib=None kind:data type:NoneType class:<class ‘xml.etree.ElementTree.Element’>
2 tag=None kind:data type:NoneType class:<class ‘xml.etree.ElementTree.Element’>
3 tail=None kind:data type:NoneType class:<class ‘xml.etree.ElementTree.Element’>
4 text=None kind:data type:NoneType class:<class ‘xml.etree.ElementTree.Element’>

method

5 append()

kind=method class=Element objtype=function

在元素的末尾添加*subelement*。
新元素将按文档顺序出现在最后一个现有子元素之后(如果是第一个子元素，则直接出现在文本之后)，但在该元素的结束标记之前。

6 clear()

kind=method class=Element objtype=function

重置元素。
该函数删除所有子元素，清除所有属性，并将文本和尾部属性设置为None。

7 copy()

kind=method class=Element objtype=function

返回当前元素的副本。
这将创建一个浅拷贝。子元素将与原始树共享。

8 extend()

kind=method class=Element objtype=function

从序列中追加子元素。*elements*是一个包含零个或多个元素的序列。

9 find()

kind=method class=Element objtype=function

根据标记名称或路径查找第一个匹配的元素。
*path*是一个包含元素标记或XPath的字符串，
*namespaces*是从名称空间前缀到全名的可选映射。
返回第一个匹配的元素，如果没有找到元素则返回None。

10 findall()

kind=method class=Element objtype=function

通过标记名称或路径查找所有匹配的子元素。
*path*是一个包含元素标记或XPath的字符串，
*namespaces*是从名称空间前缀到全名的可选映射。
返回按文档顺序包含所有匹配元素的列表。

11 findtext()

kind=method class=Element objtype=function

根据标记名称或路径查找第一个匹配元素的文本。
*path*是一个包含元素标签或XPath的字符串，
*default*是未找到元素时返回的值，
*namespaces*是一个从名称空间前缀到全名的可选映射。
返回第一个匹配元素的文本内容，或默认值，如果一个也没有找到。
注意，如果发现一个元素没有文本内容时，返回空字符串。

12 get()

kind=method class=Element objtype=function

获取元素属性。
等价于attrib.get，但某些实现可能会更有效地处理此操作。
*key*是要查找的属性，
*default*是未找到属性时返回的属性。
返回包含属性值的字符串，如果未找到属性则返回默认值。

13 getchildren()

kind=method class=Element objtype=function

返回所有子元素。元素按文档顺序返回。

14 getiterator()

kind=method class=Element objtype=function

15 insert()

kind=method class=Element objtype=function

在位置 *index* 插入子元素 *subelement*。

16 items()

kind=method class=Element objtype=function

获取作为序列的元素属性。
属性以任意顺序返回。等价于attrib.items()。返回一个(name, value)元组列表。

17 iter()

kind=method class=Element objtype=function

创建树迭代器。
迭代器按文档顺序遍历元素和所有子元素，返回带有匹配标记的所有元素。
如果树结构在迭代过程中被修改，那么新的或删除的元素可能被包含，也可能不被包含。
要获得稳定的集合，请在迭代器上使用list()函数，并遍历生成的列表。
*tag*是要查找的标签(默认是返回所有元素)
返回包含所有匹配元素的迭代器。

18 iterfind()

kind=method class=Element objtype=function

通过标记名称或路径查找所有匹配的子元素。
*path*是一个包含元素标记或XPath的字符串，
*namespaces*是从名称空间前缀到全名的可选映射。
返回一个可迭代对象，该对象按文档顺序生成所有匹配的元素。

19 itertext()

kind=method class=Element objtype=function

创建文本迭代器。迭代器按文档顺序遍历元素和所有子元素，返回所有内部文本。

20 keys()

kind=method class=Element objtype=function

获取属性名列表。名称以任意顺序返回，就像普通的Python字典一样。等价于attrib.keys()

21 makeelement()

kind=method class=Element objtype=function

创建一个具有相同类型的新元素。
*tag*是包含元素名称的字符串。
*attrib*是一个包含元素属性的字典。
不要调用此方法，而是使用SubElement工厂函数。

22 remove()

kind=method class=Element objtype=function

删除匹配子元素。
与find方法不同，此方法基于标识(而不是on标记值或内容)比较元素。
要以其他方式删除子元素，最简单的方法是使用列表解析来选择要保留的元素，然后使用切片赋值来更新父元素。
如果找不到匹配的元素则引发ValueError。

23 set()

kind=method class=Element objtype=function

设置元素属性。
等价于attrib[key] = value，但某些实现可能会更有效地处理它。
*key*是要设置的属性，
*value*是要设置的属性值。

内嵌函数或方法

45 SubElement

私有或局部

46 _get_writer <function _get_writer at 0x0000000003979708>
47 _namespaces <function _namespaces at 0x0000000003979798>
48 _serialize_xml <function _serialize_xml at 0x0000000003979828>
49 _serialize_html <function _serialize_html at 0x00000000039798B8>
50 _serialize_text <function _serialize_text at 0x0000000003979948>
51 _serialize {‘xml’: <function _serialize_xml at 0x0000000003979828>, ‘html’: <function _serialize_html at 0x00000000039798B8>, 'text…
52 _namespace_map {‘http://www.w3.org/XML/1998/namespace’: ‘xml’, ‘http://www.w3.org/1999/xhtml’: ‘html’, 'http://www.w3.org/1999/02/22-rd…
53 _raise_serialization_error <function _raise_serialization_error at 0x0000000003979A68>
54 _escape_cdata <function _escape_cdata at 0x0000000003979AF8>
55 _escape_attrib <function _escape_attrib at 0x0000000003979B88>
56 _escape_attrib_html <function _escape_attrib_html at 0x0000000003979C18>
57 _ListDataStream <class ‘xml.etree.ElementTree._ListDataStream’>
58 _sentinel [‘sentinel’]
59 _Element_Py <class ‘xml.etree.ElementTree.Element’>

五(2)【xml.etree.cElementTree】

cElementTree, fullname=xml.etree.cElementTree, file=xml\etree\cElementTree.py

统计

序号	类别	数量
4	str	5
8	dict	1
10	class	7
11	function	14
12	builtin_function_or_method	1
13	residual	3
14	system	8
16	all	31

常量

str

1 VERSION 1.3.0

函数

2 Comment(text=None)

Comment(text=None), module=xml.etree.ElementTree, line:462 at xml\etree\ElementTree.py

注释元素工厂。此函数创建一个特殊元素，标准序列化器将其序列化为XML注释。
*text*是一个包含注释字符串的字符串。

3 dump(elem)

dump(elem), module=xml.etree.ElementTree, line:1165 at xml\etree\ElementTree.py

将元素树或元素结构写入sys.stdout。
此函数应仅用于调试。
*elem*要么是一个元素树，要么是一个单独的元素。
确切的输出格式取决于实现。在这个版本中，它被编写为普通的XML文件。

4 XML(text, parser=None)

XML(text, parser=None), module=xml.etree.ElementTree, line:1302 at xml\etree\ElementTree.py

从字符串常量解析XML文档。
此函数可用于在Python代码中嵌入“XML字面量”。
*text*是一个包含XML数据的字符串，
*parser*是一个可选的解析器实例，默认为标准XMLParser。
返回一个Element实例。

5 fromstringlist(sequence, parser=None)

fromstringlist(sequence, parser=None), module=xml.etree.ElementTree, line:1343 at xml\etree\ElementTree.py

从字符串片段序列解析XML文档。
*sequence*是其他序列的列表，
*parser*是可选的解析器实例，默认为标准XMLParser。
返回一个Element实例。

6 iselement(element)

iselement(element), module=xml.etree.ElementTree, line:119 at xml\etree\ElementTree.py

如果*element*是一个element，则返回True。

7 iterparse(source, events=None, parser=None)

iterparse(source, events=None, parser=None), module=xml.etree.ElementTree, line:1201 at xml\etree\ElementTree.py

增量地将XML文档解析为元素树。
这个类还根据初始化时使用的*events*向用户报告正在发生的事情。
支持的事件是字符串"start"， "end"， "start-ns"和"end-ns" ("ns"事件用于获取详细的命名空间信息)。
如果省略*events*，则只报告“end”事件。
*source*是包含XML数据的文件名或文件对象，
*events*是要报告的事件列表，
*parser*是可选的解析器实例。
返回提供(event, elem)对的迭代器。

8 parse(source, parser=None)

parse(source, parser=None), module=xml.etree.ElementTree, line:1187 at xml\etree\ElementTree.py

将XML文档解析为元素树。
*source*是一个包含XML数据的文件名或文件对象，
*parser*是一个默认为XMLParser的可选解析器实例。
返回一个ElementTree实例。

9 ProcessingInstruction(target, text=None)

ProcessingInstruction(target, text=None), module=xml.etree.ElementTree, line:476 at xml\etree\ElementTree.py

加工指令元件工厂。
此函数创建一个特殊元素，标准序列化器将其序列化为XML注释。
*target*是包含处理指令的字符串，
*text*是包含处理指令内容(如果有的话)的字符串。

10 ProcessingInstruction(target, text=None)

ProcessingInstruction(target, text=None), module=xml.etree.ElementTree, line:476 at xml\etree\ElementTree.py

加工指令元件工厂。
此函数创建一个特殊元素，标准序列化器将其序列化为XML注释。
*target*是包含处理指令的字符串，
*text*是包含处理指令内容(如果有的话)的字符串。

11 tostring(element, encoding=None, method=None, *, short_empty_elements=True)

tostring(element, encoding=None, method=None, *, short_empty_elements=True), module=xml.etree.ElementTree, line:1120 at xml\etree\ElementTree.py

生成XML元素的字符串表示形式。包括所有子元素。
如果encoding为"unicode"，则返回一个字符串。
否则返回字节串。
*element*是element实例，
*encoding*是可选输出编码，默认为US-ASCII， 
*method*是可选输出，可以是"xml"(默认)、"html"、"text"或"c14n"之一。
返回包含XML数据的编码字符串(可选)。

12 tostringlist(element, encoding=None, method=None, *, short_empty_elements=True)

tostringlist(element, encoding=None, method=None, *, short_empty_elements=True), module=xml.etree.ElementTree, line:1156 at xml\etree\ElementTree.py

13 XML(text, parser=None)

XML(text, parser=None), module=xml.etree.ElementTree, line:1302 at xml\etree\ElementTree.py

从字符串常量解析XML文档。
此函数可用于在Python代码中嵌入“XML字面量”。
*text*是一个包含XML数据的字符串，
*parser*是一个可选的解析器实例，默认为标准XMLParser。
返回一个Element实例。

14 XMLID(text, parser=None)

XMLID(text, parser=None), module=xml.etree.ElementTree, line:1319 at xml\etree\ElementTree.py

从字符串常量解析XML文档的id。
*text*是一个包含XML数据的字符串，
*parser*是一个可选的解析器实例，默认为标准XMLParser。
返回一个(Element, dict)元组，其中dict将元素id:s映射到元素。

15 register_namespace(prefix, uri)

register_namespace(prefix, uri), module=xml.etree.ElementTree, line:1022 at xml\etree\ElementTree.py

注册命名空间前缀。
注册表是全局的，给定前缀或名称空间URI的任何现有映射都将被删除。
*prefix*是命名空间前缀，
*uri*是命名空间uri。
如果可能的话，这个名称空间中的标记和属性将使用前缀序列化。
如果前缀被保留或无效，则引发ValueError。

类

16 xml.etree.ElementTree.Element

Element, xml.etree.ElementTree.Element, module=xml.etree.ElementTree

data

1 attrib=<attribute ‘attrib’ of ‘xml.etree.ElementTree.Element’ objects> kind:data type:getset_descriptor class:<class ‘xml.etree.ElementTree.Element’>
2 tag=<attribute ‘tag’ of ‘xml.etree.ElementTree.Element’ objects> kind:data type:getset_descriptor class:<class ‘xml.etree.ElementTree.Element’>
3 tail=<attribute ‘tail’ of ‘xml.etree.ElementTree.Element’ objects> kind:data type:getset_descriptor class:<class ‘xml.etree.ElementTree.Element’>
4 text=<attribute ‘text’ of ‘xml.etree.ElementTree.Element’ objects> kind:data type:getset_descriptor class:<class ‘xml.etree.ElementTree.Element’>

method

5 append()

kind=method class=Element objtype=method_descriptor

6 clear()

kind=method class=Element objtype=method_descriptor

7 extend()

kind=method class=Element objtype=method_descriptor

8 find()

kind=method class=Element objtype=method_descriptor

9 findall()

kind=method class=Element objtype=method_descriptor

10 findtext()

kind=method class=Element objtype=method_descriptor

11 get()

kind=method class=Element objtype=method_descriptor

12 getchildren()

kind=method class=Element objtype=method_descriptor

13 getiterator()

kind=method class=Element objtype=method_descriptor

14 insert()

kind=method class=Element objtype=method_descriptor

15 items()

kind=method class=Element objtype=method_descriptor

16 iter()

kind=method class=Element objtype=method_descriptor

17 iterfind()

kind=method class=Element objtype=method_descriptor

18 itertext()

kind=method class=Element objtype=method_descriptor

19 keys()

kind=method class=Element objtype=method_descriptor

20 makeelement()

kind=method class=Element objtype=method_descriptor

21 remove()

kind=method class=Element objtype=method_descriptor

22 set()

kind=method class=Element objtype=method_descriptor

17 xml.etree.ElementTree.ElementTree

ElementTree, xml.etree.ElementTree.ElementTree, module=xml.etree.ElementTree

XML元素层次结构。
该类还提供了与标准XML之间的序列化支持。
*element*是可选的根元素节点，
*file*是可选的XML文件句柄或文件名，其内容将用于初始化树。

method

1 find()

kind=method class=ElementTree objtype=function

根据标记名称或路径查找第一个匹配的元素。
与geroot().find(path)一样，也就是element.find() 
*path*是一个包含元素标记或XPath的字符串，
*namespaces*是从名称空间前缀到全名的可选映射。
返回第一个匹配的元素，如果没有找到元素则返回None。

2 findall()

kind=method class=ElementTree objtype=function

通过标记名称或路径查找所有匹配的子元素。
与 geroot().findall(path) 相同，也就是Element.findall()。
*path*是一个包含元素标签或XPath的字符串，
*namespaces*是一个从名称空间前缀到全名的可选映射。
按文档顺序返回所有匹配元素的列表。

3 findtext()

kind=method class=ElementTree objtype=function

根据标记名称或路径查找第一个匹配的元素。
与geroot().findtext(path)(即element.findtext() 
*path*是一个包含元素标记或XPath的字符串，
*namespaces*是一个从名称空间前缀到全名的可选映射。
返回第一个匹配的元素，如果没有找到元素则返回None。

4 getiterator()

kind=method class=ElementTree objtype=function

5 getroot()

kind=method class=ElementTree objtype=function

返回此树的根元素。

6 iter()

kind=method class=ElementTree objtype=function

创建并返回根元素的树迭代器。
迭代器按文档顺序遍历树中的所有元素。
*tag*是一个带有要迭代的标记名称的字符串(默认是返回所有元素)。

7 iterfind()

kind=method class=ElementTree objtype=function

通过标记名称或路径查找所有匹配的子元素。
与geroot().iterfind(path)相同，即element.iterfind() 
*path*是一个包含元素标记或XPath的字符串，
*namespaces*是从名称空间前缀到全名的可选映射。
返回一个可迭代对象，该对象按文档顺序生成所有匹配的元素。

8 parse()

kind=method class=ElementTree objtype=function

加载外部XML文档到元素树中。
*source*是文件名或文件对象，
*parser*是一个可选的解析器实例，默认为XMLParser。
如果解析器未能解析文档，则引发ParseError。
返回给定源文档的根元素。

9 write()

kind=method class=ElementTree objtype=function

将元素树以XML格式写入文件。
参数:
*file or filename* -文件名或用于写入的文件对象
*encoding* -输出编码(默认为US-ASCII) 
*xml_declaration* - bool表示是否应该在输出中添加xml声明。如果为None，则如果encoding不是US-ASCII, UTF-8或Unicode中的任何一个，则添加XML声明
*default_namespace* -设置默认的XML名称空间(用于“xmlns”)*方法* -“XML”(默认)，“html”，“text”，或“c14n”
*short_empty_elements* -控制不包含内容的元素的格式。如果为True(默认值)，它们将作为单个自关闭标记发出，否则它们将作为一对开始/结束标记发出

10 write_c14n()

kind=method class=ElementTree objtype=function

18 xml.etree.ElementTree.ParseError

ParseError, xml.etree.ElementTree.ParseError, module=xml.etree.ElementTree

19 xml.etree.ElementTree.QName

QName, xml.etree.ElementTree.QName, module=xml.etree.ElementTree

限定的名称包装器。
该类可用于包装QName属性值，以便在输出时获得适当的名称空间处理。
*text或uri*是以{uri}local形式包含QName值的字符串，如果给出了tag参数，则包含QName的uri部分。
*tag*是一个可选参数，如果给出它，将使第一个参数(text或uri)被解释为uri，而这个参数(标签)被解释为本地名称。

20 xml.etree.ElementTree.TreeBuilder

TreeBuilder, xml.etree.ElementTree.TreeBuilder, module=xml.etree.ElementTree

method

1 close()

kind=method class=TreeBuilder objtype=method_descriptor

2 data()

kind=method class=TreeBuilder objtype=method_descriptor

3 end()

kind=method class=TreeBuilder objtype=method_descriptor

4 start()

kind=method class=TreeBuilder objtype=method_descriptor

21 xml.etree.ElementTree.XMLParser

XMLParser, xml.etree.ElementTree.XMLParser, module=xml.etree.ElementTree

method

1 close()

kind=method class=XMLParser objtype=method_descriptor

2 doctype()

kind=method class=XMLParser objtype=method_descriptor

3 feed()

kind=method class=XMLParser objtype=method_descriptor

22 xml.etree.ElementTree.XMLPullParser

XMLPullParser, xml.etree.ElementTree.XMLPullParser, module=xml.etree.ElementTree

method

1 close()

kind=method class=XMLPullParser objtype=function

完成向解析器提供数据。
与XMLParser不同，它不返回根元素。使用
read_events()来使用XMLPullParser中的元素。

2 feed()

kind=method class=XMLPullParser objtype=function

向解析器提供编码数据。

3 read_events()

kind=method class=XMLPullParser objtype=function

返回当前可用(event, elem)对的迭代器。
从迭代器检索事件时，从内部事件队列中消费事件。

内嵌函数或方法

23 SubElement

五(3)【xml.etree.ElementInclude】

ElementInclude, fullname=xml.etree.ElementInclude, file=xml\etree\ElementInclude.py

统计

序号	类别	数量
4	str	7
8	dict	1
9	module	2
10	class	1
11	function	2
13	residual	3
14	system	8
16	all	16

常量

str

1 XINCLUDE {http://www.w3.org/2001/XInclude}
2 XINCLUDE_INCLUDE {http://www.w3.org/2001/XInclude}include
3 XINCLUDE_FALLBACK {http://www.w3.org/2001/XInclude}fallback

模块

4 copy

copy, fullname=copy, file=copy.py

通用的(浅的和深的)复制操作。
接口摘要:
        import copy

        x = copy.copy(y)        # make a shallow copy of y
        x = copy.deepcopy(y)    # make a deep copy of y

5 xml.etree.ElementTree

ElementTree, fullname=xml.etree.ElementTree, file=xml\etree\ElementTree.py

函数

6 default_loader(href, parse, encoding=None)

default_loader(href, parse, encoding=None), module=xml.etree.ElementInclude, line:77 at xml\etree\ElementInclude.py

7 include(elem, loader=None)

include(elem, loader=None), module=xml.etree.ElementInclude, line:99 at xml\etree\ElementInclude.py

类

8 xml.etree.ElementInclude.FatalIncludeError

FatalIncludeError, xml.etree.ElementInclude.FatalIncludeError, module=xml.etree.ElementInclude