Question

我想在新的1D数组/列表中找到并替换多个值。

列表的示例

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

我想替换

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

带

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

因此新数组是：

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

最快的方法是什么（对于非常大的列表，即要查找和替换50000个值）？

评论 anwsers

感谢大家的快速回复！我用以下方法检查了建议的解决方案：

N = 10**4
N_val = 0.5*N
a = np.random.randint(0, N_val, size=N)
val_old = np.arange(N_val, dtype=np.int)
val_new = np.arange(N_val, dtype=np.int)
np.random.shuffle(val_new)

a1 = list(a)
val_old1 = list(val_old)
val_new1 = list(val_new)

def Ashwini_Chaudhary(a, val_old, val_new):
    arr = np.empty(a.max()+1, dtype=val_new.dtype)
    arr[val_old] = val_new
    return arr[a]

def EdChum(a, val_old, val_new):
    df = pd.Series(a, dtype=val_new.dtype)
    d = dict(zip(val_old, val_new))
    return df.map(d).values   

def xxyzzy(a, val_old, val_new):
    return [val_new[val_old.index(x)] for x in a]

def Shashank_and_Hackaholic(a, val_old, val_new):
    d = dict(zip(val_old, val_new))
    return [d.get(e, e) for e in a]

def itzmeontv(a, val_old, val_new):
    return [val_new[val_old.index(i)] if i in val_old else i for i in a]

def swenzel(a, val_old, val_new):
    return val_new[np.searchsorted(val_old,a)]

def Divakar(a, val_old, val_new):
    C,R = np.where(a[:,np.newaxis] == val_old[np.newaxis,:])
    a[C] = val_new[R]
    return a

结果：

%timeit -n100 Ashwini_Chaudhary(a, val_old, val_new)
100 loops, best of 3: 77.6 µs per loop

%timeit -n100 swenzel(a, val_old, val_new)
100 loops, best of 3: 703 µs per loop

%timeit -n100 Shashank_and_Hackaholic(a1, val_old1, val_new1)
100 loops, best of 3: 1.7 ms per loop

%timeit -n100 EdChum(a, val_old, val_new)
100 loops, best of 3: 17.6 ms per loop

%timeit -n10 Divakar(a, val_old, val_new)
10 loops, best of 3: 209 ms per loop

%timeit -n10 xxyzzy(a1, val_old1, val_new1)
10 loops, best of 3: 429 ms per loop

%timeit -n10 itzmeontv(a1, val_old1, val_new1)
10 loops, best of 3: 847 ms per loop

性能的相对差异会随着biger N而增加，即如果N=10**7，则Ashwini_Chaudhary的结果为207 ms，结果为swenzel 6.89 s。

Answer 1

>>> arr = np.empty(a.max() + 1, dtype=val_new.dtype)
>>> arr[val_old] = val_new
>>> arr[a]
array([3, 4, 3, 1, 5, 5, 2, 3])

Answer 2

在vanilla Python中，没有numpy或pandas的速度，这是一种方式：

a = [2, 3, 2, 5, 4, 4, 1, 2]
val_old = [1, 2, 3, 4, 5]
val_new = [2, 3, 4, 5, 1]
expected_a_new = [3, 4, 3, 1, 5, 5, 2, 3]
d = dict(zip(val_old, val_new))
a_new = [d.get(e, e) for e in a]
print a_new # [3, 4, 3, 1, 5, 5, 2, 3]
print a_new == expected_a_new # True

此算法的平均时间复杂度为O(M + N)，其中M是您的＆＃34;翻译列表的长度＆＃34; N是列表a的长度。

Answer 3

假设您的val_old数组已排序（在此处就是这种情况，但如果稍后没有，那么请不要忘记排序val_new！），您可以使用numpy.searchsorted，然后使用结果访问val_new 如果数字没有映射，则不起作用，在这种情况下，您必须提供1to1映射。

In [1]: import numpy as np

In [2]: a = np.array([2, 3, 2, 5, 4, 4, 1, 2])

In [3]: old_val = np.array([1, 2, 3, 4, 5])

In [4]: new_val = np.array([2, 3, 4, 5, 1])

In [5]: a_new = np.array([3, 4, 3, 1, 5, 5, 2, 3])

In [6]: i = np.searchsorted(old_val,a)

In [7]: a_replaced = new_val[i]

In [8]: all(a_replaced == a_new)
Out[8]: True

50k数字？没问题！

In [23]: def timed():
    t0 = time.time()
    i = np.searchsorted(old_val, a)
    a_replaced = new_val[i]
    t1 = time.time()
    print('%s Seconds'%(t1-t0))
   ....: 

In [24]: a = np.random.choice(old_val, 50000)

In [25]: timed()
0.00288081169128 Seconds

500k的？你不会注意到差异！

In [26]: a = np.random.choice(old_val, 500000)

In [27]: timed()
0.019248008728 Seconds

Answer 4

尝试使用此预期输出，即使elements不在value_old内也能正常工作。

>>>[val_new[val_old.index(i)] if i in val_old else i for i in a]
[3, 4, 3, 1, 5, 5, 2, 3]

Answer 5

numpy_indexed包（免责声明：我是它的作者）为这类问题提供了一种优雅而高效的矢量化解决方案：

import numpy_indexed as npi
remapped_a = npi.remap(a, val_old, val_new)

实现的方法基于类似于swenzel的搜索，并且应该具有类似的良好性能，但更通用。例如，数组的项不需要是int，但可以是任何类型，甚至是nd-subarrays本身。

如果＆＃39; a＆＃39;中的所有值都是预计将出现在＆＃39; val_old＆＃39;中，您可以设置可选的＆＃39;缺失＆＃39; kwarg＆＃39;筹集＆＃39; （默认为＆＃39;忽略＆＃39;）。性能稍好一些，如果不满足该假设，您将得到KeyError。

Answer 6

要使用另外两个列表替换列表中的值作为键：值对，有几种方法。他们都使用＆＃34;列表压缩＆＃34;。

使用list.index（）：

a=[2, 3, 2, 5, 4, 4, 1, 2]
val_old=[1, 2, 3, 4, 5] 
val_new=[2, 3, 4, 5, 1]
a_new=[val_new[val_old.index(x)] for x in a]

使用您的特例：

a=[2, 3, 2, 5, 4, 4, 1, 2]
a_new=[x % 5 + 1 for x in a]

Answer 7

我试过这样：

>>> val_old=[1, 2, 3, 4, 5]
>>> val_new=[2, 3, 4, 5, 1]
>>> a=[2, 3, 2, 5, 4, 4, 1, 2]
>>> my_dict = dict(zip(val_old, val_new))
>>> [my_dict.get(x,x) for x in a]
[3, 4, 3, 1, 5, 5, 2, 3]

Answer 8

在pandas中，我会从2个列表中创建一个dict，然后调用map来执行查找并替换值：

In [6]:

df = pd.Series([2, 3, 2, 5, 4, 4, 1, 2])
df
Out[6]:
0    2
1    3
2    2
3    5
4    4
5    4
6    1
7    2
dtype: int64
In [7]:

val_old=[1, 2, 3, 4, 5] 
val_new=[2, 3, 4, 5, 1]
d = dict(zip(val_old,val_new ))
d
Out[7]:
{1: 2, 2: 3, 3: 4, 4: 5, 5: 1}
In [9]:

df.map(d)

Out[9]:
0    3
1    4
2    3
3    1
4    5
5    5
6    2
7    3
dtype: int64

对于80000元素系列，这需要3.4ms：

In [14]:

%timeit df.map(d)

100 loops, best of 3: 3.4 ms per loop

这是一种矢量化方法，比任何基于迭代的方法都要好得多。

Answer 9

对于numpy arrays，这可能是一种方法 -

%// Find row and column IDs for matches between "a" and "val_old"
C,R = np.where(a[:,np.newaxis] == val_old[np.newaxis,:])

%// Index into "a" with the column indices and 
%// set those to "val_new" elements indexed by "R"
a[C] = val_new[R]

示例运行和时间

输入：

a = np.random.randint(10000,size=(100000))
val_old = np.random.randint(10000,size=(1000))
val_new = np.random.randint(10000,size=(1000))

每个代码行的运行时间为 -

%timeit C,R = np.where(a[:,np.newaxis] == val_old[np.newaxis,:])
1 loops, best of 3: 292 ms per loop

%timeit a[C] = val_new[R]
10000 loops, best of 3: 43 µs per loop

Answer 10

list(map(lambda x:val_new[val_old.index(x)], a))

在python中查找并替换多个值

10 个答案: