Python比较标记化列表

我需要这个问题的最快解决方案，因为它将应用于一个巨大的数据集：

鉴于此主列表：

m=['abc','bcd','cde','def']

…以及以下列表的参考列表：

r=[['abc','def'],['bcd','cde'],['abc','def','bcd']]

我想将r中的每个列表与主列表（m）进行比较，并生成一个新的列表列表。此新对象将根据m中的顺序为匹配项指定1，非匹配项指定0。因此，新对象（列表列表列表）将始终具有与m相同长度的列表。 以下是基于上述m和r的预期：

[[1,0,0,1],[0,1,1,0],[1,1,0,1]]

因为r的第一个元素是

['abc'，'def']

，并且有一个匹配项 对于m的第一个和第四个元素，结果是

[1,0,0,1]

以下是我迄今为止的方法（可能太慢了，缺少零）：

导致：

[[1, 1], [1, 1], [1, 1, 1]]

提前谢谢

一种方法使用一个循环-

np.array([np.in1d(m,i) for i in r]).astype(int)

使用显式循环时，它看起来像这样-

out = np.empty((len(r),len(m)),dtype=int)
for i,item in enumerate(r):
    out[i] = np.in1d(m,item)

我们可以使用

dtype=bool

来提高内存和性能

样本运行-

In [18]: m
Out[18]: ['abc', 'bcd', 'cde', 'def']

In [19]: r
Out[19]: [['abc', 'def'], ['bcd', 'cde'], ['abc', 'def', 'bcd']]

In [20]: np.array([np.in1d(m,i) for i in r]).astype(int)
Out[20]: 
array([[1, 0, 0, 1],
       [0, 1, 1, 0],
       [1, 1, 0, 1]])

如果

r

的列表长度相等，我们可以使用完全矢量化的方法。

一种方法使用一个循环-

np.array([np.in1d(m,i) for i in r]).astype(int)

>>> %timeit [[1 if mx in rx else 0 for mx in m] for rx in r]
100000 loops, best of 3: 4.74 µs per loop
>>> %timeit [[int(mx in rx) for mx in m] for rx in r]
100000 loops, best of 3: 8.07 µs per loop
>>> %timeit [[1 if mx in rx else 0 for mx in m] for rx in map(set, r)]
100000 loops, best of 3: 5.82 µs per loop

使用显式循环时，它看起来像这样-

out = np.empty((len(r),len(m)),dtype=int)
for i,item in enumerate(r):
    out[i] = np.in1d(m,item)

我们可以使用

dtype=bool

来提高内存和性能

样本运行-

In [18]: m
Out[18]: ['abc', 'bcd', 'cde', 'def']

In [19]: r
Out[19]: [['abc', 'def'], ['bcd', 'cde'], ['abc', 'def', 'bcd']]

In [20]: np.array([np.in1d(m,i) for i in r]).astype(int)
Out[20]: 
array([[1, 0, 0, 1],
       [0, 1, 1, 0],
       [1, 1, 0, 1]])

如果

r

有长度相等的列表，我们就可以使用完全矢量化的方法。

你几乎做到了

>>> %timeit [[1 if mx in rx else 0 for mx in m] for rx in r]
100000 loops, best of 3: 4.74 µs per loop
>>> %timeit [[int(mx in rx) for mx in m] for rx in r]
100000 loops, best of 3: 8.07 µs per loop
>>> %timeit [[1 if mx in rx else 0 for mx in m] for rx in map(set, r)]
100000 loops, best of 3: 5.82 µs per loop

如果

x

在

i

中，则要添加

1

；如果不在

0

中，则要为

m

中的每个

x

添加

所以脚本看起来像是：
1如果x在i中，否则0作为条件，
对于x在m中
：

output = [[1 if x in i else 0 for x in m] for i in r]
print(output)

结果与

[[1, 0, 0, 1], [0, 1, 1, 0], [1, 1, 0, 1]]

你就快到了

如果
x
在
i
中，则要添加
1
；如果不在
0
中，则要为
m
中的每个
x
添加

所以脚本看起来像是：
1如果x在i中，否则0作为条件，
对于x在m中
：

output = [[1 if x in i else 0 for x in m] for i in r]
print(output)

结果与

[[1, 0, 0, 1], [0, 1, 1, 0], [1, 1, 0, 1]]

如果不使用
numpy
，您可以使用嵌套列表理解来执行此操作，如下所示：

实际上，您不需要将类型转换为
int
，因为Python将
False
视为
0
，
True
视为
1
。此外，使用
bool
value更节省内存。因此，您的表达式将如下所示：

>>> [[mm in rr for mm in m] for rr in r]
[[True, False, False, True], [False, True, True, False], [True, True, False, True]]

如果不使用
numpy
，您可以使用嵌套列表理解来执行此操作，如下所示：

实际上，您不需要将类型转换为
int
，因为Python将
False
视为
0
，
True
视为
1
。此外，使用
bool
value更节省内存。因此，您的表达式将如下所示：

>>> [[mm in rr for mm in m] for rr in r]
[[True, False, False, True], [False, True, True, False], [True, True, False, True]]

您可以使用如下嵌套列表：

>>> m = ['abc','bcd','cde','def']
>>> r = [['abc','def'],['bcd','cde'],['abc','def','bcd']]
>>> [[1 if mx in rx else 0 for mx in m] for rx in r]
[[1, 0, 0, 1], [0, 1, 1, 0], [1, 1, 0, 1]]

此外，如果。。。使用
int（…）
的else 0
，您可以将
r
的子列表转换为
set
，以便rx
中的单个
mx查找更快

>>> [[int(mx in rx) for mx in m] for rx in r]
[[1, 0, 0, 1], [0, 1, 1, 0], [1, 1, 0, 1]]
>>> [[int(mx in rx) for mx in m] for rx in map(set, r)]
[[1, 0, 0, 1], [0, 1, 1, 0], [1, 1, 0, 1]]

而
int（…）
比
1短一点，如果。。。否则，它似乎也会变慢，所以您可能不应该使用它。在重复查找之前，将
r
的子列表转换为
set
，对于较长的列表应该会加快速度，但是对于非常短的示例列表，它实际上比简单的方法慢

>>> %timeit [[1 if mx in rx else 0 for mx in m] for rx in r]
100000 loops, best of 3: 4.74 µs per loop
>>> %timeit [[int(mx in rx) for mx in m] for rx in r]
100000 loops, best of 3: 8.07 µs per loop
>>> %timeit [[1 if mx in rx else 0 for mx in m] for rx in map(set, r)]
100000 loops, best of 3: 5.82 µs per loop

对于较长的列表，使用
set
会更快，正如预期的那样：

>>> m = [random.randint(1, 100) for _ in range(50)]
>>> r = [[random.randint(1,100) for _ in range(10)] for _ in range(20)]
>>> %timeit [[1 if mx in rx else 0 for mx in m] for rx in r]
1000 loops, best of 3: 412 µs per loop
>>> %timeit [[1 if mx in rx else 0 for mx in m] for rx in map(set, r)]
10000 loops, best of 3: 208 µs per loop

您可以使用如下嵌套列表：

>>> m = ['abc','bcd','cde','def']
>>> r = [['abc','def'],['bcd','cde'],['abc','def','bcd']]
>>> [[1 if mx in rx else 0 for mx in m] for rx in r]
[[1, 0, 0, 1], [0, 1, 1, 0], [1, 1, 0, 1]]

此外，如果。。。使用
int（…）
的else 0
，您可以将
r
的子列表转换为
set
，以便rx
中的单个
mx查找更快

>>> [[int(mx in rx) for mx in m] for rx in r]
[[1, 0, 0, 1], [0, 1, 1, 0], [1, 1, 0, 1]]
>>> [[int(mx in rx) for mx in m] for rx in map(set, r)]
[[1, 0, 0, 1], [0, 1, 1, 0], [1, 1, 0, 1]]

而
int（…）
比
1短一点，如果。。。否则，它似乎也会变慢，所以您可能不应该使用它。在重复查找之前，将
r
的子列表转换为
set
，对于较长的列表应该会加快速度，但是对于非常短的示例列表，它实际上比简单的方法慢

>>> %timeit [[1 if mx in rx else 0 for mx in m] for rx in r]
100000 loops, best of 3: 4.74 µs per loop
>>> %timeit [[int(mx in rx) for mx in m] for rx in r]
100000 loops, best of 3: 8.07 µs per loop
>>> %timeit [[1 if mx in rx else 0 for mx in m] for rx in map(set, r)]
100000 loops, best of 3: 5.82 µs per loop

对于较长的列表，使用
set
会更快，正如预期的那样：

>>> m = [random.randint(1, 100) for _ in range(50)]
>>> r = [[random.randint(1,100) for _ in range(10)] for _ in range(20)]
>>> %timeit [[1 if mx in rx else 0 for mx in m] for rx in r]
1000 loops, best of 3: 412 µs per loop
>>> %timeit [[1 if mx in rx else 0 for mx in m] for rx in map(set, r)]
10000 loops, best of 3: 208 µs per loop

多处理拯救

import multiprocessing as mp

def matcher(qIn, qOut):
    m = set(['abc','bcd','cde','def'])
    for i,L in iter(qIn.get, None):
        answer = [1 if e in m else 0 for e in L]
        qOut.put((i,answer))


def main(L):
    qIn, qOut = [mp.Queue() for _ in range(2)]
    procs = [mp.Process(target=matcher, args=(qIn, qOut)) for _ in range(mp.cpu_count()-1)]
    for p in procs: p.start()

    numElems = len(L)
    for t in enumerate(L): qIn.put(t)
    for p in procs: qIn.put(None)

    done = 0
    while done < numElems:
        i,answer = qIn.get()
        L[i] = answer
        done += 1

    for p in procs: p.terminate()

if __name__ == "__main__":
    L = [['abc','def'],['bcd','cde'],['abc','def','bcd']]
    main(L)
    # now L looks like the required output

将多处理导入为mp
def匹配器（qIn，qOut）：
m=集合（['abc'、'bcd'、'cde'、'def']）
对于iter中的i，L（qIn.get，None）：
答案=[1如果m中的e为1，则L中的e为0]
qOut.put（（i，答案））
def总管（L）：
qIn，qOut=[mp.Queue（）表示范围（2）]
procs=[mp.Process（target=matcher，args=（qIn，qOut））用于范围内的（mp.cpu\u count（）-1）]
对于进程中的p:p.start（）
numElems=len（L）
对于枚举（L）中的t:qIn.put（t）
对于进程中的p:qIn.put（无）
完成=0
完成时
多处理拯救

import multiprocessing as mp

def matcher(qIn, qOut):
    m = set(['abc','bcd','cde','def'])
    for i,L in iter(qIn.get, None):
        answer = [1 if e in m else 0 for e in L]
        qOut.put((i,answer))


def main(L):
    qIn, qOut = [mp.Queue() for _ in range(2)]
    procs = [mp.Process(target=matcher, args=(qIn, qOut)) for _ in range(mp.cpu_count()-1)]
    for p in procs: p.start()

    numElems = len(L)
    for t in enumerate(L): qIn.put(t)
    for p in procs: qIn.put(None)

    done = 0
    while done < numElems:
        i,answer = qIn.get()
        L[i] = answer
        done += 1

    for p in procs: p.terminate()

if __name__ == "__main__":
    L = [['abc','def'],['bcd','cde'],['abc','def','bcd']]
    main(L)
    # now L looks like the required output

将多处理导入为mp
def匹配器（qIn，qOut）：
m=集合（['abc'、'bcd'、'cde'、'def']）
对于iter中的i，L（qIn.get，None）：
答案=[1如果m中的e为1，则L中的e为0]
qOut.put（（i，答案））
def总管（L）：
qIn，qOut=[mp.Queue（）表示范围（2）]
procs=[mp.Process（target=matcher，args=（qIn，qOut））用于范围内的（mp.cpu\u count（）-1）]
对于进程中的p:p.start（）
numElems=len（L）
对于枚举（L）中的t:qIn.put（t）
对于进程中的p:qIn.put（无）
完成=0
完成时