elenco diviso per determinati valori di indice ripetuti

Question

Ho una lista di numeri interi, in cui alcuni sono numeri consecutivi.

quello che ho:

myIntList = [21,22,23,24,0,1,2,3,0,1,2,3,4,5,6,7] ecc ...

quello che voglio:

MyNewIntList = [[21,22,23,24],[0,1,2,3],[0,1,2,3,4,5,6,7]] 

voglio essere in grado di dividere questa lista l'elemento 0, vale a dire quando looping, se l'elemento è 0, per dividere la lista in liste separate. Quindi, dopo aver diviso il numero myIntList in qualsiasi numero di volte (in base alle ricorrenze di ricerca dell'elemento 0), desidero aggiungere ogni "divisione" o gruppo di numeri interi consecutivi in ​​un elenco all'interno di un elenco.

Inoltre, sarei in grado di fare lo stesso genere di cose con una "lista di stringhe" invece di numeri interi? (Dividere la lista di stringhe principale in liste più piccole sulla base di un elemento ricorrente)

EDIT:

Come potrei fare per dividere la lista con i numeri consecutivi? C'è una parte nella mia lista in cui salta da 322 a 51, non c'è nessuno in mezzo. Voglio dividere:

[[...319,320,321,322,51,52,53...]] 

in

[[...319,320,321,322],[51,52,53...]] 

fondamentalmente, come faccio a dividere elementi di una lista da numeri consecutivi?

postato qui: Split list of lists (integers) by consecutive order into separate lists

Answer 1

it = iter(myIntList) 
out = [[next(it)]] 
for ele in it: 
    if ele != 0: 
     out[-1].append(ele) 
    else: 
     out.append([ele]) 

print(out) 

O in una funzione:

def split_at(i, l): 
    it = iter(l) 
    out = [next(it)] 
    for ele in it: 
     if ele != i: 
      out.append(ele) 
     else: 
      yield out 
      out = [ele] 
    yield out 

si cattura se si dispone di un 0 all'inizio:

In [89]: list(split_at(0, myIntList)) 
Out[89]: [[21, 22, 23, 24], [0, 1, 2, 3], [0, 1, 2, 3, 4, 5, 6, 7]] 

In [90]: myIntList = [0,21, 22, 23, 24, 0, 1, 2, 3, 0, 1, 2, 3, 4, 5, 6, 7] 

In [91]: list(split_at(0, myIntList)) 
Out[91]: [[0, 21, 22, 23, 24], [0, 1, 2, 3], [0, 1, 2, 3, 4, 5, 6, 7]] 

Answer 2

è possibile scorrere l'intero elenco, aggiungendo a una lista di temperatura fino 0 viene trovato. Quindi si reimposta nuovamente la lista temporanea e si continua.

>>> myIntList = [21,22,23,24,0,1,2,3,0,1,2,3,4,5,6,7] 
>>> newlist = [] 
>>> templist = [] 
>>> for i in myIntList: 
...  if i==0: 
...   newlist.append(templist) 
...   templist = [] 
...  templist.append(i) 
... 
>>> newlist.append(templist) 
>>> newlist 
[[21, 22, 23, 24], [0, 1, 2, 3], [0, 1, 2, 3, 4, 5, 6, 7]] 

e per le stringhe è possibile utilizzare lo stesso approccio utilizzando la list chiamata

>>> s = "winterbash" 
>>> list(s) 
['w', 'i', 'n', 't', 'e', 'r', 'b', 'a', 's', 'h'] 

anche utilizzando itertools

>>> import itertools 
>>> myIntList = [21,22,23,24,0,1,2,3,0,1,2,3,4,5,6,7] 
>>> temp=[list(g) for k,g in itertools.groupby(myIntList,lambda x:x== 0) if not k] 
>>> if myIntList[0]!=0: 
...  newlist = [temp[0]] + [[0]+i for i in temp[1:]] 
... else: 
...  newlist = [[0]+i for i in temp] 
... 
>>> newlist 
[[21, 22, 23, 24], [0, 1, 2, 3], [0, 1, 2, 3, 4, 5, 6, 7]] 

Answer 3

È possibile utilizzare per affettare:

myIntList = [21,22,23,24,0,1,2,3,0,1,2,3,4,5,6,7] 
myNewIntList = [] 
lastIndex = 0 
for i in range(len(myIntList)): 
    if myIntList[i] == 0: 
     myNewIntList.append(myIntList[lastIndex:i]) 
     lastIndex = i 

myNewIntList.append(myIntList[lastIndex:]) 
print(myNewIntList) 
# [[21, 22, 23, 24], [0, 1, 2, 3], [0, 1, 2, 3, 4, 5, 6, 7]] 

Y ou può dividere le stringhe utilizzando la funzione str.split:

s = 'stackoverflow' 
s.split('o') # ['stack', 'verfl', 'w'] (removes the 'o's) 

import re 
[part for part in re.split('(o[^o]*)', s) if part] # ['stack', 'overfl', 'ow'] (keeps the 'o's) 

Answer 4

si potrebbe provare:

i = 0 
j = 0 
loop = True 
newList = [] 

while loop: 
    try: 
     i = myIntList.index(0, j) 
     newList.append(myIntList[j:i]) 
     j = i + 1 
    except ValueError as e: 
     newList.append(myIntList[j:]) 
     loop = False 

print newList 
[[21, 22, 23, 24], [1, 2, 3], [1, 2, 3, 4, 5, 6, 7]] 

Answer 5

(I vagamente sospetto che ho fatto questo prima, ma non riesco a trovare ora.)

from itertools import groupby, accumulate 

def itergroup(seq, val): 
    it = iter(seq)  
    grouped = groupby(accumulate(x==val for x in seq)) 
    return [[next(it) for c in g] for k,g in grouped] 

dà

>>> itergroup([21,22,23,24,0,1,2,3,0,1,2,3,4,5,6,7], 0) 
[[21, 22, 23, 24], [0, 1, 2, 3], [0, 1, 2, 3, 4, 5, 6, 7]] 
>>> itergroup([0,1,2,0,3,4], 0) 
[[0, 1, 2], [0, 3, 4]] 
>>> itergroup([0,0], 0) 
[[0], [0]] 

(Detto questo, in pratica, io uso la versione yield dello stesso ciclo/tralcio che non tutti gli altri, ma vi posterò quanto sopra per la varietà.)

Answer 6

myIntList = [21,22,23,24,0,1,2,3,0,1,2,3,4,5,6,7] 

new = [] 
m,j=0,0 
for i in range(myIntList.count(0)+1): 
    try: 
     j= j+myIntList[j:].index(0) 
     if m==j: 
      j= j+myIntList[j+1:].index(0)+1 



     new.append(myIntList[m:j]) 
     m,j=j,m+j 
    except: 
     new.append(myIntList[m:]) 
     break 
print new 

uscita

[[21, 22, 23, 24], [0, 1, 2, 3], [0, 1, 2, 3, 4, 5, 6, 7]] 

output2

myIntList = [0,21,22,23,24,0,1,2,3,0,1,2,3,4,5,6,7] 

[[0, 21, 22, 23, 24], [0, 1, 2, 3], [0, 1, 2, 3, 4, 5, 6, 7]]