{"title":"Input & Output","description":"","content":"Most programs do two things: take some input from the outside world and write some output back. This lesson covers Python's two built-ins for that job, `input()` and `print()`, and the parameters that let you control exactly what goes where.\n\n---\n\n# Reading Input with `input()`\n\n`input()` pauses the program, waits for the user to type something and press Enter, then returns whatever they typed as a **string**. Always a string. Even if they type a number.\n\n\n```python\nname = input(\"What's your name? \")\nprint(\"Welcome,\", name)\n```\n\n\n**Sample run:**\n\n\n```shell\nWhat's your name? Alex\nWelcome, Alex\n```\n\n\nThe argument to `input()` is the prompt: any text you want shown before the cursor. A trailing space in the prompt (`\"What's your name? \"`) keeps the user's input visually separated from the question.\n\n`input()` is the synchronous, blocking version. The program stops dead until Enter is pressed. There's no timeout, no default value, no validation. Whatever the user types is what you get back.\n\nIf the user presses Enter without typing anything, you get an empty string `\"\"`, not `None`. That's a real result, not an error, and you have to handle it yourself if it matters.\n\n---\n\n# `input()` Always Returns a String\n\nThis is the single most common beginner trap with `input()`. Watch:\n\n\n```python\nquantity = input(\"How many items? \")\ntotal = quantity * 19.99\nprint(total)\n```\n\n\n**Sample run:**\n\n\n```shell\nHow many items? 3\nTraceback (most recent call last):\n File \"...\", line 2, in \n total = quantity * 19.99\n ~~~~~~~~~^~~~~~~\nTypeError: can't multiply sequence by non-int of type 'float'\n```\n\n\nPython doesn't crash because multiplication is broken. It crashes because `quantity` is the string `\"3\"`, not the number `3`, and you can't multiply a string by a float. You have to convert the input to the type you actually need. The built-ins `int()` and `float()` do that:\n\n\n```python\nquantity = int(input(\"How many items? \"))\ntotal = quantity * 19.99\nprint(f\"Total: ${total:.2f}\")\n```\n\n\n**Sample run:**\n\n\n```shell\nHow many items? 3\nTotal: $59.97\n```\n\n\n`int(input(...))` is so common you'll see it everywhere. The same pattern works for `float()` when prices or weights are involved:\n\n\n```python\nprice = float(input(\"Enter the price: \"))\nprint(\"Price with tax:\", price * 1.1)\n```\n\n\n**Sample run:**\n\n\n```shell\nEnter the price: 19.99\nPrice with tax: 21.989\n```\n\n\nThe flow looks like this:\n\n\n```mermaid\nflowchart LR\n A[User types text
and presses Enter]:::cyan --> B[input returns
a string]:::orange\n B --> C{Convert?}:::orange\n C -->|Yes| D[int or float
or other type]:::green\n C -->|No| E[Use as string]:::teal\n D --> F[Use in program]:::green\n E --> F\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n```\n\n\nIf the user types something that can't be converted (`int(\"hello\")`), you'll get a `ValueError`. Handling that gracefully needs `try`/`except`. For now, assume reasonable input.\n\n---\n\n# Printing with `print()`\n\nYou've already used `print()` in earlier lessons. Here's its full signature:\n\n\n```python\nprint(*objects, sep=' ', end='\\n', file=sys.stdout, flush=False)\n```\n\n\nThat looks dense, but each piece is straightforward. `*objects` means you can pass as many arguments as you want. The other four are keyword parameters with defaults: a space between arguments, a newline at the end, output goes to standard output, and the output buffer isn't flushed immediately. The next sections walk through each one.\n\nThe simplest case prints a single value:\n\n\n```python\nprint(\"Welcome to MyShop\")\n```\n\n\nMultiple arguments get separated by a space and joined into a single line:\n\n\n```python\nprint(\"Order:\", 3, \"items\", \"at\", 19.99, \"each\")\n```\n\n\n`print()` automatically converts every argument to its string form, so mixing strings, integers, and floats is fine. You don't need to call `str(...)` on numbers first.\n\n---\n\n# The `sep` Parameter\n\n`sep` controls what `print()` puts between its arguments. It defaults to `' '` (a single space).\n\n\n```python\nprint(\"Wireless Mouse\", \"USB Cable\", \"HDMI Cable\")\nprint(\"Wireless Mouse\", \"USB Cable\", \"HDMI Cable\", sep=\", \")\nprint(\"Wireless Mouse\", \"USB Cable\", \"HDMI Cable\", sep=\" | \")\nprint(\"Wireless Mouse\", \"USB Cable\", \"HDMI Cable\", sep=\"\")\n```\n\n\n`sep=\"\"` removes the separator entirely. `sep=\", \"` is handy for producing comma-separated output without manually adding commas. `sep=\"\\n\"` puts each argument on its own line, which is one quick way to print a list across multiple lines:\n\n\n```python\nprint(\"Mouse\", \"Keyboard\", \"Monitor\", sep=\"\\n\")\n```\n\n\n`sep` only applies between the arguments you pass in a single `print()` call. It has nothing to do with what happens between calls.\n\n---\n\n# The `end` Parameter\n\n`end` controls what `print()` writes *after* all the arguments. It defaults to `'\\n'` (a newline), which is why each `print()` call moves the cursor to the next line.\n\n\n```python\nprint(\"Loading\")\nprint(\"Done\")\n```\n\n\nChange `end` to keep multiple calls on the same line:\n\n\n```python\nprint(\"Loading\", end=\"\")\nprint(\"...\", end=\"\")\nprint(\"Done\")\n```\n\n\nThe first two calls write text with no newline at the end, so the third call continues on the same line. The third call uses the default `end=\"\\n\"`, so the cursor moves down after it.\n\nA common use is building progress indicators or formatted lists across multiple iterations. You can also use `end=\" \"` to separate calls with a space instead of a newline:\n\n\n```python\nprint(\"Order\", end=\" \")\nprint(\"status:\", end=\" \")\nprint(\"shipped\")\n```\n\n\nOr use `end=\"\\t\"` to separate with tabs, which is useful for quick tabular output.\n\n---\n\n# Brief Intro to f-strings\n\nYou'll see `f\"...\"` strings used throughout this course. They are Python's most readable way to embed values inside text, and they're worth a quick introduction here. The Strings section covers the full formatting language, including alignment, padding, and number precision.\n\nThe basic shape is a string literal prefixed with `f`, with expressions inside curly braces:\n\n\n```python\nproduct = \"Wireless Mouse\"\nprice = 19.99\nquantity = 3\n\nprint(f\"{quantity} x {product} = ${price * quantity:.2f}\")\n```\n\n\nAnything inside `{...}` is evaluated as a Python expression. You can include variables, arithmetic, method calls, anything that produces a value. The `:.2f` part is a format specifier that rounds the number to two decimal places.\n\nWithout f-strings, you'd write the more verbose:\n\n\n```python\nprint(quantity, \"x\", product, \"=\", \"$\" + str(round(price * quantity, 2)))\n```\n\n\nThe f-string version is cleaner, faster, and easier to read. It's the default formatting tool in modern Python (added in Python 3.6).\n\nTwo more useful tricks for quick debugging:\n\n\n```python\ntotal = 64.96\nprint(f\"{total=}\")\n```\n\n\nThe `=` after the variable name prints both the name and the value, which is handy when you're debugging and want to know what a variable holds without retyping its name. This was added in Python 3.8.\n\nYou can also embed multi-token expressions:\n\n\n```python\nprices = [19.99, 4.99, 14.99]\nprint(f\"Sum: ${sum(prices):.2f}\")\nprint(f\"Items: {len(prices)}\")\n```\n\n\nThat's enough f-string for now. The Strings section goes much deeper into format specifiers (width, alignment, sign handling, thousands separators, datetime formatting). For the rest of this section, just remember that `f\"...{value}...\"` swaps in the value of `value`.\n\n---\n\n# Reading Multiple Inputs\n\nSometimes you need more than one value from the user. The straightforward way is one `input()` call per value:\n\n\n```python\nproduct = input(\"Product name: \")\nprice = float(input(\"Price: \"))\nquantity = int(input(\"Quantity: \"))\n\ntotal = price * quantity\nprint(f\"Order: {quantity} x {product} = ${total:.2f}\")\n```\n\n\n**Sample run:**\n\n\n```shell\nProduct name: Wireless Mouse\nPrice: 19.99\nQuantity: 3\nOrder: 3 x Wireless Mouse = $59.97\n```\n\n\nEach `input()` prompts and waits separately. The user types one value, presses Enter, and the next prompt appears.\n\nIf you want to read several values from a single line, use the `split()` method on the input string. `split()` breaks the string apart on whitespace and returns a list:\n\n\n```python\nparts = input(\"Enter product, price, quantity: \").split()\nprint(parts)\n```\n\n\n**Sample run:**\n\n\n```shell\nEnter product, price, quantity: Mouse 19.99 3\n['Mouse', '19.99', '3']\n```\n\n\nYou can then unpack the list into named variables:\n\n\n```python\nproduct, price_str, quantity_str = input(\"Product price quantity: \").split()\nprice = float(price_str)\nquantity = int(quantity_str)\nprint(f\"{quantity} x {product} at ${price} each\")\n```\n\n\n**Sample run:**\n\n\n```shell\nProduct price quantity: Headphones 49.99 2\n2 x Headphones at $49.99 each\n```\n\n\nTwo things are happening here. `input().split()` produces a list of three strings. The line `product, price_str, quantity_str = ...` is **iterable unpacking**: Python assigns each list element to the matching name on the left. If the user types too few or too many words, you'll get a `ValueError`, which we'll handle properly in the Exception Handling section.\n\nIf you need a different separator, pass it to `split()`. For comma-separated values:\n\n\n```python\nparts = input(\"Comma-separated names: \").split(\",\")\nprint(parts)\n```\n\n\n**Sample run:**\n\n\n```shell\nComma-separated names: Alex, Sam, Riley\n['Alex', ' Sam', ' Riley']\n```\n\n\nNotice the leading spaces in `' Sam'` and `' Riley'`. `split(\",\")` only splits on commas and doesn't trim surrounding whitespace. To clean each piece, use a list comprehension or process each value as you use it.\n\nFor now, when you want both comma separation and clean tokens, the common pattern is:\n\n\n```python\nraw = input(\"Comma-separated names: \")\nnames = [n.strip() for n in raw.split(\",\")]\nprint(names)\n```\n\n\n**Sample run:**\n\n\n```shell\nComma-separated names: Alex, Sam, Riley\n['Alex', 'Sam', 'Riley']\n```\n\n\nThat's a preview of list comprehensions. Don't worry about the syntax yet, the Lists section explains it from scratch.\n\n---\n\n# Where Output Goes: The `file` Parameter\n\nBy default, `print()` writes to **standard output** (often shown as `stdout`), which is the terminal where your script is running. The `file` parameter lets you redirect that output somewhere else.\n\nThe most common alternative destination is **standard error** (`stderr`), a separate output stream meant for diagnostic messages, warnings, and errors. The reason it matters: when someone runs your script and pipes the output somewhere else (`python script.py > results.txt`), only `stdout` goes into the file. `stderr` still shows up on the terminal.\n\nTo write to `stderr`, import `sys` and pass `sys.stderr` as the `file`:\n\n\n```python\nimport sys\n\nprint(\"Order received\", file=sys.stdout)\nprint(\"WARNING: low stock\", file=sys.stderr)\n```\n\n\nWhen run normally, both messages look identical. The difference shows up when output is redirected. Run that script as `python script.py > results.txt`, and `results.txt` will only contain `Order received`, while `WARNING: low stock` still shows up in the terminal. That separation is the whole point: regular output goes to the file, warnings stay visible to the operator.\n\nYou can also write to an open file object. For now, the rule of thumb is simple: send regular output to `stdout` (the default), and send diagnostic messages to `stderr`.\n\n\n> **INFO**\n>\n> **Cost:** `print()` with `file=sys.stderr` is just as fast as the default. The cost difference comes from where the message ends up, not from any extra work Python has to do.\n\n\n---\n\n# The `flush` Parameter\n\nThis one matters less day-to-day, but it's good to know it exists. `flush=False` by default. When `True`, Python forces the output buffer to write immediately instead of waiting.\n\nWhy is there a buffer in the first place? Writing to a terminal one character at a time is slow at scale. Python buffers output and writes it in chunks, which is much faster. The downside: if your program crashes or runs in an unusual environment (some IDEs, redirected output, piped processes), buffered output can appear out of order or not at all.\n\n\n```python\nimport time\n\nprint(\"Working\", end=\"\", flush=True)\nfor _ in range(3):\n time.sleep(0.5)\n print(\".\", end=\"\", flush=True)\nprint(\" done\")\n```\n\n\nWithout `flush=True`, the `Working` and the dots might all appear at once at the end, since the buffer wouldn't be written until the newline at the end. With `flush=True`, each piece shows up immediately. Use `flush=True` when you're printing progress indicators or doing something where the timing of output visibility matters.\n\nFor most application code, you can leave `flush` at its default.\n\n---\n\n# Putting It Together\n\nHere's a tiny order summary program that uses every piece from this lesson: reading input, converting types, splitting multiple values from one line, using f-strings for output, and sending a warning to `stderr`.\n\n\n```python\nimport sys\n\nname = input(\"Customer name: \")\nitems_in_stock = 5\n\nproduct, price_str, quantity_str = input(\"Product price quantity: \").split()\nprice = float(price_str)\nquantity = int(quantity_str)\n\nif quantity > items_in_stock:\n print(f\"WARNING: only {items_in_stock} in stock\", file=sys.stderr)\n quantity = items_in_stock\n\ntotal = price * quantity\n\nprint()\nprint(f\"Order for {name}\")\nprint(f\"{quantity} x {product} @ ${price:.2f} = ${total:.2f}\")\n```\n\n\n**Sample run:**\n\n\n```shell\nCustomer name: Alex\nProduct price quantity: Headphones 49.99 8\nWARNING: only 5 in stock\nOrder for Alex\n5 x Headphones @ $49.99 = $249.95\n```\n\n\nWe won't worry about the `if` statement yet (Control Flow covers conditionals properly), but you can see the shape of a complete tiny program: prompt the user, convert what comes back, do something with it, and print results plus diagnostics on the right streams.\n\n---\n\n# Summary\n\n- `input()` always returns a `str`. Convert to `int`, `float`, or another type before using the value in arithmetic.\n- `input()` blocks until the user presses Enter. An empty input gives an empty string, not `None`.\n- `print()` accepts any number of arguments and converts each one to its string form automatically.\n- `sep` controls what goes between arguments (default: single space). `end` controls what goes after all arguments (default: newline).\n- f-strings (`f\"{value}\"`) are the standard way to embed values inside output.\n- Use `split()` to read several values from one line of input. `split()` returns a list of strings, which you can unpack into named variables.\n- `file=sys.stderr` sends output to the diagnostic stream instead of the normal one. Useful for warnings and errors that should stay visible even when stdout is redirected.\n- `flush=True` forces output to appear immediately. Default buffering is faster, but visibility matters for progress indicators.\n\nNow that you can read input and write output, the next lesson, _Comments & Docstrings_, covers how to leave notes in your code for your future self and your teammates.","pageType":"python"}

Input & Output

Get Premium