input() String Gotcha — Calculator Bug Gives Wrong Sum

Every useful program in the world does two things: it accepts information from somewhere, and it sends information somewhere else. Google takes your search query (input) and shows you results (output). A calculator takes numbers (input) and shows the answer (output). Without input and output, a program is just a silent machine locked in a room — it can't communicate with anything or anyone. That's why this is the very first real skill you need as a Python developer.

Before input and output, you could write code that calculated things internally, but you'd have no way to see results or respond to a user. You'd be flying blind. Python's built-in print() and input() functions solve this completely. They are the bridge between your code and the real world — the moment your program stops being a private monologue and starts becoming a conversation.

By the end of this article you'll know how to display any message or value to the screen using print(), how to ask a user for information with input(), how to format output cleanly using f-strings, and how to avoid the three classic mistakes that trip up almost every beginner. You'll be ready to build interactive programs from scratch.

Displaying Information with print() — Your Program's Voice

The print() function is how Python speaks to you. Every time you call it, Python takes whatever you put inside the parentheses and displays it in the terminal or console. It then automatically moves to a new line, ready for the next thing — like pressing Enter after you finish typing a sentence.

You can print plain text (called a string) by wrapping it in quotes. You can print numbers without any quotes at all. You can even print multiple things in one go by separating them with commas — Python will put a space between each item automatically.

Here's the thing beginners often miss: print() is a function, which means it does a job and you trigger it by writing its name followed by parentheses. Everything you want it to display goes inside those parentheses. That pair of parentheses is not optional — it's what actually runs the function. In older Python 2 code you might see print without parentheses, but in Python 3 (which is what everyone should be using) the parentheses are required.

# print() sends text or values to the terminal for the user to see

# Printing a simple text message — wrap text in quotes to make it a string
print("Hello! Welcome to TheCodeForge.")

# Printing a number — no quotes needed for numbers
print(42)

# Printing multiple items separated by commas — Python adds a space between them
print("Your score is:", 95, "out of 100")

# Printing a blank line — call print() with nothing inside to create spacing
print()

# Using the 'sep' argument to change what goes between items (default is a space)
print("2024", "01", "15", sep="-")  # Useful for formatting dates

# Using the 'end' argument to control what appears at the end of the line
# Default is a newline character. Here we replace it with a space.
print("Loading", end=" ")
print("complete!")  # This continues on the same line as 'Loading'

Getting Information with input() — Your Program's Ears

If print() is how your program talks, input() is how it listens. When Python hits an input() call, it pauses everything, displays a prompt message to the user, and waits — patiently — until the user types something and presses Enter. Whatever the user typed gets handed back to your program as a value you can store and use.

The message you put inside input() is the prompt — it's what tells the user what to type. Always write a clear, friendly prompt. 'Enter your name: ' is good. '' (nothing) is confusing — the program just freezes and the user has no idea why.

Here's the most important rule about input() that catches almost every beginner: it always returns a string. Always. Even if the user types 42, Python gives you back the text '42', not the number 42. This means if you want to do maths with what the user typed, you must convert it first using int() for whole numbers or float() for decimals. We'll see exactly how to do that in the code below.

# input() pauses the program and waits for the user to type something
# Whatever they type is returned as a STRING — remember this rule!

# Asking for the user's name — the string inside input() is the prompt they see
user_name = input("What is your name? ")

# Now user_name holds whatever the user typed, as a string
print("Nice to meet you,", user_name)

# Asking for a number — input() still returns a string here
raw_age = input("How old are you? ")

# We MUST convert it to an integer before we can do maths with it
# int() converts the string '25' into the actual number 25
user_age = int(raw_age)

# Now we can use it in a calculation
year_born = 2024 - user_age
print("You were born around the year", year_born)

# You can also do the conversion directly in one line (very common pattern)
favourite_number = int(input("Enter your favourite number: "))
print("Double your favourite number is:", favourite_number * 2)

Formatting Output Beautifully with f-strings

Concatenating strings with + signs gets messy fast. Imagine building a sentence like 'Hello Alex, you are 28 years old' by gluing variables and text together — you'd need to remember to convert numbers back to strings, add spaces carefully, and the code becomes hard to read. There's a much better way: f-strings.

An f-string (short for formatted string literal) lets you embed variables directly inside a string by prefixing the string with the letter f and wrapping variable names in curly braces {}. Python replaces {variable_name} with the actual value when the line runs. It handles the type conversion automatically — no need to call str() on numbers.

f-strings were introduced in Python 3.6 and are now the industry standard for formatting output. They're faster than the older .format() method, cleaner than concatenation, and far more readable. Senior developers use them constantly. Learn them early and use them always.

# f-strings: prefix the string with f, then put variable names inside {}
# Python swaps the {} placeholders with the actual variable values at runtime

player_name = "Jordan"
player_score = 4750
player_level = 12

# Basic f-string — clean, readable, no type conversion needed
print(f"Player: {player_name}")
print(f"Score: {player_score}")
print(f"Level: {player_level}")

print()  # blank line for spacing

# You can even do calculations inside the curly braces
best_possible_score = 5000
percentage = (player_score / best_possible_score) * 100
print(f"{player_name} achieved {percentage}% of the maximum score.")

# Controlling decimal places — :.2f means 'show 2 digits after the decimal point'
item_price = 4.5
quantity = 3
total_cost = item_price * quantity
print(f"Total cost: ${total_cost:.2f}")  # Shows 13.50, not 13.5

# Padding numbers for aligned columns — useful for receipts or tables
print(f"{'Item':<15} {'Qty':>5} {'Price':>8}")
print(f"{'Coffee':<15} {2:>5} {3.50:>8.2f}")
print(f"{'Muffin':<15} {1:>5} {2.75:>8.2f}")

Building a Real Interactive Program — Putting It All Together

Knowing print() and input() separately is like knowing how to hold a guitar and how to press a string — useful, but the music only happens when you combine them. Here we'll build a small, real program: a personal budget calculator. It takes user input, processes it, and displays a formatted summary.

This example shows you the natural rhythm of an interactive Python program: prompt the user, collect their input, convert it to the right type, do something useful with it, then display the result clearly. This exact pattern — input, process, output — is the foundation of almost every program ever written, from mobile apps to banking systems.

Read through the code carefully. Every line has a comment explaining its purpose. After reading this, try changing the program to also ask for the user's monthly income and calculate how much they're saving. That hands-on practice will make this stick.

# A simple monthly budget calculator
# Demonstrates input(), int()/float() conversion, f-strings and print() together

print("===== Monthly Budget Calculator =====")
print()  # blank line for visual breathing room

# Collect the user's name for a personalised experience
user_name = input("Enter your name: ")

# Collect financial figures — wrap with float() to allow decimal amounts like 1250.50
monthly_income = float(input("Enter your monthly income ($): "))
rent = float(input("Enter your monthly rent ($): "))
groceries = float(input("Enter your monthly grocery bill ($): "))
utilities = float(input("Enter your monthly utilities ($): "))

# Calculate totals — all values are now proper floats, so maths works correctly
total_expenses = rent + groceries + utilities
remaining_balance = monthly_income - total_expenses

# Calculate what percentage of income is spent on expenses
spending_percentage = (total_expenses / monthly_income) * 100

print()  # blank line before the summary
print("===== Budget Summary for", user_name, "=====")

# f-strings with :.2f formatting keep all dollar amounts to exactly 2 decimal places
print(f"  Monthly Income:    ${monthly_income:>10.2f}")
print(f"  Total Expenses:    ${total_expenses:>10.2f}")
print(f"  Remaining Balance: ${remaining_balance:>10.2f}")
print()
print(f"  You spent {spending_percentage:.1f}% of your income this month.")

# Give the user a personalised message based on their financial situation
if remaining_balance >= 0:
    print(f"  Great work, {user_name}! You stayed within your budget.")
else:
    print(f"  Heads up, {user_name} — you exceeded your budget this month.")

Debugging with print() – The 1 Tool Every Developer Uses

Print-debugging is the oldest trick in the book. When something goes wrong, you drop a print() statement to see what a variable holds or whether a code branch runs. It's quick, dirty, and surprisingly effective – especially when you're still learning and haven't set up a debugger.

But print-debugging has traps. Print too many things and the output becomes noise. Print in a loop with millions of iterations and your terminal freezes. Print with end='' and your lines get jumbled. And if you forget to remove a debug print before pushing to production, you'll leak internal data into logs.

Here's how to do it right: use print() with meaningful prefixes like DEBUG: or >>>. Use flush=True when you need immediate output. For loops, limit prints with a counter or condition. And always clean up debug prints before committing – or better, use Python's logging module for production code.

# Print-debugging done right – use patterns that help, not hinder

# 1. Add a clear prefix to separate debug output from normal output
def calculate_discount(price, discount_percent):
    print(f"DEBUG: price={price}, discount_percent={discount_percent}")
    discount = price * (discount_percent / 100)
    print(f"DEBUG: discount={discount}")
    return price - discount

# 2. Flush when you need the message immediately (e.g., before a crash)
print("About to do risky operation...", flush=True)

# 3. In loops, print only every Nth iteration to avoid flooding
import random
for i in range(1000000):
    if i % 10000 == 0:
        print(f"Processing item {i}...")
    # actual work here

# 4. Conditional debug prints
DEBUG_ENABLED = True  # toggle this to turn debug on/off
def process_user(user_input):
    if DEBUG_ENABLED:
        print(f"DEBUG: received input: {user_input}")
    # processing...