2013-10-26 21 views
6

Ho una lista di tuple. Per esempio, ho il seguente:Come eseguire la ricerca su un elenco di tuple

a=[('jamy', 'k'), ('Park', 'h'), ('kick', 'p'), ('an', 'o'),('an', 
'o'),('an', 'o'),('an', 'r'), ('car', 'k'), ('rock', 'h'), ('pig', 
'p')] 

E un altro elenco,

b = ['k','h','p'] 

Vorrei trovare il modello in lista b da secondo elemento tupla di lista a.

Qui nell'esempio di cui sopra l'uscita dovrebbe tornare,

[('jamy','Park','kick'),('car','rock','pig')] 

qualcuno può aiutarmi a raggiungere i miei obiettivi?

+2

Cosa hai finora? –

+2

E se la lista fosse 'a = [('jamy', 'k'), ('Park', 'h'), ('kick', 'p'), ('an', 'o'), ('an', 'o'), ('an', 'o'), ('an', 'r'), ('rock', 'h'), ('pig', 'p')] 'senza la tupla dell'auto. L'output dovrebbe essere '[('jamy', 'Park', 'kick'), ('jamy', 'rock', 'pig')]' o '[('jamy', 'Park', 'kick'))] ' – Christian

+0

Non sono sicuro che questo sia un requisito, ma il mio codice funziona anche se' 'k', 'h', 'p'' non sono consecutivi in ​​'a'. Come in se le lettere nelle coppie da 'a' sono:' khhprgskrfbhevp', corrisponderanno a 'khp' da' khhprgsKrfbHevP', le maiuscole indicano quali lettere sono state abbinate. –

risposta

1
c = [(a[x][0], a[x+1][0], a[x+2][0]) 
         for x, _ in enumerate(a) 
           if a[x][1] == b[0] and 
            a[x+1][1] == b[1] and 
            a[x+2][1] == b[2]] 
+0

@ oleg grazie, è stata una rapida risposta. Forse op dovrebbe dirci se b può avere una lunghezza variabile o dovrebbe fare riferimento a [x] [0] a – cox

1

Supponendo che la lunghezza di b è 3, il seguente codice funzionerà anche se a contiene 'k','h','p' tale che non seguono sempre reciprocamente correttamente, come in:

a=[('test', 'k'), ('jamy', 'k'), ('Park', 'h'), ('kick', 'p'), ('car', 'k'), 
('an', 'r'),('rock', 'h'), ('see','k'), ('it','h'),('an', 'o'),('works', 'p')] 

b = ['k','h','p'] 

produrrà:

[('jamy', 'Park', 'kick'), ('see', 'it', 'works')] 

Codice:

letters_a = "".join(str(tup[1]) for tup in a) 
letters_b = "".join(str(letter) for letter in b) 
regex = re.compile(r'(%s)[^%s]*(%s)[^%s]*(%s)' 
        % (letters_b[0],letters_b[:2],letters_b[1],letters_b,letters_b[2])) 
#for this example, the above line translates to: 
#regex = re.compile(r'(k)[^kh]*(h)[^khp]*(p)') 
match = re.finditer(regex, letters_a) 

results=[] 
for m in match: 
    first,second,third = m.start(1), m.start(2), m.start(3) 
    results.append((a[first][0],a[second][0],a[third][0])) 

print results 
1

Prova questo snippet.

list_of_values = [ 
    ('jamy', 'k'), ('Park', 'h'), ('kick', 'p'), ('an', 'o'), ('an', 'o'), 
    ('an', 'o'), ('an', 'r'), ('car', 'k'), ('rock', 'h'), ('pig', 'p') 
] 
pattern = ('k','h','p') 

# Important part 
matches = [ 
    values for values, keys in (
     zip(*list_of_values[i:i + len(pattern)]) 
     for i in range(len(list_of_values) - len(pattern) + 1) 
    ) if keys == pattern 
] 

print(matches) 
>> [('jamy', 'Park', 'kick'), ('car', 'rock', 'pig')] 
+0

lavorato come un incantesimo .. :-) Mille grazie .. – Vysa

+0

Non funziona per 'modello = ('h ',' k ',' p ') ' – dawg

+1

@drewk perché non ci sono valori sequenziali che corrispondono al modello. L'utente non ha specificato se le chiavi casuali dovrebbero essere consentite tra i pattern key ma ha specificato che era un ** pattern **. – OdraEncoded

1
a = [('jamy', 'k'), ('Park', 'h'), ('kick', 'p'), 
    ('an', 'o'), ('an', 'o'), ('an', 'o'), ('an', 'r'), 
    ('car', 'k'), ('rock', 'h'), ('pig', 'p')] 

b = ['k', 'h', 'p'] 

filtered = [ele for ele in a if ele[1] in b] 

def split_list(_list, idx_range): 
    _t = [] 
    _temp = [] 
    _d = {idx + 1: ele for idx, ele in enumerate(_list)} 
    for k in _d: 
     if k % idx_range == 0: 
      _t.append(_d[k]) 
      _temp.append(_t) 
      _t = [] 
     else: 
      _t.append(_d[k]) 
    return _temp 

_nested = split_list(filtered, len(b)) 

_l1 = [] 
for outer in _nested: 
    _s = '' 
    for inner in outer: 
     _s += inner[1] 
    _l1.append(_s) 

_l2 = [_nested[idx] for idx, ele in enumerate(_l1) if ''.join(b) == ele] 

final = [] 
for ele in _l2: 
    tup = [e[0] for e in ele] 
    final.append(tuple(tup)) 

print final 

uscita:

[('jamy', 'Park', 'kick'), ('car', 'rock', 'pig')] 
0

Data:

a = [ 
    ('jamy', 'k'), ('Park', 'h'), ('kick', 'p'), ('an', 'o'), ('an', 'o'), 
    ('an', 'o'), ('an', 'r'), ('car', 'k'), ('rock', 'h'), ('pig', 'p') 
] 
b = ('k','h','p') 

Se il vostro obiettivo è quello di raccogliere gruppi di tuple dalla lista a basato il secondo elemento che si verificano nello stesso ordine di la sequenza in b è possibile:

result=[] 
for sl in [a[i:i+len(b)] for i in range(0,len(a))]: 
    if tuple([tp[1] for tp in sl])==b: 
     result.append(tuple(tp[0] for tp in sl)) 

print result   
# [('jamy', 'Park', 'kick'), ('car', 'rock', 'pig')] 
+0

Questo ** non ** seguirà lo schema in tutti i casi!Cerca 'list_of_values ​​= [(" Park "," h "), (" jamy "," k "), (" kick "," p ")]' che produrrà '[(" jamy "," Park " , "kick")] 'anche se non sono nel giusto ordine. – OdraEncoded

+0

@OdraEncoded: stai inventando quel requisito. Non è indicato se l'ordine dell'elenco di modelli o l'elenco di tuple dovrebbe determinare l'ordine di output. Con 'pattern = ('k', 'h', 'p')' ** e ** 'list_of_values ​​= [(" Park "," h "), (" jamy "," k "), (" kick "," p ")]" l'output di '[(" jamy "," Park "," kick ")]" mi sembra corretto. – dawg

+0

è uno schema. – OdraEncoded

Problemi correlati