DEV Community: Fidel Okumu

Loops: Repeating Work Without Repeating Code

Fidel Okumu — Tue, 08 Sep 2026 12:51:33 +0000

Introduction
A huge part of programming is doing the same action many times — checking every driver in a list, processing every row of data, or repeating a task until a condition is met. Loops are how Python handles this without forcing me to copypaste the same line over and over.
For Loops
A for loop runs a block of code once for every item in a collection.

What I understood here: driver is a temporary variable that takes on each value in drivers, one at a time in order. The loop runs exactly as many times as there are items in the list four times, in this case.

While Loops
A while loop repeats until a condition becomes false, rather than looping over a fixed collection.

The detail that took the most getting used to: the condition is checked before every round, and the loop starts counting from 0. So while rides_completed < 3 actually runs 3 times (for 0, 1, 2), not what I initially assumed. Forgetting the += 1 line entirely would make the condition stay true forever, causing an infinite loop — one of the most common mistakes with while loops.

Break and Continue
These give more control over a loop's execution:

The distinction: break exits the loop immediately and nothing after it runs, not even for remaining items. continue only skips the current round the loop still checks every other item normally.

Enumerate()
Sometimes I need both the item and its position in the list. Enumerate() provides both at once:

What I Learned
I learned that loops allow Python to repeat instructions automatically until a certain condition is met or until all items have been processed.

Functions: Writing Reusable Code

Fidel Okumu — Tue, 08 Sep 2026 12:22:51 +0000

Introduction
As my scripts grew longer, I noticed the same blocks of logic showing up again and again.
Functions lets a user write a piece of logic once and reuse it anywhere, with different data each time.

Defining and Calling Functions
Defining a function only saves its instructions — it doesn't run anything yet:

Calling it is what actually executes the code:

Parameters and Arguments
A parameter is the placeholder name written inside the function definition — an empty slot waiting for a value.
An argument is the real value handed over when the function is actually called.

A function can take multiple parameters

Return Values
Return sends a value back to whoever called the function, so it can be stored and reused elsewhere — unlike print(), which only displays something once.

An important detail: as soon as a function hits a return statement, it exits immediately. Any code written after return inside that function never runs

What I Learned
Functions reframed how I think about writing code — instead of asking "what should this line do," I started asking "what small reusable task does this represent?, and what inputs does it need?." Understanding parameters versus arguments, and that variables inside a function have their own separate scope

PYTHON Data Structures lists, Tuples, Dictionaries and Sets

Fidel Okumu — Tue, 08 Sep 2026 11:50:15 +0000

INTRODUCTION
After learning storing single values in variables, We needed a way to hold collection of data i.e multiple ride counts
multiple cities etc.
Python offers four main data structures for this that is:

LISTS
A list is a built-in data type used to store multiple items in a single variable.
A list can be changed and allows addition of more items
It can also contain items of different data types
Lists also preserve and allows duplicate values

![ ](https://dev-to-uploads.s3.us-east-2.amazonaws.com/uploads/articles/njfzoohpy0tokgot2si1.png

TUPLES
A tuple is similar to a list but once created, it cannot be changed.

Trying to modify a tuple raises an error by design.
Tuples are mainly used when values should stay fixed throughout a program example: routes fixed origin and destinations.

DICTIONARIES
A dictionary stores data in key-value.
This allows lookups by name instead of position
example;

Dictionaries are written in curly brackets {}
Each has a corresponding value
The keys should be unique
Dictionaries can be changed

SETS
A set stores only unique values any duplicates are automatically removed
They are written using curly brackets {}
You can add or remove items in a set
They are useful when keeping unique items

What I Learned
The most useful shift in understanding was realizing that choosing a data structure is really a design decision, not just a syntax choice. Picking a list when a dictionary is more appropriate (or vice versa) doesn't just look sloppy — it makes later code longer and harder to reason about. Matching the structure to what the data actually needs to do made every function I wrote afterward noticeably simpler.