Python 备忘录 2： 字典 vs. 集

>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            

1在s



3            

出真



4            

10在s



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           









导入时间



2            

id=[x表示x的范围（0100000）]



3            

价格=[xx的范围（2000000300000）]



4            

产品列表（拉链（ID价格）



5            





6            

start_using_list次。perf_counter（）



7            

find_unique_price_using_list（产品）



8            

perf_counter（）



9            

打印（"时间过去使用列表：{}"。格式（end_using_list-start_using_list）



10            





11            

##Out：使用列表的时间过去了：41.61519479751587



12            





12            





13            

start_using_set次。perf_counter（）



14            

find_unique_price_using_set（产品）



15            

perf_counter（）



16            

打印（"时间过去使用集：{}"。格式（end_using_set-start_using_set）



17            





18            

##Out：使用集的时间过去了：0.008238077163696289









正如你所看到的，只有十万的数据，两者的速度差异是如此之大。事实上，大型企业的后端数据往往在数亿甚至数十亿左右。如果使用不适当的数据结构，很容易导致服务器崩溃，这不仅会影响用户体验，还会给公司带来巨大损失。
词典和集如何工作
我们已经看到了字典的效率，并列举了上述例子。但是，为什么字典和集效率如此之高，尤其是用于查找、插入和删除操作？当然，这与字典和集的数据结构是分不开的。与其他数据结构不同，字典和集的内部结构是一个哈希表。


对于字典，哈希表存储三个元素：哈希、密钥和价值。  


对于一组，不同的是，在哈希表中没有关键值配对，只有一个元素


 |          ...
__+_______________________________+

不难想象，随着哈希表的扩大，它将会变得越来越稀疏。例如，如果我有以下字典：



蟒   





























x

1           














1            

{名称""迈克""多布"1999-01-01"性别""男性"}



















然后，它将以类似于以下形式存储：



蟒   




          




1            

条目 =[



2            

  ['--''--''--']



3            

  [-230273521'多布''1999-01-01']，



4            

  ['--''--''--'],



5            

  ['--''--''--'],



6            

  [1231236123'名称'迈克']，



7            

  ['--''--''--'],



8            

]









这样的设计结构显然是在浪费存储空间。为了提高存储空间的利用率，除了字典本身的结构外，当前的哈希表将索引与哈希值、密钥和值分开，这为我们提供了以下新结构：

Indices
----------------------------------------------------
None | index | None | None | index | None | index ...
----------------------------------------------------

Entries
--------------------
hash0   key0  value0
---------------------
hash1   key1  value1
---------------------
hash2   key2  value2
---------------------
        ...
---------------------
然后，在新的哈希表结构下使用的存储表将看起来像：



爪哇岛   





























x








指数= [无， 1，无，无， 0，无， 2]



2            

条目=[



3            

  [1231236123'名称'迈克']，



4            

  [-230273521'多布''1999-01-01']，



5            

  [9371539127'性别''男性']



6            

]









我们可以清楚地看到，空间利用率已大大提高。现在，我们已经明确了具体的设计结构，让我们来看看这些操作的工作原则 如果哈希表中的此位置为空，则此元素将插入其中。
如果这个位置已经占据，Python 将比较这两个元素的哈希值和键，看看它们是否相等。

如果两者是相等的，则意味着该元素已经存在。如果值不同，则更新值。
如果两者不相等，这种情况通常称为哈希碰撞，这意味着两个元素的键不相等，但哈希值是相等的。在这种情况下，Python 将继续在表中寻找免费位置，直到找到位置。

值得一提的是，一般来说，在这种情况下，最简单的方法是线性搜索。即从这个职位开始，逐一寻找空缺。当然，Python 已经在内部优化了这一点（您不需要深入理解这一点，如果您有兴趣，可以检查源代码，我不会重复它），以使这一步更加有效。
查找操作
与之前的插入操作类似，Python 会根据哈希值找到应位于的位置：然后，将此位置中元素的哈希值和密钥与哈希表进行比较，看看它是否等于需要找到的元素。如果是平等的，直接返回：如果没有，请继续搜索，直到找到插槽或抛出异常。
删除操作
对于删除操作，Python 暂时为此位置的元素分配一个特殊值，然后在哈希表重新定位时将其删除。
不难理解，哈希碰撞的发生往往会降低字典和设置操作的速度。因此，为了确保其效率，集合中的字典和哈希表通常保证至少有 1/3 的剩余空间。随着元素的不断插入，当剩余空间小于 1/3 时，Python 将重新获得更大的内存空间并扩展哈希表。但是，在这种情况下，表中的所有元素位置将重新排列。
虽然哈希碰撞和哈希表大小的调整会减慢速度，但这种情况很少发生。因此，平均而言，这仍然可以确保插入、查找和删除的时间复杂性为 O（1）。
结论
在这一课中，我们学习了字典的基本操作和集聚，并解释了它们的高性能和内部存储结构。
字典是 Python 3 中的有序数据结构 其内部哈希表存储结构可确保其查找、插入和删除操作的效率。因此，字典和集通常用于诸如高效查找和去复制元素等场景。
Related Posts:
用 Python 给女友做了个可能会被打死的七夕礼物
Python 和 Netflix:当您流式传输电影时会发生什么？
Python 元数：不变的神话
为什么说 Python 是人工智能最佳Web开发的语言？
PHP跌出前十，铁打的 Python 连续3年第一：IEEE Spectrum 2019编程语言排行榜出炉
使用 Python 和 Matplotlib 的自定义物理交互的简单仿真
                
				
Tags: data, span

			
            
  

	  

		  Comments are closed.