Python 2 中的扩展元组解包

发布于 2024-10-22 05:50:38 字数 310 浏览 2 评论 0原文

是否可以在 Python 2 中模拟扩展元组拆包？

具体来说，我有一个 for 循环：

for a, b, c in mylist:

当 mylist 是大小为 3 的元组列表时，它可以正常工作。如果我传入大小为 4 的列表，我希望相同的 for 循环能够工作。

我想我最终会使用命名元组，但我想知道是否有一种简单的编写方法：

for a, b, c, *d in mylist:

以便 d 吃掉任何额外的成员。

原文

Is it possible to simulate extended tuple unpacking in Python 2?

Specifically, I have a for loop:

for a, b, c in mylist:

which works fine when mylist is a list of tuples of size three. I want the same for loop to work if I pass in a list of size four.

I think I will end up using named tuples, but I was wondering if there is an easy way to write:

for a, b, c, *d in mylist:

so that d eats up any extra members.

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

り繁华旳梦境 2024-10-29 05:50:38

您不能直接执行此操作，但编写一个实用函数来执行此操作并不是非常困难：

>>> def unpack_list(a, b, c, *d):
...   return a, b, c, d
... 
>>> unpack_list(*range(100))
(0, 1, 2, (3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99))

您可以将其应用到 for 循环，如下所示：

for sub_list in mylist:
    a, b, c, d = unpack_list(*sub_list)

You can't do that directly, but it isn't terribly difficult to write a utility function to do this:

>>> def unpack_list(a, b, c, *d):
...   return a, b, c, d
... 
>>> unpack_list(*range(100))
(0, 1, 2, (3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99))

You could apply it to your for loop like this:

for sub_list in mylist:
    a, b, c, d = unpack_list(*sub_list)

回复收藏 0 原文

撩心不撩汉 2024-10-29 05:50:38

您可以定义一个包装函数，将列表转换为四元组。例如：

def wrapper(thelist):
    for item in thelist:
        yield(item[0], item[1], item[2], item[3:])

mylist = [(1,2,3,4), (5,6,7,8)]

for a, b, c, d in wrapper(mylist):
    print a, b, c, d

代码打印：

1 2 3 (4,)
5 6 7 (8,)

You could define a wrapper function that converts your list to a four tuple. For example:

def wrapper(thelist):
    for item in thelist:
        yield(item[0], item[1], item[2], item[3:])

mylist = [(1,2,3,4), (5,6,7,8)]

for a, b, c, d in wrapper(mylist):
    print a, b, c, d

The code prints:

1 2 3 (4,)
5 6 7 (8,)

回复收藏 0 原文

颜漓半夏 2024-10-29 05:50:38

到底如何，概括为解压任意数量的元素：

lst = [(1, 2, 3, 4, 5), (6, 7, 8), (9, 10, 11, 12)]

def unpack(seq, n=2):
    for row in seq:
        yield [e for e in row[:n]] + [row[n:]]

for a, rest in unpack(lst, 1):
    pass

for a, b, rest in unpack(lst, 2):
    pass

for a, b, c, rest in unpack(lst, 3):
    pass

For the heck of it, generalized to unpack any number of elements:

lst = [(1, 2, 3, 4, 5), (6, 7, 8), (9, 10, 11, 12)]

def unpack(seq, n=2):
    for row in seq:
        yield [e for e in row[:n]] + [row[n:]]

for a, rest in unpack(lst, 1):
    pass

for a, b, rest in unpack(lst, 2):
    pass

for a, b, c, rest in unpack(lst, 3):
    pass

回复收藏 0 原文

〗斷ホ乔殘χμё〖 2024-10-29 05:50:38

您可以编写一个非常基本的函数，其功能与 python3 扩展 unpack 完全相同。为了易读，稍微冗长。请注意，“rest”是星号所在的位置（从第一个位置 1 开始，而不是 0）

def extended_unpack(seq, n=3, rest=3):
    res = []; cur = 0
    lrest = len(seq) - (n - 1)    # length of 'rest' of sequence
    while (cur < len(seq)):
        if (cur != rest):         # if I am not where I should leave the rest
            res.append(seq[cur])  # append current element to result
        else:                     # if I need to leave the rest
            res.append(seq[cur : lrest + cur]) # leave the rest
            cur = cur + lrest - 1 # current index movded to include rest
        cur = cur + 1             # update current position
     return(res)

You can write a very basic function that has exactly the same functionality as the python3 extended unpack. Slightly verbose for legibility. Note that 'rest' is the position of where the asterisk would be (starting with first position 1, not 0)

def extended_unpack(seq, n=3, rest=3):
    res = []; cur = 0
    lrest = len(seq) - (n - 1)    # length of 'rest' of sequence
    while (cur < len(seq)):
        if (cur != rest):         # if I am not where I should leave the rest
            res.append(seq[cur])  # append current element to result
        else:                     # if I need to leave the rest
            res.append(seq[cur : lrest + cur]) # leave the rest
            cur = cur + lrest - 1 # current index movded to include rest
        cur = cur + 1             # update current position
     return(res)

回复收藏 0 原文

北方的巷 2024-10-29 05:50:38

对于那些通过网络搜索到达这里的人来说，Python 3 解决方案：

您可以使用 itertools.zip_longest，如下所示：

from itertools import zip_longest

max_params = 4

lst = [1, 2, 3, 4]
a, b, c, d = next(zip(*zip_longest(lst, range(max_params))))
print(f'{a}, {b}, {c}, {d}') # 1, 2, 3, 4

lst = [1, 2, 3]
a, b, c, d = next(zip(*zip_longest(lst, range(max_params))))
print(f'{a}, {b}, {c}, {d}') # 1, 2, 3, None

对于 Python 2.x，您可以按照此答案。

Python 3 solution for those that landed here via an web search:

You can use itertools.zip_longest, like this:

from itertools import zip_longest

max_params = 4

lst = [1, 2, 3, 4]
a, b, c, d = next(zip(*zip_longest(lst, range(max_params))))
print(f'{a}, {b}, {c}, {d}') # 1, 2, 3, 4

lst = [1, 2, 3]
a, b, c, d = next(zip(*zip_longest(lst, range(max_params))))
print(f'{a}, {b}, {c}, {d}') # 1, 2, 3, None

For Python 2.x you can follow this answer.

回复收藏 0 原文

~没有更多了~