Learn What a Variable Type is in Python: Absolute Beginners Tutorial

Every value in Python has a type. When you write name = "Ada", Python sees a string. When you write score = 95, Python sees an integer. Understanding variable types is the starting point for writing code that behaves the way you expect it to, because the type of a value determines what operations you can perform on it.

If you have written even one line of Python, you have already used variable types. The number 42 is an int. The text "hello" is a str. The value True is a bool. Python assigns these types automatically when you create a variable, and the type travels with the value everywhere it goes. This tutorial walks through what that means, why it matters, and how to work with types in your own code.

What is a Variable Type?

A variable type is the classification Python gives to a piece of data. It tells Python what the data represents and what you can do with it. You can add two integers together, but you cannot add an integer to a string without converting one of them first. The type is what enforces those rules.

In Python, you never have to write a type declaration. There is no int x = 5; like you would see in Java or C. Instead, you just write x = 5, and Python figures out that 5 is an integer. This behavior is called dynamic typing -- the type is determined at runtime based on the value you assign, not by a declaration you write in advance.

age = 30            # int — a whole number
price = 19.99       # float — a decimal number
name = "Ada"        # str — a text string
active = True       # bool — True or False

print(type(age))     # <class 'int'>
print(type(price))   # <class 'float'>
print(type(name))    # <class 'str'>
print(type(active))  # <class 'bool'>

The type() function is your primary tool for inspecting types. It takes any value or variable as an argument and returns the class that value belongs to. Every single value in Python is an object, and every object has a type. There are no exceptions to this rule.

A common misconception is that the variable itself has a type. In Python, the value has the type, not the variable name. The name x is just a label pointing to whatever object you last assigned to it. When you reassign x to a different value, the label moves to the new object, and the old object's type has not changed -- only the label moved.

Python's Built-in Types at a Glance

Python ships with a set of built-in types that cover the data you will work with in nearly every program. You do not need to import anything to use them. They are available the moment Python starts running. Here is a tour of the ones you will encounter first as a beginner.

Numeric Types: int and float

Integers (int) represent whole numbers with no decimal point. Python integers have no fixed size limit -- they can grow as large as your system's memory allows. Floats (float) represent numbers with a decimal point and are stored as double-precision floating-point numbers, which means they are accurate to about 15 decimal places.

count = 42              # int
temperature = 98.6      # float
big_number = 10 ** 100  # int — Python handles this fine

# Mixing int and float produces a float
result = count + temperature
print(type(result))     # <class 'float'>

Text Type: str

Strings (str) hold sequences of characters. You can define them with single quotes, double quotes, or triple quotes for multi-line text. Strings are immutable, meaning you cannot change individual characters in place -- you create a new string instead.

greeting = "Hello, world"
language = 'Python'
bio = """This is a
multi-line string."""

print(type(greeting))   # <class 'str'>
print(len(greeting))    # 12

Boolean Type: bool

Booleans (bool) represent one of two values: True or False. They are the result of comparison operations and the backbone of conditional logic. In Python, bool is a subclass of int, where True equals 1 and False equals 0.

Collection Types: list, tuple, dict, and set

These types hold groups of values. A list is an ordered, mutable sequence. A tuple is an ordered, immutable sequence. A dict maps keys to values. A set holds unique, unordered elements. Each one is designed for a different use case, and choosing the right collection type for the job is a skill you will develop over time.

colors = ["red", "green", "blue"]     # list
point = (10, 20)                       # tuple
user = {"name": "Ada", "age": 30}      # dict
unique_ids = {101, 102, 103}           # set

print(type(colors))      # <class 'list'>
print(type(point))       # <class 'tuple'>
print(type(user))        # <class 'dict'>
print(type(unique_ids))  # <class 'set'>

Checking and Converting Types

Knowing a variable's type is useful, but the real power comes from being able to check types in your code and convert between them when needed. Python gives you two main tools for checking types and a set of built-in functions for converting them.

type() vs isinstance()

You already know type() returns the exact class of a value. The related function isinstance() checks whether a value belongs to a given type and returns True or False. The key difference is that isinstance() also recognizes subclass relationships. Since bool is a subclass of int, isinstance(True, int) returns True, while type(True) == int returns False.

value = 3.14

# type() — returns the exact class
print(type(value))               # <class 'float'>
print(type(value) == float)      # True

# isinstance() — checks class and subclasses
print(isinstance(value, float))  # True
print(isinstance(value, (int, float)))  # True — checks multiple types

# Where they differ: bool is a subclass of int
print(type(True) == int)         # False
print(isinstance(True, int))    # True

Type Casting with Built-in Functions

When you need a value in a different type, Python's built-in casting functions handle the conversion. The four you will use often are int(), float(), str(), and bool(). Each one creates a new object of the target type from the input value.

# str to int
user_input = "42"
number = int(user_input)
print(number + 8)       # 50

# int to float
whole = 7
decimal = float(whole)
print(decimal)           # 7.0

# float to int (truncates, does not round)
pi = 3.99
truncated = int(pi)
print(truncated)         # 3

# int to str
age = 25
label = "Age: " + str(age)
print(label)             # Age: 25

# Truthiness — bool() on common values
print(bool(0))           # False
print(bool(1))           # True
print(bool(""))          # False
print(bool("hello"))    # True
print(bool([]))          # False
print(bool([1, 2]))     # True

"In Python, everything is an object." — Python documentation, Data Model chapter

Python Learning Summary Points

1. A variable type is the classification Python gives to a value -- it determines what operations are valid. Python assigns types automatically at runtime through dynamic typing, so you never write type declarations.
2. The core built-in types you will use as a beginner are int, float, str, bool, list, tuple, dict, and set. Use type() to inspect them and isinstance() for conditional checks in your code.
3. Python provides casting functions like int(), float(), str(), and bool() to convert between types. Not every conversion is valid, so always validate your data before casting to avoid runtime errors.

Variable types are one of the first things to understand when learning Python, and they stay relevant at every level of complexity. The patterns you build now -- checking types with type() and isinstance(), converting between types with casting functions, and understanding which operations each type supports -- will serve you in every Python project you write going forward.