1. 字典 dict 简介

      字典是 Python 中一种非常非常重要的可变容器类型，且可存储任意类型对象。

      字典的每个元素其实是一对键-值，即 key=>value 两者之间用用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中（你是不是想起来集合了） 。

      相对于之前提的列表可变容器类型，列表可以存储任意类型的数据，但是在字典里面值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组，并且每个键都在此字典中都是唯一的，这点又有点集合的不可变性。

1.1 使用 { } 直接创建字典

      可以直接使用{}创建字典。

>>> a={"a":0,"b":1,"c":2}
>>> b={} #创建空字典
>>> type(a)
<class 'dict'>
>>> type(b)
<class 'dict'>

1.2 使用 dict() 函数创建字典

        dict 函数非常聪明，创建字典有多种方式，适用于不同的场合。

1.2.1 通过关键字dict和关键字参数创建

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

1.2.2 通过二元组列表创建

>>> a=[["a",0],["b",1],["c",2]]
>>> b=dict(a)
>>> type(b)
<class 'dict'>
>>> b
{'a': 0, 'b': 1, 'c': 2}

1.2.3 dict和zip结合创建

>>> a=list("abcde")
>>> b=list(range(5))
>>> a
['a', 'b', 'c', 'd', 'e']
>>> b
[0, 1, 2, 3, 4]
>>> c=dict(zip(a,b))
>>> c
{'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4}

1.2.4 通过字典推导式创建

        通过字典推导式得到字典类似于下面的模式：

        {key_expression : value_expression for 表达式 in 可迭代对象}

>>> a
['a', 'b', 'c', 'd', 'e']
>>> b
[0, 1, 2, 3, 4]
>>> c={a[i]:b[i] for i in range(5)}
>>> c
{'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4}

1.2.5 通过dict.fromkeys()创建

        通过 dict.fromkeys() 可以批量生成相同 value 的字典元素。

>>> a
['a', 'b', 'c', 'd', 'e']
>>> c=dict.fromkeys(a,100)
>>> c
{'a': 100, 'b': 100, 'c': 100, 'd': 100, 'e': 100}

2. 字典也没有切片功能！但是可以直接访问！

2.1 按照 key 值直接访问

        如果知道 key 值，是可以直接访问字典中的 value 值的。

>>> c
{'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, '0': 0, 0: 100}
>>> c["c"]
2
>>> c[0]
100
>>> c["a"]
0

2.1 使用 for 循环遍历

        也可以通过 for 循环依次遍历。

>>> for tmp in c:
	print(tmp,c[tmp])

	
a 0
b 1
c 2
d 3
e 4
0 0
0 100

3. 处理字典的常见内置函数

3.1  len 函数

        len() 函数返回字典里面键-值对的数目。

3.2  map 函数

        map 函数对字典中的每个键 key 进行相同的操作，然后返回一个 map 对象，使用 list 函数可以得到相同个数的列表。

>>> c
{'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4}
>>> list(map(lambda x:x+"1",c))
['a1', 'b1', 'c1', 'd1', 'e1']
>>> 

3.3  filter 函数

        filter 函数对字典中的每个键 key 进行相同的操作，符合条件的元素才留下来，返回一个 filter 类型的对象。

>>> list(filter(lambda x:x.isalpha(),c))
['a', 'b', 'c', 'd', 'e']
>>> list(filter(lambda x:x.isdigit(),c))
[]

3.4  reduce 函数

        reduce 函数依次对字典中的键 key进行相同的迭代操作最后得到一个对象。

>>> c
{'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4}
>>> import functools
>>> functools.reduce(lambda x,y:x+y,c)
'abcde'

3.5 enumerate 函数

         enumerate 函数可以将一个字典中的键 key 依次取出，每个 key 对应着一个元组。

>>> for tmp in enumerate(c):
	print(tmp)

	
(0, 'a')
(1, 'b')
(2, 'c')
(3, 'd')
(4, 'e')

3.6  max 函数

        min() 函数返回字典里面最大的键 key 。

3.7  min 函数

        min() 函数返回字典里面最大的键 key 。

3.8  sorted 函数

        sorted 函数会对字典中的 key 按照指定方式进行排序，请注意，使用 sorted 函数会得到一个排好序的 key 列表，但是原字典不会改变结果。

>>> c
{'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4}
>>> max(c)
'e'
>>> min(c)
'a'
>>> sorted(c)
['a', 'b', 'c', 'd', 'e']
>>> c
{'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4}

3.9 any 函数

        any() 函数用于判断给定的字典的所有 key 是否都为 False，则返回 False，如果有一个为 True，则返回 True。

3.10 all 函数

        all() 函数用于判断给定的字典的所有 key 是否都为 TRUE，如果是返回 True，否则返回 False。

>>> c
{'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4}
>>> any(c)
True
>>> all(c)
True
>>> c["0"]=0
>>> c[0]=100
>>> c
{'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, '0': 0, 0: 100}
>>> any(c)
True
>>> all(c)
False

3.11 set 函数

        对于字典可以使用 set 函数，但是对于字典，它是一个比较鸡肋的功能。

        第一，set 函数会返回字典中的 key ，返回形式为集合；但是字典中的 key 本身是唯一的，所以起不到去重的作用。

        第二，字典有很多种其他方式得到所有的 key  ，比如自带的 keys() 方法。

>>> set(c)
{0, 'a', 'b', 'd', 'c', '0', 'e'}
>>> c
{'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, '0': 0, 0: 100}

4. 字典的内置方法

4.1  .clear(val) 

        删除字典内所有元素，也就是变成空字典，而不是删掉字典本身。

4.2  .copy() 

        返回一个字典的浅拷贝。浅拷贝和深拷贝会在其余章节专门讲。

4.3  .fromkeys(seq ，val)

        创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值。

4.4  .get()

        返回指定键的值，如果值不在字典中返回 default 值。 在直接获得字典指定键的值时候，如果不判断是否在字典中，则会报 KeyError 错。所以可以按照个人编程习惯或者要求，选择读取数据的方式。

        方法一：

>>> c
{'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, '0': 0, 0: 100}
>>> if("as" in c):
	print(c["as"])
else:
	print("as is not in dict c")

	
as is not in dict c

        方法二：

>>> c
{'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, '0': 0, 0: 100}
>>> c.get("as","Not in this dict")
'Not in this dict'

4.5  .items()

        以列表形式返回所有的的(键, 值) 元组数组。

4.6  .keys(val)

        以列表形式返回一个字典所有的键 key。

>>> c
{'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, '0': 0, 0: 100}
>>> c.items()
dict_items([('a', 0), ('b', 1), ('c', 2), ('d', 3), ('e', 4), ('0', 0), (0, 100)])
>>> c.keys()
dict_keys(['a', 'b', 'c', 'd', 'e', '0', 0])
>>> c.values()
dict_values([0, 1, 2, 3, 4, 0, 100])

4.7  .pop(key,default)

        删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。

>>> c.pop(0,"Not in this dict")
100
>>> c.pop("as","Not in this dict")
'Not in this dict'
>>> c
{'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, '0': 0}

4.8  .popitem()

        返回并删除字典中的最后一对键和值。这里所谓的最后一对，不是指按照下标，因为字典没有下标，也不是指 key 值的比较大小，而是指进入字典的早晚。

>>> c
{'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6}
>>> c["aa"]=100
>>> c
{'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'aa': 100}
>>> sorted(c)
['a', 'aa', 'b', 'c', 'd', 'e', 'f', 'g']
>>> c.popitem()
('aa', 100)
>>> c.popitem()
('g', 6)
>>> c.popitem()
('f', 5)
>>> c.popitem()
('e', 4)

>>> c={'e': 4, 'f': 5, 'g': 6, 'aa': 100,'a': 0, 'b': 1, 'c': 2, 'd': 3}
>>> c
{'e': 4, 'f': 5, 'g': 6, 'aa': 100, 'a': 0, 'b': 1, 'c': 2, 'd': 3}
>>> c.popitem()
('d', 3)
>>> c.popitem()
('c', 2)
>>> c.popitem()
('b', 1)
>>> c.popitem()
('a', 0)

4.9  .setdefault()

        和 get() 类似, 但如果键不存在于字典中，将会添加键并将值设为default。用户可以根据返回值来判断是否添加或者只是简单读取。

>>> c.setdefault("A","Coming")
'Coming'
>>> c
{'e': 4, 'f': 5, 'g': 6, 'aa': 100, 'A': 'Coming'}
>>> c.setdefault("e","Coming")
4

4.10 .update(dict2)

        把字典 dict2 的键/值对更新到 dict 里。

4.11 .values()

        以列表返回字典中的所有值

5. 字典和运算符

5.1 in 、not in 运算符

        in，not in 是与字典中的 key 值进行判断。

~~~~~~~~~~~~~~~~~~~~~求点赞，求收藏~~~~~~~~~~~~~~~~~~~~~~·~~

最后

以上就是妩媚黑裤为你收集整理的Python 内置数据类型 05----字典1. 字典 dict 简介2. 字典也没有切片功能！但是可以直接访问！3. 处理字典的常见内置函数4. 字典的内置方法5. 字典和运算符的全部内容，希望文章能够帮你解决Python 内置数据类型 05----字典1. 字典 dict 简介2. 字典也没有切片功能！但是可以直接访问！3. 处理字典的常见内置函数4. 字典的内置方法5. 字典和运算符所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。