lxml.html.diff.tag

Package lxml :: Package html :: Module diff :: Class tag_token

[show private | hide private]

Type tag_token

object --+            
         |            
basestring --+        
             |        
       unicode --+    
                 |    
             token --+
                     |
                    tag_token

Represents a token that is actually a tag. Currently this is just the <img> tag, which takes up visible space just like a word but is only represented in a document by a tag.

Method Summary
	`__new__(cls, tag, data, html_repr, pre_tags, post_tags, trailing_whitespace)` (Static method)
	`__repr__(self)`
	`html(self)`
Inherited from unicode
	`__add__(x, y)` x.__add__(y) <==> x+y
	`__contains__(x, y)` x.__contains__(y) <==> y in x
	`__eq__(x, y)` x.__eq__(y) <==> x==y
	`__ge__(x, y)` x.__ge__(y) <==> x>=y
	`__getattribute__(...)` x.__getattribute__('name') <==> x.name
	`__getitem__(x, y)` x.__getitem__(y) <==> x[y]
	`__getnewargs__(...)`
	`__getslice__(x, i, j)` Use of negative indices is not supported.
	`__gt__(x, y)` x.__gt__(y) <==> x>y
	`__hash__(x)` x.__hash__() <==> hash(x)
	`__le__(x, y)` x.__le__(y) <==> x<=y
	`__len__(x)` x.__len__() <==> len(x)
	`__lt__(x, y)` x.__lt__(y) <==> x<y
	`__mod__(x, y)` x.__mod__(y) <==> x%y
	`__mul__(x, n)` x.__mul__(n) <==> x*n
	`__ne__(x, y)` x.__ne__(y) <==> x!=y
	`__rmod__(x, y)` x.__rmod__(y) <==> y%x
	`__rmul__(x, n)` x.__rmul__(n) <==> n*x
	`__str__(x)` x.__str__() <==> str(x)
	`capitalize(S)` Return a capitalized version of S, i.e.
	`center(S, width, fillchar)` Return S centered in a Unicode string of length width.
	`count(S, sub, start, end)` Return the number of non-overlapping occurrences of substring sub in Unicode string S[start:end].
	`decode(S, encoding, errors)` Decodes S using the codec registered for encoding.
	`encode(S, encoding, errors)` Encodes S using the codec registered for encoding.
	`endswith(S, suffix, start, end)` Return True if S ends with the specified suffix, False otherwise.
	`expandtabs(S, tabsize)` Return a copy of S where all tab characters are expanded using spaces.
	`find(S, sub, start, end)` Return the lowest index in S where substring sub is found, such that sub is contained within s[start,end].
	`index(S, sub, start, end)` Like S.find() but raise ValueError when the substring is not found.
	`isalnum(S)` Return True if all characters in S are alphanumeric and there is at least one character in S, False otherwise.
	`isalpha(S)` Return True if all characters in S are alphabetic and there is at least one character in S, False otherwise.
	`isdecimal(S)` Return True if there are only decimal characters in S, False otherwise.
	`isdigit(S)` Return True if all characters in S are digits and there is at least one character in S, False otherwise.
	`islower(S)` Return True if all cased characters in S are lowercase and there is at least one cased character in S, False otherwise.
	`isnumeric(S)` Return True if there are only numeric characters in S, False otherwise.
	`isspace(S)` Return True if all characters in S are whitespace and there is at least one character in S, False otherwise.
	`istitle(S)` Return True if S is a titlecased string and there is at least one character in S, i.e.
	`isupper(S)` Return True if all cased characters in S are uppercase and there is at least one cased character in S, False otherwise.
	`join(S, sequence)` Return a string which is the concatenation of the strings in the sequence.
	`ljust(S, width, fillchar)` Return S left justified in a Unicode string of length width.
	`lower(S)` Return a copy of the string S converted to lowercase.
	`lstrip(S, chars)` Return a copy of the string S with leading whitespace removed.
	`partition(S, sep)` Searches for the separator sep in S, and returns the part before it, the separator itself, and the part after it.
	`replace(...)` S.replace (old, new[, maxsplit]) -> unicode
	`rfind(S, sub, start, end)` Return the highest index in S where substring sub is found, such that sub is contained within s[start,end].
	`rindex(S, sub, start, end)` Like S.rfind() but raise ValueError when the substring is not found.
	`rjust(S, width, fillchar)` Return S right justified in a Unicode string of length width.
	`rpartition(S, sep)` Searches for the separator sep in S, starting at the end of S, and returns the part before it, the separator itself, and the part after it.
	`rsplit(S, sep, maxsplit)` Return a list of the words in S, using sep as the delimiter string, starting at the end of the string and working to the front.
	`rstrip(S, chars)` Return a copy of the string S with trailing whitespace removed.
	`split(S, sep, maxsplit)` Return a list of the words in S, using sep as the delimiter string.
	`splitlines(...)` S.splitlines([keepends]]) -> list of strings
	`startswith(S, prefix, start, end)` Return True if S starts with the specified prefix, False otherwise.
	`strip(S, chars)` Return a copy of the string S with leading and trailing whitespace removed.
	`swapcase(S)` Return a copy of S with uppercase characters converted to lowercase and vice versa.
	`title(S)` Return a titlecased version of S, i.e.
	`translate(S, table)` Return a copy of the string S, where all characters have been mapped through the given translation table, which must be a mapping of Unicode ordinals to Unicode ordinals, Unicode strings or None.
	`upper(S)` Return a copy of S converted to uppercase.
	`zfill(S, width)` Pad a numeric string x with zeros on the left, to fill a field of the specified width.
Inherited from object
	`__init__(...)` x.__init__(...) initializes x; see x.__class__.__doc__ for signature
	`__delattr__(...)` x.__delattr__('name') <==> del x.name
	`__reduce__(...)` helper for pickle
	`__reduce_ex__(...)` helper for pickle
	`__setattr__(...)` x.__setattr__('name', value) <==> x.name = value

Class Variable Summary
Inherited from token
`bool`	`hide_when_equal` = `False`

Generated by Epydoc 2.1 on Sat Aug 18 12:44:28 2007

http://epydoc.sf.net