How to define Local and Global Variables in Python
One of the basic elements of programming languages are variables. Simply speaking a variable is an abstraction layer for the memory cells that contain the actual value. For us, as a developer, it is easier to remember the name of the memory cell than it is to remember its physical memory address. A valid name can consist of characters from ‘a’ to ‘z’ (in both lower and upper cases) as well as digits. No spaces or special characters, like umlauts and hyphens, are allowed in the name.
Furthermore, variables have a specific data type like strings (characters), digits, lists or references to other variables. In Python, we may reuse the same variable to store values of any type. The type is automatically determined by the value that is assigned to the name. In order to define a variable with a specific value, simply assign this value to a name as follows:
age = 42 name = "Dominic" places = ["Berlin", "Cape Town", "New York"]
The Python interpreter creates the three variables
places, and assigns the value 42 to the first and “Dominic” to the second variable, and
places becomes a list of three elements that contains the strings “Berlin”, “Cape Town”, and “New York”.
All the variables from above are part of the same namespace and therefore have the same scope. Unless redefined as a local variable later on, a variable defined in the main program belongs to the global namespace, that can be accessed by any function in your Python program. The following example code demonstrates that and uses the two variables
age in the function
age = 42 name = "Dominic" places = ["Berlin", "Cape Town", "New York"] def info(): print("%s is %i years old." % (name, age)) return info()
The output consists of the single line that comes from the
$ python3 global.py Dominic is 42 years old.
To be more precise, every module, class and function has its own namespace and variables are locally bound to that. In the next example we make use of two namespaces – the outer, global one from the main program and the inner, local one from the function simply named
output(). The variable
place exists in the main program (line 6) and is redefined as a local variable with a new value in line 2 of the function
def output(): place = "Cape Town" print("%s lives in %s." % (name, place)) return place = "Berlin" name = "Dominic" print("%s lives in %s." % (name, place)) output()
The output consists of these two lines, whereas the first line originates from the main program (line 8) and the second line from the
output(). At first the two variables
place are defined in the main program (lines 6 and 7) and printed to stdout. Calling the
output() function, the variable
place is locally redefined in line 2 and
name comes from the global namespace, instead. This leads to the output as shown below.
$ python3 localscope.py Dominic lives in Berlin. Dominic lives in Cape Town.
Modifying Global Variables in a Different Namespace
The value of a global variable can be accessed throughout the entire program. In order to achieve that from within functions, Python offers the usage of the keyword
global. The function below demonstrates how to use it and imports the variable
name into the namespace of the function:
def location(): global place place = "Cape Town" return place = "Berlin" print(place) location() print(place)
place is already defined in the main program (line 6). Using the keyword
global in line 2, the variable becomes available in the function
location() and can be set to a different value, immediately (line 3). The output of the the code is shown here:
$ python3 globalscope.py Berlin Cape Town
Without using the keyword
global as seen in line 2, the variable
place would be treated as a local variable in the function
location() instead and the variable
place from the main program is unchanged then.
Detect the Scope of a Variable
Python has two built-in methods named
locals(). They allow you to determine whether a variable is either part of the global namespace or the local namespace. The following example shows how to use these methods:
def calculation(): "do a complex calculation" global place place = "Cape Town" name = "John" print("place in global:", 'place' in globals()) print("place in local :", 'place' in locals()) print("name in global :", 'name' in globals()) print("name in local :", 'name' in locals()) return place = "Berlin" print(place) calculation()
The output is as follows and shows the scope of the two variables
name inside the function
$ python3 variablelist.py Berlin place in global: True place in local : False name in global : False name in local : True
Using Global Variables in Practice
Using and modifying global variables from inside functions is seen as a very bad programming style, as it causes side effects, which are rather difficult to detect. It is strongly recommended to use proper function parameters, instead.
Python Example for Beginners
Two Machine Learning Fields
There are two sides to machine learning:
- Practical Machine Learning:This is about querying databases, cleaning data, writing scripts to transform data and gluing algorithm and libraries together and writing custom code to squeeze reliable answers from data to satisfy difficult and ill defined questions. It’s the mess of reality.
- Theoretical Machine Learning: This is about math and abstraction and idealized scenarios and limits and beauty and informing what is possible. It is a whole lot neater and cleaner and removed from the mess of reality.
Data Science Resources: Data Science Recipes and Applied Machine Learning Recipes
Introduction to Applied Machine Learning & Data Science for Beginners, Business Analysts, Students, Researchers and Freelancers with Python & R Codes @ Western Australian Center for Applied Machine Learning & Data Science (WACAMLDS) !!!
Latest end-to-end Learn by Coding Recipes in Project-Based Learning:
Disclaimer: The information and code presented within this recipe/tutorial is only for educational and coaching purposes for beginners and developers. Anyone can practice and apply the recipe/tutorial presented here, but the reader is taking full responsibility for his/her actions. The author (content curator) of this recipe (code / program) has made every effort to ensure the accuracy of the information was correct at time of publication. The author (content curator) does not assume and hereby disclaims any liability to any party for any loss, damage, or disruption caused by errors or omissions, whether such errors or omissions result from accident, negligence, or any other cause. The information presented here could also be found in public knowledge domains.