class dict(object):
"""
dict() -> new empty dictionary
创建字典的方式有两种：
1、dic = {}
2、dic = dict()
----------------------------------------------------------------------
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)
"""
def clear(self): # real signature unknown; restored from __doc__
"""
D.clear() -> None. Remove all items from D.
清空字典
"""
pass
def copy(self): # real signature unknown; restored from __doc__
"""
D.copy() -> a shallow copy of D
拷贝一个字典
跟列表的lcopy方法类似，也是一个浅拷贝，如果字典里面嵌套字典或者列表，内层不会
如果需要深拷贝，也要导入copy模块
--------------------------------------------------------------------------
dic3 = {‘k1‘:{‘kk1‘:1},‘k2‘:{‘kk2‘:‘2‘}}
dic4 = dic3.copy()
print(dic3[‘k1‘] is dic4[‘k1‘]) # True
dic3[‘k1‘][‘kk1‘] = ‘kkk1‘
print(dic3)
print(dic4)
"""
pass
@staticmethod # known case
def fromkeys(*args, **kwargs): # real signature unknown
"""
Returns a new dict with keys from iterable and values equal to value.
创建一个新的字典，字典的key是从第一个参数（可迭代对象）里一一获取的，
value值是从第二个参数（任意数据类型），默认是None
注意！这个是一个静态方法，是用dict类直接调用的！！！
---------------------------------------------------------------------------
s = ‘fuyong‘
d1 = dict.fromkeys(s)
print(d1) # {‘g‘: None, ‘n‘: None, ‘f‘: None, ‘y‘: None, ‘u‘: None, ‘o‘: None}
l = [‘a‘,‘b‘,‘c‘]
d2 = dict.fromkeys(l,1000)
print(d2) # {‘a‘: 1000, ‘b‘: 1000, ‘c‘: 1000}
----------------------------------------------------------------------------
"""
pass
def get(self, k, d=None): # real signature unknown; restored from __doc__
"""
D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None.
根据key值来查找value值
如果找不到不会报错，返回None
-------------------------------------------------------------------------------
d1 = {‘a‘:‘b‘}
print(d1.get(‘a‘)) # b
print(d1.get(‘c‘)) # None
"""
pass
def items(self): # real signature unknown; restored from __doc__
"""
D.items() -> a set-like object providing a view on D‘s items
将字典的每一个元素的key和value值放到一个元组里，然后以一个类似列表形式包起来
但是返回值不是一个列表,而是一个dict_items对象
---------------------------------------------------------------
d1 = {‘a‘:1,‘b‘:2}
print(d1.items()) # dict_items([(‘b‘, 2), (‘a‘, 1)])
print(type(d1.items())) # <class ‘dict_items‘>
----------------------------------------------------------------
可以用循环的方式遍历items
for k,v in d1.items():
print(k,v)
# b 2
# a 1
"""
pass
def keys(self): # real signature unknown; restored from __doc__
"""
D.keys() -> a set-like object providing a view on D‘s keys
获取字典所有key，以一个类似于列表的东西包起来，是一个dict_keys对象
可以遍历所有value
------------------------------------------------------------------------
d1 = {‘a‘:1,‘b‘:2}
print(d1.keys()) # dict_keys([‘a‘, ‘b‘])
print(type(d1.keys())) # <class ‘dict_keys‘>
"""
pass
def pop(self, k, d=None): # real signature unknown; restored from __doc__
"""
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
按照指定的key删除一个字典中的元素
如果能找到key值，则会返回删除元素的值
如果找不到指定的key，会报错
---------------------------------------------------------------------------
d1 = {‘a‘:1,‘b‘:2,‘c‘:3}
print(d1.pop(‘a‘))
"""
pass
def popitem(self): # real signature unknown; restored from __doc__
"""
D.popitem() -> (k, v), remove and return some (key, value) pair as a
2-tuple; but raise KeyError if D is empty.
随机删除一个字典里的元素，并且以元组的形式将被删除的键值对返回
如果字典为空则会报错
-------------------------------------------------------------------------
d1 = {‘a‘:1,‘b‘:2,‘c‘:3}
print(d1.popitem()) # 因为是随机删除，每次执行返回值不同
"""
pass
def setdefault(self, k, d=None): # real signature unknown; restored from __doc__
"""
D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
1、如果key值在原字典里存在：
不会被改变
d1 = {‘a‘:1,‘b‘:2,‘c‘:3}
d1.setdefault(‘b‘)
print(d1) # {‘a‘: 1, ‘b‘: 2, ‘c‘: 3}
d1.setdefault(‘b‘,222) # {‘a‘: 1, ‘b‘: 2, ‘c‘: 3}
print(d1)
-----------------------------------------------------------------------------------
2、如果key值在原字典里不存在：
会在字典里添加一个键值对，如果不指定value值，则设置为None
d1 = {‘a‘:1,‘b‘:2,‘c‘:3}
d1.setdefault(‘d‘)
print(d1) # {‘a‘: 1, ‘c‘: 3, ‘d‘: None, ‘b‘: 2}
d1.setdefault(‘e‘,6)
# print(d1) # {‘a‘: 1, ‘c‘: 3, ‘e‘: 6, ‘d‘: None, ‘b‘: 2}
"""
pass
def update(self, E=None, **F): # known special case of dict.update
"""
D.update([E, ]**F) -> None. Update D from dict/iterable E and F.
If E is present and has a .keys() method, then does: for k in E: D[k] = E[k]
If E is present and lacks a .keys() method, then 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 = {‘a‘:1,‘b‘:2,‘c‘:3}
d2 = {‘d‘:4,‘e‘:5}
d1.update(d2)
print(d1) # {‘c‘: 3, ‘a‘: 1, ‘b‘: 2, ‘e‘: 5, ‘d‘: 4}
"""
pass
def values(self): # real signature unknown; restored from __doc__
"""
D.values() -> an object providing a view on D‘s values
获取字典所有value，以一个类似于列表的东西包起来，是一个dict_values对象
可以遍历所有value
-------------------------------------------------------------------------------
d1 = {‘a‘:1,‘b‘:2}
print(d1.values()) # dict_values([2, 1])
print(type(d1.values())) # <class ‘dict_values‘>
"""
pass
dic1 = {}
dic2 = dict()
print(type(dic1),type(dic2))
dic3 = {‘k1‘:{‘kk1‘:1},‘k2‘:{‘kk2‘:‘2‘}}
dic4 = dic3.copy()
print(dic3[‘k1‘] is dic4[‘k1‘]) # True
dic3[‘k1‘][‘kk1‘] = ‘kkk1‘
print(dic3)
print(dic4)
s = ‘fuyong‘
d1 = dict.fromkeys(s)
print(d1)
l = [‘a‘,‘b‘,‘c‘]
d2 = dict.fromkeys(l,1000)
print(d2)
d1 = {‘a‘:‘1,b‘:2}
print(d1.get(‘a‘))
print(d1.get(‘c‘))
d1 = {‘a‘:1,‘b‘:2}
print(d1.items())
print(type(d1.items()))
for k,v in d1.items():
print(k,v)
d1 = {‘a‘:1,‘b‘:2}
print(d1.keys())
print(type(d1.keys()))
d1 = {‘a‘:1,‘b‘:2}
print(d1.values())
print(type(d1.values()))
d1 = {‘a‘:1,‘b‘:2,‘c‘:3}
print(d1.pop(‘a‘))
d1 = {‘a‘:1,‘b‘:2,‘c‘:3}
print(d1.popitem())
d1 = {‘a‘:1,‘b‘:2,‘c‘:3}
d1.setdefault(‘b‘)
print(d1)
d1.setdefault(‘b‘,222)
print(d1)
d1 = {‘a‘:1,‘b‘:2,‘c‘:3}
d1.setdefault(‘d‘)
print(d1)
d1.setdefault(‘e‘,6)
print(d1)
d1 = {‘a‘:1,‘b‘:2,‘c‘:3}
d2 = {‘d‘:4,‘e‘:5}
d1.update(d2)
print(d1)
