>>> help(dict.copy)  #help()查看dict.copy的详细内容

 Help on method_descriptor:

 copy(...)

     D.copy() -> a shallow copy of D  #字典d的浅拷贝

 >>> d ={"name":"python","web":"www.baidu.com"}

 >>> e =d

 >>> e

 {'web': 'www.baidu.com', 'name': 'python'}

 >>> d

 {'web': 'www.baidu.com', 'name': 'python'}

 >>> id(e)

 49259112L

 >>> id(d)   #可以看出e和d在内存中地址相同，e和d引用的是同一个对象

 49259112L

 >>> f=d.copy() #字典d的浅复制

 >>> f

 {'web': 'www.baidu.com', 'name': 'python'}

 >>> id(f)  #可以看出f与上面的e和d的内存地址不同，f创建了新的字典对象

 13708552L

 >>> d["lang"]="python"  #向字典d中添加一个对象，d中发生了变化，字典f并没有收到影响，说明字典f是一个新的字典对象，d 和f 是两个不同的对象

 >>> d

 {'lang': 'python', 'web': 'www.baidu.com', 'name': 'python'}

 >>> f

 {'web': 'www.baidu.com', 'name': 'python'}

 >>> d={"name":"zhangsan","enjoy":["python","tea","book"]}  #新建一个字典

 >>> e =d.copy()   #对字典进行copy

 >>> id(d),id(e)　　#看出他俩的内存地址不同，是两个不同的对象

 (13708280L, 13719208L)

 >>> d["enjoy"]   #从字典d中取出enjoy所对应的列表的值

 ['python', 'tea', 'book']

 >>> d["enjoy"].remove("book") #将字典d中key为enjoy，值为book的元素移除

 >>> d     #d 中的book已经被移除

 {'enjoy': ['python', 'tea'], 'name': 'zhangsan'}

 >>> e    #e中的book也被移除了

 {'enjoy': ['python', 'tea'], 'name': 'zhangsan'}

 >>> id(d["enjoy"]) #查看d['enjoy']的内存地址 与e['enjoy']的内存地址相同，说明是同一对象，copy只进行了浅拷贝，并没有对enjoy列表进行拷贝，只是引用

 49135752L

 >>> id(e["enjoy"])

 49135752L

 >>> import copy  #引入copy模块进行 深拷贝

 >>> d

 {'enjoy': ['python', 'tea'], 'name': 'zhangsan'}

 >>> z =copy.deepcopy(d) #深拷贝

 >>> z

 {'enjoy': ['python', 'tea'], 'name': 'zhangsan'}

 >>> id(d),id(z)  #可看出d和z 是不同的两个对象

 (13708280L, 13720296L)

 >>> id(d['enjoy']),id(z['enjoy'])  #可看出d['enjoy']和z['enjopy'] 内存地址不同，是两个不同对象

 (49135752L, 50109128L)

 >>> help(dict.clear)

 Help on method_descriptor:

 clear(...)

     D.clear() -> None.  Remove all items from D. #删除字典中的所有元素

 >>> z

 {'enjoy': ['python', 'tea'], 'name': 'zhangsan'}

 >>> z.clear() #清除字典z中的元素

 >>> z   #字典中的元素为空，字典存在，没有删除字典

 {}

 >>> del z  #删除字典可用del

 >>> e

 {'enjoy': ['python', 'tea'], 'name': 'zhangsan'}

 >>> e ={}  #清空字典中的元素可以使用e={}

 >>> e

 {}

 >>>

 >>> help(dict.get)

 Help on method_descriptor:

 get(...)

     D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None. 如果k存在于d中则返回key所对应的值,否则默认返回None

 >>> d = {"enjoy":["python","tea"],"name":"zhangsan"}

 >>> d

 {'enjoy': ['python', 'tea'], 'name': 'zhangsan'}

 >>> d.get("name") #返回指定键name，所对应的值

 'zhangsan'

 >>> d.get("enjoy") #返回指定键enjoy,所对应的值

 ['python', 'tea']

 >>> d["name"]  #这种方式也可以获取，与d.get()的区别，就是如果字典中没有key值，将会报错keyError 如下示例

 'zhangsan'

 >>> d.get("teacher") #如果d.get("teacher")不存在则返回默认值none

 >>> d.get("teacher","laoshi") #如果d.get("teacher")不存在，则返回后面的值

 'laoshi'

 >>> d["teacher"]

 Traceback (most recent call last):

   File "<stdin>", line 1, in <module>

 KeyError: 'teacher'

 >>>

 >>> help(dict.setdefault)

 Help on method_descriptor:

 setdefault(...)

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

 >>> d

 {'enjoy': ['python', 'tea'], 'name': 'zhangsan'}

 >>> d.setdefault("name")  #取出d中key为name的值

 'zhangsan'

 >>> d.setdefault("city","beijing") #city 不存在与字典中，则将city添加与字典中，city为key,beijing为value

 'beijing'

 >>> d

 {'enjoy': ['python', 'tea'], 'city': 'beijing', 'name': 'zhangsan'}

 >>> d.setdefault("teacher")  #teacher 不存在于字典中，则将teacher 作为key，value为none加入字典中

 >>> d

 {'enjoy': ['python', 'tea'], 'city': 'beijing', 'name': 'zhangsan', 'teacher': None}

 >>>

 >>> help(dict.items)

 Help on method_descriptor:

 items(...)

     D.items() -> list of D's (key, value) pairs, as 2-tuples #通过字典items方法得到的是含有字典key value元组为元素的列表

 >>> d

 {'enjoy': ['python', 'tea'], 'city': 'beijing', 'name': 'zhangsan', 'teacher': None}

 >>> d.items() #得到key、value元组为元素的列表

 [('enjoy', ['python', 'tea']), ('city', 'beijing'), ('name', 'zhangsan'), ('teacher', None)]

 >>> help(dict.iteritems)

 Help on method_descriptor:

 iteritems(...)

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

 >>> d_iter=d.iteritems()

 >>> type(d_iter)

 <type 'dictionary-itemiterator'>

 >>> d_iter

 <dictionary-itemiterator object at 0x00000000013EDD68>

 >>> list(d_iter)

 [('enjoy', ['python', 'tea']), ('city', 'beijing'), ('name', 'zhangsan'), ('teacher', None)]

 >>>

 >>> help(dict.keys)

 Help on method_descriptor:

 keys(...)

     D.keys() -> list of D's keys  #用这个方法，得到一个列表，这个列表是以字典key为元素来组成的

 >>> d

 {'enjoy': ['python', 'tea'], 'city': 'beijing', 'name': 'zhangsan', 'teacher': None}

 >>> d.keys() #得到字典中所有的key

 ['enjoy', 'city', 'name', 'teacher']

 >>> d.iterkeys() #迭代器

 <dictionary-keyiterator object at 0x00000000013EDE58>

 >>>

 >>> d.values()  #得到字典value的列表

 [['python', 'tea'], 'beijing', 'zhangsan', None]

 >>> d.itervalues() #迭代器

 <dictionary-valueiterator object at 0x00000000013EDE58>

 >>>

 >>> help(dict.pop)

 Help on method_descriptor:

 #参数至少有一个key,相应着会返回一个字典中key所对应的value.
　　#如果字典中没有key,就返回第二个参数d的值，但如果d的值不写，就会报错

 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

 >>> d

 {'enjoy': ['python', 'tea'], 'city': 'beijing', 'name': 'zhangsan', 'teacher': None}

 >>> d.pop("enjoy")#删除enjoy键值对，返回的是enjoy对应的value值

 ['python', 'tea']

 >>> d

 {'city': 'beijing', 'name': 'zhangsan', 'teacher': None}

 >>> d.pop("enjoy","python") #在字典d中已经没有enjoy这个键值对，返回第二个参数python

 'python'

 >>>

 >>> help(dict.popitem)

 Help on method_descriptor:

 popitem(...)

     D.popitem() -> (k, v), remove and return some (key, value) pair as a

     2-tuple; but raise KeyError if D is empty.

 >>> d

 {'city': 'beijing', 'name': 'zhangsan', 'teacher': None}

 >>> d.popitem()   #返回删除的键值对，每次只能删除一个，且是随机删除一个键值对，如果已经没有键值对了，再去删除就会报错

 ('city', 'beijing')

 >>> d.popitem()

 ('name', 'zhangsan')

 >>> d.popitem()

 ('teacher', None)

 >>> d.popitem()

 Traceback (most recent call last):

   File "<stdin>", line 1, in <module>

 KeyError: 'popitem(): dictionary is empty'

 >>>

 >>> help(dict.update)

 Help on method_descriptor:

 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]

 >>> d1={"lang":"python"}

 >>> d2={"name":"zhangsan"}

 >>> d1.update(d2)

 >>> d1

 {'lang': 'python', 'name': 'zhangsan'}

 >>> d2

 {'name': 'zhangsan'}

 >>> d2.update([("city","beijing"),("web","java"),("site","baidu.com")])

 >>> d2

 {'site': 'baidu.com', 'city': 'beijing', 'name': 'zhangsan', 'web': 'java'}

 >>>

 >>> help(dict.has_key)

 Help on method_descriptor:

 has_key(...)

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

 >>> d2.has_key("city") #判断key是否存在

 True

 >>> "city" in d2

 True

 >>>