Stop evaluation within a module

Question

I've gotten used to writing functions that work like this:

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

I'm trying to figure out the equivalent syntax to use within a module. I want to do something like this:

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

I know I can write this as an if/else but it seems silly to indent the entire rest of my module.

I could move the rest of the code into a separate module and conditionally import it, but that seems painful.

Answer 1

Indenting the conditional part seems fine to me. If it is really long - say more than a screenful or two i'd probably move the conditional parts into separate files. Your code will be much easier to read.

Answer 2

You're going to have to indent your code, one way or the other. The easiest way is to define the code within functions, and call them. That keeps the if/else blocks tidy.

def do_if_sunny():
    pass

def do_if_rainy():
    pass

if sunny:
    do_if_sunny()
else:
    do_if_rainy()

Alternatively, you could always use sys.exit.

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

# Continue with non-sunny conditions

Answer 3

Separate files and extra indentation are probably reasonable given that this is a weird thing to be doing to begin with.

Depending on what you actually need, you might go ahead and process all of the module body and then delete anything that isn't appropriate at some point later.

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

if sunny:
  del foo
else:
  del bar

Answer 4

I would seriously go with this solution:

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

Seriously not. But it does work.

Answer 5

You can use function to do it:

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

locals().update(foo())

or:

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

    return locals()

locals().update(foo())