Parar avaliação dentro de um módulo

10

Eu me acostumei a escrever funções que funcionam assim:

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

Estou tentando descobrir a sintaxe equivalente para usar em um módulo. Eu quero fazer algo assim:

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

Eu sei que posso escrever isso como um if/else , mas parece bobagem recuar todo o resto do meu módulo.

Eu poderia mover o restante do código em um módulo separado e importá-lo condicionalmente, mas isso parece ser doloroso.

    
por Paul McMillan 02.07.2010 в 03:49
fonte

6 respostas

2

Arquivos separados e recuo extra provavelmente são razoáveis, já que isso é uma coisa estranha de se fazer para começar.

Dependendo do que você realmente precisa, você pode ir em frente e processar todo o corpo do módulo e, em seguida, excluir qualquer coisa que não seja apropriada em algum momento posterior.

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

if sunny:
  del foo
else:
  del bar
    
por kwatford 02.07.2010 / 04:06
fonte
1

Apenas na mesma situação e eu não queria recuar um código inteiro no meu módulo. Eu usei exceções para parar de carregar um módulo, peguei e ignorei a exceção personalizada. Isso faz com que meu módulo Python seja muito processual (o que eu suponho não ser o ideal), mas salvou algumas mudanças maciças de código.

Eu tinha um módulo de suporte / comum, que defini o seguinte em:

import importlib

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

class AbortModuleLoadException(Exception):
    pass;

Com isso, se eu quisesse "cancelar" ou "parar" de carregar um módulo, eu carregaria o módulo da seguinte forma:

loadModule('my_module');

E dentro do meu módulo, posso lançar a seguinte exceção para uma determinada condição:

if <condition>:
    raise AbortModuleLoadException;
    
por jdknight 17.05.2014 / 00:18
fonte
0

Recuar a parte condicional parece bem para mim. Se for realmente longo - digamos, mais do que uma ou duas telas, provavelmente transferirei as partes condicionais para arquivos separados. Seu código será muito mais fácil de ler.

    
por John La Rooy 02.07.2010 / 03:58
fonte
0

Você terá que recuar seu código, de um jeito ou de outro. A maneira mais fácil é definir o código dentro das funções e chamá-las. Isso mantém os blocos if/else limpos.

def do_if_sunny():
    pass

def do_if_rainy():
    pass

if sunny:
    do_if_sunny()
else:
    do_if_rainy()

Como alternativa, você sempre pode usar sys.exit .

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

# Continue with non-sunny conditions
    
por Chris B. 02.07.2010 / 03:58
fonte
0

Eu seriamente seria com essa solução:

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

Sério, não. Mas isso funciona.

    
por bennedich 02.07.2010 / 04:21
fonte
0

Você pode usar a função para fazer isso:

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

locals().update(foo())

ou:

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

    return locals()

locals().update(foo())
    
por Tomasz Wysocki 02.07.2010 / 08:07
fonte