Python 使用特定规则在列表上迭代

我正在编写一个分析DHCP数据包的程序，遇到了选项43（特定于供应商的信息）。这更多的是一个编程问题，与网络和DHCP的技术关系不大，因此我将其标记为python

根据RFC 2132（第19页），选项43的结构如下：

 Code   Len   Data item        Code   Len   Data item       Code
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
|  T1 |  n  |  d1 |  d2 | ... |  T2 |  n  |  D1 |  D2 | ... | ... |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+

当转换为python“bytes”对象时，它应该如下所示：

[T1, n, d1, d2, ..., T2, n, D1, D2, ...]

其中n是数据项（Dn）的长度

理想情况下，我希望迭代这个bytes对象，将每个数据项的代码保存为键，并将其映射到适当的数据项值。即：

{T1: [d1, d2, d3], T2: [D1, D2, D3]}

例如：

[0, 1, 2, 1, 2, 5, 6, 3, 4, 9, 10, 11, 12]

应该转化为：

{0: [2], 1: [5,6], 3: [9, 10, 11, 12]}

在python中是否有正确的方法来实现这一点

---

编辑：还有，是的。代码（Tn）是唯一的

使用递归函数：

trans_dict = {}
def translate(lst, trans_dict):
    if(len(lst) == 0):
        return
    else:   ​
        trans_dict[lst[0]] = lst[2:(2+lst[1])]        # the first element will be the key, 
                                                      # the value starts from the third 
                                                      # element with length of the second element
        translate(lst[(2+lst[1]):], trans_dict)

translate(lst, trans_dict)

trans_dict
# {0: [2], 1: [5, 6], 3: [9, 10, 11, 12]}

我的解决方案：

packets = [0, 1, 2, 1, 2, 5, 6, 3, 4, 9, 10, 11, 12]

pos_head = 0
len_data = len(packets)

d = dict()

while pos_head  < len_data:
    key = packets[pos_head]
    if pos_head +2 > len_data:
        break
    size = packets[pos_head+1]
    if pos_head + 2 + size > len_data:
        break
    data = packets[pos_head+2: pos_head+2 + size]
    pos_head += 2 + size
    d[key] = data

print(d)

---

观察：T1，T2，…，Tn不应重复。

使用嵌套的

而对于
循环
和
，我的解决方案是（
T1
到
Tn
应该是唯一的，因为它们是生成的字典键）：

您还可以将
for
循环与itertor结合使用。
的外部
循环将在
T
的所有值上循环，而在循环中调用
next
将从列表中删除
n
和
d1
，…，
dn

def parse(data):
    iterator = iter(data)
    d = {}
    for t in iterator:
        n = next(iterator)
        d[t] = [next(iterator) for _ in range(n)]
    return d

你甚至可以把所有这些放在一本字典里

def parse(data):
    it = iter(data)
    return {t: [next(it) for _ in range(next(it))] for t in it}

例如：

>>> data = [0, 1, 2, 1, 2, 5, 6, 3, 4, 9, 10, 11, 12]
>>> parse(data)
{0: [2], 1: [5, 6], 3: [9, 10, 11, 12]}

T1
到
Tn
是否保证是唯一的？如果没有，那么你就不能将这些信息存储在字典中。因为你事先就知道了模式。这应该相当简单。将计数器变量和数组复制到dict对象中。如果您正在寻找更惯用的方式，我不认为有这样的方式，因为这不是一个常见的案例场景，经过投票并标记为正确，因为这是有效的，并且解释很容易理解。非常感谢。
def parse(data):
    iterator = iter(data)
    d = {}
    for t in iterator:
        n = next(iterator)
        d[t] = [next(iterator) for _ in range(n)]
    return d

def parse(data):
    it = iter(data)
    return {t: [next(it) for _ in range(next(it))] for t in it}

>>> data = [0, 1, 2, 1, 2, 5, 6, 3, 4, 9, 10, 11, 12]
>>> parse(data)
{0: [2], 1: [5, 6], 3: [9, 10, 11, 12]}