__builtin__.dict

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

## Type dict

    object --+
             |
            dict

Known Subclasses:
  `ExpiringDictionary`

    dict() -> new empty dictionary.
    dict(mapping) -> new dictionary initialized from a mapping object's
        (key, value) pairs.
    dict(seq) -> new dictionary initialized as if via:
        d = {}
        for k, v in seq:
            d[k] = v
    dict(**kwargs) -> new dictionary initialized with the name=value pairs
        in the keyword argument list.  For example:  dict(one=1, two=2)

Method Summary
| ``__init__`(...)` x.__init__(...) initializes x; see x.__class__.__doc__ for signature
| ``__cmp__`(x, y)` x.__cmp__(y) <==> cmp(x,y)
| ``__contains__`(D, k)` D.__contains__(k) -> True if D has a key k, else False
| ``__delitem__`(x, y)` x.__delitem__(y) <==> del x[y]
| ``__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]
| ``__gt__`(x, y)` x.__gt__(y) <==> x>y
| ``__hash__`(x)` x.__hash__() <==> hash(x)
| ``__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
| ``__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)
| ``__setitem__`(x, i, y)` x.__setitem__(i, y) <==> x[i]=y
| ``clear`(D)` D.clear() -> None.
| ``copy`(D)` D.copy() -> a shallow copy of D
| ``get`(D, k, d)` D.get(k[,d]) -> D[k] if k in D, else d.
| ``has_key`(D, k)` D.has_key(k) -> True if D has a key k, else False
| ``items`(D)` D.items() -> list of D's (key, value) pairs, as 2-tuples
| ``iteritems`(D)` D.iteritems() -> an iterator over the (key, value) items of D
| ``iterkeys`(D)` D.iterkeys() -> an iterator over the keys of D
| ``itervalues`(D)` D.itervalues() -> an iterator over the values of D
| ``keys`(D)` D.keys() -> list of D's keys
| ``pop`(D, k, d)` If key is not found, d is returned if given, otherwise KeyError is raised
| ``popitem`(D)` 2-tuple; but raise KeyError if D is empty
| ``setdefault`(D, k, d)` D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
| ``update`(...)` D.update(E, **F) -> None.
| ``values`(D)` D.values() -> list of D's values
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)
Inherited from type
| ``fromkeys`(dict, S, v)` v defaults to None.

Method Details

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

    ### __cmp__(x, y) (Comparison operator) x.__cmp__(y) <==> cmp(x,y) Returns:
        cmp(x,y)

    ### __contains__(D, k) (In operator) D.__contains__(k) -> True if D has a key k, else False Returns:
        True if D has a key k, else False

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

    ### __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]

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

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

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

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

    ### clear(D) D.clear() -> None. Remove all items from D. Returns:
        None

    ### copy(D) D.copy() -> a shallow copy of D Returns:
        a shallow copy of D

    ### get(D, k, d=...) D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None. Returns:
        D[k] if k in D, else d

    ### has_key(D, k) D.has_key(k) -> True if D has a key k, else False Returns:
        True if D has a key k, else False

    ### items(D) D.items() -> list of D's (key, value) pairs, as 2-tuples Returns:
        list of D's (key, value) pairs, as 2-tuples

    ### iteritems(D) D.iteritems() -> an iterator over the (key, value) items of D Returns:
        an iterator over the (key, value) items of D

    ### iterkeys(D) D.iterkeys() -> an iterator over the keys of D Returns:
        an iterator over the keys of D

    ### itervalues(D) D.itervalues() -> an iterator over the values of D Returns:
        an iterator over the values of D

    ### keys(D) D.keys() -> list of D's keys Returns:
        list of D's keys

    ### pop(D, k, d=...) If key is not found, d is returned if given, otherwise KeyError is raised Returns:
        v, remove specified key and return the corresponding value

    ### popitem(D) 2-tuple; but raise KeyError if D is empty Returns:
        (k, v), remove and return some (key, value) pair as a

    ### setdefault(D, k, d=...) D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D Returns:
        D.get(k,d), also set D[k]=d if k not in D

### update(...) D.update(E, **F) -> None. Update D from E and F: for k in E: D[k] = E[k] (if E has keys else: for (k, v) in E: D[k] = v) then: for k in F: D[k] = F[k]

    ### values(D) D.values() -> list of D's values Returns:
        list of D's values