{"title":"f-Strings","description":"","content":"f-strings are Python's modern way to build strings out of values. They landed in Python 3.6 (PEP 498) and have been the default for new code since, because they're faster, shorter, and easier to read than the older `%` and `.format()` styles. This lesson covers what an f-string is, how the format spec inside the braces works, the debug shortcut `{x=}`, and the rules and pitfalls that govern their use.\n\n---\n\n# What an f-String Is\n\nAn f-string is a string literal prefixed with `f` (or `F`). Anything inside `{...}` is treated as a Python expression, evaluated, converted to a string, and dropped into the result:\n\n\n```python\nproduct = \"Wireless Mouse\"\nprice = 29.99\nquantity = 3\n\nprint(f\"Customer bought {quantity} {product} at ${price} each\")\n```\n\n\nThe rest of the string outside the braces is taken literally. The braces mark the holes where values get plugged in. No `str()` calls, no `+` operators, no juggling tuples of arguments. The variables sit where they appear in the sentence.\n\nCompare that to the alternatives. With `+` concatenation:\n\n\n```python\nprint(\"Customer bought \" + str(quantity) + \" \" + product + \" at $\" + str(price) + \" each\")\n```\n\n\nEvery non-string value needs `str()`. Every gap needs its own quoted space. The line gets noisy fast. With the older `.format()` method:\n\n\n```python\nprint(\"Customer bought {} {} at ${} each\".format(quantity, product, price))\n```\n\n\nBetter, but the placeholders sit in one place and the values in another, so reading requires bouncing between two locations. f-strings keep the values inline with the surrounding text.\n\nThe performance difference is measurable. The Python compiler turns each `{...}` in an f-string into a direct load-and-format instruction at parse time. There's no runtime parsing of a template string, no looking up positional arguments. For a single call the gap is microseconds, but in tight loops or hot code paths the f-string version is the fastest of the three formatting styles.\n\n---\n\n# Expressions, Not Just Variables\n\nThe contents of the braces don't have to be a plain variable name. They can be any Python expression that produces a value:\n\n\n```python\nunit_price = 19.99\nquantity = 4\ndiscount_rate = 0.10\n\nprint(f\"Subtotal: {unit_price * quantity}\")\nprint(f\"After discount: {unit_price * quantity * (1 - discount_rate)}\")\nprint(f\"Tax estimate: {unit_price * quantity * 0.08}\")\nprint(f\"Cart size: {quantity + 1}\")\n```\n\n\nMethod calls work too. So do attribute lookups, indexing, and conditional expressions:\n\n\n```python\nproducts = [\"Mouse\", \"Keyboard\", \"Monitor\"]\ncustomer_name = \"aarav mehta\"\n\nprint(f\"First product: {products[0]}\")\nprint(f\"Number of items: {len(products)}\")\nprint(f\"Customer: {customer_name.title()}\")\nprint(f\"Status: {'in stock' if len(products) > 0 else 'out of stock'}\")\n```\n\n\nA long arithmetic expression or a nested method call inside an f-string is harder to read than the same code split across two lines. Compute the value first, assign it to a variable with a clear name, then drop the variable into the f-string. Reserve inline expressions for short cases like indexing, simple arithmetic, or a single method call.\n\nf-strings are evaluated every time the line runs. A debug-level log call like `log.debug(f\"state={huge_dict}\")` builds the full string even when debug logging is turned off. For logging, use the `%`-style form the `logging` module supports, which defers formatting until the message gets emitted.\n\n---\n\n# The Format Spec After the Colon\n\nInside a placeholder, a colon introduces a **format spec**: a short mini-language that controls how the value gets rendered. The basic shape is:\n\n\n```shell\n{value:format_spec}\n```\n\n\nThe format spec sits after the colon and tells Python things like \"round to two decimal places\", \"pad to ten characters wide\", or \"show this as hexadecimal\". The full grammar is:\n\n\n```shell\n[[fill]align][sign][#][0][width][grouping][.precision][type]\n```\n\n\nEvery field is optional, and most format specs use only two or three at once. The fields appear in this order:\n\n\n```mermaid\nflowchart LR\n FILL[fill
any char]:::cyan --> ALIGN[align
< > ^]:::orange\n ALIGN --> SIGN[sign
+ - space]:::green\n SIGN --> ZERO[0
zero-pad]:::teal\n ZERO --> WIDTH[width
integer]:::cyan\n WIDTH --> GROUP[grouping
, or _]:::orange\n GROUP --> PREC[.precision
integer]:::green\n PREC --> TYPE[type
letter]:::teal\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\nThe fields used most often are width, precision, type, and grouping. The sections below cover each of them.\n\n### Precision for Floats\n\n`.N` after the colon controls the number of digits after the decimal point. This is the most useful format spec for displaying money:\n\n\n```python\nprice = 29.4567\ntotal = 1299.5\n\nprint(f\"${price:.2f}\")\nprint(f\"${price:.4f}\")\nprint(f\"${total:.2f}\")\nprint(f\"${total:.0f}\")\n```\n\n\nThe `f` after the precision is the **type code** for fixed-point. Without `f`, Python uses a default that can switch between scientific notation and fixed-point depending on the magnitude. Spelling out `f` keeps the output predictable.\n\nRounding follows Python's standard banker's rounding (halves go toward the nearest even digit). For most money work this is fine. For stricter financial rounding rules, use the `decimal` module rather than the format spec.\n\n### Width and Alignment\n\nA number on its own (or after a fill character and alignment marker) sets the minimum width. Strings default to left-aligned, numbers default to right-aligned:\n\n\n```python\nproduct = \"Mouse\"\nprice = 29.99\n\nprint(f\"|{product:15}|\")\nprint(f\"|{product:<15}|\")\nprint(f\"|{product:>15}|\")\nprint(f\"|{product:^15}|\")\nprint(f\"|{price:>10.2f}|\")\n```\n\n\nThe alignment markers are `<` for left, `>` for right, and `^` for center. The pipe characters in the example mark the column edges in the output. The minimum width is exactly that: a minimum. A longer value won't be truncated, it overflows:\n\n\n```python\nlong_name = \"Mechanical Gaming Keyboard\"\nprint(f\"|{long_name:15}|\")\nprint(len(long_name))\n```\n\n\nThe 26-character string doesn't fit in width 15, so the column overflows. To cap the width, combine it with precision, which truncates strings to that length. That combination appears below.\n\n### Fill Character\n\nThe character used for padding defaults to a space. You can change it by putting a character before the alignment marker:\n\n\n```python\nprint(f\"{'SALE':*^20}\")\nprint(f\"{'TOTAL':-<15}\")\nprint(f\"{42:0>5}\")\nprint(f\"{42:.>10}\")\n```\n\n\n`*^20` means \"fill with `*`, center, width 20\". `0>5` means \"fill with zero, right-align, width 5\". The fill character must come paired with an alignment marker; fill alone is not allowed.\n\nThe leading `0` shortcut (before the width, without an alignment marker) is a special form for zero-padding numbers:\n\n\n```python\norder_id = 42\nprint(f\"#{order_id:05d}\")\nprint(f\"#{-order_id:05d}\")\n```\n\n\nWith the `0` form, the sign stays on the outside and zeros fill between the sign and the digits. This is the behavior wanted for fixed-width order IDs or version numbers.\n\n### Type Codes\n\nThe trailing letter in the format spec says how to interpret the value. Different types accept different codes.\n\n\n| Code | For | Effect |\n| --- | --- | --- |\n| `s` | `str` | Plain string (default) |\n| `d` | `int` | Decimal integer |\n| `b` | `int` | Binary |\n| `o` | `int` | Octal |\n| `x` / `X` | `int` | Hex (lower / upper case) |\n| `f` / `F` | `float` | Fixed-point decimal |\n| `e` / `E` | `float` | Scientific notation |\n| `%` | `float` | Percentage (multiplies by 100, adds `%`) |\n\n\nSeveral codes in action:\n\n\n```python\norder_id = 255\ndiscount_rate = 0.075\nbig_number = 12345678.9\n\nprint(f\"Order: #{order_id:05d}\")\nprint(f\"Order in hex: 0x{order_id:04x}\")\nprint(f\"Order in binary: {order_id:08b}\")\nprint(f\"Discount: {discount_rate:.1%}\")\nprint(f\"Revenue: {big_number:.2e}\")\n```\n\n\nThe `%` type handles discounts: it multiplies by 100 and appends the percent sign in one step. So `0.075` renders as `7.5%`. Using the wrong type code for a value raises `ValueError` at runtime:\n\n\n```python\nname = \"Mouse\"\nprint(f\"{name:.2f}\")\n```\n\n\nThe `.2f` spec asks for a float, but `name` is a string. The error fires only when this line runs, not at parse time, so a stray bad spec can hide in code that rarely executes. Test format strings on real data.\n\n### Thousands Grouping\n\nA `,` or `_` in the format spec adds a separator every three digits for decimal numbers (every four digits for binary and hex):\n\n\n```python\nrevenue = 12500000\nsmall_amount = 1234.5\npermissions = 0b1011_0010_1111_0001\n\nprint(f\"${revenue:,}\")\nprint(f\"${revenue:,.2f}\")\nprint(f\"{small_amount:_.2f}\")\nprint(f\"{permissions:_b}\")\n```\n\n\nCommas are the standard for money. Underscores work for binary and hex output, where commas would look out of place. The grouping character goes right before the precision when both are used.\n\n### Width Plus Precision\n\nThe two combine to give a fixed-width column that truncates anything too long:\n\n\n```python\nproducts = [\"Mouse\", \"Mechanical Keyboard\", \"27 Inch 4K UHD Monitor\"]\n\nfor p in products:\n print(f\"|{p:<15.15}|\")\n```\n\n\nWidth 15, precision 15, left-aligned. Short names get padded with spaces, long names get cut off. For string types, precision is a maximum length, not a number of decimals. This keeps a column tidy when input lengths vary.\n\n---\n\n# The Debug Specifier `{x=}`\n\nAdded in Python 3.8, the `=` flag after an expression inside an f-string prints both the expression text and its value:\n\n\n```python\ncart_total = 124.95\ndiscount_pct = 15\nitems = [\"Mouse\", \"Keyboard\", \"Monitor\"]\n\nprint(f\"{cart_total=}\")\nprint(f\"{discount_pct=}\")\nprint(f\"{len(items)=}\")\n```\n\n\nThis form is built for debugging. Instead of typing the variable name twice (once as a label string, once as the value to print), the `=` does both. The exact text inside the braces, spaces and all, is preserved as the label:\n\n\n```python\nx = 7\nprint(f\"{x = }\")\nprint(f\"{x=}\")\n```\n\n\nThe spaces around `=` in the first example are preserved in the output. The `=` flag combines with format specs too. The format spec goes after the `=`:\n\n\n```python\ncart_total = 124.95\nprint(f\"{cart_total=:.2f}\")\nprint(f\"{cart_total * 0.85=:.2f}\")\n```\n\n\nThe debug form is shorter than scattering `print(\"cart_total:\", cart_total)` lines through code while chasing a bug. It serves the same role as a `console.log` shortcut in other languages, and is useful for tracing values during development.\n\n---\n\n# Multiline f-Strings\n\nTriple-quoted f-strings work like normal triple-quoted strings: every newline and space between the quotes is preserved. This is how to build receipts, emails, or any block of text with values dropped in:\n\n\n```python\ncustomer = \"Aarav Mehta\"\nitems = 3\ntotal = 89.50\n\nreceipt = f\"\"\"Order Confirmation\n==================\nCustomer: {customer}\nItems: {items}\nTotal: ${total:.2f}\nThank you for your order.\"\"\"\n\nprint(receipt)\n```\n\n\nEach line of the template becomes a line in the output. The format specs (`.2f` here) work the same as in single-line f-strings. To keep Python source indented without indenting the output too, write the string starting at column zero or call `textwrap.dedent()` on the result.\n\nImplicit string concatenation also works. When two string literals sit next to each other (separated only by whitespace), Python glues them at parse time into a single string. Mixing an f-string with a plain string this way is allowed:\n\n\n```python\nname = \"Aarav\"\ntotal = 199.50\n\nmessage = (\n f\"Hi {name},\\n\"\n \"Your order has been confirmed.\\n\"\n f\"Total charged: ${total:.2f}\\n\"\n)\nprint(message)\n```\n\n\nEach part sits on its own line, no trailing `+` operators, and the parser stitches them together. This form keeps individual lines short.\n\n---\n\n# Escaping Braces\n\nSince `{` and `}` mark expression placeholders, writing a literal brace requires doubling them:\n\n\n```python\ntemplate_field = \"customer_name\"\nprint(f\"Use {{customer_name}} as the placeholder for {template_field}\")\nprint(f\"JSON: {{'product': 'tablet'}}\")\n```\n\n\n`{{` becomes a single `{`, and `}}` becomes a single `}`. The escaping happens before Python parses what's inside the braces, so doubled braces never trigger expression evaluation.\n\nA dict literal inside an f-string is a separate matter: a single `{...}` is an expression, not a literal brace. To write the text of a dict, either double the braces (which means no expressions inside), or use `repr` on a real dict.\n\n---\n\n# Calling Methods Inside the Braces\n\nAny expression goes, so method calls work fine:\n\n\n```python\ncustomer_email = \" Aarav@Example.com \"\nproduct_titles = [\"mouse\", \"keyboard\", \"monitor\"]\n\nprint(f\"Normalized email: {customer_email.strip().lower()}\")\nprint(f\"First product: {product_titles[0].title()}\")\nprint(f\"All caps: {' '.join(product_titles).upper()}\")\n```\n\n\nThis is useful for last-minute cleanup or formatting. If the chain of calls gets long, do the work on a separate line and put only the variable in the f-string. Readability beats compactness.\n\n---\n\n# Nesting f-Strings\n\nA format spec field can itself contain a placeholder, which is how width and precision get parameterized at runtime:\n\n\n```python\ndef show(value, width, precision):\n print(f\"{value:>{width}.{precision}f}\")\n\nshow(3.14159, 10, 2)\nshow(3.14159, 15, 4)\nshow(1234.5, 12, 1)\n```\n\n\nThe inner `{width}` and `{precision}` evaluate first, their values get spliced into the format spec, then the outer formatting runs. This is the standard approach for building tables where column widths come from the data rather than from hardcoded constants.\n\nNesting a full f-string inside another f-string is also possible, though rarely needed. Each level of nesting needs a different quote style (or, in Python 3.12+, the same quote can be reused). The common case is the nested format spec, not nested whole f-strings.\n\n---\n\n# Pitfalls and Restrictions\n\nSeveral rules govern what can go inside an f-string expression.\n\n### No Backslashes in the Expression (Pre-3.12)\n\nIn Python 3.6 through 3.11, the expression inside `{...}` couldn't contain a backslash:\n\n\n```python\nproducts = [\"Mouse\", \"Keyboard\"]\nprint(f\"Items: {'\\n'.join(products)}\")\n```\n\n\nThe fix on older versions is to put the special character in a variable first:\n\n\n```python\nproducts = [\"Mouse\", \"Keyboard\"]\nnewline = \"\\n\"\nprint(f\"Items: {newline.join(products)}\")\n```\n\n\nPython 3.12 lifted this restriction (PEP 701), so on 3.12 and later `f\"{'\\n'.join(products)}\"` works directly. Code targeting older versions still needs the variable workaround.\n\n### No `#` Comments Inside the Braces\n\nThe hash character starts a comment in normal Python, but inside an f-string expression it isn't allowed. There's no way to add an inline comment to the expression part:\n\n\n```python\nprice = 29.99\nprint(f\"${price:.2f} # not a comment, just text\")\n```\n\n\nThe `#` and everything after it inside the literal is text in the output, not a Python comment. That's almost always the intended behavior. A `#` inside the braces is also disallowed: Python 3.11 and earlier raise a `SyntaxError`. Comments belong on the lines around the f-string, not inside it.\n\n### Using the Same Quote Style as the f-String\n\nBefore Python 3.12, the expression inside an f-string couldn't use the same kind of quote that wrapped the f-string:\n\n\n```python\nproducts = {\"name\": \"Mouse\", \"price\": 29.99}\nprint(f\"Product: {products[\"name\"]}\")\n```\n\n\nThe parser hits the inner `\"` and treats the f-string as ended. The fix on older versions is to use the other quote style for the inner string:\n\n\n```python\nproducts = {\"name\": \"Mouse\", \"price\": 29.99}\nprint(f\"Product: {products['name']}\")\n```\n\n\nSingle quotes outside, double inside, or vice versa. Python 3.12 lifted this restriction too, but code that needs to run across versions should follow the older rule.\n\n---\n\n# Conversion Flags\n\nBefore applying the format spec, the value can be routed through one of three conversion functions:\n\n\n| Flag | Calls | Use for |\n| --- | --- | --- |\n| `!s` | `str(value)` | Default, rarely written |\n| `!r` | `repr(value)` | Debug output with quotes around strings |\n| `!a` | `ascii(value)` | Like `!r` but escapes non-ASCII chars |\n\n\n\n```python\nproduct_name = \"Café Mug\"\n\nprint(f\"Display: {product_name}\")\nprint(f\"Debug: {product_name!r}\")\nprint(f\"ASCII: {product_name!a}\")\n```\n\n\n`!r` is the practical one. When a log line says `Order id was order_123`, the reader can't tell whether `order_123` is the string `\"order_123\"` or some other value that prints the same. `!r` puts the quotes around strings (and brackets around lists, braces around dicts) so the type is unambiguous.\n\nThe flag goes before the colon when combined with a format spec:\n\n\n```python\nname = \"Mouse\"\nprint(f\"{name!r:>15}\")\nprint(f\"{name!s:>15}\")\n```\n\n\n`!r` first wraps `Mouse` in quotes (giving `'Mouse'`, 7 characters), then the format spec right-aligns the result to width 15.\n\n---\n\n# A Real Receipt\n\nA small program that builds a receipt using width, alignment, precision, and grouping together:\n\n\n```python\nitems = [\n (\"Wireless Mouse\", 29.99, 2),\n (\"Mechanical Keyboard\", 129.50, 1),\n (\"27 Inch 4K Monitor\", 449.00, 1),\n (\"USB-C Hub\", 24.95, 3),\n]\n\nNAME_W = 22\nQTY_W = 5\nPRICE_W = 10\nTOTAL_W = 12\n\nheader = f\"{'Item':<{NAME_W}}{'Qty':>{QTY_W}}{'Price':>{PRICE_W}}{'Total':>{TOTAL_W}}\"\nprint(header)\nprint(\"-\" * len(header))\n\ngrand_total = 0\nfor name, price, qty in items:\n line_total = price * qty\n grand_total += line_total\n print(f\"{name:<{NAME_W}.{NAME_W}}{qty:>{QTY_W}d}{price:>{PRICE_W},.2f}{line_total:>{TOTAL_W},.2f}\")\n\nprint(\"-\" * len(header))\nprint(f\"{'TOTAL':>{NAME_W + QTY_W + PRICE_W}}{grand_total:>{TOTAL_W},.2f}\")\n```\n\n\nThe column widths come from variables that the format specs reference through nested placeholders, so changing one constant at the top adjusts every column. Names get truncated to the column width with `.{NAME_W}`, so a long product title can't overflow the layout. Prices are right-aligned, comma-grouped, and pinned to two decimals.","pageType":"python"}

f-Strings

Get Premium