数据类型详解之字典

数据类型详解-字典

字典是一种数据的集合，由键值对组成的数据集合，字典中的键不能重复，但是值可以；

字典是一种映射类型；

字典中的键必须是不可变的数据类型，常用的键主要为：字符串，整型等。

1.字典的定义：【注意使用dict()函数定义时里面的形参命名】

• 字典可以通过将以逗号分隔的 键: 值 对列表包含于花括号之内来创建字典

• 也可以通过 dict 构造器来创建

  【使用dict()函数进行定义时，key是字符串不能带引号，这里类似关键字传参】

  【使用dict()函数进行定义时，这里就！是！关键字传参！key=value，此时key是默认参数！】

  【给我回头去复习一下函数基本概念里的形参类型！】

  【同样要注意！如果在函数里取key的值，则key要注意带引号】

  【记不住也没关系，调用函数的时候注意看一下括号里应该带什么样的值就好啦】

  a = dict(b=2,c=2,a123=3)
  a['b']=3        
  print(a.get('b'))
  >>>3
  【如果这里写a[b]，a.get(b)，就都是错的！】
  

#1.使用{}定义
a = {'a':1,'b':2,'c':1}
【注意，使用{}时候，key如果是字符串则要带引号】

#2.使用dict()函数进行定义
a = dict(a=1,b='b',c='c')
【注意这里是用=号】
【注意！使用dict()定义时，key只能以不带引号的字符开头，不能是数字】
【为什么呢！因为括号里就是函数的形参！！哪有形参是数字或者字符串的！】
a = dict(b=2,1=2,'1'=3) #这样就是错的
>>>SyntaxError: keyword can't be an expression

#3.数据类型的转换：dict(二级容器类型) 列表或元组
b = [['a',1],['b','b']]
print(dict([['a',1],['b','b']]))
>>>{'a': 1, 'b': 'b'}

#4.zip()压缩函数，dict()转类型，类似第3种
a = (1,2,3,4)
b = ['a','b','c','d']
print(dict(zip(a,b)))
>>>{1: 'a', 2: 'b', 3: 'c', 4: 'd'}

2.字典的操作：增删改查

• 字典没有 + 和 * 操作，这样无法确定key是否重复

• 获取元素：a=dict[key]

  【注意这里！如果key在字典中不存在，则会报错】

  【用dict.get()函数获取key的value，存在则返回，不存在则默认返回None，在下面字典的相关函数里有详写】

a = {1: 'a', 2: 'b', 3: 'c'}
b = dict(a = 1, b = 2, c = 3)
print(a[2],b['a'])
>>>b 1

• 修改元素：dict[key]=value

  a[2] = 123
  print(a)
  >>>{1: 'a', 2: 123, 3: 'c'}
  

• 删除元素：del dict[key]

• 添加元素：dict[key] = value，如果key重复，则变成了修改

3.成员检测和获取

• 成员检测：只能检测key，不能检测value

  a in dict
  a not in dict
  

• 成员获取

  a = {1: 'a', 2: 'b', 3: 'c'}
  # 获取当前字典的长度，即键值对的个数
  res = len(a)
  >>>3
  # 获取当前字典中的所有 key 键，返回列表
  res = a.keys()
  >>>dict_keys([1, 2, 3])
  # 获取字典中所有的 value 值，返回列表
  res = a.values()
  >>>dict_values(['a', 'b', 'c'])
  # 获取当前字典中所有 键值对，返回列表
  res = a.items()
  >>>dict_items([(1, 'a'), (2, 'b'), (3, 'c')])
  

4.字典的遍历

a = {1: 'a', 2: 'b', 3: 'c'}
# 1.在遍历当前的字典时，只能获取当前的key
for i in a:
    print(i) # 只能获取 key
    print(a[i]) # 通过字典的key获取对应value

# 2.遍历字典时，使用 items() 函数，可以在遍历中获取key和value
for k,v in a.items():
    print(k,v)  

# 3. 遍历字典的所有key，和直接遍历字典的结果是一样的
for k in a.keys():
    print(k)

# 4. 遍历字典所有的value
for i in a.values():
    print(i)

5.字典的相关函数

• len(dict)

• dict.keys()

• dict.values()

• dict.items()

• str(dict)：把字典转为字符串，字典的{为字符串的第一个元素

• dict.fromkeys(seq[,value])：

  #创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值，不指定value则默认为None
  i = ('a','b',1)
  b = dict.fromkeys(i,10)
  print(b)
  >>>{'a': 10, 'b': 10, 1: 10}
  

• iter(dict)：返回以字典的键为元素的迭代器

• dict.pop(key[,default])：获取key的value，并删除键为key的字典对

  如果key不存在则返回default，default未给出则报错

  a = {1: 'a', 2: 'b', 3: 'c'}
  b = a.pop(2)
  print(a)
  print(b)
  >>>{1: 'a', 3: 'c'}
     b
      
  b = a.pop(4,'abc')
  print(b)
  >>>abc
  

• dict.popitem()：移除并返回一个键值对，键值对按照LIFO的顺序被返回成元组

  LIFO: Last in, First out.后进先出，是栈

  a = {1: 'a', 2: 'b', 3: 'c'}
  b = a.popitem()
  print(a)
  print(b)
  >>>{1: 'a', 2: 'b'}
     (3, 'c')
  

• dict.get(key[,k])：【注意和上面a=dict[key]的不同】

  #a=dict[key]：如果key在字典中不存在，则会报错
  #用dict.get()函数获取key的value，存在则返回，不存在则默认返回None，也可以自己设定返回的k值
  a = {1: 'a', 2: 'b', 3: 'c'}
  b = a.get(123,'abc')
  print(b)
  >>>abc
  

• dict.update()：【接收的是一个字典对象！】更新字典,如果key存在，则更新其value，key不存在则添加【类似修改操作，只不过dict[key]=value的修改方法一次只能改一个，update()可以多个。如果括号里为空，则返回None。】

  【注意括号里的字典对象，key不能是以数字开头的，因为key是函数的形参啊割割！！！】

  a = dict(b=2,c=2,a123=3)
  a.update(b=1)        #可以直接放key=value
  a.update(dict(a123='a'))  #也可以放dict()函数
  a.update({1:'a','c':456})  #也可以放{}，注意这里的c是字符串，必须带引号
  print(a)
  >>>{'b': 1, 'c': 456, 'a123': 'a', 1: 'a'}
  

• dict.setdefault(key[,default])：如果key存在，则返回它的值，key不存在则添加值为default的键key，并返回default

  【注意一下setdefault和update的区别】

  a = dict(b=2,c=2,a123=3)
  print(a.setdefault(1,123))  #注意这里就可以令key为1
  print(a.setdefault('b',456))
  print(a)
  >>>123
     2
     {'b': 2, 'c': 2, 'a123': 3, 1: 123}
  

6.字典推导式：返回的也是生成器

#把字典的键值反过来
【注意这里，第一次写就出了bug】
a = {'a': 1, 'b': 2, 'c': 3}
for i,j in a.items():
    a[j] = i
print(a)
【看出来问题在哪儿了吗！不能在原字典上直接修改！需要有个缓存来存新字典哇！之前写列表啥的都记得要设置个空列表，怎么这里就忘了】

a = {'a': 1, 'b': 2, 'c': 3}
b = {}
for i,j in a.items():     #也可以用for i in a.keys()做
    b[j] = i
print(b)
>>>{1: 'a', 2: 'b', 3: 'c'}

#用推导式：注意大括号的位置！！
a = {'a': 1, 'b': 2, 'c': 3}
print({j:i}for i,j in a.items())
#还是要注意一下和上面b[j]=i的区别，第一次写就在{}里也写成了a[j]=i
>>><generator object <genexpr> at 0x0000026804E54CC8>
【诶，这里是个生成器】
【那就和元组推导式一样了】
【不不不是因为大括号的位置问题！！！】
print({j:i for i,j in a.items()})
#不取键值对只取键
print({a[i]:i for i in a.keys()})
>>>{1: 'a', 2: 'b', 3: 'c'}

#以下推导式返回的是集合
a = {'a': 1, 'b': 2, 'c': 3}
b = {j for i,j in a.items()}
print(b)
>>>{1, 2, 3}    #是个集合
【注意！取的值是有序集合，如果取的是key，集合是无序的】
b = {i for i,j in a.items()}
print(b)
>>>{'a', 'c', 'b'}
print(b)
>>>{'b', 'a', 'c'}

#对dict里的value求平方
#普通方法
a = {'a': 1, 'b': 2, 'c': 3}
for i in a.keys():
    a[i] **= 2
print(a)

#推导式
b = {i:a[i]**2 for i in a.keys()}
print(b)
>>>{'a': 1, 'b': 4, 'c': 9}

#把字典中的是偶数的值，保留下来，并且交换键值对的位置
a = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
b = {}
for i in a.keys():
    if a[i] % 2 == 0:
        b[a[i]] = i
print(b)

#用推导式
b = {a[i]:i for i in a.keys() if a[i] % 2 == 0}
print(b)

#当然也可以用for i,j in a.items()来做