GNU Info

(python2.1-lib.info)Node Objects

---

Next: NodeList Objects Prev: DOMImplementation Objects Up: Objects in the DOM

---

Enter node , (file) or (file)node

Node Objects
............

All of the components of an XML document are subclasses of `Node'.

`nodeType'
     An integer representing the node type.  Symbolic constants for the
     types are on the `Node' object: `ELEMENT_NODE', `ATTRIBUTE_NODE',
     `TEXT_NODE', `CDATA_SECTION_NODE', `ENTITY_NODE',
     `PROCESSING_INSTRUCTION_NODE', `COMMENT_NODE', `DOCUMENT_NODE',
     `DOCUMENT_TYPE_NODE', `NOTATION_NODE'.  This is a read-only
     attribute.

`parentNode'
     The parent of the current node, or `None' for the document node.
     The value is always a `Node' object or `None'.  For `Element'
     nodes, this will be the parent element, except for the root
     element, in which case it will be the `Document' object.  For
     `Attr' nodes, this is always `None'.  This is a read-only
     attribute.

`attributes'
     A `NamedNodeMap' of attribute objects.  Only elements have actual
     values for this; others provide `None' for this attribute.  This
     is a read-only attribute.

`previousSibling'
     The node that immediately precedes this one with the same parent.
     For instance the element with an end-tag that comes just before the
     SELF element's start-tag.  Of course, XML documents are made up of
     more than just elements so the previous sibling could be text, a
     comment, or something else.  If this node is the first child of the
     parent, this attribute will be `None'.  This is a read-only
     attribute.

`nextSibling'
     The node that immediately follows this one with the same parent.
     See also `previousSibling'.  If this is the last child of the
     parent, this attribute will be `None'.  This is a read-only
     attribute.

`childNodes'
     A list of nodes contained within this node.  This is a read-only
     attribute.

`firstChild'
     The first child of the node, if there are any, or `None'.  This is
     a read-only attribute.

`lastChild'
     The last child of the node, if there are any, or `None'.  This is
     a read-only attribute.

`localName'
     The part of the `tagName' following the colon if there is one,
     else the entire `tagName'.  The value is a string.

`prefix'
     The part of the `tagName' preceding the colon if there is one,
     else the empty string.  The value is a string, or `None'

`namespaceURI'
     The namespace associated with the element name.  This will be a
     string or `None'.  This is a read-only attribute.

`nodeName'
     This has a different meaning for each node type; see the DOM
     specification for details.  You can always get the information you
     would get here from another property such as the `tagName'
     property for elements or the `name' property for attributes.  For
     all node types, the value of this attribute will be either a
     string or `None'.  This is a read-only attribute.

`nodeValue'
     This has a different meaning for each node type; see the DOM
     specification for details.  The situation is similar to that with
     `nodeName'.  The value is a string or `None'.

`hasAttributes()'
     Returns true if the node has any attributes.

`hasChildNodes()'
     Returns true if the node has any child nodes.

`isSameNode(other)'
     Returns true if OTHER refers to the same node as this node.  This
     is especially useful for DOM implementations which use any sort of
     proxy architecture (because more than one object can refer to the
     same node).

     *Note:*  This is based on a proposed DOM Level 3 API which is
     still in the "working draft" stage, but this particular interface
     appears uncontroversial.  Changes from the W3C will not necessarily
     affect this method in the Python DOM interface (though any new W3C
     API for this would also be supported).

`appendChild(newChild)'
     Add a new child node to this node at the end of the list of
     children, returning NEWCHILD.

`insertBefore(newChild, refChild)'
     Insert a new child node before an existing child.  It must be the
     case that REFCHILD is a child of this node; if not, `ValueError'
     is raised.  NEWCHILD is returned.

`removeChild(oldChild)'
     Remove a child node.  OLDCHILD must be a child of this node; if
     not, `ValueError' is raised.  OLDCHILD is returned on success.  If
     OLDCHILD will not be used further, its `unlink()' method should be
     called.

`replaceChild(newChild, oldChild)'
     Replace an existing node with a new node. It must be the case that
     OLDCHILD is a child of this node; if not, `ValueError' is raised.

`normalize()'
     Join adjacent text nodes so that all stretches of text are stored
     as single `Text' instances.  This simplifies processing text from a
     DOM tree for many applications.  _Added in Python version 2.1_

`cloneNode(deep)'
     Clone this node.  Setting DEEP means to clone all child nodes as
     well.  This returns the clone.