Een exacte positie van een kleinere lijst binnen een lijst vinden (python)

Dus ik heb een lijst die ongeveer zo is:

list=[10.0, 10.0, 10.0, 9.9, 9.9, 9.9, 10.0, 9.9, 10.0, 10.0, 10.0, 10.0, 9.9, 9.9, 9.9, 9.9, 9.9, 9.9, 10.0, 10.0, 10.0, 10.2, 10.0, 9.9, 9.9, 9.9, 9.9, 10.0, 10.2, 10.0, 9.9, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.1, 10.0, 10.0, 10.0, 10.0, 10.0, 10.1, 10.1, 10.1, 10.1, 10.1, 10.1, 10.1, 10.1, 10.1, 10.1, 10.1, 10.2, 10.2, 10.2, 10.2, 10.2, 10.2, 10.2, 10.2, 10.2, 10.3, 10.3, 10.2, 10.2, 10.3, 10.3, 10.2, 10.2, 10.2, 10.2, 10.2, 10.2, 10.3, 10.2, 10.5, 10.9, 10.5, 10.3, 10.3, 10.3, 10.2, 10.2, 10.2, 10.2, 10.1, 10.1, 10.1, 10.1, 10.1, 10.1, 10.1, 10.1, 10.4, 10.7, 10.3, 10.2, 10.1, 10.1, 10.0, 10.0, 10.0, 10.0, 10.0, 9.9, 9.9, 9.9, 10.0, 9.9, 9.9, 9.9, 10.1, 9.9, 9.9, 9.8, 9.8, 9.8, 9.8, 9.8, 9.8, 9.8, 9.8, 9.8, 9.8, 9.8, 9.8, 9.8, 9.7, 9.8, 9.8, 9.7, 9.7, 9.7, 9.7, 9.7, 9.7, 9.6, 9.7]

En dan heb ik ook een sublijst die er ongeveer zo uitziet:

sublijst = [9.9, 9.9, 9.8, 9.8, 9.8, 9.8, 9.8, 9.8, 9.8, 9.8]

wat ik nu met deze kleinere lijst moet doen, is dat ik moet zoeken waar dit zich in de hoofdlijst bevindt. Dus in dit geval zou het resultaat iets als dit moeten zijn: index = 119 (misschien ben ik uit met +/- 1)

Ik heb dit de hele dag geprobeerd ... En ik heb niets gevonden op internet ... Ik heb een paar ideeën:

1) Ik vind het eerste item van de sublijst op de lijst .... wat in dit geval 4 zou zijn, dus ik controleer het volgende nummer dat ook correct is, dan het volgende dat fout zal zijn en het zou verzenden om een ​​ander te vinden 9.9 in de resterende lijst [4:] en herhaal dezelfde lus ... totdat een exacte overeenkomst is gevonden

2) Dan is een ander idee om op de een of andere manier strings te gebruiken str (lijst) [1: -1] .find (str (sublijst) [1: -1]), die in dit geval het antwoord zou geven van 687 ...

Probleem met deze ideeën is dat ze lang en slordig lijken te zijn en ook dat ik deze ideeën niet heb kunnen laten werken ...

2

4 antwoord

Wat dacht je van:

l = [10.0, 10.0, 10.0, 9.9, 9.9, 9.9, 10.0, 9.9, 10.0, 10.0, 10.0, 10.0, 9.9, 9.9, 9.9, 9.9, 9.9, 9.9, 10.0, 10.0, 10.0, 10.2, 10.0, 9.9, 9.9, 9.9, 9.9, 10.0, 10.2, 10.0, 9.9, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.1, 10.0, 10.0, 10.0, 10.0, 10.0, 10.1, 10.1, 10.1, 10.1, 10.1, 10.1, 10.1, 10.1, 10.1, 10.1, 10.1, 10.2, 10.2, 10.2, 10.2, 10.2, 10.2, 10.2, 10.2, 10.2, 10.3, 10.3, 10.2, 10.2, 10.3, 10.3, 10.2, 10.2, 10.2, 10.2, 10.2, 10.2, 10.3, 10.2, 10.5, 10.9, 10.5, 10.3, 10.3, 10.3, 10.2, 10.2, 10.2, 10.2, 10.1, 10.1, 10.1, 10.1, 10.1, 10.1, 10.1, 10.1, 10.4, 10.7, 10.3, 10.2, 10.1, 10.1, 10.0, 10.0, 10.0, 10.0, 10.0, 9.9, 9.9, 9.9, 10.0, 9.9, 9.9, 9.9, 10.1, 9.9, 9.9, 9.8, 9.8, 9.8, 9.8, 9.8, 9.8, 9.8, 9.8, 9.8, 9.8, 9.8, 9.8, 9.8, 9.7, 9.8, 9.8, 9.7, 9.7, 9.7, 9.7, 9.7, 9.7, 9.6, 9.7]
subl = [9.9, 9.9, 9.8, 9.8, 9.8, 9.8, 9.8, 9.8, 9.8, 9.8]
for i in xrange(len(l)-len(subl)):
  if l[i:i+len(subl)] == subl:
    print 'found at pos', i
    break
else:
  print 'not found'

Hierdoor wordt gevonden op pos 118 afgedrukt.

Postscriptum Ik heb de variabelen hernoemd, zodat lijst geen schaduw geeft voor de ingebouwde functie.

3
toegevoegd
Wauw! Dat is gewoon geweldig! Serieus, dit is precies wat ik nodig had ... Het is eenvoudig, maar doet ook het werk ... Jammer dat ik dit niet bedankt heb bedankt!
toegevoegd de auteur Artur Käpp, de bron
ind = l.index(subl[0])
for i in xrange(l.count(subl[0])-1):
    if l[ind:ind+len(subl)] == subl:
        print (ind)
        break;
    ind = l.index(subl[0],ind+1)

Dit is een efficiënte manier die alleen zal worden vergeleken als deze weet dat de eerste waarde van subl aanwezig is.

2
toegevoegd
idx = next(i for i in range(len(lst)-len(sublst)) if lst[i:i+len(sublist)] == sublst)
# 118
1
toegevoegd

Uw tweede idee kan een vals positief resultaat geven: als de sublijst één waarde zou zijn, bijvoorbeeld 1, en de volledige lijst alleen de waarde 11 had, zou deze een overeenkomst vinden. Als u scheidings- en volgscheidingstekens aan uw tekenreeks hebt toegevoegd, kan dit worden voorkomen.

Uw eerste idee is halverwege de optimale oplossing; er is een algoritme (waarvan de naam mij op dit moment ontgaat) om te bepalen hoeveel van de substring je kunt "hergebruiken", zodat je nooit meer terug hoeft te komen in de volledige string. Stel dat je huidige kandidaat is mislukt omdat je een 9,9 hebt gevonden waar je een 9,8 verwachtte; u hoeft dat element niet opnieuw te bezoeken, omdat het overeenkomt met het eerste element van de subtekenreeks. Die kunnen vooraf worden berekend, zodat u in één keer de volledige lijst hoeft af te lopen.

1
toegevoegd
Intersting dacht over de eerste ... goed voorbeeld .. De tweede zou moeten werken ja ik veronderstel ... Dank u voor het antwoord ..
toegevoegd de auteur Artur Käpp, de bron