The variable is the name used to refer to the memory location. This means that you reserve memory when you create the variable. Python variables, also known as identifiers, are used to hold values. Python is an inference language and is smart enough to get the type of a variable, so you don’t need to specify the type of the variable. The value stored in the variable can be changed while the program is running.
Rules to create Python variables:
- First, Variable names must start with a letter or an underscore.
- Second, Variable names cannot start with a number.
- Third, Variable names can only contain alphanumerics and underscores (A-Z, 0-9, and _).
- Then, Variable names are case sensitive (Name, Name, and NAME are three different variables).
- Finally, Variables cannot be named using reserved words (keywords).
Let’s take a look at creating a simple variable.
#!/usr / bin / python # An integer assignment age = 45 # A floating point salary = 1456.8 # A string name = "John" print(age) print(salary) print(name)
45 1456.8 John
Declare the Variable:
Let’s see how to declare a variable and how to print a variable.
# declaring the var Number = 100 # display print( Number)
Re-declare the Variable:
After declaring the variable, you can redeclare the Python variable.
# declaring the var Number = 100 # display print("Before declare: ", Number) # re-declare the var Number = 120.3 print("After re-declare:", Number)
Before declare: 100 After re-declare: 120.3
In Python, you can assign values to multiple variables in a single statement. This is also known as multiple assignments.
You can apply multiple assignments in two ways: assigning a single value to multiple variables or assigning multiple values to multiple variables. Consider the following example.
Assigning a single value to multiple variables
x=y=z=70 print(x) print(y) print(z)
70 70 70
Assigning multiple values to multiple variables:
a,b,c=5,17,eMexo print a print b print c
5 17 eMexo
The values are assigned in the order in which the variables are displayed.
Can we use the same name for different types?
If you use the same name, the variable will start referencing a new value and type.
#!/usr / bin / python a = 10 a = "eMexo Technologies" print(a)
How does the + operator work with variables?
#!/usr / bin / python a = 17 b = 10 print(a+b) a = "eMexo" b = "Technologies" print(a+b)
Can we use + for different types also?
No, using different types would produce an error.
#!/usr / bin / python a = 10 b = "eMexo" print(a+b)
TypeError: unsupported operand type(s) for +: 'int' and 'str'
Python Variable Types
There are two types of variables in Python: local variables and global variables. Let’s understand the following variables.
Local variables are variables that are declared within a function and have scope within the function. Let’s understand the following example.
# Declaring a function def add(): # Defining local variables. They has scope only within a function a = 20 b = 30 c = a + b print("The sum is:", c) # Calling a function add()
The sum is: 50
The explanation for the code:
In the code above, I declared a function called add() and assigned some variables inside the function. These variables are called local variables and are only valid within the function. If you try to use them outside the function, you will get the following error:
add() # Accessing local variable outside the function print(a)
The sum is: 50 print(a) NameError: name 'a' is not defined
We tried to use a local variable outside their scope; it threw the NameError.
Global variables can be used throughout the program, and its scope is in the entire program. We can use global variables inside or outside the function. Variables declared outside the function are global variables by default. Python provides global keywords for using global variables within functions. If you do not use the global keyword, the function treats it as a local variable. Let’s understand the following example.
# Declare a variable and initialize it x = 101 # Global variable in function def mainFunction(): # printing a global variable global x print(x) # modifying a global variable x = 'Welcome To eMexo Technologies' print(x) mainFunction() print(x)
101 Welcome To eMexo Technologies Welcome To eMexo Technologies
The explanation for the code:
The code above declares the global variable x and assigns it a value. Next, I defined the function and accessed the variables declared using the global keywords in the function. You can now change that value. Then I assigned the variable x a new string value.
Now the function is called and we proceed to the print of x. Output the newly assigned value of x.
Delete a variable
You can delete a variable using the del keyword. The syntax is as follows:
The following example creates the variable x and assigns it a value. If you delete the variable x and output it, you will get the error “Variable x is not defined“. The variable x will no longer be used.
# Assigning a value to x x = 7 print(x) # deleting a variable. del x print(x)
7 Traceback (most recent call last): File "C:/Users/eMexo/PycharmProjects/Hello/multiprocessing.py", line 6, in print(x) NameError: name 'x' is not defined
Maximum Possible Value of an Integer in Python
Unlike other programming languages, Python does not have long int or float data types. Treat all integer values as int data types. The problem arises here. What is the maximum value a variable can hold in Python? Consider the following example.
# A Python program to display that we can store # large numbers in Python a = 10000000000000000000000000000000000000000000 a = a + 1 print(type(a)) print (a)
<class 'int'> 10000000000000000000000000000000000000000001
As you can see in the example above, we assigned a large integer value to the variable x and checked its type. Class long int was not printed instead of that int is printed. Therefore, there is no limit to the number of bits and it can be extended to the memory limit. Python has no special data type for storing larger numbers.