Mieux looping, pour la manipulation des cordes (python)

Question

Si j'ai ce code

s = 'abcdefghi' 
for grp in (s[:3],s[3:6],s[6:]): 
    print "'%s'"%(grp) 

    total = calc_total(grp) 

    if (grp==s[:3]): 
     # more code than this 
     p = total + random_value 
     x1 = my_function(p) 

    if (grp==s[3:6]): 
     # more code than this 
     p = total + x1 
     x2 = my_function(p) 

    if (grp==s[6:]): 
     # more code than this 
     p = total + x2 
     x3 = my_function(p) 

Si le groupe est le premier groupe, exécutez le code pour ce groupe, si le groupe est le deuxième groupe, exécutez le code en utilisant la une valeur générée à partir du code effectué pour le premier groupe, la même chose s'applique pour le troisième groupe, en utilisant une valeur générée à partir du code pour le deuxième groupe:

Comment puis-je ranger ceci pour utiliser une meilleure boucle?

Merci

Answer 1

Je code quelque chose comme ceci comme suit:

for i, grp in enumerate((s[:3],s[3:6],s[6:])): 
    print "'%s'"%(grp) 

    total = calc_total(grp) 
    # more code that needs to happen every time 

    if i == 0: 
     # code that needs to happen only the first time 
    elif i == 1: 
     # code that needs to happen only the second time 

etc. Les == contrôles peuvent induire en erreur si l'un des groupes « arrive juste » être le même que l'autre, alors que l'approche enumerate ne court aucun risque.

Answer 2

j'ai mal compris ce que vous faites, mais il semble que vous voulez faire quelque chose à s [3] sur la première itération, quelque chose de différent s [3: 6] sur la deuxième, et quelque chose d'autre encore à s [6:] sur le troisième. En d'autres termes, ce n'est pas une boucle du tout! Il suffit d'écrire ces trois blocs de code l'un après l'autre, avec s [: 3] et ainsi de suite à la place de grp.

Answer 3

x = reduce(lambda x, grp: my_function(calc_total(list(grp)) + x), 
     map(None, *[iter(s)] * 3), random_value) 

À la fin, vous aurez le dernier x.

Ou, si vous souhaitez conserver les résultats intermédiaires autour,

x = [] 
for grp in map(None, *[iter(s)] * 3): 
    x.append(my_function(calc_total(list(grp)) + (x or [random_value])[-1])) 

Ensuite, vous avez x[0], x[1], x[2].

Answer 4

insérer vos données dans la liste que vous voulez, essayez ce qui suit:

output = 0 
seed = get_random_number() 
for group in input_list: 
    total = get_total(group) 
    p = total + seed 
    seed = my_function(p) 

input_list devront ressembler ['abc', 'def', 'ghi']. Mais si vous voulez l'étendre à ['abc','def','ghi','jkl','mno','pqr'], cela devrait toujours fonctionner.

Answer 5

Je dois dire que je suis d'accord avec Peter en ce sens que la boucle est redondante. Si vous avez peur de dupliquer le code, puis il suffit de déplacer le code à répéter dans une fonction et l'appeler plusieurs fois:

s = 'abcdefghi' 

def foo(grp): 
    # Anything more you would like to happen over and over again 
    print "'%s'"%(grp) 
    return calc_total(grp) 

def bar(grp, value): 
    total = foo(grp) 
    # more code than this 
    return my_function(total + value) 

x1 = bar(s[:3], random_value) 
x2 = bar(s[3:6], x1) 
x3 = bar(s[6:], x2) 

Si

# more code than this 

contient du code non-double, alors vous devez de déplacer des cours cela en "barre" (qui avec "foo" devrait être donné un nom plus descriptif).