python之字典相关

1.概述

字典是唯一的映射关系，元组列表都是序列关系

映射关系和序列关系的简单比较：

1.序列只能使用数字键（下标），映射的键可以是任意类型的不可变的数据

2.序列是有序排列的数据结构，而映射是无序排列的数据结构

3.序列是通过下标来进行索引，映射是通过键值来映射值

字典的特点：

1.可变的数据结构

2.无序的数据结构

3.字典可以添加、删除更新，自带你对象能够自动扩展或收缩结构，保证元素能够紧密组织在一起

4.字典内的个体为元素，字典可以由一个或多个元素组成

5.字典通过大括号进行定义，元素之间通过逗号进行分隔

 2.定义字典

1.使用大括号n

语法格式：

        {键1：值1，键2：值2，键3：值3，........键n:值n}

注意：

键名是唯一，不可变的，如果有两个相同的键名，后面的会覆盖前面的数据，键名是不可变的，如数字、字符串和列表，不能为列表、字典集合等可变数据

值可以是任意类型的，也可以是重复的

具体例子：

a = {}
b = {"a":1,"b":2,"c":3}
c = {1:1,2:2,3:3}
d = {"q":7,3:"f","d":6}
print(a)
print(b)
print(c)
print(d)

2.使用dict()函数

• 定义空值  dict()
• dict(键名=值，键名=值，键名= 值，.........,键名=值)

键值的命名必须遵从标识符的命名规则，不能加引号

• dict(zip)         

 可迭代数据

• 使用enumertate()

3.使用fromkeys()函数

dict.fromkrys(键，值)

3.删除字典

使用del直接删除字典，再次访问，直接抛出异常

直接删除字典，如果没有其他的调用，则直接回收。如果有其他调用，仍然存在。

a = list(range(10))
b = dict.fromkeys(a)
c = b
del b
print(c)
print(b)

4.访问字典

使用中括号的语法

语法格式

        dict  ["键名"]  （键名必须要加“”因为是字符串）

        如果键名不存在则抛出异常

d = {"a":1,"b":2,"c":3}
print(d)
a = d["b"]
print(a)

使用get方法

语法格式：

        dict.get(key,default)

        key:是键名  default:默认值

        如果键名不存在，第二个参数没有指定值，会返回None作为默认值

d = {"a":1,"b":2,"c":3}
print(d.get("d"))
print(d.get("d","该键名不存在"))

使用str()函数

返回字典对象的字符串表示，即字典对象的格式字符串

使用len()函数

获取元素字典对象的长度或者元素个数

5.遍历字典

• 字典对象的方法：

keys()   获取字典对象的所有键名的列表

values()  获取字典对象所有键值的列表

items()   获取字典对象全部项目的列表，每一个项目就是一个元组，元组中第一个元素为键名

• 使用for语句遍历字典对象：

语句格式：

        for  key  in  dict:

                #处理语句

• 例子：

使用for语句遍历整个字典，输出键名和键值

a = list("python")
b = list(range(6))
c = dict(zip(a,b))
print(c)
for key in c:
    print("%s = %s"%(key,c[key]))

keys()   获取字典对象的所有键名的列表

a = list("python")
b = list(range(6))
c = dict(zip(a,b))
print(c)
for key in c.keys():
    print("%s"%(key))

values()  获取字典对象所有键值的列表

a = list("python")
b = list(range(6))
c = dict(zip(a,b))
print(c)
for key in c.values():
    print("%s"%(key))

items()   获取字典对象全部项目的列表

a = list("python")
b = list(range(6))
c = dict(zip(a,b))
print(c)
for key,value in c.items():
    print("%s = %s"%(key,value))

6.添加元素

1.使用中括号添加：

dict["key"] = value

键名是唯一的，如果键名重复，则会覆盖原来的值

a = list("python")
b = list(range(6))
c = dict(zip(a,b))
print(c)
d = c["e"] = 5
print(d)
print(c)

2.使用setdefault()方法

语法格式：one

        dict.setdefault(key,default=None)

如果指定的键名已存在，则什么也不做，避免覆盖已有的键值

• default默认值为None

a = list("python")
b = list(range(6))
c = dict(zip(a,b))
print(c)
d = c.setdefault("f")
print(d)
print(c)

• 添加键名为f键值为5

a = list("python")
b = list(range(6))
c = dict(zip(a,b))
print(c)
d = c.setdefault("f",5)
print(d)
print(c)

• 添加已有的键名，键值不发生变化

a = list("python")
b = list(range(6))
c = dict(zip(a,b))
print(c)
d = c.setdefault("y",5)
print(d)
print(c)

7.删除元素

• 使用del 

        del  dict[key]    可以快速删除指定键和对应的值

        删除不存在的键名的时候，会抛出异常

a = list("python")
b = list(range(6))
c = dict(zip(a,b))
del c["t"]
print(c)

如果删除一个不存在的键名，则会抛出异常

• 使用pop

        dict.pop(key,default)

        返回值为删除的键值

        当删除不存在键名时，会返回默认的None，如果设置了default就返回设置的

a = list("python")
b = list(range(6))
c = dict(zip(a,b))
print(c)
d = c.pop("t")
print(d)

删除一个不存在的键名

a = list("python")
b = list(range(6))
c = dict(zip(a,b))
print(c)
d = c.pop("a",None)
print(d)
print(c)

• 使用popitem()

        dict.popitem()

        随机的删除键组队，包括键名和键值

a = list("python")
b = list(range(6))
c = dict(zip(a,b))
print(c)
while len(c)>0:
    d = c.popitem()
    print(d)
print(c)

使用clear()

        dict.clear()

        清空字典对象

a = list("python")
b = list(range(6))
c = dict(zip(a,b))
print(c)
c.clear()
print(c)

8.修改元素

dict[key] = value

如果元素已存在，则修改元素的键值。如果该元素不存在，则直接添加该元素

a = list("python")
b = list(range(6))
c = dict(zip(a,b))
print(c)
d = c["t"] = 5
print(c)

如果不存在，则直接加在后面

a = list("python")
b = list(range(6))
c = dict(zip(a,b))
print(c)
d = c["a"] = 5
print(c)

9.检测元素

in  或  not  in 

a = list("python")
b = list(range(6))
c = dict(zip(a,b))
print(c)
if "y" in c :
    del c["y"]
print(c)
if "a"  not in c:
    c["a"] = "a"
print(c)

10.合并字典

语法格式：

        dict.update(dict_new)

如果两个字典对象的值相同，则后面合并的会覆盖原始的值

a = list("python")
b = list(range(6))
c = dict(zip(a,b))
d = dict(zip(b,a))
c.update(d)
print(c)

11.复制字典

浅复制

        只复制引用对象的元素，对子对象不进一步的复制

•         dict.copy()

a = {"a":2,"b":[2,3]}
b = a.copy()
print(a)
print(b)
print(a is b)
print(a == b)
print(id(a["b"]))
print(id(b["b"]))
#浅复制原来的值会发生改变
a["b"].append(3)
print(a)

•         使用copy模块

        import  copy

        复制对象=copy.copy(被复制的字典对象)

深复制

使用copy模块

import copy

复制对象=copy.deepcopy(被复制的字典对象)

import copy
a = {"a":2,"b":[2,3]}
b = copy.deepcopy(a)
print(a)
print(b)
print(a is b)
print(a == b)
print(id(a["b"]))
print(id(b["b"]))
#深复制原来的值会发生改变
a["b"].append(3)
print(b)

12.字典推导式

语法格式：

        {表达式1：表达式2  for 变量  in  可迭代的对象}

        {表达式1：表达式2  for 变量  in  可迭代的对象  if  条件表达式}

将键与值的位置对调

a = {"a":3,"b":5}
b = {v:k for k,v in a.items()}
print(b)

将a,b大写小写键名转换为小写，并且值相加，并输出a和b

a = {"a":3,"b":5,"A":10,"B":20,"c":30}
#将键转换为小写，键值为字典a里面的小写和大写相加，默认为零。判断的条件为键值为a和b
b = {k.lower():a.get(k.lower(),0)+a.get(k.upper(),0) for k in a.keys() if k.lower() in ["a","b"] }
print(b)

元素为键长度为值

a = ["a","bb","ccc","dddd"]
b = {key:len(key) for key in a}
print(b)