python 字典 dict

help(dict)
python 字典

class dict(object)
 | dict() -> new empty dictionary
 | dict(mapping) -> new dictionary initialized from a mapping object's
 | (key, value) pairs
 | dict(iterable) -> new dictionary initialized as if via:
 | d = {}
 | for k, v in iterable:
 | 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)
 | 
 | Methods defined here:
 | 
 | __cmp__(...)
 | x.__cmp__(y) <==> cmp(x,y)
 | 
 | __contains__(...)
 | D.__contains__(k) -> True if D has a key k, else False
 | 
 | __delitem__(...)
 | x.__delitem__(y) <==> del x[y]
 | 
 | __eq__(...)
 | x.__eq__(y) <==> x==y
 | 
 | __ge__(...)
 | x.__ge__(y) <==> x>=y
 | 
 | __getattribute__(...)
 | x.__getattribute__('name') <==> x.name
 | 
 | __getitem__(...)
 | x.__getitem__(y) <==> x[y]
 | 
 | __gt__(...)
 | x.__gt__(y) <==> x>y
 | 
 | __init__(...)
 | x.__init__(...) initializes x; see x.__class__.__doc__ for signature
 | 
 | __iter__(...)
 | x.__iter__() <==> iter(x)
 | 
 | __le__(...)
 | x.__le__(y) <==> x<=y
 | 
 | __len__(...)
 | x.__len__() <==> len(x)
 | 
 | __lt__(...)
 | x.__lt__(y) <==> x<y
 | 
 | __ne__(...)
 | x.__ne__(y) <==> x!=y
 | 
 | __repr__(...)
 | x.__repr__() <==> repr(x)
 | 
 | __setitem__(...)
 | x.__setitem__(i, y) <==> x[i]=y
 | 
 | __sizeof__(...)
 | D.__sizeof__() -> size of D in memory, in bytes
 | 
 | clear(...)
 | D.clear() -> None. Remove all items from D.
 | 
 | copy(...)
 | D.copy() -> a shallow copy of D
 | 
 | get(...)
 | D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None.
 | 
 | has_key(...)
 | D.has_key(k) -> True if D has a key k, else False
 | 
 | items(...)
 | D.items() -> list of D's (key, value) pairs, as 2-tuples
 | 
 | iteritems(...)
 | D.iteritems() -> an iterator over the (key, value) items of D
 | 
 | iterkeys(...)
 | D.iterkeys() -> an iterator over the keys of D
 | 
 | itervalues(...)
 | D.itervalues() -> an iterator over the values of D
 | 
 | keys(...)
 | D.keys() -> list of D's keys
 | 
 | pop(...)
 | D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
 | If key is not found, d is returned if given, otherwise KeyError is raised
 | 
 | popitem(...)
 | D.popitem() -> (k, v), remove and return some (key, value) pair as a
 | 2-tuple; but raise KeyError if D is empty.
 | 
 | setdefault(...)
 | D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
 | 
 | update(...)
 | D.update(E, **F) -> None. Update D from dict/iterable E and F.
 | If E has a .keys() method, does: for k in E: D[k] = E[k]
 | If E lacks .keys() method, does: for (k, v) in E: D[k] = v
 | In either case, this is followed by: for k in F: D[k] = F[k]
 | 
 | values(...)
 | D.values() -> list of D's values
 | 
 | ----------------------------------------------------------------------
 | Data and other attributes defined here:
 | 
 | __hash__ = None
 | 
 | __new__ = <built-in method __new__ of type object>
 | T.__new__(S, ...) -> a new object with type S, a subtype of T
 | 
 | fromkeys = <built-in method fromkeys of type object>
 | dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
 | v defaults to None.
(END)