Defining and Calling Functions

You have called functions since your first Python program:

print("Hello")
length = len("hello")

A function call asks Python to run behavior that has been defined somewhere. Until now, almost all of those definitions came from Python itself.

You can define your own functions too.

Your First Function

The output is:

Hello!
Welcome to the program.

The definition begins with def:

def greet():

The colon starts an indented block, just as it does with if, for, and while. The indented lines form the function body.

The function body does not run merely because Python reads the definition. It runs when the function is called:

greet()

Read that line as:

Run the function named greet.

The parentheses are part of the call. They will become more important in the next chapter, when functions begin receiving information.

Defining Is Not Calling

Before running this program, predict whether inside greet appears before or after after definition:

The output is:

before definition
after definition
inside greet
after call

When Python reaches:

def greet():

it creates the function definition and continues past the body. The body is saved for later. Only the call greet() makes Python enter the function and execute its lines.

A useful trace is:

1. print before definition;
2. define greet;
3. print after definition;
4. call greet;
5. execute the body and print inside greet;
6. return to the line after the call;
7. print after call.

This idea matters whenever you read a larger program. Function definitions often appear near the top, but their bodies may run much later.

Trace a few definitions and calls before writing your own:

Now define and call one small function yourself:

LAUNCH CONTROL
READY

Calling a Function More Than Once

Once behavior has a name, it can be reused:

def print_separator():
    print("--------------------")


print("First section")
print_separator()
print("Second section")
print_separator()
print("Third section")

The two calls execute the same body at different points in the program.

This is one reason functions help with duplicated code. If the separator later changes, there is one definition to edit instead of several copied lines.

But avoiding duplication is not the only reason to use a function. A function name can also make the structure of a program easier to see.

Compare:

print("--------------------")
print("SUMMARY")
print("--------------------")

with:

print_separator()
print("SUMMARY")
print_separator()

The second version tells a reader what the repeated lines are for.

Use repeated calls to keep one visual detail in one place:

----------

FLIGHT PLAN
----------
CREW
----------
SUPPLIES
----------

Try calling a function in natural language. Assemble the given definition and body blocks, then write the step that calls the function between the START and END print steps.

START
---
END

Functions as Named Pieces of Work

The measurement program in the overview had four jobs: read input, select usable values, calculate a summary, and present the result. A function can give one of these jobs a name.

For example, a program that collects values and displays the usable ones might later look like this:

values = read_values()
usable = select_usable(values)
print(usable)

This is a design sketch, not a complete runnable program: read_values and select_usable have not been defined here. The next chapter explains how functions return values. For now, notice that the names let you follow the program’s tasks without reading all the code for each one.

A Definition Must Run Before Its Function Is Called

When Python executes a call, the function name must already refer to a function. At the top level of a program, this normally means Python must execute the function’s def statement before it reaches the call.

This does not work:

greet()


def greet():
    print("Hello")

When the first line runs, Python does not yet know what greet refers to.

A common structure is therefore:

def greet():
    print("Hello")


def print_separator():
    print("----------")


print_separator()
greet()
print_separator()

Function definitions appear first. The main program comes afterwards. This is a useful program structure, not a rule that every function body must appear earlier than every call written anywhere in the file. What matters is whether the definition has executed by the time Python executes the call.

You will see this structure repeatedly throughout the rest of the course.

Common Mistakes

Forgetting the parentheses when calling

This:

greet

does not run the body. greet refers to the function itself. greet() calls it.

Forgetting the colon

def greet()
    print("Hello")

is invalid syntax. The definition line ends in a colon.

Incorrect indentation

def greet():
print("Hello")

The body must be indented.

Defining but never calling

This program produces no output:

def greet():
    print("Hello")

The function exists, but nothing asks it to run.

Repair each of these mistakes in a complete program:

Finally, explain the chapter’s central distinction in your own words:

def show_signal():
    print("Signal received")

print("Waiting")
show_signal()

Check Your Understanding

1. What is the difference between defining a function and calling it?
2. How do the colon and indentation identify a function’s body?
3. Where does execution continue after a function call finishes?
4. What must have happened before Python can call a function by its name?
5. When would it be useful to give a piece of work its own function name?