python学习笔记：第5天 基本数据类型之字典

目录

• 字典的介绍
  • 1. 字典的创建
  • 2. 增加元素
  • 3. 删除元素
  • 4. 修改元素
  • 5. 查找元素
  • 6. 遍历字典
• 补充

字典的介绍

字典（dict）是python中唯一的一个映射的数据类型，它是以一对一对的键值对的形式组成的一个容器，在python中字典也是可变的，我们也可以在字典中存放各种类型的数据。

• 哈希算法：在存放一个字典时是先根据key计算出一个内存地址，然后将key：value保存在这个内存地址中，这种算法被称为哈希(hash)算法。

• 字典中的key必须是可hash的,也就是字典的值必须具有唯一性.

• 可hash:可hash的意思可以理解为具有唯一性的,一种数据集如果它具有可hash的特性,那这个数据集中的数据肯定具有唯一性
• 可hash数据: int、str、tuple、bool
• 不可hash数据:list、dict、set

1. 字典的创建

In [1]: d1 = {'a':1, 'b':2}

In [2]: d2 = {1: 'a', 2: 'b'}

In [3]: d3 = {(1,): 'a', 2:'b'}            # 使用数字、字符串、和元组作为键值时不会报错

In [4]: d3
Out[4]: {(1,): 'a', 2: 'b'}

In [5]: d4 = {[1,2]: 'a', 3:'b'}           # 但是使用可变数据列表作为键值时会报unhashable type的错误
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-5-35ca200a29d3> in <module>
----> 1 d4 = {[1,2]: 'a', 3:'b'}

TypeError: unhashable type: 'list'

In [6]:

2. 增加元素

In [6]: d1['c'] = 3

In [7]: d1['d'] = (5, 6)                        # 增加一个元素,只需要使用dic[key] = value的方式赋值即可

In [8]: d1
Out[8]: {'a': 1, 'b': 2, 'c': 3, 'd': (5, 6)}

In [9]: d1.setdefault('e', {'name': 'Jerry'})   # 也可以使用setdefault增加元素,具体使用方法下面再介绍
Out[9]: {'name': 'Jerry'}

In [10]: d1
Out[10]: {'a': 1, 'b': 2, 'c': 3, 'd': (5, 6), 'e': {'name': 'Jerry'}}

In [11]:

3. 删除元素

• pop([index])
• popitem()
• clear()
• del dic[index]

In [12]: d1.pop('a')                    # pop用于删除指定的对应key的值
Out[12]: 1

In [13]: d1.popitem()                   # 随机删除
Out[13]: ('e', {'name': 'Jerry'})

In [14]: del d1['b']                    # 使用del删除对变量的引用

In [15]: d1
Out[15]: {'c': 3, 'd': (5, 6)}

In [16]: d1.clear()                     # 清空字典

In [17]: d1
Out[17]: {}

In [18]:

4. 修改元素

In [18]: d2
Out[18]: {1: 'a', 2: 'b'}

In [19]: d2[2] = 'bbbb'                 # 使用dic[key] = value修改

In [20]: d2
Out[20]: {1: 'a', 2: 'bbbb'}

In [21]: d3
Out[21]: {(1,): 'a', 2: 'b'}

In [22]: d2.update(d3)                  # 使用update更新d2中的元素

In [23]: d2
Out[23]: {1: 'a', 2: 'b', (1,): 'a'}

In [24]:

5. 查找元素

In [28]: d2
Out[28]: {1: 'a', 2: 'b', (1,): 'a'}

In [29]: print(d2[(1,)])
a

In [30]: print(d2[2])
b

In [31]: d2.get((1,))
Out[31]: 'a'

In [32]: d2.get(1)
Out[32]: 'a'

In [33]:

6. 遍历字典

字典也是一种可迭代的数据类型,也可以像列表和元组一样通过for循环遍历,字典遍历时这样的:

In [34]: for ele in d2:
    ...:     print(ele)
1
2
(1,)

In [35]:

从上面的例子可以看出,直接遍历字典得到的是字典的key,其实使用字典的keys()方法也可以得到字典的kes:

In [35]: for ele in d2.keys():
    ...:     print(ele)
1
2
(1,)

In [36]:

要获取字典的value要使用values方法可以获得:

In [36]: for ele in d2.values():
    ...:     print(ele)
a
b
a

In [37]:

要同时获取key和value事可以使用item()方法或者遍历key值访问value:

In [40]: for k, v in d2.items():                # 使用items可以遍历出字典的键值对
    ...:     print('{0} => {1}'.format(k, v))
1 => a
2 => b
(1,) => a

In [41]: for k in d2.keys():                    # 通过字典的key获取其值
    ...:     print('{0} => {1}'.format(k, d2[k]))
1 => a
2 => b
(1,) => a

In [42]:

补充

1. setdefault方法:

setdefault方法接收2个参数,第一个是字典的key,第二个是key对应的value值(可以不写,默认为None),如果指定的key在字典中则返回其所对应的值,如果指定的key不在字典中则增加一个以key为键第二个参数(默认为None)为值的元素到字典中。

In [42]: d3
Out[42]: {(1,): 'a', 2: 'b'}

In [43]: d4 = {'a':1, 'b':2, 'c':3, 'd':4}

In [44]: d4.setdefault('b', 20)
Out[44]: 2

In [45]: d4.setdefault('e')

In [46]: D4
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-46-6a0e787d4f48> in <module>
----> 1 D4

NameError: name 'D4' is not defined

In [47]: d4
Out[47]: {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': None}

In [48]: d4.setdefault('f', 30)
Out[48]: 30

In [49]: d4
Out[49]: {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': None, 'f': 30}

In [50]:

2. 封包(解构)解包

In [50]: a, b = 1, 2                  # 可以在一行给多个参数赋值,其实等号的右边是一个元组

In [51]: print(a, b)
1 2                                

In [52]: a, b = (1, 2)                 # 跟上面的效果和实现是一样的,分别给a和b赋值

In [53]: print(a, b)
1 2                                

In [54]: a, b, _, d = [1, 2, 3, 4]     # 也可以解包列表也(不需要的参数可以使用'_'接收)

In [55]: print(a, b, d)
1 2 4                              

In [56]: for ele in d4.items():
   ...:     print(ele)
('a', 1)
('b', 2)
('c', 3)
('d', 4)
('e', None)
('f', 30)

通过上面的例子我们可以看到,使用解包的方法可以把容器里的数据解封装并赋值给其他元素,这样使用解包的特性遍历字典的keys和values就方便多了:

In [60]: for k, v in d4.items():
   ...:     print(k, v)
a 1
b 2
c 3
d 4
e None
f 30

In [61]: