Python Data Types: A Complete Guide

str — Immutable Text

str is Python's built-in text type — an immutable sequence of Unicode characters. Because strings are immutable, every operation that appears to modify a string actually creates a new string object.

copy# str is a sequence — indexable and iterable
s = "Python"
print(f"s[0]    = {s[0]}")      # first character
print(f"s[-1]   = {s[-1]}")     # last character
print(f"s[1:4]  = {s[1:4]}")    # slice
print(f"s[::-1] = {s[::-1]}")   # reversed

# Immutability — you cannot change a character in place
try:
    s[0] = "J"
except TypeError as e:
    print(f"\nCannot mutate str: {e}")

# Each 'modification' returns a new object
original = "hello"
upper    = original.upper()
print(f"\noriginal id : {id(original)}")
print(f"upper id    : {id(upper)}")
print(f"same object : {original is upper}")

# String interning — Python caches some short strings
a = "hello"
b = "hello"
print(f"\na is b (interned literal) : {a is b}")  # often True — cached

c = "".join(["hel", "lo"])   # constructed at runtime
print(f"a is c (constructed)      : {a is c}")  # often False

# Three ways to build multi-line strings
sql_query = (
    "SELECT name, stock "
    "FROM inventory "
    "WHERE stock > 0"
)
print(f"\nConcatenated literals:\n  {sql_query}")

report = f"""
Product: {s}
Length : {len(s)}
Upper  : {s.upper()}
""".strip()
print(f"\nf-string multiline:\n{report}")

NoneType — The Absence of a Value

None is Python's null value. It is a singleton — there is exactly one None object in any Python process. It represents the absence of a value and is the implicit return value of any function that does not return anything explicitly.

copy# None is a singleton — only one exists
a = None
b = None
print(f"a is b     : {a is b}")   # always True
print(f"a == b     : {a == b}")   # also True
print(f"type(None) : {type(None)}")

# Functions that don't return explicitly return None
def do_nothing():
    pass

result = do_nothing()
print(f"\ndo_nothing() returned : {result!r}")
print(f"is None               : {result is None}")

# None as a sentinel / missing-value marker
def find_user(user_id, db):
    return db.get(user_id)   # dict.get() returns None if key missing

users = {1: "Alice", 2: "Bob"}

for uid in [1, 3]:
    user = find_user(uid, users)
    if user is None:
        print(f"\nUser {uid} not found")
    else:
        print(f"\nUser {uid}: {user}")

# None vs False vs 0 vs "" — all falsy, but not the same
candidates = [None, False, 0, 0.0, "", [], {}]
for v in candidates:
    print(f"  {v!r:8} is None: {v is None}   bool: {bool(v)}")

Mutable vs Immutable — Why It Matters

This is the concept that causes more confusion for Python beginners than any other. When you assign a variable in Python, you are not copying the value — you are creating a name that points at an object. Whether that object can be changed in place depends on whether its type is mutable.

copy# IMMUTABLE — rebinding creates a new object
x = 10
y = x              # y points at the same int object as x
print(f"Before: x={x}  y={y}  same object: {x is y}")

x = 20             # x now points at a NEW int object
print(f"After:  x={x}  y={y}  same object: {x is y}")
# y is unchanged — it still points at the 10 object

# MUTABLE — mutation affects all names pointing at the object
a = [1, 2, 3]
b = a              # b points at the SAME list object as a
print(f"\nBefore: a={a}  b={b}  same object: {a is b}")

a.append(4)        # mutates the object both a and b point at
print(f"After:  a={a}  b={b}  same object: {a is b}")
# b changed even though we only wrote to a!

# To get an independent copy, you must copy explicitly
c = a.copy()       # or list(a) or a[:]
print(f"\nc = a.copy(): c={c}  same object: {a is c}")
a.append(5)
print(f"After a.append(5): a={a}  c={c}  (c unaffected)")

This also explains why using a mutable default argument in a function definition is a classic Python trap:

copy# MUTABLE DEFAULT ARGUMENT TRAP
# The default list is created ONCE when the function is defined.
# Every call that doesn't pass 'items' shares that same list object.

def add_item_bad(item, items=[]):   # list created once at definition time
    items.append(item)
    return items

print(add_item_bad("apple"))    # ['apple']
print(add_item_bad("banana"))   # ['apple', 'banana']  — not what you wanted!
print(add_item_bad("cherry"))   # ['apple', 'banana', 'cherry']

# CORRECT pattern: use None as default, create fresh list inside
def add_item_good(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

print()
print(add_item_good("apple"))    # ['apple']
print(add_item_good("banana"))   # ['banana']   — fresh list each time
print(add_item_good("cherry"))   # ['cherry']

Sequences: list, tuple, range

Sequences are ordered collections where each element has a position you can access by index. Python's three most common sequence types differ in mutability and purpose.

copyimport sys

# list — mutable, heterogeneous, resizable
scores = [92, 87, 95, 74, 88]
scores.append(100)
scores.sort(reverse=True)
print(f"scores (sorted): {scores}")
print(f"top 3          : {scores[:3]}")
print(f"list size      : {sys.getsizeof(scores)} bytes")

# tuple — immutable, often used as a record (fixed structure)
point_3d  = (3.0, -1.5, 7.2)
rgb_red   = (255, 0, 0)
person    = ("Alice", 31, "engineer")

# Tuple unpacking — assigns each element to a name in one line
name, age, role = person
print(f"\n{name} is a {age}-year-old {role}")

# Swap via tuple unpacking — no temp variable needed
a, b = 10, 20
print(f"\nBefore swap: a={a}  b={b}")
a, b = b, a
print(f"After swap : a={a}  b={b}")

# Tuple as dict key (hashable); list as dict key raises TypeError
location_data = {
    (40.7128, -74.0060): "New York",
    (51.5074, -0.1278):  "London",
}
print(f"\n{location_data[(40.7128, -74.0060)]}")

try:
    bad = {[1, 2]: "value"}
except TypeError as e:
    print(f"List as key fails: {e}")

# range — lazy integer sequence, extremely memory-efficient
r = range(0, 1_000_000)
print(f"\nrange(0, 1_000_000) size : {sys.getsizeof(r)} bytes")
print(f"list of same range size  : {sys.getsizeof(list(r))} bytes")
print(f"500_000 in range         : {500_000 in r}")   # O(1) check

Mappings and Sets: dict, set, frozenset

dict stores key-value pairs. Keys must be hashable (immutable types). Since Python 3.7, dicts preserve insertion order. set stores unique hashable elements with no order. frozenset is an immutable set — hashable and usable as a dict key.

copy# dict — key-value store, insertion-ordered (Python 3.7+)
product = {
    "name"  : "Widget A",
    "stock" : 42,
    "price" : 4.99,
    "tags"  : ["sale", "featured"],
}

# Safe access — get() returns None (or a default) if key missing
print(product.get("name"))
print(product.get("discount", 0.0))    # key missing — returns default

# Iterating over all three views
print("\nKeys   :", list(product.keys()))
print("Values :", list(product.values()))
print("Items  :", [(k, v) for k, v in product.items() if k != "tags"])

# Merging dicts — Python 3.9+ | operator
defaults = {"stock": 0, "price": 0.0, "active": True}
merged   = defaults | product          # product values win conflicts
print(f"\nmerged active: {merged['active']}")
print(f"merged stock : {merged['stock']}")

# set — unique values, O(1) membership test
raw_tags  = ["sale", "featured", "sale", "new", "featured", "clearance"]
tag_set   = set(raw_tags)
print(f"\nraw_tags : {raw_tags}")
print(f"tag_set  : {tag_set}   (duplicates removed)")

# Set operations
a = {"sale", "featured", "new"}
b = {"new", "clearance", "featured"}

print(f"\na | b (union)        : {a | b}")
print(f"a & b (intersection) : {a & b}")
print(f"a - b (difference)   : {a - b}")
print(f"a ^ b (symmetric diff): {a ^ b}")

# frozenset — immutable, hashable, usable as dict key
perm_set = frozenset({"read", "write"})
role_permissions = {
    frozenset({"read"}):               "viewer",
    frozenset({"read", "write"}):      "editor",
    frozenset({"read", "write", "admin"}): "admin",
}
user_perms = frozenset({"read", "write"})
print(f"\nRole for {user_perms}: {role_permissions.get(user_perms, 'unknown')}")

copy# type() returns the exact type — no inheritance
values = [42, 3.14, True, "hello", None, [1, 2], (1, 2), {}, set()]

print("type() results:")
for v in values:
    print(f"  type({v!r:12}) = {type(v).__name__}")

# isinstance() respects inheritance
print("\nisinstance() with bool:")
print(f"  isinstance(True, bool) : {isinstance(True, bool)}")
print(f"  isinstance(True, int)  : {isinstance(True, int)}")   # True — bool IS an int
print(f"  type(True) == int      : {type(True) == int}")        # False — exact match fails

# isinstance() accepts a tuple of types — checks any match
def describe(value):
    if isinstance(value, bool):        # check bool BEFORE int (bool is subclass)
        return f"{value!r} is a bool"
    elif isinstance(value, int):
        return f"{value!r} is an int"
    elif isinstance(value, float):
        return f"{value!r} is a float"
    elif isinstance(value, (list, tuple)):
        return f"{value!r} is a sequence of {len(value)} items"
    elif isinstance(value, str):
        return f"{value!r} is a str of length {len(value)}"
    elif value is None:
        return "value is None"
    else:
        return f"unknown type: {type(value).__name__}"

tests = [True, 42, 3.14, "hi", [1, 2, 3], (4, 5), None]
for t in tests:
    print(f"  {describe(t)}")

copy# Python is strongly typed — no silent coercion
try:
    result = "3" + 3
except TypeError as e:
    print(f"'3' + 3 raises: {e}")

# Explicit conversion with constructor functions
print(f"\nint('42')        = {int('42')}")
print(f"int(3.9)         = {int(3.9)}")    # truncates, does NOT round
print(f"int('0b1010', 2) = {int('0b1010', 2)}")   # binary string -> int
print(f"int('ff', 16)    = {int('ff', 16)}")       # hex string -> int

print(f"\nfloat('3.14')    = {float('3.14')}")
print(f"float(7)         = {float(7)}")

print(f"\nstr(42)          = {str(42)!r}")
print(f"str(3.14)        = {str(3.14)!r}")
print(f"str(True)        = {str(True)!r}")

# List/tuple/set conversions — useful for deduplication and transformation
words = ("the", "quick", "brown", "fox", "the", "fox")
print(f"\ntuple -> set -> list (unique): {sorted(set(words))}")

# Converting input() — always returns str
# user_age = input("Age: ")   # returns "25" not 25
# age = int(user_age)         # explicit conversion required

# Implicit numeric coercion — the one place Python IS permissive
print(f"\nint + float  : {1 + 2.0}   type: {type(1 + 2.0).__name__}")
print(f"bool + int   : {True + 4}   type: {type(True + 4).__name__}")
print(f"bool + float : {True + 1.5} type: {type(True + 1.5).__name__}")

# round() vs int() — different behavior
print(f"\nround(3.5) = {round(3.5)}   int(3.5) = {int(3.5)}")
print(f"round(4.5) = {round(4.5)}   int(4.5) = {int(4.5)}")
# Python uses banker's rounding (round half to even)