Module __builtin__ :: Class list

[frames | no frames]

## Type list

    object --+
             |
            list

Known Subclasses:
  `FIFO`, `LIFO`, `Random`

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)
| ``__reversed__`(...)` L.__reversed__() -- return a reverse iterator over the list
| ``__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(cmp=None, key=None, reverse=False) -- stable sort IN PLACE; cmp(x, y) -> -1, 0, 1
Inherited from `object`: `__delattr__`, `__reduce__`, `__reduce_ex__`, `__setattr__`, `__str__`

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__`

### __reversed__(...)

L.__reversed__() -- return a reverse iterator over the list

### __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(cmp=None, key=None, reverse=False) -- stable sort IN PLACE; cmp(x, y) -> -1, 0, 1

Generated by Epydoc 2.1 on Sun Aug 21 08:06:58 2005 | http://epydoc.sf.net