Python 内置容器 之 字典 （ dict ）超详细指南

python 的内置容器  ：    有四个 

                    

                     list （列表）        set （集合）        tuple   （元祖）        dict  （字典）

Dict  ：字典   （ ）

         #   他本质其实也是一种 哈希表 （包装的  键值对！！）

         #    一个键 对应着一个 值 ， 键与键 是不能冲突的（就是不能有两个一模一样的键）

               值 是可以重复的。

         #   在 Python 中， 键（ Key ） 的数据类型 一般就是 数字 字符串 和元祖 ，大多数情况下

              键的数据类型 为 字符串 ！！  键必须是不可变的！！

               值 可以是任意 数据类型！！

  创建  ：  

           #    我们在前面 学习 集合的时候，就说过，集合 和 字典 都是 以 { } 的形式呈现的！！

            

            示例  ：   

 d = { }
>>> type(d)
<class 'dict'>

z = { "name"  : "太极", 5:"是整数",(0.3,0.2,0.1):"是小数"}
>>> type(z)
<class 'dict'>

              上示就是证明 ：  字典中  键  的数据类型 ！！  

            #       zip 方式 创建字典    dict(zip( ))

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

                  注意上示中    'abc'   ： 是 a , b,  c  各自成为一个  键  

name = ['李晨', '刘勇', '赵雪', "王峰"]
grade = ['89', '92', '76', '65']
dict_1 = dict(zip(name, grade))

{'李晨': '89', '刘勇': '92', '赵雪': '76', '王峰': '65'}

            

  访问  ：

                #   字典的访问 是通过   键 来访问 值  的 ！

                示例  ：   第一种 访问 方式  

z["name"]
'太极'
>>> z[5]
'是整数'
>>> z[(0.3,0.2,0.1)]
'是小数'

                示例  :    通过   get   访问  

 z.get("name")
'太极'


z.get(5)
'是整数'

               get  的第二种 访问 方式 ：

 z
{'name': '太极', 5: '是整数', (0.3, 0.2, 0.1): '是小数'}

 z.get("法外狂徒","张三")
'张三'

 z
{'name': '太极', 5: '是整数', (0.3, 0.2, 0.1): '是小数'}

             注  ：  get 的第二种访问方式 不经常用，但是也要知道这种用法 

                    #   可以看到 第二行的 get 新用法 ， 在第一行代码 我们已经说明了 字典 z 里的具体

                          内容，然后，我们执行 第二行代码， 可以发现 z 字典里 就没有 “ 法外狂徒 ” 和 

                          “张三”  的内容呀 ！！！

                          而 我们执行完 第二行代码 给我们 返回来一个 “ 张三 ”

                          所以， get 的第二种用法就是 当 字典中 没有 要访问的 键 的时候("法外狂徒") 会

                          默认将 ( " 法外狂徒 ", " 张三 ") 作为一对 键值对 进行访问 ！！

                          就相当于是  键 ： 法外狂徒    值 ： 张三   

                          但是在执行完 第二行代码后 再 看 字典 z  的内容 还是原来的样子 ，就说明  ：

                          get  的第二种  用法 不会 改变 字典 的内容！！！ 

                    #    倘若，法外狂徒 后面 没有张三 ，即 字典中 就没有这个 键 ，直接 返回 None ! 

 增删改  ： 

                    #  我们知道  不能对 键 做改动，可以对 值 做改动 

                    

                    增  ： 

 z["gender"]="男"
>>> z
{'name': '太极', 5: '是整数', (0.3, 0.2, 0.1): '是小数', 'gender': '男'}

                   

                    删  ： 

del z['name']
>>> z
{5: '是整数', (0.3, 0.2, 0.1): '是小数', 'gender': '男'}

                    我们使用的是  del  

                    改  ：  

                            由于 我们字典中  键 是不能变的，所以 只能对 值 做以 改变 

 z['gender']='女'
>>> z
{5: '是整数', (0.3, 0.2, 0.1): '是小数', 'gender': '女'}

    常见方法  ： 

                          'clear',       'copy',              'fromkeys',           'get',       

                          'pop',       'popitem',          'setdefault',       'update',   

                         'items',          'keys',              'values'

                          keys 

 u1
{'球队名': '迈阿密', '球员名': 'james', '球衣号码': 6}
>>> u1.keys()
dict_keys(['球队名', '球员名', '球衣号码'])

                        #  以列表的形式返回字典中所有的  “ 键 ”

                        values

u1
{'球队名': '热火队', '球员名': 'james', '号码': 6}
>>> u1.values()
dict_values(['热火队', 'james', 6])

                         #   以列表的形式返回字典中所有的   “ 值 ” 

                       items

u1.items()
dict_items([('球队名', '热火队'), ('球员名', 'james'), ('号码', 6)])

                        #   返回一个列表，列表中以元组的形式把字典中的每一对键值对取出 

                        get

u1.get('球员名')
'james'

                        #   通过 键 获取 值 

                       pop

 u1.pop('球队名')
'热火队'
>>> u1
{'球员名': 'james', '号码': 6}

                       #   通过 键 删除 键值对  

                        popitem 

u1['年龄'] = 23
>>> u1
{'球员名': 'james', '号码': 6, '年龄': 23}
>>> u1.popitem()
('年龄', 23)
>>> u1
{'球员名': 'james', '号码': 6}
>>> u1.popitem()
('号码', 6)
>>> u1.popitem()
('球员名', 'james')
>>> u1
{}

                   #   不带参数，是用来删除键值对，先删最后创建的键值对！！

字典的遍历  ：  

        NO : 1         for  key  in  字典对象 

for key in u1 :
...     print(key)
...
球队名
球员名
号码


for key in u1 :
...     print(key,u1[key])
...
球队名 热火队
球员名 james
号码 6

         #  上部分是  返回键            下部分 ： 直接返回   键值对        

        

        NO ：2        for    (key,value)    in   字典对象.items()

for(key,values) in u1.items():
...     print(key,values)
...
球队名 热火队
球员名 james
号码 6

         NO : 3        for  item   in   字典对象.items()

 for items in u1.items():
...     print(items)
...
('球队名', '热火队')
('球员名', 'james')
('号码', 6)

至此，我们  Python   中四个 内置容器已经全部介绍完了！！

注意  ： 当不可变的数据类型，如果包含了可变对象，那么可变对象这部分是可以变化的！！

              

              #   我们学习了 四大容器  列表  字典 元组  集合 ，其中，有的数据类型是可变的，有的是

                   不可变的，我们在实践过程中也要注意 综合来使用会更加灵活！

               示例  :   

 t = (1,2,3,4,5)
>>> t[0]=5
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

              我们知道 元组类型是不可变的，是不能够修改里面的值的，如上示！！！

              倘若 元组 如下所示时 ：

t = (1,2,3,4,5,[1,2,355,88])
>>> t
(1, 2, 3, 4, 5, [1, 2, 355, 88])

               可以看到，元组 t 里面又包含了一个列表 ，这就是所谓的 不可变数据类型包含了可变数

               据对象，因为，列表是可变的！！

               这时，就可以对 其进行修改，但是，注意是只能修改可变对象的那一部分！！

t
(1, 2, 3, 4, 5, [1, 2, 355, 88])
>>> t[5][1]=5
 t
(1, 2, 3, 4, 5, [1, 5, 355, 88])

               可以看到。此时 元组 t 的第5个元素也即 列表发生了变化，列表的第2个元素 2 变为 5！