您当前的位置:首页 > 电脑百科 > 程序开发 > 算法

Python哈希表和解析式

时间:2020-07-24 11:02:02  来源:  作者:

1. 封装和解构

1.1 封装

说明: 等号(=)右边有多个数值仅通过逗号分割,就会封装到一个元组,称为封装packing。

# 示例:
x = 1,
y = 1,2
print(type(x), x)
print(type(y), y)

# 输出结果如下:
<class 'tuple'> (1,)
<class 'tuple'> (1, 2)

备注: 如果右边只有一个数值且没有用逗号,其实是一个整数类型,请留意。另外等号右边一定先运行,再赋值给左边。

1.2 解构

说明: 等号(=)右边容器类型的元素与左边通过逗号分割的变量要一 一对应,称为解构unpacking。

x,y = (1,2)  # [1,2] {1,2} {'a':1,'b':2}
print(x)
print(y)

# 输出结果如下:
1
2

备注: 右边的容器可以是元组、列表、字典、集合等,必须是可迭代对象。

错误示范:

x,y = (1,2,3)
print(x)
print(y)

# 输出结果如下:
ValueError: too many values to unpack (expected 2)

说明: 左、右两边个数一定要一致,不然会抛出'ValueError'错误。

剩余变量解构

说明: Python3引入了剩余变量解构(rest),'尽可能'收集剩下的数据组成一个列表。

x, *rest = [1,2,3,4,5,6]
print(type(x), x)
print(type(rest), rest)  # 剩余没有赋值的就是rest的了

# 输出结果如下:
<class 'int'> 1
<class 'list'> [2, 3, 4, 5, 6]
*rest, y = [1,2,3,4,5,6]
print(type(rest), rest)
print(type(y), y)

# 输出结果如下:
<class 'list'> [1, 2, 3, 4, 5]
<class 'int'> 6

错误示例:

  • 不能单独使用说明: 等号左边只有一个标识符,无法解构。*rest = [1,2,3,4,5,6] print(rest) # 输出结果如下: #语法错误 SyntaxError: starred assignment target must be in a list or tuple
  • 不能多次同时使用x, *rest1, *rest2, y = [1,2,3,4,5,6] print(rest1) print(rest2) # 输出结果如下: #语法错误,其中一个rest就把剩余元素拿走了,另外一个rest怎么拿? SyntaxError: two starred expressions in assignment

另外一种丢弃变量下划线:'_'

说明: '_'是合法的标识符,大多场景表示不关心该值。

x, *_, y = [1,2,3,4,5,6]
print(x)
print(_)
print(y)
# 输出结果如下:
1
[2, 3, 4, 5]
6
_, *rest, _ = [1,2,3,4,5,6]
print(_)  # '_'是上一次输出值
print(rest)
# 输出结果如下:
6
[2, 3, 4, 5]

2. 集合Set

说明: 集合是'可变的、无序的、不重复'的元素集合。

成为集合元素是有条件的:'元素必须可hash、可迭代'

可哈希对象如下(不可变):

  • 数值型:int(整数)、float(浮点)、complex(复数)
  • 布尔型:True(是)、False(否)
  • 字符串:string(字符串)、bytes(字节)
  • tuple(元组)
  • None(空)

可以通过内置hash函数判断是否可hash:

s1 = [1,2,3]
print(hash(s1))

# 输出结果如下:
TypeError: unhashable type: 'list'  # 列表是不可hash的

2.1 初始化

说明:

  • set() -> new empty set object,新的空集合
  • set(iterable) -> new set object,元素必须可迭代
s = {}  # 注意这个是空字典,不是空集合
s1 = set()  # 空集合
s2 = set([1,2,3])  # 注意列表里面元素迭代出来的是整数,可hash
s3 = set("abcd")
print(s1)
print(s2)
print(s3)

# 输出结果如下:
set()
{1, 2, 3}
{'c', 'd', 'a', 'b'}

错误示例:

s = set([[1]]) # 列表套列表,迭代出来是列表,不可hash
print(s)

# 输出结果如下:
TypeError: unhashable type: 'list'

2.2 增加

  • s.add(element)说明: 增加一个元素到集合,如果元素已经存在,则不操作。
s1 = set([1,2,3])
s1.add(4)
print(s1)

# 输出结果如下:
{1, 2, 3, 4}
  • s.update(*element))说明: 合并一个或多个元素到集合中,元素必须可迭代(把迭代的元素并到集合),和后面讲的并集一样。
s1 = set([1,2,3])
s1.update((4,5,6),[7,8,9])
print(s1)

# 输出结果如下:
{1, 2, 3, 4, 5, 6, 7, 8, 9}

2.3 删除

  • remove(element)说明: 从集合中移除一个元素,如果元素不存在抛出'KeyError'错误。s1 = {1,2,3,4,5,6} s1.remove(6) print(s1) # 输出结果如下: {1, 2, 3, 4, 5}
  • discard(element)说明: 也是从集合中移除一个元素,如果元素不存在不会报异常,啥都不做。s1 = {1,2,3,4,5,6} s1.discard(6) print(s1) # 输出结果如下: {1, 2, 3, 4, 5}
  • pop()说明: 因为集合是无序的,所以是删除'任意'一个元素,如果是空集则抛出'KeyError'错误。s1 = {1,2,3,4,5,6} print(s1.pop()) # 随机的(因为无序) print(s1) # 输出结果如下: 1 {2, 3, 4, 5, 6}
  • clear()说明: 删除所有元素,都不推荐使用的啦。s1 = {1,2,3,4,5,6} s1.clear() print(s1) # 输出结果如下: set()

2.4 遍历

说明: 集合是个容器,是可以遍历的,但是效率都是O(n)。

s1 = {1,2,3}
for s in s1:
    print(s)
# 输出结果如下:
1
2
3

说到这里,你觉得集合set和列表list哪个遍历效率更高呢?

答案是set,因为set的元素是hash值作为key(下面讲的字典也是hash值),查询时间复杂度为O(1),而list是线性数据结构,时间复杂度是O(n)。

大家可以按照如下进行验证下,随着数据规模越来越大,很明显就可以看出哪个效率高。

Python哈希表和解析式

 

2.5 并集&交集&差集&对称差集

  • 并集说明: 将多个集合的所有元素合并在一起组成新的集合。s1 = {1,2,3} s2 = {3,4,5} print(s1.union(s2)) # 输出结果如下: {1, 2, 3, 4, 5}备注:还可以使用运算符 '|'、'update(element)'、'|='。
  • 交集说明: 取多个集合的共同(相交)元素s1 = {1,2,3} s2 = {3,4,5} print(s1.intersection(s2)) # 输出结果如下: {3}备注:还可以使用'&'、's.intersection_update(element)'、'&='。
  • 差集说明: 属于一个集合但不属于另一个集合的元素组成的集合。s1 = {1,2,3} s2 = {3,4,5} print(s1.difference(s2)) # 输出结果如下: {1, 2}备注:还可以使用'-'、's.difference_update(element)'、'-='.
  • 对称差集说明: 多个集合中,不属于交集元素组成的集合。s1 = {1,2,3} s2 = {3,4,5} print(s1.symmetric_difference(s2)) # 输出结果如下: {1, 2, 4, 5}备注:还可以使用'^'、's1.symmetric_difference_update(s2)'、'^='.

3.字典

说明: 字典是由任意个item(元素)组成的集合,item是由key:value对组成的二元组。

  • 字典是'可变的':支持增删改查;
  • 字典是'无序的':key存储是无序的,非线性数据结构(请不要让表面蒙蔽了你哈);
  • 字典是'key不重复':key是唯一的,且必须可'hash';

3.1 初始化

# 空字典
d1 = {}
d2 = dict()

# 示例:
d3 = dict(a=1,b=2,c=3)
d4 = dict(d3)
d5 = dict([('a',1),('b',2),('c',3)])  # 元素必须是可迭代的
d6 = {'a':1,'b':2,'c':3}

# 输出结果都是:
{'a': 1, 'b': 2, 'c': 3}

3.2 增删改查

  • 增加&修改元素1)通过'd[key] = value'方式:备注:如果key不存在,则新增,key存在则直接覆盖(修改元素)。# 增加 & 修改 d = {'a':1,'b':2,'c':3} d['d'] = 4 # 增加 d['a'] = 11 # 修改 print(d) # 输出结果如下: {'a': 11, 'b': 2, 'c': 3, 'd': 4}2)通过d.update([E, ]**F) -> None# 增加 & 修改 d = {'a':1,'b':2,'c':3} d.update(d=4) print(d) # 输出结果如下: {'a': 1, 'b': 2, 'c': 3, 'd': 4}
  • 删除元素1)d.pop()key存在则移除,并返回对应value值。key不存在,返回给定的缺省值,否则抛出KeyError。d = {'a':1,'b':2,'c':3} print(d.pop('c',None)) print(d) # 输出结果如下: 3 {'a': 1, 'b': 2}

2)d.popitem()

  • 删除并返回一个任意的item(key:value)。
  • 如果是空字典,抛出KeyError。d = {'a':1,'b':2,'c':3} print(d.popitem()) print(d) # 输出结果如下: ('c', 3) {'a': 1, 'b': 2}

3)d.clear()

  • 删除所有item,不推荐使用。d = {'a':1,'b':2,'c':3} d.clear() print(d)
  • 查找元素通过key这个键就可以快速找到value值。时间复杂度是O(1),不会随着数据规模大而降低效率。

正常访问元素:

d = {'a':1,'b':2,'c':3}
print(d['a'])
print(d.get('b'))

# 输出结果如下:
1
2

key不存在的处理方式:

d = {'a':1,'b':2,'c':3}
print(d.get('d',None))  # 如果key不存在,缺省返回None
print(d.setdefault('d',100))  # 如果key不存在,则新增key:value对
print(d)

# 输出结果如下:
None
100
{'a': 1, 'b': 2, 'c': 3, 'd': 100}

3.3 遍历

  • 遍历键:keyd = {'a':1,'b':2,'c':3} # 方法1: for k in d: # 缺省是遍历key print(k) # 方法2: for k in d.keys(): print(k) # 方法3: for k, _ in d.items(): print(k) # 输出结果如下: a b c
  • 遍历值:valued = {'a':1,'b':2,'c':3} # 方法1: for v in d.values(): print(v) # 方法2: for k in d: # print(d[k]) # 也可以用 print(d.get(k)) # 方法3: for _, v in d.items(): print(v) # 输出结果如下: 1 2 3
  • 遍历item:key-valued = {'a':1,'b':2,'c':3} for item in d.items(): print(item) # 输出结果如下: ('a', 1) ('b', 2) ('c', 3)
  • 其他问题这种情况在遍历的时候,不能够删除元素,不能改变字典的size。d = {'a':1,'b':2,'c':3} for k in d: print(d.pop(k)) # 输出结果如下: RuntimeError: dictionary changed size during iteration优雅的删除方式:d = {'a':1,'b':2,'c':3} key_list = [] for k in d: key_list.Append(k) for k in key_list: print('已删除key:', d.pop(k))然并卵,想要清除,直接用clear()啦。

4.解析式和生成器表达式

4.1 列表解析式

语法

  • [ 返回值 for 元素 in 可迭代对象 if 条件 ]
  • 列表解析式用中括号'[ ]'表示
  • 返回一个新的列表

优点

  • 提高效率
  • 代码轻量
  • 可读性高

示例需求:请从给定区间中提取能够被2整除的元素。

大众普遍的写法:

list = []
for i in range(10):
    if i % 2 == 0:
        list.append(i)
print(list)

# 输出结果如下:
[0, 2, 4, 6, 8]

再来感受一下简单而优雅的写法:

print([i for i in range(10) if i % 2 == 0])

# 输出结果如下:
[0, 2, 4, 6, 8]

以上就是列表解析式,也叫列表推倒式。

4.2 生成器表达式

语法

  • ( 返回值 for 元素 in 可迭代对象 if 条件 )
  • 生成器表达式用中括号'( )'表示
  • 返回一个生成器对象(generator)

特点:

  • 按需计算,就是需要取值的时候才去计算(而列表解析式是一次性计算立即返回所有结果)
  • 前期并不怎么占用内存,最后取值多了就跟列表解析式一样;
  • 计算耗时极短,本身并不返回结果,返回的是生成器对象;

看下生成器对象是长什么样的(不要认为是元组解析式,哈哈):

x = (i for i in range(10) if i % 2 == 0)
print(type(x))
print(x)

# 输出结果如下:
<class 'generator'>  # 生成器
<generator object <genexpr> at 0x000001A143ACBA98> # 生成器对象

那生成器对象是如何计算得到结果:

import time
x = (i for i in range(10) if i % 2 == 0)
for i in range(6):  # 仅一次循环取值
    time.sleep(0.5)
    print(next(x))
 time.sleep(1)
print(next(x))  # for循环已经计算完所有结果了,不能取值,故抛出异常

# 输出结果如下:
0
2
4
6
8
StopIteration  # 已经超出可迭代范围,抛出异常

备注:生成器表达式只能迭代一次。

4.3 集合解析式

集合解析式和列表解析式语法类似,不做过多解析。

语法:

  • { 返回值 for 元素 in 可迭代对象 if 条件 }
  • 集合解析式用花括号'{ }'表示
  • 返回一个集合

示例:

print({i for i in range(10) if i % 2 == 0})

# 输出结果如下:
{0, 2, 4, 6, 8}

4.4 字典解析式

字典解析式和集合解析式语法类似,不做过多解析。

语法:

  • { key:value for 元素 in 可迭代对象 if 条件 }
  • 字典解析式用花括号'{ }'表示
  • 返回一个字典

示例:

print({i:(i+1) for i in range(10) if i % 2 == 0})

# 输出结果如下:
{0: 1, 2: 3, 4: 5, 6: 7, 8: 9}

总体来说,解析式写起来如果让人简单易懂、又高效,是非常推荐大家使用的。

但有的场景写起来很复杂,那还是得用for...in循环拆分来写。



Tags:Python哈希表   点击:()  评论:()
声明:本站部分内容及图片来自互联网,转载是出于传递更多信息之目的,内容观点仅代表作者本人,如有任何标注错误或版权侵犯请与我们联系(Email:2595517585@qq.com),我们将及时更正、删除,谢谢。
▌相关推荐
1. 封装和解构1.1 封装说明: 等号(=)右边有多个数值仅通过逗号分割,就会封装到一个元组,称为封装packing。# 示例:x = 1,y = 1,2print(type(x), x)print(type(y), y)# 输出结果...【详细内容】
2020-07-24  Tags: Python哈希表  点击:(56)  评论:(0)  加入收藏
▌简易百科推荐
前言Kafka 中有很多延时操作,比如对于耗时的网络请求(比如 Produce 是等待 ISR 副本复制成功)会被封装成 DelayOperation 进行延迟处理操作,防止阻塞 Kafka请求处理线程。Kafka...【详细内容】
2021-12-27  Java技术那些事    Tags:时间轮   点击:(1)  评论:(0)  加入收藏
博雯 发自 凹非寺量子位 报道 | 公众号 QbitAI在炼丹过程中,为了减少训练所需资源,MLer有时会将大型复杂的大模型“蒸馏”为较小的模型,同时还要保证与压缩前相当的结果。这就...【详细内容】
2021-12-24  量子位    Tags:蒸馏法   点击:(9)  评论:(0)  加入收藏
分稀疏重建和稠密重建两类:稀疏重建:使用RGB相机SLAMOrb-slam,Orb-slam2,orb-slam3:工程地址在: http://webdiis.unizar.es/~raulmur/orbslam/ DSO(Direct Sparse Odometry)因为...【详细内容】
2021-12-23  老师明明可以靠颜值    Tags:算法   点击:(7)  评论:(0)  加入收藏
1. 基本概念希尔排序又叫递减增量排序算法,它是在直接插入排序算法的基础上进行改进而来的,综合来说它的效率肯定是要高于直接插入排序算法的;希尔排序是一种不稳定的排序算法...【详细内容】
2021-12-22  青石野草    Tags:希尔排序   点击:(6)  评论:(0)  加入收藏
ROP是一种技巧,我们对execve函数进行拼凑来进行system /bin/sh。栈迁移的特征是溢出0x10个字符,在本次getshell中,还碰到了如何利用printf函数来进行canary的泄露。ROP+栈迁移...【详细内容】
2021-12-15  星云博创    Tags:栈迁移   点击:(19)  评论:(0)  加入收藏
一、什么是冒泡排序1.1、文字描述冒泡排序是一种简单的排序算法。它重复地走访要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地...【详细内容】
2021-12-15    晓掌柜丶韶华  Tags:排序算法   点击:(16)  评论:(0)  加入收藏
在了解golang的map之前,我们需要了解哈希这个概念。哈希表,又称散列表(Hash table),是根据键(key)而直接访问在内存储存位置的数据结构。也就是说,它通过计算出一个键值的函数,将...【详细内容】
2021-12-07  一棵梧桐木    Tags:哈希表   点击:(13)  评论:(0)  加入收藏
前面文章在谈论分布式唯一ID生成的时候,有提到雪花算法,这一次,我们详细点讲解,只讲它。SnowFlake算法据国家大气研究中心的查尔斯&middot;奈特称,一般的雪花大约由10^19个水分子...【详细内容】
2021-11-17  小心程序猿QAQ    Tags:雪花算法   点击:(24)  评论:(0)  加入收藏
导读:在大数据时代,对复杂数据结构中的各数据项进行有效的排序和查找的能力非常重要,因为很多现代算法都需要用到它。在为数据恰当选择排序和查找策略时,需要根据数据的规模和类型进行判断。尽管不同策略最终得到的结果完...【详细内容】
2021-11-04  华章科技    Tags:排序算法   点击:(37)  评论:(0)  加入收藏
这是我在网上找的资源的一个总结,会先给出一个我看了觉得还行的关于算法的讲解,再配上实现的代码: Original author: Bill_Hoo Original Address: http://blog.sina.com.cn/s/bl...【详细内容】
2021-11-04  有AI野心的电工和码农    Tags: KMP算法   点击:(36)  评论:(0)  加入收藏
相关文章
    无相关信息
最新更新
栏目热门
栏目头条