Variable scope and namespaces when using import *

Question

I'm trying to get a better understanding of python imports and namespaces. Take the example of a module testImport.py:

# testImport.py
var1 = 1

def fn1():
    return var1

if I import this like this:

from testImport import *

I can inspect var1

>>> var1
1

and fn1() returns

>>> fn1()
1

Now, I can change the value of var1:

>>> var1 = 2
>>> var1
2

but fn1() still returns 1:

>>> fn1()
1

This is different to if I import properly:

>>> import testImport as t
>>> t.var1 = 2
>>> t.fn1()
2

What's going on here? How does python 'remember' the original version of var1 in fn1 when using import *?

When you use import * you are copying the references to every variable. Each module will have it's own version. This is a major reason why you don't want to use import * — mousetail
– mousetail, Commented Jul 21, 2022 at 6:45

mousetail · Accepted Answer · 2022-07-21 06:51:47Z

How `from .. import ..` works

The statement

from module import value

can basically be rewritten as

import module
value = module.value
del module # Note: this just deletes the reference to `module`. Modules are never garbage collected.

Thus, the attribute value is a copy of module.value.

Function scopes and module namespaces

If you define a function, it will be placed in a scope:

def g():
    a = 2
    def f():
        print(a)
    return f
print(g()())

The function f is bound to the namespace inside g so it can access a and print 2.

It's the same with modules. Each module has it's own scope just like a function. So functions can access variables inside their own module. Variables in different scopes, like in your case var1 won't effect it.

Why the last example works

However, you can directly modify the scope like in your last example. If you use

import module

The variable module will actually refer to the scope of the contents of that module. So you can change variables there as you wish and they will effect functions and also other files that reference that module.

juanpa.arrivillaga · Accepted Answer · 2022-07-21 06:49:51Z

1

The modules are two seperate namespaces. You are creating a new set of variables when you do:

from testImport import *

When you import properly, and mutate the module namespace directly,

import testImport as t
t.var1 = 2

that modifies the globals the function sees because the module global namespace is the module object namespace. They are one and the same!

answered Jul 21, 2022 at 6:49

juanpa.arrivillaga

97.6k14 gold badges141 silver badges190 bronze badges

Collectives™ on Stack Overflow

Variable scope and namespaces when using import *

2 Answers 2

How `from .. import ..` works

Function scopes and module namespaces

Why the last example works

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

How from .. import .. works

Function scopes and module namespaces

Why the last example works

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related

How `from .. import ..` works