day02.4-字典内置方法

字典——dict的定义：test = {"k1":18,2:True,"k3":[11,22,("zi","zai")]}

特点：1. 字典是可迭代对象

2. 字典中元素是无序的，字典是可变数据类型

3. 字典中Key值不能重复，列表、元组、字典、集合等不能作为字典的Key值

任何数据类型都可以作为字典的Value值

1. 查看字典中指定Key值对应的Value值

 test = {"k1":18,2:True,"k3":[11,22,("zi","zai")]}
 v1 = test[2]
 v2 = test["k3"][2][0]
 print(v1,v2)
 """
 运行结果：True zi
 结果分析：
     查看字典中Key=2所对应的Value值，返回给变量v1
     查看字典中Key="k3"所对应的Value值，并获取该Value中指定索引位置处的值，返回给变量v2
　　　　当指定Key值不存在时，运行后报错
 """

2. 查看字典中所有Key值

 test = {"k1":18,2:True,"k3":[11,22,("zi","zai")]}
 for item in test.keys():
     print(item)
 """
 运行结果：
     k1
     2
     k3
 结果分析：依次输出字典中所有Key值
 """

3. 查看字典中所有Value值

 test = {"k1":18,2:True,"k3":[11,22,("zi","zai")]}
 for item in test.values():
     print(item)
 """
 运行结果：
     18
     True
     [11, 22, ('zi', 'zai')]
 结果分析：依次输出字典中所有Value值
 """

4. 查看字典中所有Key-Value对值

 test = {"k1":18,2:True,"k3":[11,22,("zi","zai")]}
 for item in test.items():
     print(item)
 """
 运行结果：
     ('k1', 18)
     (2, True)
     ('k3', [11, 22, ('zi', 'zai')])
 结果分析：以元组方式依次输出字典中所有Key-Value对值，
 """

5. 根据输入序列分别创建字典的Key值与Value值

 test1 = dict.fromkeys(["k1",2,"k3"],(11,22,33))
 test2 = dict.fromkeys(["k1",2,"k3"])
 for item in test1.items():
     print(item)
 print("---"*20)
 for item in test2.items():
     print(item)
 """
 运行结果：
     ('k1', (11, 22, 33))
     (2, (11, 22, 33))
     ('k3', (11, 22, 33))
     ------------------------------------------------------------
     ('k1', None)
     (2, None)
     ('k3', None)
 结果分析：
     两个输入序列分别作为字典的Key值和Value值，创建字典的Key-Value对
     当Value值输入序列为空时，所创建字典Key-Value对中Value=None
 """

6. 获取字典中指定Key值对应的Value值。当Key值不存在时，返回指定值，默认值定值为None

 test = {"k1":18,2:True,"k3":[11,22,("zi","zai")]}
 v1 = test.get("k3")
 v2 = test.get("k4",11111)
 v3 = test.get("k4")
 print(v1)
 print(v2,v3)
 """
 运行结果：
     [11, 22, ('zi', 'zai')]
     11111 None
 结果分析：
     获取字典中Key="k3"所对应的Value值
     由于字典中不存在Key="k4"，返回指定值11111，默认指定值为None
     当Value值输入序列为空时，所创建字典Key-Value对中Value=None
 """

7. 设置字典中指定Key值对应的Value值。当Key值存在时，不重新设置Value值；当Key值不存在时，设置对应的Key-Value对值

 test = {"k1":18,2:True,"k3":[11,22,("zi","zai")]}
 test.setdefault("k1",123)
 print(test)
 print("---"*20)
 test.setdefault("k4",123)
 print(test)
 """
 运行结果：
     {'k1': 18, 2: True, 'k3': [11, 22, ('zi', 'zai')]}
     ------------------------------------------------------------
     {'k1': 18, 2: True, 'k3': [11, 22, ('zi', 'zai')], 'k4': 123}
 结果分析：
     字典中存在Key="k1"时，不重新设置其对应的Value值，字典元素保持不变
     字典中不存在Key="k4"时，追加Key="K4"、Value=123的Key-Value对
 """

8. 更新字典中指定Key值对应的Value值。当Key值存在时，更新对应的Value值；当Key值不存在时，根据Key值添加对应的Key-Value对值

 test = {"k1":18,2:True,"k3":[11,22,("zi","zai")]}
 test.update({"k1":123,"k4":456})
 print(test)

 """
 运行结果：{'k1': 123, 2: True, 'k3': [11, 22, ('zi', 'zai')], 'k4': 456}
 结果分析：
     字典中存在Key="k1"时，更新其对应的Value值为123，字典其余元素保持不变
     字典中不存在Key="k4"时，追加Key="K4"、Value=456的Key-Value对
 """

9. 拷贝字典中元素

 test = {"k1":18,2:True,"k3":[11,22,("zi","zai")]}
 v = test.copy()
 print(v)

 """
 运行结果：{'k1': 18, 2: True, 'k3': [11, 22, ('zi', 'zai')]}
 结果分析：将字典test中所有元素拷贝并赋值给v
 """

10. 删除字典中指定Key值对应的Key-Value对，并返回该Key值对应的Value值；当Key值不存在时，返回指定值

 test = {"k1":18,2:True,"k3":[11,22,("zi","zai")]}
 v1 = test.pop("k1")
 print(test)
 print(v1)
 print("--"*20)

 v2 = test.pop("k10",11111)
 print(test)
 print(v2)

 """
 运行结果：
     {2: True, 'k3': [11, 22, ('zi', 'zai')]}
     18
     ----------------------------------------
     {2: True, 'k3': [11, 22, ('zi', 'zai')]}
     11111
 结果分析：
     删除字典中Key="k1"对应的Key-Value对，并返回Value值给v1
     当字典中不存在Key="k10"时，字典元素保持不变，返回指定值11111给v2
 """

11. 随机删除字典中某一Key值对应的Key-Value对，并返回该Key值及其对应的Value值

 test = {"k1":18,2:True,"k3":[11,22,("zi","zai")]}
 k,v = test.popitem()
 print(test)
 print(k,v)

 """
 运行结果：
     {'k1': 18, 2: True}
     k3 [11, 22, ('zi', 'zai')]
 结果分析：随机删除字典中某一Key值对应的Key-Value对，并返回该Key值及其对应的Value值
 """

12. 清空字典中所有元素

 test = {"k1":18,2:True,"k3":[11,22,("zi","zai")]}
 test.clear()
 print(test)

 """
 运行结果：{}
 结果分析：清空字典中所有元素，得到一个空白字典
 """