Python之字典

字典：无序的，可变的键值对集合，字典是另一种可变容器模型，且可存储任意类型对象
字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：

# d = {key1 : value1, key2 : value2 }
# 键必须是唯一的，但值则不必。
# 值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

info = {"name": "cq", "age": 18, "class": "first"}
print(info, type(info))
print(info['name'])
print(info['age'])

输出结果:

{'name': 'cq', 'age': 18, 'class': 'first'} <class 'dict'>
cq
18

# 方式2
# Python 字典 fromkeys() 函数用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。
# fromkeys()方法语法：
# dict.fromkeys(seq[, value])

# 参数：
# seq -- 字典键值列表。
# value -- 可选参数, 设置键序列（seq）的值。

# 返回值：
# 该方法返回一个新字典
# fromkeys:是一个静态方法，类和对象都可以调用

seq = ("name", "age", "class")
dic = dict.fromkeys(seq)
print("新字典为:: ", dic)

dic = dict.fromkeys(seq, 10)
print("新的字典为:: ", dic)

dic = dict.fromkeys([1, 2, 3], 20)
print("新的字典:: ", dic)

输出结果：

新字典为:: {'name': None, 'age': None, 'class': None}
新的字典为:: {'name': 10, 'age': 10, 'class': 10}
新的字典:: {1: 20, 2: 20, 3: 20}

 # 字典定义的注意事项

1：key不能被重复 如果重复了，后值会把前值覆盖掉 

dic = {1: "a", 2: "b", 1: "c"}
print(dic)

输出结果:
{1: 'c', 2: 'b'}

  2：key必须是任意不可变类型

Python字典的实现原理

# 字典类型是Python中最常用的数据类型之一，它是一个键值对的集合，字典通过键来索引，关联到相对的值
# 理论上它的复杂度是O(1)
# 那么dict的内部实现原理是什么呢？
# 在Python中，字典是通过哈希表实现的。
# 哈希表(hash tables)也叫散列表，根据关键值对(Key-value)而直接进行访问的数据结构。它通过把key和value
# 映射到表中的一个位置来访问记录，这种查询速度非常快，更新也快。而这个映射函数叫做哈希函数，存放值的数组叫做
# 哈希表，哈希函数的实现方式决定了哈希表的搜索效率，具体实现过程是：
# 1：数据添加：把key通过哈希函数转换成一个整型数字，然后就将这个整型数字对数组长度进行取余，取余结果就当做数组
# 的下标，将value存储在以该数字为下标的数组空间里

# 2：数据查询：再次使用哈希函数将key转换为对应的数组下标，并定位到数组的位置获取value

# 但是,对key进行hash的时候,不同的key可能hash出来的结果是一样的,尤其是数据量增多的时候这个问题叫做哈希冲突
# 如果解决这种冲突情况呢?通常的做法有两种,一种是链接法,另一种是开放寻址法,Python选择后者

# 开放寻址法中,所有的元素都存放在散列表中,当产生哈希冲突然时,通过一个探测函数计算出下一个候选位置,如果下一个获选
# 位置还是有冲突,那么不断的通过探测函数往下找,直到找到一个空槽来存放插入元素


字典的常用操作

# 增加操作
# dict[key] = value
#   当key在原字典中不存在的时候，即为新增操作

dic = {"name": "xq", "age": 18}
print(dic, id(dic))

dic["height"] = 180
print(dic, id(dic))

输出结果：

{'name': 'xq', 'age': 18} 31652432
{'name': 'xq', 'age': 18, 'height': 180} 31652432

# 删除操作
# del dic[key]
# key必须存在，否则就会报一个keyerror的一个错误

dic = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
# 删除单个元素
del dic['Name']
print("删除Name关键字:: ", dic)

# 删除字典
del dic
# print(dic) 此时再打印访问字典就会报错，dic is not defined

输出结果：
删除Name关键字::  {'Age': 7, 'Class': 'First'}

# 字典clear()方法
# clear()是清空字典内的所有元素的，返回值为None
# 注意：字典本身还存在，只是字典里的内容被清空，注意和del的区别

dic = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
returnValue = dic.clear()
print("returnValue:: ", returnValue)

输出结果：

returnValue::  None

 # 字典的clear()有什么特点呢？

dic = {"name": "xq", "sex": "female", "age": 18}
dic1 = dic
dic.clear()
print("dic:: ", dic)
print("dic1:: ", dic1)
# 可以发现当原字典dic被引用时，想清空原字典中的元素，用clear()方法，dic1字典中的元素也同时被清除了。

输出结果：

dic:: {}
dic1:: {}

# 字典pop()方法 dic.pop(key[, default])
# 移除字典数据pop()方法的作用是：删除指定给定键所对应的值，返回这个值并从字典中把它移除。
# 注意字典pop()方法与列表pop()方法作用完全不同。

dic = {"a": 1, "b": 2}
result = dic.pop("a")
print("result:: ", result)
print("dic:: ", dic)
# 如果给定的key不存在，则返回给定的默认值，如果没有给定默认值，则报错
dic = {"a": 1, "b": 2}
result = dic.pop("a1", 666)
print("result:: ", result)
# dic.pop("a1") 会报错

输出结果：

result:: 1
dic:: {'b': 2}
result:: 666

# 字典popitem()方法
# Python 字典 popitem() 方法随机返回并删除字典中的一对键和值(一般删除末尾对)。
# 如果字典已经为空，却调用了此方法，就报出KeyError异常。

dic = {"name": "xq", "sex": "female", "age": 18}
result = dic.popitem()
print("result:: ", result)
print("dic:: ", dic)

输出结果：

result:: ('age', 18)
dic:: {'name': 'xq', 'sex': 'female'}

# 字典修改操作
# 只能修改值，而不能修改key
# 修改单个键值对：
# dic[key] = value
# 直接设置，如果key不存在，则新增，如果存在，则修改

dic = {"name": "xq", "age": 18}
dic["age"] = 21
print("修改后的字典为:: ", dic)

输出结果：
修改后的字典为::  {'name': 'xq', 'age': 21}

# 批量修改键值对
# oldDic.update(newDic)
# 根据新的字典，批量更新旧字典中的键值对
# 如果旧字典中没有对应的key值，则新增键值对

oldDic = {"name": "xq", "age": 18}
newDic = {"age": 21, "address": "beijing"}
oldDic.update(newDic)
print("更新后字典为:: ", oldDic)

输出结果：

更新后字典为::  {'name': 'xq', 'age': 21, 'address': 'beijing'}

# 字典的查找操作
# 1:获取单个值的情况
# 方式1: dic[key]
# 如果key不存在则会报错

dic = {"name": "xq", "age": 18}
print(dic["age"])

# 方式2:
# dict.get(key, default=None)
# 参数:
# key -- 字典中要查找的键。
# default -- 如果指定键的值不存在时，返回该默认值值。

# Python 字典 get() 函数返回指定键的值，如果值不在字典中返回默认值

dic = {"name": "xq", "age": 18, "address": "beijing"}
v = dic.get("age")
print("v的返回值:: ", v)
result = dic.get("class", 666)
print(result, dic)

输出结果：

v的返回值:: 18
666 {'name': 'xq', 'age': 18, 'address': 'beijing'}

# 方式3:
# dict.setdefault(key, default=None)
# 参数:
# key -- 查找的键值。
# default -- 键不存在时，设置的默认键值。

# Python 字典 setdefault() 方法和get()方法类似, 如果键不存在于字典中，将会添加键并将值设为默认值。

dic = {"name": "xq", "age": 18, "address": "beijing"}
res = dic.setdefault("age")
print("res的返回值:: ", res)
result = dic.setdefault("class", 666)
print(result, dic)

输出结果：

res的返回值:: 18
666 {'name': 'xq', 'age': 18, 'address': 'beijing', 'class': 666}

# 查询所有的值
# 查询所有的键
# 查询所有的键值对

# Python 字典 values() 方法返回一个迭代器，可以使用 list() 来转换为列表，列表为字典中的所有值。
# 注意：Python2.x 是直接返回列表
# 语法
# dict.values()

# 返回值:
# 返回迭代器。

dic = {'Sex': 'female', 'Age': 7, 'Name': 'Zara'}
print("字典所有值为::", list(dic.values()))

输出结果：字典所有值为:: ['female', 7, 'Zara']

# Python3 字典 keys() 方法返回一个迭代器，可以使用 list() 来转换为列表。
# 注意：Python2.x 是直接返回列表

# keys()方法语法：
# dict.keys()

# 返回值：
# 返回一个迭代器

dic = {"name": "xq", "age": 18, "address": "beijing"}
print("字典所有的key值:: ", list(dic.keys()))

输出结果为：字典所有的key值::  ['name', 'age', 'address']

# Python 字典 items() 方法以列表返回可遍历的(键, 值) 元组数组。
# 注意：Python2.x 是直接返回列表
# items()方法语法：
# dict.items()

# 返回值:
# 返回可遍历的(键, 值) 元组数组

dic = {"name": "xq", "age": 18, "address": "beijing"}
print("字典的所有键值对:: ", dic.items())

for i, j in dic.items():
    print(i, "	:", j)

输出结果：

字典的所有键值对:: dict_items([('name', 'xq'), ('age', 18), ('address', 'beijing')])
name : xq
age : 18
address : beijing

# 另外，这几个函数，Python2.x与Python3.x是有一定区别的，请看代码

Python2.x版本下

dic = {"name": "xq", "age": 18, "address": "beijing"}

# 获取所有的值
vs = dic.values()

# 获取所有的key值
ks = dic.keys()

# 获取所有的键值对
its = dic.items()

print(dic)
print(vs)
print(ks)
print(its)

# 此时字典增加一项
dic["sex"] = "female"

print(dic)
print(vs)
print(ks)
print(its)

输出结果：

{'age': 18, 'name': 'xq', 'address': 'beijing'}
[18, 'xq', 'beijing']
['age', 'name', 'address']
[('age', 18), ('name', 'xq'), ('address', 'beijing')]
{'age': 18, 'sex': 'female', 'name': 'xq', 'address': 'beijing'}
[18, 'xq', 'beijing']
['age', 'name', 'address']
[('age', 18), ('name', 'xq'), ('address', 'beijing')]

Python3.x版本下的

dic = {"name": "xq", "age": 18, "address": "beijing"}

# 获取所有的值
vs = dic.values()

# 获取所有的key值
ks = dic.keys()

# 获取所有的键值对
its = dic.items()

print(dic)
print(vs)
print(ks)
print(its)

# 此时字典增加一项
dic["sex"] = "female"

print(dic)
print(vs)
print(ks)
print(its)

输出结果：

{'name': 'xq', 'age': 18, 'address': 'beijing'}
dict_values(['xq', 18, 'beijing'])
dict_keys(['name', 'age', 'address'])
dict_items([('name', 'xq'), ('age', 18), ('address', 'beijing')])
{'name': 'xq', 'age': 18, 'address': 'beijing', 'sex': 'female'}
dict_values(['xq', 18, 'beijing', 'female'])
dict_keys(['name', 'age', 'address', 'sex'])
dict_items([('name', 'xq'), ('age', 18), ('address', 'beijing'), ('sex', 'female')])

看打印的结果可以看出：Python2.x版本下，所有的键、值和键值对结果都是以列表形式呈现的，而Python3.x版本下面都是迭代器形式呈现，而且当我们
往字典里面增加键值对的时候，Python2.x版本下面并不会把新增的键值对放到我们所获取的键、值和键值对里面，Python3.x则不是。

# 遍历
# 1:先遍历所有的key，然后根据key获取对应的值
dic = {"name": "xq", "age": 18, "address": "北京"}

# 先获取所有的keys
keys = dic.keys()

# 遍历所有的keys
for key in keys:
    print(key, "	:", dic[key])

# 2:直接遍历所有的键值对
dic = {"name": "xq", "age": 18, "address": "北京"}

for x,y in dic.items():
    print(x, "	:", y)

dic = {"name": "xq", "age": 18, "address": "北京"}
# 计算
# len(info)
# 计算键的个数
print(len(dic))


# 判定
# x in dic
# 判定dic中的key，是否存在x
print("name" in dic)


# x not in dic
# 判定dic中的key,是否不存在x
print("name" not in dic)

# dic.has_key(key)
#  已经过期，建议使用in来代替，Python2.x还可以使用