Python之哈希表-封装和解构

Python之哈希表-封装和解构

1, 2
# 返回结果：(1, 2)
1
2

t = 1, 2
t = (1, 2)
# 上面2种写法是等价的
1
2
3

• Python等式右侧出现逗号分隔的多值的时候，就会将这几个值封装到元组中。这种操作称为封装 packing。

a, b = 1, 2
a, b
# 返回结果：(1, 2)
1
2
3

• Python中等式右侧是一个容器类型，左侧是逗号分隔的多个标识符，将右侧容器中数据的一个个和左侧标识符一一对应。这种操作称为解构unpacking。
• 从Python3开始，对解构做了很大的改进，现在用起来已经非常的方便快捷。
• 封装和解构是非常方便的提取数据的方法，在Python、JavaScript等语言中应用极广。

a, b, c = range(3)
# abc等于range(3)
1
2

a
# 返回结果：0
1
2

b
# 返回结果：1
1
2

c
# 返回结果：2
1
2

• range对象的内容012，按顺序赋值给abc

a, b = [1, 2]
a, b = (1, 2)
a, b = 3, 4
a, b = range(3, 5)
a, b = 'ab'
a, b = b'ab'
a, b = bytearray(b'ab')
# 练习一下对应的封装过程。
1
2
3
4
5
6
7
8

a, b = {1, 2} 
# {}集合
1
2

a
# 返回结果：1
1
2

b
# 返回结果：2
1
2

a, b = {'a':100, 'b':200} 
# 字典:key value格式的，键值对kv对。
1
2

a
# 返回结果：'a'
1
2

b
# 返回结果：'b'
1
2

剩余变量解构

• 在Python3.0中增加了剩余变量解构（rest）

a, *rest, b = 1, 2, 3
# 标识符rest解构，是把剩余的拿走，返回list类型
1
2

a
# 返回结果：1
1
2

b
# 返回结果：3
1
2

rest
# 返回结果：[2]
1
2

a, *r, b = range(10)
a, b
# 返回结果：(0, 9)
r
# 返回结果：[1, 2, 3, 4, 5, 6, 7, 8]
1
2
3
4
5

a, *r, b = b'abc'
a, b
# 返回结果：(97, 99)
r
# 返回结果：[98]
1
2
3
4
5

• 不知道大家想明白没有，为什么得到的结果是979899呢？

a, *r = b'abc'
print(a)
print(r)
# 返回结果：97
# 返回结果：[98, 99]
1
2
3
4
5

*r, b = 'abc'
print(b)
print(r)
# 返回结果：c
# 返回结果：['a', 'b']
1
2
3
4
5

• 上面两个内容对比一下有什么不同。

a, *_ = 1, 2, 3 
print(a)
print(_)
# _虽然合法，但是表示我不关心
# 返回结果：1
# 返回结果：[2, 3]
1
2
3
4
5
6

_, *a, _ = range(5)
# 这个结果猜猜看，有没有人觉得是 '0, [1, 2, 3], 4'
1
2

print(1, _)
print(2, a)
print(3, _)
# 返回结果：1 4
# 返回结果：2 [1, 2, 3]
# 返回结果：3 4
1
2
3
4
5
6

• 结果是 ‘4, [1, 2, 3], 4’ ，这里涉及到一个覆盖问题，因为a前后都是_

x = [(1, 2)]
print(x, len(x))
# x 等于一个列表，列表里有元组，元组种1, 2的值。
# 返回结果：[(1, 2)] 1
1
2
3
4

x = [*(1, 2)] 
print(x, len(x))
# 星号是解构，把元组解构了就只剩下列表了，列表里有两个值，len的长度为2.
# 返回结果：[1, 2] 2
1
2
3
4

x = [range(5)]
print(x, len(x))
# 我想的是返回一个列表，长度为5， 忽略了一个问题range对象是惰性的，没有迭代
# 返回结果：[range(0, 5)] 1
1
2
3
4

x = [*range(5)]
print(x, len(x)) 
# 解构
# 返回结果：[0, 1, 2, 3, 4] 5
1
2
3
4

x = list(range(5))
print(x, len(x))
# 返回结果：[0, 1, 2, 3, 4] 5
1
2
3

[x, [a, b, c], z] = [1, [2, 3, 4], 5] 
# 一一对应的写法
1
2

[_, [*_, c], _] = [1, [2, 3, 4], 5] 
# 丢弃变量的写法
1
2

_, a, _, b, *_, c, _ = list(range(10))
print(a, b, c)
# 返回结果：1 3 8
1
2
3

---

报错

a, b, c = (1,)
# 返回结果：ValueError: not enough values to unpack (expected 3, got 1)
# 期待3个值，但是只给了1个
1
2
3

a, b, c = range(5)
# 返回结果：ValueError: too many values to unpack (expected 3)
# # 期待3个值，给多了
1
2
3