What are Python Variables?
A variable is a container for a value. It can be assigned a name, you can use it to refer to it later in the program. Based on the value assigned, the interpreter decides its data type. You can always store a different type in a variable.
For example, if you store 7 in a variable, later, you can store ‘Shishir Kant’.
Python Variables Naming Rules
There are certain rules to what you can name a variable(called an identifier).
- Python variables can only begin with a letter(A-Z/a-z) or an underscore(_).
>>> 9lives=9
SyntaxError: invalid syntax
>>> flag=0 >>> flag
>>> _9lives='kanpur' >>> _9lives
‘kanpur’
- The rest of the identifier may contain letters(A-Z/a-z), underscores(_), and numbers(0-9).
>>> year2='ShishirKant' >>> year2
‘ShishirKant’
>>> _$$=7
SyntaxError: invalid syntax
- Python is case-sensitive, and so are Python identifiers. Name and name are two different identifiers.
>>> name='SEED Group' >>> name
‘SEED Group’
>>> Name
Traceback (most recent call last):
File “<pyshell#21>”, line 1, in <module>
Name
NameError: name ‘Name’ is not defined
- Reserved words (keywords) cannot be used as identifier names.
| and | def | False | import | not | True |
| as | del | finally | in | or | try |
| assert | elif | for | is | pass | while |
| break | else | from | lambda | with | |
| class | except | global | None | raise | yield |
| continue | exec | if | nonlocal | return |
Assigning and Reassigning Python Variables
To assign a value to Python variables, you don’t need to declare its type. You name it according to the rules stated in section 2a, and type the value after the equal sign(=).
>>> age=7 >>> print(age)
7
>>> age='Shishir' >>> print(age)
Shishir
However, age=Dinosaur doesn’t make sense. Also, you cannot use Python variables before assigning it a value.
>>> name
Traceback (most recent call last):
File “<pyshell#8>”, line 1, in <module>
name
NameError: name ‘name’ is not defined
You can’t put the identifier on the right-hand side of the equal sign, though. The following code causes an error.
>>> 7=age
SyntaxError: can’t assign to literal
Neither can you assign Python variables to a keyword.
>>> False=choice
SyntaxError: can’t assign to keyword
3. Multiple Assignment
You can assign values to multiple Python variables in one statement.
>>> age,city=21,'Lucknow' >>> print(age,city)
21 Lucknow
Or you can assign the same value to multiple Python variables.
>>> age=fav=7 >>> print(age,fav)
7 7
This is how you assign values to Python Variables
4. Swapping Variables
Swapping means interchanging values. To swap Python variables, you don’t need to do much.
>>> a,b='red','blue' >>> a,b=b,a >>> print(a,b)
blue red
5. Deleting Variables
You can also delete Python variables using the keyword ‘del’.
>>> a='red' >>> del a >>> a
Traceback (most recent call last):
File “<pyshell#39>”, line 1, in <module>
a
NameError: name ‘a’ is not defined
This is How you can delete Python Variables
======================================================
Python Variable Scope
The scope of a variable in python is that part of the code where it is visible. Actually, to refer to it, you don’t need to use any prefixes then. Let’s take an example
>>> b=8
>>> def func():
a=7
print(a)
print(b)
>>> func()
7
8
>>> a
Traceback (most recent call last):
File “<pyshell#6>”, line 1, in <module>
a
NameError: name ‘a’ is not defined
Also, the duration for which a variable is alive is called its ‘lifetime’.
Types of Python Variable Scope
There are 4 types of Variable Scope in Python, let’s discuss them one by one:
a. Local Scope
In the above code, we define a variable ‘a’ in a function ‘func’. So, ‘a’ is local to ‘func’. Hence, we can read/write it in func, but not outside it. When we try to do so, it raises a NameError.
Look at this code.
>>> a=0
>>> def func():
print(a)
a=1
print(a)
>>> func()
Traceback (most recent call last):
File “<pyshell#79>”, line 1, in <module>
func()
File “<pyshell#78>”, line 2, in func
print(a)
UnboundLocalError: local variable ‘a’ referenced before assignment
Here, we could’ve accessed the global Scope ‘a’ inside ‘func’, but since we also define a local ‘a’ in it, it no longer accesses the global ‘a’. Then, the first print statement inside ‘func’ throws an error in Python, because we’re trying to access the local scope ‘a’ before assigning it. However, it is bad practice to try to manipulate global values from inside local scopes. Try to pass it as a parameter to the function.
>>> def func(a=0):
a+=1
print(a)
>>> func()
b. Global Scope
We also declare a variable ‘b’ outside any other python Variable scope, this makes it global scope. Consequently, we can read it anywhere in the program. Later in this article, we will see how to write it inside func.
c. Enclosing Scope
Let’s take another example.
>>> def red():
a=1
def blue():
b=2
print(a)
print(b)
blue()
print(a)
>>> red()
1
2
1
In this code, ‘b’ has local scope in Python function ‘blue’, and ‘a’ has nonlocal scope in ‘blue’. Of course, a python variable scope that isn’t global or local is nonlocal. This is also called enclosing scope.
d. Built-in Scope
Finally, we talk about the widest scope. The built-in scope has all the names that are loaded into python variable scope when we start the interpreter. For example, we never need to import any module to access functions like print() and id().
Now that we’ve discussed different types of python variable scopes, let’s see how to deal with them.
Global Keyword in Python
So far, we haven’t had any kind of a problem with global scope. So let’s take an example.
>>> a=1
>>> def counter():
a=2
print(a)
>>> counter()
2
Now, when we make a reference to ‘a’ outside this function, we get 1 instead of 2.
>>> a
1
Why does this happen? Well, this is because when we set ‘a’ to 2, it created a local variable ‘a’ in the local scope of ‘counter’. This didn’t change anything for the global ‘a’. Now, what if you wanted to change the global version of ‘a’? We use the ‘global’ keyword in python for this.
>>> a=1
>>> def counter():
global a
a=2
print(a)
>>> counter()
2
>>> a
2
What we do here is, we declare that the ‘a’ we’re going to use in this function is from the global scope. After this, whenever we make a reference to ‘a’ inside ‘counter’, the interpreter knows we’re talking about the global ‘a’. In this example, it changed the value of the global ‘a’ to 2.
Nonlocal Keyword
Like the ‘global’ keyword, you want to make a change to a nonlocal variable, you must use the ‘nonlocal’ keyword. Let’s first try this without the keyword.
>>> def red():
a=1
def blue():
a=2
b=2
print(a)
print(b)
blue()
print(a)
>>> red()
2
2
1
As you can see, this did not change the value of ‘a’ outside function ‘blue’. To be able to do that, we use ‘nonlocal’.
>>> def red():
a=1
def blue():
nonlocal a
a=2
b=2
print(a)
print(b)
blue()
print(a)
>>> red()
2
2
2
