Python Variables and Data Types: Complete Beginner’s Guide with Examples (2026)

 

Python Variables and Data Types: A Complete Guide to Python Variables

Python is one of the most popular programming languages in the world because it is readable, flexible, and beginner-friendly. Whether you want to build websites, automate tasks, analyze data, create artificial intelligence applications, or develop software, understanding Python fundamentals is essential.

One of the first concepts every Python programmer needs to learn is the variable.

Variables are used to store and work with information inside a Python program. That information might be a person's name, an age, a price, a mathematical result, a list of products, or even a complex data structure.

Python also provides several built-in data types that determine what kind of information a variable represents. Understanding variables and data types gives you the foundation needed to write more powerful Python programs.

In this complete guide, you will learn:

• What Python variables are

• How to create variables

• Python variable naming rules

• Dynamic typing in Python

• How assignment works

• Python's main built-in data types

• Numbers, strings, booleans, lists, tuples, sets, and dictionaries

• Type conversion

• Checking variable types

• Mutable and immutable data

• Multiple assignment

• Constants and naming conventions

• Common beginner mistakes

• Practical examples

• Best practices for writing clean Python code

---

1. What Is a Variable in Python?

A variable is a name that refers to a value stored in a Python program.

For example:

name = "Ali"
age = 18

Here, name and age are variables.

The variable name refers to the string "Ali", while age refers to the integer 18.

You can think of a variable as a label attached to some piece of data.

For example:

name → "Ali"
age  → 18

The important thing to understand is that Python variables do not work exactly like boxes in every other programming language. A Python variable is better understood as a reference to an object.

For example:

x = 10

Python creates an integer object representing 10, and x refers to that object.

If you later write:

x = 20

x is reassigned to another integer object.

This simple concept becomes important when you learn about objects, memory, mutability, and references.

---

2. Creating a Python Variable

Creating a variable in Python is extremely simple.

You use the assignment operator =:

name = "Khayyam"
age = 18
country = "Pakistan"

The general syntax is:

variable_name = value

For example:

score = 95

Here:

• score is the variable name.

• = is the assignment operator.

• 95 is the value.

You do not need to declare the variable's type separately.

In languages with static typing, you might need something like:

int age = 18;

Python allows:

age = 18

Python automatically determines that 18 is an integer.

---

3. Python Uses Dynamic Typing

One of Python's important features is dynamic typing.

This means that you do not have to explicitly declare a variable's data type.

Consider:

x = 10

Python understands that x refers to an integer.

Now:

x = "Hello"

The same variable name can now refer to a string.

You can even write:

x = 3.14

Now x refers to a floating-point number.

This is possible because Python variables are dynamically typed.

Example

data = 100
print(data)

data = "Python"
print(data)

data = 3.14
print(data)

Output:

100
Python
3.14

The variable name stayed the same, but the object it referred to changed.

---

4. Assignment Is Not the Same as Equality

Beginners sometimes confuse = with mathematical equality.

In Python:

x = 10

means:

Assign the value 10 to the variable x.

It does not mean that x and 10 are mathematically equal in the same sense as an equation.

Python uses == to compare values.

For example:

x = 10

print(x == 10)

Output:

True

So remember:

=   → assignment
==  → comparison

This distinction is extremely important.

---

5. Rules for Naming Python Variables

Python variable names must follow certain rules.

A variable name can contain:

• Letters

• Numbers

• Underscores

However, there are restrictions.

Rule 1: A variable cannot start with a number

This is invalid:

1name = "Ali"

This is valid:

name1 = "Ali"

A number can appear after the first character.

---

Rule 2: Variable names cannot contain spaces

This is invalid:

first name = "Ali"

Use an underscore instead:

first_name = "Ali"

---

Rule 3: Variable names are case-sensitive

Python treats uppercase and lowercase letters as different.

For example:

age = 18
Age = 20
AGE = 25

These are three different variables.

Therefore:

print(age)
print(Age)
print(AGE)

can produce:

18
20
25

---

Rule 4: Do not use Python keywords

Python has reserved words that have special meanings.

Examples include:

if
else
for
while
class
def
return
import
True
False
None

You should not use these as variable names.

For example:

class = 10

is invalid.

---

6. Good Variable Naming

Python allows many names, but not every legal name is good programming practice.

For example:

x = 500

is technically valid.

But:

student_count = 500

is much easier to understand.

Good variable names describe the data they contain.

Instead of:

a = 500

prefer:

number_of_students = 500

Instead of:

p = 2500

prefer:

product_price = 2500

Clear variable names make programs easier to read, debug, and maintain.

---

7. Python Naming Convention: snake_case

Python programmers commonly use snake_case for variable names.

Examples:

first_name = "Ali"
last_name = "Khan"
total_price = 1500
student_age = 18
number_of_users = 100

Words are separated with underscores.

This is preferred over:

firstname
firstName
FirstName

for ordinary Python variables.

---

8. Printing Variables

You can display the value of a variable using print().

name = "Ali"

print(name)

Output:

Ali

You can print multiple variables:

name = "Ali"
age = 18

print(name)
print(age)

You can also combine them:

name = "Ali"
age = 18

print("Name:", name)
print("Age:", age)

Output:

Name: Ali
Age: 18

Python also supports f-strings:

name = "Ali"
age = 18

print(f"My name is {name} and I am {age} years old.")

F-strings are one of the easiest ways to insert variable values into text.

---

9. Python Data Types

A data type describes the kind of value an object represents.

Python has many built-in data types.

Some of the most important are:

Data Type	Example
int	10
float	3.14
complex	2 + 3j
str	"Hello"
bool	True
list	[1, 2, 3]
tuple	(1, 2, 3)
set	{1, 2, 3}
dict	{"name": "Ali"}
NoneType	None

Python's type system allows you to work with many different kinds of information.

---

10. Integer Data Type: int

An integer is a whole number without a decimal component.

Examples:

age = 18
score = 95
temperature = -5
population = 1000000

All of these are integers.

You can perform mathematical operations with integers.

a = 10
b = 5

print(a + b)
print(a - b)
print(a * b)
print(a / b)

Python's / operator produces a floating-point result.

For integer division, Python provides //.

print(10 // 3)

Output:

3

You can also calculate a remainder using %:

print(10 % 3)

Output:

1

---

11. Floating-Point Data Type: float

A floating-point number contains a decimal component.

Examples:

price = 99.99
height = 1.75
temperature = 36.5
pi = 3.14159

The type of these values is float.

You can check it with:

price = 99.99

print(type(price))

Output:

<class 'float'>

Floats are widely used for measurements, scientific calculations, percentages, and many other applications.

However, floating-point arithmetic can sometimes produce tiny precision differences because computers represent many decimal values approximately in binary.

For example:

print(0.1 + 0.2)

You may see:

0.30000000000000004

This is not simply a Python mistake. It comes from how floating-point numbers are represented by computers.

For applications requiring exact decimal arithmetic, Python provides tools such as the decimal module.

---

12. Complex Numbers

Python also supports complex numbers.

A complex number contains a real part and an imaginary part.

For example:

z = 2 + 3j

Here:

• 2 is the real part.

• 3j is the imaginary part.

You can access them:

z = 2 + 3j

print(z.real)
print(z.imag)

Output:

2.0
3.0

Complex numbers are useful in areas such as mathematics, engineering, physics, and signal processing.

Most beginner Python programs do not require them, but they are an important part of Python's numeric capabilities.

---

13. String Data Type: str

A string is a sequence of characters.

Examples:

name = "Ali"
message = "Hello Python"
country = "Pakistan"

Strings can contain letters, numbers, spaces, and symbols.

For example:

text = "Python 2026!"

The entire value is still a string.

You can use single quotes:

name = 'Ali'

or double quotes:

name = "Ali"

Both are valid.

---

14. String Operations

Python provides many operations for working with strings.

For example:

first_name = "Ali"
last_name = "Khan"

full_name = first_name + " " + last_name

print(full_name)

Output:

Ali Khan

The + operator joins strings.

This is called concatenation.

You can also repeat strings:

text = "Hi "

print(text * 3)

Output:

Hi Hi Hi

---

15. String Indexing

Strings are sequences, which means individual characters can be accessed using indexes.

Consider:

word = "Python"

The indexes are:

P y t h o n
0 1 2 3 4 5

You can access a character:

print(word[0])

Output:

P

And:

print(word[3])

Output:

h

Python also supports negative indexing.

print(word[-1])

Output:

n

The index -1 refers to the last character.

---

16. String Slicing

You can extract part of a string using slicing.

word = "Python"

print(word[0:3])

Output:

Pyt

The general form is:

string[start:end]

The starting position is included, while the ending position is normally excluded.

You can also use:

print(word[:3])

or:

print(word[3:])

Slicing is extremely useful when processing text.

---

17. Boolean Data Type: bool

A Boolean value represents one of two logical states:

True
False

For example:

is_student = True
is_admin = False

Booleans are heavily used in decision-making.

For example:

age = 18

print(age >= 18)

Output:

True

You can use Boolean values with conditional statements:

age = 18

if age >= 18:
    print("Eligible")

The condition produces a Boolean result.

---

18. Lists

A list stores multiple values in a single object.

Example:

fruits = ["apple", "banana", "orange"]

A list can contain different types:

data = ["Ali", 18, 3.14, True]

Lists are:

• Ordered

• Mutable

• Indexed

• Able to contain duplicate values

You can access an item:

fruits = ["apple", "banana", "orange"]

print(fruits[0])

Output:

apple

---

19. Modifying Lists

Lists are mutable, meaning their contents can be changed.

For example:

fruits = ["apple", "banana", "orange"]

fruits[1] = "mango"

print(fruits)

Output:

['apple', 'mango', 'orange']

You can add an item:

fruits.append("grape")

You can remove an item:

fruits.remove("apple")

Lists are extremely useful when you need a collection of values that may change during program execution.

---

20. Tuples

A tuple is another collection type.

Example:

coordinates = (10, 20)

Tuples are ordered like lists but are generally immutable.

For example:

colors = ("red", "green", "blue")

You can access values:

print(colors[0])

But you cannot normally replace an element:

colors[0] = "yellow"

This produces an error because tuples cannot be modified in that way.

Tuples are useful for collections of values that should remain unchanged.

---

21. Sets

A set is an unordered collection of unique elements.

Example:

numbers = {1, 2, 3, 4}

Sets automatically eliminate duplicate values.

For example:

numbers = {1, 2, 2, 3, 3, 4}

print(numbers)

The duplicate values are represented only once.

Sets are particularly useful when you need uniqueness or mathematical set operations.

For example:

a = {1, 2, 3}
b = {3, 4, 5}

print(a | b)

The | operator performs a union.

---

22. Dictionaries

A dictionary stores data as key-value pairs.

Example:

student = {
    "name": "Ali",
    "age": 18,
    "grade": 10
}

Here:

name  → Ali
age   → 18
grade → 10

You can access a value using its key:

print(student["name"])

Output:

Ali

Dictionaries are one of Python's most important data structures.

They are useful for representing structured information.

For example:

product = {
    "name": "Laptop",
    "price": 120000,
    "available": True
}

This is much more descriptive than storing the values in unrelated variables.

---

23. The None Value

Python has a special value called None.

It represents the absence of a value.

Example:

result = None

You can later assign a real value:

result = 100

None is commonly used when a value is not available yet.

For example:

user_name = None

This can indicate that the name has not been provided.

To check for None, use:

if user_name is None:
    print("No name available")

---

24. Checking a Variable's Type

Python provides the built-in type() function.

Example:

x = 100

print(type(x))

Output:

<class 'int'>

Another example:

name = "Ali"

print(type(name))

Output:

<class 'str'>

You can check different values:

print(type(10))
print(type(3.14))
print(type("Python"))
print(type(True))

This is especially useful when debugging programs.

---

25. Using isinstance()

Python also provides isinstance() for checking whether an object belongs to a particular type or class.

Example:

age = 18

print(isinstance(age, int))

Output:

True

You can also check strings:

name = "Ali"

print(isinstance(name, str))

Output:

True

isinstance() is often more useful than directly comparing the result of type() because it works naturally with inheritance and subclasses.

---

26. Type Conversion

Sometimes you need to convert one data type into another.

This is called type conversion or type casting.

For example:

age = "18"

Here age is a string, not an integer.

You can convert it:

age = int("18")

print(age)
print(type(age))

Now it is an integer.

---

Converting to Integer

Use int():

x = int("100")

You can also convert some floating-point values:

x = int(3.9)

print(x)

Output:

3

The decimal portion is discarded rather than rounded.

---

27. Converting to Float

Use float():

price = float("99.99")

print(price)

Now the value is a floating-point number.

You can also convert an integer:

x = float(10)

print(x)

Output:

10.0

---

28. Converting to String

Use str():

age = 18

message = "I am " + str(age)

print(message)

Without str(), Python would not allow you to concatenate an integer directly with a string using +.

You can also use f-strings, which usually make this easier:

age = 18

print(f"I am {age}")

---

29. Converting to Boolean

You can use bool() to convert values into Boolean values.

For example:

print(bool(1))
print(bool(0))

Output:

True
False

Many values are considered truthy or falsy in Python.

Examples of commonly falsy values include:

False
None
0
0.0
""
[]
{}
set()

Many non-empty or non-zero values are truthy.

Understanding truthiness becomes especially useful with if, while, and logical expressions.

---

30. Multiple Variable Assignment

Python allows you to assign multiple variables in one statement.

For example:

x, y, z = 10, 20, 30

Now:

x = 10
y = 20
z = 30

You can also assign the same value to multiple variables:

a = b = c = 0

All three variables refer to the value 0.

This can make some Python code shorter and easier to read.

---

31. Swapping Variables

Python makes variable swapping particularly simple.

Instead of using a temporary variable:

a = 10
b = 20

a, b = b, a

Now:

a = 20
b = 10

This is a useful example of Python's powerful multiple-assignment syntax.

---

32. Mutable vs Immutable Data Types

One of the most important concepts to understand after learning basic data types is the difference between mutable and immutable objects.

An immutable object cannot be changed after it has been created.

Common immutable types include:

• int

• float

• bool

• str

• tuple

Mutable objects can be changed.

Common mutable types include:

• list

• dict

• set

Consider a string:

name = "Python"

You cannot directly change one character of the string.

But with a list:

numbers = [1, 2, 3]
numbers[0] = 100

The list itself changes.

Understanding mutability becomes extremely important when working with functions and multiple references to the same object.

---

33. Variables and References

Python variables are references to objects.

Consider:

a = [1, 2, 3]
b = a

Both a and b refer to the same list object.

Therefore:

b.append(4)

print(a)

produces:

[1, 2, 3, 4]

Why?

Because a and b reference the same mutable list.

This behavior is different from simply copying the list.

To create a separate list, you could use:

b = a.copy()

Then changes to b will not modify the original list in the same way.

---

34. Variable Scope

A variable's scope determines where it can be accessed.

For example, a variable created outside a function generally has global scope:

name = "Ali"

def show_name():
    print(name)

show_name()

The function can access the global variable.

A variable created inside a function normally has local scope:

def test():
    age = 18
    print(age)

test()

The variable age exists locally inside the function.

Understanding scope becomes important as programs become larger.

---

35. Variables in Functions

Variables are frequently passed into functions.

For example:

def greet(name):
    print(f"Hello, {name}")

greet("Ali")

Here, name is a parameter.

When the function is called:

greet("Ali")

the string "Ali" is passed to the function.

Variables allow functions to work with changing data instead of fixed values.

---

36. Variables and User Input

Python's input() function allows programs to receive text from users.

Example:

name = input("Enter your name: ")

print(f"Hello, {name}")

One important detail is that input() returns a string.

For example:

age = input("Enter your age: ")

Even if the user types:

18

the resulting value is a string.

If you need an integer, convert it:

age = int(input("Enter your age: "))

This is a very common pattern in beginner Python programs.

---

37. Constants in Python

Python does not have a special built-in constant declaration keyword like some languages.

Instead, programmers commonly use uppercase variable names to indicate that a value should not be changed.

For example:

PI = 3.14159
MAX_USERS = 100
APP_NAME = "MyApp"

These names communicate the programmer's intention.

Python does not automatically prevent someone from changing them.

For example:

MAX_USERS = 200

is technically allowed.

The uppercase convention simply tells developers that the value is intended to remain constant.

---

38. Common Variable Mistakes

Beginners often make several mistakes with variables.

Mistake 1: Using a variable before assigning it

For example:

print(name)

name = "Ali"

Python raises an error because name has not been defined before it is used.

Correct:

name = "Ali"
print(name)

---

Mistake 2: Confusing = and ==

Incorrect:

if age = 18:

Correct:

if age == 18:

Remember:

=   assignment
==  comparison

---

Mistake 3: Mixing strings and numbers incorrectly

This can cause an error:

age = 18

print("Age: " + age)

Convert the number:

print("Age: " + str(age))

Or use an f-string:

print(f"Age: {age}")

---

Mistake 4: Using invalid names

This is invalid:

user-name = "Ali"

Python interprets - as an operator.

Use:

user_name = "Ali"

---

39. Choosing the Right Data Type

Choosing the correct data type is an important programming skill.

If you have one person's age:

age = 18

An integer is appropriate.

If you have a person's name:

name = "Ali"

A string is appropriate.

If you have a collection of products:

products = ["Laptop", "Phone", "Mouse"]

A list may be appropriate.

If you need to associate names with prices:

prices = {
    "Laptop": 120000,
    "Phone": 50000
}

A dictionary may be a better choice.

The best data structure depends on how the data will be used.

---

40. A Practical Python Example

Let's combine variables and different data types in one small program.

name = "Ali"
age = 18
height = 1.75
is_student = True

subjects = ["Math", "Python", "Physics"]

student = {
    "name": name,
    "age": age,
    "height": height,
    "is_student": is_student
}

print(student)
print(subjects)

This example demonstrates several concepts:

• name is a string.

• age is an integer.

• height is a float.

• is_student is a Boolean.

• subjects is a list.

• student is a dictionary.

Python allows these different data types to work together in the same program.

---

41. Variables in Real Python Applications

Variables are everywhere in real software.

A web application might have:

username = "Ali"
email = "ali@example.com"
logged_in = True

A game might use:

player_health = 100
player_score = 500
player_name = "Player1"

A data science program might use:

temperature = 36.7
measurements = [36.5, 36.7, 36.8]

An AI application could have:

model_name = "MyModel"
learning_rate = 0.001
batch_size = 32

Variables are therefore not just a beginner concept. They remain fundamental throughout Python programming.

---

42. Why Data Types Matter

Data types determine what operations can sensibly be performed on data.

For example:

x = 10
y = 20

print(x + y)

produces:

30

But:

x = "10"
y = "20"

print(x + y)

produces:

1020

Why?

Because the first example adds integers, while the second concatenates strings.

The same + operator can therefore behave differently depending on the objects involved.

This is an important feature of Python's object-oriented and dynamically typed nature.

---

43. Python Is Strongly Typed

Python is dynamically typed, but it is also strongly typed.

These are two different concepts.

Dynamic typing means you do not have to declare a variable's type in advance.

Strong typing means Python generally does not silently combine incompatible types in arbitrary ways.

For example:

age = 18

print("Age: " + age)

causes a TypeError.

Python expects you to explicitly convert the integer:

print("Age: " + str(age))

This helps prevent many confusing operations.

---

44. Type Hints

Although Python is dynamically typed, modern Python also supports type hints.

For example:

age: int = 18
name: str = "Ali"
price: float = 99.99

Type hints tell readers and development tools what type of value is expected.

They do not turn Python into a traditionally statically typed language.

You can also use type hints with functions:

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

Type hints can make larger Python projects easier to understand and maintain.

---

45. Variables and Memory

When you create a variable:

x = 100

Python creates or uses an object representing the integer value and makes x refer to it.

You can inspect object identity using id():

x = 100

print(id(x))

The exact number is implementation-dependent and can change between executions.

The important idea is that variables refer to objects in memory.

This object-reference model becomes especially important with mutable data structures.

---

46. Best Practices for Python Variables

Follow these practices to write cleaner Python code.

Use descriptive names

Prefer:

total_price = 500

over:

x = 500

when the meaning is important.

Use snake_case

student_name = "Ali"

Avoid unnecessary abbreviations

Instead of:

usr_cnt = 50

consider:

user_count = 50

Keep variable names readable

Avoid extremely long or confusing names unless the context requires them.

Avoid overwriting built-in names

Do not casually use names such as:

list
str
int
input
sum

as your own variable names.

For example:

list = [1, 2, 3]

can make the built-in list() function inaccessible through that name later in the same scope.

---

47. A Complete Example

Here is a small program that demonstrates variables, data types, lists, dictionaries, input, and calculations:

name = input("Enter your name: ")
age = int(input("Enter your age: "))

next_year_age = age + 1

subjects = ["Python", "Math", "Computer Science"]

student = {
    "name": name,
    "age": age,
    "next_year_age": next_year_age,
    "subjects": subjects
}

print("\nStudent Information")
print("-------------------")
print(f"Name: {student['name']}")
print(f"Age: {student['age']}")
print(f"Next year: {student['next_year_age']}")
print(f"Subjects: {student['subjects']}")

This relatively small program demonstrates how different Python concepts work together.

The user's name is stored as a string.

The age is converted from the string returned by input() into an integer.

A calculation produces another integer.

A list stores multiple subjects.

A dictionary organizes the student's information.

This is how fundamental Python concepts gradually combine to create useful programs.

---

48. Variables and Data Types: Quick Reference

Here is a quick reference for the most important built-in types:

# Integer
age = 18

# Float
price = 99.99

# Complex
number = 2 + 3j

# String
name = "Ali"

# Boolean
is_active = True

# List
fruits = ["apple", "banana"]

# Tuple
coordinates = (10, 20)

# Set
numbers = {1, 2, 3}

# Dictionary
user = {
    "name": "Ali",
    "age": 18
}

# None
result = None

You can check any object's type with:

print(type(age))

---

49. Frequently Asked Questions

What is a variable in Python?

A variable is a name that refers to an object or value in a Python program.

Example:

name = "Ali"

Here, name refers to the string "Ali".

Do Python variables need a declared type?

No. Python uses dynamic typing, so you normally do not have to declare the type separately.

Can a Python variable change its type?

Yes.

x = 10
x = "Python"

The variable name can be reassigned to an object of another type.

What are Python's main data types?

Important built-in types include integers, floats, complex numbers, strings, Booleans, lists, tuples, sets, dictionaries, and NoneType.

How do I check a variable's type?

Use:

type(variable)

For example:

print(type(10))

What is the difference between a list and a tuple?

Lists are mutable, while tuples are generally immutable.

What is None?

None represents the absence of a value.

What is type conversion?

Type conversion means changing a value from one type to another, such as converting a string into an integer with int().

---

To fully understand this topic, we recommend reading the previous lesson first. It explains the core concepts that this article builds upon.

 Read the previous article here:
https://khayyamshah2007.blogspot.com/2026/08/jupyter-notebook-restart-kernel-guide.html

---

Conclusion

Python variables are one of the most fundamental concepts in programming. They allow programs to store, reference, manipulate, and organize information.

A simple statement such as:

age = 18

introduces several important ideas: assignment, objects, references, and data types.

Python's dynamic typing makes variable creation simple:

name = "Ali"
age = 18
price = 99.99

At the same time, Python provides a powerful collection of built-in data types, including:

• int

• float

• complex

• str

• bool

• list

• tuple

• set

• dict

• NoneType

Learning when and why to use each type is more important than simply memorizing their names.

As you progress, concepts such as mutability, object references, scope, type conversion, and type hints will help you understand how Python works at a deeper level.

Once you understand variables and data types, you have a strong foundation for learning the next major Python concepts: operators, conditional statements, loops, functions, classes, modules, exceptions, file handling, and object-oriented programming.

The key is to practice. Create variables, change their values, inspect their types, put different objects into lists and dictionaries, and experiment with Python's behavior. The more you work with data, the more naturally Python's variable and type system will become.