[TOC]

哈喽，大家好！间隔上一篇文章近 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 循环拆分来写。

如果喜爱的我的文章，欢送关注我的公众号：点滴技术，扫码关注，不定期分享