{"title":"Data Types","description":"","content":"Python ships with a small set of built-in types that cover most of what you'll write day to day: numbers, text, true/false flags, sequences, mappings, sets, and the empty value `None`. This lesson is a map. We'll see each type once, look at how to inspect a value's type at runtime, and group them by mutability and category.\n\n---\n\n# What \"Type\" Means in Python\n\nEvery value in Python is an object, and every object has a **type**. The type tells Python what the value is, what operations it supports, and how it should behave when used in expressions. The type belongs to the value, not the name. A name can be rebound to any type.\n\nYou can inspect a value's type at runtime with the built-in `type()` function:\n\n\n```python\nprint(type(42))\nprint(type(3.14))\nprint(type(\"Wireless Mouse\"))\nprint(type(True))\nprint(type(None))\n```\n\n\nThe result is the class object itself. For everyday work, the part you read is the class name: `int`, `float`, `str`, and so on. We'll use `type()` throughout this lesson to confirm what each literal produces.\n\n\n```mermaid\nflowchart LR\n L[Literal in code
e.g. 42]:::cyan --> O[Object in memory]:::orange\n O --> T[Type
int]:::green\n O --> V[Value
42]:::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\nWhen Python reads a literal in your source, it builds an object with two key parts: its type and its value. The type drives what `+`, `len()`, indexing, and any other operation will actually do.\n\n---\n\n# The Built-in Type Map\n\nHere's the full set of types this lesson covers, grouped by what they're for. Each row links forward to the section in this course that owns the deep dive.\n\n\n| Type | Category | Mutable? | Example literal | Deep dive |\n|------|----------|----------|-----------------|-----------|\n| `int` | Numeric | No | `42` | Numeric Types |\n| `float` | Numeric | No | `3.14` | Numeric Types |\n| `complex` | Numeric | No | `2 + 3j` | Numeric Types |\n| `bool` | Numeric (sub-type of `int`) | No | `True`, `False` | Boolean Type |\n| `str` | Sequence (text) | No | `\"Aisha\"` | Strings section |\n| `bytes` | Sequence (binary) | No | `b\"order\"` | Strings section (intro), file I/O |\n| `list` | Sequence (general) | Yes | `[1, 2, 3]` | Lists section |\n| `tuple` | Sequence (general) | No | `(1, 2, 3)` | Tuples section |\n| `dict` | Mapping | Yes | `{\"name\": \"Aisha\"}` | Dictionaries section |\n| `set` | Set | Yes | `{1, 2, 3}` | Sets section |\n| `frozenset` | Set | No | `frozenset({1, 2, 3})` | Sets section |\n| `NoneType` | Singleton | No | `None` | None Type lesson |\n\n\nThat's twelve types worth knowing on day one. There are more in the standard library (decimals, fractions, dates, paths, queues), but everything in the table above is available without an import.\n\nA short tour of each, with just enough code to recognize them.\n\n---\n\n# Numeric Types\n\nPython has three built-in numeric types: integers, floating-point numbers, and complex numbers. Each handles a different shape of number.\n\n\n```python\nquantity = 5\nprice = 29.99\nimpedance = 4 + 3j\n\nprint(type(quantity))\nprint(type(price))\nprint(type(impedance))\n```\n\n\nA few things worth noting up front. Python integers have arbitrary precision, which means there's no maximum value other than your machine's memory. Floats follow the IEEE 754 double-precision standard, the same one used by most other languages, so `0.1 + 0.2` is the classic `0.30000000000000004`. The `complex` type is for math and engineering work and rarely shows up in business code.\n\n\n> **INFO**\n>\n> **Cost:** Arithmetic on very large `int` values is slower than on small ones because Python falls back to multi-word arithmetic. For everyday quantities and prices, you won't notice.\n\n\nThe Boolean type `bool` is technically a subclass of `int`. `True` behaves like `1` and `False` behaves like `0` in arithmetic. Here's the proof:\n\n\n```python\nprint(True + True)\nprint(isinstance(True, int))\n```\n\n\nThe Numeric Types lesson covers `int`, `float`, and `complex` in depth, including precision, division operators, and when to reach for the `decimal` module instead of `float`.\n\n---\n\n# Strings and Bytes\n\nText in Python is stored in `str` objects. A string is a sequence of Unicode characters, written with single or double quotes. Both work the same way.\n\n\n```python\ncustomer = \"Aisha\"\nproduct = 'Wireless Mouse'\ngreeting = \"Welcome, Aisha!\"\n\nprint(type(customer))\nprint(len(product))\n```\n\n\nStrings are immutable. You can't change a character in place. Operations that look like edits (replacing a substring, uppercasing, slicing) all return a new string.\n\n\n```python\nproduct = \"Wireless Mouse\"\nproduct[0] = \"w\"\n```\n\n\nThe `bytes` type is for raw binary data: file contents, network packets, image bytes. It looks like a string with a `b` prefix on the literal.\n\n\n```python\norder_data = b\"order_id=12345\"\nprint(type(order_data))\nprint(order_data[0])\n```\n\n\nIndexing a `bytes` object returns an integer (the byte's numeric value), not a one-character `bytes` object. This trips people up coming from Python 2. You usually create `bytes` by reading files in binary mode or by encoding a string with `.encode()`.\n\n---\n\n# Sequences: List and Tuple\n\nSequences hold an ordered collection of values. Python has two general-purpose sequence types: `list` for mutable sequences, `tuple` for immutable ones. (Strings and bytes are also sequences, but they're specialized for text and binary data.)\n\nA list uses square brackets:\n\n\n```python\ncart = [\"apple\", \"bread\", \"milk\"]\ncart.append(\"eggs\")\nprint(cart)\nprint(type(cart))\n```\n\n\nYou can add to a list, remove from it, sort it, and modify items in place. Lists are the workhorse of Python. Anytime you have \"a bunch of things in order that might change\", you reach for a list.\n\nA tuple uses parentheses (or none at all, since the commas do the real work):\n\n\n```python\norder_position = (37.7749, -122.4194)\ncustomer_info = \"Aisha\", \"aisha@example.com\", 28\n\nprint(type(order_position))\nprint(type(customer_info))\n```\n\n\nTuples are immutable. Once created, you can't add, remove, or swap items. They're typically used for fixed-shape records (like a coordinate pair or an order's (id, status, total) snapshot), or as keys in a dictionary (which requires immutability).\n\n\n> **INFO**\n>\n> **Cost:** `list.append(x)` is amortized O(1). `list.insert(0, x)` is O(n) because every existing element shifts down by one.\n\n\n\n```mermaid\nflowchart LR\n SEQ[Sequences]:::cyan --> S1[str / bytes
text and binary]:::orange\n SEQ --> S2[list
mutable, mixed types]:::green\n SEQ --> S3[tuple
immutable, fixed]:::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 picture is: ordered collections, with three flavors based on what they store and whether they can change after creation.\n\n---\n\n# Mappings: Dict\n\nA dictionary stores **key-value pairs**. You look up a value by its key, not by an integer position. Keys can be any hashable type (most often strings or numbers); values can be anything.\n\n\n```python\ncustomer = {\n \"name\": \"Aisha\",\n \"email\": \"aisha@example.com\",\n \"orders\": 7,\n}\n\nprint(customer[\"name\"])\nprint(type(customer))\n```\n\n\nDictionaries are mutable. You can add, remove, and update entries:\n\n\n```python\ncustomer[\"loyalty_tier\"] = \"gold\"\ndel customer[\"orders\"]\nprint(customer)\n```\n\n\nSince Python 3.7, dictionaries preserve insertion order. You'll see them used everywhere: configuration, JSON-shaped data, lookups by id, counting things. They support O(1) average lookup, default values, and counter-style patterns.\n\n---\n\n# Sets and Frozensets\n\nA set is an unordered collection of unique values. Sets are useful when you care about membership (\"is this email in our list?\") or want to remove duplicates from a sequence.\n\n\n```python\nfavorite_categories = {\"electronics\", \"books\", \"kitchen\"}\nfavorite_categories.add(\"electronics\")\nfavorite_categories.add(\"toys\")\n\nprint(favorite_categories)\nprint(type(favorite_categories))\n```\n\n\nAdding `\"electronics\"` a second time did nothing because the value was already present. Sets de-duplicate by definition.\n\n\n> **INFO**\n>\n> **Cost:** Membership check (`x in some_set`) is O(1) average, compared to O(n) for a list. If you find yourself writing `if x in big_list:` in a hot path, consider a set.\n\n\nA `frozenset` is the immutable cousin. Once created, it can't change. You'd use one as a dictionary key, or as a value you want to guarantee won't be mutated.\n\n\n```python\nfixed_categories = frozenset({\"electronics\", \"books\"})\nprint(type(fixed_categories))\n```\n\n\nSets support operations like union, intersection, and difference, and they're the right choice when you need fast membership checks or want to deduplicate items without preserving order.\n\n---\n\n# None and NoneType\n\n`None` is Python's \"nothing\" value. It has its own type, `NoneType`, and there's exactly one `None` object in any running program. You use it to represent \"no result yet\", \"no value was provided\", or \"this function doesn't return anything meaningful\".\n\n\n```python\nshipping_address = None\nprint(type(shipping_address))\nprint(shipping_address is None)\n```\n\n\nTwo things to know now. First, you check for `None` with `is None`, not `== None`. Second, functions that don't have a `return` statement implicitly return `None`.\n\n\n```python\ndef save_order():\n pass\n\nresult = save_order()\nprint(result)\nprint(result is None)\n```\n\n\nThat's why you sometimes see `None` printed when you call a function expecting a result. The function didn't return anything explicitly, so Python returned `None`.\n\n---\n\n# Mutable vs Immutable\n\nWhether a type is mutable or immutable changes how you reason about shared references and copying. Here's the summary you'll come back to:\n\n\n| Mutable | Immutable |\n|---------|-----------|\n| `list` | `int` |\n| `dict` | `float` |\n| `set` | `complex` |\n| `bytearray` (not covered yet) | `bool` |\n| | `str` |\n| | `bytes` |\n| | `tuple` (with a caveat below) |\n| | `frozenset` |\n| | `NoneType` |\n\n\nMutable means the object's contents can change after creation. Two names pointing at the same mutable object will both see changes made through either name. Immutable means the object never changes; any \"modification\" returns a new object instead.\n\n\n```python\ncart = [\"apple\"]\ncart.append(\"bread\")\nprint(cart)\n\nproduct = \"Mouse\"\nupgraded = product.upper()\nprint(product)\nprint(upgraded)\n```\n\n\nThe list was modified in place. The string wasn't, `upper()` returned a new string and left the original alone.\n\nA subtle point about tuples: they're immutable in the sense that you can't add, remove, or replace their elements. But if a tuple contains a mutable object, that inner object can still be mutated. The tuple's slots still point to the same objects, but those objects can change.\n\n\n```python\norder = (\"ORD-1\", [\"apple\", \"bread\"])\norder[1].append(\"milk\")\nprint(order)\n```\n\n\nWe didn't change which list the tuple contains. We changed the contents of that list. Tuples freeze their slot bindings, not the objects they reference.\n\n---\n\n# Sequence, Mapping, Set: The Three Container Families\n\nBeyond mutable vs immutable, Python organizes container types into three abstract categories. Knowing which category a type belongs to tells you what kinds of operations work on it.\n\n\n| Category | What it is | Built-in types | Common operations |\n|----------|------------|----------------|-------------------|\n| Sequence | Ordered, indexed by integer | `str`, `bytes`, `list`, `tuple`, `range` | `s[0]`, `len(s)`, `s + t`, `for x in s` |\n| Mapping | Key-value pairs, indexed by key | `dict` | `d[key]`, `d.keys()`, `d.values()`, `for k in d` |\n| Set | Unordered, unique elements | `set`, `frozenset` | `x in s`, `s \\| t`, `s & t`, `for x in s` |\n\n\nThe same operator can mean different things in different categories. `+` concatenates two sequences (`[1, 2] + [3, 4]` gives `[1, 2, 3, 4]`) but isn't defined for sets (use `|` for union instead). Indexing with `[]` works for sequences (by position) and mappings (by key), but not for sets.\n\n\n```mermaid\nflowchart TD\n C[Containers]:::cyan\n C --> SEQ[Sequence
ordered, integer index]:::orange\n C --> MAP[Mapping
key to value]:::green\n C --> SET[Set
unordered, unique]:::teal\n\n SEQ --> SEQ_T[str, bytes, list, tuple, range]:::orange\n MAP --> MAP_T[dict]:::green\n SET --> SET_T[set, frozenset]:::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\nMost of the time you don't need to think about these categories explicitly. You'll learn which type to reach for based on the shape of your data: ordered things go in a list, lookups by key go in a dict, set-like things go in a set. The categories matter when you read documentation that says \"any iterable\" or \"any mapping\" and you need to know what fits.\n\n---\n\n# Using `type()` and `isinstance()`\n\n`type()` returns the exact class of an object. `isinstance()` checks whether an object is of a given class **or a subclass of it**. For Boolean values, this difference matters.\n\n\n```python\nflag = True\n\nprint(type(flag) == int)\nprint(isinstance(flag, int))\n```\n\n\n`type(True)` is `bool`, not `int`, so the first check is `False`. But `bool` is a subclass of `int`, so `isinstance(True, int)` returns `True`. In practice, prefer `isinstance()` for type checks because it respects inheritance and accepts a tuple of types:\n\n\n```python\ndef is_number(value):\n return isinstance(value, (int, float, complex))\n\nprint(is_number(5))\nprint(is_number(\"5\"))\nprint(is_number(3.14))\n```\n\n\nThis is the idiomatic way to ask \"is this any kind of number?\" Note that `isinstance(value, (int, float, complex))` would return `True` for `bool` too, since `bool` is a subclass of `int`. If you specifically want to exclude booleans, you have to check for that separately.\n\n---\n\n# Quiz","pageType":"python"}

Get Premium