14天通晓Python_字典dict_集合set _(五)_

最新推荐文章于 2024-11-07 00:26:41 发布

过了样例就AC

最新推荐文章于 2024-11-07 00:26:41 发布

阅读量171

点赞数

分类专栏： Python程序设计文章标签： python 开发语言

本文链接：https://blog.csdn.net/2301_77431942/article/details/134209984

版权

Python程序设计专栏收录该内容

7 篇文章 0 订阅

订阅专栏

不知不觉今天已经是学习python的第五天，今天主要任务同样也是两个个重要的类型字典dict_集合set，完成了今天，数据类型我们就学完了，之后就是函数了，函数和C++也有不少区别。那我们先一起来看看字典和集合吧，🐳🐳🐳

🍊.dict_字典

🍉 dict_字典的基础概念

python的字典和C++的map类似，简单说：字典是无序、键不重复 且元素只能是键值对的可变的 个容器。每一元素，由两部分组成，一个键对应一个值。

data = { "k1":1,  "k2":2 } # k1对应1，k2对应2

容器
元素必须键值对
键不重复，重复则会被覆盖
data = { "k1":1, "k1":2 } print(data) # {"k1":2} 第一个被第二个覆盖了

字典中对键值得要求：

键：必须可哈希。目前为止学到的可哈希的类型：int/bool/str/tuple；不可哈希的类型：list/set/dict。（集合）
值：任意类型。

 data_dict = {
	"nullptr":666,
	 True:111,
	123:888,
    (11,22,33):["null","C++"，"python"]
    # [1,2,3]:"list" 报错list不可哈希
}

🍉 dict_字典的常用功能

🍌通过键值获取元素

dict 是每一个键对应一个值，我们可以和像 list和 tuple一样靠下标(1,2,3…)一样通过键来获取值，
下面我们来介绍几种方法。

直接获取

my_dicti = {
   'name': 'nullptr',
   'age': 20,
   'hobby': 'coding'
}
name = info['name']  # 获取键'name'对应的值:nullptr
age = info['age']    # 获取键'age'对应的值:20
hobby = info['hobby']  # 获取键'hobby'对应的值:coding

注意，如果字典中不存在请求的键，将引发 KeyError 异常。要你希望避免这种情况，可以使用 .get() 函数

通过 get() 和setdefault() 获取
这两个函数功能一样，推荐使用 get() 更简洁

 my_dict = {
    'name': 'nullptr',
    'age': 20,
    'hobby': 'coding'
}
name = my_dict.get('name') # name = 'nullptr'
name = my_dict.get('height') # 没有'height' 会返回 None
name = my_dict.get('height'，175) # 有就如实返回，没有'height' 我们写入了默认值，则会返回175这个默认值

案例：

 my_dict = {
    'name': 'nullptr',
    'age': 20,
    'hobby': 'coding'
}
data = my_dict.get('name')
if data:
    print(data)  # nullptr
else:
    print("键不存在")

# 字典的键中是否存在 email
if "email" in info:
    data = info.get("email")
    print(data)
else:
	print("不存在") # 不存在

🍌分别获取键，值和键值对

获取键，值，键值对

 my_dict = {
    'name': 'nullptr',
    'age': 20,
    'hobby': 'coding'
}
keys = list(my_dict.keys())  # 获取所有的键并转换为列表
print(keys)  # 输出: ['name', 'age', 'hobby']

values = list(my_dict.values())  # 获取所有的值并转换为列表
print(values)  # 输出: ['nullptr', 20, 'coding']

key_value_pairs = list(my_dict.items())  # 获取所有的键值对并转换为列表
print(key_value_pairs)  # 输出: [('name', 'nullptr'), ('age', 20), ('hobby', 'coding')]

注意：在Python2中字典.keys()直接获取到的是列表，而Python3中返回的是高仿列表，这个高仿的列表有列表的功能，可以被循环显示。所以我们在上面代码加上了list类型转换。不是list，不是list，看到很多别的博客都直接说是list，真不是list！！！

更新键的值

 my_dict = {
    'name': 'nullptr',
    'age': 20,
    'hobby': 'coding'
}

info['age'] = 666  # 更新键'age'：666

# 'height' 没有就在后面添加一个
info['height'] = 180  # 添加新的键值对'('height',180)'

使用 update() 更新

my_dict = {'name': 'python', 'age': 20}
new_data = {'age':888,'hobby': 'coding', 'city': 'Gotham'}
info.update(new_data)
#有重合的就覆盖，  
# 没有重合，就添加新的键值对 'hobby': 'coding' 和 'city': 'Gotham'

🍌删除键值

del 常规删除（del是delet缩写）

my_dict = {'name': 'python', 'age': 20,'hobby': 'coding'}
del my_dict['name']
print(my_dict) #{'age': 20, 'hobby': 'coding'}

**pop()**函数删除


my_dict = {'name': 'python', 'age': 20,'hobby': 'coding'}
data = info.pop("age") # 返回被删除键的值
print(my_dict) # {'name': 'python','hobby': 'coding'}
print(data) # 20

popitem() 随机删除

my_dict = {'name': 'python', 'age': 20,'hobby': 'coding'}
data = my_dict.popitem() # 返回被删除键值对形成的元组
print(my_dict) # {'name': 'python', 'age': 20}
print(data) # ('hobby', 'coding')

clear() 清空字典

my_dict = {'name': 'python', 'age': 20,'hobby': 'coding'}
my_dict.clear()
print(my_dict) # {}

🍉 dict_字典的基本功能

🍌求两个 dict 的并集

n1 = {"k1": 1, "k2": 2}
n2 = {"k2": 22, "k3": 33}

n3 = n1 | n2
print(n3) # {'k1': 1, 'k2': 22, 'k3': 33}

🍌求dict 长度

my_dict = {'name': 'python', 'age': 20,'hobby': 'coding'}
data = len(my_dict)
print(data) # 输出：3

🍌dict 的for循坏

由于字典也属于是容器，内部可以包含多个键值对，可以通过循环对其中的：键、值、键值进行循环；

my_dict = {'name': 'python', 'age': 20,'hobby': 'coding'}
for item in my_dict:
	print(item)  # 所有键
'''
name
age
hobby
'''

my_dict = {'name': 'python', 'age': 20,'hobby': 'coding'}
for item in my_dict.key():
	print(item)
'''
name
age
hobby
'''

my_dict = {'name': 'python', 'age': 20,'hobby': 'coding'}
for item in my_dict.values():
	print(item)
'''
python
20
coding
'''

my_dict = {'name': 'python', 'age': 20,'hobby': 'coding'}
for key,value in info.items():
	print(key,value)
'''
name python
age 20
hobby coding
'''

🍌dict 和其他类型的转换

dict转换为其他
字典的键和值可以转为set ，list ， tuple ，键值对可以转为tuple

keys_list = list(my_dict.keys())  # 转换为键的列表
print(keys_list) #['name', 'age', 'hobby']

values_list = list(my_dict.values())  # 转换为值的列表
print(values_list) # ['python', 20, 'coding']

items_list = list(my_dict.items())  # 转换为键值对的列表，每个元素为元组
print(items_list) # [('name', 'python'), ('age', 20), ('hobby', 'coding')]

my_dict_tuple = tuple(my_dict.items())  # 转换为键值对的元组，每个元素为元组
print(my_dict_tuple) # (('name', 'python'), ('age', 20), ('hobby', 'coding'))

keys_set = set(my_dict.keys())  # 转换为键的集合
print(keys_set) # {'hobby', 'name', 'age'}

只有tuple和list可以转换为dict
因为字典要求具有键值对的结构，所以要转换的类型里面要满足其中每个元素都是一个包含两个元素的子序列，第一个元素是键，第二个元素是对应的值。

# 包含子序列的列表或元组转换为字典
# 子序列是list
data_tuple = (['a', 1], ['b', 2], ['c', 3])
data_dict = dict(data_tuple)

#子序列是元组
data_list = [('a', 1), ('b', 2), ('c', 3)]
data_dict = dict(data_list)

实际上，任何可迭代对象都可以用于创建字典，前提是其中的元素按照键值对的结构排列。学到了后面自然可以自己手挫的。

🍌dict 存储结构和访问速度

简单来说：dict的键是通过哈希表来实现的，就使得访问速度很快。

字典的键的元素在遇到布尔值和 1、0 时，需注意重复的情况。
元组的元素不可以被替换

🍊.set_集合

🍉 set_集合的基础概念

集合是一个无序、可变、不允许数据重复的容器。

my_set ={1,2,3,'C++','Python'}

无序，无法通过索引取值。
可变，可以添加和删除元素。

num_set = {11,22,33,44}
num_set.add(55)
print(num_set) # {11,22,33,44,55}

不允许数据重复。

num_set = {11,22,33,44}
num_set.add(11)
print(num_set) # {11,22,33,44}

注意：定义空集合时，只能使用v = set()，不能使用 v={}（这样是定义一个空字典）。

# 下面是四种类型的数据类型定义
data1 = []
data11 = list()

data2 = ()
data22 = tuple()

data3 = set()   #只有这一种

data4 = {} # 空字典
data44 = dict()

🍉 set_集合的常用和基础功能

🍌添加元素

这里在基本定义的时候已经说了

data = set()
data.add("nullptr")
data.add("C++")
data.add("python")
print(data) # 是无序的添加{'C++', 'nullptr', 'python'}

🍌删除元素

my_set ={11,22,'nullptr','C++','python'}
my_set.discard('C++')
print(my_set) # {'python', 22, 11, 'nullptr'}

注意：set 不能用del删除，del能够删除变量，list ，dict的键值，还有对象。

🍌两个set之间的交集，并集和差集

交集

set1 = {1, 2, 3, 4, 5}
set2 = {3, 4, 5, 6, 7}

intersection = set1 & set2  #推荐使用
# 或者使用 intersection() 方法：set1.intersection(set2)

print(intersection) # {3, 4, 5}

并集

set1 = {1, 2, 3, 4, 5}
set2 = {3, 4, 5, 6, 7}

union = set1 | set2  #推荐使用
# 或者使用 union() 方法：set1.union(set2)
print(union) # {1, 2, 3, 4, 5, 6, 7}

差集

A = {1, 2, 3, 4, 5}
B = {3, 4, 5, 6, 7}

C = A - B  # 或者使用C() 方法：A.C(B)

print(C) # {1, 2} A中的B中没有的

🍌长度

my_set ={11,22,'nullptr','C++','python'}
data = len(my_set)
print(my_set) # 5

🍌for循坏

my_set ={11,22,'nullptr','C++','python'}
for item in my_set:
	print(item)

🍌转换

提示：int/list/tuple/dict都可以转换为集合。
我们就不一一敲出了，和上面的dict类似。
注意：True和False 和数字 1，0 在集合里面会彼此覆盖。有重复元素得list 和tuple转换为set会去重。

🍉 set_集合存储原理

存储原来：哈希表。不懂得哥们可以看看别的博客，很好理解得。
因存储原理，集合的元素必须是可哈希的值，即：内部通过通过哈希函数把值转换成一个数字。

总结：集合的元素只能是 int、bool、str、tuple 。(还包括不可变集合，不可变对象，不太常用)
因存储原理特殊，集合的查找效率非常高（数据量大了才明显）

谢谢你看到了最后，今天的内容主要了解dict和set两种类型，在以后工作中，dict使用频率也是高于set，相比于C++的map和set，python的set和dict还是要简单不少，完成了第一阶段，之后我们开始第二阶段函数的学习，在py里面什么都是对象，就和Linux一切都是文件类似🐳🐳🐳