词典和集的基础

字典由一系列关键值映射元素组成。在Python 3.7 +中,一本字典被确定为在3.6之前订购,一本字典被无序。其长度是可变的,元素可以任意删除和更改。与列表和图集相比,字典的性能更好,尤其是在搜索、添加和删除操作方面。字典可以在不断的时间复杂性内完成。一套和一本字典基本相同,唯一的区别是一套没有钥匙值配对,是一系列无序和独特的元素组合。

首先,让我们来看看词典和收藏品的创作。通常有以下方法:

x
1
>d2=听写({"姓名":"杰森","年龄":20,"性别":"男性"})

3
d3格言([("姓名""杰森")("年龄"20)、("性别""男性")])
4
d4口述姓名="杰森"年龄=20性别="男性")
5
d1d2d3==d4 
6

7

请注意,Python 中的字典和集,无论是键还是值,都可以是混合类型的0:

x
1
1
 s={1"你好"5.0}

让我们来看看元素访问的问题。字典可以直接访问索引:如果它不存在,将抛出一个例外:

x
1
10
1
d[名称]

3
"杰森"
4
d[位置]
5
---------------------------------------------------------------------------
6
基埃罗追踪最近一次通话
7
<蟒蛇-输入-10-46d978634ca1><模块>()
8
基埃罗尔"位置"

我们也可以使用这个功能 get(key, default) 。如果密钥不存在,则函数 get() 返回默认值。例如,以下案例返回"空"。

您也可以使用该 get(key, default) 功能进行索引。如果密钥不存在,请调用 get() 该功能以返回默认值。例如,以下示例返回"空"。

d = {'name': 'jason', 'age': 20}
d.get('name')
Out: 'jason'
d.get('location', 'null')
Out: 'null'

字典访问后,让我们再看看设置。

首先,我想强调,该集不支持索引操作,因为该集本质上是一个哈希表,这与列表不一样。因此,以下操作是错误的,Python 将抛出一个例外。

x
1
1
>[0]

3
类型跟踪回溯最近一次呼叫
4
<蟒蛇-输入-15-c9c96910e542><模块>()
5
----=1s[0]
6

7
类型"设置"对象支持索引

要判断元素是在字典中还是在集中,我们可以在听写/设置中使用值1便士:" >={1,2,3}

2
1s
3
4
10s
5
6

7
d={"名称""杰森""年龄"20}
8
d中的"名称"
9
>"位置"  

11

除了创建和访问之外,字典和集还支持添加、删除和更新等操作。

x
1
18
1
d[性别]= "男性"

3
d["多布"'1999-02-01'
4
d
5
:{'年龄'20'多布''1999-02-01''性别''男性''名称''杰森'}
6

7
d["多布"'1998-01-01'
8
d.流行("多布"
9
'1998-01-01'
10
:{'年龄':20,'性别':'男性','名称':'杰森'}

12

13
 s={123}
14
添加4
15
s
16
:{1234}
17
18
删除4
19
>:{1,2,3}  

但请注意,无论 pop() 一组操作是删除最后一个元素,设置本身是无序的,您无法知道哪个元素被删除。因此,必须谨慎使用操作。
在实际应用中,在许多情况下,我们需要对字典或一套字典进行排序,例如,取出价值最大的 50 对字典或一套字典。

对于字典,我们通常根据密钥或值按升序或降序排序:

x
1
1
d_sorted_by_key = 排序(d.项目(),=兰姆达x:x[0]) 

3
d_sorted_by_value排序(d.项目密钥=兰姆达x[1])
4
d_sorted_by_key
5
:[("a"2)、("b"1)、("c"10)]
6
d_sorted_by_value
7
:[("b"1)、("a"2)、("c"10)]

此处返回列表

至于设置,排序与上述列表和图盘非常相似。只需直接调用 sorted(set) ,结果将返回排序列表。

x
1
 s={3421}
2
排序s
3
例如,电子商务公司的后端存储每个产品的 ID、名称和价格。目前的需求是,鉴于某种产品的 ID,我们希望了解其价格。
如果我们使用列表存储这些数据结构并搜索它们,相应的代码如下:

x
1
17
1
>,产品的价格

3
如果id product_id:
4
退货价格
5
返回
6
     
7
产品 =[
8
143121312100
9
43231455330
10
]

12

13
打印("产品432314553的价格是{}"。格式(find_product_price产品432314553))
14

15

16
##Out:产品价格432314553是30

假设列表具有 n 元素,并且搜索过程需要遍历列表,则时间复杂性为 O(n)。即使我们先对列表进行排序,然后使用二进制搜索,也需要 O(logn) 时间复杂性,更不用说列表的排序仍需要 O(nlogn) 时间复杂性。

但是,如果我们使用字典来存储这些数据,那么查找将非常方便和高效,并且它只能在 O(1) 时间复杂性的情况下完成。原因也很简单。正如我们前面提到的,字典的内部组成是一个哈希表,您可以直接通过密钥的哈希值找到其相应的值格式(产品[432314553])

##Out:产品432314553的价格是30"数据朗="文本/x-巨蛇">

x
1
10
9
1
产品 ={
2
143121312100
3
43231455330
4
}

6
打印("产品432314553的价格是{}"。格式产品432314553
7

8

9
##Out:产品价格432314553是30

同样,我们现在需要找出这些商品有多少不同的价格。让我们以同样的方式比较它们。

如果您仍然选择使用该列表,相应的代码如下,其中 A 和 B 为两级循环。此外,假设原始列表具有 n 元素,那么,在最坏的情况下,需要 O(n^2) 时间复杂性。

x
1
15
1
定义find_unique_price_using_list(产品):
2
unique_price_list
3
产品价格:#A
4
>unique_price_list.附录价格

6
返回(unique_price_list
7
产品
8
143121312100
9
43231455330
10
32421912367150
11
93715320130)]
12
打印("唯一价格的数量是:{}"。格式(find_unique_price_using_list产品) )
13

14

x
1
15
1
定义find_unique_price_using_set(产品
2
 >_,产品价格

4
unique_price_set.添加价格
5
返回(unique_price_set
6
产品
7
143121312100
8
43231455330
9
32421912367150
10
]

12
打印("唯一价格的数量是:{}"。格式(find_unique_price_using_set产品))
13

14
##Out:唯一价格的数量是:3

以下代码初始化包含 100,000 个元素的产品,并计算使用列表和设置来计算产品价格和数量所需的时间:

x
1
20