{"title":"Type Conversion","description":"","content":"Real programs constantly move data between types. A price comes in from a form as a string, and you need a number to do math on it. A list of products needs to become a set to remove duplicates. A boolean check decides whether to show a message. This lesson covers the conversion functions Python gives you, when Python converts automatically, and what happens when a conversion can't succeed.\n\n---\n\n# Two Kinds of Conversion\n\nPython has two ways to move a value from one type to another:\n\n- **Implicit conversion** happens automatically when Python knows the conversion is safe. The classic case: mixing an `int` and a `float` in an expression makes the result a `float`.\n- **Explicit conversion** is when you ask for it with a function like `int()`, `float()`, `str()`, `bool()`, `list()`, `tuple()`, `set()`, or `dict()`.\n\nThe distinction matters because implicit conversion is rare in Python. The language prefers to make you ask. That's why `1 + \"2\"` raises an error in Python where it might \"just work\" in JavaScript or PHP.\n\n\n```python\nquantity = 3\nprice = 19.99\ntotal = quantity * price\nprint(total)\nprint(type(total))\n```\n\n\nHere Python implicitly promoted `quantity` (an `int`) to a `float` so it could multiply with `price`. The result is a `float`. We didn't write `float(quantity)` anywhere; the interpreter did it for us because mixing `int` and `float` in arithmetic is safe and unambiguous.\n\nNow compare that to mixing a string and a number:\n\n**What's wrong with this code?**\n\n\n```python\nprice = \"19.99\"\nquantity = 3\ntotal = price * quantity\nprint(total)\n```\n\n\n`price` is a string, not a number. `\"19.99\" * 3` is valid Python, but it means \"repeat the string three times\", not \"multiply 19.99 by 3\". The fix is explicit conversion:\n\n\n```python\nprice = \"19.99\"\nquantity = 3\ntotal = float(price) * quantity\nprint(total)\n```\n\n\nThis is the rule of thumb: when the types involved are different in a way that could mean two things, Python won't guess. You convert.\n\n---\n\n# Converting to `int`\n\n`int(x)` turns `x` into a whole number. It accepts numbers, strings that look like integers, and booleans.\n\n\n```python\nprint(int(3.7))\nprint(int(-3.7))\nprint(int(\"42\"))\nprint(int(\" 42 \"))\nprint(int(True))\nprint(int(False))\n```\n\n\nA few things to notice:\n\n- **Truncation, not rounding.** `int(3.7)` is `3`, not `4`. `int(-3.7)` is `-3`, not `-4`. Python drops the fractional part and moves toward zero. If you want rounding, use `round()` instead, which is a different function.\n- **Leading and trailing whitespace is fine.** `int(\" 42 \")` works.\n- **Booleans convert cleanly.** `True` is `1`, `False` is `0`. This makes sense because `bool` is technically a subclass of `int` in Python.\n\nThe rounding distinction matters more than people expect:\n\n\n```python\nprint(int(3.9))\nprint(round(3.9))\nprint(int(-3.9))\nprint(round(-3.9))\n```\n\n\n`int()` always moves toward zero. `round()` follows standard rounding rules, with a wrinkle for halves.\n\nStrings have to look like valid integers. Anything else raises `ValueError`:\n\n\n```python\nprint(int(\"42\"))\nprint(int(\"3.7\"))\n```\n\n\nEven though `3.7` would convert fine if it were a number, `int()` won't parse a string that contains a decimal point. To go from a decimal string to an integer, do it in two steps: `int(float(\"3.7\"))` gives `3`.\n\n### Parsing with a different base\n\n`int()` takes a second argument: the base of the number in the string. This is useful for hex (`16`), octal (`8`), or binary (`2`) inputs.\n\n\n```python\nprint(int(\"12\", 16))\nprint(int(\"ff\", 16))\nprint(int(\"0xff\", 16))\nprint(int(\"1010\", 2))\nprint(int(\"777\", 8))\n```\n\n\n`int(\"12\", 16)` reads `\"12\"` as a base-16 (hex) number, which equals 18 in decimal. The `0x`, `0o`, and `0b` prefixes are optional; `int()` recognizes them.\n\nThe base argument only works with string input. `int(12, 16)` raises `TypeError` because `12` is already a number, so there's no string to parse.\n\n\n> **INFO**\n>\n> **Cost:** `int()` on a string is O(n) where n is the length of the string. For typical inputs this is irrelevant, but parsing millions of values in a loop adds up.\n\n\n---\n\n# Converting to `float`\n\n`float(x)` turns `x` into a decimal number. It accepts numbers, strings, and booleans.\n\n\n```python\nprint(float(42))\nprint(float(\"19.99\"))\nprint(float(\"3\"))\nprint(float(\"1e3\"))\nprint(float(True))\nprint(float(\" 4.5 \"))\n```\n\n\nNotes:\n\n- An `int` converts cleanly. `42` becomes `42.0`.\n- A string like `\"19.99\"` parses as you'd expect.\n- Scientific notation works: `\"1e3\"` is `1 x 10^3`, which is `1000.0`.\n- Whitespace around the number is allowed.\n- `True` and `False` become `1.0` and `0.0`.\n\nTwo special string values are also legal:\n\n\n```python\nprint(float(\"inf\"))\nprint(float(\"-inf\"))\nprint(float(\"nan\"))\n```\n\n\n`inf` is positive infinity, `-inf` is negative infinity, and `nan` is \"not a number\". You won't use these often, but they're worth knowing exist.\n\nLike `int()`, bad strings raise `ValueError`:\n\n\n```python\nprint(float(\"abc\"))\n```\n\n\nA common e-commerce use is parsing a price string from a form or a CSV file:\n\n\n```python\nform_input = \"29.99\"\nprice = float(form_input)\nquantity = 3\ntotal = price * quantity\nprint(f\"Total: ${total:.2f}\")\n```\n\n\nWithout `float()`, `form_input * quantity` would have repeated the string three times, giving `\"29.9929.9929.99\"`.\n\n---\n\n# Converting to `str`\n\n`str(x)` turns anything into a string. There is no case where `str()` raises an error on a built-in type. Every Python object has a string representation, even `None`.\n\n\n```python\nprint(str(42))\nprint(str(19.99))\nprint(str(True))\nprint(str(None))\nprint(str([1, 2, 3]))\nprint(str({\"name\": \"Alex\"}))\n```\n\n\nThe most common use is building messages that mix text and numbers. You can use `str()` directly, but f-strings are almost always cleaner:\n\n\n```python\nquantity = 3\nprice = 19.99\n\nmessage_old = \"You bought \" + str(quantity) + \" items for $\" + str(price)\nmessage_new = f\"You bought {quantity} items for ${price}\"\n\nprint(message_old)\nprint(message_new)\n```\n\n\nThe f-string version doesn't call `str()` explicitly. It does it internally. F-strings handle the conversion for you and read more naturally.\n\n\n> **INFO**\n>\n> **Cost:** Concatenating strings with `+` creates a new string every time. For two or three pieces it doesn't matter. For dozens or hundreds, use `\"\".join(parts)` or an f-string, both of which allocate only once.\n\n\n---\n\n# Converting to `bool`\n\n`bool(x)` follows the standard falsiness rules. Anything in the \"falsy\" set becomes `False`. Everything else becomes `True`.\n\nThe falsy values are:\n\n\n| Type | Falsy values |\n| -------- | ------------------- |\n| Numbers | `0`, `0.0`, `0j` |\n| Strings | `\"\"` |\n| Lists | `[]` |\n| Tuples | `()` |\n| Sets | `set()` |\n| Dicts | `{}` |\n| Special | `None`, `False` |\n\n\nEverything else is truthy:\n\n\n```python\nprint(bool(0))\nprint(bool(1))\nprint(bool(-1))\nprint(bool(\"\"))\nprint(bool(\" \"))\nprint(bool([]))\nprint(bool([0]))\nprint(bool(None))\n```\n\n\nTwo of these surprise beginners:\n\n- `bool(\" \")` is `True` because the string contains a space character, which is not the same as an empty string.\n- `bool([0])` is `True` because the list has one element, even though that element happens to be `0`. The truthiness check is \"is this collection empty?\", not \"are its contents falsy?\".\n\nYou rarely call `bool()` directly. Python applies it automatically when you write `if x:` or `while x:` or any boolean context. But knowing the rules helps you debug \"why did my if-statement go the wrong way?\" moments.\n\n\n```python\ncart = []\n\nif cart:\n print(f\"Cart has {len(cart)} items\")\nelse:\n print(\"Cart is empty\")\n```\n\n\n`if cart:` is equivalent to `if bool(cart):`, which is `if False:` because the list is empty. This idiom (`if some_collection:`) is the Pythonic way to check whether a collection has anything in it. Don't write `if len(cart) > 0:` unless you need the count anyway.\n\nThe earlier lesson on the boolean type covered the full set of falsy values and the truthiness rules. This section is here so you know `bool()` is just the explicit form of those same rules.\n\n---\n\n# Converting to `list`, `tuple`, and `set`\n\nThese three functions all accept an **iterable**: anything you can loop over. That includes lists, tuples, sets, strings, dictionary keys, generators, and more. The output is a new collection of the requested type.\n\n\n```python\nprint(list(\"HELLO\"))\nprint(tuple([1, 2, 3]))\nprint(set([1, 2, 2, 3, 3, 3]))\n```\n\n\nThe main reasons to convert between these three:\n\n- **`list(x)`** when you want a mutable, ordered sequence you can index, append to, and modify.\n- **`tuple(x)`** when you want an immutable, ordered sequence (useful for dictionary keys or as a \"frozen\" version of a list).\n- **`set(x)`** when you want unique elements, fast membership checks, or set operations like union and intersection.\n\nA common pattern: deduplicate a list of products while preserving order.\n\n\n```python\nrecently_viewed = [\n \"Wireless Mouse\",\n \"USB Cable\",\n \"Wireless Mouse\",\n \"Webcam\",\n \"USB Cable\",\n \"Keyboard\",\n]\n\nunique_unordered = set(recently_viewed)\nprint(unique_unordered)\n```\n\n\n`set()` deduplicates, but it doesn't preserve order in the way most people expect. If you need both deduplication and original order, use `dict.fromkeys()`:\n\n\n```python\nunique_ordered = list(dict.fromkeys(recently_viewed))\nprint(unique_ordered)\n```\n\n\nThis works because regular dictionaries preserve insertion order (since Python 3.7), and `dict.fromkeys()` builds a dictionary using the iterable's values as keys (which dedupes).\n\nConverting in the other direction is just as easy:\n\n\n```python\nprices_tuple = (29.99, 14.99, 9.99)\nprices_list = list(prices_tuple)\nprices_list.append(49.99)\nprint(prices_list)\n```\n\n\nYou can't append to a tuple directly because tuples are immutable. Converting to a list, modifying, and (if needed) converting back is the standard workaround.\n\nA diagram of how these conversions relate:\n\n\n```mermaid\nflowchart LR\n A[Any iterable
list, tuple, set,
string, dict keys]:::cyan --> B[list()]:::green\n A --> C[tuple()]:::teal\n A --> D[set()]:::orange\n\n B --> E[Mutable
ordered
indexable]:::cyan\n C --> F[Immutable
ordered
indexable]:::cyan\n D --> G[Mutable
unordered
unique only]:::cyan\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n```\n\n\nThe diagram shows that all three constructors accept the same kind of input (any iterable) but produce containers with different properties. Pick the one whose properties match what you actually need.\n\n\n> **INFO**\n>\n> **Cost:** `list(some_set)` and `set(some_list)` are O(n) where n is the length of the source. They walk the whole input. Don't convert in a tight loop if one type would do the whole job.\n\n\n---\n\n# Converting to `dict`\n\n`dict()` builds a dictionary. It accepts several different shapes of input, which trip up beginners.\n\nThe two most common ways:\n\n\n```python\nproduct = dict(name=\"Wireless Mouse\", price=19.99, stock=50)\nprint(product)\n```\n\n\nThis **keyword-argument form** is the most readable when you know the keys at write time. It only works when the keys are valid Python identifiers (no spaces, doesn't start with a digit).\n\nThe other common form takes an iterable of key-value pairs:\n\n\n```python\npairs = [\n (\"name\", \"Wireless Mouse\"),\n (\"price\", 19.99),\n (\"stock\", 50),\n]\nproduct = dict(pairs)\nprint(product)\n```\n\n\nEach element of the iterable must be a two-element sequence. The first becomes the key, the second becomes the value. This form is useful when the pairs come from another data source (a CSV reader, a `zip()` of two lists, an API response).\n\nA real-world pattern: converting two parallel lists into a dictionary.\n\n\n```python\nproduct_names = [\"Wireless Mouse\", \"USB Cable\", \"Webcam\"]\nprices = [19.99, 4.99, 39.99]\n\ncatalog = dict(zip(product_names, prices))\nprint(catalog)\n```\n\n\n`zip()` pairs up the two lists into tuples like `(\"Wireless Mouse\", 19.99)`. `dict()` then turns those pairs into key-value entries.\n\nYou can also copy an existing dict:\n\n\n```python\ndefault_settings = {\"shipping\": \"standard\", \"currency\": \"USD\"}\nuser_settings = dict(default_settings)\nuser_settings[\"shipping\"] = \"express\"\n\nprint(default_settings)\nprint(user_settings)\n```\n\n\n`dict(default_settings)` creates a shallow copy, so modifying `user_settings` doesn't affect the original.\n\n---\n\n# When Conversion Fails\n\nYou've seen `ValueError` from `int(\"abc\")` already. Here's the broader picture: each conversion function has its own failure modes.\n\n\n```python\nprint(int(\"abc\"))\n```\n\n\nThe traceback's last line is the part that matters. `ValueError` means the function recognized the input type (it's a string), but the value isn't something it knows how to convert.\n\nThere's also `TypeError`, which happens when the input isn't a type the function accepts at all:\n\n\n```python\nprint(int([1, 2, 3]))\n```\n\n\nThe message depends on the function and how it's called, but the type is the giveaway. `TypeError` means \"wrong shape of input\", `ValueError` means \"right shape, wrong value\".\n\nA summary table:\n\n\n| Function | Common error | Typical cause |\n| ---------- | ----------------- | --------------------------------------------- |\n| `int(x)` | `ValueError` | Non-numeric string like `\"abc\"` or `\"3.7\"` |\n| `float(x)` | `ValueError` | Non-numeric string like `\"abc\"` |\n| `str(x)` | (never raises on built-ins) | N/A |\n| `bool(x)` | (never raises on built-ins) | N/A |\n| `list(x)` | `TypeError` | `x` isn't iterable, like `list(42)` |\n| `tuple(x)` | `TypeError` | `x` isn't iterable |\n| `set(x)` | `TypeError` | `x` isn't iterable, or contains unhashable elements |\n| `dict(x)` | `ValueError` / `TypeError` | `x` isn't pairs of key-value |\n\n\nYou'll handle these failures gracefully using `try` / `except`, which gets a full lesson later in the course. The shape looks like this:\n\n\n```python\nform_input = \"abc\"\n\ntry:\n quantity = int(form_input)\n print(f\"Quantity is {quantity}\")\nexcept ValueError:\n print(f\"Could not parse '{form_input}' as a number\")\n```\n\n\n`try` runs the risky code. If it raises `ValueError`, control jumps to the `except` block. If everything succeeds, the `except` block is skipped. We'll cover the full mechanics, including `else`, `finally`, and chained exceptions, in the exception handling section. For now, recognize the pattern and know it exists.\n\nA diagram of the conversion lifecycle:\n\n\n```mermaid\nflowchart TD\n A[Call conversion
function]:::cyan --> B{Input is the
right type?}:::orange\n B -->|No| C[TypeError]:::red\n B -->|Yes| D{Value can be
converted?}:::orange\n D -->|No| E[ValueError]:::red\n D -->|Yes| F[Return new value
of target type]:::green\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef red fill:#ff8787,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n```\n\n\nThe check happens in two stages. First, is the input even something this function can work with? If you pass a list to `int()`, you'll hit `TypeError`. Second, given that the type is OK, can the actual value be converted? If you pass `\"abc\"` to `int()`, the string is the right type but the value isn't a number, so you get `ValueError`.\n\n---\n\n# Implicit Promotion in Arithmetic\n\nImplicit conversion in Python is narrow. It happens in arithmetic between numeric types, and that's mostly it.\n\n\n```python\nprint(3 + 4)\nprint(3 + 4.0)\nprint(3 * 2.5)\nprint(True + 1)\nprint(True + False)\n```\n\n\nRules:\n\n- `int` mixed with `int` stays `int`.\n- `int` mixed with `float` promotes to `float`.\n- `bool` mixed with `int` or `float` promotes to `int` or `float` (since `True` is `1` and `False` is `0`).\n\nNotice that `True + 1` is `2`, not `True`. As soon as you do arithmetic on a `bool`, you're working with integers. This is occasionally useful: `sum([True, False, True, True])` gives you the count of `True` values, which is `3`.\n\nWhat Python won't do implicitly: convert strings to numbers, or numbers to strings, in arithmetic. Those have to be explicit.\n\n\n```python\nprint(\"Price: $\" + 19.99)\n```\n\n\nThe fix is `\"Price: $\" + str(19.99)` or, much better, an f-string: `f\"Price: ${19.99}\"`.\n\nDivision has one more quirk worth knowing. The `/` operator always produces a `float`, even when both operands are integers and the result is whole. The `//` operator does integer division (truncating toward negative infinity).\n\n\n```python\nprint(10 / 2)\nprint(10 // 2)\nprint(10 / 3)\nprint(10 // 3)\n```\n\n\nIf you want an integer back from `/`, you have to convert explicitly: `int(10 / 2)`. Or just use `//`.\n\n---\n\n# Summary\n\n- Python distinguishes implicit conversion (automatic, narrow) from explicit conversion (you ask for it with a function).\n- `int()` truncates toward zero on numbers and parses strings as integers. It takes an optional base argument for hex, octal, and binary.\n- `float()` accepts numbers and number-like strings, including scientific notation and `\"inf\"` / `\"nan\"`. It always returns a decimal.\n- `str()` works on every built-in type and never raises. F-strings handle the conversion automatically and are usually cleaner than calling `str()` directly.\n- `bool()` follows the falsiness rules: `0`, `0.0`, `\"\"`, `[]`, `()`, `{}`, `set()`, and `None` are falsy. Everything else is truthy.\n- `list()`, `tuple()`, and `set()` accept any iterable and return a new collection of the requested type. Use `dict.fromkeys()` to dedupe while preserving order.\n- `dict()` accepts keyword arguments, an iterable of key-value pairs, or another dictionary. `dict(zip(keys, values))` is the standard way to build a dict from two parallel lists.\n- Conversion can fail with `ValueError` (right type, wrong value) or `TypeError` (wrong type entirely). The `try` / `except` block handles failures gracefully.\n- Python implicitly promotes numbers in arithmetic (`int + float` gives `float`), but never converts between strings and numbers. That's always explicit.\n\nIn the next lesson, we look at the full set of arithmetic, comparison, logical, and assignment operators, including how operator precedence and short-circuit evaluation actually work.","pageType":"python"}

Type Conversion

Get Premium