Python 解包混合元组列表

我有一个混合元组列表：

my_list = [("Adam",1985),("Karen",1990),("anna",1986)] 

---

如何将它分别解压为两个列表或元组，一个带字符串，一个带整数？

您可以将其转换为字典并正常工作

dict([("Adam",1985),("Karen",1990),("anna",1986)])

{'Adam'：1985，'Karen'：1990，'anna'：1986}

---

您可以将其转换为字典并正常工作

dict([("Adam",1985),("Karen",1990),("anna",1986)])

{'Adam'：1985，'Karen'：1990，'anna'：1986}

如果列表模式保持为

（str，int）

使用python，您可以轻松地解压缩元组列表，而无需特别考虑类型：

my_list = [("Adam",1985),("Karen",1990),("anna",1986)] 
names, years = zip(*my_list)

未打包的清单包括：

('Adam', 'Karen', 'anna'), (1985, 1990, 1986)

关于

*

运算符的注释 调用

*

运算符，它将列表中的单个元素作为参数传递。假设您有一个包含3个元素的列表

my_list=[1,2,3]

和一个包含3个参数的函数

def func（a，b，c）

：您可以使用

func（*my_list）

调用

func（my_list[0]，my_list[1]，…，my_list[n]）

如果列表模式被洗牌 使用排序的解决方案，逐元组 使用，我们可以首先对元组进行排序，然后执行zip：

import functools
key=functools.cmp_to_key(lambda x1, x2: 1 if isinstance(x2, str) else -1)
names, years = zip(*[sorted(t, key=key) for t in l])

这样，列表首先被排序为：

[['Adam', 1985], ['Karen', 1990], ['anna', 1986]]

运行zip之后，我们得到了相同的结果：

('Adam', 'Karen', 'anna'), (1985, 1990, 1986)

使用groupby的解决方案 示例列表上的解决方案速度比较 Running timeit在示例列表中，我们得到：

元组排序：

%timeit zip(*[sorted(t, key=key) for t in my_list])
>>> 5.2 µs ± 157 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

%timeit zip(*[sorted(t, key=key) for t in my_list])
>>> 166 ms ± 8.99 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

Groupby

%timeit [list(v) for _, v in groupby(sorted(chain.from_iterable(my_list), key=lambda x: str(x)), lambda x: isinstance(x, str))]
>>> 6.83 µs ± 358 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

%timeit [list(v) for _, v in groupby(sorted(chain.from_iterable(my_list), key=lambda x: str(x)), lambda x: isinstance(x, str))]
>>> 149 ms ± 2.62 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

大列表上的解决方案速度比较 运行时间在一个大的列表中，例如：

import random
n = 100000
my_list = []
for i in range(n):
    if random.choice([True, False]):
        my_list.append((i, "Karen"))
    else:
        my_list.append(("Karen", i))

元组排序：

%timeit zip(*[sorted(t, key=key) for t in my_list])
>>> 5.2 µs ± 157 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

%timeit zip(*[sorted(t, key=key) for t in my_list])
>>> 166 ms ± 8.99 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

Groupby

%timeit [list(v) for _, v in groupby(sorted(chain.from_iterable(my_list), key=lambda x: str(x)), lambda x: isinstance(x, str))]
>>> 6.83 µs ± 358 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

%timeit [list(v) for _, v in groupby(sorted(chain.from_iterable(my_list), key=lambda x: str(x)), lambda x: isinstance(x, str))]
>>> 149 ms ± 2.62 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

结论 即使在小列表上，第一种方法似乎速度更快，但在大列表上，groupby方法速度更快。

如果列表模式保持为

（str，int）

使用python，您可以轻松地解压缩元组列表，而无需特别考虑类型：

my_list = [("Adam",1985),("Karen",1990),("anna",1986)] 
names, years = zip(*my_list)

未打包的清单包括：

('Adam', 'Karen', 'anna'), (1985, 1990, 1986)

关于

*

运算符的注释 调用

*

运算符，它将列表中的单个元素作为参数传递。假设您有一个包含3个元素的列表

my_list=[1,2,3]

和一个包含3个参数的函数

def func（a，b，c）

：您可以使用

func（*my_list）

调用

func（my_list[0]，my_list[1]，…，my_list[n]）

如果列表模式被洗牌 使用排序的解决方案，逐元组 使用，我们可以首先对元组进行排序，然后执行zip：

import functools
key=functools.cmp_to_key(lambda x1, x2: 1 if isinstance(x2, str) else -1)
names, years = zip(*[sorted(t, key=key) for t in l])

这样，列表首先被排序为：

[['Adam', 1985], ['Karen', 1990], ['anna', 1986]]

运行zip之后，我们得到了相同的结果：

('Adam', 'Karen', 'anna'), (1985, 1990, 1986)

使用groupby的解决方案 示例列表上的解决方案速度比较 Running timeit在示例列表中，我们得到：

元组排序：

%timeit zip(*[sorted(t, key=key) for t in my_list])
>>> 5.2 µs ± 157 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

%timeit zip(*[sorted(t, key=key) for t in my_list])
>>> 166 ms ± 8.99 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

Groupby

%timeit [list(v) for _, v in groupby(sorted(chain.from_iterable(my_list), key=lambda x: str(x)), lambda x: isinstance(x, str))]
>>> 6.83 µs ± 358 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

%timeit [list(v) for _, v in groupby(sorted(chain.from_iterable(my_list), key=lambda x: str(x)), lambda x: isinstance(x, str))]
>>> 149 ms ± 2.62 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

大列表上的解决方案速度比较 运行时间在一个大的列表中，例如：

import random
n = 100000
my_list = []
for i in range(n):
    if random.choice([True, False]):
        my_list.append((i, "Karen"))
    else:
        my_list.append(("Karen", i))

元组排序：

%timeit zip(*[sorted(t, key=key) for t in my_list])
>>> 5.2 µs ± 157 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

%timeit zip(*[sorted(t, key=key) for t in my_list])
>>> 166 ms ± 8.99 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

Groupby

%timeit [list(v) for _, v in groupby(sorted(chain.from_iterable(my_list), key=lambda x: str(x)), lambda x: isinstance(x, str))]
>>> 6.83 µs ± 358 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

%timeit [list(v) for _, v in groupby(sorted(chain.from_iterable(my_list), key=lambda x: str(x)), lambda x: isinstance(x, str))]
>>> 149 ms ± 2.62 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

结论 即使在小列表上，第一种方法似乎更快，但在大列表上，groupby方法似乎更快。

使用

zip

>>> years, names = zip(*(sorted(t, key=lambda x: str(type(x))) for t in my_list))
>>> years
(1985, 1990, 1986)
>>> names
('Adam', 'Karen', 'anna')
>>> 

或使用

dict

>>> d = dict(sorted(t, key=lambda x: str(type(x))) for t in my_list)
>>> years = tuple(d.keys())
>>> names = tuple(d.values())
>>> 
>>> years
(1985, 1990, 1986)
>>> names
('Adam', 'Karen', 'anna')
>>> 

使用

zip

>>> years, names = zip(*(sorted(t, key=lambda x: str(type(x))) for t in my_list))
>>> years
(1985, 1990, 1986)
>>> names
('Adam', 'Karen', 'anna')
>>> 

或使用

dict

>>> d = dict(sorted(t, key=lambda x: str(type(x))) for t in my_list)
>>> years = tuple(d.keys())
>>> names = tuple(d.values())
>>> 
>>> years
(1985, 1990, 1986)
>>> names
('Adam', 'Karen', 'anna')
>>> 

---

---

如果

my_list=[（1，'a'），（'b'，2）]

呢？如果我想迭代字符串或整数，如何访问每个项。这里有索引吗当然，假设你想要

“Adam”

：你去

名称[0]

@ChihebNexus，这需要循环，一秒钟。@LucaCappelletti一种方法：

来自itertools导入链，groupby；a=[groupby中v的列表（v）（已排序（chain.from_iterable（my_list）），key=lambda x:str（x）），lambda x:isinstance（x，str））]；打印（a）

if

my_list=[（1，'a'），（'b'，2）]

？如果我想迭代字符串或整数，如何访问每个项目。这里有索引吗当然，假设你想要

“Adam”

：你去

名称[0]

@ChihebNexus，这需要循环，一秒钟。@LucaCappelletti一种方法：

来自itertools导入链，groupby；a=[groupby中v的列表（v）（已排序（chain.from_iterable（my_list）），key=lambda x:str（x）），lambda x:isinstance（x，str））]；打印（a）

可能的重复我相信它的半个重复：我相信问题应该扩展到包括元组的可能性

（str，int）

和

（int，str）

。可能的重复我相信它的半个重复：我相信问题应该扩展到包括元组的可能性

（str，int）

和

（int，str）

。转换字典是一种简单的方法，如何转换和迭代这里转换字典是一种简单的方法，如何转换和迭代here@Karamzov

sorted（t，key=lambda x:str（type（x））for t in my_list）

将以有序形式返回元组列表，这是在一种形式中，岁月总是排在第一位，名字总是排在第二位。如果列表已按顺序排列，则可以跳过此步骤为什么：

key=lambda x

不是

lamda x

？python中没有所谓的

lamda

lambda

是正确的术语：key=lambda x不是lambda x？如果您不将

key=

指定给排序方法，它将抱怨

TypeError:必须为key函数使用关键字参数，因为它只需要关键字arguments@Karamzov
sorted（t，key=lambda x:str（type（x））for t in my_list）
将以有序形式返回元组列表，这是在一种形式中，岁月总是排在第一位，名字总是排在第二位。如果列表已按顺序排列，则可以跳过此步骤为什么：
key=lambda x
不是
lamda x
？python中没有所谓的
lamda
lambda
是正确的术语：key=lambda x不是lambda x？如果您不将
key=
指定给sorted方法，它将抱怨
TypeError:必须为key函数使用关键字参数，因为它只需要关键字参数