Data Types in Python

Want to understand data types in Python? Every value you hand Python gets classified the instant you create it — a number does not sit on the same shelf as a word, and a list does not live where single values live. Those shelves are Python's data types.

This page covers the built-in types you will meet constantly — int, float, str, bool, list, tuple, dict, set — plus the two ideas that organize them: primitive vs non-primitive and mutable vs immutable. Pair it with Types, Values, and Errors for how type() works, and Variables for how names attach to these values.

What you will learn

By the end you can:

• Name Python's core built-in data types and what each one is for
• Tell primitive types (int, float, bool, str) from non-primitive ones (list, tuple, set, dict)
• Explain mutable vs immutable and why it matters
• Pick the right container: list vs tuple vs set vs dict
• Use type() to confirm what you actually created

We are not covering type casting (int(), str() conversions) or custom classes yet — those get their own pages. This is the map of what Python ships with by default.

Why data types exist

Python needs to know three things about every value: what operations are allowed on it, how much memory to use, and how it should behave. The same symbol can mean different things depending on type — + adds numbers but joins strings.

Numbers: values that can be calculated

Integers — whole and steady

count = 10
temperature = -5

print(type(count))
# <class 'int'>

No decimals, no fractions. Python calls these integers.

Floating-point numbers — numbers that slide

pi = 3.14159
gravity = 9.8

print(type(pi))
# <class 'float'>

Numbers with decimal points are stored using floating-point representation.

Strings: values that speak

name = "ada"
print(type(name))
# <class 'str'>

Quotes matter — without them, Python assumes you are naming a variable. Strings can contain letters, numbers, symbols, and even spaces, but Python treats all of it as text, not math.

Booleans: yes or no, nothing else

is_active = True
is_logged_in = False

print(type(is_active))
# <class 'bool'>

Booleans have exactly two possible values. They quietly power decisions, conditions, and logic everywhere in a program.

Lists: many things, one name

marks = [85, 90, 78]
names = ["Alice", "Bob", "Charlie"]

print(type(marks))
# <class 'list'>

A list groups values under one name. Lists can hold multiple values, mix data types, and be changed after creation.

Tuples: lists that don't change

coordinates = (10, 20)
print(type(coordinates))
# <class 'tuple'>

Tuples look like lists but behave differently. Once created, a tuple cannot be modified — use them when safety and consistency matter.

Dictionaries: meaning over position

student = {
    "name": "Ravi",
    "age": 20,
    "branch": "CSE"
}

print(type(student))
# <class 'dict'>

A dictionary stores key–value pairs. You do not ask where a value lives — you ask what it is called.

Sets: uniqueness matters

unique_ids = {101, 102, 103}
print(type(unique_ids))
# <class 'set'>

A set is a collection of unique values — duplicates are automatically removed. Sets are useful when presence matters more than order.

Python never forgets what type a value is, no matter how you inspect it:

print(type(42))     # <class 'int'>
print(type("42"))   # <class 'str'>
print(type([42]))   # <class 'list'>

Primitive vs non-primitive data types

Some values are simple. Some values are built from other values. That is the difference between primitive and non-primitive data types.

Primitive types — the building blocks

Primitive types represent one clear, atomic idea:

• int — whole numbers
• float — decimal numbers
• bool — True or False
• str — text (internally complex, but behaves like a single value)

age = 20
price = 99.99
is_student = True
name = "Aditya"

Each variable here refers to one single value — you do not logically break it into smaller meaningful parts.

Non-primitive types — collections and structures

Non-primitive types are built from multiple values: they can store many elements, organize data, and represent more complex structures. Common ones: list, tuple, set, dict.

marks = [85, 90, 78]
coordinates = (10, 20)
unique_ids = {101, 102, 103}
student = {"name": "Ravi", "age": 20}

Mutable vs immutable — what can change

Python has two kinds of values: flexible ones, and ones fixed once created.

Immutable (non-mutable)

Imagine carving something in stone — once written, you cannot edit it; to get something different, you carve a new stone. An immutable value cannot be changed after creation. Any "modification" actually creates a new object.

• int
• float
• bool
• str
• tuple

Mutable

Now imagine writing with a pencil — you can erase, add, and modify the same page repeatedly. A mutable value can change after creation without becoming a new object.

• list
• dict
• set

Immutable objects protect stability. Mutable objects allow flexibility. Good programming means knowing which one a situation needs.

Quick reference: all built-in types at a glance

Common mistakes

• Forgetting quotes and accidentally naming a variable instead of writing a string
• Expecting a tuple to accept item reassignment like a list
• Assuming dict key order does not matter for equality or display
• Using a list when a set would remove needed duplicate-checking work
• Confusing str's immutability with lists being similarly protected

Why this matters

Every bug involving "wrong" behavior traces back to a type you did not expect. Knowing the shelf a value sits on — primitive or structured, mutable or fixed — is what lets you predict how your program will behave before you run it.