Sharing package data across files

John Pote johnpote at
Tue Jun 28 18:07:17 EDT 2016

On 28/06/2016 20:55, zackbaker at wrote:
> On Tuesday, June 28, 2016 at 1:17:23 PM UTC-6, scott... at wrote:
>> I'm trying to create a package in which the constituent files share some state.  Apparently, I don't understand scopes, namespaces, and package semantics as well as I thought I did.  Here's the directory structure for a simplified example:
>>     example/
>> defines a single variable:
>>      foo = 123
>> defines a function that reads and writes that variable:
>>      def bar():
>>          global foo
>>          foo += 1
>>          return foo
>> exposes both of those to the caller:
>>      from vars import foo
>>      from funcs import bar
>> Alas, it seems the bar function does not reside in the same global scope as the foo variable:
>>      >>> from example import foo, bar
>>      >>> foo
>>      123
>>      >>> bar()
>>      Traceback (most recent call last):
>>        File "<stdin>", line 1, in <module>
>>        File "example/", line 3, in bar
>>          foo += 1
>>      NameError: global name 'foo' is not defined
>> How can I make the example package work like one integrated module even though in reality it's split across multiple files?
>> Thanks,
>> -- Scott
> This problem of references is addressed in:
> >From Michael Ray Lovett:
> For example, if I do this in module a:
> from foo import bar
> bar = "oranges"
> No code outside of a will see bar as "oranges" because my setting of bar merely affected the name "bar" inside module a, it did not "reach into" the foo module object and update its "bar".
Correct me if I'm wrong but is not the above only true if bar has been 
assigned to and thus references an imutable object? In your example the 
string "oranges".
If bar has been assigned to a mutable object in module foo then every 
module importing via "from foo import bar" will all import the name bar 
pointing to the same mutable object. If this mutable obj is changed via 
bar in one module then every other module importing bar will also see 
the change.
In module foo:
     bar = ["apples","bananas","grapes"]

In module bar1
     from foo import bar
     bar[0] = "oranges"

In module barx at some later time
     from foo import bar
     print bar    #prints ["oranges","bananas","grapes"]

If my understanding here is correct then this would be a good case for 
never directly writing to a globle. Use getter()s and setter()s to make 
it obvious that any use of the setter() will be seen by all future calls 
to the getter().

Regards all,

More information about the Python-list mailing list