Type Conversion

Why would a value need to change set?

You type a birth year into a form. Python’s input() hands you back a string, "2004". But "2004" is not a number in any arithmetic sense: try "2004" + 26 and Python answers "200426", because to a string + means join, not add.

You hold the digits of a number without the number. The set it belongs to is wrong. A value that crossed from the keyboard into a program arrives as text, and text cannot do arithmetic.

So a program constantly needs to convert a value from one set to another: from str to int before computing a year, from int to str before printing alongside a label. Python gives you four functions for this, one per target set.

Four conversion functions

Each is named after the set it produces:

int("42")       # 42     — str -> int   "42" was digits, now it's a number
float("3.14")   # 3.14   — str -> float
str(42)         # "42"   — int -> str    the number becomes text
bool(0)         # False  — number -> truth value

Reading these out loud says what they are: str(42) is “give me the string version of $42$”. The function name is the name of the target set, and the parentheses are the conversion machine itself.

Conversion does not round, it truncates

Now a subtlety that costs beginners real bugs. You want the whole part of $3.9$. What should the answer be?

The natural instinct is to round: $4$. Python’s int(3.9) instead returns $3$:

int(3.9)        # 3   — the decimal part is chopped off, not rounded
round(3.9)      # 4   — this is rounding

int() truncates: it discards the fractional part and keeps what remains, moving toward zero. The difference shows up once numbers go negative:

int(-3.9)       # -3  — toward zero
import math
math.floor(-3.9)  # -4 — toward negative infinity

The number line settles it: truncation walks toward $0$, math.floor walks down (toward $-\infty$), and round walks to the nearest integer. Choose the one that matches what you meant by “the whole part”.

Some conversions must fail

Crossing from one set to another is not always possible. Which of these can you picture working?

int("hello")    # ValueError: invalid literal for int()
int("3.14")     # ValueError: invalid literal for int()  ("3.14" is digits with a dot)
float("hello")  # ValueError: could not convert string to float

"hello" contains no digits at all, nothing to convert, so Python refuses. int("3.14") is trickier: it has digits, but the conversion function int accepts only a whole literal, and 3.14 is not whole. You must pass through float if you want to shrink it:

int(float("3.14"))   # 3  — parse 3.14, truncate to 3

Notice the philosophy: Python fails loudly rather than guessing what you meant. A silent guess would corrupt your data; a loud error stops the program so you decide.

The daily trap: input() returns a string

Every single time, input() returns a str, even when the user types 2004. The number you wanted is still on the other side of a conversion:

year_text = input("Birth year? ")   # str, always
year = int(year_text)                # now it can do arithmetic
print(f"About {2026 - year} years old")

Forgetting the conversion is one of the most common early bugs, and here is exactly what forgetting looks like:

age = input("Age? ")
print(age + 1)    # TypeError: can only concatenate str (not "int") to str

The error is the machine being honest: age sits in $\mathbb{S}$ (strings), and + with a string does not mean addition. The lesson is a habit: if a value came from the outside, convert it before doing math with it.

A worked example: the cut-off measurement

A sensor reports "3.9" as text, and a display shows whole units only. Two conversions, one intention each:

raw = "3.9"
numeric = float(raw)     # 3.9 — parse the real number
whole = int(numeric)     # 3   — truncate toward zero
print(f"{whole} units")  # 3 units — the .9 is chopped, not rounded

The funnel matters because each step is a different promise: float(...) turns text into a real value, int(...) then chops toward zero, and you never ask one function to do both. Say which promise you mean and the conversion stops surprising you.

Common pitfalls

• int("3.14") raises an error. You cannot parse a float string straight into int(). Shrink it by hand: int(float("3.14")), or round(float("3.14")).
• int() truncates, round() rounds. int(4.7) is 4, not 5. Ask yourself which operation you actually describe when you say “convert this to an integer.”
• float("inf") is valid. Python knows infinity: float('inf'). Handy in optimization algorithms, startling when it slips into a result you expected to be finite.
• int() and bool() truncate and reinterpret silently. int(3.9) quietly chops the fraction; bool("") quietly returns False. Parsing text fails loudly (ValueError), but number-to-number conversions are quiet, those are the ones to double-check.