Modifica di un numero elevato di istruzioni if-elif-else per utilizzare la struttura sottostante

La tua funzione iniziale esegue un passo specifico per un tipo specifico, entrambi forniti come argomento. Nel secondo caso si itera sui passaggi cercando di trovare quello giusto.

Alternativa 1: doppio dizionario

In base alla tua alternativa, ti propongo di prendere in considerazione un dizionario di dizionari, usando due indici invece di uno solo. Esempio:

# just some functions to be invoked
def do_me_at_step_1():
    return 1

def do_me_at_step_2():
    return 2

def do_other_step_2():
    return 102

# Use a dictionary assigning one type to a second level dictionary   
# In the second level dictionary, assign one step with a function 
command = { 'A': { 1:do_me_at_step_1, 2:do_me_at_step_2 }, 'B': { 1:do_me_at_step_1, 2:do_other_step_2 } }

# How you'd invoke the right function in function_name()
print (command['A'][1]())
print (command['A'][2]())
print (command['B'][1]())
print (command['B'][2]())

Quindi in questo caso, il tuo function_name () trova la funzione da invocare usando un dizionario di dizionari e poi li invoca.

Alternativa 2: codice orientato agli oggetti?

Potresti anche considerare l'utilizzo di un approccio orientato agli oggetti:

Quindi, in effetti, dovresti creare classi diverse, ognuna corrispondente a un tipo diverso. E poi invocherai per una istanziazione di una classe specifica il metodo corrispondente al passo.

In effetti, l'implementazione sarebbe molto vicina al pattern di stato

Questo è basato sulla risposta di Christophe .

La risposta di Christophe si concentra sull'uso di un doppio dizionario, con un set di chiavi typ e l'altro set di chiavi step . Tuttavia, questo non tiene conto dell'istruzione else - cioè, ad un certo punto, indipendentemente dal valore di step , viene utilizzata la stessa funzione, ma il dizionario non può saperlo.

In realtà c'è un modo abbastanza semplice per spiegare questo, ed è quello che sto usando in questo momento (anche se sarei molto aperto ad altre risposte che sembrano più pulite): usa un secondo dizionario con i casi predefiniti. Quindi la funzione diventa:

def function_name(step, ... , typ):
    command = { 'A': { 1:do_me_at_step_1, 2:do_me_at_step_2 }, 'B': { 1:do_me_at_step_1, 2:do_other_step_2 } }
    default_command = {'A':final_function_for_A, 'B':final_function_for_B, ...}
    try:
        return command[typ][step](inputs to function)
    except KeyError:
        return default_command[typ](inputs to function)

che è molto più bello di quello che ho avuto.

Modifica: poiché l'intercettazione di un errore è costosa, le ultime quattro righe probabilmente andrebbero meglio come if-else:

if step in command[typ].keyValues():
    return command[typ][step](...)
else:
    return default_command[typ](...)

Puoi chiamare le tue funzioni typ tra i passaggi comuni se passi la funzione come parametro, quindi chiamalo durante il tuo keytep.

# defining some dummy functions as the common code
def f1(*args):
    pass

def f2(*args):
    pass

def f3(*args):
    pass

# defining some functions for a specific 'typ'
def integer(*args):
    pass

def complex(*args):
    pass

# a dictionary that 1-indexes the common code
common_code = {
    1 : f1,
    2 : f2,
    3 : f3,
    # some lambdas in case your common code is simple or short
    4 : (lambda *args: args),
    5 : (lambda *args: args),
}

# the main function that lets us call a function for a chosen keystep
def calc_switch(step, calc_typ, *args):
    last = len(common_code)
    # perform the common steps from 1 until the chosen step
    # this for loop will not execute code if the user chooses 1
    for i in range(1, step):
        common_code[i](args)

    # the call to our step-dependent function
    calc_typ(args)

    # Continue calculating common code
    # if you want to exclude the step chosen by the user, then 
    # set the first argument of range to step+1
    for i in range(step, last + 1):
        common_code[i](args)


# some example calls, where the first argument is the key-step
calc_switch(2, complex)
calc_switch(4, integer)

Ora devi solo definire le funzioni del tuo passo chiave una volta e il tuo comportamento comune una volta. Ulteriori modifiche al codice comune verranno eseguite nel dizionario di codice comune.

Inoltre, se si desidera isolare la chiamata per un 'typ', è possibile utilizzare le funzioni parziali. Ad esempio:

from functools import partial

do_integer = partial(calc_switch, 2, complex)
do_complex = partial(calc_switch, 4, integer)

Ora avremo una funzione do_integer completa che esegue tutte le attività comuni, esegue il calcolo per typ 'intero' al passo chiave definito, esegue qualsiasi funzione comune dopo quel keystep e accetta qualsiasi argomento e passa alla funzione di base (tramite il parametro * args).

Spero che questo aiuti! Il codice è in Python 2.7, ma la roba del dizionario e le applicazioni parziali sono tutte in Python 3.