python常用数据结构字典梳理

目录

• dict字典
• 字典定义与使用
• 字典使用：创建
• 字典使用：访问元素
• 字典使用：操作元素
• 字典使用：嵌套字典
• 字典常用方法
• values()
• items()
• values()
• get()
• update()
• pop()
• 字典推导式

dict字典

字典定义与使用

字典的定义：

• 字典是无序的键值对集合
• 字典用大括号{}包围
• 每个键/值对之间用一个逗号分隔
• 各个键与值之间用一个冒号分隔
• 字典是动态的

字典使用：创建

创建字典:

• –使用大括号填充键值对
• –通过构造方法dict()
• –使用字典推导式

# 创建字典
# --使用大括号填充键值对
a = {\"name\": \"happy\", \"age\": 18}
print(type(a), a)
# --通过构造方法dict()
b = dict()
print(type(b), b)
c = dict([(\"name\", \"happy\"), (\"age\", 18)])
print(type(c), c)
# --使用字典推导式
d = {i: j for i, j in [(\"name\", \"happy\"), (\"age\", 18)]}
print(type(d), d)

字典使用：访问元素

访问元素:

• –与字典也支持支持中括号记法[key]
• –字典使用键来访问其关联的值
• –访问时对应的key必须要存在

# 访问元素
# --与字典也支持支持中括号记法[key]
# --字典使用键来访问其关联的值
# --访问时对应的key必须要存在
a = {\"name\": \"happy\", \"age\": 18}
print(a[\"name\"])

字典使用：操作元素

语法：dict[key]=value

添加元素:

–键不存在

修改元素:

—键已存在

# 语法：dict[key]=value
# 添加元素
# --键不存在
# 修改元素
# ---键已存在
a = {\"name\": \"happy\", \"age\": 18}
a[\"name\"] = \"lucky\"
print(a)
a[\"sex\"] = \"man\"
print(a)

字典使用：嵌套字典

嵌套字典:字典的值可以是字典对象

# 嵌套字典
# 字典的值可以是字典对象
a = {\'name\': {\'lucky\': 5, \"happy\": 6}, \'age\': 18, \'sex\': \'man\'}
print(a[\'name\'][\"lucky\"])
a[\'name\'][\"lucky\"] = 10
print(a)

字典常用方法

• keys()
• keys()

返回由字典键组成的一个新视图对象

入参：无

返回

# 字典常用方法
# keys()
# 返回由字典键组成的一个新视图对象
# 入参：无
# 返回：
a = {\'name\': \'lucky\', \'age\': 18, \'sex\': \'man\'}
print(a.keys())
print(list(a.keys()))

values()

values()

返回由字典值组成的一个新视图对象

入参：无

返回：

# values()
# 返回由字典值组成的一个新视图对象
# 入参：无
# 返回：
a = {\'name\': \'lucky\', \'age\': 18, \'sex\': \'man\'}
print(a.values())
print(list(a.values()))

items()

values()

返回由字典项（（键，值）对）组成的一个新视图对象

入参：无

返回：

# items()
# 返回由字典项（（键，值）对）组成的一个新视图对象
# 入参：无
# 返回
a = {\'name\': \'lucky\', \'age\': 18, \'sex\': \'man\'}
print(a.items())
print(list(a.items()))

get()

get(key)

获取指定key关联的value值

入参：key:字典的键，必传

返回：

• –如果key存在于字典中，返回key关联的value值。
• –如果key不存在，则返回None

此方法的好处是无需担心key是否存在，永远都不会引发KeyError错误。

# get(key)
# 获取指定key关联的value值
# 入参：key:字典的键，必传
# 返回：
# --如果key存在于字典中，返回key关联的value值。
# --如果key不存在，则返回None
# 此方法的好处是无需担心key是否存在，永远都不会引发KeyError错误。
a = {\'name\': \'lucky\', \'age\': 18, \'sex\': \'man\'}
print(a.get(\"name\"))
print(a.get(\"cc\"))

update()

update(dict)

使用来自dict的键/值对更新字典，覆盖原有的键和值

入参：字典对象，必传

返回:None

# update(dict)
# 使用来自dict的键/值对更新字典，覆盖原有的键和值
# 入参：字典对象，必传
# 返回:None
a = {\'name\': \'lucky\', \'age\': 18, \'sex\': \'man\'}
a.update({\'name\': \'happy\', \'cc\': 18})
print(a)

pop()

pop(key)

删除指定key的键值对，并返回对应value值

入参：

key:必传

返回：

• –如果key存在于字典中，则将其移除并返回value值
• –如果key不存在与字典中，则会引发KeyError

# pop(key)
# 删除指定key的键值对，并返回对应value值
# 入参：
# key:必传
# 返回：
# --如果key存在于字典中，则将其移除并返回value值
# --如果key不存在与字典中，则会引发KeyError
a = {\'name\': \'lucky\', \'age\': 18, \'sex\': \'man\'}
print(a.pop(\"sex\"))
print(a)

字典推导式

字典推导式：可以从任何以键值对作为元素的可迭代对象中构建出字典

实例：给定一个字典对象{"a":1,"b":2,"c":3},找出其中所有大于1的键值对，同时value值进行平方运算。

# 字典推导式：可以从任何以键值对作为元素的可迭代对象中构建出字典
# 实例：给定一个字典对象{\"a\":1,\"b\":2,\"c\":3},找出其中所有大于1的键值对，同时value值进行平方运算。
 
a = {\"a\": 1, \"b\": 2, \"c\": 3}
b = {i: j ** 2 for i, j in a.items() if j > 1}
print(b)