#!/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])
