07. Functions¶

# Concept-01: A function is a named block of code; define it with def, then RUN it by calling its name with ()
# Question: How do we run the same block of code many times without copying it? (def names it once; calling it runs it)
def greet():
    print("Hello, welcome to Python!")

# A name with NO () does not run the function - it just points at the function object:
# print(greet)   # <function greet at 0x...>  (the function itself, not the greeting)
greet()  # the () is what RUNS it

# Concept-02: A docstring describes what a function does; the first line inside, in triple quotes
# Question: How do we document what a function does, so we (and tools like help()) can read it later?
def welcome():
    """Print a friendly welcome message."""
    print("Glad you are here!")

welcome()
print(welcome.__doc__)
# help(welcome)   # same text, shown in the interactive help pager

# Concept-03: Define once, call many times; that is the whole point of a function (reuse, no copy-paste)
# Question: How does a function save us from writing the same lines again and again?
def divider():
    print("------------------------------")

divider()
print("Section 07: Functions")
divider()

# Concept-01: A parameter is the name in the def line; an argument is the value you pass when you call
# Question: How do we make one function greet ANY name we give it, like "Sam" or "Tom"? (put a parameter in the def, pass an argument in the call)
def greet(name):
    print(f"Hello, {name}!")

greet("Sam")
greet("Tom")
# `name` exists ONLY inside greet - it is created fresh each call (more on this in Scope)

# Concept-02: The argument can be a variable, not just a typed-in value
# Question: How do we greet a name we already stored in a variable, like "Amy"?
# Same greet function as Concept-01, repeated so this block stands on its own
def greet(name):
    print(f"Hello, {name}!")

student = "Amy"
greet(student)

# Concept-03: Arguments fill parameters by POSITION, left to right (positional arguments)
# Question: How does Python know which value goes to which parameter? (by position: first value -> first parameter)
def describe(name, city):
    print(f"{name} is from {city}")

describe("Sam", "Hyderabad")
# A positional call must pass exactly as many values as there are parameters:
# describe("Sam")   # TypeError: missing 'city'
# describe("Sam", "Hyderabad", "India")   # TypeError: too many arguments

# Concept-01: A print-only function SHOWS a value but hands back None, so you cannot store or reuse it
# Question: We know print shows a value - but can we capture and reuse what a function prints? (no: it hands back None)
def show_sum(a, b):
    print(a + b)

returned = show_sum(2, 3)
print(returned)  # None
print(type(returned))  # <class 'NoneType'>

# Concept-02: return hands the actual value BACK, so you can store it in a variable and reuse it
# Question: How do we get a REAL value back from a function, to store and reuse? (return hands the value back; print could not)
def add(a, b):
    return a + b

result = add(2, 3)
print(result)
print(result * 10)

# Concept-03: return can hand back the answer to a yes/no question (a True/False value)
# Question: How do we make a function ANSWER a yes or no question? (return the comparison; the result is a bool)
def is_even(n):
    return n % 2 == 0

print(is_even(10))
print(is_even(7))

# Concept-01: A function can take MORE THAN ONE parameter; values fill them by position
# Question: How do we calculate the area of a rectangle by passing both its width (4) and height (3) to a function? (list both parameters; pass the values in order)
def area(width, height):
    return width * height

print(area(4, 3))

# Concept-02: Put logic INSIDE a function (if / elif / else) and return a different value per case
# Question: How do we turn a student's marks into a grade inside a function, like 72 or 95? (if/elif/else, then return the grade)
def get_student_grade(marks):
    if marks >= 90:
        return "A"
    elif marks >= 75:
        return "B"
    elif marks >= 50:
        return "C"
    else:
        return "F"

print(get_student_grade(72))
print(get_student_grade(95))

# Concept-03: A function can run a LOOP and return a built-up result
# Question: How do we add up a whole list of numbers, like [10, 20, 30], and return the total? (loop over them, keep a running total, return it)
def total(numbers):
    if not numbers:  # guard: no numbers, so there is no total - hand back None
        return None
    running_total = 0
    for number in numbers:
        running_total = running_total + number
    return running_total

print(total([10, 20, 30]))  # 60
print(total([]))  # None (empty list - the guard returned early)

# Concept-04: return inside a loop stops the function immediately.
# The "not found" return belongs AFTER the loop, not inside it.

# Question: How do we check whether a list contains ANY even number?
# Stop as soon as we find one.

# E1: Common mistake - returning False too early
def has_even_buggy(numbers):
    for number in numbers:
        if number % 2 == 0:
            return True
        else:
            return False  # WRONG: decides after the first item instead of checking them all

print(has_even_buggy([1, 3, 4]))  # False - WRONG: 4 is even, but the function stopped at 1
print(has_even_buggy([1, 3, 5]))  # False - Correct by luck (there is no even number)

# E2: Correct - return True when found, otherwise return False after the loop
def has_even(numbers):
    for number in numbers:
        if number % 2 == 0:
            return True  # Found an even number - stop the loop and the function
    return False  # Reached only if no even number was found

print(has_even([1, 3, 4]))  # True  - Correct: it kept checking until it found 4
print(has_even([1, 3, 5]))  # False - Correct: every number was checked

# Concept-01: A default value is used when you do NOT pass that argument
# Question: How do we make an input optional, with a sensible default? (give the parameter a default value in the def line)
def greet(name, greeting="Hello", punctuation="!"):
    print(f"{greeting}, {name}{punctuation}")

greet("Sam")  # both defaults used
greet("Tom", "Welcome")  # override greeting only
greet("Amy", "Hi", ".")  # override both defaults

# Concept-02: Parameters WITH defaults must come AFTER parameters without them
# Question: Why does Python reject a default before a normal parameter? (defaults must be last; the line below would be an error)
# def bad(greeting="Hi", name):   # SyntaxError: parameter without a default follows parameter with a default

# Concept-03: Keyword arguments. Name each value in the call, so the order does not matter
# Question: How do we pass arguments by NAME so we do not depend on their order? (write name=value in the call)
def describe(name, city):
    print(f"{name} lives in {city}")

describe(city="Hyderabad", name="Sam")  # all keyword: order does not matter
describe("Ben", city="Delhi")  # mix: positional first, then keyword
# At the call site, any keyword argument must come AFTER the positional ones:
# describe(name="Sam", "Hyderabad")   # SyntaxError: positional argument follows keyword argument

# Concept-04: The mutable default argument trap. A default list is created ONCE and reused across function calls.

# Question: Why does a default list seem to "remember" values from previous function calls?
# (Default parameter values are created only once when the function is defined. Use None to create a fresh list for each call.)

# E1: The TRAP - the same default list is reused on every call
def add_item(item, basket=[]):   # Avoid using a mutable object as a default value
    basket.append(item)
    return basket

print(add_item("apple"))    # ['apple']
print(add_item("banana"))   # ['apple', 'banana'] - 'apple' is still there!

# E2: The FIX - use None, then create a new list inside the function
def add_item_safe(item, basket=None):
    if basket is None:
        basket = []

    basket.append(item)
    return basket

print(add_item_safe("apple"))    # ['apple']
print(add_item_safe("banana"))   # ['banana'] - each call gets a fresh list

# Concept-01: Return MANY values at once by separating them with commas; you get a tuple
# Question: How does a function hand back more than one result, like the lowest and highest of [4, 9, 2, 7]? (return them comma-separated; it becomes a tuple)
def low_high(numbers):
    # A function returns ONE object. The commas (not the brackets) pack both values
    # into a single tuple, so we can catch it whole (result) or unpack it (lo, hi).
    return min(numbers), max(numbers)

result = low_high([4, 9, 2, 7])
print(result)

# Concept-02: Unpack the returned tuple into separate variables in one line
# Question: How do we catch several returned values into their own names? (unpack them: lo, hi = low_high(...))
# Same low_high function as Concept-01, repeated so this block stands on its own
def low_high(numbers):
    return min(numbers), max(numbers)

lo, hi = low_high([4, 9, 2, 7])
print("low:", lo)
print("high:", hi)
# lo, hi, extra = low_high([4, 9, 2, 7])  # ValueError: not enough values to unpack (expected 3, got 2)

# Concept-03: Return three values and unpack them into three names
# Question: How do we hand back the low, high, AND count of [4, 9, 2, 7] at once? (return three, comma-separated; unpack into three names)
def low_high_count(numbers):
    return min(numbers), max(numbers), len(numbers)

lo, hi, count = low_high_count([4, 9, 2, 7])
print("low:", lo)
print("high:", hi)
print("count:", count)

# Concept-01: *args collects any number of positional values into a tuple
# Question: How do we accept an UNLIMITED number of values, like adding up 1, 2, 3 or 10, 20, 30, 40? (*args gathers them into a tuple)
# E1: THE PROBLEM - a fixed parameter list locks the count in the moment you write it
def total(a, b, c):
    return a + b + c

print(total(1, 2, 3))
# print(total(10, 20, 30, 40))  # uncomment: TypeError, takes 3 positional arguments but 4 were given

# E2: THE FIX - one star takes however many values the caller happens to have
def total(*nums):  # the name is yours: *args is the convention, *nums is fine too
    return sum(nums)

print(total(1, 2, 3))
print(total(10, 20, 30, 40))

# Concept-02: **kwargs collects any number of named values into a dictionary
# Question: How do we let each caller choose WHICH options to pass - gift wrap, a note, both, neither? (**kwargs gathers them into a dict)
# E1: THE PROBLEM - a fixed option list locks in which options exist, and their order
def make_order(item, gift_wrap, note):
    print("options:", gift_wrap, note)

make_order("pen", True, "Thanks")
# make_order("pen", True)  # uncomment: TypeError, missing 1 required positional argument: 'note'

# E2: THE FIX - two stars take whatever named options the caller has
def make_order(item, **options):  # the name is yours: **kwargs is the convention, **options is fine too
    print("options:", options)

make_order("pen", gift_wrap=True, note="Thanks")
make_order("pen", gift_wrap=True)

# Concept-03: Call-site unpacking. Spread a list with * and a dict with ** straight into a call
# Question-1: How do we feed a list we already have, like [5, 10, 15], into a function's arguments? (unpack with * before the list)
# Question-2: How do we feed a dict we already have, like {"gift_wrap": True, "note": "Thanks"}, into a function's arguments? (unpack with ** before the dict)
# Same *args function as Concept-01, repeated so this block stands on its own
def total(*nums):
    return sum(nums)

scores = [5, 10, 15]
print(total(*scores))  # * spreads the list into total(5, 10, 15)

# Same **kwargs function as Concept-02, repeated so this block stands on its own
def make_order(item, **options):
    print("options:", options)

extras = {"gift_wrap": True, "note": "Thanks"}
make_order("pen", **extras)  # ** spreads the dict into make_order("pen", gift_wrap=True, note="Thanks")

# Concept-04: Keyword-only arguments. A bare * forces the arguments after it to be passed by name
# Question: How do we MAKE callers pass an argument by name, for clarity? (put a bare * before it: def f(*, flag))
def make_box(*, width, height):
    return width * height

print(make_box(width=3, height=4))
# print(make_box(3, 4))  # uncomment: TypeError, make_box() takes 0 positional arguments but 2 were given

# Concept-05: One function can take BOTH; *args (a tuple) must come BEFORE **kwargs (a dict)
# Question: How does a function accept any positionals AND any named options at once, like a logging call? (*args first, then **kwargs)
# The same make_order as Concept-02, grown up: any number of ITEMS as well as any number of options
def make_order(*items, **options):
    print("items:", items)
    print("options:", options)

make_order("pen", "book", gift_wrap=True, note="Thanks")
# This would be a SyntaxError - a keyword argument cannot come before a positional one:
# make_order(gift_wrap=True, "pen")

# Concept-01: LOCAL scope. A variable assigned inside a function lives only there
# Question: Where does a variable made inside a function live? (in the function's LOCAL scope; it is gone when the function ends)
def show_course():
    course = "Python"  # LOCAL: born here, gone the moment the function ends
    print("Course:", course)

show_course()

# Concept-02: GLOBAL scope. A name at the top level of the file; a function can READ it
# Question: How can every function in a file share one value, like the platform name, without passing it each time? (define it at the top level; functions can READ that global)
platform = "StackSimplify"  # GLOBAL: top level of the file, so every function can read it

def show_platform():
    print("Platform:", platform)  # reads the global 'platform'

show_platform()

# Concept-03: ENCLOSING scope. A function INSIDE another function can see the outer function's variables (nested functions)
# Question: If we put a function inside another function, can the inner one see the outer one's variables? (yes, the ENCLOSING scope)
platform = "StackSimplify"  # GLOBAL: top level of the file, so every function can read it

def show_course_page():
    course = "Python"  # belongs to show_course_page, the ENCLOSING function

    def show_title():
        print(course, "on", platform)  # the enclosing 'course' AND the global 'platform'

    show_title()

show_course_page()

# Concept-04: The LEGB rule. Python looks up a name in this order: Local, Enclosing, Global, Built-in
# Question-1: When the same name exists in several places, which one does Python use? (LEGB: Local first, then Enclosing, then Global, then Built-in)
# Question-2: What if the name is in NONE of the places we wrote, like len? (Python keeps searching outward and finds it in Built-in)
# E1: the L, the E and the G. Guess first: which x prints inside legb_inner, in legb_outer, and at the very end?
x = "global x"

def legb_outer():
    x = "enclosing x"
    def legb_inner():
        x = "local x"
        print(x)  # Local wins here
    legb_inner()
    print(x)  # Enclosing wins here

legb_outer()
print(x)  # Global wins here

# E2: the B. Nothing we wrote is called len - not local, not enclosing, not global - so the
# search runs all the way out to Built-in, and that is where Python finds it
def show_length():
    print(len("Python"))

show_length()
# len is a built-in NAME Python provides, like print, sum and max. Never shadow one:
# len = 5   # this HIDES the built-in len(); now len("hi") would break

# Concept-05: The global statement. Let a function CHANGE a global variable (use it sparingly; returning a value is usually cleaner)
# Question: How can a function actually change a global value? (declare it with 'global' first, but prefer returning a value)
# E1: WITHOUT global: assigning to score makes it LOCAL, so reading it first causes an error
score = 20  # a global: defined at the top level of the file

def add_points_bad():
    score = score + 10  # UnboundLocalError: score is local here, and has no value yet
    print("Inside the function score:", score)

# Call the function
# add_points_bad()  # uncomment to see the error
print("Global score:", score)  # 20: the global was never changed

# E2: WITH global: 'global score' makes the assignment target the REAL global
score = 20

def add_points():
    global score
    score = score + 10
    print("Inside the function score:", score)

# Call the function
add_points()
add_points()
print("Global score:", score)  # 40: the function changed the global

# Concept-06: The nonlocal statement. Let an inner function CHANGE the ENCLOSING function's variable
# Question: How can an inner (nested) function change a variable that belongs to the outer function? (declare it 'nonlocal')
# E1: WITHOUT nonlocal: assigning to score makes it LOCAL, so reading it first causes an error
def create_score_bad():
    score = 20  # belongs to create_score_bad (enclosing)

    def add_points():
        score = score + 10  # UnboundLocalError: score is local here, and has no value yet
        print("Inner Function score:", score)

    # Call the inner function
    # add_points()  # uncomment to see the error
    print("Enclosing score:", score)  # 20: the enclosing score was never changed

# Call the outer function
create_score_bad()

# E2: WITH nonlocal: 'nonlocal score' makes add_points update the ENCLOSING score
def create_score():
    score = 20

    def add_points():
        nonlocal score
        score = score + 10
        print("Inner Function score:", score)

    # Call the inner function
    add_points()
    add_points()
    print("Enclosing score:", score)  # 40: the enclosing score was changed

# Call the outer function
create_score()

# Note: An inner function that remembers variables from its enclosing function
# is called a CLOSURE. It is the idea behind decorators, which the next course covers.

# Concept-01: A function is a value (an object). You can store it in a variable and call it through that name
# Question: How do we give a long function name a short alias we can call instead? (assign the function to a variable, with no parentheses)
def shout(text):
    return text.upper() + "!"

# NO parentheses: the variable holds the FUNCTION itself
yeller = shout  # store the function itself; note: no parentheses
print(yeller("hello"))  # call it through the new name

# WITH parentheses: the variable holds the RESULT of running it
result = shout("hello")
print(result)
# print(result("x"))  # uncomment: TypeError, 'str' object is not callable

# Concept-02: A function can take ANOTHER function as an argument (a higher-order function)
# Question: How do we pass one function into another so it runs once, twice or three times? (pass the function NAME as the argument, with no parentheses)
# First, a plain function we already know how to write:
def add_three(n):
    return n + 3

# Now higher-order functions: each one TAKES a function (func) and runs it on a value:
def apply_once(func, value):
    return func(value)

def apply_twice(func, value):
    return func(func(value))

def apply_thrice(func, value):
    return func(func(func(value)))

# Pass add_three itself as the argument - its NAME, with no ():
print(apply_once(add_three, 10))
print(apply_twice(add_three, 10))
print(apply_thrice(add_three, 10))

# Concept-03: map applies a function to EVERY item of a list and gives back the transformed results (a built-in higher-order function)
# Question: How do we apply one function to a whole list at once, like adding 3 to every price in [10, 20, 30, 40]? (map(add_three, prices) transforms each)
# Same add_three as Concept-02, repeated so this block stands on its own
def add_three(n):
    return n + 3

prices = [10, 20, 30, 40]
prices_new = list(map(add_three, prices))  # map gives a map object; list() turns it into a list
print(prices_new)
print(type(prices_new))

# Concept-04: filter keeps only the items a function says True to, and drops the rest (a built-in higher-order function)
# Question: How do we keep only the items in [50, 120, 90, 200] that pass a test, like the ones over 100? (filter(is_big, prices) selects)
def is_big(n):
    return n > 100

prices = [50, 120, 90, 200]
print(list(filter(is_big, prices)))  # keep only the big ones -> [120, 200]

# Concept-05: Functions are objects, so they can live in a dict and be picked by key at runtime (dispatch)
# Question: How do we pick which checkout operation to run - shipping, tax, or a coupon - without a big if-chain? (store the functions in a dict, look one up by key)
# E1: the long way: an if/elif chain, and it grows by one branch for every new operation
def run_operation(name, total):
    if name == "shipping":
        return total + 50
    elif name == "tax":
        return total + (total // 10)
    elif name == "coupon":
        return total - 100
    else:
        return total  # unknown name: hand the total back unchanged, never None
print(run_operation("tax", 1000))  # 1100
print(run_operation("gift", 1000))  # 1000 - unknown name, total unchanged

# E2: dict dispatch: store the functions in a dictionary and pick which one to run by key
# A new operation is just one more key-value pair - no if/elif chain
def add_shipping(total):
    return total + 50

def add_tax(total):
    return total + (total // 10)

def apply_coupon(total):
    return total - 100

operations = {
    "shipping": add_shipping,
    "tax": add_tax,
    "coupon": apply_coupon
}

# Get the function stored under the "tax" key - this does NOT call the function
print(operations["tax"])  # <function add_tax at ...>

# Store the selected function in a variable, then CALL it with 1000 as the argument
chosen = operations["tax"]
print(chosen(1000))  # 1100

# Or get the function and CALL it directly with 1000 as the argument
print(operations["tax"](1000))  # 1100

# Other options: pick a different operation by changing only the key
print(operations["shipping"](1000))  # 1050
print(operations["coupon"](1000))  # 900

# Concept-01: A lambda is a tiny ANONYMOUS function - one expression, no name (lambda args: expression)
# Question: How do we write a small function we only need for a moment? (a lambda has no name; to NAME a function, use def)
# A lambda body is ONE expression (no statements, no return keyword) - that is the whole rule.
# E1: with def - a NAMED function, so you can call it again by that name
def square_number(x):
    return x * x

print(square_number(5))

# E2: with lambda - the SAME rule as an ANONYMOUS expression, built and called on the spot
print((lambda x: x * x)(5))
# A lambda can take several arguments too: (lambda x, y: x + y)(2, 3) is 5

# Concept-02: The real use. Hand a function to ANOTHER function, like sorted(key=...) - def or lambda
# Question: How do we sort words like ["banana", "kiwi", "apple", "fig"] by their LENGTH instead of alphabetically? (give sorted a key function; a lambda is perfect here)
# E1: with def - the key is a NAMED function, passed to sorted by name
words = ["banana", "kiwi", "apple", "fig"]

def get_length(word):
    return len(word)

by_length = sorted(words, key=get_length)
print(by_length)

# E2: with lambda - the SAME key written straight into the call, with no name to invent
words = ["banana", "kiwi", "apple", "fig"]
by_length = sorted(words, key=lambda word: len(word))
print(by_length)

# Concept-03: A key function can dig INTO each item - sort (name, score) pairs by the score
# Question: How do we sort records by a field inside each item, like [("Sam", 70), ("Tom", 60), ("Ben", 95)] by score? (key=lambda pair: pair[1])
# E1: with def - the key picks out pair[1], the score
pairs = [("Sam", 70), ("Tom", 60), ("Ben", 95)]

def get_score(pair):
    return pair[1]

by_score = sorted(pairs, key=get_score)
print(by_score)

# E2: with lambda - the same pick, short enough to read inside the call
pairs = [("Sam", 70), ("Tom", 60), ("Ben", 95)]
by_score = sorted(pairs, key=lambda pair: pair[1])
print(by_score)

# Concept-04: map with a lambda - transform every item without naming the transformation
# Question: How do we add 3 to every price in [10, 20, 30, 40] without inventing a name for "add 3"? (map takes any function, and a lambda fits right inside the call)
# E1: with def - the same map as Step-09, where the transformation carries a name
def add_three(n):
    return n + 3

prices = [10, 20, 30, 40]
print(list(map(add_three, prices)))

# E2: with lambda - the same transformation, written where it is used
prices = [10, 20, 30, 40]
print(list(map(lambda n: n + 3, prices)))

# Concept-05: filter with a lambda - keep the items a one-line test says True to
# Question: How do we keep only the prices over 100 in [50, 120, 90, 200] without naming the test? (filter takes any function that answers True or False)
# E1: with def - the same filter as Step-09, where the test carries a name
def is_big(n):
    return n > 100

prices = [50, 120, 90, 200]
print(list(filter(is_big, prices)))

# E2: with lambda - the same test, written where it is used
prices = [50, 120, 90, 200]
print(list(filter(lambda n: n > 100, prices)))

# Concept-01: Import a function from Python's standard library and use it
# Question: How do we use ready-made functions that come with Python, like a square root? (import the module, then module.function())
import math

print(math.sqrt(144))
print(math.floor(3.7))

# Concept-02: Import specific names with "from module import name"
# Question: How do we pull just the names we need from a module? (from module import name1, name2)
from math import pi, ceil

print(pi)
print(ceil(4.1))

# Concept-03: Give a module (or name) a short alias with "as"
# Question: How do we give a long module name a short handle, the way pros write import numpy as np? (import module as alias)
import math as m
print(m.sqrt(49))

from math import factorial as fact
print(fact(5))

# A small module of our OWN. Other files can import these functions.
# (Step-11 imports make_upper and make_lower from here.)

def make_upper(text):
    """Return the text in capital letters."""
    return text.upper()

def make_lower(text):
    """Return the text in small letters."""
    return text.lower()

if __name__ == "__main__":
    # This guard is explained in full in Section 12. In short: this block runs ONLY
    # when you run texttools.py directly, not when another file imports it.
    print(make_upper("hi"))
    print(make_lower("HI"))

# Concept-04: Make your OWN module, then import from it - a .py file of functions sitting next to this one
# Question: How do we reuse functions we wrote in another file? (put them in their own .py, then import from it)
# STEP 1 - create a file named texttools.py in THIS folder, containing exactly this:
#
#     def make_upper(text):
#         return text.upper()
#
#     def make_lower(text):
#         return text.lower()
#
# STEP 2 - now import from it. Python finds texttools because it sits in the same folder as this file.
from texttools import make_upper, make_lower

print(make_upper("welcome"))
print(make_lower("WELCOME"))

# Beyond the standard library: other people publish modules on PyPI. Install one from your
# terminal (NOT inside Python), for example:  pip install requests
# then use it with "import requests", just like math above.

# Concept-01: Recursion. A function that calls ITSELF, with a base case to stop
# Question: How can a function repeat by calling itself, like counting down to zero? (call itself with a smaller value; STOP at the base case)
def countdown(n):
    if n == 0:  # base case, stop here
        print("Liftoff!")
        return
    print(n)
    countdown(n - 1)  # recursive call, with a smaller n

countdown(3)
# WARNING - no base case means it never stops. Python stops it with a
# RecursionError after about 1000 calls (its recursion limit). Never run this:
# def forever(n):
#     print(n)
#     forever(n - 1)   # nothing stops it -> RecursionError

# Concept-02: The classic example, factorial (n! = n * (n-1) * ... * 1)
# Question: How do we compute a factorial with recursion? (n! = n * factorial(n-1), and factorial(1) is 1)
def factorial(n):
    if n == 1:  # base case
        return 1
    return n * factorial(n - 1)

print(factorial(5))
# factorial(5) -> 5 * factorial(4) -> 5 * 4 * factorial(3) -> ... -> 5 * 4 * 3 * 2 * 1 = 120
# The base case here is n == 1, so this factorial expects n >= 1

# Note: most everyday repeating is done with loops (Section 6). Recursion is a tool for
# a few problems. This is a BONUS so you recognize it when you meet it later.