Python学习week4-dict字典

1、字典的定义与初始化

1.1、python字典的特点：

• key-value键值对的数据集合；
• 可变的，无序的，key去重；
• key必须为可hash数据类型，value可以为任意数据类型；

1.2、定义与初始化

• 定义方法：

  def __init__(self, seq=None, **kwargs): # known special case of dict.__ini
      """
      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)
      # (copied from class doc)
      """
  (1)d=dict()与d={} # 定义空字典；
  (2)dict(**kwargs) # 使用name=value对初始化一个字典；
  (3)dict(iterable,**kwargs)# 使用可迭代对象和name=value构造字典，不过可迭代对象的元素必须是一个二元结构：
  　　例如：d=dict((['a','1'],['b','2'])) ==> {'a': '1', 'b': '2'}
  (4)dict.fromkeys(iterable,value) # value不给默认为None
  　　d=dict.fromkeys(range(5)) ==> {0: None, 1: None, 2: None, 3: None, 4: None}
  　　d=dict.fromkeys(range(1,5),0)==> {1: 0, 2: 0, 3: 0, 4: 0} 

2、字典的访问

# 访问方法：

(1)d[key]
    返回key对应的value值
    如果key不存在则抛出keyError异常
d=dict.fromkeys(range(1,5),0) # d={1: 0, 2: 0, 3: 0, 4: 0}
print(d[1])  # ==>0

(2)get[key]
    返回key对应的value值
    key不存在返回缺省值，如果没有缺省值则返回None
d=dict.fromkeys(range(1,5),0)

print(d.get(0,'test')) # ==>返回缺省值'test'
print(d.get(0)) # ==>返回默认值None
print(d.get(1)) # ==> 返回找到对应key的value 0
(3)setdefault(key,[,default])
    返回key值对应的value
    If key is in the dictionary, return its value.
    key不存在，则添加kv对，value设置为default,
    如果没有设置default，则为默认值None;
    If not, insert key with a value of default and return default. default defaults to None.

d={i:'a' for i in range(2)} # {0: 'a', 1: 'a'}
s1=d.setdefault(5,'b') # s1='b' d={0: 'a', 1: 'a', 5: 'b'}
s2=d.setdefault(6) 　　# s2=None　　 d={0: 'a', 1: 'a', 5: 'b', 6: None}

3、字典的增加与修改

3.1、字典的增加

（1）dict[key]=value
    将key对应的值直接修改为value；
    key不存在则添加新的kv对；

（2）update([other]) ==> None；
    使用另外一个字典的kv对，更新本字典；
    key不存在则添加，存在则覆盖；
    就地修改（直接修改源字典）

例如：

dic={'a':1,'b':2}
dic.update(c=3,d=4)
print(dic)
'''
{'a': 1, 'b': 2, 'c': 3, 'd': 4}
'''

nd={'f':5,'g':6}
dic.update(nd)
print(dic)
'''
{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'f': 5, 'g': 6}
'''

3.2、字典的删除　

（1）pop(key,[,default])
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存在，移除它，并返回它的value；
    key不存在，返回给点的default，如果default没有设置，则抛出异常

（2）popitem()
def popitem(self): # real signature unknown; restored from __doc__
    """
    D.popitem() -> (k, v), remove and return some (key, value) pair a
    2-tuple; but raise KeyError if D is empty.
    """
    移除并返回任意的键值对；
    字典为空，则抛出异常

4、字典的遍历

(1)遍历key
for key in dict:
    print(k)

for key in d.keys()
    print(k)

(2)遍历value
for key in dict:
    print(dict[key])

for key in d.keys():
    print(d.get(key))

for value in d.values():
    print(value)

(3)遍历item，kv对
for item in d.items():
    print(item)

for item in d.items():
    print(item[0],item[1])

for k,v in d.items():
    print(k,v)

总结：在python3中，keys,values.items方法返回一个类似一个生成器的可迭代对象，不会把函数的结果直接复制返回到内存中；
    1)dictionary view对象，可以使用len(),iter(),in操作
    2)字典的entry的动态的视图，字典变化，视图将反应出这些变化；
    3)keys返回一个类set对象，也就是可以看作一个set集合；如果values都是可hash，那么items也可以看作是一个类set对象；

5、字典遍历与移除

# 字典在遍历的时候不能删除字典元素
d=dict(a=1,b=2,c='abc')

# for k,v in d.items(): # 错误
#     d.pop(k)
#
# while d:
#     for k in d.keys(): # 错误
#         d.pop(k)
# print(d)

'''
运行报错：RuntimeError: dictionary changed size during iteration，字典不能再遍历的时候删除字典元素；
'''

# 正确做法，先找到要删除的key，将key放到一个容器中，然后迭代这个容器

keys=[]

for k,v in d.items():
    # if isinstance(v,str):
        keys.append(k)

for k in keys:
    d.pop(k)
print(d)

6、defaultdict

# 众所周知，在Python中如果访问字典中不存在的键，会引发KeyError异常；

例如统计某个单词出现的次数：

strings = ('puppy', 'kitten', 'puppy', 'puppy',
           'weasel', 'puppy', 'kitten', 'puppy')
d = {}

#for循环遍历
for kw in strings:
    d[kw] += 1 # 报错，keyErr

# 可以使用判断来实现
for kw in strings:
    if kw not in d:
        d[kw]=1
    else:
        d[kw]+=1

# 使用fromkeys实现
d=dict.fromkeys(strings,0)
print(d)
for k in strings:
    if k in d:
        d[k]+=1
#################

以上的方法虽然在一定程度上解决了dict中不存在默认值的问题，但是这时候我们会想，
有没有一种字典它本身提供了默认值的功能呢？答案是肯定的，那就是collections.defaultdict；
defaultdict类就好像是一个dict，但是它是使用一个类型来初始化的；
from collections import defaultdict
d=defaultdict(list) # 这里必须传入一个指定可变类型例如：list,dict

d1=defaultdict(list)
d2=defaultdict(dict)
d1['a'].append(1)
d2['b']=2
print(d1)
print(d2)
'''
defaultdict(<class 'list'>, {'a': [1]})
defaultdict(<class 'dict'>, {'b': 2})
''

# setdefault 可以代替defaultdict

d = {} # A regular dictionary
d.setdefault('a', []).append(1)
d.setdefault('a', []).append(2)
d.setdefault('b', []).append(4)

print(d) # ==>{'a': [1, 2], 'b': [4]}

7、orderedDict

#  collections.Orderdict([items])

#  Orderdict简单的的理解就是给无序的字典加入的顺序功能；

#  具体使用参考：https://www.cnblogs.com/gide/p/6370082.html

from collections import OrderedDict
d = OrderedDict()
d['foo'] = 1
d['bar'] = 2
d['spam'] = 3
d['grok'] = 4
# Outputs "foo 1", "bar 2", "spam 3", "grok 4"
for key in d:
    print(key, d[key])
'''
运行结果：
foo 1
bar 2
spam 3
grok 4
'''