当前位置 博文首页 > 一篇文章带你了解python字典基础

    一篇文章带你了解python字典基础

    作者:wakeyo_J 时间:2021-09-17 18:41

    目录
    • 1. 字典基础知识
      • 字典的基本格式表示
      • 字典的键、值设置要求
        • 1)键的设置要求
        • 2)值的设置要求
    • 2. 字典元素增加
      • 1.利用赋值给字典增加元素
        • 2.利用setdefault()方法给字典增加元素
        • 3. 字典值查找
          • 1.字典名+[key]查找
            • 2.利用get()方法查找
            • 4. 字典值修改
              • 1.利用赋值修改键对应的值
                • 2.利用update()方法修改键对应的值
                • 5. 字典元素删除
                  • 1.利用del函数删除
                    • 2.利用pop()方法删除
                      • 3.利用popitem()方法删除
                      • 6. 字典遍历操作
                        • 1.遍历所有键值对:
                          • 遍历所有键
                            • 遍历所有值
                            • 7. 字典其他操作方法
                              • 1.in成员操作
                                • 2.clear()方法
                                  • 3.copy()方法
                                    • 4.fromkeys()方法
                                    • 总结

                                      1. 字典基础知识

                                      字典:是可变的无序集合,以键值对为基本元素可以存储各种数据类型的集合,用大括号({})表示字典的开始和结束,元素之间用半角逗号(,)分隔。键值对,由键(key)和值(value)组成,中间用冒号(:)分隔。如:“wky”:28。字典属于典型的一对一的映射关系的数据类型。

                                      • 字典可以理解为“映射”,映射是一种键(索引)和值(数据)的对应

                                      在这里插入图片描述

                                      字典的基本格式表示

                                      >>> #空字典
                                      >>> {}
                                      {}
                                      >>> #定义一个元素的字典变量
                                      >>> d1 = {"wky":28}
                                      >>> len(d1)
                                      1
                                      >>> d2 = {"wky":1,"lyj":2}
                                      >>> len(d2)
                                      2
                                      >>> 
                                      

                                      字典的键、值设置要求

                                      1)键的设置要求

                                      (1)唯一性:一个字典对象里所有的键必须是唯一的。

                                      >>> d3={1:"wky",2:"lyj",2:"lyj"}
                                      >>> len(d3)
                                      2
                                      >>> d3={1:"wky",2:"lyj",2:"wa"}
                                      >>> len(d3)
                                      2
                                      

                                      在定义字典变量时,python允许输入重复的元素,但是在调用时,python只会保留最后一个键相同的元素。为了避免出现问题,在定义字典对象时,应该养成严格定义每个元素键并保证键的唯一性的良好习惯。

                                      (2)不可变性,字典在使用过程中不能对元素的键进行直接修改。

                                      >>> d2={"wkys":1,"lyj":2}    #wky错误写成wkys
                                      

                                      2)值的设置要求

                                      在这里插入图片描述

                                      2. 字典元素增加

                                      1.利用赋值给字典增加元素

                                      >>> d2 = {"wky":1,"lyj":2}
                                      >>> d2["wa"]=3
                                      >>> d2
                                      {'wky': 1, 'lyj': 2, 'wa': 3}
                                      >>> 
                                      

                                      上述增加元素的前提是:要求字典里没有新增的键,否则会修改指定键的值。

                                      列表变量带中括号与字典变量带中括号之间的区别:
                                      (1)列表:L[x]=value的方法,修改对应的元素,x为指定的下标
                                      (2)字典:D[x]=value的方法,为字典增加新元素,k为指定的键,且k在字典对象中不存在。

                                      2.利用setdefault()方法给字典增加元素

                                      setdefault()使用格式为D.setdefault(k[,d])。D代表字典对象,k代表新增键,d代表新增键对应的值(若不提供值,则默认值为None)

                                      >>> d1={"wky":1,"lyj":2}
                                      >>> d1.setdefault("wa",10)
                                      10
                                      >>> d1
                                      {'wky': 1, 'lyj': 2, 'wa': 10}
                                      >>> d1.setdefault('wake')
                                      >>> d1
                                      {'wky': 1, 'lyj': 2, 'wa': 10, 'wake': None}
                                      >>> 
                                      

                                      用setdefault()方法新增键值对时,若指定键已经存在,则只显示已经存在键的值。

                                      3. 字典值查找

                                      1.字典名+[key]查找

                                      >>> d2={'wky': 1, 'lyj': 2, 'wa': 10, 'wake': None}
                                      >>> d2["lyj"]
                                      2
                                      

                                      若指定的键在字典对象中不存在会报错。

                                      >>> d2={'wky': 1, 'lyj': 2, 'wa': 10, 'wake': None}
                                      >>> d2['w']
                                      Traceback (most recent call last):
                                        File "<pyshell#28>", line 1, in <module>
                                          d2['w']
                                      KeyError: 'w'         #提示键出错
                                      

                                      2.利用get()方法查找

                                      get()方法使用格式D.get(k[,d]),D代表字典对象,k为指定的键,d为键对应的值。

                                      >>> d2={'wky': 1, 'lyj': 2, 'wa': 10, 'wake': None}
                                      >>> d2.get("wky")
                                      1
                                      >>> #查找字典中不存在的键
                                      >>> d2.get('w')
                                      >>> 
                                      

                                      get()方法指定的键在字典中不存在时返回空值。

                                      4. 字典值修改

                                      1.利用赋值修改键对应的值

                                      >>> d2={'wky': 1, 'lyj': 2, 'wa': 10, 'wake': None}
                                      >>> d2["wake"]=99
                                      >>> d2
                                      {'wky': 1, 'lyj': 2, 'wa': 10, 'wake': 99}
                                      >>> 
                                      

                                      2.利用update()方法修改键对应的值

                                      update()方法的使用格式D.update(d1),D代表要更新的字典对象,d1为提供更新内容的字典。若d1中提供的键在D中,则更新D里对应的键值,若不存在,则增加键值对。

                                      1)更新字典里键对应的值

                                      >>> d1={'wky': 1, 'lyj': 2, 'wa': 10, 'wake': None}
                                      >>> d2={"wky":10,"wake":89}
                                      >>> d1.update(d2)
                                      >>> d1
                                      {'wky': 10, 'lyj': 2, 'wa': 10, 'wake': 89}
                                      

                                      2)新增键值对

                                      >>> d1={'wky': 1, 'lyj': 2, 'wa': 10, 'wake': None}
                                      >>> d1.update({"wakeyo":100})
                                      >>> d1
                                      {'wky': 10, 'lyj': 2, 'wa': 10, 'wake': 89, 'wakeyo': 100}
                                      

                                      5. 字典元素删除

                                      1.利用del函数删除

                                      >>> d1={'wky': 10, 'lyj': 2, 'wa': 10, 'wake': 89, 'wakeyo': 100}
                                      >>> del(d1["wakeyo"])
                                      >>> d1
                                      {'wky': 10, 'lyj': 2, 'wa': 10, 'wake': 89}
                                      >>> 
                                      

                                      2.利用pop()方法删除

                                      pop()方法使用格式D.pop(k[,d]),D代表字典,k代表需要删除的元素的键,d为键对应的值(可选)。

                                      >>> d1={'wky': 10, 'lyj': 2, 'wa': 10, 'wake': 89}
                                      >>> pl=d1.pop('wake')
                                      >>> pl
                                      89
                                      >>> 
                                      

                                      3.利用popitem()方法删除

                                      popitem()方法使用格式D.popitme(),D代表字典,随即返回一个键值对元组,并在字典里删除对应的元素。

                                      >>> d1={'wky': 10, 'lyj': 2, 'wa': 10, 'wake': 89}
                                      >>> k1,v1=d1.popitem()
                                      >>> k1,v1
                                      ('wake', 89)
                                      >>> d1
                                      {'wky': 10, 'lyj': 2, 'wa': 10}
                                      >>> t1=d1.popitem()
                                      >>> t1
                                      ('wa', 10)
                                      >>> type(t1)
                                      <class 'tuple'>
                                      >>> 
                                      

                                      del函数、pop()方法、popitem()方法若对不存在的元素进行操作时,都将报错。

                                      6. 字典遍历操作

                                      1.遍历所有键值对:

                                      利用items()方法遍历所有键值对

                                      items()方法使用格式D.items(),D代表字典,以元组形式返回字典的所有元素。

                                      >>> d1={'wky': 10, 'lyj': 2, 'wa': 10, 'wake': 89}
                                      >>> for get_l in d1.items():
                                      	print(get_l)
                                      #结果	
                                      ('wky', 10)
                                      ('lyj', 2)
                                      ('wa', 10)
                                      ('wake', 89)
                                      
                                      >>> d1.items()
                                      dict_items([('wky', 10), ('lyj', 2), ('wa', 10), ('wake', 89)])
                                      >>> type(d1.items)
                                      <class 'builtin_function_or_method'>
                                      >>> 
                                      

                                      遍历所有键

                                      1)利用字典变量循环遍历

                                      >>> d1={'wky': 10, 'lyj': 2, 'wa': 10, 'wake': 89}
                                      >>> for gets in d1:
                                      	print(gets)
                                      

                                      #结果
                                      wky
                                      lyj
                                      wa
                                      wake

                                      2)利用keys()方法获取字典键

                                      >>> d1={'wky': 10, 'lyj': 2, 'wa': 10, 'wake': 89}
                                      >>> for get_l in d1.keys():
                                      	print(get_l)

                                      #结果
                                      wky
                                      lyj
                                      wa
                                      wake

                                      遍历所有值

                                      1)通过键遍历值

                                      >>> d1={'wky': 10, 'lyj': 2, 'wa': 10, 'wake': 89}
                                      >>> for get_key in d1:
                                      	print(d1[get_key])
                                      

                                      #结果
                                      10
                                      2
                                      10
                                      89

                                      2)利用values()方法获取字典值

                                      >>> d1={'wky': 10, 'lyj': 2, 'wa': 10, 'wake': 89}
                                      >>> for get_v in d1.values():
                                      	print(get_v)

                                      #结果
                                      10
                                      2
                                      10
                                      89

                                      7. 字典其他操作方法

                                      1.in成员操作

                                      >>> d1={'wky': 10, 'lyj': 2, 'wa': 10, 'wake': 89}
                                      >>> if "wky" in d1.keys():
                                      		print("wky在字典里")
                                      	else:
                                      		print("wky不在字典里")
                                      
                                      wky在字典里
                                      

                                      2.clear()方法

                                      >>> d1={'wky': 10, 'lyj': 2, 'wa': 10, 'wake': 89}
                                      >>> d1.clear()
                                      >>> d1
                                      {}
                                      

                                      3.copy()方法

                                      >>> d1={'wky': 10, 'lyj': 2, 'wa': 10, 'wake': 89}
                                      >>> d2=d1.copy()
                                      >>> d2
                                      {'wky': 10, 'lyj': 2, 'wa': 10, 'wake': 89}
                                      >>> id(d1)
                                      2432414090296
                                      >>> id(d2)
                                      2432414587208
                                      >>> d3=d2
                                      >>> id(d3)
                                      2432414587208
                                      

                                      通过copy()方法的复制,可以避免字典变量之间直接赋值指向同一个地址。

                                      4.fromkeys()方法

                                      fromkeys()方法使用格式D.fromkeys(iterable),D代表字典,iterable代表列表对象,用于指定字典键,生成的D的键对应的值默认为None。

                                      >>> d1={}.fromkeys(["wky","lyj","wa"])
                                      >>> d1
                                      {'wky': None, 'lyj': None, 'wa': None}
                                      >>> 
                                      

                                      总结

                                      本篇文章就到这里了,希望能给你带来帮助,也希望您能够多多关注站长博客的更多内容!

                                      jsjbwy
                                      下一篇:没有了