Создать массив значений индекса из списка с другим списком Python

1111 Вопрос в том, как сделать так, чтобы это было не очень неэффективно. Я вижу, что в двух подходах

1. используется словарь, поэтому поиск будет быстрым. numpy массивы являются изменяемыми и, следовательно, не могут быть хешируемыми, поэтому вам придется преобразовывать их, например, в кортежи для использования со словарем.

2. Используйте широковещательную проверку для проверки value_list каждого «ключа» в key_list векторизованным способом. Это по крайней мере выведет циклы for из Python, но вам все равно придется сравнивать каждое значение с каждым ключом.

Здесь я также предполагаю, что key_list имеет только уникальные «ключи».

Вот как вы могли бы сделать первый подход:

value_list = np.array([[2,2,3],[255,243,198],[2,2,3],[50,35,3]])
key_list = np.array([[2,2,3],[255,243,198],[50,35,3]])

key_map = {tuple(key): i for i, key in enumerate(key_list)}
result = np.array([key_map[tuple(value)] for value in value_list])
result # array([0, 1, 0, 2])

И вот второй:

result = np.where((key_list[None] == value_list[:, None]).all(axis=-1))[1]
result # array([0, 1, 0, 2])

Какой способ быстрее может зависеть от размера key_list и [ 117]. Я бы выбрал для вас оба набора типичных размеров.

РЕДАКТИРОВАТЬ - как отмечалось в комментариях, второе решение не кажется полностью правильным, но я не уверен, что делает его неудачным. Попробуйте вместо этого использовать первое решение.

Допущения:

1. Каждый элемент value_list будет присутствовать в key_list (в той или иной позиции)
2. Нас интересует индекс в key_list только для первого совпадения

Решение:

Из из двух массивов мы создаем представления из 3-х кортежей. Затем мы транслируем два представления в двух ортогональных направлениях, а затем проверяем поэлементное равенство на транслируемых массивах.

import numpy as np

value_list = np.array([[2,2,3],[255,243,198],[2,2,3],[50,35,3]], dtype='uint8')
key_list   = np.array([[2,2,3],[255,243,198],[50,35,3]], dtype='uint8')

# Define a new dtype, describing a "structure" of 3 uint8's (since
# your original dtype is uint8). To the fields of this structure,
# give some arbitrary names 'first', 'sec', and 'third'
dt = np.dtype([('first', np.uint8, 1),('sec', np.uint8, 1),('third', np.uint8, 1)])

# Now view the arrays as 1-d arrays of 3-tuples, using the dt
v_value_list = value_list.view(dtype=dt).reshape(value_list.shape[0])
v_key_list   = key_list.view(dtype=dt).reshape(key_list.shape[0])

result = np.argmax(v_key_list[:,None] == v_value_list[None,:], axis=0)
print (result)

Вывод:

[0, 1, 0, 2]

Примечания:

1. Хотя это чистое решение без видимых циклов он может иметь скрытую неэффективность, потому что он сопоставляет каждый элемент value_list с каждым элементом key_list, в отличие от поиска на основе цикла, который интеллектуально останавливается при первом успешном сопоставлении. Любое полученное преимущество будет зависеть от фактического размера key_list, а также от того, где происходят успешные совпадения, в key_list. По мере роста размера key_list, может быть некоторое размывание преимущества NumPy, особенно если успешные совпадения происходят в основном в более ранней части key_list.

2. Представления, которые мы создаем, на самом деле являются простыми структурированными массивами, где каждый элемент представления представляет собой структуру из двух int с. Один интересный вопрос, который я еще не исследовал, заключается в том, что, когда numpy сравнивает одну структуру с другой, выполняет ли она сравнение каждого поля в структуре или замыкает сравнение полей в первом ошибочном поле структура? Любое такое короткое замыкание может подразумевать небольшое дополнительное преимущество для этого решения со структурированным массивом.