PYTHON
Python Variables
In Python, variables are used to store data that can be referenced and manipulated during
program execution. A variable is essentially a name that is assigned to a value.
Unlike Java and many other languages, Python variables do not require explicit
declaration of type.
The type of the variable is inferred based on the value assigned.
x=5
name = "Samantha"
print(x)
print(name)
Output:
5
Samantha
Rules for Naming Variables
To use variables effectively, we must follow Python’s naming rules:
Variable names can only contain letters, digits and underscores (_).
A variable name cannot start with a digit.
Variable names are case-sensitive like myVar and myvar are different.
Avoid using Python keywords like if, else, for as variable names.
Valid :
age = 21
_colour = "lilac"
total_score = 90
Invalid :
1name = "Error" # Starts with a digit
class = 10 # 'class' is a reserved keyword
user-name = "Doe" # Contains a hyphen
Assigning Values to Variables
Basic Assignment
Variables in Python are assigned values using the = operator.
x=5
y = 3.14
z = "Hi"
Dynamic Typing
Python variables are dynamically typed, meaning the same variable can hold different types
of values during execution.
x = 10
x = "Now a string"
Multiple Assignments
Python allows multiple variables to be assigned values in a single line.
Assigning the Same Value
Python allows assigning the same value to multiple variables in a single line, which can be
useful for initializing variables with the same value.
a = b = c = 100
print(a, b, c)
Output:
100 100 100
Assigning Different Values
We can assign different values to multiple variables simultaneously, making the code concise
and easier to read.
x, y, z = 1, 2.5, "Python"
print(x, y, z)
Output:
1 2.5 Python
Type Casting a Variable
Type casting refers to the process of converting the value of one data type into another.
Python provides several built-in functions to facilitate casting, including int(), float() and str()
among others.
Basic Casting Functions
int(): Converts compatible values to an integer.
float(): Transforms values into floating-point numbers.
str(): Converts any data type into a string.
s = "10"
n = int(s)
cnt = 5
f = float(cnt)
age = 25
s2 = str(age)
print(n)
print(f)
print(s2)
Output:
10
5.0
25
Getting the Type of Variable
In Python, we can determine the type of a variable using the type() function. This built-in
function returns the type of the object passed to it.
n = 42
f = 3.14
s = "Hello, World!"
li = [1, 2, 3]
d = {'key': 'value'}
bool = True
print(type(n))
print(type(f))
print(type(s))
print(type(li))
print(type(d))
print(type(bool))
Output:
<class 'int'>
<class 'float'>
<class 'str'>
<class 'list'>
<class 'dict'>
<class 'bool'>
Object Reference in Python
Let us assign a variable x to value 5.
x=5
When x = 5 is executed, Python creates an object to represent the value 5 and
makes x reference this object.
Now, let's assign another variable y to the variable x.
y=x
Python encounters the first statement, it creates an object for the value 5 and
makes x reference it. The second statement creates y and references the same object
as x, not x itself. This is called a Shared Reference, where multiple variables reference
the same object.
Now, if we write
x = 'Geeks'
Python creates a new object for the value "Geeks" and makes x reference this new object.
The variable y remains unchanged, still referencing the original object 5.
If we now assign a new value to y:
y = "Computer"
Python creates yet another object for "Computer" and updates y to reference it.
The original object 5 no longer has any references and becomes eligible for garbage
collection.
Python variables hold references to objects, not the actual objects themselves.
Reassigning a variable does not affect other variables referencing the same object
unless explicitly updated.
Delete a Variable Using del Keyword
We can remove a variable from the namespace using the del keyword. This deletes the
variable and frees up the memory it was using.
x = 10
print(x)
del x
# Trying to print x after deletion will raise an error
# print(x) # Uncommenting this line will raise NameError: name 'x' is not defined
del x removes the variable x from memory.
After deletion, trying to access the variable x results in a NameError indicating that
the variable no longer exists.
Practical Examples
1. Swapping Two Variables
Using multiple assignments, we can swap the values of two variables without needing a
temporary variable.
a, b = 5, 10
a, b = b, a
print(a, b)
Output:
10 5
2. Counting Characters in a String
Assign the results of multiple operations on a string to variables in one line.
word = "Python"
length = len(word)
print("Length of the word:", length)
Output:
Length of the word: 6