DEV Community: Feddy Mwanjumwa

Python OOP: How Classes and Objects Finally Started Making Sense

Feddy Mwanjumwa — Sun, 04 Oct 2026 15:12:10 +0000

Object-Oriented Programming, or OOP, was one of the Python topics that looked complicated before I actually used it.

I kept seeing words like classes, objects, attributes, methods, and inheritance.

At first, I was asking myself, "Why can't I just use functions and variables?"

After practicing, I started to understand that OOP is mainly about organising related data and behaviour together.

What is OOP?

OOP stands for Object-Oriented Programming.

The basic idea is to create objects that contain information and actions related to that object.

For example, if I'm building a school system, a student has information such as a name, age, and course.

A student can also perform actions, such as introducing themselves.

OOP gives me a way to put all of that together.

Classes

A class is like a blueprint for creating objects.

For example:

class Student:

pass

Right now, the class doesn't do anything.

I'm basically saying, "I want a blueprint called Student."

Creating an object

An object is an actual instance of a class.

For example:

student1 = Student()

student2 = Student()

Now I have two Student objects created from the same class.

This was one distinction I had to understand:

Class → blueprint

Object → actual thing created from the blueprint

init()

A class becomes much more useful when I give its objects some information.

That's where __init__() comes in.

For example:

class Student:

def __init__(self, name, age):

self.name = name

self.age = age

Now I can create students like this:

student1 = Student("Feddy", 20)

student2 = Student("Amina", 21)

Each object gets its own name and age.

What is self?

self was probably one of the strangest things when I first saw OOP.

I eventually understood that self refers to the current object.

For example:

class Student:

def __init__(self, name, age):

self.name = name

self.age = age

When I create:

student1 = Student("Feddy", 20)

self.name belongs to student1.

When I create:

student2 = Student("Amina", 21)

self.name belongs to student2.

So the same class can create objects with different information.

Attributes

Attributes are basically the data stored inside an object.

In this example:

self.name = name

self.age = age

name and age are attributes of the Student object.

I can access them like this:

print(student1.name)

print(student1.age)

The result could be:

Feddy

20

Methods

Methods are functions that belong to a class.

For example:

class Student:

def __init__(self, name, age):

self.name = name

self.age = age

def introduce(self):

print(f"My name is {self.name} and I am {self.age} years old.")

Now I can call the method:

student1.introduce()

The result is:

My name is Feddy and I am 20 years old.

This was where OOP started becoming more practical for me.

The object has data, and it also has behaviour.

Changing attributes

Because objects can store data, I can also change that data.

For example:

student1.age = 21

Now:

print(student1.age)

gives:

21

This can be useful when information changes while the program is running.

A practical example

I can create a simple bank account class.

class BankAccount:

def __init__(self, owner, balance):

self.owner = owner

self.balance = balance

def deposit(self, amount):

self.balance += amount

def show_balance(self):

print(f"{self.owner}'s balance: KSh {self.balance}")

Now I can create an account:

account = BankAccount("Feddy", 5000)

I can deposit money:

account.deposit(2000)

And check the balance:

account.show_balance()

The result is:

Feddy's balance: KSh 7000

This example helped me see why putting data and related functions inside one class can be useful.

Inheritance

Another important OOP concept is inheritance.

Inheritance allows one class to get attributes and methods from another class.

For example, I can create a general class:

class Animal:

def speak(self):

print("Animal makes a sound")

Then create another class based on it:

class Dog(Animal):

pass

Now the Dog class automatically gets the speak() method.

I can do:

dog = Dog()

dog.speak()

And get:

Animal makes a sound

The Dog class inherited the method from Animal.

Overriding a method

A child class can also change how an inherited method behaves.

For example:

class Animal:

def speak(self):

print("Animal makes a sound")

class Dog(Animal):

def speak(self):

print("Dog barks")

Now:

dog = Dog()

dog.speak()

gives:

Dog barks

The Dog class has its own version of speak().

This is called method overriding.

Another practical example

Suppose I'm creating an employee system.

I can start with:

class Employee:

def __init__(self, name, salary):

self.name = name

self.salary = salary

Then I can create a manager class:

class Manager(Employee):

def manage_team(self):

print(f"{self.name} is managing the team.")

Now:

manager = Manager("Feddy", 120000)

I can use the inherited information:

print(manager.salary)

And also the method from Manager:

manager.manage_team()

This is where inheritance started making sense to me. I can reuse code from an existing class instead of starting everything from zero.

What I understood

The main ideas I took from OOP are:

Class → blueprint for creating objects.

Object → an actual instance of a class.

__init__() → sets up the object when it is created.

self → refers to the current object.

Attributes → information stored in the object.

Methods → actions the object can perform.

Inheritance → allows one class to reuse another class's code.

Once I understood these, OOP became much less intimidating.

Final thoughts

OOP took me longer to understand than some of the earlier Python topics.

The syntax wasn't necessarily the hardest part. The difficult part was understanding why I would even want to organise my code this way.

What finally helped was using realistic examples.

A student has information and actions.

A bank account has information and actions.

An employee has information and actions.

That's when I started seeing the point of OOP.

Instead of having data and functions scattered everywhere, I can organise related things into objects.

And that makes much more sense when a program starts getting bigger.

Python Exception Handling: How I Learned to Handle Errors

Feddy Mwanjumwa — Sun, 04 Oct 2026 13:46:55 +0000

When I started writing Python programs, getting an error was frustrating.

I would run my program and suddenly see a long error message in the terminal.

At first, I just wanted the error to disappear.

Then I realised that errors are actually useful because they tell me something went wrong.

The next question was: how can I make my programs handle these situations without crashing?

That's where exception handling came in.

What is an exception?

An exception is an error that happens while a program is running.

For example, this will cause an error:

number = int(input("Enter a number: "))

If I enter:

hello

Python can't convert "hello" into an integer, so the program crashes.

Instead of letting that happen, I can handle the error.

try and except

The basic structure is try and except.

For example:

try:

number = int(input("Enter a number: "))

print(number)

except ValueError:

print("Please enter a valid number.")

Now if I enter:

hello

I get:

Please enter a valid number.

The program doesn't suddenly stop.

This was probably the first time exception handling really made sense to me.

A practical example

Imagine I'm creating a simple division program.

Normally:

number = int(input("Enter a number: "))

divisor = int(input("Enter the divisor: "))

result = number / divisor

print(result)

But what happens if the user enters 0 as the divisor?

Python raises a ZeroDivisionError.

I can handle it:

try:

number = int(input("Enter a number: "))

divisor = int(input("Enter the divisor: "))

result = number / divisor

print(result)

except ZeroDivisionError:

print("You cannot divide by zero.")

Now the program can respond properly instead of crashing.

Handling different errors

A program can have more than one possible error.

For example:

try:

number = int(input("Enter a number: "))

divisor = int(input("Enter the divisor: "))

print(number / divisor)

except ValueError:

print("Please enter numbers only.")

except ZeroDivisionError:

print("You cannot divide by zero.")

Now Python can handle each problem differently.

That helped me understand that except isn't just about saying "something went wrong."

I can tell Python what kind of problem I expect and what I want it to do about it.

else

else runs when no exception occurs.

For example:

try:

number = int(input("Enter a number: "))

except ValueError:

print("Invalid number.")

else:

print(f"You entered {number}.")

So:

Correct input → else runs.

Invalid input → except runs.

I found this useful when I wanted to separate successful code from error-handling code.

finally

finally runs whether there is an error or not.

For example:

try:

file = open("notes.txt", "r")

print(file.read())

except FileNotFoundError:

print("The file does not exist.")

finally:

print("Finished attempting to read the file.")

The finally block will always run.

This is useful when there is something I need to do regardless of whether the operation succeeded.

A file example

Since I had already learnt file handling, this was one of the easiest ways for me to understand exception handling.

Imagine I try to open a file that doesn't exist:

try:

with open("contacts.txt", "r") as file:

print(file.read())

except FileNotFoundError:

print("Contacts file not found.")

Instead of getting a long traceback, my program can give the user a clear message.

raise

Sometimes I don't want to wait for Python to generate an error.

I can create an exception myself using raise.

For example, suppose I don't want negative ages:

age = int(input("Enter your age: "))

if age < 0:

raise ValueError("Age cannot be negative.")

print(age)

This lets me create my own rule and stop the program when that rule is broken.

A practical validation example

Suppose I'm creating a simple registration system.

I want the user to be at least 18:

age = int(input("Enter your age: "))

if age < 18:

raise ValueError("You must be at least 18 years old.")

print("Registration successful.")

I'm now checking for a condition that matters to my program rather than just relying on Python to find a technical error.

What I understood

The biggest thing I learnt is that exception handling isn't about hiding errors.

It's about deciding how my program should respond when something unexpected happens.

I started thinking about it like this:

try → "Try this code."

except → "If this specific problem happens, handle it like this."

else → "If everything worked, do this."

finally → "Do this no matter what."

raise → "I want to create an error because this situation isn't acceptable."

Final thoughts

At first, errors made me feel like my code was completely wrong.

Now I see them differently.

Some errors are simply situations my program needs to be prepared for.

A user might enter the wrong type of data.

A file might not exist.

Someone might try to divide by zero.

A value might break a rule in my program.

Exception handling gives me a way to deal with those situations without making the whole program fall apart.

That was an important shift for me: a good program isn't one where errors never happen. It's one that knows how to handle them.

Python File Handling: How I Learned to Save Data Outside My Program

Feddy Mwanjumwa — Sun, 04 Oct 2026 13:46:11 +0000

One thing I noticed while learning Python was that all the data I created disappeared when I stopped the program.

For example, I could create a list of contacts:

contacts = ["Amina", "Brian", "Feddy"]

It would work while the program was running, but once I closed it, the data was gone.

So I started wondering: how do I make Python save information?

That's where file handling came in.

What is file handling?

File handling is simply using Python to create, read, write, and update files.

For example, I can create a text file called notes.txt and use Python to store information in it.

The function I use is open().

Opening a file

I can open a file like this:

file = open("notes.txt", "r")

The "r" means I'm opening the file for reading.

I can then read the contents:

content = file.read()

print(content)

And when I'm finished:

file.close()

This works, but I quickly learnt that there is a better way.

Using with open()

Instead of manually closing the file, I can use with.

with open("notes.txt", "r") as file:

content = file.read()

print(content)

Python automatically handles closing the file after I'm done.

This is the approach I prefer.

Reading a file

There are a few ways to read a file.

read()

read() gives me the entire file as one string.

For example:

with open("notes.txt", "r") as file:

content = file.read()

print(content)

If the file contains:

I am learning Python.

I get that entire text back.

readline()

readline() reads one line.

For example:

with open("notes.txt", "r") as file:

line = file.readline()

print(line)

This is useful when I only need the first line or want to process a file one line at a time.

readlines()

readlines() reads all the lines and gives them to me as a list.

For example:

with open("notes.txt", "r") as file:

lines = file.readlines()

print(lines)

If the file contains:

Bread

Milk

Sugar

I get something similar to:

["Bread\n", "Milk\n", "Sugar\n"]

I can also loop directly through the file:

with open("notes.txt", "r") as file:

for line in file:

print(line.strip())

I like this approach when working with files containing many records.

Writing to a file

If I want Python to write something into a file, I use "w".

For example:

with open("notes.txt", "w") as file:

file.write("I am learning Python.")

Now the text is saved inside notes.txt.

One thing I had to learn here is that "w" can overwrite what is already in the file.

So if I already had:

I am learning Python.

and then ran:

with open("notes.txt", "w") as file:

file.write("I am learning SQL.")

the old text would be replaced.

Appending to a file

What if I want to keep the old information and add something new?

That's where "a" comes in.

For example:

with open("notes.txt", "a") as file:

file.write("\nI am also learning SQL.")

Now the file contains both pieces of information.

This made sense to me for things like logs, transactions, or contact books where I'm constantly adding new records.

A practical contact book

One of the examples that helped me understand file handling was saving contacts.

I can start with a dictionary:

contacts = {"Amina": "0712345678", "Brian": "0723456789", "Feddy": "0734567890"}

I can save them to a file:

with open("contacts.txt", "w") as file:

for name, phone in contacts.items():

file.write(f"{name}: {phone}\n")

Now my contacts.txt file will contain:

Amina: 0712345678

Brian: 0723456789

Feddy: 0734567890

This was the point where file handling started feeling like something I could actually use.

Adding a new contact

Later, I can add another contact without deleting the existing ones:

name = "Faith"

phone = "0745678901"

with open("contacts.txt", "a") as file:

file.write(f"{name}: {phone}\n")

Now Faith is added to the file.

Reading the contacts back

I can also open the file later and read the saved contacts:

with open("contacts.txt", "r") as file:

for line in file:

print(line.strip())

This is what really made the concept click for me.

My program can save data, close, and later open the file and get the data back.

File modes

The three modes I used most are:

"r" → read

"w" → write

"a" → append

So I started thinking about them like this:

I want to see what's already there → "r"

I want to create or replace the contents → "w"

I want to add something without deleting what's already there → "a"

Checking whether a file exists

Sometimes I don't know whether a file already exists.

Python provides the os module for this.

For example:

import os

if os.path.exists("contacts.txt"):

print("File exists")

else:

print("File does not exist")

This became useful when I started thinking about programs that need to work with files safely.

Working with lines

Suppose I have a file containing product names:

Bread

Milk

Sugar

I can read each one and clean it:

with open("products.txt", "r") as file:

for line in file:

product = line.strip()

print(product)

The strip() removes the newline character and any unnecessary spaces.

This connects nicely with what I learnt about strings.

What I understood

The biggest thing I learnt about file handling is that it gives my Python programs a way to remember information after they stop running.

The basic idea became:

open() → access the file

read() → get information

write() → save or replace information

append() → add information

close() → close the file

And using:

with open(...)

makes the process much cleaner.

Final thoughts

Before learning file handling, my programs only remembered things while they were running.

After learning it, I could save contacts, notes, products, and other information to a file and use that information later.

That was a small but important step for me because Python started feeling less like a language for simple exercises and more like something I could use to build actual programs.

Python Strings: What I Learned About Working with Text

Feddy Mwanjumwa — Sun, 04 Oct 2026 13:42:29 +0000

Strings were one of the first Python concepts I came across.

At first, I thought a string was just text inside quotation marks.

And honestly, that's basically what it is.

But once I started working with names, messages, passwords, and other text, I realised there was a lot more I could do with strings.

Creating a string

A string is simply text.

For example:

name = "Feddy"

message = 'Welcome to Python'

Both single and double quotation marks work.

I usually use double quotes, but the important thing is to be consistent.

Accessing characters

Just like lists, strings are indexed.

Python starts counting from 0.

For example:

name = "Feddy"

print(name[0])

The result is:

F

The second character is:

print(name[1])

which gives:

e

This was useful because I realised I could work with individual characters instead of treating the whole string as one thing.

Negative indexing

I can also count from the end.

name = "Feddy"

print(name[-1])

This gives:

y

And:

print(name[-2])

gives:

d

I found this especially useful when I wanted to get the last character without calculating the length of the string.

Slicing strings

I can also take part of a string using slicing.

For example:

name = "Feddy Mwanjumwa"

print(name[0:5])

The result is:

Feddy

The starting position is included, but the ending position is not.

I can also get everything after a certain position:

print(name[6:])

This gives:

Mwanjumwa

Once I understood slicing with lists, slicing strings felt much easier.

Changing the case

Python gives me several ways to change the case of text.

For example:

name = "feddy mwanjumwa"

print(name.upper())

This gives:

FEDDY MWANJUMWA

I can also use:

print(name.lower())

which gives:

feddy mwanjumwa

And if I want the first letter of each word capitalised:

print(name.title())

which gives:

Feddy Mwanjumwa

I found these methods useful when dealing with inconsistent text.

Removing unwanted spaces

Sometimes text has spaces that shouldn't be there.

For example:

name = " Feddy "

I can use:

print(name.strip())

The result is:

Feddy

There are also:

lstrip()

and:

rstrip()

which remove spaces from the left and right respectively.

This became particularly useful when I started thinking about cleaning data.

Replacing text

I can replace part of a string using replace().

For example:

message = "I am learning Java"

message = message.replace("Java", "Python")

Now the message becomes:

I am learning Python

This is useful when I need to correct or change specific text.

Checking whether text exists

I can check whether a word or character exists inside a string using in.

For example:

email = "feddy@gmail.com"

print("@gmail.com" in email)

The result is:

True

I can also use this in a condition:

if "@gmail.com" in email:

print("Gmail address")

This made strings much more useful when I started thinking about validation.

Finding text

I can use find() to get the position of a piece of text.

For example:

email = "feddy@gmail.com"

print(email.find("@"))

The result is:

5

So the @ is at index 5.

I can use this when I need to know where something appears inside a string.

Counting characters or words

count() tells me how many times something appears.

For example:

message = "Python is easy and Python is useful"

print(message.count("Python"))

The result is:

2

This can be useful when analysing or checking text.

Splitting a string

split() turns a string into a list.

For example:

names = "Feddy,Amina,Brian"

names = names.split(",")

Now I get:

["Feddy", "Amina", "Brian"]

This was an important one for me because it showed me how I could move from text into a list of individual values.

Joining strings

join() does almost the opposite.

Suppose I have:

names = ["Feddy", "Amina", "Brian"]

I can join them together:

result = ", ".join(names)

The result is:

Feddy, Amina, Brian

This is useful when I have separate pieces of text that I want to combine into one string.

Checking the beginning and end

I can check whether a string starts or ends with certain text.

For example:

filename = "report.pdf"

print(filename.startswith("report"))

This gives:

True

And:

print(filename.endswith(".pdf"))

also gives:

True

This can be useful when working with filenames or user input.

String formatting with f-strings

One of my favourite things about Python strings is f-strings.

They make it easy to combine text with variables.

For example:

name = "Feddy"

age = 20

print(f"My name is {name} and I am {age} years old.")

The result is:

My name is Feddy and I am 20 years old.

I found this much cleaner than constantly joining strings together with +.

A practical example

I can put several string concepts together in a simple program.

Suppose a user enters their name with extra spaces and strange capitalisation:

name = input("Enter your name: ")

I can clean it:

name = name.strip().title()

Then display it:

print(f"Welcome, {name}!")

So if the user enters:

fEDDY mwanjumwa

the program displays:

Welcome, Feddy Mwanjumwa!

This was the kind of example that helped me understand why string methods actually matter.

What I understood

The biggest thing I learnt is that strings aren't just text that I print on the screen.

I can clean them, search them, split them, combine them, change their case, check them, and extract specific parts from them.

The methods I started using most are:

strip() → remove unwanted spaces

upper() → convert to uppercase

lower() → convert to lowercase

title() → capitalise words

replace() → replace text

split() → turn text into a list

join() → combine text

find() → find the position of text

count() → count occurrences

Final thoughts

Strings seemed very basic when I first started Python.

But once I started working with real text, I realised how often I needed to manipulate it.

For me, strings really started making sense when I stopped thinking of them as just words inside quotation marks and started thinking of them as data that I could work with.

That shift made a big difference in how I approached Python.

Python Sets: How I Learned to Work with Unique Values

Feddy Mwanjumwa — Sun, 04 Oct 2026 13:39:57 +0000

When I first came across sets in Python, I didn't immediately see why I needed them.

I already had lists and dictionaries, so I wondered what sets were supposed to do differently.

The thing that made sets click for me was one word , unique.

A set is useful when I want to store values without duplicates.

Creating a set

A set is created using curly brackets.

For example:

numbers = {1, 2, 3, 4}

I can also create a set from a list:

numbers = set([1, 2, 2, 3, 3, 4])

The result is:

{1, 2, 3, 4}

The duplicate values are removed automatically.

That was the first thing that made sets useful to me.

Why would I use a set?

Imagine I have customer locations:

locations = ["Nairobi", "Mombasa", "Nairobi", "Kisumu", "Mombasa"]

If I want to know the unique locations, I can do:

unique_locations = set(locations)

Now I get:

{"Nairobi", "Mombasa", "Kisumu"}

Instead of manually checking for duplicates, Python handles it for me.

Adding items

I can add an item using add().

locations = {"Nairobi", "Mombasa"}

locations.add("Kisumu")

Now the set contains:

{"Nairobi", "Mombasa", "Kisumu"}

If I try to add something that's already there:

locations.add("Nairobi")

Python doesn't create another "Nairobi".

That's because sets only keep unique values.

Removing items

I can remove an item using remove():

locations.remove("Mombasa")

I can also use discard():

locations.discard("Mombasa")

The difference is that remove() raises an error if the item doesn't exist, while discard() simply does nothing.

I found discard() useful when I wasn't sure whether a value was already in the set.

Checking if an item exists

Just like with lists, I can use in.

For example:

locations = {"Nairobi", "Mombasa", "Kisumu"}

print("Nairobi" in locations)

The result is:

True

This is useful when I only need to know whether a value exists.

Finding the length

I can use len() with a set:

locations = {"Nairobi", "Mombasa", "Kisumu"}

print(len(locations))

The result is:

3

This tells me how many unique values are in the set.

Sets and loops

I can loop through a set just like other Python collections.

For example:

locations = {"Nairobi", "Mombasa", "Kisumu"}

for location in locations:

print(location)

Python goes through each unique value.

One thing I had to understand is that sets don't work like lists when it comes to positions.

Sets don't use indexing

With a list, I can do:

products = ["Bread", "Milk", "Sugar"]

print(products[0])

But I can't do that with a set:

products = {"Bread", "Milk", "Sugar"}

print(products[0])

A set doesn't have positions that I can rely on.

That is another reason I wouldn't use a set when the order of items matters.

Union

Sets become really useful when comparing groups of data.

Suppose I have customers from two branches:

nairobi_customers = {"Amina", "Brian", "Feddy"}

mombasa_customers = {"Brian", "Faith", "Kevin"}

I can combine all unique customers using union():

all_customers = nairobi_customers.union(mombasa_customers)

The result contains:

{"Amina", "Brian", "Feddy", "Faith", "Kevin"}

Brian only appears once.

Intersection

What if I want to find customers who appear in both branches?

I can use intersection():

common_customers = nairobi_customers.intersection(mombasa_customers)

The result is:

{"Brian"}

This was one of the most useful set operations for me because it makes comparing groups very easy.

Difference

I can also find values that exist in one set but not another.

For example:

nairobi_only = nairobi_customers.difference(mombasa_customers)

The result is:

{"Amina", "Feddy"}

These are customers in the Nairobi set who are not in the Mombasa set.

Symmetric difference

There is also symmetric_difference().

It gives me values that are in either set, but not in both.

different_customers = nairobi_customers.symmetric_difference(mombasa_customers)

The result is:

{"Amina", "Feddy", "Faith", "Kevin"}

Brian isn't included because he appears in both sets.

A practical example

Imagine I have two lists of students who attended different events.

event_one = ["Feddy", "Amina", "Brian", "Faith"]

event_two = ["Brian", "Faith", "Kevin", "David"]

I can convert them to sets:

set_one = set(event_one)

set_two = set(event_two)

Now I can find students who attended both events:

set_one.intersection(set_two)

Students who only attended the first event:

set_one.difference(set_two)

And everyone who attended at least one of the events:

set_one.union(set_two)

This is where I started seeing why sets exist.

They're not just another way to store a bunch of values. They're really useful when I care about uniqueness and comparing groups.

Converting a set back to a list

Sometimes I may need a list after removing duplicates.

For example:

names = ["Feddy", "Amina", "Feddy", "Brian"]

I can remove duplicates:

unique_names = set(names)

And convert the result back to a list:

unique_names = list(set(names))

Now I have a list containing only the unique names.

What I understood

The main thing I learnt about sets is that I shouldn't think of them as a replacement for lists.

They solve a different problem.

If I need ordered data, I think of a list.

If I need unique data, I think of a set.

If I need to compare two groups of values, sets become especially useful.

Final thoughts

Sets were probably one of those Python topics that only made sense after I actually had a problem to solve.

The moment I needed to remove duplicate data or compare two groups, sets suddenly became useful.

Python Dictionaries: What I Learned About Key-Value Data

Feddy Mwanjumwa — Sun, 04 Oct 2026 13:33:13 +0000

After working with lists and tuples, I came across dictionaries.

At first, dictionaries felt a little strange because I was used to accessing things by position, like products[0].

With dictionaries, I had to use keys instead.

That was the main idea I had to understand.

A dictionary stores information as key-value pairs.

Creating a dictionary

A dictionary uses curly brackets {}.

For example:

student = {"name": "Feddy", "age": 20, "course": "Data Science"}

Here:

"name" is the key.

"Feddy" is the value.

The same applies to the other pieces of information.

I started thinking of it as giving every piece of information a label.

Accessing values

Unlike a list, I don't use a position.

I use the key:

student = {"name": "Feddy", "age": 20, "course": "Data Science"}

print(student["name"])

The result is:

Feddy

I can also access the age:

print(student["age"])

The result is:

20

This was the point where dictionaries started making sense to me.

Instead of thinking, "Which position is the age in?", I just ask for "age".

Using get()

There is another way to access a value:

student.get("name")

This also gives:

Feddy

The difference becomes useful when the key doesn't exist.

For example:

print(student.get("phone"))

Instead of raising an error, Python returns:

None

I can even provide a default value:

print(student.get("phone", "No phone number"))

Now I get:

No phone number

I found this useful when working with data where some information might be missing.

Adding new values

Dictionaries are changeable.

I can add a new key-value pair like this:

student["city"] = "Nairobi"

Now the dictionary contains the city as well.

I don't have to recreate the entire dictionary just to add one more piece of information.

Updating values

I can also change an existing value.

For example:

student["age"] = 21

Now the age is 21.

The same syntax is used for both adding and updating.

If the key already exists, the value changes.

If it doesn't exist, Python adds it.

Removing values

There are a few ways to remove dictionary items.

Using pop():

student.pop("city")

This removes the "city" entry.

I can also use del:

del student["age"]

And if I want to remove everything:

student.clear()

The dictionary itself still exists, but there is nothing inside it.

Checking if a key exists

I can check whether a key is in a dictionary using in.

For example:

"name" in student

This returns:

True

I can also use it in a condition:

if "phone" in student:

print("Phone number exists")

This became useful when dealing with information that isn't always available.

Finding the number of items

Just like with lists and tuples, I can use len().

student = {"name": "Feddy", "age": 20, "course": "Data Science"}

print(len(student))

The result is:

3

There are three key-value pairs in the dictionary.

Getting all keys

I can get all the keys using keys():

student.keys()

For example:

for key in student.keys():

print(key)

This would give me:

name

age

course

I use this when I only care about the labels.

Getting all values

I can get the values using values():

for value in student.values():

print(value)

This gives:

Feddy

20

Data Science

Getting keys and values together

This is one of the dictionary methods I use most.

items() gives me both:

for key, value in student.items():

print(f"{key}: {value}")

The output would be:

name: Feddy

age: 20

course: Data Science

This is especially useful when I want to go through all the information in a dictionary.

Looping through dictionaries

I can loop through a dictionary in different ways.

Just the keys:

for key in student:

print(key)

Just the values:

for value in student.values():

print(value)

Or both:

for key, value in student.items():

print(key, value)

I found .items() easiest when I wanted to actually work with the information.

Dictionary with numbers

Dictionaries don't have to store text.

For example:

prices = {"Bread": 80, "Milk": 120, "Sugar": 180}

I can get the price of milk:

print(prices["Milk"])

The result is:

120

I can also update it:

prices["Milk"] = 130

Now the price is 130.

This made dictionaries feel useful for things like products and prices.

A practical inventory example

Let's say I'm building a small shop inventory.

I could have:

product = {"name": "Bread", "price": 80, "quantity": 20}

Now I can access each piece of information:

print(product["name"])

print(product["price"])

print(product["quantity"])

I can also calculate the value of the stock:

stock_value = product["price"] * product["quantity"]

print(stock_value)

The result is:

1600

Now the dictionary is storing information, while my code is using that information to do something useful.

Nested dictionaries

This is where dictionaries become much more powerful.

A dictionary can contain another dictionary.

For example:

students = {

"student1": {"name": "Feddy", "age": 20, "course": "Data Science"},

"student2": {"name": "Amina", "age": 21, "course": "Python"}

}

Now I can access Feddy's name using:

print(students["student1"]["name"])

The result is:

Feddy

And Amina's course:

print(students["student2"]["course"])

The result is:

Python

At first this looked confusing because there are multiple brackets, but I realised I was simply going one dictionary level at a time.

A list of dictionaries

I can also combine dictionaries with lists.

For example:

students = [

{"name": "Feddy", "age": 20},

{"name": "Amina", "age": 21},

{"name": "Brian", "age": 19}

]

Now I have a list containing three dictionaries.

I can loop through them:

for student in students:

print(student["name"])

This gives:

Feddy

Amina

Brian

This structure started making a lot of sense to me because it looks much more like real data.

Dictionary comprehension

Just like lists have comprehensions, dictionaries do too.

For example:

squares = {number: number ** 2 for number in range(1, 6)}

The result is:

{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

I found this easier to understand after becoming comfortable with normal loops.

The same idea is happening, but Python lets me write it in a shorter form.

Copying dictionaries

Just like lists, I need to be careful when copying dictionaries.

If I do:

student2 = student

both variables refer to the same dictionary.

So changing one can affect the other.

To create a separate copy, I can use:

student2 = student.copy()

Now I can modify student2 without changing the original dictionary.

What I understood about dictionaries

The biggest thing I learnt is that dictionaries are really useful when the information needs labels.

With a list, I might have:

student = ["Feddy", 20, "Data Science"]

But now I have to remember that index 0 is the name, index 1 is the age, and index 2 is the course.

With a dictionary:

student = {"name": "Feddy", "age": 20, "course": "Data Science"}

I don't have to remember positions.

I just use the key I need.

Lists vs dictionaries

This is how I now think about the difference.

A list:

products = ["Bread", "Milk", "Sugar"]

is useful when I mainly care about the collection of items.

A dictionary:

product = {"name": "Bread", "price": 80, "quantity": 20}

is useful when I care about different pieces of information about one thing.

And I can combine them:

inventory = [

{"name": "Bread", "price": 80, "quantity": 20},

{"name": "Milk", "price": 120, "quantity": 15},

{"name": "Sugar", "price": 180, "quantity": 10}

]

That combination is something I expect to use a lot as I build bigger Python programs.

Final thoughts

Dictionaries took some getting used to because they are different from the position-based approach I was used to with lists.

But once I understood the idea of keys and values, everything started falling into place.

I can add information, update it, remove it, search for it, loop through it, and even put dictionaries inside other data structures.

The biggest thing I took away is simple:

A list helps me organise items.

A dictionary helps me organise information about those items.

That distinction has made choosing between the two much easier for me.

After working with lists and tuples, I came across dictionaries.

At first, dictionaries felt a little strange because I was used to accessing things by position, like products[0].

With dictionaries, I had to use keys instead.

That was the main idea I had to understand.

A dictionary stores information as key-value pairs.

Creating a dictionary

A dictionary uses curly brackets {}.

For example:

student = {"name": "Feddy", "age": 20, "course": "Data Science"}

Here:

"name" is the key.

"Feddy" is the value.

The same applies to the other pieces of information.

I started thinking of it as giving every piece of information a label.

Accessing values

Unlike a list, I don't use a position.

I use the key:

student = {"name": "Feddy", "age": 20, "course": "Data Science"}

print(student["name"])

The result is:

Feddy

I can also access the age:

print(student["age"])

The result is:

20

This was the point where dictionaries started making sense to me.

Instead of thinking, "Which position is the age in?", I just ask for "age".

Using get()

There is another way to access a value:

student.get("name")

This also gives:

Feddy

The difference becomes useful when the key doesn't exist.

For example:

print(student.get("phone"))

Instead of raising an error, Python returns:

None

I can even provide a default value:

print(student.get("phone", "No phone number"))

Now I get:

No phone number

I found this useful when working with data where some information might be missing.

Adding new values

Dictionaries are changeable.

I can add a new key-value pair like this:

student["city"] = "Nairobi"

Now the dictionary contains the city as well.

I don't have to recreate the entire dictionary just to add one more piece of information.

Updating values

I can also change an existing value.

For example:

student["age"] = 21

Now the age is 21.

The same syntax is used for both adding and updating.

If the key already exists, the value changes.

If it doesn't exist, Python adds it.

Removing values

There are a few ways to remove dictionary items.

Using pop():

student.pop("city")

This removes the "city" entry.

I can also use del:

del student["age"]

And if I want to remove everything:

student.clear()

The dictionary itself still exists, but there is nothing inside it.

Checking if a key exists

I can check whether a key is in a dictionary using in.

For example:

"name" in student

This returns:

True

I can also use it in a condition:

if "phone" in student:

print("Phone number exists")

This became useful when dealing with information that isn't always available.

Finding the number of items

Just like with lists and tuples, I can use len().

student = {"name": "Feddy", "age": 20, "course": "Data Science"}

print(len(student))

The result is:

3

There are three key-value pairs in the dictionary.

Getting all keys

I can get all the keys using keys():

student.keys()

For example:

for key in student.keys():

print(key)

This would give me:

name

age

course

I use this when I only care about the labels.

Getting all values

I can get the values using values():

for value in student.values():

print(value)

This gives:

Feddy

20

Data Science

Getting keys and values together

This is one of the dictionary methods I use most.

items() gives me both:

for key, value in student.items():

print(f"{key}: {value}")

The output would be:

name: Feddy

age: 20

course: Data Science

This is especially useful when I want to go through all the information in a dictionary.

Looping through dictionaries

I can loop through a dictionary in different ways.

Just the keys:

for key in student:

print(key)

Just the values:

for value in student.values():

print(value)

Or both:

for key, value in student.items():

print(key, value)

I found .items() easiest when I wanted to actually work with the information.

Dictionary with numbers

Dictionaries don't have to store text.

For example:

prices = {"Bread": 80, "Milk": 120, "Sugar": 180}

I can get the price of milk:

print(prices["Milk"])

The result is:

120

I can also update it:

prices["Milk"] = 130

Now the price is 130.

This made dictionaries feel useful for things like products and prices.

A practical inventory example

Let's say I'm building a small shop inventory.

I could have:

product = {"name": "Bread", "price": 80, "quantity": 20}

Now I can access each piece of information:

print(product["name"])

print(product["price"])

print(product["quantity"])

I can also calculate the value of the stock:

stock_value = product["price"] * product["quantity"]

print(stock_value)

The result is:

1600

Now the dictionary is storing information, while my code is using that information to do something useful.

Nested dictionaries

This is where dictionaries become much more powerful.

A dictionary can contain another dictionary.

For example:

students = {

"student1": {"name": "Feddy", "age": 20, "course": "Data Science"},

"student2": {"name": "Amina", "age": 21, "course": "Python"}

}

Now I can access Feddy's name using:

print(students["student1"]["name"])

The result is:

Feddy

And Amina's course:

print(students["student2"]["course"])

The result is:

Python

At first this looked confusing because there are multiple brackets, but I realised I was simply going one dictionary level at a time.

A list of dictionaries

I can also combine dictionaries with lists.

For example:

students = [

{"name": "Feddy", "age": 20},

{"name": "Amina", "age": 21},

{"name": "Brian", "age": 19}

]

Now I have a list containing three dictionaries.

I can loop through them:

for student in students:

print(student["name"])

This gives:

Feddy

Amina

Brian

This structure started making a lot of sense to me because it looks much more like real data.

Dictionary comprehension

Just like lists have comprehensions, dictionaries do too.

For example:

squares = {number: number ** 2 for number in range(1, 6)}

The result is:

{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

I found this easier to understand after becoming comfortable with normal loops.

The same idea is happening, but Python lets me write it in a shorter form.

Copying dictionaries

Just like lists, I need to be careful when copying dictionaries.

If I do:

student2 = student

both variables refer to the same dictionary.

So changing one can affect the other.

To create a separate copy, I can use:

student2 = student.copy()

Now I can modify student2 without changing the original dictionary.

What I understood about dictionaries

The biggest thing I learnt is that dictionaries are really useful when the information needs labels.

With a list, I might have:

student = ["Feddy", 20, "Data Science"]

But now I have to remember that index 0 is the name, index 1 is the age, and index 2 is the course.

With a dictionary:

student = {"name": "Feddy", "age": 20, "course": "Data Science"}

I don't have to remember positions.

I just use the key I need.

Lists vs dictionaries

This is how I now think about the difference.

A list:

products = ["Bread", "Milk", "Sugar"]

is useful when I mainly care about the collection of items.

A dictionary:

product = {"name": "Bread", "price": 80, "quantity": 20}

is useful when I care about different pieces of information about one thing.

And I can combine them:

inventory = [

{"name": "Bread", "price": 80, "quantity": 20},

{"name": "Milk", "price": 120, "quantity": 15},

{"name": "Sugar", "price": 180, "quantity": 10}

]

That combination is something I expect to use a lot as I build bigger Python programs.

Final thoughts

Dictionaries took some getting used to because they are different from the position-based approach I was used to with lists.

But once I understood the idea of keys and values, everything started falling into place.

I can add information, update it, remove it, search for it, loop through it, and even put dictionaries inside other data structures.

The biggest thing I took away is simple:

A list helps me organise items.

A dictionary helps me organise information about those items.

That distinction has made choosing between the two much easier for me.

Python Tuples: What I Learned About Fixed Data

Feddy Mwanjumwa — Sun, 04 Oct 2026 13:28:19 +0000

After learning lists, I came across tuples.

At first, I honestly wondered why Python needed tuples when lists already existed.

They looked almost the same.

For example, a list looks like this:

products = ["Bread", "Milk", "Sugar"]
And a tuple looks like this:

products = ("Bread", "Milk", "Sugar")

The big difference I eventually understood is that lists can be changed, while tuples cannot.

That one idea made tuples much easier to understand.

Creating a tuple

A tuple is created using parentheses:

fruits = ("Apple", "Mango", "Banana")

I can also create a tuple with numbers:

numbers = (10, 20, 30, 40)

Or different types of values:

person = ("Feddy", 20, True)

Just like lists, tuples can store multiple values.

Accessing items

Tuples use indexing just like lists.

Python starts from 0.

For example:

fruits = ("Apple", "Mango", "Banana")

print(fruits[0])

The result is:

Apple

I can also use negative indexing:

print(fruits[-1])

This gives:

Banana

So the way I access tuple items is almost exactly the same as with lists.

The main difference: tuples cannot be changed

This is where tuples become different.

Suppose I have:

coordinates = (10, 20)

I can't do this:

coordinates[0] = 50

Python will give me an error because tuples are immutable.

That simply means once the tuple is created, I cannot change its individual values.

This was the main thing that helped me understand when to use a tuple.

Why would I want data that cannot change?

At first, I thought being unable to change the data was a disadvantage.

Then I started thinking about information that should stay fixed.

For example, coordinates:

location = (-1.286389, 36.817223)

Or the days of the week:

days = ("Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday")

I don't want my program accidentally changing these values.

That's where tuples make sense.

Tuple methods

Tuples don't have as many methods as lists because they cannot be modified.

The two main ones I use are count() and index().

For example:

numbers = (10, 20, 20, 30, 20)

I can count how many times 20 appears:

print(numbers.count(20))

The result is:

3

I can also find the position of an item:

print(numbers.index(30))

The result is:

3

That's basically it for the most common tuple-specific methods.

Checking if an item exists

Just like with lists, I can use in.

For example:

days = ("Monday", "Tuesday", "Wednesday")

print("Monday" in days)

The result is:

True

I can also use it in a condition:

if "Monday" in days:

print("It's a weekday")

Finding the length

I can use len() with tuples too.

coordinates = (10, 20)

print(len(coordinates))

The result is:

2

So functions such as len() work with both lists and tuples.

Slicing tuples

Tuples can also be sliced.

For example:

numbers = (10, 20, 30, 40, 50)

print(numbers[1:4])

The result is:

(20, 30, 40)

Just like with lists, the starting index is included and the ending index is not.

Looping through a tuple

I can use a for loop with a tuple.

For example:

days = ("Monday", "Tuesday", "Wednesday")

for day in days:

print(day)

Python goes through the tuple one item at a time.

This is useful when I have a fixed collection of values that I still need to process.

Tuple unpacking

This was one of the more interesting things I learnt about tuples.

I can assign the values of a tuple to separate variables.

For example:

student = ("Feddy", 20, "Data Science")

I can write:

name, age, course = student

Now:

name is "Feddy"

age is 20

course is "Data Science"

I can then do:

print(name)

print(age)

print(course)

This is called tuple unpacking.

Once I understood it, I started noticing how useful it could be when working with multiple values at once.

Returning multiple values from a function

Tuple unpacking also makes sense when working with functions.

For example:

def get_student():

return "Feddy", 20, "Data Science"

I can then do:

name, age, course = get_student()

Python returns the three values together, and I can unpack them into separate variables.

I found this interesting because I don't have to create three separate variables inside the function just to return them.

A tuple with one item

There is one small thing that caught me out.

This:

numbers = (10)

is not actually a tuple.

Python treats it as a normal number.

For a single-item tuple, I need a comma:

numbers = (10,)

That comma is important.

This is one of those small Python details I only really remembered after using it.

Tuples can contain mutable objects

The tuple itself cannot be changed, but it can contain something that can be changed.

For example:

student = ("Feddy", ["Python", "SQL"])

I can't replace "Feddy" with another name.

But the list inside the tuple can be changed:

student[1].append("Power BI")

Now the tuple contains:

("Feddy", ["Python", "SQL", "Power BI"])

This was a good reminder that immutable doesn't always mean absolutely everything inside can never change.

Lists vs tuples

This became much clearer to me when I stopped thinking about syntax and started thinking about the data.

A list:

products = ["Bread", "Milk", "Sugar"]

A tuple:

shop_location = ("Nairobi", "Kenya")

The products might change.

The location probably shouldn't.

So I started thinking about it like this:

List → data I may need to modify.

Tuple → data I want to keep fixed.

A practical example

Imagine I'm building a small application for a shop.

I could store the shop location as:

shop_location = ("Nairobi", "Kenya")

I can access the city:

print(shop_location[0])

And the country:

print(shop_location[1])

But I don't want another part of the program accidentally changing the location.

For products, I would probably use a list instead:

products = ["Bread", "Milk", "Sugar"]

because products can be added or removed.

This helped me understand that choosing between a list and a tuple isn't about which one is better.

It's about what I want the data to do.

What I understood

The biggest thing I learnt about tuples is that they are useful for data that shouldn't be changed.

I can still:

Access items
Slice them
Loop through them
Check for values
Count values
Find positions
Unpack values

But I can't simply change one of the items after creating the tuple.

Final thoughts

At first, tuples felt unnecessary because they looked so similar to lists.

But once I understood they are immutable , their purpose became much clearer.

I don't reach for a tuple because it has more features than a list.

Python Data Structures: Lists

Feddy Mwanjumwa — Sun, 04 Oct 2026 13:18:59 +0000

When I started learning Python, I quickly realised that storing one value at a time wasn't going to be enough.

I needed a way to store multiple things together.

That's where lists came in.

At first, a list looked very simple:

products = ["Bread", "Milk", "Sugar", "Soap"]

But there is actually quite a lot you can do with a list.

Creating a list

A list is created using square brackets [].

For example:

names = ["Feddy", "Amina", "Brian"]

A list can contain numbers:

prices = [80, 120, 250, 300]

It can also contain different data types:

student = ["Feddy", 20, True, 85.5]

Although Python allows mixed data types, I usually keep a list focused on similar kinds of data because it makes the code easier to understand.

Indexing

One of the first things I learnt about lists was indexing.

Python starts counting from 0.

So:

products = ["Bread", "Milk", "Sugar", "Soap"]

print(products[0])

gives: Bread

And: print(products[2])

gives:Sugar

This was confusing at first because I naturally wanted the first item to be position 1. Eventually, I got used to Python starting at 0.

Negative indexing

Python also lets me access items from the end of the list.

print(products[-1])

gives:Soap

And: print(products[-2])

gives: Sugar

I find this useful when I want the last item without having to count how many items are in the list.

Changing items

Lists are mutable.

In simple terms, that means I can change them after creating them.

For example:

products = ["Bread", "Milk", "Sugar"]

products[1] = "Rice"

Now the list becomes:

["Bread", "Rice", "Sugar"]

This was one of the first moments where I understood that lists aren't fixed. I can keep modifying them as my program runs.

Adding items
There are a few ways to add items.

1.append()

append() adds one item to the end.

products.append("Salt")

If the list was:

["Bread", "Milk", "Sugar"]

it becomes:

["Bread", "Milk", "Sugar", "Salt"]

2. insert()

insert() lets me add an item at a specific position.

products.insert(1, "Flour")

Now Flour is placed at index 1.

3. extend()

extend() is useful when I want to add several items.

products.extend(["Tea", "Coffee"])

Instead of adding the items one at a time, Python adds both to the list.

Removing items

I can also remove items in different ways.

1. remove()

remove() removes a specific value.

products.remove("Milk")

2. pop()

pop() removes an item based on its index.

products.pop(1)

If I don't give an index, it removes the last item:

products.pop()

One useful thing about pop() is that it can give me back the item that was removed.

removed_product = products.pop()

3. del

I can also use del:

del products[0]

This removes the item at index 0.

4. clear()

And if I want to remove everything:

products.clear()

The list still exists, but it is now empty.

Checking if an item exists

I can check whether an item is inside a list using in.

For example:

products = ["Bread", "Milk", "Sugar"]

print("Milk" in products)

This gives:

True

I can also use it in a condition:

if "Milk" in products:

print("Milk is available")

This made a lot of sense to me when I started thinking about things like inventory.

Finding the length

len() tells me how many items are in a list.

products = ["Bread", "Milk", "Sugar", "Soap"]

print(len(products))

The result is:

This is useful when I need to know how many items I'm working with.

Slicing

Slicing lets me take part of a list instead of the whole thing.

For example:

products = ["Bread", "Milk", "Sugar", "Soap", "Salt"]

print(products[1:4])

The result is:

["Milk", "Sugar", "Soap"]

The important thing I learnt here is that the starting index is included, but the ending index is not.

I can also get the first three items:

print(products[:3])

Or everything from index 2 onward:

print(products[2:])

Sorting a list

I can sort numbers:

prices = [500, 200, 800, 300]

prices.sort()

Now I get:

[200, 300, 500, 800]

For descending order:

prices.sort(reverse=True)

I can also sort text alphabetically:

names = ["Brian", "Amina", "Feddy"]

names.sort()

The result is:

["Amina", "Brian", "Feddy"]

sorted() vs sort()

This was something I had to pay attention to.

sort() changes the original list.

sorted() creates a new sorted result.

For example:

prices = [500, 200, 800, 300]

new_prices = sorted(prices)

Now new_prices contains the sorted values, while prices remains unchanged.

Reversing a list

I can reverse a list using reverse().

products = ["Bread", "Milk", "Sugar", "Soap"]

products.reverse()

Now the order becomes:

["Soap", "Sugar", "Milk", "Bread"]

This does not sort the list. It simply reverses the current order.

Looping through a list

Lists and loops go together really well.

For example:

products = ["Bread", "Milk", "Sugar"]

for product in products:

print(product)

Python takes each item from the list one at a time.

This became one of the most useful things for me because I could perform an action on every item without writing the same code repeatedly.

enumerate()

Sometimes I want both the item and its position.

That's where enumerate() helps.

products = ["Bread", "Milk", "Sugar"]

for number, product in enumerate(products, start=1):

print(number, product)

The result is:

1 Bread

2 Milk

3 Sugar

This is useful when displaying numbered lists.

List concatenation

I can combine two lists using +.

fruits = ["Apple", "Mango"]

vegetables = ["Carrot", "Spinach"]

items = fruits + vegetables

The result is:

["Apple", "Mango", "Carrot", "Spinach"]

Repeating a list

I can also repeat a list using *.

For example:

numbers = [1, 2]

print(numbers * 3)

The result is:

[1, 2, 1, 2, 1, 2]

I don't use this as often, but it's useful to know.

Finding an item's position
If I know the value but want to find its position, I can use index().

For example:

products = ["Bread", "Milk", "Sugar"]

print(products.index("Sugar"))

The result is:

Counting items
count() tells me how many times a value appears.

For example:

numbers = [1, 2, 2, 3, 2, 4]

print(numbers.count(2))

The result is:

This is useful when duplicate values matter.

List comprehensions

Once I became comfortable with normal loops, I came across list comprehensions.

They are a shorter way of creating lists.

For example, I can create a list of squares:

numbers = [1, 2, 3, 4, 5]

squares = [number ** 2 for number in numbers]

The result is:

[1, 4, 9, 16, 25]

I wouldn't recommend trying to learn comprehensions before understanding normal loops. For me, they made more sense after I understood what the longer version was doing.

Filtering with a list comprehension

I can also use a condition.

For example, suppose I only want numbers greater than 10:

numbers = [5, 12, 8, 20, 15]

large_numbers = [number for number in numbers if number > 10]

The result is:

[12, 20, 15]

This became useful when I wanted to create a new list from existing data based on a condition.

Nested lists

A list can also contain other lists.

For example:

students = [["Feddy", 20], ["Amina", 21], ["Brian", 19]]

I can access Brian's name with:

print(students[2][0])

The result is:

Brian

Nested lists are possible, although when the data becomes more detailed, I often find dictionaries easier to work with.

Copying lists
One thing that can be confusing is copying a list.

For example:

products = ["Bread", "Milk", "Sugar"]

new_products = products

Both variables now refer to the same list.

So changing one can affect the other.

A safer way to create a separate copy is:

new_products = products.copy()

Now I can change new_products without changing the original products.

A practical inventory example

This is where lists started feeling like something I could actually use in a program.

Imagine I have a simple shop inventory:

products = ["Bread", "Milk", "Sugar", "Soap"]

I can check whether something is available:

if "Milk" in products:

print("Milk is available")

I can add a new product:

products.append("Salt")

I can remove a product:

products.remove("Soap")

And display everything:

for product in products:

print(product)

Now I'm not just learning list methods individually. I'm using them together to solve an actual problem.

What I understood about lists

The biggest thing I learnt about lists is that they are more than just a place to store multiple values.

I can add items, remove them, change them, sort them, search through them, loop through them, and even create new lists from existing ones.

The way I now think about a list is simple:

If I have a collection of items that I want to keep together and possibly change later, a list is usually a good choice.

Final thoughts

Lists were one of the first Python concepts that made me feel like I could actually build something useful.

At first I only knew how to create a list and access an item.

Then I learnt how to modify lists, loop through them, search them, sort them, and eventually use list comprehensions.

What made the difference was not memorising every method.

It was actually using lists in small programs and seeing why each feature exists.

That's when lists stopped being just another Python topic and became something I naturally reach for when I need to store a collection of things.

Python Functions: How I Learned to Reuse My Code

Feddy Mwanjumwa — Sun, 04 Oct 2026 12:31:40 +0000

When I started writing more Python, I noticed I was repeating the same pieces of code.

At first, I didn't think much of it. But after a while, I realised there had to be a better way.

That's when functions started making sense to me.

A function lets me write a piece of code once and use it whenever I need it.

Defining a function
I create a function using def.

For example:

def greet():

print("Hello, welcome!")

Nothing happens yet because I have only defined the function.

To actually run it, I call it:

greet()

This was one of the first things I understood about functions: defining a function and calling a function are two different things.

Parameters and arguments

Functions become more useful when I can give them information.

For example:

def greet(name):

print(f"Hello, {name}!")

Now I can pass a name:

greet("Feddy")

The result is:

Hello, Feddy!

The name inside the function is the parameter, while "Feddy" is the argument I pass to it.

That distinction took me a little practice to remember.

Multiple parameters

I can also pass more than one value.

For example, I can calculate the total cost of a product:

def calculate_total(price, quantity):

total = price * quantity

print(total)

Then:

calculate_total(500, 3)

The result is:

1500

This is much better than writing the same calculation every time I need it.

Return values

This was another important part for me.

A function can return a value instead of just printing it.

For example:

def calculate_total(price, quantity):

return price * quantity

Now I can store the result:

total = calculate_total(500, 3)

print(total)

The result is:

1500

The difference between print() and return became much clearer to me here.

print() displays something.

return sends a value back so I can use it somewhere else.

Scope

Scope is basically about where a variable can be accessed.

For example:

name = "Feddy"

def greet():

name = "Amina"

print(name)

greet()

print(name)

Inside the function, the result is:

Amina

Outside the function, the result is:

Feddy

The name created inside the function is local to that function.

Understanding this helped me avoid accidentally changing or depending on variables in the wrong place.

A practical example

One simple example I used was calculating a net salary.

Suppose someone's salary is KSh 85,000 and their deductions are KSh 4,500.

I can create:

def calculate_net_salary(salary, deductions):

return salary - deductions

Then:

net_salary = calculate_net_salary(85000, 4500)

print(f"Net salary: KSh {net_salary}")

The result is:

Net salary: KSh 80500

Now I can use the same function for different employees without rewriting the calculation.

Why functions became useful to me

Before functions, I was thinking:

"I need to write this calculation again."

After learning functions, I started thinking:

"I've already written this once. I'll just call the function."

That small change made my code much cleaner.

What I understood

The way I now think about functions is pretty simple:

def → create the function

Parameters → information the function expects

Arguments → values I actually pass

return → send a result back

Scope → where variables can be accessed

Once these pieces made sense, functions stopped feeling complicated.

Final thoughts

Functions were one of the first things that made me feel like I was actually organising my code rather than just writing lines of Python.

They helped me avoid repetition, break bigger programs into smaller parts, and reuse code whenever I needed it.

For me, the biggest lesson was simple: write it once, then reuse it.

Python Loops: How I Learned to Repeat Tasks Without Repeating Code

Feddy Mwanjumwa — Sun, 04 Oct 2026 12:21:47 +0000

One of the first things I noticed when writing Python programs was that I sometimes wanted to do the same thing several times.

I could write the same line of code again and again, but that obviously wasn't a good way to program.

That's where loops came in.

The idea is simple, tell Python to repeat something for me.

for loops

I use a for loop when I want to go through a collection of items or repeat something a specific number of times.

For example, suppose I have some products:

Instead of writing four separate print() statements, Python goes through the list for me.

That was one of the first things that made loops click.

Using range()

I can also use range() when I want to repeat something a certain number of times.

For example:

This prints:

So range(1, 6) gives me numbers starting from 1, but stops before 6.

while loops

A while loop works a little differently.

It keeps running as long as a condition is true.

For example, I can keep asking for a PIN until the correct one is entered:

The loop keeps asking until the condition becomes false.

This helped me understand that while is useful when I don't necessarily know how many times something needs to repeat.

break

Sometimes I want to stop a loop completely.

That's what break does.

For example:

The loop stops when it reaches 6.

So even though the loop was supposed to go up to 10, break tells Python:

"Stop here."

continue

continue is different from break.

Instead of stopping the whole loop, it skips the current iteration and moves to the next one.

For example:

The output is:

The number 3 is skipped, but the loop continues.

That's the difference I had to remember:

break → stop the loop

continue → skip this round

enumerate()

I found enumerate() useful when I wanted both the item and its position in a list.

For example:

The result is:

1 Bread

2 Milk

3 Sugar

Without enumerate(), I would have to create and manage the counter myself.

A practical example

I can put some of these ideas together in a small shopping program.

Suppose I have a list of products and want to display them with numbers:

products = ["Bread", "Milk", "Sugar", "Soap"]

for number, product in enumerate(products, start=1):

print(f"{number}. {product}")

Now Python handles the numbering for me.

This is much cleaner than manually writing:

print("1. Bread")

print("2. Milk")

print("3. Sugar")

print("4. Soap")

What I understood

The main thing that finally made loops make sense to me was thinking about the question:

"Do I need to repeat something?"

If I want to go through items in a list, I can use a for loop.

If I want something to keep running while a condition is true, I can use a while loop.

If I want to stop the loop, I use break.

If I want to skip one iteration, I use continue.

And if I need the position of each item, enumerate() makes it easier.

Final thoughts

Loops seemed confusing at first because there was a lot of new syntax.

But once I saw that their main purpose is simply to avoid repeating the same code manually, they became much easier.

Instead of telling Python the same thing ten times, I can write it once and let the loop handle the repetition.

Python Operators and Conditionals: How I Learned to Make Decisions

Feddy Mwanjumwa — Sun, 04 Oct 2026 11:41:19 +0000

After learning variables and basic Python syntax, I wanted my programs to actually make decisions.

For example, I didn't want Python to just calculate a total. I wanted it to decide whether a customer qualified for free delivery.

That's when operators and conditionals started making sense to me.

Arithmetic operators

Arithmetic operators are used for calculations.

The basic ones are +, -, , /, %, and *.

For example, I can calculate the total cost of a shopping order:

The result is 1000.

The % operator gives the remainder:

print(10 % 3)

The result is 1.

This became useful when I wanted to check things like whether a number was even or odd.

Comparison operators

Comparison operators allow me to compare values.

For example:

age = 20

print(age >= 18)

The result is True.

Python can compare values using operators such as ==, !=, >, <, >=, and <=.

At first, I confused = with ==.

I eventually understood that = assigns a value, while == checks whether two values are equal.

For example:

age = 20

age == 20

The first line stores 20 in age.

The second checks whether age is equal to 20.

Logical operators

Sometimes one condition isn't enough.

That's where and, or, and not come in.

For example, suppose I want to check whether someone can access a system:

Both conditions have to be true for access to be granted.

That's how I started understanding and both conditions must be satisfied.

if, elif and else

This is where things became more interesting for me.

if lets Python check a condition.

elif gives it another condition to check.

else handles everything that doesn't match the earlier conditions.

For example, I can use a student's score:

Since the score is 76, Python prints Pass.

The important thing I understood here is that Python checks the conditions from top to bottom.

A practical example

One of the examples that helped me understand conditionals was a simple shopping system.

I can give customers free delivery when they spend KSh 2,000 or more:

Since the total is 2,500, the customer gets free delivery.

But if:

total = 1500

the result becomes:

Delivery fee: KSh 200

This made conditionals feel much more useful because I could see how they could be used in an actual program.

Combining conditions

I can also create more specific rules.

For example, suppose a customer gets a discount if they spend at least KSh 5,000 and they are a member:

Now Python is checking two things before making a decision.

What I understood

The biggest thing I learnt was that operators are what help Python compare or calculate things, while conditionals use those results to make decisions.

For example:

total = price * quantity

This calculates something.

Then:

if total >= 2000:

uses that result to make a decision.

That connection is what finally made conditionals click for me.

Final thoughts

At first, operators looked like a bunch of symbols I just needed to memorise.

Then conditionals looked like another syntax rule to learn.

But once I started using them together in practical examples, I realised they are really just tools for telling Python:

"Calculate this."

"Compare that."

"If this happens, do this."

"Otherwise, do something else."

That was the point where Python started feeling less like memorising code and more like actually programming.

Python Basics: What I Understood When I Started Learning Python

Feddy Mwanjumwa — Sun, 04 Oct 2026 11:23:51 +0000

When I started learning Python, I had almost no idea what I was looking at.

I would see things like variables, strings, integers, and input() and wonder why there were so many names for what seemed like simple things.

The more I practiced, the more I realised that the basics are actually pretty straightforward. The important part was understanding what each thing was doing rather than just memorising the syntax.

Here are some of the basics that finally started making sense to me.

Variables
The first thing I learnt was that variables are basically names used to store values.

For example:

Now I don't have to write those values again every time. I can just use the variable:

The way I started thinking about variables was like labels attached to information. Once that made sense, they became much easier.

Data types

Then I came across data types.

Python has different types of values, and the type matters because Python needs to know what kind of data it is working with.

For example:

name = "Feddy"

This is a string because it is text.

age = 20

This is an integer because it is a whole number.

price = 1500.50

This is a float because it has decimal places.

is_student = True

This is a boolean because it is either True or False.

I can also check the type of a value using:

print(type(age))

Strings

A string is simply text.

For example:

name = "Feddy Mwanjumwa"

I can combine strings:

This gives:

Feddy Mwanjumwa

I started noticing that strings are everywhere, especially when working with names, messages, and other text.

Integers and floats

Integers are whole numbers:

age = 20

quantity = 5

Floats are numbers with decimal values:

price = 250.50

For example:

The result is:

751.5

This made more sense once I started using numbers for realistic things like prices and quantities.

Input
One of the things that made Python feel more interactive was input().

Instead of giving the program all the information myself, I can allow the user to enter it.

For example:

name = input("Enter your name: ")

print("Hello", name)

Now the program waits for the user to enter a name.

I can also ask for a number:

age = int(input("Enter your age: "))

The int() is important here because input() gives me text by default.

That was something I had to learn through practice.

Output

For output, Python mainly uses print().

For example:

I can also use an f-string:

print(f"My name is {name} and I am {age} years old.")

I found f-strings much cleaner once I got used to them.

Basic Python syntax

Python syntax is basically the way Python expects me to write my instructions.

For example:

Python reads these instructions from top to bottom.

One thing I quickly noticed is that Python uses indentation to show blocks of code.

For example:

if age >= 18:

print("Adult")

The indentation is part of the syntax. It isn't just for making the code look neat.

A small practical example

Once I understood the basics, I could put them together into something more realistic.

For example, a simple shopping calculation:

The result would be:

This is where the different concepts started connecting for me.

I had a string for the product, numbers for the price and quantity, a variable storing the calculation, and print() displaying the result.

What I understood from the basics

The biggest thing I learnt is that Python isn't really about memorising a huge number of commands.

I started looking at it more like giving the computer instructions.

Store something in a variable.

name = "Feddy"

Ask the user for information.

age = int(input("Enter your age: "))

Do something with the information.

next_year = age + 1

Show the result.

print(next_year)

Once I started seeing Python this way, the basics became much less intimidating.

Final thoughts

These concepts may seem very basic now, but they were important for me because everything else in Python builds on them.

Variables, data types, input, output, and syntax were the first pieces I needed to understand before moving on to things like conditionals, loops, functions, and data structures.