basictypes.list_types
index
p:\properties\basictypes\list_types.py

Restricted lists with base-datatype meta-type support
 
This module is normally used to easily create a baseType
definition for a property like so:
 
        listof_Blarghs = list_types.listof(
                name = "listof_Blarghs",
                baseType = Blargh,
                dataType = "list.Blargh",
        )
        class X(propertied.Propertied):
                blarghs = common.ListProperty(
                        'blarghs', "A sequence of Blarghs",
                        baseType = listof_Blarghs,
                )
 
The listof_Blarghs type (a sub-class of list) will
have coercion, data-type checking, and factories support,
and a dataType attribute which allows the wxoo system
to service instances in a number of useful ways.
 
The module also includes a set of "basic" list-of-types
mirroring those in the basic_types module.

 
Modules
       
basictypes.basic_types
inspect
basictypes.latebind
os
basictypes.rlist
types

 
Classes
       
rlist(list)
ListOf
listof_bools
listof_classes
listof_classnames
listof_floats
listof_ints
listof_longs
listof_strings
type(object)
listof

 
class ListOf(rlist)
    List of a particular object-type
 
This is the default base class for the classes
generated by the listof meta-class.  It is a
simple restrictive list (see the superclass)
which calls its class'es coerce_single method
on every value added.
 
 
Method resolution order:
ListOf
rlist
list
object

Methods defined here:
beforeAdd(self, value)
Called before all attempts to add an item

Methods inherited from rlist:
__iadd__ = extend(self, value)
extend with value checking
__init__(self, value=None)
Initialize the restricted list object
__setitem__(self, index, value)
__setitem__ with value checking
__setslice__(self, start, stop, value)
__setslice__ with value checking
append(self, value)
append with value checking
beforeMultipleAdd(self, value)
Called before attempts to add more than one item (beforeAdd has already be called for each item)
extend(self, value)
extend with value checking
insert(self, index, value)
insert with value checking

Data and other attributes inherited from rlist:
__dict__ = <dictproxy object at 0x01C6E590>
dictionary for instance variables (if defined)
__weakref__ = <attribute '__weakref__' of 'rlist' objects>
list of weak references to the object (if defined)

Methods inherited from list:
__add__(...)
x.__add__(y) <==> x+y
__contains__(...)
x.__contains__(y) <==> y in x
__delitem__(...)
x.__delitem__(y) <==> del x[y]
__delslice__(...)
x.__delslice__(i, j) <==> del x[i:j]
 
Use of negative indices is not supported.
__eq__(...)
x.__eq__(y) <==> x==y
__ge__(...)
x.__ge__(y) <==> x>=y
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getitem__(...)
x.__getitem__(y) <==> x[y]
__getslice__(...)
x.__getslice__(i, j) <==> x[i:j]
 
Use of negative indices is not supported.
__gt__(...)
x.__gt__(y) <==> x>y
__hash__(...)
x.__hash__() <==> hash(x)
__imul__(...)
x.__imul__(y) <==> x*=y
__iter__(...)
x.__iter__() <==> iter(x)
__le__(...)
x.__le__(y) <==> x<=y
__len__(...)
x.__len__() <==> len(x)
__lt__(...)
x.__lt__(y) <==> x<y
__mul__(...)
x.__mul__(n) <==> x*n
__ne__(...)
x.__ne__(y) <==> x!=y
__repr__(...)
x.__repr__() <==> repr(x)
__rmul__(...)
x.__rmul__(n) <==> n*x
count(...)
L.count(value) -> integer -- return number of occurrences of value
index(...)
L.index(value, [start, [stop]]) -> integer -- return first index of value
pop(...)
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

Data and other attributes inherited from list:
__new__ = <built-in method __new__ of type object at 0x1E0C3C68>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class listof(type)
    Meta-class which creates a new typed list-class
 
The listof meta-class is normally called like so:
 
        classname = listof(
                "classname",
                baseType,
                dataType = "list.something",
        )
 
with baseType being the basictypes specifier for the
base object type, or a simple data-class.
 
Note: there is a horrible hack that tries to figure
out the correct __module__ name for the resulting class,
this is very annoyingly set to list_types by default,
rather than the module which calls listof() :( .
 
 
Method resolution order:
listof
type
object

Methods defined here:
check(cls, value)
Check the whole set (debugging checks)
check_single(cls, value)
Check whether a value is an instance of an acceptable type
coerce(cls, value)
Attempt to coerce the value using one of our baseType
coerce_single(cls, value)
coerce a single value to an acceptable type
factories(cls)
Retrieve the list of factories for this class

Static methods defined here:
__new__(cls, baseType, name='', bases=(<class 'basictypes.list_types.ListOf'>,), **named)

Properties defined here:
baseType
The base-type specifier for the listof type
get = _get_baseType(self)
set = _set_baseType(self, value)
delete = _del_baseType(self)

Methods inherited from type:
__call__(...)
x.__call__(...) <==> x(...)
__cmp__(...)
x.__cmp__(y) <==> cmp(x,y)
__delattr__(...)
x.__delattr__('name') <==> del x.name
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__hash__(...)
x.__hash__() <==> hash(x)
__repr__(...)
x.__repr__() <==> repr(x)
__setattr__(...)
x.__setattr__('name', value) <==> x.name = value
__subclasses__(...)
__subclasses__() -> list of immediate subclasses
mro(...)
mro() -> list
return a type's method resolution order

Data and other attributes inherited from type:
__base__ = <type 'type'>
__bases__ = (<type 'type'>,)
__basicsize__ = 420
__dict__ = <dictproxy object at 0x01C6E5B0>
__dictoffset__ = 132
__flags__ = 22523
__itemsize__ = 20
__mro__ = (<class 'basictypes.list_types.listof'>, <type 'type'>, <type 'object'>)
__weakrefoffset__ = 184

 
class listof_bools(ListOf)
    
Method resolution order:
listof_bools
ListOf
rlist
list
object

Data and other attributes defined here:
dataType = 'list.bool'

Methods inherited from ListOf:
beforeAdd(self, value)
Called before all attempts to add an item

Methods inherited from rlist:
__iadd__ = extend(self, value)
extend with value checking
__init__(self, value=None)
Initialize the restricted list object
__setitem__(self, index, value)
__setitem__ with value checking
__setslice__(self, start, stop, value)
__setslice__ with value checking
append(self, value)
append with value checking
beforeMultipleAdd(self, value)
Called before attempts to add more than one item (beforeAdd has already be called for each item)
extend(self, value)
extend with value checking
insert(self, index, value)
insert with value checking

Data and other attributes inherited from rlist:
__dict__ = <dictproxy object at 0x01C6E350>
dictionary for instance variables (if defined)
__weakref__ = <attribute '__weakref__' of 'rlist' objects>
list of weak references to the object (if defined)

Methods inherited from list:
__add__(...)
x.__add__(y) <==> x+y
__contains__(...)
x.__contains__(y) <==> y in x
__delitem__(...)
x.__delitem__(y) <==> del x[y]
__delslice__(...)
x.__delslice__(i, j) <==> del x[i:j]
 
Use of negative indices is not supported.
__eq__(...)
x.__eq__(y) <==> x==y
__ge__(...)
x.__ge__(y) <==> x>=y
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getitem__(...)
x.__getitem__(y) <==> x[y]
__getslice__(...)
x.__getslice__(i, j) <==> x[i:j]
 
Use of negative indices is not supported.
__gt__(...)
x.__gt__(y) <==> x>y
__hash__(...)
x.__hash__() <==> hash(x)
__imul__(...)
x.__imul__(y) <==> x*=y
__iter__(...)
x.__iter__() <==> iter(x)
__le__(...)
x.__le__(y) <==> x<=y
__len__(...)
x.__len__() <==> len(x)
__lt__(...)
x.__lt__(y) <==> x<y
__mul__(...)
x.__mul__(n) <==> x*n
__ne__(...)
x.__ne__(y) <==> x!=y
__repr__(...)
x.__repr__() <==> repr(x)
__rmul__(...)
x.__rmul__(n) <==> n*x
count(...)
L.count(value) -> integer -- return number of occurrences of value
index(...)
L.index(value, [start, [stop]]) -> integer -- return first index of value
pop(...)
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

Data and other attributes inherited from list:
__new__ = <built-in method __new__ of type object at 0x1E0C3C68>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class listof_classes(ListOf)
    
Method resolution order:
listof_classes
ListOf
rlist
list
object

Data and other attributes defined here:
dataType = 'list.class'

Methods inherited from ListOf:
beforeAdd(self, value)
Called before all attempts to add an item

Methods inherited from rlist:
__iadd__ = extend(self, value)
extend with value checking
__init__(self, value=None)
Initialize the restricted list object
__setitem__(self, index, value)
__setitem__ with value checking
__setslice__(self, start, stop, value)
__setslice__ with value checking
append(self, value)
append with value checking
beforeMultipleAdd(self, value)
Called before attempts to add more than one item (beforeAdd has already be called for each item)
extend(self, value)
extend with value checking
insert(self, index, value)
insert with value checking

Data and other attributes inherited from rlist:
__dict__ = <dictproxy object at 0x01C6E430>
dictionary for instance variables (if defined)
__weakref__ = <attribute '__weakref__' of 'rlist' objects>
list of weak references to the object (if defined)

Methods inherited from list:
__add__(...)
x.__add__(y) <==> x+y
__contains__(...)
x.__contains__(y) <==> y in x
__delitem__(...)
x.__delitem__(y) <==> del x[y]
__delslice__(...)
x.__delslice__(i, j) <==> del x[i:j]
 
Use of negative indices is not supported.
__eq__(...)
x.__eq__(y) <==> x==y
__ge__(...)
x.__ge__(y) <==> x>=y
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getitem__(...)
x.__getitem__(y) <==> x[y]
__getslice__(...)
x.__getslice__(i, j) <==> x[i:j]
 
Use of negative indices is not supported.
__gt__(...)
x.__gt__(y) <==> x>y
__hash__(...)
x.__hash__() <==> hash(x)
__imul__(...)
x.__imul__(y) <==> x*=y
__iter__(...)
x.__iter__() <==> iter(x)
__le__(...)
x.__le__(y) <==> x<=y
__len__(...)
x.__len__() <==> len(x)
__lt__(...)
x.__lt__(y) <==> x<y
__mul__(...)
x.__mul__(n) <==> x*n
__ne__(...)
x.__ne__(y) <==> x!=y
__repr__(...)
x.__repr__() <==> repr(x)
__rmul__(...)
x.__rmul__(n) <==> n*x
count(...)
L.count(value) -> integer -- return number of occurrences of value
index(...)
L.index(value, [start, [stop]]) -> integer -- return first index of value
pop(...)
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

Data and other attributes inherited from list:
__new__ = <built-in method __new__ of type object at 0x1E0C3C68>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class listof_classnames(ListOf)
    
Method resolution order:
listof_classnames
ListOf
rlist
list
object

Data and other attributes defined here:
dataType = 'list.str.classname'

Methods inherited from ListOf:
beforeAdd(self, value)
Called before all attempts to add an item

Methods inherited from rlist:
__iadd__ = extend(self, value)
extend with value checking
__init__(self, value=None)
Initialize the restricted list object
__setitem__(self, index, value)
__setitem__ with value checking
__setslice__(self, start, stop, value)
__setslice__ with value checking
append(self, value)
append with value checking
beforeMultipleAdd(self, value)
Called before attempts to add more than one item (beforeAdd has already be called for each item)
extend(self, value)
extend with value checking
insert(self, index, value)
insert with value checking

Data and other attributes inherited from rlist:
__dict__ = <dictproxy object at 0x01C6E570>
dictionary for instance variables (if defined)
__weakref__ = <attribute '__weakref__' of 'rlist' objects>
list of weak references to the object (if defined)

Methods inherited from list:
__add__(...)
x.__add__(y) <==> x+y
__contains__(...)
x.__contains__(y) <==> y in x
__delitem__(...)
x.__delitem__(y) <==> del x[y]
__delslice__(...)
x.__delslice__(i, j) <==> del x[i:j]
 
Use of negative indices is not supported.
__eq__(...)
x.__eq__(y) <==> x==y
__ge__(...)
x.__ge__(y) <==> x>=y
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getitem__(...)
x.__getitem__(y) <==> x[y]
__getslice__(...)
x.__getslice__(i, j) <==> x[i:j]
 
Use of negative indices is not supported.
__gt__(...)
x.__gt__(y) <==> x>y
__hash__(...)
x.__hash__() <==> hash(x)
__imul__(...)
x.__imul__(y) <==> x*=y
__iter__(...)
x.__iter__() <==> iter(x)
__le__(...)
x.__le__(y) <==> x<=y
__len__(...)
x.__len__() <==> len(x)
__lt__(...)
x.__lt__(y) <==> x<y
__mul__(...)
x.__mul__(n) <==> x*n
__ne__(...)
x.__ne__(y) <==> x!=y
__repr__(...)
x.__repr__() <==> repr(x)
__rmul__(...)
x.__rmul__(n) <==> n*x
count(...)
L.count(value) -> integer -- return number of occurrences of value
index(...)
L.index(value, [start, [stop]]) -> integer -- return first index of value
pop(...)
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

Data and other attributes inherited from list:
__new__ = <built-in method __new__ of type object at 0x1E0C3C68>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class listof_floats(ListOf)
    
Method resolution order:
listof_floats
ListOf
rlist
list
object

Data and other attributes defined here:
dataType = 'list.float'

Methods inherited from ListOf:
beforeAdd(self, value)
Called before all attempts to add an item

Methods inherited from rlist:
__iadd__ = extend(self, value)
extend with value checking
__init__(self, value=None)
Initialize the restricted list object
__setitem__(self, index, value)
__setitem__ with value checking
__setslice__(self, start, stop, value)
__setslice__ with value checking
append(self, value)
append with value checking
beforeMultipleAdd(self, value)
Called before attempts to add more than one item (beforeAdd has already be called for each item)
extend(self, value)
extend with value checking
insert(self, index, value)
insert with value checking

Data and other attributes inherited from rlist:
__dict__ = <dictproxy object at 0x01C6E470>
dictionary for instance variables (if defined)
__weakref__ = <attribute '__weakref__' of 'rlist' objects>
list of weak references to the object (if defined)

Methods inherited from list:
__add__(...)
x.__add__(y) <==> x+y
__contains__(...)
x.__contains__(y) <==> y in x
__delitem__(...)
x.__delitem__(y) <==> del x[y]
__delslice__(...)
x.__delslice__(i, j) <==> del x[i:j]
 
Use of negative indices is not supported.
__eq__(...)
x.__eq__(y) <==> x==y
__ge__(...)
x.__ge__(y) <==> x>=y
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getitem__(...)
x.__getitem__(y) <==> x[y]
__getslice__(...)
x.__getslice__(i, j) <==> x[i:j]
 
Use of negative indices is not supported.
__gt__(...)
x.__gt__(y) <==> x>y
__hash__(...)
x.__hash__() <==> hash(x)
__imul__(...)
x.__imul__(y) <==> x*=y
__iter__(...)
x.__iter__() <==> iter(x)
__le__(...)
x.__le__(y) <==> x<=y
__len__(...)
x.__len__() <==> len(x)
__lt__(...)
x.__lt__(y) <==> x<y
__mul__(...)
x.__mul__(n) <==> x*n
__ne__(...)
x.__ne__(y) <==> x!=y
__repr__(...)
x.__repr__() <==> repr(x)
__rmul__(...)
x.__rmul__(n) <==> n*x
count(...)
L.count(value) -> integer -- return number of occurrences of value
index(...)
L.index(value, [start, [stop]]) -> integer -- return first index of value
pop(...)
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

Data and other attributes inherited from list:
__new__ = <built-in method __new__ of type object at 0x1E0C3C68>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class listof_ints(ListOf)
    
Method resolution order:
listof_ints
ListOf
rlist
list
object

Data and other attributes defined here:
dataType = 'list.int'

Methods inherited from ListOf:
beforeAdd(self, value)
Called before all attempts to add an item

Methods inherited from rlist:
__iadd__ = extend(self, value)
extend with value checking
__init__(self, value=None)
Initialize the restricted list object
__setitem__(self, index, value)
__setitem__ with value checking
__setslice__(self, start, stop, value)
__setslice__ with value checking
append(self, value)
append with value checking
beforeMultipleAdd(self, value)
Called before attempts to add more than one item (beforeAdd has already be called for each item)
extend(self, value)
extend with value checking
insert(self, index, value)
insert with value checking

Data and other attributes inherited from rlist:
__dict__ = <dictproxy object at 0x01C6E350>
dictionary for instance variables (if defined)
__weakref__ = <attribute '__weakref__' of 'rlist' objects>
list of weak references to the object (if defined)

Methods inherited from list:
__add__(...)
x.__add__(y) <==> x+y
__contains__(...)
x.__contains__(y) <==> y in x
__delitem__(...)
x.__delitem__(y) <==> del x[y]
__delslice__(...)
x.__delslice__(i, j) <==> del x[i:j]
 
Use of negative indices is not supported.
__eq__(...)
x.__eq__(y) <==> x==y
__ge__(...)
x.__ge__(y) <==> x>=y
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getitem__(...)
x.__getitem__(y) <==> x[y]
__getslice__(...)
x.__getslice__(i, j) <==> x[i:j]
 
Use of negative indices is not supported.
__gt__(...)
x.__gt__(y) <==> x>y
__hash__(...)
x.__hash__() <==> hash(x)
__imul__(...)
x.__imul__(y) <==> x*=y
__iter__(...)
x.__iter__() <==> iter(x)
__le__(...)
x.__le__(y) <==> x<=y
__len__(...)
x.__len__() <==> len(x)
__lt__(...)
x.__lt__(y) <==> x<y
__mul__(...)
x.__mul__(n) <==> x*n
__ne__(...)
x.__ne__(y) <==> x!=y
__repr__(...)
x.__repr__() <==> repr(x)
__rmul__(...)
x.__rmul__(n) <==> n*x
count(...)
L.count(value) -> integer -- return number of occurrences of value
index(...)
L.index(value, [start, [stop]]) -> integer -- return first index of value
pop(...)
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

Data and other attributes inherited from list:
__new__ = <built-in method __new__ of type object at 0x1E0C3C68>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class listof_longs(ListOf)
    
Method resolution order:
listof_longs
ListOf
rlist
list
object

Data and other attributes defined here:
dataType = 'list.long'

Methods inherited from ListOf:
beforeAdd(self, value)
Called before all attempts to add an item

Methods inherited from rlist:
__iadd__ = extend(self, value)
extend with value checking
__init__(self, value=None)
Initialize the restricted list object
__setitem__(self, index, value)
__setitem__ with value checking
__setslice__(self, start, stop, value)
__setslice__ with value checking
append(self, value)
append with value checking
beforeMultipleAdd(self, value)
Called before attempts to add more than one item (beforeAdd has already be called for each item)
extend(self, value)
extend with value checking
insert(self, index, value)
insert with value checking

Data and other attributes inherited from rlist:
__dict__ = <dictproxy object at 0x01C6E570>
dictionary for instance variables (if defined)
__weakref__ = <attribute '__weakref__' of 'rlist' objects>
list of weak references to the object (if defined)

Methods inherited from list:
__add__(...)
x.__add__(y) <==> x+y
__contains__(...)
x.__contains__(y) <==> y in x
__delitem__(...)
x.__delitem__(y) <==> del x[y]
__delslice__(...)
x.__delslice__(i, j) <==> del x[i:j]
 
Use of negative indices is not supported.
__eq__(...)
x.__eq__(y) <==> x==y
__ge__(...)
x.__ge__(y) <==> x>=y
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getitem__(...)
x.__getitem__(y) <==> x[y]
__getslice__(...)
x.__getslice__(i, j) <==> x[i:j]
 
Use of negative indices is not supported.
__gt__(...)
x.__gt__(y) <==> x>y
__hash__(...)
x.__hash__() <==> hash(x)
__imul__(...)
x.__imul__(y) <==> x*=y
__iter__(...)
x.__iter__() <==> iter(x)
__le__(...)
x.__le__(y) <==> x<=y
__len__(...)
x.__len__() <==> len(x)
__lt__(...)
x.__lt__(y) <==> x<y
__mul__(...)
x.__mul__(n) <==> x*n
__ne__(...)
x.__ne__(y) <==> x!=y
__repr__(...)
x.__repr__() <==> repr(x)
__rmul__(...)
x.__rmul__(n) <==> n*x
count(...)
L.count(value) -> integer -- return number of occurrences of value
index(...)
L.index(value, [start, [stop]]) -> integer -- return first index of value
pop(...)
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

Data and other attributes inherited from list:
__new__ = <built-in method __new__ of type object at 0x1E0C3C68>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class listof_strings(ListOf)
    
Method resolution order:
listof_strings
ListOf
rlist
list
object

Data and other attributes defined here:
dataType = 'list.str'

Methods inherited from ListOf:
beforeAdd(self, value)
Called before all attempts to add an item

Methods inherited from rlist:
__iadd__ = extend(self, value)
extend with value checking
__init__(self, value=None)
Initialize the restricted list object
__setitem__(self, index, value)
__setitem__ with value checking
__setslice__(self, start, stop, value)
__setslice__ with value checking
append(self, value)
append with value checking
beforeMultipleAdd(self, value)
Called before attempts to add more than one item (beforeAdd has already be called for each item)
extend(self, value)
extend with value checking
insert(self, index, value)
insert with value checking

Data and other attributes inherited from rlist:
__dict__ = <dictproxy object at 0x01C6E390>
dictionary for instance variables (if defined)
__weakref__ = <attribute '__weakref__' of 'rlist' objects>
list of weak references to the object (if defined)

Methods inherited from list:
__add__(...)
x.__add__(y) <==> x+y
__contains__(...)
x.__contains__(y) <==> y in x
__delitem__(...)
x.__delitem__(y) <==> del x[y]
__delslice__(...)
x.__delslice__(i, j) <==> del x[i:j]
 
Use of negative indices is not supported.
__eq__(...)
x.__eq__(y) <==> x==y
__ge__(...)
x.__ge__(y) <==> x>=y
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getitem__(...)
x.__getitem__(y) <==> x[y]
__getslice__(...)
x.__getslice__(i, j) <==> x[i:j]
 
Use of negative indices is not supported.
__gt__(...)
x.__gt__(y) <==> x>y
__hash__(...)
x.__hash__() <==> hash(x)
__imul__(...)
x.__imul__(y) <==> x*=y
__iter__(...)
x.__iter__() <==> iter(x)
__le__(...)
x.__le__(y) <==> x<=y
__len__(...)
x.__len__() <==> len(x)
__lt__(...)
x.__lt__(y) <==> x<y
__mul__(...)
x.__mul__(n) <==> x*n
__ne__(...)
x.__ne__(y) <==> x!=y
__repr__(...)
x.__repr__() <==> repr(x)
__rmul__(...)
x.__rmul__(n) <==> n*x
count(...)
L.count(value) -> integer -- return number of occurrences of value
index(...)
L.index(value, [start, [stop]]) -> integer -- return first index of value
pop(...)
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

Data and other attributes inherited from list:
__new__ = <built-in method __new__ of type object at 0x1E0C3C68>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
Data
        __file__ = r'p:\properties\basictypes\list_types.pyc'
__name__ = 'basictypes.list_types'