Type Casting in Python

Imagine walking into a bank with dollars, but the shop next door only accepts euros. Your money is still money — it just needs to be converted before it can be used. That is exactly what type casting in Python is: converting a value from one data type into another so an operation actually works.

Sometimes Python converts types for you automatically. Sometimes it refuses to guess, and you must convert explicitly. This page covers both, plus every common casting function and the errors you will hit along the way. It builds directly on Data Types in Python.

What you will learn

• The difference between implicit and explicit casting
• How to convert between int, float, str, and bool
• Why some conversions raise TypeError or ValueError
• Python's truthiness rules when casting to bool
• Why int() truncates instead of rounding

Implicit casting — when Python decides

This happens automatically. When Python sees two different numeric types combined in one expression, it promotes the smaller type to the larger one so no information is lost.

x = 5        # int
y = 2.0      # float

result = x + y
print(result)
print(type(result))
# 7.0
# <class 'float'>

x was an integer, y was a float. Python converted x into a float automatically because mixing int and float always produces a float. This is called implicit casting — Python made the decision, not you.

Explicit casting — when you decide

Sometimes Python refuses to guess what you mean:

age = "20"
print(age + 5)
# TypeError: can only concatenate str (not "int") to str

You are trying to add a string and an integer. Python does not assume what you meant — you must explicitly convert the type yourself using a casting function.

Converting to int — int()

age = "20"
age = int(age)

print(age + 5)
# 25

Now Python understands age as a number, so addition works.

Converting to float — float()

price = "99.99"
price = float(price)

print(price)
# 99.99

Converting to string — str()

score = 100
message = "Your score is " + str(score)

print(message)
# Your score is 100

Here an integer is converted into text so it can be joined with another string using +.

When casting fails

Python will not lie for you. If a conversion does not make logical sense, it raises an error instead of guessing:

int("Hello")
# ValueError: invalid literal for int() with base 10: 'Hello'

"Hello" cannot logically become a number, so Python raises a ValueError instead of silently producing garbage. Casting must always make sense.

Common casting functions

Casting to bool — Python's truthiness rules

bool(0)       # False
bool(1)       # True
bool("")      # False
bool("Hi")    # True

Python has rules for what counts as "truthy" and "falsy". Zero, empty strings, empty lists, and None are all falsy; almost everything else — including any non-empty string — is truthy.

A subtle example: int() truncates, it does not round

int(3.9)
# 3

int() does not round to the nearest whole number. It simply removes the decimal part — 3.9 becomes 3, not 4. If you need rounding, use the built-in round() function instead.

Common mistakes

• Trying to add a string and a number directly instead of casting first
• Assuming int() rounds — it truncates toward zero
• Calling int() on text that isn't a valid number and being surprised by ValueError
• Forgetting that bool("False") is True — any non-empty string is truthy, even the string "False"
• Relying on implicit casting between incompatible types like str and int, which Python will never do for you

Why this matters

Mastering type casting means fewer TypeErrors, cleaner data handling — especially with user input, which always arrives as a string — and better control over exactly how your program interprets values.