Suche nach Elementen in einer bestimmten Reihenfolge in Listen

Question

Versuchen zu lernen, wie man in einer Liste in Python nach "pattern-like" -Sequenzen sucht, d. H., Ob es eine bestimmte Folge von Ganzzahlen in einer Liste gibt.

Meine beste Idee war zu überprüfen, ob a) alle drei Zahlen vorhanden sind b) um zu sehen, ob ihre Indizes sequentiell größer als einander sind. Aber ich bekomme unexcepted Ausgang wie folgt:

necessary_sequence = [20, 56, 2] 

first_num = necessary_sequence[0] 
second_num = necessary_sequence[1] 
third_num = necessary_sequence[2] 
test_list = [43, 12, 20, 20, 56, 56, 2, 4, 98, 20] #should print output_2, but printing output_1 (order rule is not observed) 

if first_num in test_list and second_num in test_list and third_num in test_list: 
    if test_list.index(first_num) < test_list.index(second_num) < test_list.index(third_num): 
     print("output_1: all three numbers are in the list in order") 
    else: 
     print("output_2: the numbers are either missing from the list or are not in order") 

Kann jemand die Fehler in der Logik des oben genannten Codes lokalisieren?

Answer 1

Ihr Code funktioniert wie erwartet. Es testet nur, ob die Werte der Indizes kleiner als die anderen sind. Es prüft nicht, ob sie direkt nebeneinander in der Liste ist:

>>> first, second, third = (20, 56, 2)           
>>> test_list = [43, 12, 20, 20, 56, 56, 2, 4, 98, 20] 
>>> if all([x in test_list for x in [first, second, third]]): 
... if test_list.index(first) < test_list.index(second) < test_list.index(third): 
...  print('output1')               
... else: 
...  print('output2') 
... 
output1 
>>> print(test_list.index(first)) 
2 
>>> print(test_list.index(second)) 
4 
>>> print(test_list.index(third)) 
6 

Answer 2

vielleicht zu weit fortgeschritten, aber es ist schwer, ein ‚Motto‘ Verständnis zu widerstehen ...

ns = [20, 56, 2] 
tl = [43, 12, 20, 20, 56, 56, 2, 4, 98, 20] 

[sum(a == b for a, b in zip(ns, tl[i:])) for i in range(len(tl)-len(ns)+1)] 

Out[31]: [0, 0, 1, 2, 2, 0, 0, 0] 

das Muster lose spricht ‚Faltung‘ einen ‚kernal‘ ns inkrementell parallel über eine andere Liste tl, dabei einige zwischen dem zusammenpassenden Positionswert Gleiten, das Ergebnis summiert und bei jedem Inkrement in einer Liste, die die Summen sammelt

for i in range(len(tl)-len(ns)+1) erzeugt den Index i

a == b for a, b in zip(ns, tl[i:]) ist ein Generator Ausdruck innerhalb sum()

zip(ns, tl[i:]) Linien ns parallel mit der gleichen Länge Scheibe tl bei Index beginnend i

zip automatisch verwirft die ecxcess tl Elemente

können wir sum das boolesche Ergebnis von a == b becuse von ‚duck typing‘, die True dreht, False in 1, 0

der Ausgang [0, 0, 1, 2, 2, 0, 0, 0] ist eine Liste mit der Anzahl der Übereinstimmungen zwischen ns und tl[i:] an jedem i für die i in range(len(tl)-len(ns)+1) wo ns und t1 vollständig

überlappen