说明: 等号(=)右边有多个数值仅通过逗号分割,就会封装到一个元组,称为封装packing。
# 示例:
x = 1,
y = 1,2
print(type(x), x)
print(type(y), y)
# 输出结果如下:
<class 'tuple'> (1,)
<class 'tuple'> (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
错误示例:
另外一种丢弃变量下划线:'_'
说明: '_'是合法的标识符,大多场景表示不关心该值。
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]
说明: 集合是'可变的、无序的、不重复'的元素集合。
成为集合元素是有条件的:'元素必须可hash、可迭代'
可哈希对象如下(不可变):
可以通过内置hash函数判断是否可hash:
s1 = [1,2,3]
print(hash(s1))
# 输出结果如下:
TypeError: unhashable type: 'list' # 列表是不可hash的
说明:
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'
s1 = set([1,2,3])
s1.add(4)
print(s1)
# 输出结果如下:
{1, 2, 3, 4}
s1 = set([1,2,3])
s1.update((4,5,6),[7,8,9])
print(s1)
# 输出结果如下:
{1, 2, 3, 4, 5, 6, 7, 8, 9}
说明: 集合是个容器,是可以遍历的,但是效率都是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)。
大家可以按照如下进行验证下,随着数据规模越来越大,很明显就可以看出哪个效率高。
说明: 字典是由任意个item(元素)组成的集合,item是由key:value对组成的二元组。
# 空字典
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}
2)d.popitem()
3)d.clear()
正常访问元素:
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}
语法
优点
示例需求:请从给定区间中提取能够被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]
以上就是列表解析式,也叫列表推倒式。
语法
特点:
看下生成器对象是长什么样的(不要认为是元组解析式,哈哈):
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 # 已经超出可迭代范围,抛出异常
备注:生成器表达式只能迭代一次。
集合解析式和列表解析式语法类似,不做过多解析。
语法:
示例:
print({i for i in range(10) if i % 2 == 0})
# 输出结果如下:
{0, 2, 4, 6, 8}
字典解析式和集合解析式语法类似,不做过多解析。
语法:
示例:
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循环拆分来写。