From the Python FAQ, we can read :

In Python, variables that are only referenced inside a function are implicitly global

And from the Python Tutorial on defining functions, we can read :

The execution of a function introduces a new symbol table used for the local variables of the function. More precisely, all variable assignments in a function store the value in the local symbol table; whereas variable references first look in the local symbol table, then in the local symbol tables of enclosing functions, then in the global symbol table, and finally in the table of built-in names

Now I perfectly understand the tutorial statements, but then saying that variables that are only referenced inside a function are implicitly global seems pretty vague to me.

Why saying that they are implicitly global if we actually start looking at the local symbol tables, and then follow with the more 'general' ones? Is it just a way of saying that if you're only going to reference a variable within a function, you don't need to worry if it's either local or global?

Examples

(See further down for a summary)

What this means is that if a variable is never assigned to in a function's body, then it will be treated as global.

This explains why the following works (a is treated as global):

a = 1

def fn():
    print a  # This is "referencing a variable" == "reading its value"

# Prints: 1

---

However, if the variable is assigned to somewhere in the function's body, then it will be treated as local for the entire function body .

This includes statements that are found before it is assigned to (see the example below).

This explains why the following does not work. Here, a is treated as local,

a = 1

def fn():
    print a 
    a = 2  # <<< We're adding this

fn()

# Throws: UnboundLocalError: local variable 'a' referenced before assignment

---

You can have Python treat a variable as global with the statement global a. If you do so, then the variable will be treated as global, again for the entire function body.

a = 1

def fn():
   global a  # <<< We're adding this
   print a
   a = 2

fn()
print a

# Prints: 1
# Then, prints: 2 (a changed in the global scope too)

---

Summary

Unlike what you might expect, Python will not fall back to the global scope it if fails to find a in the local scope.

This means that a variable is either local or global for the entire function body: it can't be global and then become local.

Now, as to whether a variable is treated as local or global, Python follows the following rule. Variables are:

• Global if only referenced and never assigned to
• Global if the global statement is used
• Local if the variable is assigned to at least once (and global was not used)

---

Further notes

In fact, "implicitly global" doesn't really mean global. Here's a better way to think about it:

• "local" means "somewhere inside the function"
• "global" really means "somewhere outside the function"

So, if a variable is "implicitly global" (== "outside the function"), then its "enclosing scope" will be looked up first:

a = 25

def enclosing():
   a = 2
   def enclosed():
       print a
   enclosed()

enclosing()

# Prints 2, as supplied in the enclosing scope, instead of 25 (found in the global scope)

Now, as usual, global lets you reference the global scope.

a = 25

def enclosing():
   a = 2
   def enclosed():
       global a  # <<< We're adding this
       print a
   enclosed()

enclosing()

# Prints 25, as supplied in the global scope

Now, if you needed to assign to a in enclosed, and wanted a's value to be changed in enclosing's scope, but not in the global scope, then you would need nonlocal, which is new in Python 3. In Python 2, you can't.