Input with `input()` — always returns string, conversion needed: Worked examples

The scenario matrix

Before any code, let's list every distinct situation the same line int(input(...)) or float(input(...)) can land in. Think of this as the full map — each worked example below fills exactly one cell.

Cell	User types	Converter	What happens
A — clean whole number	`42`	`int()`	works → `42`
B — clean decimal	`3.14`	`float()`	works → `3.14`
C — negative sign	`-7`	`int()`	works → `-7` (sign kept)
D — surrounding spaces	`9`	`int()`	works → `9` (spaces trimmed)
E — zero / degenerate	`0` or empty	`int()`	`0` works; empty crashes
F — decimal into `int()`	`3.5`	`int()`	crashes (`ValueError`)
G — letters (garbage)	`twenty`	`int()`	crashes (`ValueError`)
H — forgot to convert	`3` then `4`	none	`+` joins → `"34"` (wrong)
I — word problem	mixed	`float`/`int`	real calculation
J — exam twist	tricky mix	you decide	reason it out

The three big axes here are: (1) which converter matches the meaning (whole vs decimal), (2) sign and whitespace (does the text survive cleaning?), and (3) does the text even look like a number at all (or does it crash?). The picture below shows those three axes as a decision funnel.

Figure — Input with `input()` — always returns string, conversion needed

Now let's fill every cell.

Case A — the clean whole number

Worked example Cell A —

int() on a tidy integer

age = int(input("Enter your age: "))   # user types 42
print(age + 8)

Forecast: what prints — 428, 50, or a crash? Decide before reading on.

Steps:

input(...) returns the string "42". Why this step? Because input() always returns text — the golden rule from the parent note. Nothing is a number yet.
int("42") reads the characters '4' and '2' and builds the whole number 42. Why this step? int() is the tool that answers "what integer does this text spell?" We use int (not float) because an age is a whole count — no half-years wanted.
age + 8 is now 42 + 8 — real arithmetic. Why this step? Once age is an int, the + sign switches from "join text" to "add numbers." Same symbol, different job depending on type (see Operators in Python).

Verify: $42 + 8 = 50$ . Prints 50. If you guessed 428, you were imagining + still joining strings — but we converted, so that trap is gone.

Case B — the clean decimal

Worked example Cell B —

float() on a decimal

price = float(input("Price: "))   # user types 3.14
print(price * 2)

Forecast: 6.28, 3.143.14, or crash?

Steps:

input() → the string "3.14".
float("3.14") builds the decimal number 3.14. Why float and not int? Because there's a decimal point in the meaning. int() would refuse this text (that's Cell F). float is the tool for "numbers that can have a fractional part." (Deep dive: Type Conversion (Casting).)
price * 2 is 3.14 * 2 — arithmetic multiply.

Verify: $3.14 \times 2 = 6.28$ . Prints 6.28. ✓ (Note: real floats can print tiny rounding dust like 6.28000000001 for some values — here it's exact enough.)

Case C — the negative sign survives

Worked example Cell C —

int() keeps the minus sign

temp = int(input("Temperature (°C): "))   # user types -7
print(temp + 10)

Forecast: does int() choke on the -? What prints?

Steps:

input() → the string "-7" (three characters: '-', '7'... actually two: '-' and '7').
int("-7") → -7. Why this works: int() explicitly understands a leading sign. A - (or +) at the very front is part of "what a whole number looks like." So the sign is preserved, not stripped.
temp + 10 → -7 + 10.

Verify: $- 7 + 10 = 3$ . Prints 3. ✓ Every sign is covered: positive (Case A), negative (here), and zero (Case E next).

Case D — spaces around the number

Worked example Cell D — whitespace is forgiven

n = int(input("Enter n: "))   # user types "   9   " (spaces before and after)
print(n * 3)

Forecast: does the space break int()? Crash, 9, or 27?

Steps:

input() → " 9 " — the string literally contains spaces.
int(" 9 ") → 9. Why this works: int() trims surrounding whitespace before reading digits. Leading/trailing spaces are ignored. (But spaces between digits, like "9 9", would crash — that's garbage, Cell G.)
n * 3 → 9 * 3.

Verify: $9 \times 3 = 27$ . Prints 27. ✓

Case E — zero and the degenerate empty input

This cell has two sub-cases because "nothing typed" is the true edge of the map.

Worked example Cell E1 — zero is a perfectly good number

count = int(input("Count: "))   # user just types 0
print(count + 1)

Forecast: is 0 special? Crash or 1?

Steps:

input() → "0".
int("0") → 0. Zero is an ordinary integer; nothing degenerate about it to int().
0 + 1 = 1.

Verify: $0 + 1 = 1$ . Prints 1. ✓

Worked example Cell E2 — the truly empty input (degenerate limit)

x = int(input("Number: "))   # user presses Enter without typing

Forecast: what does int("") do?

Steps:

input() → "" — the empty string, zero characters.
int("") → crashes with ValueError: invalid literal for int() with base 10: ''. Why: int() needs at least one digit to read. An empty string spells no number at all — this is the degenerate limit where there's nothing to convert.

Verify (conceptually): empty is not 0; empty is absence of a number. Guard it with Exceptions and try-except:

try:
    x = int(input("Number: "))
except ValueError:
    print("Please type a whole number.")

Case F — a decimal fed to `int()`

Worked example Cell F — the classic wrong-converter crash

x = int(input("Enter: "))   # user types 3.5

Forecast: 3, 4, or crash?

Steps:

input() → "3.5".
int("3.5") → crashes ValueError. Why (subtle!): int() does not round or truncate a string — it demands the text spell a whole number. "3.5" contains a ., which is not part of a whole-number spelling, so it refuses. Contrast: int(3.5) (on a float, not a string) → 3 (truncates). But int("3.5") (on a string) crashes. The . in text is the killer.

Verify: the correct tool here is float: float("3.5") → 3.5. If you truly want the integer part, do int(float("3.5")) → 3.

Look at the picture below — it shows the two-hop route str → float → int that survives a decimal, versus the direct str → int road that hits a wall.

Case G — letters and garbage

Worked example Cell G — text that isn't a number at all

n = int(input("How many? "))   # user types "twenty"

Forecast: does Python understand English number words?

Steps:

input() → "twenty".
int("twenty") → crashes ValueError: invalid literal for int() with base 10: 'twenty'. Why: int() reads digit characters (0–9) plus an optional sign — not English words. "twenty" is letters; no digit to be found.

Verify (guarded version):

raw = input("How many? ")
try:
    n = int(raw)
    print("Got", n)
except ValueError:
    print(raw, "is not a whole number.")

For "twenty" this prints twenty is not a whole number. — no crash. This is the production-safe pattern; see Exceptions and try-except.

Case H — forgetting to convert (the flagship bug)

Worked example Cell H —

+ joins instead of adding

a = input("First: ")    # user types 3
b = input("Second: ")   # user types 4
print(a + b)

Forecast: 7 or something else?

Steps:

a = "3", b = "4" — both strings, no conversion happened.
a + b = "3" + "4". Why this joins: for two strings, + means concatenate — glue them end to end. The characters '3' and '4' sit next to each other.

Verify: "3" + "4" = "34". Prints 34, not 7. To fix: print(int(a) + int(b)) → 7.

This is the single most common beginner trap — you now know why the type, not the digits, decides what + does.

Case I — the word problem (real-world mix)

Worked example Cell I — shopping cart total

Statement: A shop asks for the item price (may have cents), the quantity (whole items), and a discount percent (may be fractional, like 12.5). Compute the final amount paid.

price    = float(input("Price per item: "))   # 19.99
qty      = int(input("Quantity: "))           # 3
discount = float(input("Discount %: "))        # 10
subtotal = price * qty
final    = subtotal * (1 - discount / 100)
print("Pay:", round(final, 2))

Forecast: with 19.99, 3, 10 — what's the final amount?

Steps:

price = float("19.99") → 19.99. Why float? money has cents — a fractional part. int would crash on the ..
qty = int("3") → 3. Why int? you can't buy half an item; quantity is a whole count.
discount = float("10") → 10.0. Why float? discounts can be 12.5\%; using float keeps it flexible even when the user types a whole 10.
subtotal = 19.99 * 3 = 59.97.
final = 59.97 * (1 - 10/100) = 59.97 * 0.9. Why divide by 100? 10\% means "10 per hundred" = 0.10. 1 - 0.10 = 0.90 keeps 90% of the price.

Verify (units too): dollars × count = dollars; dollars × (unitless fraction) = dollars ✓. $59.97 \times 0.9 = 53.973 \to round \to 53.97$ . Prints Pay: 53.97. ✓

Case J — the exam-style twist

Worked example Cell J — spot the type at every line

Statement: Predict the exact output. The user types 5 then 2.

x = input("a: ")      # 5
y = int(input("b: ")) # 2
print(x * y)

Forecast: 10, 52, 55, or crash? This one is nasty — think about the type of each operand.

Steps:

x = "5" — a string (no conversion on line 1).
y = 2 — an int (converted on line 2).
x * y = "5" * 2. Why this is legal and NOT a crash: string * int is defined in Python — it repeats the string int times! "5" * 2 = "55". (This is different from "ab" * "3" in the parent note, which crashes because that's str * str.)

Verify: "5" * 2 = "55". Prints 55. Not 10 (that would need both to be numbers), not 52. The lesson: str * int = repeat, int * int = multiply. Type decides the operation. See Operators in Python.

Master recall

Connections

Parent topic — the golden rule this page stress-tests.
Type Conversion (Casting) — the str → float → int two-hop of Case F.
String Concatenation vs Arithmetic — why Case H prints 34.
Exceptions and try-except — guarding Cases E2 and G.
Operators in Python — why Case J's str * int repeats.
Variables and Data Types — the str/int/float triad behind every cell.
print() Function — the output side of all examples.