# This is correct Python
if True:
    print("This line is inside the if block")
    print("So is this line")
print("This line is outside the if block")

# This raises an IndentationError
if True:
print("Missing indentation")  # IndentationError!

# WRONG: mixing tabs and spaces (Python 3 raises TabError)
if True:
    print("4 spaces")
	print("tab")  # TabError!

# RIGHT: 4 spaces consistently
if True:
    print("level 1")
    if True:
        print("level 2")
        if True:
            print("level 3")

# You can see the nesting at a glance
def process_users(users):
    for user in users:
        if user["active"]:
            if user["age"] >= 18:
                print(f"Adult active user: {user['name']}")
            else:
                print(f"Minor active user: {user['name']}")
        else:
            print(f"Inactive user: {user['name']}")

# Basic usage
print("Hello, World!")

# Multiple arguments — separated by space by default
print("Name:", "Alice", "Age:", 30)
# Output: Name: Alice Age: 30

# Custom separator
print("2026", "04", "17", sep="-")
# Output: 2026-04-17

# Custom end character (default is newline \n)
print("Loading", end="")
print("...", end="")
print(" Done!")
# Output: Loading... Done!

# Print nothing (empty line)
print()

# Print a list or other object
numbers = [1, 2, 3]
print(numbers)
# Output: [1, 2, 3]

name = "Alice"
score = 98.5
rank = 1

# Old-style % formatting (still seen in legacy code)
print("Student: %s, Score: %.1f" % (name, score))

# str.format() method
print("Student: {}, Score: {:.1f}".format(name, score))

# f-strings (modern, preferred since Python 3.6)
print(f"Student: {name}, Score: {score:.1f}, Rank: #{rank}")
# Output: Student: Alice, Score: 98.5, Rank: #1

# Basic input
name = input("What is your name? ")
print(f"Hello, {name}!")

# Input always returns string — convert when needed
age_str = input("How old are you? ")
age = int(age_str)  # Convert to integer
print(f"In 10 years you will be {age + 10}")

# Common mistake: forgetting to convert
age = input("Age: ")
# print(age + 10)  # TypeError: can only concatenate str (not "int") to str

# Safe input with validation
while True:
    try:
        age = int(input("Enter your age: "))
        break
    except ValueError:
        print("Please enter a valid number.")

# Simple assignment
x = 10
name = "Alice"
is_active = True

# Multiple assignment on one line
a, b, c = 1, 2, 3
print(a, b, c)  # 1 2 3

# Swap variables (Python's elegant idiom)
a, b = b, a
print(a, b)  # 2 1

# Assign the same value to multiple variables
x = y = z = 0
print(x, y, z)  # 0 0 0

# Augmented assignment
count = 0
count += 1   # count = count + 1
count += 1
print(count)  # 2

score = 100
score -= 15  # subtract
score *= 2   # multiply
score //= 3  # integer divide
print(score)  # 56

# Valid variable names
user_name = "Alice"        # snake_case (PEP 8 recommended)
userName = "Bob"           # camelCase (not recommended in Python)
_private = "secret"        # leading underscore = convention for private
__dunder__ = "special"     # double underscore = dunder/magic (avoid in user code)
MAX_SIZE = 100             # ALL_CAPS = convention for constants
counter1 = 0               # letters and digits (not at start)

# Invalid names
# 1counter = 0   # SyntaxError: cannot start with digit
# my-var = 0     # SyntaxError: hyphens not allowed
# class = "A"    # SyntaxError: reserved keyword

# Check reserved keywords
import keyword
print(keyword.kwlist)
# ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await',
#  'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except',
#  'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is',
#  'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try',
#  'while', 'with', 'yield']

# Integers are immutable — reassignment creates a new object
x = 5
y = x       # y points to the same 5
x = 10      # x now points to 10; y still points to 5
print(x, y)  # 10 5

# Lists are mutable — both variables point to the same list
list_a = [1, 2, 3]
list_b = list_a       # list_b is NOT a copy; it's the same list
list_a.append(4)
print(list_b)         # [1, 2, 3, 4] — list_b sees the change!

# To copy: use .copy() or list()
list_c = list_a.copy()
list_a.append(5)
print(list_c)         # [1, 2, 3, 4] — list_c is independent

age = 25
year = 2026
big_number = 1_000_000  # underscores for readability (Python 3.6+)
negative = -42
zero = 0

# Integer literals in different bases
binary = 0b1010      # binary: 10
octal = 0o17         # octal: 15
hexadecimal = 0xFF   # hexadecimal: 255

print(binary, octal, hexadecimal)  # 10 15 255

# Integer operations
print(7 // 2)   # 3  — integer (floor) division
print(7 % 2)    # 1  — modulo (remainder)
print(2 ** 10)  # 1024 — exponentiation

# Python 3 integers have unlimited precision
factorial_20 = 1
for i in range(1, 21):
    factorial_20 *= i
print(factorial_20)  # 2432902008176640000 (exact, no overflow)

pi = 3.14159
temperature = -12.5
scientific = 1.5e3    # 1500.0
small = 2.5e-4        # 0.00025

print(type(pi))       # <class 'float'>

# Float arithmetic precision issue (famous gotcha)
print(0.1 + 0.2)      # 0.30000000000000004 (NOT 0.3!)
print(0.1 + 0.2 == 0.3)  # False!

# Solution: use round() for comparison or decimal module
print(round(0.1 + 0.2, 2) == 0.3)  # True

# For financial calculations, use decimal.Decimal
from decimal import Decimal
print(Decimal("0.1") + Decimal("0.2"))  # 0.3 (exact)

# Special float values
import math
print(math.inf)       # inf
print(-math.inf)      # -inf
print(math.nan)       # nan (Not a Number)
print(math.isnan(math.nan))  # True

# String creation — single, double, or triple quotes
name = 'Alice'
greeting = "Hello"
multiline = """This is
a multiline
string."""

# String with quotes inside
quote1 = "She said 'hello'"
quote2 = 'He replied "hi there"'
escaped = "It's a \"beautiful\" day"

# Raw strings — backslash is literal (useful for regex, Windows paths)
path = r"C:\Users\Alice\Documents"
pattern = r"\d+\.\d+"

print(len(name))        # 5
print(name[0])          # A
print(name[-1])         # e
print(name[1:4])        # lic (slicing)
print(name[::-1])       # ecilA (reverse)

is_active = True
is_deleted = False

print(type(is_active))    # <class 'bool'>
print(True + True)        # 2 (bool is subclass of int!)
print(True * 5)           # 5
print(False + 1)          # 1

# Boolean from comparisons
x = 10
print(x > 5)    # True
print(x == 5)   # False
print(x != 5)   # True

# Truthy and Falsy values
# Falsy: False, 0, 0.0, "", [], {}, set(), None
# Truthy: everything else
print(bool(0))      # False
print(bool(""))     # False
print(bool([]))     # False
print(bool(None))   # False
print(bool(1))      # True
print(bool("hi"))   # True
print(bool([0]))    # True (list with one item, even if item is falsy)

result = None
print(result)           # None
print(type(result))     # <class 'NoneType'>

# None is a singleton — always use 'is' to compare, not '=='
if result is None:
    print("No result yet")

# Functions that don't return explicitly return None
def greet(name):
    print(f"Hello, {name}")

output = greet("Alice")  # prints: Hello, Alice
print(output)            # None

# None as a default parameter sentinel
def connect(host, port=None):
    if port is None:
        port = 443
    print(f"Connecting to {host}:{port}")

connect("api.example.com")         # Connecting to api.example.com:443
connect("api.example.com", 8080)   # Connecting to api.example.com:8080

print(type(42))           # <class 'int'>
print(type(3.14))         # <class 'float'>
print(type("hello"))      # <class 'str'>
print(type(True))         # <class 'bool'>
print(type(None))         # <class 'NoneType'>
print(type([1, 2, 3]))    # <class 'list'>
print(type({"a": 1}))     # <class 'dict'>

# Using type() in conditions (usually avoid this pattern)
x = 42
if type(x) == int:
    print("x is an int")

x = 42
print(isinstance(x, int))    # True
print(isinstance(x, float))  # False
print(isinstance(x, (int, float)))  # True — check multiple types

# Why isinstance is better: it respects inheritance
class Animal:
    pass

class Dog(Animal):
    pass

rex = Dog()
print(type(rex) == Animal)        # False — type() is exact
print(isinstance(rex, Animal))    # True — isinstance checks hierarchy
print(isinstance(rex, Dog))       # True

# Practical use: validate function inputs
def calculate_area(radius):
    if not isinstance(radius, (int, float)):
        raise TypeError(f"radius must be a number, got {type(radius).__name__}")
    if radius <= 0:
        raise ValueError("radius must be positive")
    return 3.14159 * radius ** 2

print(calculate_area(5))      # 78.53975
# calculate_area("big")       # TypeError: radius must be a number, got str

# String to int
age = int("25")
print(age, type(age))   # 25 <class 'int'>

# Float to int — truncates (does NOT round)
x = int(3.9)
print(x)                # 3 (not 4!)
y = int(-3.9)
print(y)                # -3 (truncates toward zero)

# Bool to int
print(int(True))   # 1
print(int(False))  # 0

# Invalid conversions raise ValueError
# int("hello")     # ValueError: invalid literal for int()
# int("3.14")      # ValueError: float string needs float() first

# From other bases
print(int("0b1010", 2))   # 10 (binary string)
print(int("FF", 16))      # 255 (hex string)
print(int("17", 8))       # 15 (octal string)

# String to float
price = float("19.99")
print(price, type(price))  # 19.99 <class 'float'>

# Int to float
x = float(5)
print(x)    # 5.0

# Bool to float
print(float(True))   # 1.0
print(float(False))  # 0.0

# Special strings
print(float("inf"))   # inf
print(float("-inf"))  # -inf
print(float("nan"))   # nan

# Any type to string
print(str(42))          # "42"
print(str(3.14))        # "3.14"
print(str(True))        # "True"
print(str(None))        # "None"
print(str([1, 2, 3]))   # "[1, 2, 3]"

# Useful for string concatenation with non-strings
age = 30
# print("Age: " + age)         # TypeError!
print("Age: " + str(age))      # "Age: 30"
# Better: use f-string
print(f"Age: {age}")           # "Age: 30"

# Explicit conversion
print(bool(0))      # False
print(bool(1))      # True
print(bool(-1))     # True (any non-zero)
print(bool(""))     # False
print(bool("  "))   # True (whitespace is truthy!)
print(bool([]))     # False
print(bool([0]))    # True

# Parsing user data from a form or CSV
raw_data = {
    "name": "Alice",
    "age": "28",
    "salary": "75000.50",
    "is_manager": "true",
    "department_id": "42"
}

parsed = {
    "name": raw_data["name"],
    "age": int(raw_data["age"]),
    "salary": float(raw_data["salary"]),
    "is_manager": raw_data["is_manager"].lower() == "true",
    "department_id": int(raw_data["department_id"])
}

print(parsed)
# {'name': 'Alice', 'age': 28, 'salary': 75000.5, 'is_manager': True, 'department_id': 42}

text = "Hello, World!"

print(text.upper())       # HELLO, WORLD!
print(text.lower())       # hello, world!
print(text.title())       # Hello, World!
print(text.capitalize())  # Hello, world! (only first char)
print(text.swapcase())    # hELLO, wORLD!

# Practical use: case-insensitive comparison
user_input = "YeS"
if user_input.lower() == "yes":
    print("User confirmed")

messy = "   hello world   "

print(repr(messy.strip()))   # 'hello world'    (both sides)
print(repr(messy.lstrip()))  # 'hello world   ' (left only)
print(repr(messy.rstrip()))  # '   hello world' (right only)

# Strip specific characters
url = "///path/to/resource///"
print(url.strip("/"))   # path/to/resource

csv_line = "Alice,28,Engineer\n"
print(csv_line.strip())  # Alice,28,Engineer

sentence = "The quick brown fox jumps over the lazy dog"

# Finding
print(sentence.find("fox"))      # 16 (index of first occurrence)
print(sentence.find("cat"))      # -1 (not found)
print(sentence.index("fox"))     # 16 (same but raises ValueError if not found)
print(sentence.count("the"))     # 1 (case sensitive)
print(sentence.count("the", 0, len(sentence)))  # 1

# Testing
print(sentence.startswith("The"))   # True
print(sentence.endswith("dog"))     # True
print(sentence.startswith(("The", "A")))  # True (tuple of options)

# Character testing
print("hello123".isalnum())    # True (letters and digits)
print("hello".isalpha())       # True (letters only)
print("12345".isdigit())       # True (digits only)
print("   ".isspace())         # True (whitespace only)
print("HELLO".isupper())       # True
print("hello".islower())       # True
print("Hello World".istitle()) # True

# split() — string to list
sentence = "the quick brown fox"
words = sentence.split()         # split on whitespace
print(words)                     # ['the', 'quick', 'brown', 'fox']

csv_line = "Alice,28,New York,Engineer"
fields = csv_line.split(",")
print(fields)   # ['Alice', '28', 'New York', 'Engineer']

# Split with max splits
print("a:b:c:d".split(":", 2))  # ['a', 'b', 'c:d']

# splitlines() for multi-line text
poem = "Roses are red\nViolets are blue\nPython is great"
print(poem.splitlines())
# ['Roses are red', 'Violets are blue', 'Python is great']

# join() — list to string
words = ["the", "quick", "brown", "fox"]
print(" ".join(words))       # the quick brown fox
print("-".join(words))       # the-quick-brown-fox
print("".join(words))        # thequickbrownfox

# Common pattern: build CSV line
fields = ["Alice", "28", "Engineer"]
csv_line = ",".join(fields)
print(csv_line)  # Alice,28,Engineer

# Performance tip: always use join() to concatenate many strings
# SLOW: building a string with +=
result = ""
for i in range(1000):
    result += str(i)  # creates a new string each iteration!

# FAST: collect parts, then join
parts = []
for i in range(1000):
    parts.append(str(i))
result = "".join(parts)

text = "I love cats. Cats are great. Cats rule!"

# Replace all occurrences
print(text.replace("Cats", "Dogs"))
# I love cats. Dogs are great. Dogs rule!

# Note: case-sensitive
print(text.replace("cats", "dogs"))
# I love dogs. Cats are great. Cats rule!

# Replace with count limit
print(text.replace("Cats", "Dogs", 1))
# I love cats. Dogs are great. Cats rule!

# Chaining replacements
dirty = "  Hello,   World!  "
clean = dirty.strip().replace(",", "").replace("  ", " ")
print(clean)  # Hello World!

# str.format() — positional
print("Hello, {}! You are {} years old.".format("Alice", 28))

# str.format() — named
print("Name: {name}, Age: {age}".format(name="Alice", age=28))

# str.format() — formatting numbers
print("{:.2f}".format(3.14159))    # 3.14
print("{:,}".format(1000000))      # 1,000,000
print("{:>10}".format("hi"))       # "        hi" (right-align, width 10)
print("{:<10}".format("hi"))       # "hi        " (left-align)
print("{:^10}".format("hi"))       # "    hi    " (center)
print("{:0>5}".format("42"))       # "00042" (zero-pad)

# f-strings (Python 3.6+) — preferred modern approach
name = "Alice"
age = 28
score = 98.756

print(f"Name: {name}, Age: {age}")
print(f"Score: {score:.2f}")           # Score: 98.76
print(f"Double age: {age * 2}")        # Double age: 56
print(f"Uppercase: {name.upper()}")    # Uppercase: ALICE

# f-string debugging (Python 3.8+)
x = 42
print(f"{x=}")      # x=42
print(f"{x * 2=}")  # x * 2=84

# Multiline f-strings
user = {"name": "Alice", "city": "Oslo"}
message = (
    f"Dear {user['name']},\n"
    f"Welcome from {user['city']}!\n"
    f"Best regards"
)
print(message)

# zfill() — zero-pad
print("42".zfill(5))     # 00042
print("042".zfill(5))    # 00042

# center(), ljust(), rjust()
print("hi".center(10))       # "    hi    "
print("hi".center(10, "*"))  # "****hi****"

# encode() — to bytes
text = "Hello"
encoded = text.encode("utf-8")
print(encoded)            # b'Hello'
print(encoded.decode())   # Hello

# in operator — membership test
print("fox" in "the quick brown fox")   # True
print("cat" in "the quick brown fox")   # False

a = 17
b = 5

print(a + b)    # 22 — addition
print(a - b)    # 12 — subtraction
print(a * b)    # 85 — multiplication
print(a / b)    # 3.4 — true division (always returns float)
print(a // b)   # 3   — floor division (rounds down to integer)
print(a % b)    # 2   — modulo (remainder)
print(a ** b)   # 1419857 — exponentiation

# Integer division and modulo relationship
# a == (a // b) * b + (a % b)
print(17 == (17 // 5) * 5 + 17 % 5)  # True

# Modulo with negative numbers (Python follows mathematical convention)
print(-7 % 3)   # 2 (not -1!) — result has same sign as divisor
print(7 % -3)   # -2           — result has same sign as divisor

# Floor division
print(-7 // 2)  # -4 (rounds toward negative infinity)
print(7 // 2)   # 3

# Operator precedence (PEMDAS / BODMAS)
print(2 + 3 * 4)        # 14 (not 20)
print((2 + 3) * 4)      # 20
print(2 ** 3 ** 2)      # 512 (right-to-left: 3**2=9, 2**9=512)
print((2 ** 3) ** 2)    # 64  (left-to-right)

# Augmented assignment operators
x = 10
x += 5   # x = x + 5  → 15
x -= 3   # x = x - 3  → 12
x *= 2   # x = x * 2  → 24
x //= 5  # x = x // 5 → 4
x **= 3  # x = x ** 3 → 64
x %= 10  # x = x % 10 → 4
print(x)  # 4

import math

print(math.sqrt(16))      # 4.0
print(math.ceil(3.2))     # 4 (round up)
print(math.floor(3.8))    # 3 (round down)
print(math.abs(-5))       # AttributeError! — use abs() built-in
print(abs(-5))            # 5
print(math.pow(2, 8))     # 256.0 (returns float)
print(2 ** 8)             # 256   (returns int)
print(math.log(100, 10))  # 2.0
print(math.log2(8))       # 3.0
print(math.pi)            # 3.141592653589793
print(math.e)             # 2.718281828459045

# Trigonometry (angles in radians)
print(math.sin(math.pi / 2))  # 1.0
print(math.cos(0))            # 1.0
print(math.degrees(math.pi))  # 180.0
print(math.radians(180))      # 3.141592653589793

a = 10
b = 20

print(a == b)   # False — equal to
print(a != b)   # True  — not equal to
print(a < b)    # True  — less than
print(a > b)    # False — greater than
print(a <= b)   # True  — less than or equal to
print(a >= b)   # False — greater than or equal to

# Chained comparisons (unique to Python)
x = 15
print(10 < x < 20)    # True — elegant!
print(0 <= x <= 100)  # True

# Equivalent to: 10 < x and x < 20
# But more readable and only evaluates x once

# Identity operators: is vs ==
# == checks VALUE equality
# is checks IDENTITY (same object in memory)
a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a == b)   # True  — same values
print(a is b)   # False — different objects
print(a is c)   # True  — same object

# None comparison: always use 'is'
result = None
print(result == None)   # True (works but not recommended)
print(result is None)   # True (correct way)
print(result is not None)  # False

# Surprising: Python caches small integers (-5 to 256)
x = 256
y = 256
print(x is y)   # True (cached)

x = 257
y = 257
print(x is y)   # False (not cached — different objects)
# This is an implementation detail; don't rely on it