Operare in un elenco in modo pignolo quando l'output dipende da altri elementi

Question

Ho un'attività che richiede un'operazione su ogni elemento di un elenco, con il risultato dell'operazione a seconda degli altri elementi nell'elenco.

Ad esempio, potrebbe piacermi per concatenare un elenco di stringhe condizionali sopra partendo da un particolare carattere:

Questo codice risolve il problema:

x = ['*a', 'b', 'c', '*d', 'e', '*f', '*g'] 
concat = [] 
for element in x: 
    if element.startswith('*'): 
     concat.append(element) 
    else: 
     concat[len(concat) - 1] += element 

conseguente:

concat 
Out[16]: ['*abc', '*de', '*f', '*g'] 

Ma questo sembra orribilmente non-Pythonic. Come si dovrebbe operare sugli elementi di un list quando il risultato dell'operazione dipende dai risultati precedenti?

Answer 1

alcuni stralci rilevanti import this (l'arbitro di ciò che è Pythonic):

• Semplice è meglio che complesso
• Leggibilità conta
• Esplicito è meglio che implicita.

Vorrei solo usare un codice come questo, e non preoccuparmi di sostituire il ciclo for con qualcosa di "più piatto".

x = ['*a', 'b', 'c', '*d', 'e', '*f', '*g'] 
partials = [] 
for element in x: 
    if element.startswith('*'): 
     partials.append([]) 
    partials[-1].append(element) 
concat = map("".join, partials) 

Answer 2

"".join(x).split("*") 

forse sufficiente, di grossolana questo può essere un esempio inventato nel vostro OP che viene semplificato eccessivamente e come tale questo non funzionerà

Answer 3

Si potrebbe utilizzare espressioni regolari per raggiungere questo succintamente. Ciò, tuttavia, aggira la tua domanda su come operare sugli elementi della lista dipendenti. Crediti a mbomb007 per migliorare la funzionalità dei caratteri consentiti.

import re 
z = re.findall('\*[^*]+',"".join(x)) 

Uscite:

['*abc', '*de', '*f', '*g'] 

---

Piccolo analisi comparativa:

Donkey Kong's answer:

import timeit 
setup = ''' 
import re 
x = ['*a', 'b', 'c', '*d', 'e', '*f', '*g'] 
y = ['*a', 'b', 'c', '*d', 'e', '*f', '*g'] * 100 
''' 
print (min(timeit.Timer('re.findall("\*[^\*]+","".join(x))', setup=setup).repeat(7, 1000))) 
print (min(timeit.Timer('re.findall("\*[^\*]+","".join(y))', setup=setup).repeat(7, 1000))) 

Restituisce 0.00226416693456 e 0.06827958075, rispettivamente.

Chepner's answer:

setup = ''' 
x = ['*a', 'b', 'c', '*d', 'e', '*f', '*g'] 
y = ['*a', 'b', 'c', '*d', 'e', '*f', '*g'] * 100 
def chepner(x): 
    partials = [] 
    for element in x: 
     if element.startswith('*'): 
      partials.append([]) 
     partials[-1].append(element) 
    concat = map("".join, partials) 
    return concat 
''' 
print (min(timeit.Timer('chepner(x)', setup=setup).repeat(7, 1000))) 
print (min(timeit.Timer('chepner(y)', setup=setup).repeat(7, 1000))) 

ritorni rispettivamente 0.00456210269896 e 0.364635824689,.

Saksham's answer

setup = ''' 
x = ['*a', 'b', 'c', '*d', 'e', '*f', '*g'] 
y = ['*a', 'b', 'c', '*d', 'e', '*f', '*g'] * 100 

''' 
print (min(timeit.Timer("['*'+item for item in ''.join(x).split('*') if item]", setup=setup).repeat(7, 1000))) 
print (min(timeit.Timer("['*'+item for item in ''.join(y).split('*') if item]", setup=setup).repeat(7, 1000)))) 

Returns 0.00104848906006 e 0.0556093171512 rispettivamente.

tl; dr Saksham è leggermente più veloce del mio, quindi Chepner segue entrambi i nostri.

Answer 4

ne dite di questo:

>>> x = ['*a', 'b', 'c', '*d', 'e', '*f', '*g'] 
>>> print ['*'+item for item in ''.join(x).split('*') if item] 
['*abc', '*de', '*f', '*g'] 

Answer 5

sento che questo è molto Pythonic:

# assumes no empty strings, or no spaces in strings 
"".join(x).replace('*', ' *').split() 

---

Ecco un approccio funzionale ad esso:

from functools import reduce 

# assumes no empty strings 
def reduction(l, it): 
    if it[0] == '*': 
     return l + [it] 
    else: 
     new_l, last = l[:-1], l[-1] 
     return new_l + [last + it] 

x = ['*a', 'b', 'c', '*d', 'e', '*f', '*g'] 

print reduce(reduction, x, []) 
>>> ['*abc', '*de', '*f', '*g'] 

Se sei un fan di lambda (non molto Pythonic), si potrebbe ottenere via con questo:

# Don't do this, it's ugly and unreadable. 
reduce(lambda l, it: l + [it] if it.startswith('*') else l[:-1] + [l[-1]+it], x, []) 

Answer 6

Questo è terribilmente vicino a quello che itertools.groupby fa, e di fatto con un po 'porzione di curry che può fare continua a raggruppare fino a quando non si verifica una condizione di "interruzione", ad esempio startswith('*').

from itertools import groupby 

def new_group_when_true(pred): 
    group_num = 0 
    def group_for_elem(elem): 
     nonlocal group_num 
     if pred(elem): 
      group_num +=1 
     return group_num 
    return group_for_elem 

l = ['*a', 'b', 'c', '*d', 'e', '*f', '*g'] 

test = new_group_when_true(lambda elem: elem.startswith('*')) 

grouped = [list(v) for k,v in groupby(l, test)] 

Con conseguente:

>>> print(grouped) 
[['*a', 'b', 'c'], ['*d', 'e'], ['*f'], ['*g']] 

Il nonlocal parola chiave richiede Python 3, naturalmente. Un'altra possibilità sarebbe quella di creare una classe, sulla falsariga del "codice equivalente" groupby dai documenti itertools.

Non so che questo è più Pythonic che il vostro codice, ma penso che l'idea di andare in libreria standard per vedere se qualcosa quasi adatto alle proprie esigenze è un punto utile.