Functional Programming: Beginner

Build reusable functions with def

You have already used functions without realizing it. Every time you write print("Hello") or len("text"), you are calling a function. These are built-in functions that come with Python, created by Python developers to handle common tasks. The print() function displays output to the screen. The len() function calculates the length of a string or collection. You do not need to know how these functions work internally; you just need to know what to give them and what they give back.

Each function call follows the same pattern: write the function name, open parentheses, provide any data the function needs (called arguments), and close parentheses. The function processes the arguments and may produce a result you can use.

Reusability

Write code once and call it from anywhere in your program

Maintainability

Fix bugs in a single place instead of hunting down every copy

Readability

Give complex logic a meaningful name that explains its purpose

Testability

Test each function independently to catch errors early

Organization

Break large problems into smaller, manageable pieces

To create a function, use the def keyword (short for "define"), followed by the function name, parentheses, and a colon. The lines of code that belong to the function must be indented. This indented block is called the function body, and it contains the code that runs when you call the function.

Notice the order of output. The code inside the function only runs when you call it with greet(). Defining a function is like writing a recipe; calling it is like actually cooking the dish. You can call a function as many times as you want, and each call executes the function body from the beginning.

def format_score(score):
    rounded = ___(score, 1)
    return ___(rounded) + "%"

print(format_score(87.456))

Pass data into functions with params

When you call greet("Alice"), Python assigns the value "Alice" to the parameter name. Inside the function, name behaves like any other variable, holding that value for the duration of the function call.

The parameter greeting has a default value of "Hello". When you call greet("Alice") with only one argument, greeting uses its default. When you provide a second argument, that value overrides the default.

def greet(name, greeting=___"Hello""Hey""Welcome"):
    print(greeting + ", " + name)

greet("Alice")

Send results back with return values

Functions can send data back to the caller using the return statement. This is how functions produce results that you can store in variables, use in calculations, or pass to other functions. Return values transform functions from mere action performers into calculators that produce usable results.

The return statement immediately exits the function and sends the specified value back to where the function was called. That value replaces the function call in the expression, as if you had written the value directly.

Beginners often confuse print() and return. They seem similar because both involve output, but they serve completely different purposes. Understanding this distinction is fundamental to writing useful functions:

add_with_print displays 8 on the screen but returns None, so result1 is useless. add_with_return does not display anything but returns 8, which we can store, display, or use in further calculations.

If a function does not have a return statement, or if return is used without a value, the function automatically returns None. None is Python's special value representing "nothing" or "no value."

When Python encounters a return statement, it immediately exits the function. Any code after the return statement never runs. This is useful for early exits when you have already determined the result:

Control variable visibility in code

The parameter x inside the function is a separate variable that happens to start with the same value as number. Changing x does not change number. This is called pass by value for simple types like numbers and strings.

def get_stats(numbers):
    biggest = ___(numbers)
    count = ___(numbers)
    return biggest, count

top, n = get_stats([4, 9, 2, 7])
print(top)
print(n)

Annotate functions with type hints

Add type hints after parameter names with a colon and the type. Add return type hints after the closing parenthesis with -> followed by the type:

These hints tell readers that calculate_area expects two float numbers and returns a float. greet expects a str and returns a str. is_adult expects an int and returns a bool (True or False).

Python does not enforce type hints at runtime. You can pass a str where the hint says int, and Python will try to run the code. This differs from statically-typed languages like Java or TypeScript. Type hints are purely informational:

The type hint says int, but Python happily multiplies a str by 2 (which repeats it). Type hints are for documentation and for external tools like type checkers (mypy) that analyze code before you run it.

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 calculate_area(width, height):
  area = width * height
  print(area)

result = calculate_area(5, 3)
print("Area is:", result)

greet (without parentheses) is the function object itself. greet() (with parentheses) calls the function. They are very different: