Beginner

# Basic print
print("Hello, World!")           # => Output: Hello, World!

# Multiple arguments (space-separated by default)
print("Hello", "Python", "3")    # => Output: Hello Python 3

# Custom separator
print("A", "B", "C", sep="-")    # => Output: A-B-C

# Custom end character (default is newline)
print("Same line", end=" ")      # => Output: Same line (no newline)
print("continues")                # => Output: continues

# Printing variables
name = "Alice"                    # => name is "Alice" (type: str)
age = 30                          # => age is 30 (type: int)
print("Name:", name, "Age:", age) # => Output: Name: Alice Age: 30

# Dynamic typing - no type declarations needed
x = 42                            # => x is 42 (type: int)
print(type(x))                    # => Output: <class 'int'>

# Reassign to different type
x = "now a string"                # => x is "now a string" (type: str)
print(type(x))                    # => Output: <class 'str'>

# Multiple assignment
a, b, c = 1, 2, 3                 # => a is 1, b is 2, c is 3
print(a, b, c)                    # => Output: 1 2 3

# Swap variables (Pythonic idiom)
a, b = b, a                       # => a is 2, b is 1 (swapped!)
print(a, b)                       # => Output: 2 1

# Chain assignment
x = y = z = 0                     # => x, y, z all equal 0
print(x, y, z)                    # => Output: 0 0 0

# Integer arithmetic
a = 10                            # => a is 10 (type: int)
b = 3                             # => b is 3 (type: int)

print(a + b)                      # => Output: 13 (addition)
print(a - b)                      # => Output: 7 (subtraction)
print(a * b)                      # => Output: 30 (multiplication)
print(a / b)                      # => Output: 3.3333... (float division)
print(a // b)                     # => Output: 3 (floor division, integer result)
print(a % b)                      # => Output: 1 (modulo, remainder)
print(a ** b)                     # => Output: 1000 (exponentiation, 10^3)

# Float arithmetic
pi = 3.14159                      # => pi is 3.14159 (type: float)
radius = 5.0                      # => radius is 5.0 (type: float)
area = pi * radius ** 2           # => area is 78.53975 (π × 5²)
print(f"Area: {area:.2f}")        # => Output: Area: 78.54 (formatted to 2 decimals)

# Integer unlimited precision
big = 10 ** 100                   # => big is 1 followed by 100 zeros
print(big)                        # => Output: 100000000000... (no overflow!)

# Complex numbers
z = 3 + 4j                        # => z is (3+4j) (type: complex)
print(abs(z))                     # => Output: 5.0 (magnitude: √(3²+4²))

# String creation (single or double quotes)
name = "Alice"                    # => name is "Alice" (type: str)
greeting = 'Hello'                # => greeting is "Hello" (single quotes equivalent)

# String concatenation
message = greeting + ", " + name  # => message is "Hello, Alice"
print(message)                    # => Output: Hello, Alice

# String repetition
laugh = "ha" * 3                  # => laugh is "hahahaha"
print(laugh)                      # => Output: hahaha

# String methods (immutable - return new strings)
text = "  Python Programming  "   # => text has leading/trailing spaces
print(text.strip())               # => Output: Python Programming (spaces removed)
print(text.upper())               # => Output:   PYTHON PROGRAMMING   (uppercase)
print(text.lower())               # => Output:   python programming   (lowercase)
print(text.replace("Python", "Go"))# => Output:   Go Programming   (replaced)

# Original string unchanged (immutability)
print(text)                       # => Output:   Python Programming   (unchanged!)

# String splitting and joining
words = "apple,banana,cherry"     # => words is "apple,banana,cherry"
fruits = words.split(",")         # => fruits is ["apple", "banana", "cherry"] (list)
print(fruits)                     # => Output: ['apple', 'banana', 'cherry']

joined = "-".join(fruits)         # => joined is "apple-banana-cherry"
print(joined)                     # => Output: apple-banana-cherry

# String formatting (f-strings, Python 3.6+)
age = 30                          # => age is 30
print(f"{name} is {age} years old")# => Output: Alice is 30 years old

# Multiline strings
poem = """Line one
Line two
Line three"""                     # => poem is 3-line string
print(poem)                       # => Output: (3 lines)

# Boolean values
is_active = True                  # => is_active is True (type: bool)
is_deleted = False                # => is_deleted is False (type: bool)

# Comparison operators
x = 10                            # => x is 10
y = 20                            # => y is 20

print(x == y)                     # => Output: False (equal)
print(x != y)                     # => Output: True (not equal)
print(x < y)                      # => Output: True (less than)
print(x <= y)                     # => Output: True (less than or equal)
print(x > y)                      # => Output: False (greater than)
print(x >= y)                     # => Output: False (greater than or equal)

# Logical operators (and, or, not)
a = True                          # => a is True
b = False                         # => b is False

print(a and b)                    # => Output: False (both must be True)
print(a or b)                     # => Output: True (at least one True)
print(not a)                      # => Output: False (negation)

# Short-circuit evaluation
def expensive():
    print("Expensive function called")
    return True

result = False and expensive()    # => expensive() NOT called (short-circuit!)
print(result)                     # => Output: False (no "Expensive..." printed)

result = True or expensive()      # => expensive() NOT called (short-circuit!)
print(result)                     # => Output: True (no "Expensive..." printed)

# Truthy and falsy values
print(bool(0))                    # => Output: False (0 is falsy)
print(bool(""))                   # => Output: False (empty string is falsy)
print(bool([]))                   # => Output: False (empty list is falsy)
print(bool(42))                   # => Output: True (non-zero numbers truthy)
print(bool("text"))               # => Output: True (non-empty strings truthy)

# Basic if statement
age = 18                          # => age is 18
if age >= 18:
    print("Adult")                # => Output: Adult (condition is True)

# if-else
score = 75                        # => score is 75
if score >= 80:
    grade = "A"
else:
    grade = "B"                   # => grade is "B" (score < 80)
print(f"Grade: {grade}")          # => Output: Grade: B

# if-elif-else chain
temperature = 15                  # => temperature is 15
if temperature > 30:
    status = "Hot"
elif temperature > 20:
    status = "Warm"
elif temperature > 10:
    status = "Cool"               # => status is "Cool" (10 < temp <= 20)
else:
    status = "Cold"
print(f"Status: {status}")        # => Output: Status: Cool

# Nested conditions
x = 10                            # => x is 10
y = 20                            # => y is 20
if x > 0:
    if y > 0:
        print("Both positive")    # => Output: Both positive
    else:
        print("x positive, y not")
else:
    print("x not positive")

# Ternary operator (conditional expression)
age = 25                          # => age is 25
status = "adult" if age >= 18 else "minor"
                                  # => status is "adult" (age >= 18)
print(status)                     # => Output: adult

# Multiple conditions with logical operators
has_ticket = True                 # => has_ticket is True
is_vip = False                    # => is_vip is False
if has_ticket and is_vip:
    print("VIP entrance")
elif has_ticket:
    print("Regular entrance")     # => Output: Regular entrance
else:
    print("No entrance")

# Basic while loop
count = 0                         # => count is 0
while count < 5:
    print(f"Count: {count}")      # => Output: Count: 0, Count: 1, ..., Count: 4
    count += 1                    # => count increments: 1, 2, 3, 4, 5
                                  # => Loop exits when count is 5

# While with break
n = 0                             # => n is 0
while True:                       # => Infinite loop
    if n >= 3:
        break                     # => Exit loop when n is 3
    print(f"n: {n}")              # => Output: n: 0, n: 1, n: 2
    n += 1                        # => n increments: 1, 2, 3

# While with continue
i = 0                             # => i is 0
while i < 5:
    i += 1                        # => i increments: 1, 2, 3, 4, 5
    if i % 2 == 0:
        continue                  # => Skip even numbers (2, 4)
    print(f"Odd: {i}")            # => Output: Odd: 1, Odd: 3, Odd: 5

# While-else (else executes if loop completes without break)
x = 0                             # => x is 0
while x < 3:
    print(f"x: {x}")              # => Output: x: 0, x: 1, x: 2
    x += 1                        # => x increments: 1, 2, 3
else:
    print("Loop completed")       # => Output: Loop completed (no break occurred)

# While-else with break (else skipped)
y = 0                             # => y is 0
while y < 10:
    if y == 2:
        break                     # => Exit early at y=2
    y += 1
else:
    print("This won't print")     # => NOT executed (break occurred)

# Sentinel-controlled loop
user_input = ""                   # => user_input is ""
# Uncomment to test interactively:
# while user_input != "quit":
#     user_input = input("Enter 'quit' to exit: ")
#     print(f"You entered: {user_input}")

# Basic for loop with range (0 to n-1)
for i in range(5):                # => range(5) generates 0, 1, 2, 3, 4
    print(f"i: {i}")              # => Output: i: 0, i: 1, ..., i: 4

# Range with start and stop
for i in range(2, 6):             # => range(2, 6) generates 2, 3, 4, 5
    print(f"i: {i}")              # => Output: i: 2, i: 3, i: 4, i: 5

# Range with step
for i in range(0, 10, 2):         # => range(0, 10, 2) generates 0, 2, 4, 6, 8
    print(f"i: {i}")              # => Output: i: 0, i: 2, i: 4, i: 6, i: 8

# Reverse range
for i in range(5, 0, -1):         # => range(5, 0, -1) generates 5, 4, 3, 2, 1
    print(f"i: {i}")              # => Output: i: 5, i: 4, i: 3, i: 2, i: 1

# Iterating over strings
name = "Python"                   # => name is "Python"
for char in name:                 # => Iterates: 'P', 'y', 't', 'h', 'o', 'n'
    print(char)                   # => Output: P, y, t, h, o, n (one per line)

# Iterating over lists
fruits = ["apple", "banana", "cherry"]
                                  # => fruits is ["apple", "banana", "cherry"]
for fruit in fruits:              # => Iterates through each element
    print(fruit)                  # => Output: apple, banana, cherry (one per line)

# Enumerate for index and value
for index, fruit in enumerate(fruits):
                                  # => enumerate yields (0, "apple"), (1, "banana"), (2, "cherry")
    print(f"{index}: {fruit}")    # => Output: 0: apple, 1: banana, 2: cherry

# For-else (else executes if loop completes without break)
for i in range(3):
    print(i)                      # => Output: 0, 1, 2
else:
    print("Loop completed")       # => Output: Loop completed

# Nested loops
for i in range(3):                # => Outer loop: 0, 1, 2
    for j in range(2):            # => Inner loop: 0, 1 (for each i)
        print(f"({i}, {j})")      # => Output: (0,0), (0,1), (1,0), (1,1), (2,0), (2,1)

# List creation
numbers = [1, 2, 3, 4, 5]         # => numbers is [1, 2, 3, 4, 5] (type: list)
mixed = [1, "two", 3.0, True]     # => mixed is [1, "two", 3.0, True] (mixed types OK)
empty = []                        # => empty is [] (empty list)

# Indexing (0-based)
first = numbers[0]                # => first is 1 (index 0)
second = numbers[1]               # => second is 2 (index 1)
last = numbers[-1]                # => last is 5 (negative index from end)
second_last = numbers[-2]         # => second_last is 4

print(first, last)                # => Output: 1 5

# Slicing [start:stop:step]
subset = numbers[1:4]             # => subset is [2, 3, 4] (indices 1, 2, 3)
print(subset)                     # => Output: [2, 3, 4]

first_three = numbers[:3]         # => first_three is [1, 2, 3] (start to index 3)
print(first_three)                # => Output: [1, 2, 3]

last_two = numbers[-2:]           # => last_two is [4, 5] (last 2 elements)
print(last_two)                   # => Output: [4, 5]

every_second = numbers[::2]       # => every_second is [1, 3, 5] (step of 2)
print(every_second)               # => Output: [1, 3, 5]

reversed_list = numbers[::-1]     # => reversed_list is [5, 4, 3, 2, 1] (reversed)
print(reversed_list)              # => Output: [5, 4, 3, 2, 1]

# List length
length = len(numbers)             # => length is 5
print(f"Length: {length}")        # => Output: Length: 5

# Membership testing
has_three = 3 in numbers          # => has_three is True (3 exists in list)
has_ten = 10 in numbers           # => has_ten is False (10 not in list)
print(has_three, has_ten)         # => Output: True False

# List modification methods
fruits = ["apple", "banana"]      # => fruits is ["apple", "banana"]

# append() - add single element to end
fruits.append("cherry")           # => fruits is ["apple", "banana", "cherry"]
print(fruits)                     # => Output: ['apple', 'banana', 'cherry']

# extend() - add multiple elements
fruits.extend(["date", "elderberry"])
                                  # => fruits is ["apple", ..., "elderberry"]
print(fruits)                     # => Output: ['apple', 'banana', 'cherry', 'date', 'elderberry']

# insert() - add element at specific index
fruits.insert(1, "apricot")       # => Insert at index 1
                                  # => fruits is ["apple", "apricot", "banana", ...]
print(fruits)                     # => Output: ['apple', 'apricot', 'banana', ...]

# remove() - remove first occurrence of value
fruits.remove("banana")           # => Removes "banana"
                                  # => fruits is ["apple", "apricot", "cherry", ...]
print(fruits)                     # => Output: ['apple', 'apricot', 'cherry', 'date', 'elderberry']

# pop() - remove and return element at index (default: last)
last = fruits.pop()               # => last is "elderberry", removed from list
print(last)                       # => Output: elderberry
print(fruits)                     # => Output: ['apple', 'apricot', 'cherry', 'date']

popped = fruits.pop(1)            # => popped is "apricot", removed from index 1
print(popped)                     # => Output: apricot
print(fruits)                     # => Output: ['apple', 'cherry', 'date']

# clear() - remove all elements
backup = fruits.copy()            # => backup is ["apple", "cherry", "date"] (shallow copy)
fruits.clear()                    # => fruits is [] (empty)
print(fruits)                     # => Output: []
print(backup)                     # => Output: ['apple', 'cherry', 'date'] (unchanged)

# Index assignment
numbers = [1, 2, 3, 4, 5]         # => numbers is [1, 2, 3, 4, 5]
numbers[0] = 10                   # => numbers is [10, 2, 3, 4, 5]
numbers[-1] = 50                  # => numbers is [10, 2, 3, 4, 50]
print(numbers)                    # => Output: [10, 2, 3, 4, 50]

# Slice assignment
numbers[1:3] = [20, 30, 35]       # => Replace indices 1-2 with 3 elements
                                  # => numbers is [10, 20, 30, 35, 4, 50]
print(numbers)                    # => Output: [10, 20, 30, 35, 4, 50]

# Sorting
unsorted = [3, 1, 4, 1, 5, 9]     # => unsorted is [3, 1, 4, 1, 5, 9]
unsorted.sort()                   # => unsorted is [1, 1, 3, 4, 5, 9] (in-place)
print(unsorted)                   # => Output: [1, 1, 3, 4, 5, 9]

# sorted() - returns new sorted list
original = [3, 1, 4]              # => original is [3, 1, 4]
sorted_copy = sorted(original)    # => sorted_copy is [1, 3, 4]
print(original)                   # => Output: [3, 1, 4] (unchanged)
print(sorted_copy)                # => Output: [1, 3, 4]

# Tuple creation
point = (3, 4)                    # => point is (3, 4) (type: tuple)
colors = ("red", "green", "blue") # => colors is ("red", "green", "blue")
single = (42,)                    # => single is (42,) (comma required for single element!)
not_tuple = (42)                  # => not_tuple is 42 (type: int, NOT tuple!)

print(type(point))                # => Output: <class 'tuple'>
print(type(single))               # => Output: <class 'tuple'>
print(type(not_tuple))            # => Output: <class 'int'>

# Indexing and slicing (same as lists)
first = point[0]                  # => first is 3
second = point[1]                 # => second is 4
subset = colors[1:]               # => subset is ("green", "blue")
print(first, second)              # => Output: 3 4
print(subset)                     # => Output: ('green', 'blue')

# Unpacking
x, y = point                      # => x is 3, y is 4
print(f"x={x}, y={y}")            # => Output: x=3, y=4

# Multiple unpacking
r, g, b = colors                  # => r is "red", g is "green", b is "blue"
print(r, g, b)                    # => Output: red green blue

# Unpacking with * (rest)
numbers = (1, 2, 3, 4, 5)         # => numbers is (1, 2, 3, 4, 5)
first, *rest, last = numbers      # => first is 1, rest is [2, 3, 4], last is 5
print(first)                      # => Output: 1
print(rest)                       # => Output: [2, 3, 4] (list!)
print(last)                       # => Output: 5

# Immutability
try:
    point[0] = 10                 # => Attempt to modify
except TypeError as e:
    print(f"Error: {e}")          # => Output: Error: 'tuple' object does not support item assignment

# Tuple methods (limited due to immutability)
nums = (1, 2, 3, 2, 1)            # => nums is (1, 2, 3, 2, 1)
count_of_twos = nums.count(2)     # => count_of_twos is 2 (two occurrences of 2)
index_of_three = nums.index(3)    # => index_of_three is 2 (3 is at index 2)
print(count_of_twos, index_of_three)# => Output: 2 2

# Tuple as dictionary key (lists can't do this!)
locations = {}                    # => locations is {} (empty dict)
locations[(0, 0)] = "origin"      # => Tuple as key works!
locations[(1, 1)] = "diagonal"
print(locations[(0, 0)])          # => Output: origin

# Named tuples (more readable alternative - requires import)
from collections import namedtuple

Point = namedtuple("Point", ["x", "y"])
                                  # => Define Point type with x, y fields
p = Point(3, 4)                   # => p is Point(x=3, y=4)
print(p.x, p.y)                   # => Output: 3 4 (access by name)
print(p[0], p[1])                 # => Output: 3 4 (still indexable)

# Dictionary creation
person = {
    "name": "Alice",
    "age": 30,
    "city": "New York"
}                                 # => person is {"name": "Alice", ...}

# Access by key
name = person["name"]             # => name is "Alice"
age = person["age"]               # => age is 30
print(name, age)                  # => Output: Alice 30

# Access with get() (returns None or default if key missing)
city = person.get("city")         # => city is "New York"
country = person.get("country")   # => country is None (key doesn't exist)
country_default = person.get("country", "USA")
                                  # => country_default is "USA" (default provided)
print(city, country, country_default)
                                  # => Output: New York None USA

# Add or update key-value pairs
person["email"] = "alice@example.com"
                                  # => person has new key "email"
person["age"] = 31                # => age updated to 31
print(person)                     # => Output: {'name': 'Alice', 'age': 31, ...}

# Delete key-value pairs
del person["city"]                # => "city" key removed
print(person)                     # => Output: {'name': 'Alice', 'age': 31, 'email': ...}

removed = person.pop("email")     # => removed is "alice@example.com", key deleted
print(removed)                    # => Output: alice@example.com
print(person)                     # => Output: {'name': 'Alice', 'age': 31}

# Membership testing (checks keys, not values)
has_name = "name" in person       # => has_name is True
has_city = "city" in person       # => has_city is False (deleted earlier)
print(has_name, has_city)         # => Output: True False

# Iterating over dictionaries
scores = {"Alice": 95, "Bob": 87, "Charlie": 92}

# Iterate over keys (default)
for name in scores:
    print(name)                   # => Output: Alice, Bob, Charlie

# Iterate over keys explicitly
for name in scores.keys():
    print(name)                   # => Output: Alice, Bob, Charlie

# Iterate over values
for score in scores.values():
    print(score)                  # => Output: 95, 87, 92

# Iterate over key-value pairs
for name, score in scores.items():
    print(f"{name}: {score}")     # => Output: Alice: 95, Bob: 87, Charlie: 92

# Dictionary methods
grades = {"math": 90, "english": 85}
                                  # => grades is {"math": 90, "english": 85}

# update() - merge another dictionary
grades.update({"science": 88, "math": 92})
                                  # => grades is {"math": 92, "english": 85, "science": 88}
print(grades)                     # => Output: {'math': 92, 'english': 85, 'science': 88}

# setdefault() - get value or set default if missing
history = grades.setdefault("history", 80)
                                  # => history is 80 (set because key missing)
math = grades.setdefault("math", 0)
                                  # => math is 92 (key exists, no change)
print(history, math)              # => Output: 80 92
print(grades)                     # => Output: {..., 'history': 80}

# Set creation
numbers = {1, 2, 3, 4, 5}         # => numbers is {1, 2, 3, 4, 5} (type: set)
empty_set = set()                 # => empty_set is set() (use set(), NOT {})
not_empty_set = {}                # => This is an empty DICT, not set!

print(type(numbers))              # => Output: <class 'set'>
print(type(empty_set))            # => Output: <class 'set'>
print(type(not_empty_set))        # => Output: <class 'dict'>

# Duplicate elimination
duplicates = {1, 2, 2, 3, 3, 3}   # => duplicates is {1, 2, 3} (duplicates removed)
print(duplicates)                 # => Output: {1, 2, 3}

# Set from list (removes duplicates)
list_with_dupes = [1, 2, 2, 3, 3, 3]
unique = set(list_with_dupes)     # => unique is {1, 2, 3}
print(unique)                     # => Output: {1, 2, 3}

# Add and remove elements
fruits = {"apple", "banana"}      # => fruits is {"apple", "banana"}
fruits.add("cherry")              # => fruits is {"apple", "banana", "cherry"}
print(fruits)                     # => Output: {'apple', 'banana', 'cherry'}

fruits.remove("banana")           # => fruits is {"apple", "cherry"}
print(fruits)                     # => Output: {'apple', 'cherry'}

# discard() vs remove() - discard doesn't raise error if missing
fruits.discard("banana")          # => No error (banana already removed)
try:
    fruits.remove("banana")       # => Raises KeyError (banana not in set)
except KeyError:
    print("KeyError: banana not found")
                                  # => Output: KeyError: banana not found

# Membership testing
has_apple = "apple" in fruits     # => has_apple is True
has_banana = "banana" in fruits   # => has_banana is False
print(has_apple, has_banana)      # => Output: True False

# Set operations
a = {1, 2, 3, 4}                  # => a is {1, 2, 3, 4}
b = {3, 4, 5, 6}                  # => b is {3, 4, 5, 6}

# Union (all elements from both sets)
union = a | b                     # => union is {1, 2, 3, 4, 5, 6}
union_method = a.union(b)         # => Same result
print(union)                      # => Output: {1, 2, 3, 4, 5, 6}

# Intersection (common elements)
intersection = a & b              # => intersection is {3, 4}
intersection_method = a.intersection(b)# => Same result
print(intersection)               # => Output: {3, 4}

# Difference (elements in a but not in b)
difference = a - b                # => difference is {1, 2}
difference_method = a.difference(b)# => Same result
print(difference)                 # => Output: {1, 2}

# Symmetric difference (elements in either set but not both)
sym_diff = a ^ b                  # => sym_diff is {1, 2, 5, 6}
sym_diff_method = a.symmetric_difference(b)# => Same result
print(sym_diff)                   # => Output: {1, 2, 5, 6}

# Subset and superset
small = {1, 2}                    # => small is {1, 2}
large = {1, 2, 3, 4}              # => large is {1, 2, 3, 4}
is_subset = small.issubset(large) # => is_subset is True (small ⊆ large)
is_superset = large.issuperset(small)# => is_superset is True (large ⊇ small)
print(is_subset, is_superset)     # => Output: True True

# Basic function definition
def greet(name):
    """Return a greeting message."""# => Docstring (optional but recommended)
    return f"Hello, {name}!"

# Function call
message = greet("Alice")          # => message is "Hello, Alice!"
print(message)                    # => Output: Hello, Alice!

# Function with multiple parameters
def add(a, b):
    """Add two numbers and return result."""
    return a + b

result = add(5, 3)                # => result is 8
print(result)                     # => Output: 8

# Default arguments
def power(base, exponent=2):
    """Raise base to exponent (default: 2)."""
    return base ** exponent

square = power(5)                 # => square is 25 (5^2, default exponent)
cube = power(5, 3)                # => cube is 125 (5^3, explicit exponent)
print(square, cube)               # => Output: 25 125

# Keyword arguments
def describe_pet(animal, name):
    """Print pet description."""
    return f"I have a {animal} named {name}"

# Positional arguments
desc1 = describe_pet("dog", "Buddy")# => desc1 is "I have a dog named Buddy"

# Keyword arguments (order doesn't matter)
desc2 = describe_pet(name="Whiskers", animal="cat")
                                  # => desc2 is "I have a cat named Whiskers"
print(desc1)                      # => Output: I have a dog named Buddy
print(desc2)                      # => Output: I have a cat named Whiskers

# Multiple return values (returns tuple)
def min_max(numbers):
    """Return minimum and maximum of a list."""
    return min(numbers), max(numbers)

minimum, maximum = min_max([1, 5, 3, 9, 2])
                                  # => minimum is 1, maximum is 9
print(f"Min: {minimum}, Max: {maximum}")
                                  # => Output: Min: 1, Max: 9

# No return value (implicitly returns None)
def print_greeting(name):
    """Print greeting (no return)."""
    print(f"Hello, {name}!")

result = print_greeting("Bob")    # => Prints "Hello, Bob!", result is None
print(result)                     # => Output: None

# *args for variable positional arguments
def sum_all(*args):
    """Sum any number of arguments."""
    total = 0                     # => total is 0
    for num in args:              # => args is tuple of all arguments
        total += num
    return total

print(sum_all(1, 2, 3))           # => Output: 6
print(sum_all(1, 2, 3, 4, 5))     # => Output: 15

# **kwargs for variable keyword arguments
def print_info(**kwargs):
    """Print all keyword arguments."""
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_info(name="Alice", age=30, city="NYC")
                                  # => Output: name: Alice, age: 30, city: NYC

# Combining all parameter types
def complex_func(pos1, pos2, *args, kwarg1="default", **kwargs):
    """Demonstrate all parameter types."""
    print(f"Positional: {pos1}, {pos2}")
    print(f"*args: {args}")
    print(f"kwarg1: {kwarg1}")
    print(f"**kwargs: {kwargs}")

complex_func(1, 2, 3, 4, kwarg1="custom", extra="value")
# => Output: Positional: 1, 2
#    *args: (3, 4)
#    kwarg1: custom
#    **kwargs: {'extra': 'value'}

# Global variable
counter = 0                       # => counter is 0 (global scope)

def increment():
    global counter                # => Declare intent to modify global counter
    counter += 1                  # => counter is now 1 (modifies global)
    return counter

result = increment()              # => result is 1, global counter is 1
print(f"Result: {result}, Global: {counter}")
                                  # => Output: Result: 1, Global: 1

# Without global keyword (creates local variable)
x = 10                            # => x is 10 (global)

def set_x():
    x = 20                        # => Creates local x (shadows global)
    print(f"Local x: {x}")        # => Output: Local x: 20

set_x()
print(f"Global x: {x}")           # => Output: Global x: 10 (unchanged!)

# Enclosing scope with nonlocal
def outer():
    y = 5                         # => y is 5 (enclosing scope)

    def inner():
        nonlocal y                # => Declare intent to modify enclosing y
        y += 1                    # => y is now 6 (modifies enclosing)
        print(f"Inner y: {y}")    # => Output: Inner y: 6

    inner()
    print(f"Outer y: {y}")        # => Output: Outer y: 6 (modified by inner!)

outer()

# Without nonlocal (creates local variable)
def outer2():
    z = 10                        # => z is 10 (enclosing scope)

    def inner2():
        z = 20                    # => Creates local z (shadows enclosing)
        print(f"Inner z: {z}")    # => Output: Inner z: 20

    inner2()
    print(f"Outer z: {z}")        # => Output: Outer z: 10 (unchanged!)

outer2()

# LEGB demonstration
builtin_len = len                 # => Save built-in len function
x = "global"                      # => x is "global" (Global)

def outer():
    x = "enclosing"               # => x is "enclosing" (Enclosing)

    def inner():
        x = "local"               # => x is "local" (Local)
        print(f"Local: {x}")      # => Output: Local: local
        print(f"Built-in len: {builtin_len([1, 2, 3])}")
                                  # => Output: Built-in len: 3

    inner()
    print(f"Enclosing: {x}")      # => Output: Enclosing: enclosing

outer()
print(f"Global: {x}")             # => Output: Global: global

# Reading global without global keyword (allowed)
config = {"debug": True}          # => config is dict (global)

def is_debug():
    # Reading global is OK (no global keyword needed)
    return config["debug"]        # => Returns True (reads global config)

print(is_debug())                 # => Output: True

# Basic lambda syntax: lambda arguments: expression
square = lambda x: x ** 2         # => square is a function object
result = square(5)                # => result is 25
print(result)                     # => Output: 25

# Lambda with multiple arguments
add = lambda a, b: a + b          # => add is a function
sum_result = add(3, 7)            # => sum_result is 10
print(sum_result)                 # => Output: 10

# Lambda in sorted() with key parameter
students = [
    ("Alice", 25, 3.8),
    ("Bob", 22, 3.5),
    ("Charlie", 23, 3.9)
]                                 # => List of (name, age, gpa) tuples

# Sort by age (index 1)
by_age = sorted(students, key=lambda student: student[1])
                                  # => by_age sorted by age: Bob(22), Charlie(23), Alice(25)
print(by_age)                     # => Output: [('Bob', 22, 3.5), ('Charlie', 23, 3.9), ('Alice', 25, 3.8)]

# Sort by GPA (index 2)
by_gpa = sorted(students, key=lambda student: student[2])
                                  # => by_gpa sorted by GPA: Bob(3.5), Alice(3.8), Charlie(3.9)
print(by_gpa)                     # => Output: [('Bob', 22, 3.5), ('Alice', 25, 3.8), ('Charlie', 23, 3.9)]

# Lambda with map() - apply function to each element
numbers = [1, 2, 3, 4, 5]         # => numbers is [1, 2, 3, 4, 5]
squared = list(map(lambda x: x ** 2, numbers))
                                  # => squared is [1, 4, 9, 16, 25]
print(squared)                    # => Output: [1, 4, 9, 16, 25]

# Lambda with filter() - select elements matching condition
evens = list(filter(lambda x: x % 2 == 0, numbers))
                                  # => evens is [2, 4]
print(evens)                      # => Output: [2, 4]

# Lambda with reduce() - accumulate values
from functools import reduce

product = reduce(lambda acc, x: acc * x, numbers)
                                  # => product is 120 (1*2*3*4*5)
print(product)                    # => Output: 120

# Comparison: lambda vs regular function
# Lambda version (concise)
is_positive_lambda = lambda x: x > 0

# Equivalent regular function (more readable for complex logic)
def is_positive_func(x):
    """Check if number is positive."""
    return x > 0

print(is_positive_lambda(5))      # => Output: True
print(is_positive_func(5))        # => Output: True

# Lambda limitations - single expression only
# This works:
simple = lambda x: x * 2

# This does NOT work (multiple statements):
# complex = lambda x:
#     y = x * 2
#     return y + 1

# Use regular function for multiple statements
def complex_func(x):
    y = x * 2                     # => Multiple statements require regular function
    return y + 1

result = complex_func(5)          # => result is 11
print(result)                     # => Output: 11

# Lambda in list comprehension (avoid - use comprehension directly)
# Less Pythonic:
squares_lambda = list(map(lambda x: x ** 2, numbers))

# More Pythonic (list comprehension):
squares_comp = [x ** 2 for x in numbers]
                                  # => Both produce [1, 4, 9, 16, 25]
print(squares_comp)               # => Output: [1, 4, 9, 16, 25]

# Basic list comprehension: [expression for item in iterable]
numbers = [1, 2, 3, 4, 5]         # => numbers is [1, 2, 3, 4, 5]
squares = [x ** 2 for x in numbers]
                                  # => squares is [1, 4, 9, 16, 25]
print(squares)                    # => Output: [1, 4, 9, 16, 25]

# Comprehension with condition: [expression for item in iterable if condition]
evens = [x for x in numbers if x % 2 == 0]
                                  # => evens is [2, 4]
print(evens)                      # => Output: [2, 4]

# Transform and filter combined
even_squares = [x ** 2 for x in numbers if x % 2 == 0]
                                  # => even_squares is [4, 16] (2^2, 4^2)
print(even_squares)               # => Output: [4, 16]

# Comprehension from string
word = "Python"                   # => word is "Python"
upper_chars = [char.upper() for char in word]
                                  # => upper_chars is ['P', 'Y', 'T', 'H', 'O', 'N']
print(upper_chars)                # => Output: ['P', 'Y', 'T', 'H', 'O', 'N']

# Comprehension with range
first_ten_squares = [x ** 2 for x in range(1, 11)]
                                  # => first_ten_squares is [1, 4, 9, ..., 100]
print(first_ten_squares)          # => Output: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# Nested comprehension (flattening)
matrix = [[1, 2], [3, 4], [5, 6]] # => matrix is [[1, 2], [3, 4], [5, 6]]
flattened = [num for row in matrix for num in row]
                                  # => flattened is [1, 2, 3, 4, 5, 6]
print(flattened)                  # => Output: [1, 2, 3, 4, 5, 6]

# Equivalent nested loop for comparison
flattened_loop = []
for row in matrix:                # => Outer loop: [1,2], [3,4], [5,6]
    for num in row:               # => Inner loop: 1, 2, then 3, 4, then 5, 6
        flattened_loop.append(num)
                                  # => flattened_loop is [1, 2, 3, 4, 5, 6]
print(flattened_loop)             # => Output: [1, 2, 3, 4, 5, 6]

# Comprehension with multiple conditions
numbers = range(1, 21)            # => numbers is 1 to 20
special = [x for x in numbers if x % 2 == 0 if x % 3 == 0]
                                  # => special is [6, 12, 18] (divisible by both 2 and 3)
print(special)                    # => Output: [6, 12, 18]

# Conditional expression in comprehension
nums = [-2, -1, 0, 1, 2]          # => nums is [-2, -1, 0, 1, 2]
absolute = [x if x >= 0 else -x for x in nums]
                                  # => absolute is [2, 1, 0, 1, 2]
print(absolute)                   # => Output: [2, 1, 0, 1, 2]

# Comprehension with function calls
words = ["hello", "world", "python"]
                                  # => words is ["hello", "world", "python"]
lengths = [len(word) for word in words]
                                  # => lengths is [5, 5, 6]
print(lengths)                    # => Output: [5, 5, 6]

# Nested list comprehension (2D matrix)
matrix_2d = [[i * j for j in range(1, 4)] for i in range(1, 4)]
                                  # => Creates 3x3 multiplication table
print(matrix_2d)                  # => Output: [[1, 2, 3], [2, 4, 6], [3, 6, 9]]

# When NOT to use comprehensions (too complex - use loops)
# Bad (hard to read):
# complex = [x if x > 0 else -x for x in range(-10, 10) if abs(x) % 2 == 0 if x != 0]

# Better (use regular loop for complex logic):
complex = []
for x in range(-10, 10):
    if x != 0 and abs(x) % 2 == 0:
        complex.append(x if x > 0 else -x)
print(complex)                    # => Output: [2, 4, 6, 8, 10, 2, 4, 6, 8]

# Dictionary comprehension: {key_expr: value_expr for item in iterable}
numbers = [1, 2, 3, 4, 5]         # => numbers is [1, 2, 3, 4, 5]
squares_dict = {x: x ** 2 for x in numbers}
                                  # => squares_dict is {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
print(squares_dict)               # => Output: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# Dictionary comprehension with condition
even_squares = {x: x ** 2 for x in numbers if x % 2 == 0}
                                  # => even_squares is {2: 4, 4: 16}
print(even_squares)               # => Output: {2: 4, 4: 16}

# Dictionary from two lists using zip
names = ["Alice", "Bob", "Charlie"]
                                  # => names is ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]               # => ages is [25, 30, 35]
people = {name: age for name, age in zip(names, ages)}
                                  # => people is {"Alice": 25, "Bob": 30, "Charlie": 35}
print(people)                     # => Output: {'Alice': 25, 'Bob': 30, 'Charlie': 35}

# Swapping keys and values
original = {"a": 1, "b": 2, "c": 3}
                                  # => original is {"a": 1, "b": 2, "c": 3}
swapped = {value: key for key, value in original.items()}
                                  # => swapped is {1: "a", 2: "b", 3: "c"}
print(swapped)                    # => Output: {1: 'a', 2: 'b', 3: 'c'}

# Dictionary comprehension with string manipulation
words = ["apple", "banana", "cherry"]
                                  # => words is ["apple", "banana", "cherry"]
word_lengths = {word: len(word) for word in words}
                                  # => word_lengths is {"apple": 5, "banana": 6, "cherry": 6}
print(word_lengths)               # => Output: {'apple': 5, 'banana': 6, 'cherry': 6}

# Set comprehension: {expression for item in iterable}
numbers = [1, 2, 2, 3, 3, 3, 4, 5]# => numbers is [1, 2, 2, 3, 3, 3, 4, 5]
unique_squares = {x ** 2 for x in numbers}
                                  # => unique_squares is {1, 4, 9, 16, 25} (no duplicates)
print(unique_squares)             # => Output: {1, 4, 9, 16, 25}

# Set comprehension with condition
even_set = {x for x in numbers if x % 2 == 0}
                                  # => even_set is {2, 4} (unique even numbers)
print(even_set)                   # => Output: {2, 4}

# Set comprehension from string (unique characters)
text = "hello"                    # => text is "hello"
unique_chars = {char for char in text}
                                  # => unique_chars is {'h', 'e', 'l', 'o'} (unique only)
print(unique_chars)               # => Output: {'h', 'e', 'l', 'o'}

# Case-insensitive unique characters
text = "Hello World"              # => text is "Hello World"
unique_lower = {char.lower() for char in text if char.isalpha()}
                                  # => unique_lower is {'h', 'e', 'l', 'o', 'w', 'r', 'd'}
print(unique_lower)               # => Output: {'h', 'e', 'l', 'o', 'w', 'r', 'd'}

# Dictionary comprehension with conditional values
numbers = range(1, 6)             # => numbers is 1 to 5
parity = {x: "even" if x % 2 == 0 else "odd" for x in numbers}
                                  # => parity is {1: "odd", 2: "even", 3: "odd", 4: "even", 5: "odd"}
print(parity)                     # => Output: {1: 'odd', 2: 'even', 3: 'odd', 4: 'even', 5: 'odd'}

# Nested dictionary comprehension
matrix = {
    i: {j: i * j for j in range(1, 4)}
    for i in range(1, 4)
}                                 # => Creates nested dict multiplication table
print(matrix)                     # => Output: {1: {1: 1, 2: 2, 3: 3}, 2: {1: 2, 2: 4, 3: 6}, 3: {1: 3, 2: 6, 3: 9}}

# Filtering existing dictionary
grades = {"Alice": 95, "Bob": 72, "Charlie": 88, "David": 65}
passing = {name: grade for name, grade in grades.items() if grade >= 75}
                                  # => passing is {"Alice": 95, "Charlie": 88}
print(passing)                    # => Output: {'Alice': 95, 'Charlie': 88}

# Basic try/except
def divide(a, b):
    try:
        result = a / b            # => May raise ZeroDivisionError
        return result
    except ZeroDivisionError:
        print("Error: Division by zero")
        return None               # => Return None on error

print(divide(10, 2))              # => Output: 5.0
print(divide(10, 0))              # => Output: Error: Division by zero, then None

# Multiple except clauses
def convert_to_int(value):
    try:
        return int(value)         # => May raise ValueError or TypeError
    except ValueError:
        print(f"ValueError: '{value}' is not a valid integer")
        return None
    except TypeError:
        print(f"TypeError: Cannot convert {type(value)} to int")
        return None

print(convert_to_int("42"))       # => Output: 42
print(convert_to_int("abc"))      # => Output: ValueError: 'abc' is not a valid integer, then None
print(convert_to_int([1, 2]))     # => Output: TypeError: Cannot convert <class 'list'> to int, then None

# Catching multiple exceptions in one clause
def safe_operation(x, y):
    try:
        result = int(x) / int(y)  # => May raise ValueError or ZeroDivisionError
        return result
    except (ValueError, ZeroDivisionError) as e:
        print(f"Error: {type(e).__name__}: {e}")
        return None

print(safe_operation("10", "2"))  # => Output: 5.0
print(safe_operation("abc", "2")) # => Output: Error: ValueError: invalid literal...
print(safe_operation("10", "0"))  # => Output: Error: ZeroDivisionError: division by zero

# Accessing exception object
def parse_number(text):
    try:
        return float(text)
    except ValueError as e:
        print(f"Caught exception: {e}")
        print(f"Exception type: {type(e)}")
        return 0.0

result = parse_number("invalid")
# => Output: Caught exception: could not convert string to float: 'invalid'
#    Exception type: <class 'ValueError'>
print(result)                     # => Output: 0.0

# Try/except/else/finally
def process_file(filename):
    try:
        # Simulate file opening (not actual file I/O)
        if filename == "":
            raise ValueError("Empty filename")
        data = f"Data from {filename}"# => Success path
    except ValueError as e:
        print(f"Error: {e}")
        data = None
    else:
        # Runs only if no exception occurred
        print("File processed successfully")
    finally:
        # Always runs (cleanup code)
        print("Cleanup complete")

    return data

print(process_file("data.txt"))
# => Output: File processed successfully
#    Cleanup complete
#    Data from data.txt

print(process_file(""))
# => Output: Error: Empty filename
#    Cleanup complete
#    None

# Bare except (catches all exceptions - use sparingly!)
def risky_operation():
    try:
        # Some risky code
        x = 1 / 0                 # => Raises ZeroDivisionError
    except:
        print("Something went wrong")
        # Problem: Can't tell what went wrong!

risky_operation()                 # => Output: Something went wrong

# Better: Catch specific exceptions
def better_operation():
    try:
        x = 1 / 0
    except ZeroDivisionError:
        print("Attempted division by zero")
    except Exception as e:
        # Catch other exceptions with access to details
        print(f"Unexpected error: {type(e).__name__}: {e}")

better_operation()                # => Output: Attempted division by zero

# Re-raising exceptions
def validate_age(age):
    try:
        age_int = int(age)
        if age_int < 0:
            raise ValueError("Age cannot be negative")
        return age_int
    except ValueError as e:
        print(f"Validation failed: {e}")
        raise                     # => Re-raise the same exception

try:
    validate_age("-5")
except ValueError:
    print("Caught re-raised exception")
# => Output: Validation failed: Age cannot be negative
#    Caught re-raised exception

# Writing to a file
def write_example():
    # Create and write to file
    with open("example.txt", "w") as file:
        file.write("Hello, World!\n")
        file.write("This is line 2.\n")
        file.write("This is line 3.")
    # => File automatically closed when with block exits
    print("File written successfully")

write_example()                   # => Creates example.txt with 3 lines

# Reading entire file
def read_entire_file():
    try:
        with open("example.txt", "r") as file:
            content = file.read() # => content is all text as single string
            print(content)
    except FileNotFoundError:
        print("File not found")

read_entire_file()
# => Output: Hello, World!
#    This is line 2.
#    This is line 3.

# Reading line by line
def read_lines():
    try:
        with open("example.txt", "r") as file:
            for line in file:     # => Iterate over lines (memory-efficient)
                print(line.strip())# => strip() removes trailing newline
    except FileNotFoundError:
        print("File not found")

read_lines()
# => Output: Hello, World!
#    This is line 2.
#    This is line 3.

# Reading into list
def read_as_list():
    try:
        with open("example.txt", "r") as file:
            lines = file.readlines()
                                  # => lines is ['Hello, World!\n', 'This is line 2.\n', ...]
            print(lines)
    except FileNotFoundError:
        print("File not found")

read_as_list()
# => Output: ['Hello, World!\n', 'This is line 2.\n', 'This is line 3.']

# Appending to file
def append_example():
    with open("example.txt", "a") as file:
        file.write("\nAppended line.")
                                  # => Adds to end of file
    print("Line appended")

append_example()                  # => example.txt now has 4 lines

# Reading and writing (r+, w+, a+)
def read_write_example():
    with open("example.txt", "r+") as file:
        content = file.read()     # => Read existing content
        file.write("\nAdditional line")
                                  # => Write at end
    print("Read and write complete")

read_write_example()

# File modes summary:
# "r"  - Read (default, file must exist)
# "w"  - Write (creates file, truncates if exists)
# "a"  - Append (creates file if doesn't exist)
# "r+" - Read and write (file must exist)
# "w+" - Write and read (creates file, truncates if exists)
# "a+" - Append and read (creates file if doesn't exist)
# "b"  - Binary mode (combine with above: "rb", "wb", etc.)

# Binary file operations
def binary_example():
    # Write binary data
    with open("binary.dat", "wb") as file:
        data = bytes([65, 66, 67])# => data is b'ABC' (bytes object)
        file.write(data)

    # Read binary data
    with open("binary.dat", "rb") as file:
        content = file.read()     # => content is b'ABC'
        print(content)            # => Output: b'ABC'
        print(list(content))      # => Output: [65, 66, 67]

binary_example()

# File operations without context manager (manual close - not recommended)
def manual_close_example():
    file = open("example.txt", "r")
    try:
        content = file.read()
        print(content)
    finally:
        file.close()              # => Must manually close!

# Better: Use with statement (automatic cleanup)
def context_manager_example():
    with open("example.txt", "r") as file:
        content = file.read()
        print(content)
    # => File automatically closed, even if exception occurs

# Check if file exists before opening
import os

def safe_read(filename):
    if os.path.exists(filename):
        with open(filename, "r") as file:
            return file.read()
    else:
        print(f"{filename} does not exist")
        return None

result = safe_read("example.txt")
# => Returns content if file exists

result = safe_read("nonexistent.txt")
# => Output: nonexistent.txt does not exist
# => Returns None

# Basic class definition
class Dog:
    """Represents a dog with name and age."""

    def __init__(self, name, age):
        """Initialize dog with name and age."""
        self.name = name          # => Instance attribute name
        self.age = age            # => Instance attribute age

    def bark(self):
        """Make the dog bark."""
        return f"{self.name} says Woof!"

# Creating instances
dog1 = Dog("Buddy", 3)            # => dog1 is Dog object with name="Buddy", age=3
dog2 = Dog("Max", 5)              # => dog2 is Dog object with name="Max", age=5

# Accessing attributes
print(dog1.name)                  # => Output: Buddy
print(dog2.age)                   # => Output: 5

# Calling methods
print(dog1.bark())                # => Output: Buddy says Woof!
print(dog2.bark())                # => Output: Max says Woof!

# Class attributes (shared by all instances)
class Circle:
    """Represents a circle."""
    pi = 3.14159                  # => Class attribute (shared)

    def __init__(self, radius):
        self.radius = radius      # => Instance attribute (unique per instance)

    def area(self):
        """Calculate circle area."""
        return Circle.pi * self.radius ** 2

circle1 = Circle(5)               # => circle1 has radius=5
circle2 = Circle(10)              # => circle2 has radius=10

print(circle1.area())             # => Output: 78.53975 (π × 5²)
print(circle2.area())             # => Output: 314.159 (π × 10²)

# Access class attribute through class or instance
print(Circle.pi)                  # => Output: 3.14159 (via class)
print(circle1.pi)                 # => Output: 3.14159 (via instance)

# Instance methods vs static methods vs class methods
class MathOperations:
    """Demonstrates different method types."""

    multiplier = 2                # => Class attribute

    def instance_method(self, x):
        """Instance method (has access to self)."""
        return x * self.multiplier

    @staticmethod
    def static_method(x, y):
        """Static method (no access to self or cls)."""
        return x + y

    @classmethod
    def class_method(cls, x):
        """Class method (has access to cls, not self)."""
        return x * cls.multiplier

math = MathOperations()

# Instance method (needs instance)
print(math.instance_method(5))    # => Output: 10 (5 × 2)

# Static method (can call on class or instance)
print(MathOperations.static_method(3, 4))
                                  # => Output: 7 (3 + 4)
print(math.static_method(3, 4))   # => Output: 7 (same via instance)

# Class method (can call on class or instance)
print(MathOperations.class_method(5))
                                  # => Output: 10 (5 × 2)
print(math.class_method(5))       # => Output: 10 (same via instance)

# String representation
class Point:
    """Represents a 2D point."""

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

    def __str__(self):
        """Human-readable string representation."""
        return f"Point({self.x}, {self.y})"

    def __repr__(self):
        """Developer-friendly representation."""
        return f"Point(x={self.x}, y={self.y})"

p = Point(3, 4)                   # => p is Point object
print(p)                          # => Output: Point(3, 4) (uses __str__)
print(repr(p))                    # => Output: Point(x=3, y=4) (uses __repr__)

# Private attributes (convention: prefix with _)
class BankAccount:
    """Represents a bank account."""

    def __init__(self, balance):
        self._balance = balance   # => "Private" by convention (not enforced)

    def deposit(self, amount):
        """Deposit money."""
        if amount > 0:
            self._balance += amount
            return True
        return False

    def get_balance(self):
        """Get current balance."""
        return self._balance

account = BankAccount(100)        # => account has _balance=100
account.deposit(50)               # => _balance is now 150
print(account.get_balance())      # => Output: 150

# Can still access "private" attribute (not truly private!)
print(account._balance)           # => Output: 150 (discouraged but possible)