__builtin__.list

Module __builtin__ :: Class list |
[show private | hide private]
[frames | no frames]

## Type list

    object --+
             |
            list

Known Subclasses:
  `Histogram`, `Histogram`, `Histogram`, `Histogram`, `Monitor`, `Monitor`, `Monitor`, `Monitor`, `Queue`, `Queue`, `Queue`, `Queue`

list() -> new list list(sequence) -> new list initialized from sequence's items

Method Summary
| ``__init__`(...)` x.__init__(...) initializes x; see x.__class__.__doc__ for signature
| ``__add__`(x, y)` x.__add__(y) <==> x+y
| ``__contains__`(x, y)` x.__contains__(y) <==> y in x
| ``__delitem__`(x, y)` x.__delitem__(y) <==> del x[y]
| ``__delslice__`(x, i, j)` Use of negative indices is not supported.
| ``__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]
| ``__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)
| ``__iadd__`(x, y)` x.__iadd__(y) <==> x+=y
| ``__imul__`(x, y)` x.__imul__(y) <==> x*=y
| ``__iter__`(x)` x.__iter__() <==> iter(x)
| ``__le__`(x, y)` x.__le__(y) <==> x<=y
| ``__len__`(x)` x.__len__() <==> len(x)
| ``__lt__`(x, y)` x.__lt__(y) <==> x<y
| ``__mul__`(x, n)` x.__mul__(n) <==> x*n
| ``__ne__`(x, y)` x.__ne__(y) <==> x!=y
| ``__new__`(T, S, ...)` T.__new__(S, ...) -> a new object with type S, a subtype of T
| ``__repr__`(x)` x.__repr__() <==> repr(x)
| ``__rmul__`(x, n)` x.__rmul__(n) <==> n*x
| ``__setitem__`(x, i, y)` x.__setitem__(i, y) <==> x[i]=y
| ``__setslice__`(x, i, j, y)` Use of negative indices is not supported.
| ``append`(...)` L.append(object) -- append object to end
| ``count`(L, value)` L.count(value) -> integer -- return number of occurrences of value
| ``extend`(...)` L.extend(iterable) -- extend list by appending elements from the iterable
| ``index`(...)` L.index(value, [start, [stop]]) -> integer -- return first index of value
| ``insert`(...)` L.insert(index, object) -- insert object before index
| ``pop`(L, index)` L.pop([index]) -> item -- remove and return item at index (default last)
| ``remove`(...)` L.remove(value) -- remove first occurrence of value
| ``reverse`(...)` L.reverse() -- reverse *IN PLACE*
| ``sort`(...)` L.sort(cmpfunc=None) -- stable sort *IN PLACE*; cmpfunc(x, y) -> -1, 0, 1
Inherited from object
| ``__delattr__`(...)` x.__delattr__('name') <==> del x.name
| ``__reduce__`(...)` helper for pickle
| ``__reduce_ex__`(...)` helper for pickle
| ``__setattr__`(...)` x.__setattr__('name', value) <==> x.name = value
| ``__str__`(x)` x.__str__() <==> str(x)

Method Details

### __init__(...) (Constructor) x.__init__(...) initializes x; see x.__class__.__doc__ for signature Overrides: `__builtin__.object.__init__`

    ### __add__(x, y) (Addition operator) x.__add__(y) <==> x+y Returns:
        x+y

    ### __contains__(x, y) (In operator) x.__contains__(y) <==> y in x Returns:
        y in x

    ### __delitem__(x, y) (Index deletion operator) x.__delitem__(y) <==> del x[y] Returns:
        del x[y]

    ### __delslice__(x, i, j) (Slice deletion operator) Use of negative indices is not supported. Returns:
        del x[i:j]

    ### __eq__(x, y) (Equality operator) x.__eq__(y) <==> x==y Returns:
        x==y

    ### __ge__(x, y) (Greater-than-or-equals operator) x.__ge__(y) <==> x>=y Returns:
        x>=y

### __getattribute__(...) x.__getattribute__('name') <==> x.name Overrides: `__builtin__.object.__getattribute__`

    ### __getitem__(x, y) (Indexing operator) x.__getitem__(y) <==> x[y] Returns:
        x[y]

    ### __getslice__(x, i, j) (Slicling operator) Use of negative indices is not supported. Returns:
        x[i:j]

    ### __gt__(x, y) (Greater-than operator) x.__gt__(y) <==> x>y Returns:
        x>y

    ### __hash__(x) (Hashing function) x.__hash__() <==> hash(x) Returns:
        hash(x)
Overrides: `__builtin__.object.__hash__`

    ### __iadd__(x, y) x.__iadd__(y) <==> x+=y Returns:
        x+=y

    ### __imul__(x, y) x.__imul__(y) <==> x*=y Returns:
        x*=y

    ### __iter__(x) x.__iter__() <==> iter(x) Returns:
        iter(x)

    ### __le__(x, y) (Less-than-or-equals operator) x.__le__(y) <==> x<=y Returns:
        x<=y

    ### __len__(x) (Length operator) x.__len__() <==> len(x) Returns:
        len(x)

    ### __lt__(x, y) (Less-than operator) x.__lt__(y) <==> x<y Returns:
        x<y

    ### __mul__(x, n) x.__mul__(n) <==> x*n Returns:
        x*n

    ### __ne__(x, y) x.__ne__(y) <==> x!=y Returns:
        x!=y

    ### __new__(T, S, ...) T.__new__(S, ...) -> a new object with type S, a subtype of T Returns:
        a new object with type S, a subtype of T
Overrides: `__builtin__.object.__new__`

    ### __repr__(x) (Representation operator) x.__repr__() <==> repr(x) Returns:
        repr(x)
Overrides: `__builtin__.object.__repr__`

    ### __rmul__(x, n) x.__rmul__(n) <==> n*x Returns:
        n*x

    ### __setitem__(x, i, y) (Index assignment operator) x.__setitem__(i, y) <==> x[i]=y Returns:
        x[i]=y

    ### __setslice__(x, i, j, y) (Slice assignment operator) Use of negative indices is not supported. Returns:
        x[i:j]=y

### append(...) L.append(object) -- append object to end

    ### count(L, value) L.count(value) -> integer -- return number of occurrences of value Returns:
        integer

### extend(...) L.extend(iterable) -- extend list by appending elements from the iterable

### index(...) L.index(value, [start, [stop]]) -> integer -- return first index of value

### insert(...) L.insert(index, object) -- insert object before index

    ### pop(L, index=...) L.pop([index]) -> item -- remove and return item at index (default last) Returns:
        item

### remove(...) L.remove(value) -- remove first occurrence of value

### reverse(...) L.reverse() -- reverse *IN PLACE*

### sort(...) L.sort(cmpfunc=None) -- stable sort *IN PLACE*; cmpfunc(x, y) -> -1, 0, 1

Generated by Epydoc 2.1 on Wed Jun 14 14:32:44 2006 | http://epydoc.sf.net