```python
>>> help(tuple)
Help on class tuple in module __builtin__:
class tuple(object)
│ tuple() -> empty tuple
│ tuple(iterable) -> tuple initialized from iterable's items
│
│ If the argument is a tuple, the return value is the same object.
│
│ Methods defined here:
│
│ __add__(...)
│ x.__add__(y) <==> x+y
│
│ __contains__(...)
│ x.__contains__(y) <==> y in x
│
│ __eq__(...)
│ x.__eq__(y) <==> x==y
│
│ __ge__(...)
│ x.__ge__(y) <==> x>=y
│
│ __getattribute__(...)
│ x.__getattribute__('name') <==> x.name
│
│ __getitem__(...)
│ x.__getitem__(y) <==> x[y]
│
│ __getnewargs__(...)
│
│ __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)
│
│ __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
│
│ __sizeof__(...)
│ T.__sizeof__() -- size of T in memory, in bytes
│
│ count(...)
│ T.count(value) -> integer -- return number of occurrences of value
│
│ index(...)
│ T.index(value, [start, [stop]]) -> integer -- return first index of value.
│ Raises ValueError if the value is not present.
│
│ ----------------------------------------------------------------------
│ Data and other attributes defined here:
│
│ __new__ = <built-in method __new__ of type object>
│ T.__new__(S, ...) -> a new object with type S, a subtype of T
>>> help(list)
Help on class list in module __builtin__:
class list(object)
│ list() -> new empty list
│ list(iterable) -> new list initialized from iterable's items
│
│ Methods defined here:
│
│ __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
│
│ __iadd__(...)
│ x.__iadd__(y) <==> x+=y
│
│ __imul__(...)
│ x.__imul__(y) <==> x*=y
│
│ __init__(...)
│ x.__init__(...) initializes x; see help(type(x)) for signature
│
│ __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)
│
│ __reversed__(...)
│ L.__reversed__() -- return a reverse iterator over the list
│
│ __rmul__(...)
│ x.__rmul__(n) <==> n*x
│
│ __setitem__(...)
│ x.__setitem__(i, y) <==> x[i]=y
│
│ __setslice__(...)
│ x.__setslice__(i, j, y) <==> x[i:j]=y
│
│ Use of negative indices is not supported.
│
│ __sizeof__(...)
│ L.__sizeof__() -- size of L in memory, in bytes
│
│ append(...)
│ L.append(object) -- append object to end
│
│ count(...)
│ 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.
│ Raises ValueError if the value is not present.
│
│ insert(...)
│ L.insert(index, object) -- insert object before index
│
│ pop(...)
│ L.pop([index]) -> item -- remove and return item at index (default last).
│ Raises IndexError if list is empty or index is out of range.
│
│ remove(...)
│ L.remove(value) -- remove first occurrence of value.
│ Raises ValueError if the value is not present.
│
│ 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
│
│ ----------------------------------------------------------------------
│ 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
>>> help(dict)
Help on class dict in module __builtin__:
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 help(type(x)) 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
│
│ fromkeys(...)
│ dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
│ v defaults to None.
│
│ 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 present and has a .keys() method, does: for k in E: D[k] = E[k]
│ If E present and 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
│
│ viewitems(...)
│ D.viewitems() -> a set-like object providing a view on D's items
│
│ viewkeys(...)
│ D.viewkeys() -> a set-like object providing a view on D's keys
│
│ viewvalues(...)
│ D.viewvalues() -> an object providing a view on 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
分类: Python
绿色通道： 好文要顶 关注我 收藏该文与我联系
0 0
(请您对文章做出评价)
« 上一篇：测试通过Word直接发布博文
» 下一篇：测试2
posted @ 2014-07-26 21:44 Mx.Hu 阅读(12) 评论(1) 编辑 收藏
评论列表
修改删除
#1楼[楼主] 2014-07-31 17:10 Mx.Hu
# coding=utf-8
d={
'a':1,
'b':2,
'c':{'c1':1,'c2':2}
}
print d['c']
d1={'d':3}
# d['c']['d']=d1['d']
d['c'].update(d1)
print d['c']
```