Python Global variables

The scope of a variable in Python refers to the part of the code where the variable can be accessed and used. In Python, there are two types of scope:

  1. Global scope
  2. Local scope

Global scope (Global variables):

Variables declared outside of any function or class have global scope and can be accessed from anywhere in the code.

Local scope (Local variables):

Variables declared inside a function or class have local scope and can only be accessed within the function or class where they were declared.

Python Global variables

A global variable is a variable that can be accessed from anywhere in the code, i.e. it has a global scope. Global variables are declared outside of any function or class and can be used by any function in the code. To declare a global variable, you use the "global" keyword before the variable name.

How to create a global variable in Python?

x = 10 #Declaring a global variable def my_function(): print("Global Value : " , x) my_function() # Output: Global Value : 10

In the above example, the variable x is declared outside of any function and thus has global scope. It can be accessed from anywhere in the code, including from within the my_function function. When the my_function function is called, it prints the value of the global variable x, which is 10.

Python shadowing

Shadowing in Python refers to the situation where a local variable in a function has the same name as a global variable, and thus "shadows" the global variable within the scope of the local variable. When a local variable and a global variable have the same name in Python, the local variable will take precedence over the global variable within the scope of the local variable.

x = 10 # global variable def my_function(): x = 5 # local variable name same as global print(x) my_function() # Output: 5 print(x) # Output: 10

In the above example, you have a global variable named x with a value of 10. Within the my_function function, you declare a local variable named x with a value of 5. When the my_function function is called, it prints the value of the local variable x, which is 5. When you print the value of the global variable x outside of the function, it is still 10.

Python Global keyword


Python global keyword

The global keyword in Python is used to indicate that a variable is a global variable, rather than a local variable. It allows you to access and modify the value of a global variable from within a function.

x = 10 #lobal variable def my_function(): global x x = 5 print(x) my_function() #Output: 5 print(x) #Output: 5

In this example, you have a global variable x with a value of 10. Within the my_function function, you use the global keyword to indicate that you want to access and modify the value of the global variable x, not create a new local variable with the same name. Then you change the value of x to 5. When you call the my_function function, it prints the new value of x, which is 5. When you print the value of x outside of the function, it is also 5, because the global variable has been modified.

Python Local Variable

A local variable is a variable declared inside a function or class. Local variables have a local scope, which means that they can only be accessed and used within the function or class where they were declared.

def my_function(): x = 5 # local variable print(x) my_function() #Output: 5 print(x) #Raises a NameError: name 'x' is not defined

In the above example, the variable x is declared as a local variable within the my_function function with a value of 5. When the my_function function is called, it prints the value of the local variable x, which is 5. However, if you try to access x outside of the function, a NameError will be raised because x is not defined in the global scope. On the other hand, global variables can be accessed from anywhere in the code. However, it is generally considered best practice to avoid using global variables as much as possible, as they can make the code harder to understand and maintain.

Python variable's lifetime


Python global variable

It's important to keep in mind that local variables are only accessible within their scope, and are destroyed once the function or class is finished executing. This is known as the variable's lifetime. When a function is called again, a new instance of the local variable is created and its value is not remembered from the previous call.

Conclusion

By contrast, global variables are accessible from anywhere in the code, and their lifetime extends from the time they are defined until the end of the program. However, as mentioned earlier, it is generally considered best practice to avoid using global variables as much as possible, as they can make the code harder to understand and maintain.






Related Topics
  1. Python Interview Questions (Part 2)
  2. Python Interview Questions (Part 3)
  3. What is python used for?
  4. Is Python interpreted, or compiled, or both?
  1. Explain how python is interpreted
  2. How do I install pip on Windows?
  3. How do you protect Python source code?
  4. What are the disadvantages of the Python?
  5. How would you achieve web scraping in Python?
  6. How to Python Script executable on Unix
  7. What is the difference between .py and .pyc files?
  8. What is __init__.py used for in Python?
  9. What does __name__=='__main__' in Python mean?
  10. What is docstring in Python?
  11. What is the difference between runtime and compile time?
  12. How to use *args and **kwargs in Python
  13. Purpose of "/" and "//" operator in python?
  14. What is the purpose pass statement in python?
  15. Why isn't there a switch or case statement in Python?
  16. How does the ternary operator work in Python?
  17. What is the purpose of "self" in Python
  18. How do you debug a program in Python?
  19. What are literals in python?
  20. Is Python call-by-value or call-by-reference?
  21. What is the process of compilation and Loading in python?
  22. Static analysis tools in Python
  23. What does the 'yield' keyword do in Python?
  24. Python Not Equal Operator (!=)
  25. What is the difference between 'is' and '==' in python
  26. What is the difference between = and == in Python?
  27. How are the functions help() and dir() different?
  28. What is the python keyword "with" used for?
  29. Why isn't all memory freed when CPython exits
  30. Difference between Mutable and Immutable in Python
  31. Python Split Regex: How to use re.split() function?
  32. Accessor and Mutator methods in Python
  33. How to Implement an 'enum' in Python
  34. What is Object in Python?
  35. How to determine the type of instance and inheritance in Python
  36. Python Inheritance
  37. How is Inheritance and Overriding methods are related?
  38. How can you create a copy of an object in Python?
  39. Class Attributes vs Instance Attributes in Python
  40. Static class variables in Python
  41. Difference between @staticmethod and @classmethod in Python
  42. How to Get a List of Class Attributes in Python
  43. Does Python supports interfaces like in Java or C#?
  44. How To Work with Unicode strings in Python
  45. Difference between lists and tuples in Python?
  46. What are differences between List and Dictionary in Python
  47. Different file processing modes supported by Python
  48. Python append to a file
  49. Difference Between Multithreading vs Multiprocessing in Python
  50. Is there any way to kill a Thread in Python?
  51. What is the use of lambda in Python?
  52. What is map, filter and reduce in python?
  53. Is monkey patching considered good programming practice?
  54. What is "typeerror: 'module' object is not callable"
  55. Python: TypeError: unhashable type: 'list'
  56. How to convert bytes to string in Python?
  57. What are metaclasses in Python?