Question

我有一个列表列表（最多可包含90k个元素）

[[1,2,3], [1,2,4], [1,2,3], [1,2,4], [1,2,5]]

我想为每个元素分配一个id，其中id是唯一的，除非项目是重复的。所以对于上面的列表，我需要这个：

[0,1,0,1,2]

最有效的方法是什么？

Answer 1

使用相关的ID保留已经看过的元素的地图。

from itertools import count
from collections import defaultdict


mapping = defaultdict(count().__next__)
result = []
for element in my_list:
    result.append(mapping[tuple(element)])

你也可以使用列表理解：

result = [mapping[tuple(element)] for element in my_list]

不幸的是，list不可清除，因此在将它们存储为映射的键时，必须将它们转换为tuple。

请注意使用defaultdict和count().__next__提供独特增加ID的技巧。在python2上，您必须将.__next__替换为.next。

defaultdict会在无法找到密钥时指定默认值。通过调用构造函数中提供的函数获取默认值。在这种情况下，__next__生成器的count()方法会产生越来越多的数字。

作为一种更便携的替代方案，您可以这样做：

from functools import partial

mapping = defaultdict(partial(next, count()))

评论中提出的另一种解决方案是将索引用作唯一ID：

result = [my_list.index(el) for el in my_list]

然而这是实施：

需要O（N ^ 2）时间而不是O（N）
ID是唯一的，增加但不连续（可能是也可能不是问题）

为了比较两种解决方案，请参阅：

In [1]: from itertools import count
   ...: from collections import defaultdict

In [2]: def hashing(seq):
   ...:         mapping = defaultdict(count().__next__)
   ...:         return [mapping[tuple(el)] for el in seq]
   ...: 

In [3]: def indexing(seq):
   ...:    return [seq.index(i) for i in seq]
   ...: 

In [4]: from random import randint

In [5]: seq = [[randint(1, 20), randint(1, 20), randint(1, 20)] for _ in range(90000)]

In [6]: %timeit hashing(seq)
10 loops, best of 3: 37.7 ms per loop

In [7]: %timeit indexing(seq)
1 loop, best of 3: 26 s per loop

请注意，对于90k元素列表，映射解决方案需要少于40 毫秒，而索引解决方案需要26 秒。

Answer 2

这就是我接触它的方式：

from itertools import product
from random import randint
import time

t0 = time.time()
def id_list(lst):
    unique_set = set(tuple(x) for x in lst)
    unique = [list(x) for x in unique_set]
    unique.sort(key = lambda x: lst.index(x))

    result = [unique.index(i[1]) for i in product(lst, unique) if i[0] == i[1]]

    return result

seq = [[randint(1, 5), randint(1, 5), randint(1, 5)] for i in range(90000)]

print(id_list(seq))

t1 = time.time()

print("Time: %.4f seconds" % (t1-t0))

其中打印出id序列，以及在 1 和 4 之间的列表中计算一系列随机整数所需的大致时间， 90000次次。

Time: 2.3397 seconds  # Will slightly differ from computation to computation

实际时间总是会有点高，因为最后需要在print语句中考虑，但它不应该有太大差别。

我还使用time库来标记代码块开始和结束之间的时间间隔。

import time

t0 = time.time()

# code block here

t1 = time.time()

# Difference in time: t1 - t0

itertools库以及代码段中使用的product也会加快计算速度。

Answer 3

我略微修改了Bakuriu的解决方案，它只适用于numpy数组，它在内存占用和计算方面效果更好（因为它需要将数组转换为元组）：

from itertools import count
from collections import defaultdict
from functools import partial

def hashing_v1(seq):
    mapping = defaultdict(partial(next, count()))
    return [mapping[tuple(el)] for el in seq]

def hashing_v2(seq):
    mapping = defaultdict(partial(next, count()))
    result = []
    for le in seq:
        le.flags.writeable = False
        result.append(mapping[le.data])
    return result

In [4]: seq = np.random.rand(50000, 2000)

In [5]: %timeit hashing_v1(seq)
1 loop, best of 3: 14.1 s per loop

In [6]: %timeit hashing_v2(seq)
1 loop, best of 3: 1.2 s per loop

将唯一ID分配给python中的列表列表，其中重复项获得相同的id

3 个答案: