Using global variables in a function

Question

How can I create or use a global variable in a function   If I create a global variable in one function  how can I use that global variable in another function  Do I need to store the global variable in a local variable of the function which needs its access

User · Accepted Answer

You can use a global variable within other functions by declaring it as global within each function that assigns a value to it:

globvar = 0

def set_globvar_to_one():
    global globvar    # Needed to modify global copy of globvar
    globvar = 1

def print_globvar():
    print(globvar)     # No need for global declaration to read value of globvar

set_globvar_to_one()
print_globvar()       # Prints 1

I imagine the reason for it is that, since global variables are so dangerous, Python wants to make sure that you really know that's what you're playing with by explicitly requiring the global keyword.

See other answers if you want to share a global variable across modules.

User · Answer

If I m understanding your situation correctly  what you re seeing is the result of how Python handles local  function  and global  module  namespaces   Say you ve got a module like this     sample py myGlobal   5  def func1        myGlobal   42  def func2        print myGlobal  func1   func2     You might expecting this to print 42  but instead it prints 5   As has already been mentioned  if you add a  global  declaration to func1    then func2   will print 42   def func1        global myGlobal     myGlobal   42   What s going on here is that Python assumes that any name that is assigned to  anywhere within a function  is local to that function unless explicitly told otherwise   If it is only reading from a name  and the name doesn t exist locally  it will try to look up the name in any containing scopes  e g  the module s global scope    When you assign 42 to the name myGlobal  therefore  Python creates a local variable that shadows the global variable of the same name   That local goes out of scope and is garbage-collected when func1   returns  meanwhile  func2   can never see anything other than the  unmodified  global name   Note that this namespace decision happens at compile time  not at runtime -- if you were to read the value of myGlobal inside func1   before you assign to it  you d get an UnboundLocalError  because Python has already decided that it must be a local variable but it has not had any value associated with it yet   But by using the  global  statement  you tell Python that it should look elsewhere for the name instead of assigning to it locally    I believe that this behavior originated largely through an optimization of local namespaces -- without this behavior   Python s VM would need to perform at least three name lookups each time a new name is assigned to inside a function  to ensure that the name didn t already exist at module builtin level   which would significantly slow down a very common operation

User · Answer

Writing to explicit elements of a global array does not apparently need the global declaration  though writing to it  wholesale  does have that requirement   import numpy as np  hostValue   3 14159 hostArray   np array  2   3    hostMatrix   np array   1 0  0 0    0 0  1 0     def func1        global hostValue      mandatory  else local      hostValue   2 0  def func2        global hostValue      mandatory  else UnboundLocalError      hostValue    1 0  def func3        global hostArray      mandatory  else local      hostArray   np array  14   15     def func4                 no need for globals     hostArray 0    123 4  def func5                 no need for globals     hostArray 1     1 0  def func6                 no need for globals     hostMatrix 1  1    12   def func7                 no need for globals     hostMatrix 0  0     0 33  func1   print  After func1    hostValue      hostValue func2   print  After func2    hostValue      hostValue func3   print  After func3    hostArray      hostArray func4   print  After func4    hostArray      hostArray func5   print  After func5    hostArray      hostArray func6   print  After func6    hostMatrix    n   hostMatrix func7   print  After func7    hostMatrix    n   hostMatrix

User · Answer

If I m understanding your situation correctly  what you re seeing is the result of how Python handles local  function  and global  module  namespaces   Say you ve got a module like this     sample py myGlobal   5  def func1        myGlobal   42  def func2        print myGlobal  func1   func2     You might expecting this to print 42  but instead it prints 5   As has already been mentioned  if you add a  global  declaration to func1    then func2   will print 42   def func1        global myGlobal     myGlobal   42   What s going on here is that Python assumes that any name that is assigned to  anywhere within a function  is local to that function unless explicitly told otherwise   If it is only reading from a name  and the name doesn t exist locally  it will try to look up the name in any containing scopes  e g  the module s global scope    When you assign 42 to the name myGlobal  therefore  Python creates a local variable that shadows the global variable of the same name   That local goes out of scope and is garbage-collected when func1   returns  meanwhile  func2   can never see anything other than the  unmodified  global name   Note that this namespace decision happens at compile time  not at runtime -- if you were to read the value of myGlobal inside func1   before you assign to it  you d get an UnboundLocalError  because Python has already decided that it must be a local variable but it has not had any value associated with it yet   But by using the  global  statement  you tell Python that it should look elsewhere for the name instead of assigning to it locally    I believe that this behavior originated largely through an optimization of local namespaces -- without this behavior   Python s VM would need to perform at least three name lookups each time a new name is assigned to inside a function  to ensure that the name didn t already exist at module builtin level   which would significantly slow down a very common operation

User · Answer

There are 2 ways to declare a variable as global  1  assign variable inside functions and use global line def declare a global variable        global global variable 1     global variable 1   1    Note to use the function to global variables declare a global variable     2  assign variable outside functions  global variable 2   2  Now we can use these declared global variables in the other functions  def declare a global variable        global global variable 1     global variable 1   1    Note to use the function to global variables declare a global variable    global variable 2   2  def print variables        print global variable 1      print global variable 2  print variables     prints 1  amp  2  Note 1  If you want to change a global variable inside another function like update variables   you should use global line in that function before assigning the variable  global variable 1   1 global variable 2   2  def update variables        global global variable 1     global variable 1   11     global variable 2   12   will update just locally for this function  update variables   print global variable 1    prints 11 print global variable 2    prints 2  Note 2  There is a exception for note 1 for list and dictionary variables while not using global line inside a function    declaring some global variables variable    peter  list variable 1     a   b   list variable 2     c   d    def update global variables         quot  quot  quot without using global line quot  quot  quot      variable    PETER    won t update in global scope     list variable 1     A   B     won t update in global scope     list variable 2 0     C    updated in global scope surprisingly this way     list variable 2 1     D    updated in global scope surprisingly this way  update global variables    print  variable is   s  variable    prints peter print  list variable 1 is   s  list variable 1    prints   a    b   print  list variable 2 is   s  list variable 2    prints   C    D

User · Answer

Reference the class namespace where you want the change to show up     In this example  runner is using max from the file config  I want my test to change the value of max when runner is using it   main config py  max   15000   main runner py  from main import config def check threads        return max  lt  thread count    tests runner test py  from main import runner                   lt ----- 1  add file from main runner import check threads class RunnerTest unittest      def test threads self          runner max   0                     lt ----- 2  set global         check threads

User · Answer

In case you have a local variable with the same name  you might want to use the globals   function   globals    your global var     42

User · Answer

If I create a global variable in one function  how can I use that variable in another function    We can create a global with the following function   def create global variable        global global variable   must declare it to be a global first       modifications are thus reflected on the module s global scope     global variable    Foo     Writing a function does not actually run its code  So we call the create global variable function    gt  gt  gt  create global variable     Using globals without modification  You can just use it  so long as you don t expect to change which object it points to    For example    def use global variable        return global variable           and now we can use the global variable    gt  gt  gt  use global variable    Foo       Modification of the global variable from inside a function  To point the global variable at a different object  you are required to use the global keyword again   def change global variable        global global variable     global variable    Bar    Note that after writing this function  the code actually changing it has still not run    gt  gt  gt  use global variable    Foo       So after calling the function    gt  gt  gt  change global variable     we can see that the global variable has been changed  The global variable name now points to  Bar     gt  gt  gt  use global variable    Bar       Note that  global  in Python is not truly global - it s only global to the module level  So it is only available to functions written in the modules in which it is global  Functions remember the module in which they are written  so when they are exported into other modules  they still look in the module in which they were created to find global variables   Local variables with the same name  If you create a local variable with the same name  it will overshadow a global variable   def use local with same name as global          bad name for a local variable  though      global variable    Baz       return global variable           gt  gt  gt  use local with same name as global    Baz       But using that misnamed local variable does not change the global variable    gt  gt  gt  use global variable    Bar       Note that you should avoid using the local variables with the same names as globals unless you know precisely what you are doing and have a very good reason to do so  I have not yet encountered such a reason   We get the same behavior in classes  A follow on comment asks      what to do if I want to create a global variable inside a function inside a class and want to use that variable inside another function inside another class    Here I demonstrate we get the same behavior in methods as we do in regular functions   class Foo      def foo self           global global variable         global variable    Foo   class Bar      def bar self           return global variable          Foo   foo     And now    gt  gt  gt  Bar   bar    Foo       But I would suggest instead of using global variables you use class attributes  to avoid cluttering the module namespace  Also note we don t use self arguments here - these could be class methods  handy if mutating the class attribute from the usual cls argument  or static methods  no self or cls

User · Answer

Globals are fine - Except with Multiprocessing  Globals in connection with multiprocessing on different platforms envrionments  as Windows Mac OS on the one side and Linux on the other are troublesome   I will show you this with a simple example pointing out a problem which I run into some time ago    If you want to understand  why things are different on Windows MacOs and Linux you  need to know that  the default mechanism to start a new process on       Windows MacOs is  spawn  Linux is  fork    They are different in Memory allocation an initialisation      but I don t go into this here     Let s have a look at the problem example      import multiprocessing  counter   0  def do task id       global counter     counter   1     print f task  task id   counter    counter     if   name         main          pool   multiprocessing Pool processes 4      task ids   list range 4       pool map do  task ids    Windows  If you run this on Windows  And I suppose on MacOS too   you get the following output      task 0  counter   1 task 1  counter   2 task 2  counter   3 task 3  counter   4   Linux  If you run this on Linux  you get the following instead    task 0  counter   1 task 1  counter   1 task 2  counter   1 task 3  counter   1

User · Answer

If you want to refer to a global variable in a function  you can use the global keyword to declare which variables are global  You don t have to use it in all cases  as someone here incorrectly claims  - if the name referenced in an expression cannot be found in local scope or scopes in the functions in which this function is defined  it is looked up among global variables   However  if you assign to a new variable not declared as global in the function  it is implicitly declared as local  and it can overshadow any existing global variable with the same name   Also  global variables are useful  contrary to some OOP zealots who claim otherwise - especially for smaller scripts  where OOP is overkill

User · Answer

You re not actually storing the global in a local variable  just creating a local reference to the same object that your original global reference refers to  Remember that pretty much everything in Python is a name referring to an object  and nothing gets copied in usual operation   If you didn t have to explicitly specify when an identifier was to refer to a predefined global  then you d presumably have to explicitly specify when an identifier is a new local variable instead  for example  with something like the  var  command seen in JavaScript   Since local variables are more common than global variables in any serious and non-trivial system  Python s system makes more sense in most cases   You could have a language which attempted to guess  using a global variable if it existed or creating a local variable if it didn t  However  that would be very error-prone  For example  importing another module could inadvertently introduce a global variable by that name  changing the behaviour of your program

User · Answer

If I create a global variable in one function  how can I use that variable in another function    We can create a global with the following function   def create global variable        global global variable   must declare it to be a global first       modifications are thus reflected on the module s global scope     global variable    Foo     Writing a function does not actually run its code  So we call the create global variable function    gt  gt  gt  create global variable     Using globals without modification  You can just use it  so long as you don t expect to change which object it points to    For example    def use global variable        return global variable           and now we can use the global variable    gt  gt  gt  use global variable    Foo       Modification of the global variable from inside a function  To point the global variable at a different object  you are required to use the global keyword again   def change global variable        global global variable     global variable    Bar    Note that after writing this function  the code actually changing it has still not run    gt  gt  gt  use global variable    Foo       So after calling the function    gt  gt  gt  change global variable     we can see that the global variable has been changed  The global variable name now points to  Bar     gt  gt  gt  use global variable    Bar       Note that  global  in Python is not truly global - it s only global to the module level  So it is only available to functions written in the modules in which it is global  Functions remember the module in which they are written  so when they are exported into other modules  they still look in the module in which they were created to find global variables   Local variables with the same name  If you create a local variable with the same name  it will overshadow a global variable   def use local with same name as global          bad name for a local variable  though      global variable    Baz       return global variable           gt  gt  gt  use local with same name as global    Baz       But using that misnamed local variable does not change the global variable    gt  gt  gt  use global variable    Bar       Note that you should avoid using the local variables with the same names as globals unless you know precisely what you are doing and have a very good reason to do so  I have not yet encountered such a reason   We get the same behavior in classes  A follow on comment asks      what to do if I want to create a global variable inside a function inside a class and want to use that variable inside another function inside another class    Here I demonstrate we get the same behavior in methods as we do in regular functions   class Foo      def foo self           global global variable         global variable    Foo   class Bar      def bar self           return global variable          Foo   foo     And now    gt  gt  gt  Bar   bar    Foo       But I would suggest instead of using global variables you use class attributes  to avoid cluttering the module namespace  Also note we don t use self arguments here - these could be class methods  handy if mutating the class attribute from the usual cls argument  or static methods  no self or cls

User · Answer

In addition to already existing answers and to make this more confusing      In Python  variables that are only referenced inside a function are   implicitly global  If a variable is assigned a new value anywhere   within the function   s body  it   s assumed to be a local  If a variable   is ever assigned a new value inside the function  the variable is   implicitly local  and you need to explicitly declare it as    global          Though a bit surprising at first  a moment   s consideration explains   this  On one hand  requiring global for assigned variables provides a   bar against unintended side-effects  On the other hand  if global was   required for all global references  you   d be using global all the   time  You   d have to declare as global every reference to a built-in   function or to a component of an imported module  This clutter would   defeat the usefulness of the global declaration for identifying   side-effects    Source  What are the rules for local and global variables in Python

User · Answer

In addition to already existing answers and to make this more confusing      In Python  variables that are only referenced inside a function are   implicitly global  If a variable is assigned a new value anywhere   within the function   s body  it   s assumed to be a local  If a variable   is ever assigned a new value inside the function  the variable is   implicitly local  and you need to explicitly declare it as    global          Though a bit surprising at first  a moment   s consideration explains   this  On one hand  requiring global for assigned variables provides a   bar against unintended side-effects  On the other hand  if global was   required for all global references  you   d be using global all the   time  You   d have to declare as global every reference to a built-in   function or to a component of an imported module  This clutter would   defeat the usefulness of the global declaration for identifying   side-effects    Source  What are the rules for local and global variables in Python

User · Answer

Globals are fine - Except with Multiprocessing  Globals in connection with multiprocessing on different platforms envrionments  as Windows Mac OS on the one side and Linux on the other are troublesome   I will show you this with a simple example pointing out a problem which I run into some time ago    If you want to understand  why things are different on Windows MacOs and Linux you  need to know that  the default mechanism to start a new process on       Windows MacOs is  spawn  Linux is  fork    They are different in Memory allocation an initialisation      but I don t go into this here     Let s have a look at the problem example      import multiprocessing  counter   0  def do task id       global counter     counter   1     print f task  task id   counter    counter     if   name         main          pool   multiprocessing Pool processes 4      task ids   list range 4       pool map do  task ids    Windows  If you run this on Windows  And I suppose on MacOS too   you get the following output      task 0  counter   1 task 1  counter   2 task 2  counter   3 task 3  counter   4   Linux  If you run this on Linux  you get the following instead    task 0  counter   1 task 1  counter   1 task 2  counter   1 task 3  counter   1

User · Answer

You re not actually storing the global in a local variable  just creating a local reference to the same object that your original global reference refers to  Remember that pretty much everything in Python is a name referring to an object  and nothing gets copied in usual operation   If you didn t have to explicitly specify when an identifier was to refer to a predefined global  then you d presumably have to explicitly specify when an identifier is a new local variable instead  for example  with something like the  var  command seen in JavaScript   Since local variables are more common than global variables in any serious and non-trivial system  Python s system makes more sense in most cases   You could have a language which attempted to guess  using a global variable if it existed or creating a local variable if it didn t  However  that would be very error-prone  For example  importing another module could inadvertently introduce a global variable by that name  changing the behaviour of your program

User · Answer

You may want to explore the notion of namespaces  In Python  the module is the natural place for global data   Each module has its own private symbol table  which is used as the global symbol table by all functions defined in the module  Thus  the author of a module can use global variables in the module without worrying about accidental clashes with a user   s global variables  On the other hand  if you know what you are doing you can touch a module   s global variables with the same notation used to refer to its functions  modname itemname   A specific use of global-in-a-module is described here - How do I share global variables across modules   and for completeness the contents are shared here   The canonical way to share information across modules within a single program is to create a special configuration module  often called config or cfg   Just import the configuration module in all modules of your application  the module then becomes available as a global name  Because there is only one instance of each module  any changes made to the module object get reflected everywhere  For example    File  config py   x   0     Default value of the  x  configuration setting    File  mod py  import config config x   1   File  main py  import config import mod print config x

User · Answer

Try this  def x1        global x     x    1     print  x1     x   def x2        global x     x   x 1     print  x2     x   x   5 print  x      x  x1   x2      Output    x    5   x1   6   x2   7

User · Answer

Python uses a simple heuristic to decide which scope it should load a variable from  between local and global   If a variable name appears on the left hand side of an assignment  but is not declared global  it is assumed to be local   If it does not appear on the left hand side of an assignment  it is assumed to be global      gt  gt  gt  import dis  gt  gt  gt  def foo            global bar         baz   5         print bar         print baz         print quux       gt  gt  gt  dis disassemble foo func code    3           0 LOAD CONST               1  5                3 STORE FAST               0  baz     4           6 LOAD GLOBAL              0  bar                9 PRINT ITEM                        10 PRINT NEWLINE           5          11 LOAD FAST                0  baz               14 PRINT ITEM                        15 PRINT NEWLINE           6          16 LOAD GLOBAL              1  quux               19 PRINT ITEM                        20 PRINT NEWLINE                     21 LOAD CONST               0  None               24 RETURN VALUE          gt  gt  gt     See how baz  which appears on the left side of an assignment in foo    is the only LOAD FAST variable

User · Answer

You need to reference the global variable in every function you want to use   As follows   var    test   def printGlobalText        global var  wWe are telling to explicitly use the global version     var    global from printGlobalText fun       print  var from printGlobalText      var  def printLocalText         We are NOT telling to explicitly use the global version  so we are creating a local variable     var    local version from printLocalText fun      print  var from printLocalText      var  printGlobalText   printLocalText       Output Result  var from printGlobalText  global from printGlobalText fun  var from printLocalText  local version from printLocalText  Finished in 0 1s

User · Answer

In case you have a local variable with the same name  you might want to use the globals   function   globals    your global var     42

User · Answer

Reference the class namespace where you want the change to show up     In this example  runner is using max from the file config  I want my test to change the value of max when runner is using it   main config py  max   15000   main runner py  from main import config def check threads        return max  lt  thread count    tests runner test py  from main import runner                   lt ----- 1  add file from main runner import check threads class RunnerTest unittest      def test threads self          runner max   0                     lt ----- 2  set global         check threads

User · Answer

I m adding this as I haven t seen it in any of the other answers and it might be useful for someone struggling with something similar  The globals   function returns a mutable global symbol dictionary where you can  magically  make data available for the rest of your code   For example   from pickle import load def loaditem name       with open r C  pickle file location       dat  format name    rb   as openfile          globals   name    load openfile      return True   and   from pickle import dump def dumpfile name       with open name   dat    wb   as outfile          dump globals   name   outfile      return True   Will just let you dump load variables out of and into the global namespace  Super convenient  no muss  no fuss  Pretty sure it s Python 3 only

User · Answer

Following on and as an add on  use a file to contain all global variables all declared locally and then import as   File initval py   Stocksin   300 Prices        File getstocks py   import initval as iv  def getmystocks         iv Stocksin   getstockcount     def getmycharts        for ic in range iv Stocksin

User · Answer

With parallel execution  global variables can cause unexpected results if you don t understand what is happening  Here is an example of using a global variable within multiprocessing  We can clearly see that each process works with its own copy of the variable   import multiprocessing import os import random import sys import time  def worker new value       old value   get value       set value random randint 1  99       print  pid   pid                old value   old value 2                new value   new value 2                get value   get value 2    format            pid str os getpid               old value old value            new value new value            get value get value      def get value        global global variable     return global variable  def set value new value       global global variable     global variable   new value  global variable   -1  print  before set value    get value       s     get value    set value new value -2  print  after  set value    get value       s     get value     processPool   multiprocessing Pool processes 5  processPool map func worker  iterable range 15     Output   before set value    get value      -1  after  set value    get value      -2  pid  53970  old value  -2  new value   0  get value  23  pid  53971  old value  -2  new value   1  get value  42  pid  53970  old value  23  new value   4  get value  50  pid  53970  old value  50  new value   6  get value  14  pid  53971  old value  42  new value   5  get value  31  pid  53972  old value  -2  new value   2  get value  44  pid  53973  old value  -2  new value   3  get value  94  pid  53970  old value  14  new value   7  get value  21  pid  53971  old value  31  new value   8  get value  34  pid  53972  old value  44  new value   9  get value  59  pid  53973  old value  94  new value  10  get value  87  pid  53970  old value  21  new value  11  get value  21  pid  53971  old value  34  new value  12  get value  82  pid  53972  old value  59  new value  13  get value   4  pid  53973  old value  87  new value  14  get value  70

User · Answer

Use global keyword   Creating global variable glob var 0  def use         Accessing global variable     global glob var        Changing value of global variable     glob var 2  def show         Showing value of global variable     print glob var   if   name       main         use       show

User · Answer

What you are saying is to use the method like this  globvar   5  def f        var   globvar     print var   f      Prints 5  But the better way is to use the global variable like this  globvar   5 def f        global globvar     print globvar  f      prints 5  Both give the same output

User · Answer

You re not actually storing the global in a local variable  just creating a local reference to the same object that your original global reference refers to  Remember that pretty much everything in Python is a name referring to an object  and nothing gets copied in usual operation   If you didn t have to explicitly specify when an identifier was to refer to a predefined global  then you d presumably have to explicitly specify when an identifier is a new local variable instead  for example  with something like the  var  command seen in JavaScript   Since local variables are more common than global variables in any serious and non-trivial system  Python s system makes more sense in most cases   You could have a language which attempted to guess  using a global variable if it existed or creating a local variable if it didn t  However  that would be very error-prone  For example  importing another module could inadvertently introduce a global variable by that name  changing the behaviour of your program

User · Answer

Use global keyword   Creating global variable glob var 0  def use         Accessing global variable     global glob var        Changing value of global variable     glob var 2  def show         Showing value of global variable     print glob var   if   name       main         use       show

User · Answer

If I m understanding your situation correctly  what you re seeing is the result of how Python handles local  function  and global  module  namespaces   Say you ve got a module like this     sample py myGlobal   5  def func1        myGlobal   42  def func2        print myGlobal  func1   func2     You might expecting this to print 42  but instead it prints 5   As has already been mentioned  if you add a  global  declaration to func1    then func2   will print 42   def func1        global myGlobal     myGlobal   42   What s going on here is that Python assumes that any name that is assigned to  anywhere within a function  is local to that function unless explicitly told otherwise   If it is only reading from a name  and the name doesn t exist locally  it will try to look up the name in any containing scopes  e g  the module s global scope    When you assign 42 to the name myGlobal  therefore  Python creates a local variable that shadows the global variable of the same name   That local goes out of scope and is garbage-collected when func1   returns  meanwhile  func2   can never see anything other than the  unmodified  global name   Note that this namespace decision happens at compile time  not at runtime -- if you were to read the value of myGlobal inside func1   before you assign to it  you d get an UnboundLocalError  because Python has already decided that it must be a local variable but it has not had any value associated with it yet   But by using the  global  statement  you tell Python that it should look elsewhere for the name instead of assigning to it locally    I believe that this behavior originated largely through an optimization of local namespaces -- without this behavior   Python s VM would need to perform at least three name lookups each time a new name is assigned to inside a function  to ensure that the name didn t already exist at module builtin level   which would significantly slow down a very common operation

User · Answer

As it turns out the answer is always simple   Here is a small sample module with a simple way to show it in a main definition   def five enterAnumber sumation       global helper     helper    enterAnumber   sumation  def isTheNumber        return helper   Here is how to show it in a main definition   import TestPy  def main        atest    TestPy     atest five 5 8      print atest isTheNumber     if   name         main         main     This simple code works just like that  and it will execute  I hope it helps

User · Answer

You re not actually storing the global in a local variable  just creating a local reference to the same object that your original global reference refers to  Remember that pretty much everything in Python is a name referring to an object  and nothing gets copied in usual operation   If you didn t have to explicitly specify when an identifier was to refer to a predefined global  then you d presumably have to explicitly specify when an identifier is a new local variable instead  for example  with something like the  var  command seen in JavaScript   Since local variables are more common than global variables in any serious and non-trivial system  Python s system makes more sense in most cases   You could have a language which attempted to guess  using a global variable if it existed or creating a local variable if it didn t  However  that would be very error-prone  For example  importing another module could inadvertently introduce a global variable by that name  changing the behaviour of your program

User · Answer

Try this  def x1        global x     x    1     print  x1     x   def x2        global x     x   x 1     print  x2     x   x   5 print  x      x  x1   x2      Output    x    5   x1   6   x2   7

User · Answer

You may want to explore the notion of namespaces  In Python  the module is the natural place for global data   Each module has its own private symbol table  which is used as the global symbol table by all functions defined in the module  Thus  the author of a module can use global variables in the module without worrying about accidental clashes with a user   s global variables  On the other hand  if you know what you are doing you can touch a module   s global variables with the same notation used to refer to its functions  modname itemname   A specific use of global-in-a-module is described here - How do I share global variables across modules   and for completeness the contents are shared here   The canonical way to share information across modules within a single program is to create a special configuration module  often called config or cfg   Just import the configuration module in all modules of your application  the module then becomes available as a global name  Because there is only one instance of each module  any changes made to the module object get reflected everywhere  For example    File  config py   x   0     Default value of the  x  configuration setting    File  mod py  import config config x   1   File  main py  import config import mod print config x

User · Answer

I m adding this as I haven t seen it in any of the other answers and it might be useful for someone struggling with something similar  The globals   function returns a mutable global symbol dictionary where you can  magically  make data available for the rest of your code   For example   from pickle import load def loaditem name       with open r C  pickle file location       dat  format name    rb   as openfile          globals   name    load openfile      return True   and   from pickle import dump def dumpfile name       with open name   dat    wb   as outfile          dump globals   name   outfile      return True   Will just let you dump load variables out of and into the global namespace  Super convenient  no muss  no fuss  Pretty sure it s Python 3 only

User · Answer

If I m understanding your situation correctly  what you re seeing is the result of how Python handles local  function  and global  module  namespaces   Say you ve got a module like this     sample py myGlobal   5  def func1        myGlobal   42  def func2        print myGlobal  func1   func2     You might expecting this to print 42  but instead it prints 5   As has already been mentioned  if you add a  global  declaration to func1    then func2   will print 42   def func1        global myGlobal     myGlobal   42   What s going on here is that Python assumes that any name that is assigned to  anywhere within a function  is local to that function unless explicitly told otherwise   If it is only reading from a name  and the name doesn t exist locally  it will try to look up the name in any containing scopes  e g  the module s global scope    When you assign 42 to the name myGlobal  therefore  Python creates a local variable that shadows the global variable of the same name   That local goes out of scope and is garbage-collected when func1   returns  meanwhile  func2   can never see anything other than the  unmodified  global name   Note that this namespace decision happens at compile time  not at runtime -- if you were to read the value of myGlobal inside func1   before you assign to it  you d get an UnboundLocalError  because Python has already decided that it must be a local variable but it has not had any value associated with it yet   But by using the  global  statement  you tell Python that it should look elsewhere for the name instead of assigning to it locally    I believe that this behavior originated largely through an optimization of local namespaces -- without this behavior   Python s VM would need to perform at least three name lookups each time a new name is assigned to inside a function  to ensure that the name didn t already exist at module builtin level   which would significantly slow down a very common operation

User · Answer

Python uses a simple heuristic to decide which scope it should load a variable from  between local and global   If a variable name appears on the left hand side of an assignment  but is not declared global  it is assumed to be local   If it does not appear on the left hand side of an assignment  it is assumed to be global      gt  gt  gt  import dis  gt  gt  gt  def foo            global bar         baz   5         print bar         print baz         print quux       gt  gt  gt  dis disassemble foo func code    3           0 LOAD CONST               1  5                3 STORE FAST               0  baz     4           6 LOAD GLOBAL              0  bar                9 PRINT ITEM                        10 PRINT NEWLINE           5          11 LOAD FAST                0  baz               14 PRINT ITEM                        15 PRINT NEWLINE           6          16 LOAD GLOBAL              1  quux               19 PRINT ITEM                        20 PRINT NEWLINE                     21 LOAD CONST               0  None               24 RETURN VALUE          gt  gt  gt     See how baz  which appears on the left side of an assignment in foo    is the only LOAD FAST variable

User · Answer

If you want to refer to a global variable in a function  you can use the global keyword to declare which variables are global  You don t have to use it in all cases  as someone here incorrectly claims  - if the name referenced in an expression cannot be found in local scope or scopes in the functions in which this function is defined  it is looked up among global variables   However  if you assign to a new variable not declared as global in the function  it is implicitly declared as local  and it can overshadow any existing global variable with the same name   Also  global variables are useful  contrary to some OOP zealots who claim otherwise - especially for smaller scripts  where OOP is overkill

User · Answer

You need to reference the global variable in every function you want to use   As follows   var    test   def printGlobalText        global var  wWe are telling to explicitly use the global version     var    global from printGlobalText fun       print  var from printGlobalText      var  def printLocalText         We are NOT telling to explicitly use the global version  so we are creating a local variable     var    local version from printLocalText fun      print  var from printLocalText      var  printGlobalText   printLocalText       Output Result  var from printGlobalText  global from printGlobalText fun  var from printLocalText  local version from printLocalText  Finished in 0 1s

User · Answer

As it turns out the answer is always simple   Here is a small sample module with a simple way to show it in a main definition   def five enterAnumber sumation       global helper     helper    enterAnumber   sumation  def isTheNumber        return helper   Here is how to show it in a main definition   import TestPy  def main        atest    TestPy     atest five 5 8      print atest isTheNumber     if   name         main         main     This simple code works just like that  and it will execute  I hope it helps

User · Answer

You may want to explore the notion of namespaces  In Python  the module is the natural place for global data   Each module has its own private symbol table  which is used as the global symbol table by all functions defined in the module  Thus  the author of a module can use global variables in the module without worrying about accidental clashes with a user   s global variables  On the other hand  if you know what you are doing you can touch a module   s global variables with the same notation used to refer to its functions  modname itemname   A specific use of global-in-a-module is described here - How do I share global variables across modules   and for completeness the contents are shared here   The canonical way to share information across modules within a single program is to create a special configuration module  often called config or cfg   Just import the configuration module in all modules of your application  the module then becomes available as a global name  Because there is only one instance of each module  any changes made to the module object get reflected everywhere  For example    File  config py   x   0     Default value of the  x  configuration setting    File  mod py  import config config x   1   File  main py  import config import mod print config x

User · Answer

If you want to refer to a global variable in a function  you can use the global keyword to declare which variables are global  You don t have to use it in all cases  as someone here incorrectly claims  - if the name referenced in an expression cannot be found in local scope or scopes in the functions in which this function is defined  it is looked up among global variables   However  if you assign to a new variable not declared as global in the function  it is implicitly declared as local  and it can overshadow any existing global variable with the same name   Also  global variables are useful  contrary to some OOP zealots who claim otherwise - especially for smaller scripts  where OOP is overkill

User · Answer

With parallel execution  global variables can cause unexpected results if you don t understand what is happening  Here is an example of using a global variable within multiprocessing  We can clearly see that each process works with its own copy of the variable   import multiprocessing import os import random import sys import time  def worker new value       old value   get value       set value random randint 1  99       print  pid   pid                old value   old value 2                new value   new value 2                get value   get value 2    format            pid str os getpid               old value old value            new value new value            get value get value      def get value        global global variable     return global variable  def set value new value       global global variable     global variable   new value  global variable   -1  print  before set value    get value       s     get value    set value new value -2  print  after  set value    get value       s     get value     processPool   multiprocessing Pool processes 5  processPool map func worker  iterable range 15     Output   before set value    get value      -1  after  set value    get value      -2  pid  53970  old value  -2  new value   0  get value  23  pid  53971  old value  -2  new value   1  get value  42  pid  53970  old value  23  new value   4  get value  50  pid  53970  old value  50  new value   6  get value  14  pid  53971  old value  42  new value   5  get value  31  pid  53972  old value  -2  new value   2  get value  44  pid  53973  old value  -2  new value   3  get value  94  pid  53970  old value  14  new value   7  get value  21  pid  53971  old value  31  new value   8  get value  34  pid  53972  old value  44  new value   9  get value  59  pid  53973  old value  94  new value  10  get value  87  pid  53970  old value  21  new value  11  get value  21  pid  53971  old value  34  new value  12  get value  82  pid  53972  old value  59  new value  13  get value   4  pid  53973  old value  87  new value  14  get value  70

User · Answer

Following on and as an add on  use a file to contain all global variables all declared locally and then import as   File initval py   Stocksin   300 Prices        File getstocks py   import initval as iv  def getmystocks         iv Stocksin   getstockcount     def getmycharts        for ic in range iv Stocksin

User · Answer

What you are saying is to use the method like this  globvar   5  def f        var   globvar     print var   f      Prints 5  But the better way is to use the global variable like this  globvar   5 def f        global globvar     print globvar  f      prints 5  Both give the same output

User · Answer

If you want to refer to a global variable in a function  you can use the global keyword to declare which variables are global  You don t have to use it in all cases  as someone here incorrectly claims  - if the name referenced in an expression cannot be found in local scope or scopes in the functions in which this function is defined  it is looked up among global variables   However  if you assign to a new variable not declared as global in the function  it is implicitly declared as local  and it can overshadow any existing global variable with the same name   Also  global variables are useful  contrary to some OOP zealots who claim otherwise - especially for smaller scripts  where OOP is overkill

User · Answer

There are 2 ways to declare a variable as global  1  assign variable inside functions and use global line def declare a global variable        global global variable 1     global variable 1   1    Note to use the function to global variables declare a global variable     2  assign variable outside functions  global variable 2   2  Now we can use these declared global variables in the other functions  def declare a global variable        global global variable 1     global variable 1   1    Note to use the function to global variables declare a global variable    global variable 2   2  def print variables        print global variable 1      print global variable 2  print variables     prints 1  amp  2  Note 1  If you want to change a global variable inside another function like update variables   you should use global line in that function before assigning the variable  global variable 1   1 global variable 2   2  def update variables        global global variable 1     global variable 1   11     global variable 2   12   will update just locally for this function  update variables   print global variable 1    prints 11 print global variable 2    prints 2  Note 2  There is a exception for note 1 for list and dictionary variables while not using global line inside a function    declaring some global variables variable    peter  list variable 1     a   b   list variable 2     c   d    def update global variables         quot  quot  quot without using global line quot  quot  quot      variable    PETER    won t update in global scope     list variable 1     A   B     won t update in global scope     list variable 2 0     C    updated in global scope surprisingly this way     list variable 2 1     D    updated in global scope surprisingly this way  update global variables    print  variable is   s  variable    prints peter print  list variable 1 is   s  list variable 1    prints   a    b   print  list variable 2 is   s  list variable 2    prints   C    D

User · Answer

Writing to explicit elements of a global array does not apparently need the global declaration  though writing to it  wholesale  does have that requirement   import numpy as np  hostValue   3 14159 hostArray   np array  2   3    hostMatrix   np array   1 0  0 0    0 0  1 0     def func1        global hostValue      mandatory  else local      hostValue   2 0  def func2        global hostValue      mandatory  else UnboundLocalError      hostValue    1 0  def func3        global hostArray      mandatory  else local      hostArray   np array  14   15     def func4                 no need for globals     hostArray 0    123 4  def func5                 no need for globals     hostArray 1     1 0  def func6                 no need for globals     hostMatrix 1  1    12   def func7                 no need for globals     hostMatrix 0  0     0 33  func1   print  After func1    hostValue      hostValue func2   print  After func2    hostValue      hostValue func3   print  After func3    hostArray      hostArray func4   print  After func4    hostArray      hostArray func5   print  After func5    hostArray      hostArray func6   print  After func6    hostMatrix    n   hostMatrix func7   print  After func7    hostMatrix    n   hostMatrix

User · Answer

You may want to explore the notion of namespaces  In Python  the module is the natural place for global data   Each module has its own private symbol table  which is used as the global symbol table by all functions defined in the module  Thus  the author of a module can use global variables in the module without worrying about accidental clashes with a user   s global variables  On the other hand  if you know what you are doing you can touch a module   s global variables with the same notation used to refer to its functions  modname itemname   A specific use of global-in-a-module is described here - How do I share global variables across modules   and for completeness the contents are shared here   The canonical way to share information across modules within a single program is to create a special configuration module  often called config or cfg   Just import the configuration module in all modules of your application  the module then becomes available as a global name  Because there is only one instance of each module  any changes made to the module object get reflected everywhere  For example    File  config py   x   0     Default value of the  x  configuration setting    File  mod py  import config config x   1   File  main py  import config import mod print config x

[python] Using global variables in a function

Examples related to python

Examples related to global-variables

Examples related to scope