Python Variables

Python Variable is containers that store values. Python is not “statically typed”. We do not need to declare variables before using them or declare their type. A variable is created the moment we first assign a value to it. A Python variable is a name given to a memory location. It is the basic unit of storage in a program. In this article, we will see how to define a variable in Python.

Example of Variable in Python

An Example of a Variable in Python is a representational name that serves as a pointer to an object. Once an object is assigned to a variable, it can be referred to by that name. In layman’s terms, we can say that Variable in Python is containers that store values.

Here we have stored “Geeksforgeeks”  in a variable var, and when we call its name the stored information will get printed.

Var = "Geeksforgeeks"
print(Var)

Output:

Geeksforgeeks

Notes:

• The value stored in a variable can be changed during program execution.
• A Variables in Python is only a name given to a memory location, all the operations done on the variable effects that memory location.

Rules for Python variables

• A Python variable name must start with a letter or the underscore character.
• A Python variable name cannot start with a number.
• A Python variable name can only contain alpha-numeric characters and underscores (A-z, 0-9, and _ ).
• Variable in Python names are case-sensitive (name, Name, and NAME are three different variables).
• The reserved words(keywords) in Python cannot be used to name the variable in Python.

Example 

# valid variable name
geeks = 1
Geeks = 2
Ge_e_ks = 5
_geeks = 6
geeks_ = 7
_GEEKS_ = 8

print(geeks, Geeks, Ge_e_ks)
print(_geeks, geeks_, _GEEKS_)

Output:

1 2 5
6 7 8

Variables Assignment in Python

Here, we will define a variable in python. Here, clearly we have assigned a number, a floating point number, and a string to a variable such as age, salary, and name.

# An integer assignment
age = 45

# A floating point
salary = 1456.8

# A string
name = "John"

print(age)
print(salary)
print(name)

Output:

45
1456.8
John

Declaration and Initialization of Variables

Let’s see how to declare a variable and how to define a variable and print the variable.

# declaring the var
Number = 100

# display
print( Number)

Output:

100

Redeclaring variables in Python

We can re-declare the Python variable once we have declared the variable and define variable in python already.

# declaring the var
Number = 100

# display
print("Before declare: ", Number)

# re-declare the var
Number = 120.3
  
print("After re-declare:", Number)

Output:

Before declare:  100
After re-declare: 120.3

Python Assign Values to Multiple Variables 

Also, Python allows assigning a single value to several variables simultaneously with “=” operators. 
For example: 

a = b = c = 10

print(a)
print(b)
print(c)

Output:

10
10
10

Assigning different values to multiple variables

Python allows adding different values in a single line with “,” operators.

a, b, c = 1, 20.2, "GeeksforGeeks"

print(a)
print(b)
print(c)

Output:

1
20.2
GeeksforGeeks

Can We Use the Same Name for Different Types?

If we use the same name, the variable starts referring to a new value and type.

a = 10
a = "GeeksforGeeks"

print(a)

Output:

GeeksforGeeks

How does + operator work with variables? 

The Python plus operator + provides a convenient way to add a value if it is a number and concatenate if it is a string. If a variable is already created it assigns the new value back to the same variable.

a = 10
b = 20
print(a+b)

a = "Geeksfor"
b = "Geeks"
print(a+b)

30
GeeksforGeeks

Can we use + for different Datatypes also? 

No use for different types would produce an error.

a = 10
b = "Geeks"
print(a+b)

Output : 

TypeError: unsupported operand type(s) for +: 'int' and 'str'

Global and Local Python Variables

Local variables in Python are the ones that are defined and declared inside a function. We can not call this variable outside the function.

# This function uses local variable s
def f():
    s = "Welcome geeks"
    print(s)


f()

Output:

Welcome geeks

Global variables in Python are the ones that are defined and declared outside a function, and we need to use them inside a function.

# This function has a variable with
# name same as s
def f():
    print(s)

# Global scope
s = "I love Geeksforgeeks"
f()

Output:

I love Geeksforgeeks

Global keyword in Python

Python global is a keyword that allows a user to modify a variable outside of the current scope. It is used to create global variables from a non-global scope i.e inside a function. Global keyword is used inside a function only when we want to do assignments or when we want to change a variable. Global is not needed for printing and accessing.

Rules of global keyword

• If a variable is assigned a value anywhere within the function’s body, it’s assumed to be local unless explicitly declared as global.
• Variables that are only referenced inside a function are implicitly global.
• We use a global in Python to use a global variable inside a function.
• There is no need to use a global keyword in Python outside a function.

Example:

Python program to modify a global value inside a function.

x = 15

def change():

    # using a global keyword
    global x

    # increment value of a by 5
    x = x + 5
    print("Value of x inside a function :", x)


change()
print("Value of x outside a function :", x)

Output:

Value of x inside a function : 20
Value of x outside a function : 20

Variable Types in Python

Data types are the classification or categorization of data items. It represents the kind of value that tells what operations can be performed on a particular data. Since everything is an object in Python programming, data types are actually classes and variables are instances (object) of these classes.

Built-in Python Data types are:

• Numeric
• Text Type
• Sequence Type (Python list, Python tuple, Python range)
• Boolean
• Set
• Dictionary

Example:

In this example, we have shown different examples of Built-in data types in Python.

# numberic
var = 123
print("Numeric data : ", var)

# Sequence Type
String1 = 'Welcome to the Geeks World'
print("String with the use of Single Quotes: ")
print(String1)

# Boolean
print(type(True))
print(type(False))

# Creating a Set with
# the use of a String
set1 = set("GeeksForGeeks")
print("\nSet with the use of String: ")
print(set1)

# Creating a Dictionary
# with Integer Keys
Dict = {1: 'Geeks', 2: 'For', 3: 'Geeks'}
print("\nDictionary with the use of Integer Keys: ")
print(Dict)

Output:

Numeric data :  123
String with the use of Single Quotes: 
Welcome to the Geeks World
<class 'bool'>
<class 'bool'>
Set with the use of String: 
{'r', 'G', 'e', 'k', 'o', 's', 'F'}
Dictionary with the use of Integer Keys: 
{1: 'Geeks', 2: 'For', 3: 'Geeks'}

Object Reference in Python

Let us assign a variable x to value 5.

x = 5

Another variable is y to the variable x.

y = x

When Python looks at the first statement, what it does is that, first, it creates an object to represent the value 5. Then, it creates the variable x if it doesn’t exist and made it a reference to this new object 5. The second line causes Python to create the variable y, and it is not assigned with x, rather it is made to reference that object that x does. The net effect is that the variables x and y wind up referencing the same object. This situation, with multiple names referencing the same object, is called a Shared Reference in Python.
Now, if we write:

x = 'Geeks'

This statement makes a new object to represent ‘Geeks’ and makes x reference this new object.

Now if we assign the new value in Y, then the previous object refers to the garbage values.

y = "Computer"

Creating objects (or variables of a class type)

Please refer to Class, Object, and Members for more details. 

class CSStudent:
    # Class Variable
    stream = 'cse'
    # The init method or constructor
    def __init__(self, roll):
        # Instance Variable
        self.roll = roll

# Objects of CSStudent class
a = CSStudent(101)
b = CSStudent(102)

print(a.stream)  # prints "cse"
print(b.stream)  # prints "cse"
print(a.roll)    # prints 101

# Class variables can be accessed using class
# name also
print(CSStudent.stream)  # prints "cse"

cse
cse
101
cse

Python Variables – FAQs

What Are Variables in Python?

Variables in Python are used to store data values. They act as containers for storing data, which can be used and manipulated throughout a program. In Python, variables do not need explicit declaration to reserve memory space; the declaration happens automatically when you assign a value to a variable.

How to Declare Variables in Python?

In Python, variables are declared by assigning a value to them using the assignment operator =. You do not need to specify the type of variable as Python is dynamically typed.

Example:

# Declaring variables
name = "Alice"
age = 25
is_student = True

In this example, name is a string, age is an integer, and is_student is a boolean.

What Are Global and Local Variables in Python?

Global Variables: Global variables are variables that are declared outside of any function. They can be accessed and modified by any function within the same module.

Example:

global_var = "I am global"

def print_global():
    print(global_var)

print_global()  # Output: I am global

Local Variables: Local variables are variables that are declared within a function. They can only be accessed within that function and are not available outside of it.

Example:

def print_local():
    local_var = "I am local"
    print(local_var)

print_local()  # Output: I am local
# print(local_var)  # This would raise an error because local_var is not accessible outside the function.

Can Variable Types Change in Python?

Yes, variable types can change in Python because it is a dynamically typed language. This means that the type of a variable is interpreted at runtime and you can assign different types of values to the same variable.

Example:

var = 10    # var is an integer
var = "Hello"  # Now var is a string
var = [1, 2, 3]  # Now var is a list

How to Use Type Annotations for Variables in Python?

Type annotations in Python provide a way to specify the expected type of a variable. They do not enforce type checking at runtime but can be used by static type checkers, IDEs, and linters to help catch type-related errors.

Example:

# Using type annotations
name: str = "Alice"
age: int = 25
is_student: bool = True

def greeting(name: str) -> str:
    return f"Hello, {name}"

# Static type checkers can use these annotations to detect type errors

In this example, the variables name, age, and is_student are annotated with their expected types. The function greeting also has type annotations for its parameter and return type.

S

shruthitv

Follow

Improve