valutazione arresto all'interno di un modulo

Question

io sono abituato a funzioni di scrittura che funzionano in questo modo:

def f(): 
    if sunny: 
    return 
    #do non-sunny stuff 

che sto cercando di capire la sintassi equivalente di utilizzare all'interno di un modulo. Voglio fare qualcosa di simile:

if sunny: 
    import tshirt 
    #do something here to skip the rest of the file 
import raincoat 
import umbrella 
#continue defining the module for non-sunny conditions 

So che posso scrivere questo come un if/else ma sembra stupido per far rientrare l'intero resto del mio modulo.

Potrei spostare il resto del codice in un modulo separato e importarlo condizionatamente, ma ciò sembra doloroso.

Answer 1

File separati e indentazione aggiuntiva sono probabilmente ragionevoli dato che questa è una cosa strana da fare per cominciare.

A seconda di cosa è effettivamente necessario, è possibile procedere ed elaborare tutto il corpo del modulo e quindi eliminare tutto ciò che non è appropriato in un momento successivo.

def foo(): 
    print "foo" 
def bar(): 
    print "bar" 

if sunny: 
    del foo 
else: 
    del bar 

Answer 2

L'indentazione della parte condizionale mi sembra soddisfacente. Se è davvero lungo - diciamo più di uno screenful o due probabilmente spostarei le parti condizionali in file separati. Il tuo codice sarà molto più facile da leggere.

Answer 3

Dovrai indentare il codice, in un modo o nell'altro. Il modo più semplice è definire il codice all'interno delle funzioni e chiamarle. Ciò mantiene ordinati i blocchi if/else.

def do_if_sunny(): 
    pass 

def do_if_rainy(): 
    pass 

if sunny: 
    do_if_sunny() 
else: 
    do_if_rainy() 

In alternativa, è possibile utilizzare sempre sys.exit.

if sunny: 
    print "It's sunny" 
    sys.exit(0) 

# Continue with non-sunny conditions 

Answer 4

Vorrei seriamente andare con questa soluzione:

if sunny: 
    print "it's sunny" 
else: 
    exec ''' 
print "one" 
print "two" 
x = 3 
print x 
# ETC 
''' 

non

Scherzi a parte. Ma funziona.

Answer 5

È possibile utilizzare la funzione per farlo:

def foo(): 
    if True: 
     import re 
     import os 
    else: 
     import sys 
    return locals() 

locals().update(foo()) 

o:

def foo(): 
    if not True: 
     import sys 
     return locals() 
    import re 
    import os 

    return locals() 

locals().update(foo()) 

Answer 6

Proprio nella stessa situazione e non ho voglia di rientrare tutta una serie di codice nel mio modulo. Ho usato eccezioni per interrompere il caricamento di un modulo, catturato e ignorato l'eccezione personalizzata. Questo rende il mio modulo Python molto procedurale (che presumo non sia l'ideale), ma ha salvato alcune enormi modifiche al codice.

avevo un modulo comune/supporto, che ho definito quanto segue:

import importlib 

def loadModule(module): 
    try: 
     importlib.import_module(module) 
    except AbortModuleLoadException: 
     pass; 

class AbortModuleLoadException(Exception): 
    pass; 

Con questo, se volevo "cancellare" o "stop" caricare un modulo, avrei caricare il modulo come segue:

loadModule('my_module'); 

E dentro il mio modulo, posso buttare la seguente eccezione per una certa condizione:

if <condition>: 
    raise AbortModuleLoadException;