Chapter 17: How Python Functions Turn Repetitive Network Logic into Elegant Automation - Part 1

1. Why Functions Matter in Network Automation

In network engineering, we thrive on structure, clarity, and repeatability.

We build topologies using layers, protocols with well-defined behaviors, and operating models that aim to eliminate chaos through consistency. Yet, when it comes to automation, many engineers fall into a trap: writing long, repetitive scripts that are hard to manage, hard to debug, and nearly impossible to reuse.

This is where functions become your most critical ally.

If you’ve ever copied and pasted the same five lines of Python code across multiple parts of your script, or worse, across multiple files, this article is for you.

Again, the antidote to messy, unscalable scripting is the use of functions.

What’s a Function, Really?

A function in Python is simply a named block of logic that you can call again and again.

You can think of it like a tool in your CLI toolbox:

• Instead of typing the same show interface | include up command on every router…

• You write a script that defines what this check means.

• And then you encapsulate that logic into a function: check_interface_status().

Functions let you name a piece of behavior and reuse it without rewriting it every time.

They are like network design patterns, but for your Python code.

Why Network Engineers Should Care

Imagine the following scenarios:

• You need to validate the interface’s status on 100 switches.

• You want to verify BGP neighbor uptime and format alerts differently based on vendor.

• You want to extract IP addresses from running configs across a multi-vendor environment.

• You want to validate hostnames, config timestamps, or software versions across data centers.

What do all these tasks have in common?

They are repeated operations that apply similar logic to different data.

Instead of writing 200 lines of procedural code, you can write a few well-structured functions, each one responsible for one specific task. These functions become your toolbox, and once you have them, you can use them anywhere.

Functions and the Power of Abstraction

Abstraction is a powerful engineering concept. In networking, we don’t configure every bit individually; we use protocols, encapsulation, and hierarchies to make complexity manageable.

Functions offer the same principle in code.

Let’s look at two contrasting styles:

1. Procedural (bad):

print(f"Checking router1 interface")
# code to parse data

print(f"Checking router2 interface")
# same code repeated

print(f"Checking router3 interface")
# repeated again

2. Functional (good):

def check_interface(device):
    print(f"Checking {device} interface")
    # shared parsing logic here

for device in ["router1", "router2", "router3"]:
    check_interface(device)

See the difference?

The second example is:

• Shorter

• More readable

• Easier to debug

• Easier to extend

Need to check router4 later? Just add it to the list.

Functions Are the First Step to Professional-Grade Code

As your automation skills grow, you'll want to:

• Build libraries of reusable helpers (push_config(), parse_vlan_output(), etc.)

• Share code with colleagues

• Write tests for your code (unit testing)

• Use frameworks like Nornir or custom NetBox API wrappers

• Package logic into CLI tools or integrations

None of this is possible without functions. They are the entry point to writing real Python, not just quick scripts.

From Copy-Paste to Declarative Logic

In production environments, we want our automation tools to be:

• Predictable

• Reproducible

• Auditable

• Easy to troubleshoot

Functions help you achieve this by:

• Making code easier to follow

• Enforcing separation of concerns

• Avoiding duplication

• Enabling test coverage

If you’re building a system that needs to validate interface naming on all core routers, don’t write that code inline 50 times. Write it once. Wrap it in a function. Call it when needed.

A Network Engineer’s Evolution

Our goal with this article is to take you from Beginner to Intermediate, and give you the foundation for reaching Advanced.

What You’ll Learn in This Article

By the end of this article, you’ll be able to:

• Understand how to define and use functions in Python

• Write your own reusable functions to perform network tasks

• Avoid code duplication with clarity and intention

• Start structuring your scripts like real tools, not quick hacks

• Build up your own toolbox of automation helpers

Let’s begin by understanding the fundamentals: how functions are defined and called in Python.

Let's dive in.

Subscribe to our premium content to read the rest.