Objective

In this unit, we will learn about functions in Python. Functions are a way to group code into reusable blocks, making your programs more organized and easier to understand. By the end of this unit, you will understand how to create and use functions, and you will know about function parameters and return values.

What is a Function?

A function is a block of code that only runs when it is called. You can pass data, known as parameters, into a function. A function can return data as a result. In Python, a function is defined using the def keyword.

Creating and Calling Functions

To create a function in Python, you need to use the def keyword. Here's an example of a function that prints "Hello, World!" to the console:

def my_function():
  print("Hello, World!")

To call a function, you simply write the function's name followed by parentheses:

my_function()

If you run this code, it will print "Hello, World!" to the console.

Function Parameters and Arguments

Information can be passed into functions as arguments. Arguments are specified after the function name, inside the parentheses. You can add as many arguments as you want, just separate them with a comma. Here's an example of a function with one argument:

def my_function(name):
  print(f"Hello, {name}!")

Note: In the print statement, we're using an f-string (formatted string literal) to insert the value of name into the string. The f at the beginning of the string tells Python to allow embedded expressions inside curly braces {}. The expression inside the curly braces is evaluated and its value is inserted into the string. In this case, the expression is just a variable, so the value of the variable name is inserted into the string. This is a very convenient way to build or format strings.

When we call this function, we need to provide one argument:

my_function("Alice")

This will print "Hello, Alice!" to the console.

Return Values

A function can return a value using the return statement. When Python encounters a return statement, it will exit the function immediately and pass the value from return back as the result of the function. Here's an example of a function that returns a value:

def my_function(x):
  return 5 * x

You can call this function and store its return value in a variable:

result = my_function(3)
print(result)

This will print "15" to the console.

Project: Draw a Pattern of Shapes by Making Use of Reusable Functions

For this project, you'll create a function that draws a shape using the Turtle library, and then you'll use this function to draw a pattern of shapes.

Here's a simple example:

import turtle

# Create a new turtle screen and set its background color
screen = turtle.Screen()
screen.bgcolor("white")

# Initialize a turtle object
t = turtle.Turtle()

# Function to draw a square
def draw_square(turtle, side_length):
    for _ in range(4):
        turtle.forward(side_length)
        turtle.right(90)

# Draw a pattern of squares
for _ in range(36):
    draw_square(t, 100)
    t.right(10)

# Hide the turtle and wait until the window is closed
t.hideturtle()
turtle.done()

This program defines a function called draw_square to draw a square. The function takes two parameters: turtle, which is the turtle object that will draw the square, and side_length, which is the length of each side of the square. Inside the function, we use a for loop to draw each side of the square. In each iteration of the loop, the turtle moves forward by side_length units, then turns right by 90 degrees.

At this point, the function is only defined, but the block of code it contains has not yet been executed. That occurs in the next block of code where we draw a pattern of squares. Here, we use a for loop to draw 36 squares. In each iteration of the loop, we call the draw_square function to draw a square with a side length of 100 units, then turn the turtle right by 10 degrees. This creates a pattern of squares that rotate around a central point.

Try to modify this program to draw different shapes and patterns!

In the next unit, we'll look at lambda functions and explore how we can define small, anonymous functions.