Scope of variable confusion

[Mark17]

Hi all,

Here's a simple code:

global check

check = 0

def sample_fcn():
  check += 1

sample_fcn()

print(check)

The result is UnboundLocalError: local variable 'check' referenced before assignment .

I'm guessing when the function runs and tries to add 1 to check, the program doesn't know what it's adding 1 to? Why didn't the first line make it available to the function, though?

Even if I add return check to the end of the function (to make sure the function actually returns something), I get the same exception.

And in case it matters, the reason I didn't put check = 0 inside the function is because I wanted to count the number of times the program runs through that function.

[deanhystad]

The global keyword tells Python to look for the following symbols in the global scope instead of the local scope. Placing "global check" at the top of the file does not do anything at all because you are currently in the global scope.

global only makes sense inside a function. Here the "global check" tells Python that the "check" inside this function is the global variable "check".

def sample_fcn()
    global check  # The global has to be inside the function
    check += 1

[Mark17]

The global keyword tells Python to look for the following symbols in the global scope instead of the local scope. Placing "global check" at the top of the file does not do anything at all because you are currently in the global scope.

global only makes sense inside a function. Here the "global check" tells Python that the "check" inside this function is the global variable "check".

def sample_fcn()
    global check  # The global has to be inside the function
    check += 1

Thanks so much!

[ThomasL]

Using the global keyword is highly discouraged in Python.
If you think you must use it, then you are doing something wrong.

[Mark17]

Using the global keyword is highly discouraged in Python.
If you think you must use it, then you are doing something wrong.

Why? What would be another way to accomplish the same thing?

[deanhystad]

Global variables are not bad. Sometimes they are the right solution to a problem. But using lots of global variables can make you code difficult to work with.

The problem with a global variable is that the variable is defined in one place and used somewhere else that may be nowhere near the definition. If you want to know everything that modifies your global variable you need to search for all occurrences of the name and then verify that the each of those is actually referencing the global and not some local variable that has the same name. And since the variable is global it is visible to anyone who imports your module. A global variable can be changed by code you did not write.

Instead of a global variable you can pass a value as an argument and return the modified value.

def sample_fcn(check):
    return check + 1

You can make a function variable

def sample_fcn():
    sample_fcn.check_count += 1

sample_fcn.check_count = 0
sample_fcn()
print(sample_fcn.check_count)

You can make a class.

class Sample():
    def __init__(self):
        self.check = 0

    def fcn(self):
        self.check += 1

x = Sample()
x.fcn()
print(x.check)

[Mark17]

I'll just ask one more question and then try to let this simmer. What you said about using global keyword to "look for variable in the global scope" makes most sense to me, deanhystad.

However, I just read a DC article that seems to conflict a bit with that by claiming variables defined globally are available locally. So... what's the difference between this:

check = 0
 
def sample_fcn():
  print(check)

and

check = 0
 
def sample_fcn():
  check += 1
  print(check)

When calling sample_fcn(), the first prints 0. The second gives UnboundLocalError: local variable 'check' referenced before assignment. It was assigned globally, though.

It does make sense to me that if I define a variable locally with the same name was one that was globally initialized, it won't be the same as the latter--it'll be a local variable with the same name.

[ibreeden]

Why? What would be another way to accomplish the same thing?

Let me tell you a story. Long ago the company where I worked had a large information system built. When it was ready we saw the programmers had used lots of global variables. What was the problem? A bug was found in one part of the system and it was repaired. But after that the use of the variables had changed and this influenced other parts of the program. This again caused bugs to be found. This kept on happening for years until at last the information system was replaced.

So what has to be done to prevent this kind of troubles? Large books have been written about the rules to prevent these problems. But as I have a simple mind I believe I can simplify the case by showing how to apply the rules on a function, because functions are the building blocks for larger programs. I leave it to you to think about classes, modules etc.

• A function has input (parameters) and output (return value).
  
• A function does not interfere with the main program other than by its parameters and its return value.
  
• A function does not have side effects.
  

Now about your question. How should you use a function without global variables?

def sample_fcn(local_number):
    local_number += 1
    return local_number

check = 0
check = sample_fcn(check)
print(check)

---

Sorry deanhystad, you were typing faster than I did. And had more examples to do it right.

[deanhystad]

There are different rules for accessing and assigning.

When looking to resolve a name Python looks in this order: local scope, enclosed scope, global/module scope, built-in scope. This is why Python functions and modules can use "input" and "print". These names exist in the built-in scope and can be seen by everyone.

When assigning a variable, Python uses the local scope unless otherwise directed.

Here I do something horrible and assigned the input variable to a module function instead of the built-in.

def input(x):
    return x**2

print(input(2))

Now this module cannot use the built-in input() because python resolves the "input" name in the global/module scope.

Here I do something less horrible and only assign the input variable to an enclosed function inside an enclosed scope. Outside the scope of my_func, input() works as before.

def my_func(x):
    def input(x):
        return x**2

    return input(x)

print(my_func(2)) 
print(input(2))

[Mark17]

There are different rules for accessing and assigning.

When looking to resolve a name Python looks in this order: local scope, enclosed scope, global/module scope, built-in scope. This is why Python functions and modules can use "input" and "print". These names exist in the built-in scope and can be seen by everyone.

When assigning a variable, Python uses the local scope unless otherwise directed.

I'm finding this a bit too complex for me to understand... can you apply this explanation to the two seemingly conflicting examples I gave in my last post? I think that would crystalize things for me.

Thanks!