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

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]

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

注意使用 defaultdict, and count().__next__ 提供唯一递增 ID 的技巧。在 python2 上，您必须将 .__next__ 替换为 .next。

defaultdict找不到key时会赋默认值。默认值是通过调用构造函数中提供的函数获得的。在这种情况下，count() 生成器的 __next__ 方法会产生递增的数字。

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

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[ 之间的列表中的随机整数序列所花费的大概时间=31=], 90000 次。

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

实际时间总是会高一点，因为它需要在最后的打印语句中计算，但应该不会相差太多。

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

import time t0 = time.time() # code block here t1 = time.time() # Difference in time: t1 - t0

代码段中使用itertools library along with product也会加快计算速度。

Answer 3

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

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

Assign unique id to list of lists in python where duplicates get the same id

python

list

counting