python编程之解压、字典等

一、解压序列：

任何序列（或者可迭代对象）可以通过一个简单的复制

语句解压并赋值给多个变量。

（前提：变量个数=序列元素个数，否则会产生异常）

data = ( 1, 2, 3)
x, y, z = data
#x = 1, y = 2, z = 3
info = ['zqcc<>', 18, (2022, 4, 26)]
name, age, date = data
#name = 'zqcc<>', age = 18, date = (2022, 4, 26)

那么想要压解一部分，那么怎么办呢？

我们只需要使用任意变量名去占位，然后丢掉这些值就可以了！

二、解压可迭代的对象：

当可迭代的对象元素个数超过变量个数时，会抛出一个ValueError。

我们可以用星号表达式去解决这个问题。

data = [1, 2, 3, 4, 5, 6]
first_number, *middle_number, last_number = data
# first_number = 1
# middle_number = [2, 3, 4, 5] 注意：解压出来的是列表类型
# last_number = 6
head, *tail = data
# head = 1
# tail = [2, 3, 4, 5, 6]

 同理：也可以用星号任意变量名去占位，然后丢弃这些值。

三、保留最后N个元素

利用collections.deque

from collections import deque
q = deque(maxlen = 2)
q.append(1)
q.append(2)
# deque([1, 2], maxlen=2)
q.append(3)
# deque([2, 3], maxlen=2)
q.appendleft(4)
# 在队列的左边加元素 deque([5, 2], maxlen=2)
q.popleft()
# deque([2], maxlen=2)

在队列两端插入或者删除元素的时间复杂度都是O(1)，而在列表的前端插入或者删除元素的时间复杂度为O(n)

四、查找最大或最小的N个元素

我第一时间想到的就是排序（不管从升序还是降序）然后（切片）把前N个打印出来。

在这里我们可以使用最小（大）堆来实现，heap[0]永远是最小的元素，调用heapq.heappop()这个方法得到（时间复杂度O(logN)，N是堆的大小）

>>>import heapq
>>>data = [3, 4, 2, 1, 5]
>>>heapq.heapify(data)
>>>data
[1, 3, 2, 4, 5]
>>>heapq.heappop(data)
1
>>>data
[2, 3, 5, 4]

有了最小（大）堆，我们可以考虑实现一个优先队列（此处不展示，希望大家思考一下）。

五、字典中的键映射多个值

我们都知道一个字典一个键对应一个单值的映射，

那么我们想要一个键映射多个值，需要将这些值放到另外的容器中。

例如：下面的容器是列表

d = {
    'a' : [1, 2],
    'b' : [3, 4],
    'c' : [5, 6]
}

六、字典排序

当我们在一个字典插入时，字典的排序会按照刚插入时排序。

d = {
    'b': 1,
    'a': 3,
    'c': 2
}
# {'b': 1, 'a': 3, 'c': 2}

字典没有sort()，当我们使用sort()，就出现错误了

Traceback (most recent call last):
  File "", line 1, in 
    sort(d)
NameError: name 'sort' is not defined. Did you mean: 'sorted'?

这就要我们使用sorted()去给字典排序了

sorted(d)
#['a', 'b', 'c']
#反向排序
sorted(d, reverse=True)
#['c', 'b', 'a']

结果却只返回了字典的键（已排序），这不符合我们想要排序的本意（返回键值对，按键或按值）

下面我们先学习了下关于字典的一些 *** 作！

使用d.keys()和d.values()以列表的形式返回所有的键，所有的值

d.keys()
#dict_keys(['b', 'a', 'c'])
d.values()
#dict_values([1, 3, 2])

使用d.items()同时返回所有的键值对

d.items()
#dict_items([('b', 1), ('a', 3), ('c', 2)])

 下面对key进行排序

d = {
    'b': 1,
    'a': 3,
    'c': 2
}
ls = sorted(d.keys())
#ls = ['a', 'b', 'c']

对value进行排序

d = {
    'b': 1,
    'a': 3,
    'c': 2
}
ls = sorted(d.values())
#ls = [1, 2, 3]

用d.items()，得到包含key，value的元组。由于迭代对象是元组，返回值自然是元组组成的列表。

使用lambda函数对字典的排序规则进行定义，x指元组，x[0]是key，x[1]是value

d = {
    'b': 1,
    'a': 3,
    'c': 2
}
ls = sorted(d.items())
# ls = [('a', 3), ('b', 1), ('c', 2)]
ls = sorted(d.items(), key = lambda x: x[1])
# ls = [('b', 1), ('c', 2), ('a', 3)]
ls = sorted(d.items(), key = lambda x : x[1], reverse = True)
# ls = [('a', 3), ('c', 2), ('b', 1)]

七、字典的运算

我们可以使用拉链的方法zip()， 连接两个列表

zip()函数的语法：

zip([iterable, ...])

ls1 = ['b', 'a', 'c']
ls2 = [1, 3, 2]
d = dict(zip(ls1, ls2))
# d = {'b': 1, 'a': 3, 'c': 2}
d = dict(zip(d.values(), d.keys()))
# d = {1: 'b', 3: 'a', 2: 'c'}