sqltriples.Types.URIRef

Package sqltriples :: Module Types :: Class URIRef |
[show private | hide private]
[frames | no frames]

## Type URIRef

    object --+
             |
    basestring --+
                 |
           unicode --+
                     |
               Special --+
                         |
                        URIRef

Known Subclasses:
  `Namespace`

An URI reference compatible with the rdflib class of the same name.

Method Summary
Inherited from Special
| ``__repr__`(self)`
Inherited from unicode
| ``__add__`(x, y)` x.__add__(y) <==> x+y
| ``__cmp__`(x, y)` x.__cmp__(y) <==> cmp(x,y)
| ``__contains__`(x, y)` x.__contains__(y) <==> y in x
| ``__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.
| ``__hash__`(x)` x.__hash__() <==> hash(x)
| ``__len__`(x)` x.__len__() <==> len(x)
| ``__mod__`(x, y)` x.__mod__(y) <==> x%y
| ``__mul__`(x, n)` x.__mul__(n) <==> x*n
| ``__new__`(T, S, ...)` T.__new__(S, ...) -> a new object with type S, a subtype of T
| ``__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 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.
| ``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.
| ``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

Generated by Epydoc 2.1 on Sat Sep 30 00:54:36 2006 | http://epydoc.sf.net