Functions & Reusable Code.

So far, we've used variables, conditions, loops and structured data to make reports. Functions let us give those operations names, test them independently, and reuse them without repeating implementation details.

• Define and call functions without confusing definition with execution.
• Pass values using positional and keyword arguments and describe parameters.
• Explain return versus print and recognize implicit None.
• Keep variables local and understand when mutable inputs can change.
• Use defaults safely and avoid shared mutable default arguments.
• Compose, document and test functions using realistic IT datasets.
• Compare generator expressions with explicit counting loops before using them in a summary.

A function gives a group of instructions a name. The def keyword creates the function, but its indented body does not execute until you call that name. This difference matters in IT automation: defining a device-health check does not contact or inspect anything by itself. Functions make repeated operations understandable and prevent copy-and-paste logic from drifting into inconsistent versions.

def show_device(host):
    print(f'Checking {host}')

print('Start')
show_device('SW-01')
show_device('AP-02')

A parameter is the name written in a function definition, while an argument is the actual value provided at a call site. Each call binds its argument to a new local parameter name. This is how one function works for many hostnames or measurements. Passing the correct number of arguments matters: Python raises TypeError for missing required arguments or extra positional arguments.

def classify_latency(milliseconds):
    if milliseconds >= 200:
        return 'critical'
    return 'normal'

print(classify_latency(35))
print(classify_latency(240))

def classify_latency(milliseconds):
    result = 'critical' if milliseconds >= 200 else 'normal'
    return result

level = classify_latency(240)

print displays text but does not make a computed result available to the caller. return sends an object back to the expression that called the function and exits that call. A function that reaches the end without an explicit return returns None. If you assign the result of a print-only helper, the variable will contain None—not the displayed message. Returning values makes functions composable and testable.

def sum_ports(a, b):
    return a + b

count = sum_ports(2, 3)
print(count + 1)

Variables assigned inside a function normally belong to that function's local scope. They do not become available at module level just because the function ran. Using return makes the boundary explicit. An immutable argument such as a string cannot be altered in place, while mutating a list or dictionary passed into a function can affect the caller; choose whether to return a new value or intentionally modify an object.

def normalize(host):
    cleaned = host.strip().upper()
    return cleaned

raw = ' sw-01 '
result = normalize(raw)
print(result)
print(raw)

A default parameter provides a value when callers omit that argument. Keyword arguments make the purpose of supplied values clear and can be used in a different order from the definition. Put required parameters before parameters with defaults. Default values are evaluated when the def statement runs, so avoid a shared mutable default list or dictionary: use None and create a fresh collection inside the function when needed.

def ticket_label(host, state='unknown'):
    return f'{host}: {state}'

print(ticket_label('SW-01'))
print(ticket_label(state='offline', host='AP-02'))

One function can call another. This is where Python becomes much easier to maintain: a status-normalization helper can be used by a reporting function, so the same rules apply in every place. Each function should have one clear responsibility. Keep input parsing, business logic and printing separate whenever practical; this makes testing individual behaviors much simpler.

def normalize_status(value):
    return value.strip().lower()

def needs_attention(device):
    return normalize_status(device['status']) == 'offline'

print(needs_attention({'status': ' OFFLINE '}))

Functions are interfaces used by other code. A short docstring can explain what an input represents, what is returned and what errors may occur. Then test normal inputs and boundary cases: an empty list, zero, a missing field or an unexpected type. A function that works for one example but fails a second sample is not yet reliable. Use descriptive exception messages instead of silently replacing invalid measurements with made-up values.

def is_critical(latency_ms):
    """Return True for latency at or above 200 ms."""
    return latency_ms >= 200

print(is_critical(199))
print(is_critical(200))

A generator expression looks like (value for item in items if condition). Unlike a list comprehension, it produces values as another operation asks for them; it does not immediately build the whole list. You may see sum(1 for device in devices if is_offline(device)), but it is simply counting one for each matching device. Begin with an explicit count and loop to understand the intent before choosing the shorter form. For beginners, clarity is more important than cleverness.

statuses = ['online', 'offline', 'offline']
count = 0
for status in statuses:
    if status == 'offline':
        count += 1
short_count = sum(1 for status in statuses
                  if status == 'offline')
print(count, short_count)

A small health-report workflow can normalize status text, filter a list of dictionaries and return a summary. It is easier to reuse than one large script because data cleaning can change without rewriting the whole report. Use fictional inventory records here; the browser lesson does not connect to customer devices. The next milestone will introduce file and structured-data inputs so the same helpers can process stored reports.

def is_offline(device):
    return device.get('status', 'unknown').strip().lower() == 'offline'

def count_offline(devices):
    return sum(1 for device in devices if is_offline(device))

records = [{'status': ' OFFLINE '}, {'status': 'online'}, {}]
print(count_offline(records))

Run actual Python in your browser. The first exercise repairs a print-only hostname formatter and verifies it with two inputs. Next, move into arguments, defaults, scope and a two-function inventory report.

Refer to the official Python documentation for function definitions, arguments and return behavior. You can return to these references as your scripts get more complex.