Python Functions

# Without functions — repeated code (bad)
tax1 = 1500 * 0.17
tax2 = 2800 * 0.17
tax3 = 950  * 0.17

# With a function — write once, use anywhere (DRY)
def calculate_tax(amount):
    """Calculate 17% sales tax on an amount."""
    return amount * 0.17

tax1 = calculate_tax(1500)   # 255.0
tax2 = calculate_tax(2800)   # 476.0
tax3 = calculate_tax(950)    # 161.5

# Calling the function
print(f"Tax: PKR {tax1:.2f}")

# Functions without a return statement return None
def say_hello():
    print("Hello, BitWithBite!")   # does work, returns None

result = say_hello()
print(result)   # None

# ── Positional and default parameters ────────
def describe_student(name, age, city="Lahore", grade="A"):
    return f"{name}, {age}, from {city}, Grade {grade}"

print(describe_student("Ali", 20))                    # uses defaults
print(describe_student("Sara", 22, "Karachi"))          # overrides city
print(describe_student("Zara", 21, grade="B"))           # keyword arg

# ── *args — collect any number of positional args ──
def total(*numbers):
    """Sum any number of arguments."""
    return sum(numbers)   # numbers is a tuple

print(total(1, 2, 3))           # 6
print(total(10, 20, 30, 40))    # 100
print(total(5))                  # 5

# ── **kwargs — collect keyword arguments as a dict ──
def build_profile(**info):
    """Print a profile from any keyword arguments."""
    for key, val in info.items():
        print(f"  {key.capitalize()}: {val}")

build_profile(name="Fatima", age=20, city="Islamabad", gpa=3.9)

# ── Combining all types (correct order!) ─────
def mixed(required, optional="default", *args, **kwargs):
    print(required, optional, args, kwargs)

# Single return value
def square(n):
    return n ** 2

print(square(7))   # 49

# Early return — guard clause pattern
def divide(a, b):
    if b == 0:
        return None    # exit early on bad input
    return a / b

print(divide(10, 2))   # 5.0
print(divide(10, 0))   # None

# Multiple return values (returns a tuple)
def stats(numbers):
    """Return min, max, average of a list."""
    return min(numbers), max(numbers), sum(numbers)/len(numbers)

lo, hi, avg = stats([8, 3, 15, 1, 9])
print(f"Min: {lo}, Max: {hi}, Avg: {avg:.1f}")   # 1 15 7.2

# Return a dict — named results
def analyse_text(text):
    words = text.split()
    return {
        "chars"  : len(text),
        "words"  : len(words),
        "unique" : len(set(words)),
    }

r = analyse_text("to be or not to be that is the question")
print(r)   # {'chars': 40, 'words': 10, 'unique': 8}

# Global scope
APP_NAME = "BitWithBite"   # G — global

def show_app():
    version = "2.0"          # L — local to show_app
    print(APP_NAME, version)  # can read global APP_NAME

show_app()
# print(version)  ← NameError: version not defined here

# Global variables are READ-ONLY inside functions by default
counter = 0

def increment():
    global counter         # declare intent to MODIFY global
    counter += 1

increment()
increment()
print(counter)   # 2

# ── Best practice: avoid global — use return instead ──
def increment_v2(count):
    return count + 1         # pure function — no side effects

counter = increment_v2(counter)  # caller controls the global

# Enclosing scope (closure preview)
def outer():
    msg = "hello from outer"
    def inner():
        print(msg)   # E — enclosing scope
    inner()

# Lambda syntax: lambda params: expression
square = lambda x: x ** 2
print(square(5))   # 25

add = lambda a, b: a + b
print(add(3, 7))   # 10

# ── sorted() with key lambda ──────────────────
students = [("Ali", 85), ("Sara", 92), ("Zara", 78)]
by_score = sorted(students, key=lambda s: s[1], reverse=True)
print(by_score)   # [('Sara', 92), ('Ali', 85), ('Zara', 78)]

names = ["banana", "Apple", "mango", "cherry"]
print(sorted(names, key=lambda x: x.lower()))   # case-insensitive sort

# ── map() — apply a function to every item ───
prices  = [100, 250, 80, 320]
with_tax = list(map(lambda p: p * 1.17, prices))
print(with_tax)   # [117.0, 292.5, 93.6, 374.4]

# ── filter() — keep items where function is True ─
marks   = [55, 42, 88, 31, 76, 90]
passing = list(filter(lambda m: m >= 50, marks))
print(passing)    # [55, 88, 76, 90]

# Passing a def function as argument
def is_even(n): return n % 2 == 0
evens = list(filter(is_even, range(10)))
print(evens)      # [0, 2, 4, 6, 8]

# One-line docstring (simple functions)
def celsius_to_fahrenheit(c):
    """Convert Celsius to Fahrenheit."""
    return c * 9/5 + 32

# Multi-line docstring (complex functions)
def calculate_grade(score, total=100):
    """
    Calculate a letter grade from a score.

    Args:
        score (float): The marks obtained.
        total (float): Maximum possible marks. Default 100.

    Returns:
        str: Letter grade A+, A, B, C, or F.

    Examples:
        >>> calculate_grade(92)
        'A+'
        >>> calculate_grade(45, 100)
        'F'
    """
    pct = score / total * 100
    if   pct >= 95: return "A+"
    elif pct >= 85: return "A"
    elif pct >= 70: return "B"
    elif pct >= 55: return "C"
    else:            return "F"

# Access the docstring programmatically
print(calculate_grade.__doc__)
help(calculate_grade)   # formatted output in terminal