How can one create new scopes in python

Question

In many languages (and places) there is a nice practice of creating local scopes by creating a block like this.

void foo()
{
     ... Do some stuff ...

             


        

Answer 1

Like so, for arbitrary name t:

### at top of function / script / outer scope (maybe just big jupyter cell)
try: t
except NameError:
    class t
        pass
else:
    raise NameError('please `del t` first')

#### Cut here -- you only need 1x of the above -- example usage below ###

t.tempone = 5 # make new temporary variable that definitely doesn't bother anything else.
# block of calls here...
t.temptwo = 'bar' # another one...
del t.tempone # you can have overlapping scopes this way

# more calls
t.tempthree = t.temptwo; del t.temptwo # done with that now too
print(t.tempthree)
# etc, etc -- any number of variables will fit into t.


### At end of outer scope, to return `t` to being 'unused'
del t

All the above could be in a function def, or just anyplace outside defs along a script.

You can add or del new elements to an arbitrary-named class like that at any point. You really only need one of these -- then manage your 'temporary' namespace as you like.

The del t statement isn't necessary if this is in a function body, but if you include it, then you can copy/paste chunks of code far apart from each other and have them work how you expect (with different uses of 't' being entirely separate, each use starting with the that try: t... block, and ending with del t).

This way if t had been used as a variable already, you'll find out, and it doesn't clobber t so you can find out what it was.

This is less error prone then using a series of random=named functions just to call them once -- since it avoids having to deal with their names, or remembering to call them after their definition, especially if you have to reorder long code.

This basically does exactly what you want: Make a temporary place to put things you know for sure won't collide with anything else, and which you are responsible for cleaning up inside as you go.

Yes, it's ugly, and probably discouraged -- you will be directed to decompose your work into a set of smaller, more reusable functions.

Answer 2

def a():
    def b():
        pass
    b()

If I just want some extra indentation or am debugging, I'll use if True:

Answer 3

Python has exactly two scopes, local and global. Variables that are used in a function are in local scope no matter what indentation level they were created at. Calling a nested function will have the effect that you're looking for.

def foo():
  a = 1

  def bar():
    b = 2
    print a, b #will print "1 2"

  bar()

Still like everyone else, I have to ask you why you want to create a limited scope inside a function.

Answer 4

As mentioned in the other answers, there is no analogous functionality in Python to creating a new scope with a block, but when writing a script or a Jupyter Notebook, I often (ab)use classes to introduce new namespaces for similar effect. For example, in a notebook where you might have a model "Foo", "Bar" etc. and related variables you might want to create a new scope to avoid having to reuse names like

model = FooModel()
optimizer = FooOptimizer()
...
model = BarModel()
optimizer = BarOptimizer()

or suffix names like

model_foo = ...
optimizer_foo = ...

model_bar = ...
optimizer_bar= ...

Instead you can introduce new namespaces with

class Foo:
    model = ...
    optimizer = ...
    loss = ....

class Bar:
    model = ...
    optimizer = ...
    loss = ...

and then access the variables as

Foo.model
Bar.optimizer
...

I find that using namespaces this way to create new scopes makes code more readable and less error-prone.

Answer 5

Why do you want to create new scopes in python anyway?

The normal reason for doing it in other languages is variable scoping, but that doesn't happen in python.

if True:
    a = 10

print a

Answer 6

If you just want to create temp variables and let them be garbage collected right after using them, you can use

del varname

when you don't want them anymore.

If its just for aesthetics, you could use comments or extra newlines, no extra indentation, though.