本文由 大侠(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, 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 |
dom, fullname=xml.dom, file=xml\dom_init_.py
Python的W3C文档对象模型实现。
文档对象模型的Python映射在Python库参考中xml.dom包的部分有详细的说明。
这个包包含以下模块:
minidom—添加了名称空间支持的1级DOM的简单实现(基于2级规范)和其他次要的2级功能。
pulldom—DOM构建器,支持按需为文档的选定子树构建树。
parsers, fullname=xml.parsers, file=xml\parsers_init_.py
Python接口到XML解析器。
这个包包含一个模块:
expat -用于James Clark的expat解析器的Python包装器,支持命名空间。
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解析器的驱动程序。
etree, fullname=xml.etree, file=xml\etree_init_.py
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 |
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
17 XML_NAMESPACE
18 XMLNS_NAMESPACE
19 XHTML_NAMESPACE
domreg, fullname=xml.dom.domreg, file=xml\dom\domreg.py
DOM的注册工具。
不应直接使用此模块。而是应从xml.dom中导入函数 getDOMImplementation 和 registerDOMImplementation 。
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)对序列。
registerDOMImplementation(name, factory), module=xml.dom.domreg, line:21 at xml\dom\domreg.py
用名称注册工厂函数。
工厂函数应该返回一个实现DOMImplementation接口的对象。
工厂函数可以返回相同的对象,也可以返回一个新的对象(例如,如果该实现支持一些自定义)。
Node, xml.dom.Node, module=xml.dom>
类提供NodeType常量。
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:
DOMException, xml.dom.DOMException, module=xml.dom>
DOM异常的抽象基类。具有特定代码的异常是该类的专门化。
IndexSizeErr, xml.dom.IndexSizeErr, module=xml.dom>
1 code=1 kind:data type:int class:
DomstringSizeErr, xml.dom.DomstringSizeErr, module=xml.dom>
1 code=2 kind:data type:int class:
HierarchyRequestErr, xml.dom.HierarchyRequestErr, module=xml.dom>
1 code=3 kind:data type:int class:
WrongDocumentErr, xml.dom.WrongDocumentErr, module=xml.dom>
1 code=4 kind:data type:int class:
InvalidCharacterErr, xml.dom.InvalidCharacterErr, module=xml.dom>
1 code=5 kind:data type:int class:
NoDataAllowedErr, xml.dom.NoDataAllowedErr, module=xml.dom>
1 code=6 kind:data type:int class:
NoModificationAllowedErr, xml.dom.NoModificationAllowedErr, module=xml.dom>
1 code=7 kind:data type:int class:
NotFoundErr, xml.dom.NotFoundErr, module=xml.dom>
1 code=8 kind:data type:int class:
NotSupportedErr, xml.dom.NotSupportedErr, module=xml.dom>
1 code=9 kind:data type:int class:
InuseAttributeErr, xml.dom.InuseAttributeErr, module=xml.dom>
1 code=10 kind:data type:int class:
InvalidStateErr, xml.dom.InvalidStateErr, module=xml.dom>
1 code=11 kind:data type:int class:
SyntaxErr, xml.dom.SyntaxErr, module=xml.dom>
1 code=12 kind:data type:int class:
InvalidModificationErr, xml.dom.InvalidModificationErr, module=xml.dom>
1 code=13 kind:data type:int class:
NamespaceErr, xml.dom.NamespaceErr, module=xml.dom>
1 code=14 kind:data type:int class:
InvalidAccessErr, xml.dom.InvalidAccessErr, module=xml.dom>
1 code=15 kind:data type:int class:
ValidationErr, xml.dom.ValidationErr, module=xml.dom>
1 code=16 kind:data type:int class:
UserDataHandler, xml.dom.UserDataHandler, module=xml.dom>
为UserDataHandler.handle()提供操作常量的类。
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
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 |
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 |
1 _false 0
2 _key python.xml.sax.parser
3 default_parser_list [‘xml.sax.expatreader’]
handler, fullname=xml.sax.handler, file=xml\sax\handler.py
此模块包含SAX for Python 2.0版本的核心类。
这个文件只提供了具有绝对最小功能的默认类,驱动程序和应用程序可以从这些类中子类化。
其中许多类是空的,仅作为接口的文档包含。
_exceptions, fullname=xml.sax._exceptions, file=xml\sax_exceptions.py
不同类型的SAX异常
xmlreader, fullname=xml.sax.xmlreader, file=xml\sax\xmlreader.py
XML Reader是XML解析器的SAX 2名称。XML解析器应该基于此代码。
parse(source, handler, errorHandler=
), module=xml.sax, line:29 at xml\sax_init_.py
parseString(string, handler, errorHandler=
), module=xml.sax, line:35 at xml\sax_init_.py
make_parser(parser_list=[]), module=xml.sax, line:70 at xml\sax_init_.py
创建并返回SAX解析器。
创建第一个解析器,它能够实例化通过做解析器列表+默认解析器列表创建的列表中给出的解析器。
列表必须包含包含SAX解析器和创建解析器函数的Python模块的名称。
create_parser(parser_name), module=xml.sax, line:103 at xml\sax_init.py
InputSource, xml.sax.xmlreader.InputSource, module=xml.sax.xmlreader>
XMLReader读取实体所需的信息的封装。
该类可以包括关于公共标识符、系统标识符、字节流(可能带有字符编码信息)和/或实体的字符流的信息。
应用程序将创建该类的对象,以便在XMLReader中使用。
方法和用于从EntityResolver.resolveEntity返回。
InputSource属于应用程序,XMLReader不允许修改从应用程序传递给它的InputSource对象,尽管它可以复制并修改这些对象。
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的系统标识符。
ContentHandler, xml.sax.handler.ContentHandler, module=xml.sax.handler>
接收逻辑文档内容事件的接口。
这是SAX中的主要回调接口,也是对应用程序最重要的接口。
此接口中的事件顺序反映了文档中信息的顺序。
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事件之后,但它们的顺序不保证。
ErrorHandler, xml.sax.handler.ErrorHandler, module=xml.sax.handler>
SAX错误处理程序的基本接口。
如果创建了实现此接口的对象,然后将该对象注册到XMLReader中,解析器将调用对象中的方法以报告所有警告和错误。
有三种级别的错误可用:警告、(可能的)可恢复错误和不可恢复错误。所有方法都将SAXParseException作为唯一参数。
1 error()
kind=method class=ErrorHandler objtype=function
处理一个可恢复的错误。
2 fatalError()
kind=method class=ErrorHandler objtype=function
处理一个不可恢复的错误。
3 warning()
kind=method class=ErrorHandler objtype=function
处理警告。
SAXException, xml.sax._exceptions.SAXException, module=xml.sax._exceptions>
封装XML错误或警告。
该类可以包含来自XML解析器或应用程序的基本错误或警告信息:您可以对其进行子类化,以提供额外的功能或添加本地化。
注意,尽管您将接收SAXException作为ErrorHandler接口中处理程序的参数,但实际上并不需要引发异常;相反,您可以简单地阅读其中的信息。
1 getException()
kind=method class=SAXException objtype=function
返回嵌入的异常,如果没有则返回None。
2 getMessage()
kind=method class=SAXException objtype=function
返回此异常的消息。
SAXNotRecognizedException, xml.sax._exceptions.SAXNotRecognizedException, module=xml.sax._exceptions>
无法识别的标识符的异常类。
XMLReader在遇到无法识别的特性或属性时将引发此异常。SAX应用程序和扩展可以出于类似的目的使用该类。
SAXParseException, xml.sax._exceptions.SAXParseException, module=xml.sax._exceptions>
封装XML解析错误或警告。
此异常将包括在原始XML文档中定位错误的信息。
注意,尽管应用程序将接收SAXParseException作为ErrorHandler接口中处理程序的参数,但应用程序实际上并不需要引发异常;
相反,它可以简单地读取其中的信息并采取不同的操作。
因为这个异常是SAXException的子类,所以它继承了包装另一个异常的能力。
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
获取发生异常的实体的系统标识符。
SAXNotSupportedException, xml.sax._exceptions.SAXNotSupportedException, module=xml.sax._exceptions>
不支持操作的异常类。
当请求无法执行的服务时(特别是设置状态或值),XMLReader将引发此异常。
SAX应用程序和扩展可以出于类似的目的使用该类。
SAXReaderNotAvailable, xml.sax._exceptions.SAXReaderNotAvailable, module=xml.sax._exceptions>
缺少驱动程序的异常类。
XMLReader模块(驱动程序)在第一次导入时应该引发此异常,例如当支持模块不能导入时。
它也可能在解析过程中被引发,例如,如果不允许执行外部程序。
19 _exceptions
20 _false 0
21 _key python.xml.sax.parser
22 _create_parser
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 |
ElementPath, fullname=xml.etree.ElementPath, file=xml\etree\ElementPath.py
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进行转换。
cElementTree, fullname=xml.etree.cElementTree, file=xml\etree\cElementTree.py
ElementInclude, fullname=xml.etree.ElementInclude, file=xml\etree\ElementInclude.py
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 |
1 ops {‘’:
, ‘*’: , ‘.’: 2 _cache {}
re, fullname=re, file=re.py
xpath_tokenizer(pattern, namespaces=None), module=xml.etree.ElementPath, line:73 at xml\etree\ElementPath.py
get_parent_map(context), module=xml.etree.ElementPath, line:87 at xml\etree\ElementPath.py
prepare_child(next, token), module=xml.etree.ElementPath, line:96 at xml\etree\ElementPath.py
prepare_star(next, token), module=xml.etree.ElementPath, line:105 at xml\etree\ElementPath.py
prepare_self(next, token), module=xml.etree.ElementPath, line:111 at xml\etree\ElementPath.py
prepare_descendant(next, token), module=xml.etree.ElementPath, line:116 at xml\etree\ElementPath.py
prepare_parent(next, token), module=xml.etree.ElementPath, line:134 at xml\etree\ElementPath.py
prepare_predicate(next, token), module=xml.etree.ElementPath, line:147 at xml\etree\ElementPath.py
iterfind(elem, path, namespaces=None), module=xml.etree.ElementPath, line:265 at xml\etree\ElementPath.py
find(elem, path, namespaces=None), module=xml.etree.ElementPath, line:306 at xml\etree\ElementPath.py
findall(elem, path, namespaces=None), module=xml.etree.ElementPath, line:312 at xml\etree\ElementPath.py
findtext(elem, path, default=None, namespaces=None), module=xml.etree.ElementPath, line:318 at xml\etree\ElementPath.py
_SelectorContext, xml.etree.ElementPath._SelectorContext, module=xml.etree.ElementPath
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+')
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.』
Comment(text=None), module=xml.etree.ElementTree, line:462 at xml\etree\ElementTree.py
注释元素工厂。
此函数创建一个特殊元素,标准序列化器将其序列化为XML注释。
*text*是一个包含注释字符串的字符串。
ProcessingInstruction(target, text=None), module=xml.etree.ElementTree, line:476 at xml\etree\ElementTree.py
加工指令元件工厂。
此函数创建一个特殊元素,标准序列化器将其序列化为XML注释。
*target*是包含处理指令的字符串,
*text*是包含处理指令内容(如果有的话)的字符串。
ProcessingInstruction(target, text=None), module=xml.etree.ElementTree, line:476 at xml\etree\ElementTree.py
加工指令元件工厂。
此函数创建一个特殊元素,标准序列化器将其序列化为XML注释。
*target*是包含处理指令的字符串,
*text*是包含处理指令内容(如果有的话)的字符串。
_get_writer(file_or_filename, encoding), module=xml.etree.ElementTree, line:237 at contextlib.py
_namespaces(elem, default_namespace=None), module=xml.etree.ElementTree, line:838 at xml\etree\ElementTree.py
_serialize_xml(write, elem, qnames, namespaces, short_empty_elements, **kwargs), module=xml.etree.ElementTree, line:899 at xml\etree\ElementTree.py
_serialize_html(write, elem, qnames, namespaces, **kwargs), module=xml.etree.ElementTree, line:957 at xml\etree\ElementTree.py
_serialize_text(write, elem), module=xml.etree.ElementTree, line:1007 at xml\etree\ElementTree.py
register_namespace(prefix, uri), module=xml.etree.ElementTree, line:1022 at xml\etree\ElementTree.py
注册命名空间前缀。
注册表是全局的,给定前缀或名称空间URI的任何现有映射都将被删除。
*prefix*是命名空间前缀,
*uri*是命名空间uri。
如果可能的话,这个名称空间中的标记和属性将使用前缀序列化。
如果前缀被保留或无效,则引发ValueError。
_raise_serialization_error(text), module=xml.etree.ElementTree, line:1056 at xml\etree\ElementTree.py
_escape_cdata(text), module=xml.etree.ElementTree, line:1061 at xml\etree\ElementTree.py
_escape_attrib(text), module=xml.etree.ElementTree, line:1077 at xml\etree\ElementTree.py
_escape_attrib_html(text), module=xml.etree.ElementTree, line:1105 at xml\etree\ElementTree.py
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数据的编码字符串(可选)。
tostringlist(element, encoding=None, method=None, *, short_empty_elements=True), module=xml.etree.ElementTree, line:1156 at xml\etree\ElementTree.py
dump(elem), module=xml.etree.ElementTree, line:1165 at xml\etree\ElementTree.py
将元素树或元素结构写入sys.stdout。
此函数应仅用于调试。*elem*要么是一个元素树,要么是一个单独的元素。
确切的输出格式取决于实现。在这个版本中,它被编写为普通的XML文件。
parse(source, parser=None), module=xml.etree.ElementTree, line:1187 at xml\etree\ElementTree.py
将XML文档解析为元素树。
*source*是一个包含XML数据的文件名或文件对象,
*parser*是一个默认为XMLParser的可选解析器实例。
返回一个ElementTree实例。
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)对的迭代器。
XML(text, parser=None), module=xml.etree.ElementTree, line:1302 at xml\etree\ElementTree.py
从字符串常量解析XML文档。此函数可用于在Python代码中嵌入“XML字面量”。
*text*是一个包含XML数据的字符串,
*parser*是一个可选的解析器实例,默认为标准XMLParser。返回一个Element实例。
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映射到元素。
XML(text, parser=None), module=xml.etree.ElementTree, line:1302 at xml\etree\ElementTree.py
从字符串常量解析XML文档。此函数可用于在Python代码中嵌入“XML字面量”。
*text*是一个包含XML数据的字符串,
*parser*是一个可选的解析器实例,默认为标准XMLParser。
返回一个Element实例。
fromstringlist(sequence, parser=None), module=xml.etree.ElementTree, line:1343 at xml\etree\ElementTree.py
从字符串片段序列解析XML文档。
*sequence*是其他序列的列表,
*parser*是可选的解析器实例,默认为标准XMLParser。
返回一个Element实例。
ParseError, xml.etree.ElementTree.ParseError, module=xml.etree.ElementTree
Element, xml.etree.ElementTree.Element, module=xml.etree.ElementTree
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:
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
QName, xml.etree.ElementTree.QName, module=xml.etree.ElementTree
限定的名称包装器。
该类可用于包装QName属性值,以便在输出时获得适当的名称空间处理。
*text或uri*是以{uri}local形式包含QName值的字符串,如果给出了tag参数,则包含QName的uri部分。
*tag*是一个可选参数,如果给出它,将使第一个参数(text或uri)被解释为uri,而这个参数(标签)被解释为本地名称。
ElementTree, xml.etree.ElementTree.ElementTree, module=xml.etree.ElementTree
XML元素层次结构。
该类还提供了与标准XML之间的序列化支持。
*element*是可选的根元素节点,
*file*是可选的XML文件句柄或文件名,其内容将用于初始化树。
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
_ListDataStream, xml.etree.ElementTree._ListDataStream, module=xml.etree.ElementTree
累积到列表引用中的辅助流。
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
XMLPullParser, xml.etree.ElementTree.XMLPullParser, module=xml.etree.ElementTree
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)对的迭代器。
从迭代器检索事件时,从内部事件队列中消费事件。
TreeBuilder, xml.etree.ElementTree.TreeBuilder, module=xml.etree.ElementTree
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
XMLParser, xml.etree.ElementTree.XMLParser, module=xml.etree.ElementTree
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
Element, xml.etree.ElementTree.Element, module=xml.etree.ElementTree
一个XML元素。
该类是Element接口的参考实现。
一个元素的长度是它的子元素的数目。
这意味着如果你想检查一个元素是否真的为空,你应该同时检查它的长度和它的文本属性。
元素标记、属性名和属性值可以是字节或字符串。
*tag*是元素名称。
*attrib*是一个包含元素属性的可选字典。
*extra*是作为关键字参数给出的额外元素属性。
表单示例:text ... tail
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:
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
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 |
1 VERSION 1.3.0
Comment(text=None), module=xml.etree.ElementTree, line:462 at xml\etree\ElementTree.py
注释元素工厂。此函数创建一个特殊元素,标准序列化器将其序列化为XML注释。
*text*是一个包含注释字符串的字符串。
dump(elem), module=xml.etree.ElementTree, line:1165 at xml\etree\ElementTree.py
将元素树或元素结构写入sys.stdout。
此函数应仅用于调试。
*elem*要么是一个元素树,要么是一个单独的元素。
确切的输出格式取决于实现。在这个版本中,它被编写为普通的XML文件。
XML(text, parser=None), module=xml.etree.ElementTree, line:1302 at xml\etree\ElementTree.py
从字符串常量解析XML文档。
此函数可用于在Python代码中嵌入“XML字面量”。
*text*是一个包含XML数据的字符串,
*parser*是一个可选的解析器实例,默认为标准XMLParser。
返回一个Element实例。
fromstringlist(sequence, parser=None), module=xml.etree.ElementTree, line:1343 at xml\etree\ElementTree.py
从字符串片段序列解析XML文档。
*sequence*是其他序列的列表,
*parser*是可选的解析器实例,默认为标准XMLParser。
返回一个Element实例。
iselement(element), module=xml.etree.ElementTree, line:119 at xml\etree\ElementTree.py
如果*element*是一个element,则返回True。
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)对的迭代器。
parse(source, parser=None), module=xml.etree.ElementTree, line:1187 at xml\etree\ElementTree.py
将XML文档解析为元素树。
*source*是一个包含XML数据的文件名或文件对象,
*parser*是一个默认为XMLParser的可选解析器实例。
返回一个ElementTree实例。
ProcessingInstruction(target, text=None), module=xml.etree.ElementTree, line:476 at xml\etree\ElementTree.py
加工指令元件工厂。
此函数创建一个特殊元素,标准序列化器将其序列化为XML注释。
*target*是包含处理指令的字符串,
*text*是包含处理指令内容(如果有的话)的字符串。
ProcessingInstruction(target, text=None), module=xml.etree.ElementTree, line:476 at xml\etree\ElementTree.py
加工指令元件工厂。
此函数创建一个特殊元素,标准序列化器将其序列化为XML注释。
*target*是包含处理指令的字符串,
*text*是包含处理指令内容(如果有的话)的字符串。
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数据的编码字符串(可选)。
tostringlist(element, encoding=None, method=None, *, short_empty_elements=True), module=xml.etree.ElementTree, line:1156 at xml\etree\ElementTree.py
XML(text, parser=None), module=xml.etree.ElementTree, line:1302 at xml\etree\ElementTree.py
从字符串常量解析XML文档。
此函数可用于在Python代码中嵌入“XML字面量”。
*text*是一个包含XML数据的字符串,
*parser*是一个可选的解析器实例,默认为标准XMLParser。
返回一个Element实例。
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映射到元素。
register_namespace(prefix, uri), module=xml.etree.ElementTree, line:1022 at xml\etree\ElementTree.py
注册命名空间前缀。
注册表是全局的,给定前缀或名称空间URI的任何现有映射都将被删除。
*prefix*是命名空间前缀,
*uri*是命名空间uri。
如果可能的话,这个名称空间中的标记和属性将使用前缀序列化。
如果前缀被保留或无效,则引发ValueError。
Element, xml.etree.ElementTree.Element, module=xml.etree.ElementTree
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:
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
ElementTree, xml.etree.ElementTree.ElementTree, module=xml.etree.ElementTree
XML元素层次结构。
该类还提供了与标准XML之间的序列化支持。
*element*是可选的根元素节点,
*file*是可选的XML文件句柄或文件名,其内容将用于初始化树。
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
ParseError, xml.etree.ElementTree.ParseError, module=xml.etree.ElementTree
QName, xml.etree.ElementTree.QName, module=xml.etree.ElementTree
限定的名称包装器。
该类可用于包装QName属性值,以便在输出时获得适当的名称空间处理。
*text或uri*是以{uri}local形式包含QName值的字符串,如果给出了tag参数,则包含QName的uri部分。
*tag*是一个可选参数,如果给出它,将使第一个参数(text或uri)被解释为uri,而这个参数(标签)被解释为本地名称。
TreeBuilder, xml.etree.ElementTree.TreeBuilder, module=xml.etree.ElementTree
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
XMLParser, xml.etree.ElementTree.XMLParser, module=xml.etree.ElementTree
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
XMLPullParser, xml.etree.ElementTree.XMLPullParser, module=xml.etree.ElementTree
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
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 |
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
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
ElementTree, fullname=xml.etree.ElementTree, file=xml\etree\ElementTree.py
default_loader(href, parse, encoding=None), module=xml.etree.ElementInclude, line:77 at xml\etree\ElementInclude.py
include(elem, loader=None), module=xml.etree.ElementInclude, line:99 at xml\etree\ElementInclude.py
FatalIncludeError, xml.etree.ElementInclude.FatalIncludeError, module=xml.etree.ElementInclude