🐍 Lesson 10: Functions

Define a function called cheer that prints Have a great day!, then call it once.

def cheer():
    print("Have a great day!")

cheer()

Write a function greet(name) that prints Hi, NAME!. Call it with "Sam" and then "Mia". Output:

def greet(name):
    print(f"Hi, {name}!")

greet("Sam")
greet("Mia")

Write a function area(width, height) that returns width × height. Call it with 4 and 5 and print the result (it's 20).

def area(width, height):
    return width * height

print(area(4, 5))

Write a function is_even(n) that returns True if n is even, False if odd. Print is_even(8) then is_even(3). Output:

def is_even(n):
    return n % 2 == 0

print(is_even(8))
print(is_even(3))

Invent a useful function! Ideas: double(n) that returns n×2, shout(word) that returns it in CAPS, or a function that builds a fun greeting. Call it a few times.

Write rectangle_area(width, height) that returns width × height. Print the area of a 4 × 6 rectangle and a 2 × 9 rectangle.

def rectangle_area(width, height):
    return width * height

print(rectangle_area(4, 6))
print(rectangle_area(2, 9))

Write greet(name, greeting="Hello") that returns "Hello, Ana!". Call it once with just a name, and once with greeting="Yo".

def greet(name, greeting="Hello"):
    return f"{greeting}, {name}!"

print(greet("Ana"))
print(greet("Ben", greeting="Yo"))

Write min_and_max(numbers) that returns both the smallest and the largest value. Call it with [4, 9, 1, 7], unpack the answer into low, high, and print low 1 high 9.

def min_and_max(numbers):
    return min(numbers), max(numbers)

low, high = min_and_max([4, 9, 1, 7])
print("low", low, "high", high)

Write is_teenager(age) that returns True when the age is between 13 and 19 (inclusive). Print the answer for 12, 13 and 20.

def is_teenager(age):
    return 13 <= age <= 19

print(is_teenager(12))
print(is_teenager(13))
print(is_teenager(20))

Write double(n) that returns n × 2, and quadruple(n) that returns double(double(n)). Print quadruple(5).

def double(n):
    return n * 2

def quadruple(n):
    return double(double(n))

print(quadruple(5))

Write safe_divide(a, b) that returns the text "Cannot divide by zero" straight away if b is 0, otherwise returns a / b. Print safe_divide(10, 2) and safe_divide(7, 0).

def safe_divide(a, b):
    if b == 0:
        return "Cannot divide by zero"
    return a / b

print(safe_divide(10, 2))
print(safe_divide(7, 0))

Write average(numbers) that returns the mean of a list, rounded to 1 decimal place. Print the average of [8, 9, 10] and of [3, 4].

def average(numbers):
    return round(sum(numbers) / len(numbers), 1)

print(average([8, 9, 10]))
print(average([3, 4]))

Write celsius_to_fahrenheit(c) with a docstring (a """triple-quoted""" sentence on the first line inside the function) explaining what it does. Print the result for 0 and 100, then print celsius_to_fahrenheit.__doc__ — exactly the sentence Convert Celsius to Fahrenheit.

def celsius_to_fahrenheit(c):
    """Convert Celsius to Fahrenheit."""
    return c * 9 / 5 + 32

print(celsius_to_fahrenheit(0))
print(celsius_to_fahrenheit(100))
print(celsius_to_fahrenheit.__doc__)

Write three small functions: is_long_enough(p) (8+ characters), has_digit(p) (contains any of 0-9) and strength(p) which returns "strong" when both are true, "medium" when only one is, and "weak" when neither. Print the strength of "dragon123", "dragon" and "a1".

def is_long_enough(p):
    return len(p) >= 8

def has_digit(p):
    for ch in p:
        if ch.isdigit():
            return True
    return False

def strength(p):
    score = 0
    if is_long_enough(p):
        score += 1
    if has_digit(p):
        score += 1
    if score == 2:
        return "strong"
    if score == 1:
        return "medium"
    return "weak"

print(strength("dragon123"))
print(strength("dragon"))
print(strength("a1"))

Write four functions you would actually use: convert money, work out a tip, turn a name into initials, pick a random compliment… then call them all and print the results. Give every one a clear name and a docstring. 🧰