Проверка, чтобы увидеть, если элементы массива равны

Question

В питоне, как бы я это сделать:

говорит, у меня есть:

a = [[1, 5], [2,6], [3,3], [4,2]] 
b= [[3, 1], [4,2], [1,8], [2,4]] 

Теперь я хочу сделать операцию со вторым значений столбца, если первый столбец значения соответствуют.

E.G.

а имеет запись [, 5], теперь пройти через Ь, чтобы увидеть О, это имеет значение [, 8], теперь я хочу, чтобы разделить 5/8 и хранить это значение в массив, скажем, с. Следующее будет соответствовать [, 6] и [, 4] и получить следующее значение в c: 6/4.

так:

c = [5/8, 6/4, 3/1, 2/2] 

Учитывая приведенный выше пример. Я надеюсь в этом есть смысл. Хотелось бы это с numpy и python.

Answer 1

Вы можете использовать np.searchsorted, чтобы получить позиции, где b «s первые элементы столбцов соответствуют a» первых элементов столбцов s и, используя которые получают соответствующие вторые элементы столбцов для разделения и, наконец, получить c. Таким образом, предположив a и b быть Numpy массивов, векторизованная реализация будет -

a0 = a[:,0] 
c = np.true_divide(a[:,1],b[np.searchsorted(a0,b[:,0],sorter=a0.argsort()),1]) 

подхода перечисленным выше работами для общего случая, когда первые элементы столбцов a не обязательно отсортированы. Но, если они сортируются так же, как для перечисленного случая образца, вы можете просто игнорировать входной аргумент sorter и имеете упрощенное решение, как так -

c = np.true_divide(a[:,1],b[np.searchsorted(a0,b[:,0]),1]) 

Пример запуск -

In [35]: a 
Out[35]: 
array([[1, 5], 
     [2, 6], 
     [3, 3], 
     [4, 2]]) 

In [36]: b 
Out[36]: 
array([[3, 1], 
     [4, 2], 
     [1, 8], 
     [2, 4]]) 

In [37]: a0 = a[:,0] 

In [38]: np.true_divide(a[:,1],b[np.searchsorted(a0,b[:,0],sorter=a0.argsort()),1]) 
Out[38]: array([ 0.625, 1.5 , 3. , 1. ]) 

Answer 2

Вы можете использовать простой способ O(n^2) с вложенными петлями:

c = [] 

for x in a: 
for y in b: 
    if x[0] == y[0]: 
    c.append(x[1]/y[1]) 
    break 

выше полезно, когда списки малы. Для огромных списков рассмотрите подход на основе словаря, где сложность будет O (n) за счет некоторого дополнительного пространства.

Answer 3

Учитывая все предположения в комментариях, это будет работать:

from operator import itemgetter 
from __future__ import division 

a = [[1, 5], [2,6], [3,3], [4,2]] 
b = [[3, 1], [4,2], [1,8], [2,4]] 

result = [x/y for (_, x), (_, y) in zip(a, sorted(b, key=itemgetter(0)))] 

Предположения: списки имеют одинаковую длину, элементы в первой позиции являются уникальными для каждого списка, первый список сортируется по первому элементу , каждый элемент, который встречается в первой позиции в a, также встречается в первой позиции в b.

Answer 4

Я смиренно предлагаю вам использовать неправильную структуру данных. Обратите внимание: если у вас есть столбец массива, который имеет уникальные значения между 1 и N (индексный столбец), вы можете кодировать одни и те же данные, просто переупорядочив другие столбцы. После того, как вы перенаправили свои данные, вы можете не только отбросить столбец «индекс», но теперь становится проще работать с оставшимися данными.Позвольте мне продемонстрировать:

import numpy as np 

N = 5 
a = np.array([[1, 5], [2,6], [3,3], [4,2]]) 
b = np.array([[3, 1], [4,2], [1,8], [2,4]]) 

a_trans = np.ones(N) 
a_trans[a[:, 0]] = a[:, 1] 

b_trans = np.ones(N) 
b_trans[b[:, 0]] = b[:, 1] 

c = a_trans/b_trans 
print c 

В зависимости от характера вашей проблемы, вы можете иногда использовать неявный индекс с самого начала, но иногда явный показатель может быть очень полезным. Если вам нужен явный индекс, подумайте о том, чтобы использовать что-то вроде pandas.DataFrame с лучшей поддержкой индексирования.