Python Lesson 5: User Input & Output — input(), f-strings & Your First Interactive Program

Introduction

Every program you've written so far has been a monologue — it runs, prints something, and ends. It never listens. Real software isn't like that. Command-line tools ask for a filename. Signup forms ask for an email. Even a simple tip calculator needs to know the bill amount before it can do anything useful.

This is the lesson where your Python programs start listening. You'll learn input(), the function that pauses execution and waits for a human to respond, and you'll learn why it hands you back something you probably weren't expecting: plain text, always, no matter what the user typed.

This distinction — that input is always a string — is one of the most common sources of bugs for beginners, and it also shows up in technical interviews. Interviewers frequently ask candidates to parse and validate user-supplied input before processing it, because it tests whether you understand that data doesn't arrive in the shape you want by default. You have to shape it yourself.

By the end of this lesson you'll be able to read data from a user, safely convert it into numbers, and print it back out in clean, professional-looking output using f-strings — the same formatting tool used throughout production Python codebases today.

Problem Overview

Strip away the code and the task is simple: get a program to hold a two-way conversation with whoever is running it.

That breaks into three smaller problems:

1. Reading input — pause the program, show the user a prompt, and capture whatever they type.
2. Converting types — turn that captured text into a usable number when the situation calls for math.
3. Formatting output — take variables and turn them into a readable, well-structured sentence or report.

Get all three right, and you have the foundation for practically any interactive command-line program: calculators, quizzes, form validators, small games, data-entry tools — all of it is built from this same read → convert → compute → print rhythm.

Example

name = input("What's your name? ")
print(f"Hello, {name}!")

If the user types Kai and presses Enter:

What's your name? Kai
Hello, Kai!

Nothing surprising there — name holds the text "Kai", and the f-string drops it into the greeting.

Now the interesting case:

age = input("How old are you? ")
print(age + 1)

If the user types 25, this crashes:

TypeError: can only concatenate str (not "int") to str

Even though 25 looks like a number on the screen, Python stored it as the string "25". You can't add an integer to a string, so this line fails. Fix it by converting explicitly:

age = int(input("How old are you? "))
print(age + 1)

Now age is a real integer, and age + 1 correctly produces 26.

Intuition

Think about what input() is actually doing under the hood: it's reading raw keystrokes from a terminal. A terminal doesn't know or care whether the user typed a name, a number, or an equation — it only knows how to send characters. So Python makes a deliberate, consistent choice: input() always returns a str, full stop, no exceptions. That consistency is a feature, not a limitation — it means you never have to guess what type you're getting back.

The job of turning that text into something you can compute with belongs to you, using int() or float(). Picture it as a small pipeline: raw keystrokes go in on the left as text, pass through a converter function in the middle, and come out the other side as a genuine number you can add, subtract, or compare.

This two-step separation — read as text, then convert deliberately — is actually a good design pattern that shows up everywhere in software: never trust incoming data to already be in the shape you need. Validate and convert it at the boundary, before it touches your business logic. input() teaches that habit from day one.

Once you have real numbers, formatting the result back into human-readable text is the second half of the puzzle. f-strings solve this by letting you write your sentence exactly as it should read, with variables dropped directly into place using curly braces — no error-prone string concatenation, no counting %s placeholders.

Brute Force Solution

There isn't really a "brute force" algorithm here in the traditional sense, but there is a clumsier way to do output formatting that's worth naming so you can recognize why f-strings are better.

Idea: Build the output string by concatenating pieces together with +.

name = input("What's your name? ")
age = int(input("How old are you? "))
print("Hello, " + name + "! You are " + str(age) + " years old.")

Algorithm: Manually stitch each variable into the surrounding text using +, remembering to wrap non-string values in str() first.

Advantages:

• Works in every version of Python, no special syntax needed.
• Conceptually simple — it's just string addition.

Disadvantages:

• Every non-string value needs an explicit str() wrapper, or you get a TypeError.
• Hard to read once you have more than two or three variables.
• Easy to miss a space or lose track of quote marks.
• No built-in way to control number formatting (like rounding to 2 decimal places) without extra function calls.

Time complexity: O(n) where n is the total length of the final string — same as any approach, since you must produce every character.

Space complexity: O(n) for the resulting string, plus temporary intermediate strings created at each + operation, which the f-string approach avoids.

Optimal Solution

The optimal approach uses f-strings for output and explicit type conversion for input. Here's the shape of it:

Step	Action	Tool
1	Show a prompt, wait for the user	input("...")
2	Convert text to a number (if needed)	int(...) or float(...)
3	Do any computation	normal operators
4	Build a clean output string	f-string with {}
5	Display the result	print(...)

The key insight is that steps 1 and 2 are often combined into a single line — you wrap the entire input() call in int() so the conversion happens immediately, before the text value ever gets a chance to be misused:

birth_year = int(input("What year were you born? "))

For output, an f-string lets you embed the expression {value} directly inside the string, and even apply formatting instructions right there using a colon, like {price:.2f} to round a decimal to two places.

print() also gives you two extra dials that most beginners never learn:

• sep — controls what's inserted between multiple printed items (default is a space).
• end — controls what's printed after everything (default is a newline).

print("2024", "07", "21", sep="-")        # 2024-07-21
print("Loading", end="...")               # stays on the same line
print("done")

Python Code

def run_interactive_intro() -> None:
    """Ask for a name and birth year, then greet the user with their age."""
    name = input("What's your name? ")
    birth_year = int(input("What year were you born? "))

    current_year = 2026
    age = current_year - birth_year

    print(f"Hello, {name}! You are approximately {age} years old.")


def tip_calculator() -> None:
    """Read a bill amount and tip percentage, then print the total."""
    bill = float(input("What was the bill amount? $"))
    tip_percent = float(input("What percentage would you like to tip? "))

    tip_amount = bill * (tip_percent / 100)
    total = bill + tip_amount

    print(f"Tip: ${tip_amount:.2f} | Total: ${total:.2f}")


if __name__ == "__main__":
    run_interactive_intro()
    tip_calculator()

Code Walkthrough

• input("What's your name? ") displays the prompt text and pauses execution until the user presses Enter, returning whatever they typed as a str.
• int(input(...)) chains two calls together: input() runs first and returns text, then int() immediately converts that text into an integer. If the user types something non-numeric, this line raises a ValueError.
• current_year - birth_year is ordinary integer subtraction — this only works because birth_year was converted to an int in the previous line, not left as a string.
• f"Hello, {name}! You are approximately {age} years old." is an f-string: the f prefix right before the opening quote tells Python to evaluate anything inside {} and substitute the result into the string.
• float(input(...)) follows the same pattern as int(), but produces a decimal number — necessary here because bill amounts and percentages aren't whole numbers.
• {tip_amount:.2f} is an f-string format specifier: .2f means "format as a fixed-point decimal with 2 digits after the point," which is exactly what you want for currency.
• The if __name__ == "__main__": guard ensures these functions only run when the file is executed directly, not when imported elsewhere — standard practice in any real Python codebase.

Dry Run

Trace tip_calculator() with the user typing 50 for the bill and 20 for the tip percentage:

Step	Expression	Value
1	input("What was the bill amount? $")	"50" (string)
2	float("50")	50.0
3	input("What percentage...? ")	"20" (string)
4	float("20")	20.0
5	tip_percent / 100	0.2
6	bill * 0.2	10.0
7	bill + tip_amount	60.0
8	`f"Tip: ${tip_amount:.2f}	Total: ${total:.2f}"`

Final printed output: Tip: $10.00 | Total: $60.00

Complexity Analysis

• Time complexity: O(1) for the arithmetic itself — a fixed number of operations regardless of input size. Reading input and formatting output are O(k) where k is the length of the typed or printed string, which is effectively constant for typical use.
• Space complexity: O(1) beyond the input string itself — you're storing a handful of scalar variables (name, bill, tip_percent, tip_amount, total), not a growing data structure.

These are the correct bounds because nothing in this program loops over a collection or recurses — it's a straight-line sequence of read, convert, compute, and print operations.

Alternative Solutions

The .format() method works everywhere f-strings do syntactically but is more verbose:

print("Tip: ${:.2f} | Total: ${:.2f}".format(tip_amount, total))

It's still seen in older codebases and is worth recognizing, but for new code, f-strings are strictly better: shorter, easier to read, and just as fast.

The % formatting style is a holdover from Python 2 that behaves like C's printf:

print("Tip: $%.2f | Total: $%.2f" % (tip_amount, total))

You'll encounter this in legacy code and some logging libraries, but don't write it fresh — it's harder to read and easier to get wrong with multiple values.

Command-line arguments (via sys.argv or the argparse module) are an alternative to input() entirely — values are supplied when the program starts rather than requested interactively. This suits automation and scripting where no human is present to answer prompts, but it's the wrong tool when a person is directly using your program.

Edge Cases

• Empty input: pressing Enter with nothing typed gives input() an empty string "". Converting that with int("") raises a ValueError.
• Non-numeric text where a number is expected: int("twenty") raises ValueError: invalid literal for int() with base 10: 'twenty'.
• Leading/trailing whitespace: int(" 25 ") actually succeeds — int() strips whitespace automatically — but comparing raw strings like name == "Kai " would fail unexpectedly if you forget to .strip() text input.
• Very large numbers: Python's int has no fixed size limit (unlike many languages), so extremely large input numbers won't overflow — but float still has standard floating-point precision limits.
• Negative numbers: int(input(...)) handles a typed -5 correctly, but if your logic assumes only positive values (like an age), you'll want to validate that separately.

Common Mistakes

1. Forgetting to convert input before doing math. input() always returns a string, so age + 1 on unconverted input either crashes or silently misbehaves.
2. Multiplying a string instead of a number. "5" * 3 doesn't triple the value five — it produces "555", since Python interprets * on a string as repetition.
3. Forgetting the f prefix on an f-string. Without it, "{name}" prints the literal curly braces instead of substituting the variable.
4. Not handling ValueError when the user types something unexpected. A production program should wrap conversions in a try/except rather than letting the whole program crash.
5. Confusing int() and float(). Using int() on a value like "19.99" raises a ValueError — decimal-looking text needs float().
6. Assuming sep and end only take spaces or newlines. They accept any string, including empty ones (end=""), which is useful for building output on a single line.

Interview Questions

• How would you validate that user input is a positive integer before using it?
• What's the difference between int() and float() when converting a string like "3.0"?
• How would you handle a ValueError gracefully instead of crashing the program?
• Why does Python force input() to always return a string rather than guessing the type?
• How would you rewrite this program to keep prompting until the user provides valid input?
• What's the difference in behavior between input() and reading from sys.argv?

Similar Problems

• LeetCode 8: String to Integer (atoi) — directly tests manual string-to-number conversion logic, the same core idea behind why int() can fail on malformed input.
• LeetCode 65: Valid Number — reinforces understanding of what does and doesn't count as a valid numeric string.
• LeetCode 415: Add Strings — builds intuition for treating digit characters as data rather than assuming they behave like numbers.
• LeetCode 6: ZigZag Conversion — a good follow-up for practicing string formatting and construction logic beyond simple f-strings.

Key Takeaways

• input() pauses your program and always returns a string — no exceptions, ever.
• Convert with int() or float() before doing arithmetic on user input.
• f-strings (f"...") are the modern, readable way to format output in Python; prefer them over .format() or % formatting in new code.
• print()'s sep and end parameters give you fine control over spacing and line breaks.
• The rhythm behind almost every interactive program: read, convert, compute, print.

Watch the Video

For the full walkthrough with live demonstrations of every mistake and fix covered here, watch the video: {LINK}

About the Series

This lesson is part of the Daily Python LeetCode series — a daily, beginner-friendly walk through Python fundamentals and interview-style problem solving, one concept at a time. Each lesson builds directly on the last, so today's input() and f-string skills will show up again the moment we start reading user-driven problems and formatting solutions in upcoming lessons.

Call To Action

If this helped things click, subscribe on YouTube so you don't miss tomorrow's lesson, and subscribe to the Substack newsletter for the written breakdown delivered straight to your inbox. Drop a comment with your tip calculator once you've built it — and share this with anyone starting their Python journey.

---

name = input("Name? ")
birth = int(input("Birth year? "))
age = 2026 - birth
print(f"Hi {name}, you are about {age}.")

# Name? Mia
# Birth year? 2000
# Hi Mia, you are about 26.