• Readability counts
• Explicit is better than implicit
• Simple is better than complex
• Errors should never pass silently
• Practicality beats purity

import this

• Indentation defines code blocks
• 4 spaces per level (PEP 8)
• Tabs and spaces should not be mixed

if x > 0:
    print("Positive")
else:
    print("Not positive")

• Single-line comments start with #
• Inline comments are written after code
• Docstrings use triple quotes and document APIs

def add(a, b):
    """
    Returns the sum of two numbers.
    """
    return a + b

• Python favors expressions over statements

result = "yes" if x > 0 else "no"

• True and False are boolean values
• bool is a subclass of int
• Implicit truthiness is preferred

isinstance(True, int)  # True

• Strings are immutable
• Unicode by default in Python 3

s = "Python"
s[0]  # 'P'
s[-1] # 'n'

• Represents absence of value
• Singleton object
• Use 'is None' for comparison

x = None
x is None  # ✔ preferred

• Identifiers must start with a letter or underscore
• Cannot use Python keywords as names

user_name = "Alice"
_private = 42

• Variables can change type
• Type checking happens at runtime
• Python is strongly typed

x = 10
x = "now a string"

• Assign multiple variables at once
• Swap variables without temporary variables

a, b = 1, 2
a, b = b, a
x, *rest = [1, 2, 3, 4]

• Ordered collection
• Mutable
• Heterogeneous elements allowed

lst = [1, 2, 3]
lst.append(4)

• Immutable
• Hashable if elements are hashable
• Faster than lists

t = (1, 2, 3)

• Lazy sequence
• Memory efficient

range(0, 10, 2)

• Supports positive and negative indexing
• Slicing creates a new object

lst[1]
lst[-1]
lst[1:4]
lst[::-1]

• Stores unique elements
• Unordered collection

s = {1, 2, 3}
empty = set()  # {} creates a dict

• Union, intersection, difference, symmetric difference

a | b   # union
a & b   # intersection
a - b   # difference
a ^ b   # symmetric difference

• Immutable
• Hashable
• Can be dictionary keys

fs = frozenset([1, 2, 3])

• Ordered in Python 3.7+
• Fast lookups

d = {"a": 1, "b": 2}

• Keys must be hashable
• Lists, dicts, and sets cannot be keys

# Valid: int, str, tuple
# Invalid: list, dict, set

• Access keys, values, and items
• Safely retrieve values with defaults

d.keys()
d.values()
d.items()
d.get("a", 0)
d.pop("a")

• Values can themselves be dictionaries

users = {
    "u1": {"age": 20, "active": True}
}

• Strings are immutable
• Provide rich built-in methods

s.lower()
s.upper()
s.strip()
s.replace("a", "b")
s.split(",")

• f-strings are preferred
• format() is still supported

name = "Ada"
age = 30
f"{name} is {age}"
"{:.2f}".format(3.14159)

• Strings are Unicode
• Bytes represent encoded data

text = "café"
encoded = text.encode("utf-8")
decoded = encoded.decode("utf-8")

• Used for validation, parsing, and pattern searching

import re
re.search(r"\d+", "abc123")
re.findall(r"\w+", "hello world")

• Conditions evaluated top-down
• First matching block executes
• No switch-case before Python 3.10

if x > 0:
    result = "positive"
elif x == 0:
    result = "zero"
else:
    result = "negative"

• Supports and, or, not operators
• Uses short-circuit evaluation

x and func()   # func() runs only if x is truthy
x or default   # returns first truthy value

• Expression, not a statement
• Useful for simple conditions
• Avoid nesting for readability

status = "adult" if age >= 18 else "minor"

• More powerful than switch-case
• Supports destructuring and guards

match value:
    case 1:
        print("one")
    case 2 | 3:
        print("two or three")
    case _:
        print("default")

• Supports tuple unpacking

match point:
    case (0, 0):
        print("origin")
    case (x, y):
        print(x, y)

• Iterates directly over iterables
• Does not rely on index implicitly

for i in range(5):
    print(i)

• Condition checked before each iteration
• Risk of infinite loops if condition never changes

while condition:
    do_something()

• Use break and continue to control flow

for i in range(5):
    if i == 2:
        continue
    if i == 4:
        break

• Loops can be nested
• Often result in O(n²) complexity

for i in range(3):
    for j in range(2):
        print(i, j)

• Executes only if loop does not break
• Common interview question

for x in nums:
    if x == target:
        break
else:
    print("Not found")

• Lazy sequence
• Uses constant memory

range(5)
range(1, 10, 2)

• Provides index and value pairs
• Preferred over manual indexing

for index, value in enumerate(items):
    print(index, value)

• Iterates over multiple iterables
• Stops at the shortest iterable

for a, b in zip(list1, list2):
    print(a, b)

• Iterators are exhausted after use

it = iter([1, 2, 3])
next(it)

• Functions are defined using def
• Functions can return values

def greet(name):
    return f"Hello {name}"

greet("Alice")

• Functions return None implicitly
• Multiple values are returned as a tuple

def f():
    return 1, 2

a, b = f()

• Default values evaluated once at definition time

def add(x, y=10):
    return x + y

• Improves readability
• Prevents misuse of arguments

def func(a, *, b):
    return a + b

• *args collects positional arguments
• **kwargs collects keyword arguments

def f(*args, **kwargs):
    print(args)
    print(kwargs)

• Used by help()
• Essential for APIs and libraries

def add(a, b):
    """Return the sum of a and b."""
    return a + b

• Anonymous functions
• Single expression only
• Avoid complex lambdas

square = lambda x: x * x

• Operate on iterables
• Functional-style transformations

map(lambda x: x*2, nums)
filter(lambda x: x > 0, nums)

from functools import reduce
reduce(lambda a, b: a + b, nums)

• Concise and readable
• Considered Pythonic

[x*x for x in range(5)]
{x for x in nums if x > 0}
{k: v for k, v in pairs}

• else runs only if no exception occurs
• finally always runs for cleanup

try:
    x = int("10")
except ValueError:
    print("Conversion failed")
else:
    print("Success:", x)
finally:
    print("Always runs")

• Use a tuple to catch multiple exception types

try:
    risky()
except (TypeError, ValueError) as e:
    print(e)

• Use raise to signal exceptional conditions

if age < 0:
    raise ValueError("Age cannot be negative")

• Classes define object blueprints
• __init__ initializes object state

class Person:
    def __init__(self, name):
        self.name = name

    def greet(self):
        return f"Hello, {self.name}"

p = Person("Alice")
p.greet()

• Called automatically on object creation
• Initializes object state
• Forgetting self is a common mistake

def __init__(self, value):
    self.value = value

• _var indicates internal use
• __var triggers name mangling
• Access control is based on convention

class Account:
    def __init__(self, balance):
        self._balance = balance

• Child classes can override parent behavior
• Supports multiple inheritance

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof"

• Same interface, different behavior
• Duck typing is common in Python

def make_sound(animal):
    return animal.speak()

• Defines required interface
• Abstract classes cannot be instantiated

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

• __repr__ helps debugging

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __repr__(self):
        return f"Point({self.x}, {self.y})"

• Automatically generates boilerplate code
• Best suited for data containers

from dataclasses import dataclass

@dataclass
class User:
    name: str
    age: int