Python哈希表和解析式
哈喽,大家好!距离上一篇文章近1个半月了,不是我拖呀~,刚好这个月遇到了工作调整,再加上要照顾10个月的孩子,实属不易,所以就这么长时间没来更新了。这不,我每天码一点点,'滴水成河',努力完成了这篇文章。
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)。
大家可以按照如下进行验证下,随着数据规模越来越大,很明显就可以看出哪个效率高。
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 遍历
遍历键:key
d = {'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
遍历值:value
d = {'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-value
d = {'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循环拆分来写。
如果喜欢的我的文章,欢迎关注我的公众号:点滴技术,扫码关注,不定期分享
Python哈希表和解析式的更多相关文章
- 04.python哈希表
python哈希表 集合Set 集合,简称集.由任意个元素构成的集体.高级语言都实现了这个非常重要的数据结构类型. Python中,它是可变的.无序的.不重复的元素的集合. 初始化 set() -&g ...
- Python哈希表的例子:dict、set
dict(字典) Python内置了字典:dict的支持,dict全称dictionary,在其他语言中也称为map,使用键-值(key-value)存储,具有极快的查找速度. 和list比较,dic ...
- python数据结构与算法——哈希表
哈希表 学习笔记 参考翻译自:<复杂性思考> 及对应的online版本:http://greenteapress.com/complexity/html/thinkcomplexity00 ...
- 用python实现哈希表
哈哈,这是我第一篇博客园的博客.尝试了一下用python实现的哈希表,首先处理冲突的方法是开放地址法,冲突表达式为Hi=(H(key)+1)mod m,m为表长. #! /usr/bin/env py ...
- python数据结构之哈希表
哈希表(Hash table) 众所周知,HashMap是一个用于存储Key-Value键值对的集合,每一个键值对也叫做Entry.这些个键值对(Entry)分散存储在一个数组当中,这个数组就是Has ...
- 【Python算法】哈希存储、哈希表、散列表原理
哈希表的定义: 哈希存储的基本思想是以关键字Key为自变量,通过一定的函数关系(散列函数或哈希函数),计算出对应的函数值(哈希地址),以这个值作为数据元素的地址,并将数据元素存入到相应地址的存储单元中 ...
- 使用python实现哈希表、字典、集合
哈希表 哈希表(Hash Table, 又称为散列表),是一种线性表的存储结构.哈希表由一个直接寻址表和一个哈希函数组成.哈希函数h(k)将元素关键字k作为自变量,返回元素的存储下标. 简单哈希函数: ...
- python code practice(二):KMP算法、二分搜索的实现、哈希表
1.替换空格 题目描述:请实现一个函数,将一个字符串中的每个空格替换成“%20”.例如,当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy. 分析: 将长度为 ...
- Python 中的哈希表
Python 中的哈希表:对字典的理解 有没有想过,Python中的字典为什么这么高效稳定.原因是他是建立在hash表上.了解Python中的hash表有助于更好的理解Python,因为Pytho ...
随机推荐
- Intellij IDEA 基础设置,个性化设置,好用的设置→_→
Intellij IDEA 个性化设置 Appearance & Behavior 外观和行为 Keymap 快捷键 Editor 编辑器设置 Plugins 插件 Version Contr ...
- HTML+CSS教程(四)选择器(id选择器,类选择器,标签选择器,子代选择器,后代选择器,组选择器,伪类选择器)/css引入页面的形式(行内样式、内嵌样式、外联样式)
一.回顾内容 前端的三大组成(三大模块) HTMl(超文本标记语言) 结构层 css(层叠样式表) 表现层:用来美化HTML结构 JS(Java script)(脚本语言) 行为层: ...
- 2018版移动端ui规范
计规范是一种将移动端常用控件标准化.统一化的的文档 今天整理了一篇设计规范的文章概论,讲诉中会以ios做介绍,安卓由于开源,平台相对教多不做单一阐述,实际操作的时候,我们不管是做一代还是二次的迭代产品 ...
- 【山外笔记-云原生】《Docker+Kubernetes应用开发与快速上云》读书笔记-2020.04.25(六)
书名:Docker+Kubernetes应用开发与快速上云 作者:李文强 出版社:机械工业出版社 出版时间:2020-01 ISBN:9787111643012 [山外笔记-云原生]<Docke ...
- 非常简单的string驻留池,你对它真的了解吗
昨天看群里在讨论C#中的string驻留池,炒的火热,几轮下来理论一堆堆,但是在证据提供上都比较尴尬.虽然这东西很基础,但比较好的回答也不是那么容易,这篇我就以我能力范围之内跟大家分享一下 一:无处不 ...
- 定期清理nohup.out
事件背景 服务应用weblogic通过nohup启动. nohup的使用全部都在weblogic域中的bin目录下 但是没有做定期nohup.out的清理 导致核心服务的日志过大,在出现问题时候难以打 ...
- 发布AI芯片昆仑和百度大脑3.0、L4自动驾驶巴士量产下线,这是百度All in AI一年后的最新答卷...
机器之心报道,作者:李泽南. 去年的 7 月 5 日,百度在北京国际会议中心开办了首届「AI 开发者大会」.在会上,百度首次喊出了「All in AI」的口号.一年的时间过去了,今天在同样地点举行的第 ...
- MySQL使用ProxySQL实现读写分离
1 ProxySQL简介: ProxySQL是一个高性能的MySQL中间件,拥有强大的规则引擎.官方文档:https://github.com/sysown/proxysql/wiki/下载地址:ht ...
- nat和静态映射
拓扑图: 实验要求: 1.R2.R3能访问外网的4.4.4.4(4.4.4.4为R4上的环回接口,用来模拟inter网). 2.R4访问222.222.222.100其实访问到的是内网的192.168 ...
- 【阅读笔记】Ranking Relevance in Yahoo Search (二)—— maching learned ranking
3. MACHINE LEARNED RANKING 1) 完全使用不好的数据去训练模型不可行,因为负面结果不可能覆盖到所有方面: 2) 搜索可以看做是个二分问题,在此实验中,我们使用gradient ...