文章目录

• • 认识字典
  • 创建和使用字典
  • 字典的运算
  • 字典的应用

认识字典

1. 字典

• 字典是容器型数据类型，将{}作为容器的标志，字典中的元素都是键值对，形如：{键1: 值1, 键2: 值2, 键3: 值3, …}
• 字典是可变的（支持增删改）
• 字典是无序的（不支持下标操作）

2. 字典元素（键值对）

• 字典中的所有元素必须是键值对，键和值必须成对出现；字典存数据存的是值，键是用来区分和说明不同的值的。
• 键：任意不可变的数据都可以作为键，实际开发的时候一般将字符串作为key；键是唯一的。
• 值：任何类型的数据都可以作为字典的value。

创建和使用字典

有以下三种方法创建字典

# 字面量语法
student1 = {
    'id': 1001,
    'name': '小青',
    'sex': '女',
    'birthday': '1999-07'
}
print(student1)
# 构造器函数
student2 = dict(id=1002, name='小白', sex='女', birthday='2000-01')
print(student2)

# 生成式语法（推导式语法）
dict1 = {i: i ** 2 for i in range(1, 9)}
print(dict1)

运行结果：

{'id': 1001, 'name': '小青', 'sex': '女', 'birthday': '1999-07'}
{'id': 1002, 'name': '小白', 'sex': '女', 'birthday': '2000-01'}
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64}

还有一种常用的创建字典的方法，将列表和字符串、列表和列表、字符串与字符串压缩并创建字典。

# 可以通过Python内置函数zip压缩两个序列并创建字典
items1 = dict(zip('ABCDE', '12345'))
print(items1)    # {'A': '1', 'B': '2', 'C': '3', 'D': '4', 'E': '5'}
items2 = dict(zip('ABCDE', range(1, 10)))
print(items2)    # {'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5}

list1 = [1, 2, 3]
str1 = 'hello'
list2 = ['xx', 'yy', 'zz']
print(dict(zip(str1, list1)))      # {'h': 1, 'e': 2, 'l': 3} 
print(dict(zip(list2, list1)))     # {'xx': 1, 'yy': 2, 'zz': 3}

遍历列表

student1 = {
    'id': 1001,
    'name': '小青',
    'sex': '女',
    'birthday': '1999-07'
}
# 循环遍历
# 遍历字典中的键
for key in student1:
    print(key, student1[key])
print('-' * 20)
# 遍历字典中的键
for key in student1.keys():
    print(key, student1[key])
print('-' * 20)
# 遍历字典中的值
for value in student1.values():
    print(value)
print('-' * 20)
# 遍历字典中的键值对
for key, value in student1.items():
    print(key, value)

运行结果：

id 1001
name 小青
sex 女
birthday 1999-07
--------------------
id 1001
name 小青
sex 女
birthday 1999-07
--------------------
1001
小青
女
1999-07
--------------------
id 1001
name 小青
sex 女
birthday 1999-07

字典的运算

1. 成员运算可以判定指定的键在不在字典中，索引运算可以通过键获取对应的值或者向字典中加入新的键值对。值得注意的是，字典的索引不同于列表的索引，列表中的元素因为有属于自己有序号，所以列表的索引是一个整数；字典中因为保存的是键值对，所以字典的索引是键值对中的键，通过索引操作可以修改原来的值或者向字典中存入新的键值对。

2. 字典中的键必须是不可变类型，例如整数（int）、浮点数（float）、字符串（str）、元组（tuple）等类型的值；显然，列表（list）和集合（set）是不能作为字典中的键的，当然字典类型本身也不能再作为字典中的键，因为字典也是可变类型，但是字典可以作为字典中的值。

student = dict(id=1002, name='小白', sex='女', birthday='2000-01')
# 成员运算
print('name' in student)                  # True
print('age' in student)                   # False
print('address' not in student)           # True

# 索引运算
# 字典的索引运算放在赋值运算符的左边
# 如果索引对应的键在字典中存在，就更新它的值
student['name'] = '小柔'     
# 如果索引对应的键在字典中不存在，就增加键值对
student['address'] = '四川成都'
print(student)              # {'id': 1002, 'name': '小柔', 'sex': '女', 'birthday': '2000-01', 'address': '四川成都'}
print(student['birthday'])  # 2000-01
# 使用get函数通过key获取value时，如果key不存在，返回None
print(student.get('age'))   # None
# 如果key不存在，返回指定的值
print(student.get('age', 20))  # 20
# 删除键值对
print(student.pop('id'))       # 1002
del student['name']

print(student)            # {'sex': '女', 'birthday': '2000-01', 'address': '四川成都'}
print(student.get('name', '无名氏'))   # 无名氏

# 如果使用索引运算，必须保证键一定存在，否则会报错
if 'birthday' in student:
    print(student['birthday'])    # 2000-01

dict1 = {'A': 100, 'B': 200, 'C': 300}
dict2 = {'D': 400, 'E': 500, 'A': 600}
# 更新字典
dict1.update(dict2)   
print(dict1)       # {'A': 600, 'B': 200, 'C': 300, 'D': 400, 'E': 500}

# 删除 ---> 键必须存在，否则会产生KeyError
del dict1['B']
dict1.pop('C')
print(dict1)      # {'A': 600, 'D': 400, 'E': 500}
# 删除最后一个键值对
dict1.popitem()
print(dict1)     # {'A': 600, 'D': 400}
# 清空字典
dict1.clear()
print(dict1)     # {}

# 如果键存在，返回对应的值，如果不存在，添加一个新的键值对，并返回对应的值
print(dict2.setdefault('A'))         # 600
print(dict2.setdefault('K', 1000))   # 1000
print(dict2)        # {'D': 400, 'E': 500, 'A': 600, 'K': 1000}

字典的应用

例1：输入一段话，统计每个英文字母出现的次数。

import string
str1 = input()
# 英文字母转小写
str1 = str1.lower()
# 产生由26个键为小写英文字母，值为0构成的字典
dict_str = {letter: 0 for letter in string.ascii_lowercase}
# 统计每个英文字母出现的次数
for s in str1:
    if s in dict_str:
        dict_str[s] += 1
for letter, count in dict_str.items():
    print(f'{letter}: {count}')

调用string库中的ascii_lowercase变量可以得到26个小写英文字母。

例2：在一个字典中保存了股票的代码和价格，找出股价大于100元的股票并创建一个新的字典，找出价格最高和最低的股票对应的股票代码按照股票价格从高到低给股票代码排序

stocks = {
    'AAPL': 191.88,
    'GOOG': 1186.96,
    'IBM': 149.24,
    'ORCL': 48.44,
    'ACN': 166.89,
    'FB': 208.09,
    'SYMC': 21.29
}

stocks1 = {k: v for k, v in stocks.items() if v > 100}
print(stocks1)   # {'AAPL': 191.88, 'GOOG': 1186.96, 'IBM': 149.24, 'ACN': 166.89, 'FB': 208.09}
# zip可以把两个列表压缩成若干个二元组
print(max(zip(stocks.values(), stocks.keys()))[1])   # GOOG
print(min(zip(stocks.values(), stocks.keys()))[1])   # SYMC

# 按值求最大的，返回最大值对应的键
print(max(stocks, key=stocks.get))         # GOOG
# 按值求最小的，返回最小值对应的键
print(min(stocks, key=stocks.get))         # SYMC
# 按值排序，返回一个排好序的列表，reverse = True表示降序
print(sorted(stocks, key=stocks.get, reverse=True))  # ['GOOG', 'FB', 'AAPL', 'ACN', 'IBM', 'ORCL', 'SYMC']