python 學習筆記06: dict（字典）類型的操作

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon Mar 25 22:04:09 2019

@author: sungang
"""

'''
   今天學習python中用資料類型 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版本的不同，不同的版本中，同一個類型的成員函數會有所差別，需要具體對待。
這裡隻是作為一種學習方法的探究。

'''


help('dict')


# 重上面的幫助文檔中我們已經可以看到借用dict類型
# 我們可以對資料來做哪些操作了
# 直覺的了解，dict中的每個元素都是一個鍵值對

# 建立一個dict并初始化;注意dict 使用“{ }”包起來
testdict = {"Jake":12,"Mick":13,"July":11}
print(testdict)  #{'July': 11, 'Jake': 12, 'Mick': 13}

# 先試一下copy和clear函數
copydict = testdict.copy()
print(copydict) # {'July': 11, 'Jake': 12, 'Mick': 13}

testdict.clear()
print(testdict) # {} 很明顯，結果dict對象被清空
print(copydict) # {'July': 11, 'Jake': 12, 'Mick': 13}

del testdict # 銷毀這個變量看看
# print(testdict) #error


# 看看dict類型的增加、删除、修改和查找操作==》貌似基本的資料結構（甚至資料庫）都是這一套
# 重點是我們要比較下dict類型和前面學習到的list、tuple類型有哪些不同。
# 我記得我們中學的化學老師最喜歡balabala的一句話：結構決定性質，性質決定用途
# 感覺資料結構也是這樣的。不過逆向來想，一種資料結構的産生，往往是因為先有了需求（用途），
# 然後創造和誕生的。。。。。

# 增加 
copydict["Dav"] = 14  # {'July': 11, 'Jake': 12, 'Mick': 13, 'Dav': 14}
print(copydict)

# pop()  popitem() ==> 删除
popvalue = copydict.pop("July") # 删除一個鍵值對，存在傳回值，否則傳回 KeyError資訊
print("pop('july') returned %s"%(popvalue))  # pop('july') returned 11

poptuple = copydict.popitem() # 删除the pair，存在傳回一個tuple，否則 raise KeyError
print(poptuple) #('Dav', 14)

# get() ==> 通過鍵找值，存在傳回value，否則傳回None
print( copydict.get("Dav")) # 14

# items()
for key,value in copydict.items():
    print(key,"-",value)
'''
Jake - 12
Mick - 13
July - 11
Dav - 14
'''

# keys()  values() ==> 擷取dict中的keys 和values 并傳回一個list
print(copydict.keys()) # dict_keys(['Jake', 'Mick', 'July', 'Dav'])
print(copydict.values()) # dict_values([12, 13, 11, 14])