Functions: Beginner

Create reusable code blocks with def

A function is a named block of code that performs a specific task. Think of it as a mini-program within your program that you can run whenever you need it. You create a function using the def keyword, which is short for "define." After def, you write the function name, followed by parentheses and a colon. All the code that belongs to the function must be indented beneath the definition line. This indented block is called the function body.

Pay close attention to the execution order in the output above. The code inside greet() only runs when you explicitly call the function with parentheses. Defining a function is like writing a recipe and putting it in a cookbook. Calling the function is like actually following that recipe to cook the dish. You can define a function once and call it as many times as you need throughout your program.

Reusability

Write code once and use it anywhere in your program without duplication.

Maintainability

Fix bugs or improve logic in one place, and every caller benefits instantly.

Readability

Give complex operations meaningful names that explain intent at a glance.

Testability

Test each function independently with known inputs and expected outputs.

Organization

Break large problems into smaller, manageable pieces that are easy to reason about.

Function names follow the same rules as variable names in Python. They must start with a letter or underscore, can contain only letters, numbers, and underscores, and cannot be reserved Python keywords like if, for, or class. Beyond these technical requirements, there are strong community conventions that make code more readable and professional.

Good function names use lowercase letters with words separated by underscores, a style called snake_case. They use verbs or verb phrases that describe what the function does. A developer reading calculate_total_revenue immediately understands the purpose without examining the code inside. Poor names like doStuff or func1 force readers to study the implementation to understand what the function does, wasting time and causing confusion.

___ greet():
    ___("Hello, World!")

greet()
greet()

Notice how we defined print_separator once but called it six times through announce_section. If we want to change the separator character from equals signs to dashes, we modify one line in print_separator, and all six uses update automatically. This is the fundamental value of functions: change once, benefit everywhere.

Pass data into functions flexibly

When you call greet_user("Alice"), Python creates a local variable named name and assigns the value "Alice" to it. Inside the function body, name behaves like any other variable, holding that value for the duration of this particular call. When the function finishes, that local variable is destroyed. The next call creates a fresh variable with whatever new value you pass.

def describe(name, age):
    return ___ + " is " + ___(age)

print(describe("Alice", 28))

Send computed results back to callers

Functions become truly powerful when they can send data back to the caller. The return statement lets a function produce a result that you can store in a variable, use in calculations, pass to other functions, or include in expressions. Return values transform functions from actions that just do things into calculators that compute and deliver usable results.

The return statement immediately exits the function and sends the specified value back to where the function was called. That returned value effectively replaces the function call in your code. In the expression calculate_area(20, 15) * cost_per_sqft, Python first calls the function to get 300, then multiplies 300 by 25 to get 7500.

One of the most common sources of confusion for beginners is the difference between print() and return. They seem similar because both involve outputting information, but they serve completely different purposes. Understanding this distinction is essential for writing useful functions that work correctly in larger programs.

Look carefully at the output. add_with_print displays 15 on the screen, but when we store the result, we get None. We cannot do math with None. Meanwhile, add_with_return does not display anything itself, but the returned value 15 can be stored, multiplied, added, or used in any way we need.

When Python executes a return statement, it immediately exits the function. Any code after the return statement never runs. This behavior is useful for early exits when you have already determined the result and do not need to continue processing.

Try changing the return keyword below to see how it affects function behavior. What happens when you use print instead of return?

def double(n):
    ___returnprint n * 2

result = double(5)
print(result)

If a function has no return statement, or uses return without a value, Python automatically returns None. None is a special Python value that represents "nothing" or "no value." Functions that return None are used for their side effects, like printing output, writing files, or modifying data structures.

Chain function calls into pipelines

Function calls can appear anywhere Python expects a value: on the right side of an assignment, inside print(), as an argument to another function, or as part of an arithmetic expression. Python evaluates the function call first, gets the returned value, and then uses that value in the surrounding expression.

There is an important distinction between a function reference and a function call. Writing my_func without parentheses gives you the function object itself, which you can pass around or inspect. Writing my_func() with parentheses actually executes the function and gives you its return value.

Document functions for team clarity

The docstring appears immediately after the function definition, enclosed in triple quotes. Python stores it in the __doc__ attribute. IDEs show docstrings when you hover over function names, and tools like help() display them. This makes docstrings a powerful form of inline documentation that stays with the code.

Self-documenting

Documentation lives right next to the code it describes.

IDE integration

Editors show docstrings as you type function calls, speeding up development.

Team collaboration

New team members understand functions faster without reading implementation.

API design clarity

Writing docs first helps clarify what functions should do before coding.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

def add(a, b):
  result = a + b
  print result
  return result