Python 字典(dict)介绍

字典 dict

1.字典是一种可变的容器，可以存储任意类型的数据

2.字典中的每个数都是用“键”（key）进行索引，而不像序列可以用下标进行索引

3.字典中的数据没有先后关系，字典的存储是无序的

4.字典中的数据以键（key）-值 （value） 对的形式进行存储.

5.字典的键不能重复，且只能用不可变类型作为字典的键 

字典的字面值表示方法：

字典的表示方式是用 {} 括起来，以冒号（：）分隔键-值对，各键值对之间用逗号分隔开

创建空字典的字面值：   type（查询类型）

d = {}  # 空字典

创建非空的字典

d ={"姓名"："小张"，"年龄"：20}
d ={1:"一"，2："二"，5："五"}

dict的构造（创建）函数dict

dict()    　　　　# 生成一个空的字典，等同于{}
dict(iterable)   # 用可迭代对象创建一个字典
dict(**kwargs)   # 用关键字传参形式生成一个字典
# 　　(字典的键名必须是符合标识符命名规则的字符串)

# 示例：
d = dict（） 
L = [（"姓名","小张"）,["年龄",20],"AB"]
d = dict(L)
d = dict(name="小张",age=20)

字典的键（key）必须为不可变的数据类型，可以用数字，字符串，元组等充当字典的键

python3中不可变的数据类型：

bool，int，float，complex，str，tuple，frozenset（固定集合），bytes（字节串）
包括：None

python3中可变的数据类型：

# 列表list，字典dict，set（集合），bytearray（字节数组）
#    （键 必须是不可改变的  值可以改变）
# 示例：
d = {"a":100}
d = {"a":(1,2,3)}
d = {(1,2,3):"a"}
d = {"a":[1,2,3]}
d = {[1,2,3]:"a"} #报错
d = {"a":{"b":100,"c":200}}
d = {{1:"一"}:"壹"}  # 报错，字典不能做键

字典的基本操作

# 字典的键索引
#    用[]运算符可以获取字典内“键”所对应的“值”
# 取值语法：
#    变量 = 字典[键]
# 示例：
d = {"name":"tarena","age":20}
print(d["name"],"今年",d["age"],"岁")

添加和修改字典的键值对

# 语法：
#    字典[键] = 表达式
# 说明：
#    键不存在，创建键，并绑定键对应的值
#    键存在，修改键绑定的值
# 示例：
d = {}
d{"name"} = "tarena" # 创建新建值对
d["age"] = 15
d["age"] = 16 # 修改age 键对应的值为16

删除字典的元组 del语句

# 语法：
#    del 字典[键]
# 作用：
#    删除字典的键，同时解除对值的绑定
# 示例：
d = {"name":"tarena","age":20}
del d["age"]

in / not in 运算符

# 用于字典中，in 运算符用来判断一个键是否在于字典中，如果存在则返回True，否则返回False
#　　not in（不在序列元素） 与 in（在序列元素） 结果相反

# 示例：
d = {"name":"tarena","age":15}
"name" in d    #true
30 in d        # False
"tarena" in d  # False
15 not in d    # True 
# 注：只判断键是否在，不判断值是否存

练习

# 练习：
# 写程序，实现以下要求：
# 1.将如下数据形成一个字典seasons
# "键"        "值"
# 1  ----->  "春季有1,2,3月"
# 2  ----->  "夏季有4,5,6月"
# 3  ----->  "秋季有7,8,9月"
# 4  ----->  "冬季有10,11,12月"
# 让用书输入一个整数代表这个季度，打印这个季度的信息，如果用户输入的信息不在字典内，则打印“信息不存在”

# 方法1
seasons = {
    1 : "春季有1,2,3月",
    2 : "夏季有4,5,6月",
    3 : "秋季有7,8,9月",
    4 : "冬季有10,11,12月",
    }
print(seasons)

# 方法2
t = {}
t[1] = "春季有1,2,3月"
t[2] = "夏季有4,5,6月"
t[3] = "秋季有7,8,9月"
t[4] = "冬季有10,11,12月"
x = int(input("请输入季度（1～4）"))
if x in t:
    print(t[x])
else:
    print("信息不存在")

字典是可迭代对象

# 字典只能对键进行迭代访问
d = {"name":"tarnea","birthday":(2002,1,1)}
for k in d :
    print(d)

字典的比较运算：

# 运算符：
== !=
# 说明：
#    只有键和值都完全相同时，才相等，否则不相等
# 示例：
{1:"一",2:"二"} == {1:"一",2:"二"}  #True
{1:"一",2:"二"} == {1:"一",2:"2"}  #False

可以用于字典的内建 函数

len(x)  # 返回字典的键值对的个数
max(x)  # 返回字典的键的最大值
min(x)  # 返回字典的键的最小值
sum(x)  # 返回字典中所有键的和
any(x)  # 真值测试，如果字典中其中一个键为真值则返回True
all(x)  # 真值测试，如果字典全部键为真值才返True

# 示例：
d = {0:"零",5:"伍",8:"捌",3:"叁"}
len（d）  #4
max（d）  #8
min（d）  #0
sum（d）  #16
any（d）  #True
all（d）  #False

字典的方法

# 方法                            # 说明
# D 代表字典对象    
D.clear()                        # 清空字典
D.pop(key)                    　　# 移除键，同时返回此键所对应的值
D.copy()                         # 返回字典D的副本,只复制一层(浅拷贝)
D.update(D2)                 　 　# 将字典 D2 合并到D中，如果键相同，则此键的值取D2的值作为新值
D.get(key, default=None)　　　　   # 返回键key所对应的值,如果没有此键，则返回default
D.keys()                          # 返回可迭代的 dict_keys 集合对象
D.values()                        # 返回可迭代的 dict_values 值对象
D.items()                         # 返回可迭代的 dict_items 对象

# 示例；
d1 = {1:"one",2:"二",3:"三"}
for t in d1.items():
    print(t)  #(1,"one"),(2,"二"),(3:"三")
for k，v in d1.items():
    print("k=",k,"v=",v)

练习

# 写一个程序，输入一个字符串，写程序统计出这个字符串的字符个数的字符的种类
# 如：
# 请输入： ABCDABCABA
# 输出结果：
#    字符 A：4次
#    字符 B：3次
#    字符 D: 1次
#    字符 C：1次
#    （注：不要求输出的顺序）

s = input("请输入一个字符串")
# 统计字符的个数：
# 如果第一次出现这个字符：
# 用这个字符创建字典的键，值为1
# 如果第二次或之后出现这个字符，直接将键对应的值加1
d ={}
for ch in s:
    if ch not in d:  #第一次出现
        d[ch]=1
    else:
        d[ch]+=1
print(d)
for k in d:
    print("字符",k,"次",d[k],"次")

字典推导式：

字典推导式是用可迭代对象依次生成字典内元素的表达式

# 语法：
    # {键表达式:值表达式 for 变量 in 可迭代对象 [if真值表达式]...}
    # 注：[]的内容代表可省略
# 示例：
# 生成一个字典，键为数字（10以内），值为键的平方
d = {x : x **2 for x in range(10)}  
# {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

练习：

# 有如下字符串列表：k = ["tarena","xiaozhang","hello"]
# 生成如下字典：
# d = {"tarena":6,"xiaozhang":9,:"hello":5}
#    注：字典的值为键的长度

d = {k:len(k)for k in l}
print(d)

# 已知有两个字符串列表：
# Nos = [1001,1002,1005,1008]
# names = ["Tom","Jerry","Spike","Tyke"]
# 生成以Nos 中项为键，以names中的项为值的字典
#    打印下
# {1008: 'Tyke', 1001: 'Tom', 1002: 'Jerry', 1005: 'Spike'}

Nos = [1001,1002,1005,1008]
names = ["Tom","Jerry","Spike","Tyke"]

# 方法1
d = {}
for i in range(len(Nos)):
    d[Nos[i]] = names[i]
print(d)

# 方法2
d = {Nos[i]:names[i] for i in range(len(Nos))}
print(d)

# 方法3
d = {}
for n in Nos:
    d[n] = names[Nos.index(n)]
print(d)

# 方法4
d = {n:names[Nos.index(n)] for n in Nos}
print(d)

字典 VS 列表

1.都是可变对象

2.索引方式不同，列表用整数索引，字典用键索引

3.字典的插入，删除，修改的速度可能会快于列表（重要）

4.列表的存储是有序的，字典的存储是无序的