一图看懂 xml 模块：可扩展标记语言数据处理, 资料整理+笔记（大全）
本文由 大侠(AhcaoZhu)原创，转载请声明。
链接: https://blog.csdn.net/Ahcao2008
一图看懂 xml 模块：可扩展标记语言数据处理, 资料整理+笔记（大全）
- 摘要
- 模块关系图
- 类关系图
- 模块全展开
-
- 一、【xml】
- 统计
- 模块
-
- 1 xml.dom
- 2 xml.parsers
- 3 xml.sax
- 4 xml.etree
- 二、【xml.dom】
- 统计
- 常量
-
- int
- str
- 模块
-
- 20 xml.dom.domreg
- 函数
-
- 21 getDOMImplementation(name=None, features=())
- 22 registerDOMImplementation(name, factory)
- 类
-
- 23 xml.dom.Node
-
- data
- 24 xml.dom.DOMException
- 25 xml.dom.IndexSizeErr
-
- data
- 26 xml.dom.DomstringSizeErr
-
- data
- 27 xml.dom.HierarchyRequestErr
-
- data
- 28 xml.dom.WrongDocumentErr
-
- data
- 29 xml.dom.InvalidCharacterErr
-
- data
- 30 xml.dom.NoDataAllowedErr
-
- data
- 31 xml.dom.NoModificationAllowedErr
-
- data
- 32 xml.dom.NotFoundErr
-
- data
- 33 xml.dom.NotSupportedErr
-
- data
- 34 xml.dom.InuseAttributeErr
-
- data
- 35 xml.dom.InvalidStateErr
-
- data
- 36 xml.dom.SyntaxErr
-
- data
- 37 xml.dom.InvalidModificationErr
-
- data
- 38 xml.dom.NamespaceErr
-
- data
- 39 xml.dom.InvalidAccessErr
-
- data
- 40 xml.dom.ValidationErr
-
- data
- 41 xml.dom.UserDataHandler
-
- data
- 剩余
- 三、【xml.parsers】
- 统计
- 四、【xml.sax】
- 统计
- 常量
-
- int
- str
- list
- 模块
-
- 4 xml.sax.handler
- 5 xml.sax._exceptions
- 6 xml.sax.xmlreader
- 函数
-
- 7 parse(source, handler, errorHandler=
) - 8 parseString(string, handler, errorHandler=
) - 9 make_parser(parser_list=[])
- 10 _create_parser(parser_name)
- 7 parse(source, handler, errorHandler=
- 类
-
- 11 xml.sax.xmlreader.InputSource
-
- method
- 1 getByteStream()
- 2 getCharacterStream()
- 3 getEncoding()
- 4 getPublicId()
- 5 getSystemId()
- 6 setByteStream()
- 7 setCharacterStream()
- 8 setEncoding()
- 9 setPublicId()
- 10 setSystemId()
- 12 xml.sax.handler.ContentHandler
-
- method
- 1 characters()
- 2 endDocument()
- 3 endElement()
- 4 endElementNS()
- 5 endPrefixMapping()
- 6 ignorableWhitespace()
- 7 processingInstruction()
- 8 setDocumentLocator()
- 9 skippedEntity()
- 10 startDocument()
- 11 startElement()
- 12 startElementNS()
- 13 startPrefixMapping()
- 13 xml.sax.handler.ErrorHandler
-
- method
- 1 error()
- 2 fatalError()
- 3 warning()
- 14 xml.sax._exceptions.SAXException
-
- method
- 1 getException()
- 2 getMessage()
- 15 xml.sax._exceptions.SAXNotRecognizedException
- 16 xml.sax._exceptions.SAXParseException
-
- method
- 1 getColumnNumber()
- 2 getLineNumber()
- 3 getPublicId()
- 4 getSystemId()
- 17 xml.sax._exceptions.SAXNotSupportedException
- 18 xml.sax._exceptions.SAXReaderNotAvailable
- 私有或局部
- 五、【xml.etree】
- 统计
- 模块
-
- 1 xml.etree.ElementPath
- 2 xml.etree.ElementTree
- 3 xml.etree.cElementTree
- 4 xml.etree.ElementInclude
- 五(1)【xml.etree.ElementPath】
- 统计
- 常量
-
- dict
- 模块
-
- 3 re
- 函数
-
- 4 xpath_tokenizer(pattern, namespaces=None)
- 5 get_parent_map(context)
- 6 prepare_child(next, token)
- 7 prepare_star(next, token)
- 8 prepare_self(next, token)
- 9 prepare_descendant(next, token)
- 10 prepare_parent(next, token)
- 11 prepare_predicate(next, token)
- 12 iterfind(elem, path, namespaces=None)
- 13 find(elem, path, namespaces=None)
- 14 findall(elem, path, namespaces=None)
- 15 findtext(elem, path, default=None, namespaces=None)
- 类
-
- 16 xml.etree.ElementPath._SelectorContext
-
- data
- 私有或局部
- 剩余
- 函数
-
- 13 iselement(element)
- 14 Comment(text=None)
- 15 ProcessingInstruction(target, text=None)
- 16 ProcessingInstruction(target, text=None)
- 17 _get_writer(file_or_filename, encoding)
- 18 _namespaces(elem, default_namespace=None)
- 19 _serialize_xml(write, elem, qnames, namespaces, short_empty_elements, **kwargs)
- 20 _serialize_html(write, elem, qnames, namespaces, **kwargs)
- 21 _serialize_text(write, elem)
- 22 register_namespace(prefix, uri)
- 23 _raise_serialization_error(text)
- 24 _escape_cdata(text)
- 25 _escape_attrib(text)
- 26 _escape_attrib_html(text)
- 27 tostring(element, encoding=None, method=None, *, short_empty_elements=True)
- 28 tostringlist(element, encoding=None, method=None, *, short_empty_elements=True)
- 29 dump(elem)
- 30 parse(source, parser=None)
- 31 iterparse(source, events=None, parser=None)
- 32 XML(text, parser=None)
- 33 XMLID(text, parser=None)
- 34 XML(text, parser=None)
- 35 fromstringlist(sequence, parser=None)
- 类
-
- 36 xml.etree.ElementTree.ParseError
- 37 xml.etree.ElementTree.Element
-
- data
- method
- 5 append()
- 6 clear()
- 7 extend()
- 8 find()
- 9 findall()
- 10 findtext()
- 11 get()
- 12 getchildren()
- 13 getiterator()
- 14 insert()
- 15 items()
- 16 iter()
- 17 iterfind()
- 18 itertext()
- 19 keys()
- 20 makeelement()
- 21 remove()
- 22 set()
- 38 xml.etree.ElementTree.QName
- 39 xml.etree.ElementTree.ElementTree
-
- method
- 1 find()
- 2 findall()
- 3 findtext()
- 4 getiterator()
- 5 getroot()
- 6 iter()
- 7 iterfind()
- 8 parse()
- 9 write()
- 10 write_c14n()
- 40 xml.etree.ElementTree._ListDataStream
-
- method
- 1 seekable()
- 2 tell()
- 3 writable()
- 4 write()
- 41 xml.etree.ElementTree.XMLPullParser
-
- method
- 1 close()
- 2 feed()
- 3 read_events()
- 42 xml.etree.ElementTree.TreeBuilder
-
- method
- 1 close()
- 2 data()
- 3 end()
- 4 start()
- 43 xml.etree.ElementTree.XMLParser
-
- method
- 1 close()
- 2 doctype()
- 3 feed()
- 44 xml.etree.ElementTree.Element
-
- data
- method
- 5 append()
- 6 clear()
- 7 copy()
- 8 extend()
- 9 find()
- 10 findall()
- 11 findtext()
- 12 get()
- 13 getchildren()
- 14 getiterator()
- 15 insert()
- 16 items()
- 17 iter()
- 18 iterfind()
- 19 itertext()
- 20 keys()
- 21 makeelement()
- 22 remove()
- 23 set()
- 内嵌函数或方法
- 私有或局部
- 五(2)【xml.etree.cElementTree】
- 统计
- 常量
-
- str
- 函数
-
- 2 Comment(text=None)
- 3 dump(elem)
- 4 XML(text, parser=None)
- 5 fromstringlist(sequence, parser=None)
- 6 iselement(element)
- 7 iterparse(source, events=None, parser=None)
- 8 parse(source, parser=None)
- 9 ProcessingInstruction(target, text=None)
- 10 ProcessingInstruction(target, text=None)
- 11 tostring(element, encoding=None, method=None, *, short_empty_elements=True)
- 12 tostringlist(element, encoding=None, method=None, *, short_empty_elements=True)
- 13 XML(text, parser=None)
- 14 XMLID(text, parser=None)
- 15 register_namespace(prefix, uri)
- 类
-
- 16 xml.etree.ElementTree.Element
-
- data
- method
- 5 append()
- 6 clear()
- 7 extend()
- 8 find()
- 9 findall()
- 10 findtext()
- 11 get()
- 12 getchildren()
- 13 getiterator()
- 14 insert()
- 15 items()
- 16 iter()
- 17 iterfind()
- 18 itertext()
- 19 keys()
- 20 makeelement()
- 21 remove()
- 22 set()
- 17 xml.etree.ElementTree.ElementTree
-
- method
- 1 find()
- 2 findall()
- 3 findtext()
- 4 getiterator()
- 5 getroot()
- 6 iter()
- 7 iterfind()
- 8 parse()
- 9 write()
- 10 write_c14n()
- 18 xml.etree.ElementTree.ParseError
- 19 xml.etree.ElementTree.QName
- 20 xml.etree.ElementTree.TreeBuilder
-
- method
- 1 close()
- 2 data()
- 3 end()
- 4 start()
- 21 xml.etree.ElementTree.XMLParser
-
- method
- 1 close()
- 2 doctype()
- 3 feed()
- 22 xml.etree.ElementTree.XMLPullParser
-
- method
- 1 close()
- 2 feed()
- 3 read_events()
- 内嵌函数或方法
- 五(3)【xml.etree.ElementInclude】
- 统计
- 常量
-
- str
- 模块
-
- 4 copy
- 5 xml.etree.ElementTree
- 函数
-
- 6 default_loader(href, parse, encoding=None)
- 7 include(elem, loader=None)
- 类
-
- 8 xml.etree.ElementInclude.FatalIncludeError
摘要
全文介绍系统内置 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:
2 CDATA_SECTION_NODE=4 kind:data type:int class:
3 COMMENT_NODE=8 kind:data type:int class:
4 DOCUMENT_FRAGMENT_NODE=11 kind:data type:int class:
5 DOCUMENT_NODE=9 kind:data type:int class:
6 DOCUMENT_TYPE_NODE=10 kind:data type:int class:
7 ELEMENT_NODE=1 kind:data type:int class:
8 ENTITY_NODE=6 kind:data type:int class:
9 ENTITY_REFERENCE_NODE=5 kind:data type:int class:
10 NOTATION_NODE=12 kind:data type:int class:
11 PROCESSING_INSTRUCTION_NODE=7 kind:data type:int class:
12 TEXT_NODE=3 kind:data type:int class:
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:
26 xml.dom.DomstringSizeErr
DomstringSizeErr, xml.dom.DomstringSizeErr, module=xml.dom>
data
1 code=2 kind:data type:int class:
27 xml.dom.HierarchyRequestErr
HierarchyRequestErr, xml.dom.HierarchyRequestErr, module=xml.dom>
data
1 code=3 kind:data type:int class:
28 xml.dom.WrongDocumentErr
WrongDocumentErr, xml.dom.WrongDocumentErr, module=xml.dom>
data
1 code=4 kind:data type:int class:
29 xml.dom.InvalidCharacterErr
InvalidCharacterErr, xml.dom.InvalidCharacterErr, module=xml.dom>
data
1 code=5 kind:data type:int class:
30 xml.dom.NoDataAllowedErr
NoDataAllowedErr, xml.dom.NoDataAllowedErr, module=xml.dom>
data
1 code=6 kind:data type:int class:
31 xml.dom.NoModificationAllowedErr
NoModificationAllowedErr, xml.dom.NoModificationAllowedErr, module=xml.dom>
data
1 code=7 kind:data type:int class:
32 xml.dom.NotFoundErr
NotFoundErr, xml.dom.NotFoundErr, module=xml.dom>
data
1 code=8 kind:data type:int class:
33 xml.dom.NotSupportedErr
NotSupportedErr, xml.dom.NotSupportedErr, module=xml.dom>
data
1 code=9 kind:data type:int class:
34 xml.dom.InuseAttributeErr
InuseAttributeErr, xml.dom.InuseAttributeErr, module=xml.dom>
data
1 code=10 kind:data type:int class:
35 xml.dom.InvalidStateErr
InvalidStateErr, xml.dom.InvalidStateErr, module=xml.dom>
data
1 code=11 kind:data type:int class:
36 xml.dom.SyntaxErr
SyntaxErr, xml.dom.SyntaxErr, module=xml.dom>
data
1 code=12 kind:data type:int class:
37 xml.dom.InvalidModificationErr
InvalidModificationErr, xml.dom.InvalidModificationErr, module=xml.dom>
data
1 code=13 kind:data type:int class:
38 xml.dom.NamespaceErr
NamespaceErr, xml.dom.NamespaceErr, module=xml.dom>
data
1 code=14 kind:data type:int class:
39 xml.dom.InvalidAccessErr
InvalidAccessErr, xml.dom.InvalidAccessErr, module=xml.dom>
data
1 code=15 kind:data type:int class:
40 xml.dom.ValidationErr
ValidationErr, xml.dom.ValidationErr, module=xml.dom>
data
1 code=16 kind:data type:int class:
41 xml.dom.UserDataHandler
UserDataHandler, xml.dom.UserDataHandler, module=xml.dom>
为UserDataHandler.handle()提供操作常量的类。
data
1 NODE_CLONED=1 kind:data type:int class:
2 NODE_DELETED=3 kind:data type:int class:
3 NODE_IMPORTED=2 kind:data type:int class:
4 NODE_RENAMED=4 kind:data type:int class:
剩余
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=)
parse(source, handler, errorHandler=
), module=xml.sax, line:29 at xml\sax_init_.py
8 parseString(string, handler, errorHandler=)
parseString(string, handler, errorHandler=
), 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
20 _false 0
21 _key python.xml.sax.parser
22 _create_parser
五、【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 {‘’:
, ‘*’: , ‘.’: 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:
私有或局部
17 _cache {}
18 _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=
kind:data type:getset_descriptor class:
2 tag=kind:data type:getset_descriptor class:
3 tail=kind:data type:getset_descriptor class:
4 text=kind:data type:getset_descriptor class:
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*是作为关键字参数给出的额外元素属性。
表单示例:text tail
data
1 attrib=None kind:data type:NoneType class:
2 tag=None kind:data type:NoneType class:
3 tail=None kind:data type:NoneType class:
4 text=None kind:data type:NoneType class:
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
47 _namespaces
48 _serialize_xml
49 _serialize_html
50 _serialize_text
51 _serialize {‘xml’:, ‘html’: , '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
54 _escape_cdata
55 _escape_attrib
56 _escape_attrib_html
57 _ListDataStream
58 _sentinel [‘sentinel’]
59 _Element_Py
五(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=
kind:data type:getset_descriptor class:
2 tag=kind:data type:getset_descriptor class:
3 tail=kind:data type:getset_descriptor class:
4 text=kind:data type:getset_descriptor class:
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