python-基础(5)-字典

python专栏地址
上一篇: python-基础(4)-list

字典

本节主要介绍

• 字典初始
• 字典的操作

一、字典简单了解

所谓字典，就像我们常用的字典一样，输入一个页码，就到达一页。它有两种方式创建：

• 直接写name={}
• name=dict()

gufeng = {"gufen": 1, "feng": "234"}
gufeng

{'gufen': 1, 'feng': '234'}

type(gufeng)

dict

gufeng = dict()
type(gufeng)

dict

gufeng

{}

gufeng = dict({"gu": 1, "feng": 2})
gufeng

{'gu': 1, 'feng': 2}

二、字典结构操作

• key-value

1、初始化

• 一个个添加
• 一次添加一组
  字典中存放的东西的顺序是乱序的，和添加的顺组无关,打印后顺序有可能会乱

test = {}
test["first"] = 123
test

{'first': 123}

test["python"] = 456
test

{'first': 123, 'python': 456}

# 添加一组
test = {"gu": 123, "feng": 456, "python": 789}
test

{'gu': 123, 'feng': 456, 'python': 789}

test = dict([("gu", 123), ("feng", 456)])
test

{'gu': 123, 'feng': 456}

2、 取值/查找

字典中的查找是通过键值查找，不能通过序号查找
查找有两种，

• 直接通过字典名后跟键值
• 通过get方法

gufeng = {"gu": 123, "feng": 456, "python": 789}
gufeng["python"]

789

# 修改其中元素
gufeng["python"] = 567
gufeng

{'gu': 123, 'feng': 456, 'python': 567}

通过get方法

gufeng.get("wang")

# get方法有个好处是，对于没有的可以做出自己规定的响应
gufeng.get("fengzi", "没有")

'没有'

dishes = {"eggs": 2, "sausage": 1, "bacon": 1, "spam": 500}
keys = dishes.keys()
values = dishes.values()
print(keys)
print(values)

dict_keys(['eggs', 'sausage', 'bacon', 'spam'])
dict_values([2, 1, 1, 500])

3、 数值类型

任何数值类型都行

gufeng_value = [1, 2, 3]
gufeng_value2 = {}
gufeng_value2["gufeng"] = gufeng_value
gufeng_value2["gufeng2"] = 3
gufeng_value2

{'gufeng': [1, 2, 3], 'gufeng2': 3}

这里用到了字典的嵌套

gufeng = {}
d1 = {"gu": 123, "feng": 456}
d2 = {"gu2": 1231, "feng1": 4561}
gufeng["test1"] = d1
gufeng["test2"] = d2
gufeng

{'test1': {'gu': 123, 'feng': 456}, 'test2': {'gu2': 1231, 'feng1': 4561}}

4、键是否存在

通过in查找

d1 = {"gu2": 1231, "feng1": 4561}
"gu2" in d1

True

"hello" in d1

False

gufeng = dict([("gu", 123), ("feng", 456)])
if "gu" in gufeng.keys():
    print("111")

111

5、 字典方法

5.1 clear()

# clear()
d = {}
a = d
d["name"] = "gufeng"
d["age"] = 22
d

{'name': 'gufeng', 'age': 22}

d = {}  # d被清空了
d

{}

a  # a仍然存在

{'name': 'gufeng', 'age': 22}

# 使用clear()清空的方法
d = {}
a = d
d["name"] = "gufeng"
d["age"] = 22
print(d)
m = d.clear()
print(d)
print(a)

{'name': 'gufeng', 'age': 22}
{}
{}

5.2 copy()

从下面的例子可以看出，当在副本替换值时，原始字典不受影响，但是如果修改了某个值（这里修改和替换不一样），原始的字典也会改变

为了解决以上的问题，可以采用深复制的方法，deepcopy().

x = {"username": "admin", "info": ["nishishui", "gufeng", 12]}
y = x.copy()
y["username"] = "gufeng"
y["info"].remove(12)
y

{'username': 'gufeng', 'info': ['nishishui', 'gufeng']}

x

{'username': 'admin', 'info': ['nishishui', 'gufeng']}

x = {"username": "admin", "info": ["nishishui", "wngkai"]}
y = x.copy()
y["info"] = ["ni"]
y

{'username': 'admin', 'info': ['ni']}

x

{'username': 'admin', 'info': ['nishishui', 'wngkai']}

5.3 deepcopy()

from copy import deepcopy

x = {"username": "admin", "info": ["nishishui", "gufeng", 12]}
y = deepcopy(x)
y["username"] = "gufeng"
y["info"].remove(12)
# 与自己发生变化
y

{'username': 'gufeng', 'info': ['nishishui', 'gufeng']}

x  # 不会影响x

{'username': 'admin', 'info': ['nishishui', 'gufeng', 12]}

5.4 fromkeys()

set.fromkeys() 是 Python 中 set 类型的一个类方法，用于创建一个新的集合，该集合包含由指定的可迭代对象提供的元素作为键，并将每个键的值都设置为指定的值。但需要注意的是，由于集合中的元素是唯一的，所以 fromkeys() 方法中的值参数实际上在结果集合中并不会被体现出来，因为集合只关心键（元素）的存在与否，不关心其值。

# 创建一个新的集合，其中元素为 'a', 'b', 'c'，每个元素的值都被设置为一个固定的值（虽然这个值在集合中不体现）  
s = {}.fromkeys(['a', 'b', 'c'], 'some_value')  
print(s)  # 输出：{'a', 'b', 'c'}  
  
# 实际上，你可以不提供值参数，因为集合不关心值  
s = {}.fromkeys(['a', 'b', 'c'])  
print(s)  # 输出：{'a', 'b', 'c'}  
  
# 注意：如果可迭代对象中有重复的元素，它们只会在结果集合中出现一次，因为集合中的元素是唯一的  
s = {}.fromkeys(['a', 'a', 'b', 'c'])  
print(s)  # 输出：{'a', 'b', 'c'}

{'a': 'some_value', 'b': 'some_value', 'c': 'some_value'}
{'a': None, 'b': None, 'c': None}
{'a': None, 'b': None, 'c': None}

5.5 keys() 和iterkeys()

• keys():方法返回一个包含字典所有键的视图对象。这个视图对象是一个动态集合，它会随着字典的改变而改变。你可以遍历这个视图对象来获取所有的键，也可以将其转换为列表或其他数据结构。
  在Python 3中，keys() 返回的是一个视图对象，而不是一个列表。这意味着它支持集合操作，如交集、并集等，而且它的内存占用更小，因为它不需要创建一个新的列表来存储所有的键。
• iterkeys():在Python2中，iterkeys() 方法返回一个迭代器，用于遍历字典的键。迭代器是一个可以记住遍历的位置的对象，它可以从头到尾访问数据集合的元素。与 keys() 返回的列表相比，迭代器更节省内存，因为它不需要一次性加载所有的键到内存中。然而，在Python 3中，iterkeys() 方法已经被移除，取而代之的是 keys() 方法的迭代器行为。也就是说，在Python 3中，keys() 方法返回的就是一个迭代器，你可以直接用它来遍历字典的键，而不需要调用 iterkeys()。这里不在说明iterkeys的用法

# 创建一个字典  
d = {'a': 1, 'b': 2, 'c': 3}  
  
# 使用 keys() 方法获取所有的键，并遍历它们  
for key in d.keys():  
    print(key)  # 输出: a, b, c  
  
# 将 keys() 的结果转换为列表  
key_list = list(d.keys())  
print(key_list)  # 输出: ['a', 'b', 'c']  
  
# 使用 keys() 的结果进行集合操作  
keys1 = {'a', 'b', 'c'}  
keys2 = {'b', 'c', 'd'}  
common_keys = keys1.intersection(d.keys())  
print(common_keys)  # 输出: {'b', 'c'}

a
b
c
['a', 'b', 'c']
{'a', 'b', 'c'}

5.7 get() 获取某个key的值

d1 = {"gu2": 1231, "feng1": 4561}
print(d1.get("gu2"))
print(d1.get("gu3", "3232"))

1231
3232

5.8 pop() 弹出元素

gufeng = dict([("gu", 123), ("feng", 456)])
gufeng.pop("gu")
gufeng

{'feng': 456}

gufeng = dict([("gu", 123), ("feng", 456)])
# 上面的操作类似于del 操作
del gufeng["feng"]
gufeng

{'gu': 123}

5.9 获取所有的value

d1 = {"gu2": 1231, "feng1": 4561}
d1.values()

dict_values([1231, 4561])

if 1231 in d1.values():
    print("gu2")

gu2

5.10 items() 枚举所有值

d1 = {"gu2": 1231, "feng1": 4561}
d1.items()

dict_items([('gu2', 1231), ('feng1', 4561)])

5.11 update() 更新数据

用于将一个新字典的键值对添加到当前字典中，如果键已经存在，则更新其对应的值。

# 创建一个字典  
d = {'a': 1, 'b': 2}  
  
# 创建一个新的字典，包含要更新的键值对  
new_dict = {'b': 3, 'c': 4}  
  
# 使用 update() 方法更新字典 d  
d.update(new_dict)  
  
# 打印更新后的字典  
print(d)  # 输出: {'a': 1, 'b': 3, 'c': 4}

{'a': 1, 'b': 3, 'c': 4}

python 字典的update方法和直接赋值有什么区别

在Python中，字典（dictionary）的update()方法和直接赋值（assignment）都可以用来修改字典的内容，但它们在使用方式和效果上存在一些区别。

• 直接赋值

当你使用直接赋值来修改字典时，你实际上是在替换与特定键相关联的值。如果键已经存在于字典中，它的值会被新值替换；如果键不存在，一个新的键值对会被添加到字典中。

# 创建一个字典
d = {'a': 1, 'b': 2}

# 直接赋值修改一个已存在的键
d['a'] = 3

# 直接赋值添加一个新的键
d['c'] = 4

# 打印修改后的字典
print(d)  # 输出: {'a': 3, 'b': 2, 'c': 4}

• update() 方法

update()方法用于将一个字典的键值对合并到另一个字典中。如果传入的字典中的键在原始字典中已经存在，则这些键对应的值会被更新；如果键不存在，则这些键值对会被添加到原始字典中。

# 创建一个字典
d = {'a': 1, 'b': 2}

# 使用 update() 方法更新字典
d.update({'a': 3, 'c': 4})

# 打印修改后的字典
print(d)  # 输出: {'a': 3, 'b': 2, 'c': 4}

• 区别

1. 操作对象：直接赋值是针对单个键进行的操作，而update()方法是对整个字典进行操作的。

2. 灵活性：update()方法可以接受另一个字典或可迭代的键值对作为参数，从而允许你一次性添加或更新多个键值对。直接赋值则一次只能操作一个键值对。

3. 返回值：直接赋值会返回新赋的值，而update()方法没有返回值（返回None），因为它直接修改了原字典。

4. 使用场景：如果你只需要修改或添加一个键值对，直接赋值通常更直接和简单。但是，如果你需要合并两个字典或添加多个键值对，使用update()方法会更加方便。

5. 性能：对于大量键值对的更新，update()方法可能比多次直接赋值更高效，因为它减少了函数调用和可能的内存分配次数。然而，对于单个键值对的更新，两者在性能上的差异通常可以忽略不计。

python专栏地址
上一篇: python-基础(4)-list
点个关注呗 🤪😝