DEV Community: Sylvia Ndili

An Introduction to Object-Oriented Programming (OOP) in Python

Sylvia Ndili — Sun, 11 Oct 2026 15:10:11 +0000

As I continue navigating Python and data science, one concept that has helped me understand how to structure programs better is Object-Oriented Programming (OOP).

At first, working with variables, lists, dictionaries, loops and functions was enough for the small programs I was writing. However, as programs become more complex, keeping related data and functions organized becomes increasingly important.

That is where Object-Oriented Programming comes in. In this article, I will walk through the fundamentals of OOP in Python, including classes, objects, attributes, methods and the four pillars of OOP.

1. What is Object-Oriented Programming?

OOP is a programming approach that organizes code around objects. An object combines related data and behavior into one unit.

For example, think about a car. A car has attributes such as:

Brand
Color
Model
Maximum speed

It also has behaviors, such as:

Starting
Stopping
Accelerating

Instead of storing all these details in separate variables and writing unrelated functions, OOP allows us to group them together in a single object.

Why OOP?

There are three main benefits I found useful when learning this concept.

1. Organization

Related data and functions stay together, making code easier to understand and navigate.

2. Reusability

Once you define a class, you can create multiple objects from it without rewriting the same structure.

3. Maintainability

When you need to change how a particular behavior works, you can usually make that change in one place.

2. Classes and Objects

Before writing our first OOP program, we need to understand two fundamental concepts: classes and objects.

What is a class?

A class is a blueprint or template used to create objects. It defines the attributes and methods that objects of that class can have.

For example, a class called Car can describe the common characteristics and behaviors of different cars.

In Python, we define a class using the class keyword.

class Car:
    pass

The pass keyword allows us to define an empty class temporarily.

What is an object?

An object is an instance of a class. If Car is the blueprint, individual cars created from that blueprint are objects.

For example, a BMW X5 and a Volvo XC60 can both be objects created from the same Car class, even though they have different attributes.

Let's see how this works.

class Car:
    def __init__(self, brand, color, model):
        self.brand = brand
        self.color = color
        self.model = model

car1 = Car("BMW", "Blue", "X5")
car2 = Car("Volvo", "Grey", "XC60")

print(car1.brand)
print(car2.brand)

Output:

BMW
Volvo

Both objects come from the same class, but each stores its own information.

Understanding `init()`

The __init__() method runs automatically when a new object is created. We commonly use it to initialize an object's attributes.

For example:

class Dog:
    def __init__(self, name, breed):
        self.name = name
        self.breed = breed

dog1 = Dog("Bosco", "African Shepherd")
dog2 = Dog("Max", "German Shepherd")

print(dog1.name)
print(dog2.name)

Output:

Bosco
Max

When we create dog1, Python calls __init__() and assigns the supplied values to that object. The same happens when we create dog2. You may hear __init__() described as a constructor. More precisely, Python uses __new__() to create an instance, while __init__() initializes it.

What is `self`?

The self parameter refers to the particular object whose method is being called. In a regular instance method, self is the first parameter. Python supplies the instance automatically when you call the method.

For example:

class Dog:
    def __init__(self, name):
        self.name = name

    def bark(self):
        print(f"{self.name} says: Woof!")

dog1 = Dog("Bosco")
dog2 = Dog("Max")

dog1.bark()
dog2.bark()

Output:

Bosco says: Woof!
Max says: Woof!

The method is the same, but self.name refers to the name belonging to whichever dog is calling it.

3. Attributes and Methods

Attributes

Attributes are variables associated with a class or an object. In Python, we commonly distinguish between instance attributes and class attributes.

Instance attributes

These belong to individual objects. They are often initialized inside __init__() using self.

class Dog:
    def __init__(self, name, breed):
        self.name = name
        self.breed = breed

Here, name and breed are instance attributes. Each dog can have its own values.

Class attributes

These are defined directly inside the class body, outside instance methods. They are shared through the class unless an instance provides its own attribute with the same name.

class Dog:
    species = "Canis familiaris"

    def __init__(self, name, breed):
        self.name = name
        self.breed = breed

dog1 = Dog("Bosco", "African Shepherd")
dog2 = Dog("Max", "German Shepherd")

print(dog1.species)
print(dog2.species)

Output:

Canis familiaris
Canis familiaris

Both dogs share the same species classification, but their names and breeds differ.

Methods

Methods are functions defined inside a class. They describe the behaviors an object can perform.

Let's expand our Dog class.

class Dog:
    def __init__(self, name, breed):
        self.name = name
        self.breed = breed

    def bark(self):
        print(f"{self.name} says: Woof!")

    def play(self, minutes):
        print(f"{self.name} played for {minutes} minutes")

    def fact(self, top_speed):
        print(
            f"{self.name}, a {self.breed}, "
            f"can reach {top_speed} km/h."
        )

dog1 = Dog("Bosco", "African Shepherd")

dog1.bark()
dog1.play(30)
dog1.fact(72)

Output:

Bosco says: Woof!
Bosco played for 30 minutes
Bosco, a African Shepherd, can reach 72 km/h.

This example brings together the concepts covered so far. The class defines the structure, the object stores the individual dog's information and the methods define its behaviors.

4. Python Naming Conventions

Consistent naming makes code easier to read, especially when working on larger projects.

Element	Convention	Example
Variables	`snake_case`	`owner_name`
Functions	`snake_case`	`check_balance()`
Classes	`PascalCase`	`MpesaAccount`
Constants	`UPPER_SNAKE_CASE`	`API_KEY`

Python does not enforce every naming convention, but following these conventions helps keep code readable and consistent.

5. The Four Pillars of OOP

The four commonly recognized pillars of Object-Oriented Programming are:

Encapsulation
Inheritance
Polymorphism
Abstraction

Let's explore each one.

5.1 Encapsulation

Encapsulation means grouping data and the methods that operate on that data inside a class, while controlling how that data is accessed or modified. Think about a bank account. You should not be able to change your account balance arbitrarily without following the bank's rules. Instead, you interact with the account through operations such as depositing, withdrawing and checking your balance.

Python uses naming conventions and mechanisms to support encapsulation:

name: Public attribute, intended for general access.
_name: Non-public attribute by convention. It signals that the attribute should generally be treated as an internal implementation detail.
__name: An attribute using double-leading underscores. Python applies name mangling to make accidental access from outside the class less likely.

These conventions do not provide absolute security, but they help structure code.

Example: A bank account

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.__balance = balance

    def deposit(self, amount):
        if amount <= 0:
            print("Deposit amount must be positive.")
            return

        self.__balance += amount
        print(f"Deposited KES {amount}.")

    def withdraw(self, amount):
        if amount <= 0:
            print("Withdrawal amount must be positive.")
            return

        if amount > self.__balance:
            print("Insufficient funds.")
            return

        self.__balance -= amount
        print(f"Withdrew KES {amount}.")

    def check_balance(self):
        return self.__balance


account = BankAccount("Sylvia", 3000)

account.deposit(100)
account.withdraw(1000)

print(account.check_balance())

Output:

Deposited KES 100.
Withdrew KES 1000.
2100

You notice that we use methods to modify the balance instead of directly changing __balance. These methods also validate transactions before updating the account. This is a practical example of encapsulation: the class manages its internal state through controlled operations.

Another example: An M-Pesa account

The same principle applies to a mobile money account.

class MpesaAccount:
    def __init__(self, owner_name, phone_number, balance=0):
        self.owner_name = owner_name
        self.phone_number = phone_number
        self.__balance = balance

    def deposit(self, amount):
        if amount < 50:
            print("Deposit must be at least KES 50.")
            return

        self.__balance += amount
        print(f"New balance: KES {self.__balance}")

    def check_balance(self):
        return self.__balance


account = MpesaAccount("Sylvia", "0712345678")

account.deposit(150)
print(account.check_balance())

Output:

New balance: KES 150
150

This is a simplified learning example to demonstrate how an object can manage its own data.

5.2 Inheritance

Inheritance allows a new class to reuse attributes and methods from an existing class. The existing class is called the parent class or superclass, while the new class is called the child class or subclass. Inheritance is useful when several types of objects share common characteristics but also have their own specialized behaviors.

For example, cows and chickens are both farm animals. Both have names, ages and weights and both can eat. However, cows produce milk while chickens lay eggs. Instead of defining everything separately, we can create a shared parent class.

Example: Farm animals

class FarmAnimal:
    def __init__(self, name, age, weight):
        self.name = name
        self.age = age
        self.weight = weight

    def eat(self):
        print(f"{self.name} is eating.")

    def display_details(self):
        print(f"Name: {self.name}")
        print(f"Age: {self.age}")
        print(f"Weight: {self.weight} kg")


class Cow(FarmAnimal):
    def __init__(self, name, age, weight, milk_per_day):
        super().__init__(name, age, weight)
        self.milk_per_day = milk_per_day

    def produce_milk(self):
        print(
            f"{self.name} produces "
            f"{self.milk_per_day} litres of milk per day."
        )


class Chicken(FarmAnimal):
    def __init__(self, name, age, weight, eggs_per_week):
        super().__init__(name, age, weight)
        self.eggs_per_week = eggs_per_week

    def produce_eggs(self):
        print(
            f"{self.name} produces "
            f"{self.eggs_per_week} eggs per week."
        )


cow = Cow("Tuimet", 3, 250, 25)
chicken = Chicken("Ingokho", 2, 2, 10)

cow.display_details()
cow.eat()
cow.produce_milk()

chicken.display_details()
chicken.eat()
chicken.produce_eggs()

Here, Cow and Chicken inherit eat() and display_details() from FarmAnimal, so we do not need to rewrite those methods.

What does `super()` do?

The expression super() allows a child class to access methods from its parent class.

In the example:

super().__init__(name, age, weight)

we call the parent's initializer to set up the attributes that cows and chickens have in common. Each child class then adds its own specialized attribute. This reduces duplication and makes the code easier to maintain.

5.3 Polymorphism

Polymorphism means that different objects can respond to the same method call in different ways. For example, a delivery service may use vans and motorbikes. Both perform deliveries, but their delivery statuses or costs may differ.

To model that idea;

class Delivery:
    def __init__(self, customer_name, destination, distance):
        self.customer_name = customer_name
        self.destination = destination
        self.distance = distance

    def delivery_status(self):
        print("Delivery is processing.")

class Van(Delivery):
    def delivery_status(self):
        print("The van delivery is on its way.")

class Motorbike(Delivery):
    def delivery_status(self):
        print("The motorbike delivery is complete.")


van = Van("Wilson", "Mombasa", 400)
motorbike = Motorbike("Emmanuel", "Upper Hill", 2)

van.delivery_status()
motorbike.delivery_status()

Output:

The van delivery is on its way.
The motorbike delivery is complete.

Both objects use the same method name, delivery_status(), but each class implements it differently. This is an example of method overriding, where a child class provides its own implementation of a method inherited from its parent. Polymorphism makes it possible to write code that works with different object types without requiring every object to behave identically.

5.4 Abstraction

Abstraction means hiding unnecessary implementation details and exposing only the operations that a user needs. Consider using an ATM. You can withdraw money, deposit money or check your balance without knowing all the internal processes involved in verifying your account and updating the bank's records. The ATM provides a simple interface while hiding much of the complexity behind it.

In programming, abstraction helps us focus on what an object can do rather than every detail of how it does it.

For example, when we use our bank account class, we can write:

account.deposit(500)
account.withdraw(200)
account.check_balance()

We do not need to repeat the balance calculation every time we make a transaction. The methods provide a simple interface for those operations.

Python also supports formal abstraction through abstract classes and the abc module. That is a useful next step once you are comfortable with classes, inheritance and methods.

6. Putting the Concepts Together

Let's look at a practical example inspired by Kenya's public transport system.

A matatu has information such as its registration number, route, passenger capacity, fare and number of passengers currently on board. It also performs actions such as boarding passengers and calculating potential fare revenue.

We can represent those attributes and behaviors in a class.

class Matatu:
    def __init__(
        self,
        registration_number,
        route,
        capacity,
        fare,
        passengers=0
    ):
        self.registration_number = registration_number
        self.route = route
        self.capacity = capacity
        self.fare = fare
        self.passengers = passengers

    def board_passengers(self, number):
        if number <= 0:
            print("Enter a valid number of passengers.")
            return

        if self.passengers + number > self.capacity:
            available = self.capacity - self.passengers
            print(f"Only {available} seats are available.")
            return

        self.passengers += number
        print(f"{number} passengers have boarded.")

    def trip_income(self):
        income = self.passengers * self.fare
        return income

    def display_details(self):
        print(f"Registration: {self.registration_number}")
        print(f"Route: {self.route}")
        print(f"Passengers: {self.passengers}/{self.capacity}")


matatu = Matatu(
    "KDA 001A",
    "Nairobi-Thika",
    32,
    100
)

matatu.board_passengers(20)
matatu.display_details()

print(f"Expected fare revenue: KES {matatu.trip_income()}")

Output:

20 passengers have boarded.
Registration: KDA 001A
Route: Nairobi-Thika
Passengers: 20/32
Expected fare revenue: KES 2000

This example brings several OOP concepts together:

Class: Matatu defines the structure of a matatu object.
Object: matatu is an instance of that class.
Attributes: The registration number, route, capacity, fare and passenger count store the object's information.
Methods: board_passengers(), trip_income() and display_details() define what the object can do.
Encapsulation: The boarding method checks capacity before changing the passenger count.

We can create other matatu objects with different routes, fares and capacities without rewriting the class.

Conclusion

Learning Object-Oriented Programming has really helped me see how Python can be used to model real-world things and organize related data and behavior. The best way to understand these concepts is to practice building small programs. Start with a Car or Dog class, then move on to something more practical, such as a bank account, inventory manager or transport management system.

I am continuing to build my Python skills one concept at a time and OOP is an important step toward writing more structured, reusable and maintainable programs.

# Learning Python Data Structures and Algorithms Through Practical Examples

Sylvia Ndili — Sun, 11 Oct 2026 09:16:04 +0000

When learning Python, understanding the syntax is just part of the process. You also need to know how to organise data, retrieve it, update it and validate user input. These are some of the foundations of data structures and algorithms.

In this article, we are going to explore Python's built-in data structures, string manipulation and file-related concepts through practical examples. At the end, I also applied what I learned in a small capstone project: A bundle purchase simulator inspired by the *544# menu.

Here are the key concepts I learned.

1. Lists: Working with Collections of Data

Lists are useful when you need to store multiple items in one variable. They can hold strings, numbers, Boolean values or even other lists.

students = ["Bob", "Faith", "Brian", "Ken"]
scores = [78, 85, 67, 34]

Python uses zero-based indexing, meaning the first item is at index 0. Negative indexing lets you access elements from the end of a list.

print(scores[0])   # 78
print(scores[-1])  # 34

Slicing allows you to retrieve a section of a list. The stop index is excluded.

print(scores[1:3])  # [85, 67]
print(scores[::-1])  # Reverses the list

We also explored methods for modifying lists, including append(), insert(), extend(), remove(), and pop(). Other useful operations include sorting, counting occurrences, finding an item's position and calculating the length of a list.

One important distinction is that sort() changes the original list, while sorted() returns a new sorted list.

Lists are useful whenever data needs to be stored in an ordered, changeable collection.

2. Tuples: Storing Data That Should Not Change

Tuples look similar to lists, but they are immutable. Once created, their elements cannot be reassigned.

coordinates = (1.2864, 36.8172)

latitude, longitude = coordinates

print(latitude)
print(longitude)

The example also demonstrates tuple unpacking, which assigns tuple elements to separate variables in one statement. Tuples are useful for values that belong together and should remain unchanged, such as coordinates or fixed sets of related values.

A tuple containing just one item needs a trailing comma:

single_item = (20,)

Without the comma, (20) is simply an integer expression in parentheses.

3. Dictionaries: Organising Data Using Keys and Values

Dictionaries store information as key-value pairs. They are particularly useful when each piece of information has a label.

student = {
    "name": "Amina Wanjiku",
    "age": 24,
    "track": "Data Science",
    "scores": [75, 85, 91]
}

We can access information using a key or the get() method.

print(student["name"])
print(student.get("city", "Not found"))

The main difference is that accessing a missing key with square brackets raises a KeyError, while get() returns None or a specified default value.

Dictionaries can also be updated, extended with new keys and have entries removed using del or pop().

To process dictionary contents, we can iterate over keys, values or both:

for key, value in student.items():
    print(f"{key}: {value}")

This structure is useful for representing records such as students, employees, products and transactions.

4. Sets: Handling Unique Values

Sets store unique elements. If a value appears multiple times, only one instance remains.

cities = {"Nairobi", "Mombasa", "Nairobi", "Kisumu"}
print(cities)

Sets are useful for removing duplicates and comparing collections of data.

The are four important set operations:

Union (|) combines elements from both sets.
Intersection (&) returns elements shared by both sets.
Difference (-) returns elements found in one set but not the other.
Symmetric difference (^) returns elements found in either set, but not both.

For example, if two datasets contain customer IDs, intersection can help identify IDs that appear in both datasets.

Unlike lists, sets do not guarantee a particular iteration order, so they are not suitable when positional order matters.

5. Strings: Cleaning, Searching and Validating Text

Strings are sequences of characters. We can access individual characters using indexing and extract sections using slicing, much like lists.

However, strings are immutable. Instead of changing a character directly, we create a new string.

city = "Nairobi"
updated_city = "K" + city[1:]
print(updated_city)  # Karobi

There are several string methods that are especially useful when handling user input and real-world data.

Method	Purpose
`lower()` and `upper()`	Standardise letter case
`strip()`	Remove surrounding whitespace
`split()`	Break a string into a list
`join()`	Combine strings using a separator
`find()`	Locate a substring, returning `-1` if absent
`replace()`	Replace part of a string
`count()`	Count occurrences
`startswith()` and `endswith()`	Check prefixes and suffixes
`isdigit()`	Check whether a string contains digits

For example, consider a record containing unnecessary spaces:

dirty = "  Moses, 23, Nairobi, Data Science  "
parts = dirty.split(",")
clean_parts = [item.strip() for item in parts]
print(clean_parts)

Here, split() separates the fields and strip() cleans each field. This is a simple example of data cleaning before analysis.

You can also use validation methods with loops to keep requesting input until the user entered an acceptable value. For example, isdigit() can help validate a whole-number input before converting it to an integer. One limitation is that isdigit() does not accept every valid numeric format. It rejects values such as negative numbers and decimals, so validation should match the type of input expected.

6. Bringing the Concepts Together: Bundle Purchase Simulator

The capstone project was a command-line bundle purchase simulator inspired by the *544# menu. It allows a user to browse data, SMS and minutes bundles, confirm a purchase, check their airtime balance or exit the application.

Here is the complete implementation of the bundle purchase simulator.

# =========================================================
# CAPSTONE PROJECT: Bundle Purchase Simulator (*544#)
# =========================================================

bundles = {
    "Data": [
        {"name": "50MB - Daily",   "price": 5,   "validity": "24 hours"},
        {"name": "500MB - Weekly", "price": 50,  "validity": "7 days"},
        {"name": "2GB - Monthly",  "price": 200, "validity": "30 days"},
    ],
    "SMS": [
        {"name": "20 SMS - Daily",   "price": 5,  "validity": "24 hours"},
        {"name": "200 SMS - Weekly", "price": 20, "validity": "7 days"},
    ],
    "Minutes": [
        {"name": "10 Min - Daily",    "price": 10,  "validity": "24 hours"},
        {"name": "100 Min - Monthly", "price": 100, "validity": "30 days"},
    ],
}

balance = 200.00  # Starting airtime balance in Ksh


# Step 1: Main Menu
def main_menu():
    print("\n========================================")
    print("                *544#                   ")
    print("========================================")
    print("1. Buy Data Bundle")
    print("2. Buy SMS Bundle")
    print("3. Buy Minutes Bundle")
    print("4. Check Balance")
    print("5. Exit")
    print("========================================")
    choice = input("Enter choice (1-5): ").strip()
    return choice


# Step 2: Show Bundles Sub-menu
def show_bundles(category, bundle_list):
    print(f"\n--- {category.upper()} BUNDLES ---")
    for index, bundle in enumerate(bundle_list, start=1):
        name = bundle["name"]
        price = bundle["price"]
        validity = bundle["validity"]
        print(f"{index}. {name:<16} | Ksh {price:<3} | Valid: {validity}")
    print("0. Back to main menu")


# Step 3: Buy Bundle Handler
def buy_bundle(category, bundle_list, balance):
    while True:
        show_bundles(category, bundle_list)
        choice_input = input("\nEnter choice: ").strip()

        # Validate digits input
        if not choice_input.isdigit():
            print("Invalid input! Please enter a valid number.")
            continue

        choice = int(choice_input)

        # Go back to main menu
        if choice == 0:
            break

        # Check range validity
        if 1 <= choice <= len(bundle_list):
            selected_bundle = bundle_list[choice - 1]
            name = selected_bundle["name"]
            price = selected_bundle["price"]

            confirm = input(f"Confirm purchase of {name} for Ksh {price}? (y/n): ").strip().lower()

            if confirm == 'y':
                if balance >= price:
                    balance -= price
                    print(f"Purchase successful! New balance: Ksh {balance:.2f}")
                else:
                    print("Insufficient balance. Please top up.")
            else:
                print("Transaction cancelled.")
        else:
            print(f"Invalid option! Please enter a number between 0 and {len(bundle_list)}.")

    return balance


# Step 4: Check Balance
def check_balance(balance):
    print(f"\nYour current balance is Ksh {balance:.2f}")


# Step 5: Main Program Loop
def main():
    global balance

    while True:
        user_choice = main_menu()

        if user_choice == '1':
            balance = buy_bundle("Data", bundles["Data"], balance)
        elif user_choice == '2':
            balance = buy_bundle("SMS", bundles["SMS"], balance)
        elif user_choice == '3':
            balance = buy_bundle("Minutes", bundles["Minutes"], balance)
        elif user_choice == '4':
            check_balance(balance)
        elif user_choice == '5':
            print("\nThank you for using *544#. Goodbye!")
            break
        else:
            print("\nInvalid choice! Please select an option between 1 and 5.")

# Run the application
main()

The project brought together several concepts;

Data organisation: A dictionary stores the bundle categories, while lists hold the available bundles. Each bundle is represented by another dictionary containing its name, price and validity period.

Functions: Separate functions handle the main menu, display available bundles, process purchases and check the balance. This keeps the code organised and makes each function responsible for a specific task.

Loops and conditional statements: The main loop keeps the application running until the user chooses to exit. Conditional statements determine which menu option to execute.

Input validation: The program checks whether the user's selection contains digits and whether it falls within the available options. Invalid input prompts the user to try again instead of immediately ending the program.

Indexing: Menu selections start at 1, but Python lists start at index 0. Therefore, the selected bundle is retrieved using choice - 1.

Functions and return values: The purchase function receives the current balance, checks whether the user can afford the selected bundle and returns the updated balance.

The purchase logic is the most important part of the simulator:

if balance >= price:
    balance -= price
    print(f"Purchase successful! New balance: Ksh {balance:.2f}")
else:
    print("Insufficient balance. Please top up.")

The balance is deducted only when sufficient funds are available. The simulator also asks the user to confirm the purchase before processing it.

This is a simplified simulation rather than a real ussd integration, but it demonstrates how data structures, functions, loops and validation work together in a small application.

Final Thoughts

These exercises helped me understand that choosing the right data structure depends on what the program needs to do. Lists work well for ordered collections, tuples for immutable groups of values, dictionaries for labelled data and sets for unique elements and comparisons.

String manipulation and input validation are equally important because data is not always clean and users do not always enter what a program expects.

The bundle purchase simulator brought these ideas together in one practical project. It was a useful way to move beyond individual Python methods and see how different concepts can work together to solve a problem.

Write Code Once, Use It Forever: Python Functions Explained

Sylvia Ndili — Tue, 08 Sep 2026 15:43:51 +0000

After working with variables, conditions and loops, we can now cover functions.

The easiest way I got to understand functions was to think about repeated work. For instance, if I have to calculate VAT for three different prices, I could write the calculation three times. But if I need the same calculation in ten or twenty places, repeating the same code quickly becomes a hassle.

Essentially what I'm getting at is that, a function lets you write the logic once and reuse it.

The problem with repeating code

Without a function, calculating VAT for three items could look like this:

price1 = 1000
vat1 = price1 * 0.16
total1 = price1 + vat1

price2 = 2500
vat2 = price2 * 0.16
total2 = price2 + vat2

price3 = 750
vat3 = price3 * 0.16
total3 = price3 + vat3

The calculation itself isn't complicated. The problem is repetition. If the VAT rate changes from 16% to 14%, we would have to find every place where 0.16 was used and change it.

A function gives you one place to maintain that logic.

def add_vat(price, rate=0.16):
    vat = price * rate
    total = price + vat
    return total

Now it can be reused:

print(f"Item 1: Ksh {add_vat(1000)}")
print(f"Item 2: Ksh {add_vat(2500)}")
print(f"Item 3: Ksh {add_vat(750)}")

If the rate needs to change, we can change the default in the function instead of changing every calculation.

Defining and calling a function

A function starts with def.

For example:

def greet_student(name):
    print(f"Good evening, {name}! Welcome to Python Class.")

At this point, the fucntion has been defined. But it doesn't run just because we defined it. A function needs to be called as shown below:

greet_student("Moses")
greet_student("Sylvia")
greet_student("Amina")

The function runs each time you call it, using the name provided. This is one of the main benefits of functions: define the behaviour once, then reuse it with different values.

Functions can have more than one parameter

You can also pass several pieces of information:

def student_info(name, age, track):
    print(f"Name:  {name}")
    print(f"Age:   {age}")
    print(f"Track: {track}")
    print()

student_info("Sylvia", 26, "Data Science")
student_info("Moses", 20, "Data Engineering")

Here, name, age and track are parameters. When you call the function, you provide the actual values.

You can also use keyword arguments to make it clear which value belongs to which parameter:

describe_student(
    track="Data Science",
    name="Jane",
    city="Nyeri"
)

Printing isn't the same as returning

This is a really important distinctions.

Consider:

def add_print(a, b):
    print(a + b)

result = add_print(6, 5)
print(result)

The function prints 11, but result becomes None. That's because the function displayed the answer but didn't give the answer back to the program. If we want to use the result later, we need to use return.

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

Now you can do something with the result:

result = add_return(5, 10) * 2
print(result)

This gives: 30

Functions can contain decisions

A function can also contain conditional logics.

For example, create a function to determine a grade:

def get_grade(score):
    if score >= 80:
        return "A"
    elif score >= 70:
        return "B"
    elif score >= 60:
        return "C"
    elif score >= 50:
        return "D"
    else:
        return "F"

The grading logic doesn't need to be repeated every time there is a score. You can use it with a list by adding the below:

scores = [87, 74, 55, 91, 43]

for score in scores:
    grade = get_grade(score)
    print(f"Score: {score} Grade: {grade}")

This is where functions and loops work together. The loop goes through the scores, while the function handles the grading logic.

Returning multiple values

Functions can return more than one thing. In this case, create a function that analyses a list of scores:

def analyse_score(scores):
    total = sum(scores)
    average = round(total / len(scores), 1)
    highest = max(scores)
    lowest = min(scores)

    return total, average, highest, lowest

To receive all four results:

scores = [87, 74, 55, 91, 43, 78, 88]

tot, avg, hi, lo = analyse_score(scores)

print(f"Total:     {tot}")
print(f"Average:   {avg}")
print(f"Highest:   {hi}")
print(f"Lowest:    {lo}")

The variables: tot, avg, hi, lo, receive the four values returned by the function. This is useful when one piece of logic needs to calculate several results that are related.

Scope: where variables exist

Another important concept is scope. A variable created inside a function is local to that function.

def calculate_fee():
    fee = 4000
    print(f"This is fee inside function: {fee}")

calculate_fee()

This works because fee exists inside the function.

But: print(fee) outside the function would cause an error because that local variable doesn't exist there.

Another one is global variables:

school = "Nairobi Academy"

def show_school():
    print(f"School: {school}")

show_school()
print(f"Also here: {school}")

A function can read the global variable.

So, what happens when a local variable has the same name as a global one:

name = "Nairobi"

def show_local():
    name = "Mombasa"
    print(f"Inside function: {name}")

show_local()
print(f"Outside function: {name}")

The output is:

Inside function: Mombasa
Outside function: Nairobi

The two name variables are separate.

The `global` keyword

You can also use the global keyword when a function needed to change a global variable.

For example:

login_count = 0

def login(username):
    global login_count
    login_count += 1
    print(f"{username} logged in. Total logins is {login_count}")

login("Prudence")
login("John")
login("Daniel")
login("Martha")

The counter is shared between the function calls. In practice, I also learned why keeping data local or passing it into functions can often make code easier to manage. global is something to use when it is actually needed, not simply because it is available.

Default arguments

Functions can also have default values.

For example:

def send_message(recipient, message, channel="SMS"):
    print(f"Sending to {recipient} via {channel}: {message}.")

If you don't provide a channel: send_message("Brian", "Meeting at 3pm"), Python uses: SMS. But that can be overridden like this:

send_message(
    "Moses",
    "Your package has arrived",
    "WhatsApp"
)

Default arguments are useful when there is a value that will normally stay the same but sometimes needs to be changed.

`*args`

The parameter *args, allows a function to receive a variable number of arguments.

For example:

def class_summary(teacher, *scores):
    print(f"Teacher: {teacher}")
    print(f"Students: {len(scores)}")

    if scores:
        print(f"Average: {sum(scores) / len(scores)}")
        print(f"Highest: {max(scores)}")

    print()

Then you can call it with different numbers of scores:

class_summary("Mr. David", 78, 85, 91, 65, 72)
class_summary("Ms. Wanjiku", 88, 94, 76)

The teacher is a required parameter, while *scores collects however many scores we provide.

Putting Functions Together: Payslip Generator Program

To understand functions better, I did a simple program which is a Payslip generator. Instead of putting all the salary calculations into one large block of code, we separated the different deductions into their own functions.

def calculate_nhif(gross):
    if gross < 6000:
        return 150
    elif gross < 12000:
        return 400
    elif gross < 25000:
        return 750
    else:
        return 950

def calculate_nssf(gross):
    return min(round(gross * 0.06), 2160)

def calculate_paye(gross):
    if gross <= 24000:
        return 0

    return round((gross - 24000) * 0.16)

def print_payslip(name, gross):
    nhif = calculate_nhif(gross)
    nssf = calculate_nssf(gross)
    paye = calculate_paye(gross)

    deductions = nhif + nssf + paye
    net = gross - deductions

    width = 40

    print("=" * width)
    print(f"  PAYSLIP - {name}")
    print("=" * width)
    print(f"  Gross salary:  Ksh {gross:>9,}")
    print(f"  NHIF:          Ksh {nhif:>9,}")
    print(f"  NSSF:          Ksh {nssf:>9,}")
    print(f"  PAYE:          Ksh {paye:>9,}")
    print(f"  {'─' * 36}")
    print(f"  NET PAY:       Ksh {net:>9,}")
    print("=" * width)
    print()

#generate payslips for different employees simply by calling the function

print_payslip("Amina Wanjiku", 85000)
print_payslip("Brian Otieno", 28000)
print_payslip("Njeri Kamau", 22000)

Output:

This can probably be seen as a simple and clear example of the importance of functions. Each function has one responsibility. The overall flow becomes easier to follow:

Gross salary
     ↓
Calculate NHIF
     ↓
Calculate NSSF
     ↓
Calculate PAYE
     ↓
Add deductions
     ↓
Subtract from gross
     ↓
Print payslip

If I needed to change the logic for one deduction, I could work on that particular function instead of searching through one huge block of code.

Finally

The biggest thing I took from functions is that they help turn a program into smaller, reusable pieces. Instead of writing the same calculation repeatedly, we can put it inside a function and call it whenever we need it. You can also see that functions can work together with things we have already learned like: if/elif/else, loops, calculations, lists and f-strings.

The payslip generator brought that picure together really well. Each function handled a specific part of the problem, and the final function combined those pieces into something useful.

Loops In Python: Making Programs Repeat Without Repeating Yourself

Sylvia Ndili — Tue, 08 Sep 2026 15:01:05 +0000

By now, we've worked with variables, user input, calculations and conditional statements. The next step is getting Python to repeat things for us. This is where loops come in.

Imagine having to print a receipt for 100 items. Without a loop, we would have to write the same code 100 times. A loop tells Python, essentially, keep doing this until you're done.

There are two main loops:

for loops - this is useful when we know what we want to go through or roughly how many times we want to repeat something.
while loops - this is for when we want to keep going while a condition is true.

Starting with a `for` loop

A for loop goes through items one at a time.

For example:

names = ["Alice", "Brian", "Jane", "David"]

for x in names:
    print(f"Good morning, {x}")

print("For loop ended")

Instead of writing four separate print() statements, the loop handles all four names. The important part here is understanding what x actually represents. On the first round: x = "Alice" then Brian, then Jane, then David. So x is just a variable that temporarily holds the current item.

Here is the same idea with something more familiar:

fruits = ["Mango", "Banana", "Orange"]

for fruit in fruits:
    print(f"I like {fruit}")

The loop doesn't need to know how many fruits there are. It simply goes through the list until there are no more items.

Using `range()`

Sometimes you don't have a list, you just want Python to repeat something a certain number of times. That's where range() comes in. For example:

for i in range(5):
    print(i)

This prints:

One thing that stood out here is that 5 is not included. range(5) starts at 0 and stops before 5.

You can also choose where to start:

for n in range(1, 6):
    print(n)

Output will highlight numbers 1, 2, 3, 4, 5

And you can also specify a step:

for n in range(1, 11, 2):
    print(n)

Output being 1, 3, 5, 7, 9

Key note:

range(stop)
range(start, stop)
range(start, stop, step)

python

The stop value is always left out.

Loop Calculations

A loop becomes more useful when you actually do something with each value. For example, a multiplication table:

for i in range(1, 11):
    result = 5 * i
    print(f"5 x {i} = {result}")

You can also calculate squares:

for i in range(1, 6):
    result = i ** 2
    print(f"{i} squared is {result}")

The same pattern can be used for things like calculating totals.

The accumulator pattern

One example is adding transactions together.

transactions = [1500, 3000, 800, 12000, 450, 2700]
total = 0

for amount in transactions:
    total += amount
    print(f"Added Ksh {amount} Running total: Ksh {total}")

print()
print(f"Final Total: Ksh {total}")

The important thing here is: total = 0 comes before the loop. Then every time the loop runs, another transaction is added to the running total. So if the transactions are: 1500, 3000, 800 the total changes like this: 0 → 1500 → 4500 → 5300

An `if` inside a loop

Loops and conditionals can also work together. For example, you have a list of prices and want to classify each one:

prices = [250, 980, 120, 1500, 75]

for price in prices:
    if price < 500:
        show = "Affordable"
    else:
        show = "Expensive"

    print(f"Price is {price} - {show}")

Here, the loop handles each price, while the if/else decides what to say about that particular price.

`while` loops

A for loop works well when you're going through a collection or have a known range. But what if you don't know how many times something should happen? For example, you might want to keep asking for a password until the correct one is entered.

password = ""

while password != "pi2025":
    print("You entered the wrong password")
    password = input("Enter password: ")

print("Access Granted")

The loop keeps checking: password != "pi2025". As long as that condition is True(password is not equal to pi2025), it continues. Once the password is correct, the condition becomes False and the loop ends.

One important thing to note here is that something inside the loop needs to change the condition.

For example:

count = 1

while count < 5:
    print(f"Count: {count}")
    count = count + 1

Without: count = count + 1, count would remain 1 forever and the loop would never finish. That's an infinite loop.

`while True` and `break`

Another one is: while True:. This creates a loop that will keep running unless we explicitly stop it. For example:

total = 0

while True:
    entry = input("Enter Amount (or 'done' to finish): ")

    if entry == "done":
        break

    amount = int(entry)
    total += amount
    print(f"Running total: Ksh {total}")

print(f"Final total: {total}")

The important part is: break which immediately exits the loop. This becomes useful when the user controls when the program should stop.

A small practice task can be a mini program for an ATM PIN: where the loop stops once the correct PIN is entered.

`continue`

continue is quite different from breakin the sense that break says: Stop the entire loop and continue says: Skip this round and move to the next one.

For example:

for n in range(1, 11):
    if n % 2 == 0:
        continue

    print(n)

This skips even numbers, so only the odd numbers are printed.

`enumerate()`

Before enumerate(), if you wanted to number students, you would do something like:

students = ["Alice", "Brian", "Jane", "David"]

for i in range(len(students)):
    print(f"{i + 1}. {students[i]}")

enumerate() now comes in and makes our code cleaner:

for number, student in enumerate(students, start=1):
    print(f"{number}. {student}")

This gives us both:the position and the item

Here is a prcatical example for student scores:

scores = [78, 85, 45, 91, 35, 66, 38, 42]

for position, score in enumerate(scores, start=1):
    if score < 50:
        status = "FAIL"
    else:
        status = "PASS"

    print(f"Student {position}: {score} {status}")

This is much easier to read when you need both the item and its position.

Nested loops

Nested loops are really interesting. You can put one loop inside another loop.

For example:

weeks = ["Week 1", "Week 2"]
exercises = ["Push-ups", "Squats", "Plank"]

for week in weeks:
    print(week)

    for exercise in exercises:
        print(f"   {exercise}")

The inner loop runs for every item in the outer loop. This shows that loops don't have to work independently. One loop can control or depend on another.

Putting It All Together: Mini Bank Loop

With this exercise, you can bring several of these ideas into one program. The task is to build a small bank menu with a starting balance of Ksh 10,000. The menu needs to keep appearing until the user chooses Exit.

Here's the complete program:

balance = 10000

while True:
    print()
    print("=== Mini Bank ===")
    print("1. Check balance")
    print("2. Deposit")
    print("3. Withdraw")
    print("4. Exit")

    option = input("Choose option: ")

    if option == "1":
        print(f"Current balance: Ksh {balance}")

    elif option == "2":
        amount = float(input("Deposit amount: "))
        balance += amount
        print(f"Deposited Ksh {amount}. New balance: Ksh {balance}")

    elif option == "3":
        amount = float(input("Withdrawal amount: "))

        if amount > balance:
            print("Insufficient funds!")
        else:
            balance -= amount
            print(f"Withdrawn Ksh {amount}. New balance: Ksh {balance}")

    elif option == "4":
        print("Thank you. Goodbye!")
        break

    else:
        print("Invalid option. Try again.")

This small program uses quite a few things:

while True keeps the bank open

if/elif/else statements decide what should happen depending on the user's choice.

The balance is updated when money is deposited or withdrawn: balance += amount and: balance -= amount

There's also another if inside the withdrawal option to check whether the customer has enough money.

Finally, there is break which stops the program when the user chooses option 4.

Output:

To Sum Up

The main thing I took from this, is that loops are about automating repetition. A for loop is useful when going through items or a known range, while a while loop is useful when something should continue until a condition changes. break, continue, enumerate() and nested loops give more control over how those repetitions work. The Mini Bank project was a good example of why loops matter. Instead of writing a separate menu for every possible transaction, the program keeps running and responds to whatever the user chooses.

Learning Python? Here's how you can get started

Sylvia Ndili — Sun, 06 Sep 2026 10:01:45 +0000

When you start learning programming, one thing you quickly realise is that it looks more intimidating from the outside than it actually is. Before starting, I knew Python was popular. I knew it was used for things like data analysis, automation, websites and AI. But knowing what Python is used for and actually writing Python code are two different things.

The ultimate roadmap is to start with the basics instead of trying to jump into complicated projects.

The goal is simple:

Understand what Python actually is
Print things to the screen
Store information in variables
Understand basic data types
Get information from a user
Convert between data types
Use f-strings
Work with operators
Make decisions using if, elif and else
Combine conditions using and, or and not
Understand nested if statements

If you're completely new to Python, this is basically where I started.

So, What Is Python?

Python is a programming language. It does sound obvious, but as a beginner, I think it helps to think about programming in a simpler way.

A programming language is basically a way of giving instructions to a computer. Take a recipe for example:

Think of it like writing a recipe. You write clear, step-by-step instructions and the computer follows them exactly.

Python is also a good language because its syntax is relatively easy to read.

Let's get into it.

My First Line of Python

The first thing I learned was print().

print("Hello World")

Output:

Hello World

print() is Python's way of showing something on the screen.

You put whatever you want Python to display inside the brackets.

For example:

print("I am learning python")
print("My name is Sylvia")
print(3.14)

You can also print more than one thing:

print("Python is", "great")

Output:

Python is great

Printing Blank Lines

You can also use print() without putting anything inside it.

print("Line one")
print()
print("Line three")

Output:

Line one

Line three

The empty print() gives us a blank line.

Another way of doing something similar is \n.

print("Line one\n")
print("Line three")

\n represents a new line.

These small things become useful when you're trying to make the output of your program easier to read.

Variables: Giving Information a Name

The easiest way I've found to understand a variable is to think of it as a labelled box. You put some information inside the box, give the box a name and then use that name whenever you need the information.

For example:

name = "Sylvia Ndili"
age = 26
city = "Nairobi"

Here, I've created three variables:

name
age
city

And I've stored different pieces of information in them.

I can then print them:

print(name)
print(age)
print(city)

Instead of writing "Sylvia Ndili" every time I need the name, I can just use name.

You can also combine them:

print(name, "is", age, "years old and lives in", city)

Output:

Sylvia Ndili is 26 years old and lives in Nairobi

This is one of those simple concepts that will come in handy later.

What Does the `=` Sign Actually Mean?

When I first saw something like this:

name = "Sylvia"

it was easy to look at = and think of it as "equals".

In Python, when we're creating a variable, it's better to think of it as assignment.

name = "Sylvia"

means we're assigning "Sylvia" to the variable name.

We can also change what is stored in a variable.

score = 50
print("Score before:", score)

score = 75
print("Score after:", score)

Output:

Score before: 50
Score after: 75

The old value has been replaced.

We can also use the current value to calculate a new one:

score = 75
score = score + 10

print("Score plus 10:", score)

Now the score is 85.

With this, you learn that variables aren't necessarily permanent. The value inside them can change as the program runs.

Naming Variables

There are rules for naming variables.

The common style in Python is called snake_case.

For example:

student_name = "Sylvia"
phone_number = "0712345678"
total_score = 450

The words are separated using underscores.

There are also names that won't work:

2name = "Sylvia"
my-name = "Sylvia"
class = "Python"

For example, a variable can't start with a number, class is a reserved keyword and - isn't used to separate words in variable names.

Python variable names are also case-sensitive. That means: age, Age, AGE are three different variable names.

Data Types: What Type of Information Are We Storing?

This is an important part as Python treats different kinds of data differently.

There are four main data types:

Type	Meaning	Example
`str`	String/text	`"Sylvia"`
`int`	Integer/whole number	`26`
`float`	Number with a decimal	`1.68`
`bool`	True or False	`True`

Let's look at each one.

Strings

A string is text and normally written inside quotes.

name = "Sylvia Ndili"
city = "Nairobi"

Integers

An integer is a whole number. There are no quotes around the numbers.

age = 26
score = 87

Floats

A float is a number containing a decimal.

height = 1.68
balance = 2350.50

Booleans

A boolean has only two possible values:

True
False

For example:

is_student = True
has_id_card = False

Booleans might not make sense right now, but become extremely useful when we get to conditions.

How Do I Know What Type Something Is?

Python has a function called type().

name = "Sylvia"
age = 26
height = 1.68
has_id_card = False

print(type(name))                   #string
print(type(age))                    #integer
print(type(height))                 #float
print(type(has_id_card))            #boolean

Python will tell us what type each value is. This is useful when you're not sure what kind of data you're actually working with.

`"5"` Is Not the Same as `5`

These two things look almost identical but Python sees them differently.

number_a = 5
number_b = "5"

5 is an integer while "5" is a string.

For example:

print(number_a + number_a)

gives: 10

But:

print(number_b + number_b)

gives: 55

This is because Python is treating "5" as text, so + joins the two strings together.

The same thing happens here:

print("5" + "3")

Output: 53

But:

print(5 + 3)

Output: 8

This was a very useful beginner lesson for me. Python needs to know what type of data it is dealing with.

Something that looks like a number isn't necessarily a number.

Converting Between Types

Sometimes you get data in one type but need another type. Python gives us functions for converting between some common types.

For example, we can convert a string into an integer using int().

text_number = "42"
real_number = int(text_number)

print(real_number)

Python now treats 42 as a number, so we can do arithmetic with it.

We can also convert a number into a string:

age = 24
age_str = str(age)

print(type(age))
print(type(age_str))

The first variable is an integer and the second is a string.

We can also convert something to a float:

price = float("99.99")

print(price)

`input()`: Letting the User Talk to Python

So far, Python has mostly been talking to us. With input() the user now gets a chance to talk back.

For example:

name = input("What is your name? ")

print()
print("Hello,", name)
print("Welcome to Python class")

When Python reaches input(), it stops and waits for the user to type something.

input() always returns a string as default data type even if the user enters a number.

So if you write:

age = input("How old are you? ")

and enter: 26 , Python receives "26" as a string.

If you want to treat it as a number, you need to convert it as shown below, using int and input at once:

age = int(input("How old are you? "))

print("You are", age, "years old.")

First, input() gets the user's answer. Then int() converts that answer from a string into an integer. The same idea works with floats also.

f-Strings: A Cleaner Way to Print

There is another way of putting variables and text together: f-strings.

Before f-strings, we could do something like:

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

print("Hello", name, "!", "You are", age, "years old.")

This works, but it can get difficult to read with many variables.

With an f-string:

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

print(f"Hello {name}! You are {age} years old.")

Output:

Hello Daniel! You are 24 years old.

The f before the quote tells Python that we're going to put variables or expressions inside {}.

Operators and Conditionals

Here, we are now giving python conditions and saying:

If this is true, do this.

The first thing we need for that is comparison operators.

Comparison Operators

A comparison operator compares two values and gives us either:

True or: False

Think of it as asking a yes-or-no question.

For example:

age = 20

print(age == 20)

Python answers: True

But:

age = 20

print(age == 25)

gives:False

Here are the comparison operators I learned:

Operator	Meaning	Example
`==`	Equal to	`7 == 7`
`!=`	Not equal to	`7 != 2`
`>`	Greater than	`12 > 9`
`<`	Less than	`4 < 2`
`>=`	Greater than or equal to	`6 >= 6`
`<=`	Less than or equal to	`5 <= 3`

One thing that confused me initially was the difference between: = and ==. A single = is used when assigning a value, while two equals signs == are used when asking whether two values are equal:

Comparing Strings

We can compare text too.

track = "Data Engineering"

print(track == "Data Engineering")

This gives: True

But Python is case-sensitive. So:

print(track == "data engineering")

gives: False

Strings can also be compared alphabetically:

print("Amina" < "Collins")

This is True because A comes before C.

`if`: Conditionals

An if statement allows Python to make a decision.

For example:

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

if score >= 50:
    print("You passed")

print("Thank you for taking the test.")

The important parts here are:

if score >= 50:

and the indentation:

    print("You passed")

The colon : is required and indentation is also important. The indented code belongs to the if statement. If the score is 50 or higher, Python prints: You passed. If the score is less than 50, Python skips that line.

But this line: print("Thank you for taking the test.") will still run because it isn't indented under the if.

That's something you need to be keen on because Python uses indentation to show which code belongs together.

`if` and `else`

What if we want Python to do something when the condition is false too?

That's where else comes in.

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

if score >= 50:
    print("Pass - Well done")
else:
    print("FAIL - Please try again")

print(f"Your score was: {score}")

Basically, if the condition is true, Python takes the if path. If it's false, Python takes the else path. Only one of them runs.

The final print() isn't part of either path because it isn't indented.

`elif`: ELSE IF

This is for more than two possible outcomes. For example, we're assigning grades.

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

if score >= 80:
    print("Grade A - Excellent")
elif score >= 70:
    print("Grade B - Good")
elif score >= 60:
    print("Grade C - Average")
elif score >= 50:
    print("Grade D - Below Average")
else:
    print("Grade F - Failed")

Here, there are several possibilities. Python checks them from the top down.

Python stops at the first condition that is true.

So if the score is 85, Python checks:

score >= 80

That's true. It prints Grade A and stops checking the other conditions.

Why the Order of `if` and `elif` Matters

This was one of the more interesting mistakes to understand.

Look at this:

score = 85

if score >= 50:
    print("Grade D")
elif score >= 70:
    print("Grade B")
elif score >= 80:
    print("Grade A")

You might expect 85 to produce Grade A. But it won't.

The first condition is:

score >= 50

That's already true. So Python prints: GRADE D and stops. It never gets to the Grade B or Grade A conditions. That's why we need to put the highest boundary first, which is why we start with the highest score first. Python checks from top to bottom and stops when it finds the first true condition.

Logical Operators: When One Condition Isn't Enough

Sometimes asking one question isn't enough.

For example, imagine we want to give someone access only if: they are at least 18 and they have an ID.

We can use and.

There are three logical operators:

Operator	Meaning
`and`	Both conditions must be true
`or`	At least one condition must be true
`not`	Flips True to False and False to True

`and`

With and, both conditions must be true.

age = int(input("Age: "))
has_id = input("Do you have an ID? (yes/no) ")

if age >= 18 and has_id == "yes":
    print("Access granted - Welcome")
else:
    print("Access Denied")

Someone who is 20 but doesn't have an ID is denied. Someone who has an ID but is 15 is also denied. Both conditions need to be true.

You can think about it like:

True and True   → True
True and False  → False
False and True  → False
False and False → False

`or`

With or, we only need one condition to be true.

For example, imagine a discount for students and senior citizens.

is_student = input("Are you a student? (yes/no): ")
is_senior = input("Are you 60+ ? (yes/no): ")

if is_student == "yes" or is_senior == "yes":
    print("Discount Applied - 25% off")
else:
    print("Full price applies")

A student qualifies. A senior qualifies. Someone who is both also qualifies. Only when both answers are no do they pay full price.

So:

True or True   → True
True or False  → True
False or True  → True
False or False → False

The easiest way I've found to remember it is:

and = both. or = at least one

`not`

The third logical operator is not. It basically flips a boolean value.

not True  → False
not False → True

A simple real-life way to think about it would be:

The alarm rings if the door is not locked.

We're basically reversing the condition.

Combining Conditions

We can combine comparison operators and logical operators.

For example, imagine a student needs: a score of at least 50 and and attendance of at least 75% to pass.

score = int(input("Score: "))
attendance = int(input("Attendance %: "))

if score >= 50 and attendance >= 75:
    print("PASS")
elif score >= 50 and attendance < 75:
    print("FAIL - Poor Attendance")
elif score < 50 and attendance >= 75:
    print("FAIL - Low Score")
else:
    print("FAIL - Both score and attendance below minimum")

Now Python is evaluating more than one piece of information before deciding what to do. This is where variables, data types, comparison operators and logical operators start coming together.

Nested `if`: A Decision Inside a Decision

The last concept here is a nested if.

A nested if is simply an if statement inside another if statement. This is useful when the second question only makes sense after the first question has been answered.

Take an example of a login system.

First:

Is this the correct username?

Only if the answer is yes do we need to ask:

Is this the correct password?

We can write it like this:

username = input("Username: ")

if username == "admin":
    password = input("Password: ")

    if password == "kenya2025":
        print("Welcome Admin")
    else:
        print("Wrong Password. Try again")
else:
    print("User not found")

Notice that the second if is inside the first one.

The password question only happens if: username == "admin" is true.

This is the main reason to use a nested if: the second decision depends on the first one.

Nested `if` vs `elif`

I initially found these two concepts a bit hard to differentiate. You can think about it like this:

Use elif when you're asking the same question with different possible answers.

For example:

track = input("Your track (DS or DE): ")

if track == "DS":
    print("Your next course: Pandas and NumPy")
elif track == "DE":
    print("Your next course: Airflow and Kafka")
else:
    print("Unknown track")

We're asking: Which track are you in?. There are different possible answers.

But with a nested if, the second question depends on the first answer.

For example:

has_laptop = input("Do you have a laptop? (yes/no) ")

if has_laptop == "yes":
    os_type = input("Windows or Mac? ")

    if os_type == "Windows":
        print("Install Python from python.org")
    else:
        print("Python may already be installed - check with python3 --version")
else:
    print("Please borrow a laptop for this session")

There's no point asking: Windows or Mac?, if the person doesn't even have a laptop. That's the kind of situation where a nested if makes sense.

Bringing the concepts together

For the final, you can try incorporating all concepts together and build a small mini program.

The program below asks whether someone has a bank account. If they don't, we're done. If they do, we ask how long they've been a customer. If they've been a customer for at least six months, we then ask about their salary.

has_account = input("Do you have a bank account? (yes/no): ")

if has_account == "no":
    print("Sorry, you need an account first.")
else:
    months = int(input("How many months have you been a customer? "))

    if months < 6:
        print("You need at least 6 months of account history.")
    else:
        salary = int(input("What is your monthly salary? "))

        if salary < 20000:
            print("Minimum salary for loan is Ksh 20,000")
        else:
            print("Congratulations! You qualify for a loan")

This example uses quite a few things from the concepts covered:

input(), Variables, Strings, Integers, int() conversion, Comparison operators, if, else, Nested if

My biggest takeaway from this is that, the individual concepts aren't really isolated concepts, they eventually start working together.

Final Thoughts

Although these concepts seem straightforward, they are important because they form the foundation for writing more useful programs. Once you understand how Python stores information, compares values and makes decisions, it becomes much easier to build on top of these ideas. You don't have to build a program on your first try.

For me, a fair progression in mastering python would look like this:

Tell Python something
        ↓
Store information
        ↓
Understand what type the information is
        ↓
Get information from the user
        ↓
Work with the information
        ↓
Compare the information
        ↓
Make decisions based on the comparison

And that last part is where programming starts getting interesting. We're no longer just telling Python what to say. We're starting to tell it how to respond depending on what happens.

There's so much more Python to learn. But for now, understanding these fundamentals gives us a solid starting point for moving into more advanced topics. And I think that's a good place to start.

SQL Made Simple: Greenwood Academy Database Project with PostgreSQL

Sylvia Ndili — Sun, 19 Jul 2026 15:50:37 +0000

Opening a blank database console for the first time can feel intimidating. You're staring at an empty space and somehow expected to turn it into a clean, organized structure. Over the past two weeks I went from not knowing basic syntax to building, populating and running real queries in PostgreSQL.

If you're just starting out, it helps a lot to break things down by what each piece actually does. Here's how I made sense of it, using the exact queries I wrote while building a small management system for a school called Greenwood Academy.

1. First you build the house (DDL)

Before you can put any data anywhere, you have to decide what the data even looks like. That's DDL - Data Definition Language. It's just the "building the shelves before you put stuff on them" part.

One trick that saved me a lot of typing: instead of writing greenwood_academy.students every single time, you can just tell Postgres which schema to default to.

-- Create a schema called greenwood_academy and set search path
CREATE SCHEMA greenwood_academy;
SET search_path TO greenwood_academy;

-- Create the students table
CREATE TABLE students (
    student_id      INT PRIMARY KEY,
    first_name      VARCHAR(50) NOT NULL,
    last_name       VARCHAR(50) NOT NULL,
    gender          VARCHAR(1),
    date_of_birth   DATE,
    class           VARCHAR(10),
    city            VARCHAR(50)
);

-- Create the subjects table
CREATE TABLE subjects (
    subject_id INT PRIMARY KEY,
    subject_name VARCHAR(100) NOT NULL UNIQUE,
    department VARCHAR(50),
    teacher_name VARCHAR(100),
    credits INT
);

-- Create the exam_results table
CREATE TABLE exam_results (
    result_id INT PRIMARY KEY,
    student_id INT NOT NULL,
    subject_id INT NOT NULL,
    marks INT NOT NULL,
    exam_date DATE,
    grade VARCHAR(2)
);

And of course, that is not the end. You can do various alterations on your table without having to start over. The below are for adding, renaming and removing columns:

-- adding a phone number column to students table
ALTER TABLE students ADD COLUMN phone_number VARCHAR(20);

-- Rename credits to credit_hours in subjects table
ALTER TABLE subjects RENAME COLUMN credits TO credit_hours;

-- Drop phone_number column from students table
ALTER TABLE students DROP COLUMN phone_number;

2. Then you actually put data in it (DML)

Once the table exists, it's empty. This is where DML comes in - Data Manipulation Language; adding, changing or removing rows.

Inserting data into students table

-- Insert all 10 students into the students table
INSERT INTO students (student_id, first_name, last_name, gender, date_of_birth, class, city) VALUES
(1, 'Amina', 'Wanjiku', 'F', '2008-03-12', 'Form 3', 'Nairobi'),
(2, 'Brian', 'Ochieng', 'M', '2007-07-25', 'Form 4', 'Mombasa'),
(3, 'Cynthia', 'Mutua', 'F', '2008-11-05', 'Form 3', 'Kisumu'),
(4, 'David', 'Kamau', 'M', '2007-02-18', 'Form 4', 'Nairobi'),
(5, 'Esther', 'Akinyi', 'F', '2009-06-30', 'Form 2', 'Nakuru'),
(6, 'Felix', 'Otieno', 'M', '2009-09-14', 'Form 2', 'Eldoret'),
(7, 'Grace', 'Mwangi', 'F', '2008-01-22', 'Form 3', 'Nairobi'),
(8, 'Hassan', 'Abdi', 'M', '2007-04-09', 'Form 4', 'Mombasa'),
(9, 'Ivy', 'Chebet', 'F', '2009-12-01', 'Form 2', 'Nakuru'),
(10, 'James', 'Kariuki', 'M', '2008-08-17', 'Form 3', 'Nairobi');

Inserting data into subjects table

-- Insert all 10 subjects into the subjects table
INSERT INTO subjects (subject_id, subject_name, department, teacher_name, credit_hours) VALUES
(1, 'Mathematics', 'Sciences', 'Mr. Njoroge', 4),
(2, 'English', 'Languages', 'Ms. Adhiambo', 3),
(3, 'Biology', 'Sciences', 'Ms. Otieno', 4),
(4, 'History', 'Humanities', 'Mr. Waweru', 3),
(5, 'Kiswahili', 'Languages', 'Ms. Nduta', 3),
(6, 'Physics', 'Sciences', 'Mr. Kamande', 4),
(7, 'Geography', 'Humanities', 'Ms. Chebet', 3),
(8, 'Chemistry', 'Sciences', 'Ms. Muthoni', 4),
(9, 'Computer Studies', 'Sciences', 'Mr. Oduya', 3),
(10, 'Business Studies', 'Humanities', 'Ms. Wangari', 3);

Inserting data into exams_results table

-- Insert all 10 exam results into the exam_results table
INSERT INTO exam_results (result_id, student_id, subject_id, marks, exam_date, grade) VALUES
(1, 1, 1, 78, '2024-03-15', 'B'),
(2, 1, 2, 85, '2024-03-16', 'A'),
(3, 2, 1, 92, '2024-03-15', 'A'),
(4, 2, 3, 55, '2024-03-17', 'C'),
(5, 3, 2, 49, '2024-03-16', 'D'),
(6, 3, 4, 71, '2024-03-18', 'B'),
(7, 4, 1, 88, '2024-03-15', 'A'),
(8, 4, 6, 63, '2024-03-19', 'C'),
(9, 5, 5, 39, '2024-03-20', 'F'),
(10, 6, 9, 95, '2024-03-21', 'A');

Confirm all 10 rows exist

-- Confirm all 10 rows exist in each of the three tables
SELECT * FROM students;
SELECT * FROM subjects;
SELECT * FROM exam_results;

UPDATE - Changes existing records

-- fixing a student's city
UPDATE students
SET city = 'Nairobi'
WHERE student_id = 5;

DELETE - removes rows from a table, but keeps the structure of the table

--- Delete exam result with result_id 9
DELETE FROM exam_results 
WHERE result_id = 9;

3. WHERE now comes in

Honestly this is where I started seeing the power of SQL. WHERE is how you check through rows and pull out exactly what you need.

Here are the operators I used:

-- students who scored between 50 and 80
SELECT *
FROM exam_results
WHERE marks BETWEEN 50 AND 80;

-- students from a specific set of cities
SELECT *
FROM students
WHERE city IN ('Nairobi', 'Mombasa', 'Kisumu');

-- everyone NOT in Form 2 or Form 3
SELECT *
FROM students
WHERE class NOT IN ('Form 2', 'Form 3');

-- any subject with "Studies" somewhere in the name
SELECT *
FROM subjects
WHERE subject_name LIKE '%Studies%';

That % wildcard in LIKE became interesting when I finally figured it out. %Studies% just means "What's before or after it is not of concern, just find 'Studies' somewhere in there." So much cleaner than stacking a bunch of OR conditions.

4. Aggregate functions

This is basically just the summary.

-- how many Form 3 students do we have?
SELECT COUNT(*) AS total_form3_students
FROM students
WHERE class = 'Form 3';

-- how many students scored 70 or above?
SELECT COUNT(*) AS total_above_70
FROM exam_results
WHERE marks >= 70;

5. CASE WHEN

Checks each rule one by one down the list, returning the matching label the second a condition is met.

--- Label each exam result with a grade description
SELECT result_id, student_id, subject_id, marks,
       CASE 
           WHEN marks >= 80 THEN 'Distinction'
           WHEN marks >= 60 THEN 'Merit'
           WHEN marks >= 40 THEN 'Pass'
           ELSE 'Fail'
       END AS performance
FROM exam_results;

My takeaway from this

SET search_path is a small habit that saves a lot of repetitive typing.
Always, check your WHERE clause before running an update or delete.
Name your aggregate results something readable.

Conclusion

Building the Greenwood Academy database was a genuinely useful beginner project because it touched both database design and querying. By the end I'd practiced creating tables, inserting data, updating records, filtering results, summarizing data and writing conditional logic.
If you're learning SQL, I'd recommend building a small project like this yourself. It's a much better way to understand how these pieces actually get used than just reading through syntax on its own.

How to Connect Power BI to SQL Databases (Local & Cloud)

Sylvia Ndili — Sun, 05 Jul 2026 17:55:40 +0000

Connecting your data to Power BI is usually the very first step in building any meaningful dashboard. SQL databases, whether located on a local office server or hosted out in the cloud, they remain the industry foundation for this data.

Let's walk through how to set up both local and cloud-based SQL connections in Power BI, step-by-step.

Part 1: Connecting Power BI to a Local SQL Server

To pull data from a local SQL Server, you will need to have a server name and database configuration parameters.

Step 1: Open the SQL Server Connector

Launch Power BI.
On the Home tab ribbon, click on Get Data.
Select More... and search postgres to locate it under the Database category.

Step 2: Configure Server Details & Data Connectivity

A dialog box will appear asking for your server credentials and access choices.

Server: Enter your local server path i.e (localhost:5432)
Database: Enter your database name (postgres)
Data Connectivity Mode:
- Import: Downloads a snapshot of the data into the Power BI file. Best for fast performance and complex modeling.
- DirectQuery: Queries the data live every time you interact with a visual. Essential for massive datasets or real-time tracking.

Step 3: Provide Credentials

For authentication:

Select Database to enter your username and password, then click Connect.
Preview and Load Tables The Navigator window will open. Expand your database instance, check the boxes next to the tables or views you want to use and click Transform Data to clean them inside Power Query.

Part 2: Connecting Power BI to a Cloud Database (Aiven)

Cloud solutions like Aiven make it easy to deploy PostgreSQL databases. Because Aiven exposes a public endpoint by default, Power BI can securely stream cloud data.

Step 1: Gather Connection Details from Aiven

Before switching to Power BI, grab your credentials from the Aiven Console.

In the Overview tab, find the Connection information and copy the following fields: Host, Port, User, Password, and Database Name.

Step 2: Install the CA Certificate on Your Windows Machine

Power BI relies on the Windows Certificate Store to validate SSL handshakes. Download and install your ca.pem file as a trusted certificate.

Click the Windows Start menu, search for Manage user certificates, and open it.
In the left panel, locate and click on Trusted Root Certification Authorities.
Right-click on the Certificates folder inside that directory, navigate to All Tasks, and click Import.
The Certificate Import Wizard will pop up. Click Next, change the file extension filter to "All Files (.)" so you can find your ca.pem file, select it, and complete the installation wizard instructions.

Step 3: Select the PostgreSQL Connector in Power BI

Back in Power BI, click Get Data on the Home ribbon.
Click More..., choose Database on the left menu, and select PostgreSQL database.
Click Connect.

Establish the connection on Power BI

Server: Combine your host and port separated by a colon (e.g., pg-your-project-name.aivencloud.com:12345).
Database: Type the exact name of the database you intend to read from (e.g., defaultdb).
Select either Import, then click OK.

Authenticate with Database Credentials - Username and Password, then click Connect.
Select Tables - The Navigator panel will look up your database. Select your dataset, then click Load for a clean dataset or Transform to start the process of cleaning on Power Query

Finally

Once these parameters are configured, your relationships can be built directly inside the Power BI Model view. The core difference ultimately boils down to network topology: local connections require safe local-network access paths or gateways, while cloud-hosted services like Aiven rely primarily on public connection strings backed by strong encryption and user credentials.

Power BI Finally Started Clicking(Schemas, Relationships & Joins)

Sylvia Ndili — Sun, 28 Jun 2026 19:31:47 +0000

You've loaded your data into Power BI. You've got the tables. Now what are you expected to do?

Here's the thing most beginners skip: how your tables connect to each other is more important than the data inside them. A poorly structured model will give you wrong numbers, slow reports and a difficult time every time you try to add a new chart.

This week we're covering the foundation of Power BI, data modeling. Specifically: what kinds of tables exist, how schemas work, what relationships are and what joins are doing behind the scenes.

One thing that took me a while to get in Power BI is that loading data is only half the job. The other half is telling Power BI how your tables talk to each other. That's what schemas, relationships and joins are about.

The Problem I hadn't anticipated

When I first loaded data into Power BI, I had three separate tables; customers, products and sales. I could build charts from each one individually, but the moment I tried to combine them like "show me sales by customer city", things either broke or gave me numbers that made no sense.
Turns out I had no relationships set up. Power BI had no idea how those three tables were supposed to connect. That's what I got to learn.

Fact Tables vs Dimension Tables

Every Power BI model has two kinds of tables doing different jobs.

Fact tables store your actual transactions - every sale, every order, every event. They're usually huge and full of numbers and IDs.

Dimension tables give those numbers context. Your Customers, Products and Dates tables are dimension tables (fewer rows but more descriptive columns). They answer the who, what and when behind every fact.

The Star Schema

Power BI is basically built for this layout. One fact table sits in the middle, dimension tables connect around it. For instance:

           DIM_Date
               |
DIM_Customer — FACT_Sales — DIM_Product
               |
           DIM_Store

Filters flow from the outside in, queries run fast and the model stays easy to read. There's a variation called the Snowflake Schema where you break dimension tables into sub-tables, but in Power BI it adds complexity without much payoff. Star schema is the standard.

Snowflake Schema

The snowflake schema extends the star by breaking dimension tables into sub-tables. For example, instead of one DIM_Customer table with a City and Country column, you'd have a separate DIM_City table linked to a DIM_Country table.

Relationships

A relationship is the link between two tables through a shared column.

Primary Key (PK) - uniquely identifies every row in a table. No duplicates.
Foreign Key (FK) - that same ID living in another table as a reference.

The most common type is One-to-Many (1:N) - one customer, many orders. One product, many sales. The dimension table always sits on the "one" side, the fact table on the "many" side.

When you have a situation where many rows in Table A relate to many rows in Table B - like students and courses, that's a Many-to-Many relationship. Power BI doesn't handle this cleanly on its own so you use a bridge table in between, which breaks it into two clean one-to-many links.

Cross-Filter Direction

When you click on something in a visual, other visuals filter too. That behaviour is controlled by cross-filter direction.

Single direction - filters flow from dimension into fact only. This is the default and what you should stick with most of the time.

Bidirectional - filters travel both ways. Useful in specific cases but can slow things down and cause circular logic if overused.

Active vs Inactive Relationships

You can have more than one relationship between two tables but only one can be active at a time. A common example - a Sales table with both an OrderDate and a ShipDate, both linking to the same date table. One relationship is active by default, the other sits inactive until you call it explicitly in DAX using USERELATIONSHIP().

Joins

This is what Power BI does behind the scenes when combining tables in a visual.

Inner join - only rows with a match in both tables come through. Unmatched rows get dropped silently, which is why some totals can look off unexpectedly.

Left join - all rows from the left table come through, matched or not. Unmatched rows just show blank on the right side. This is what Power BI uses most of the time when pulling from a dimension into a fact table.

Cross Join - every row in Table A paired with every row in Table B. Rarely useful; produces enormous result sets.

Little hacks

Use Star Schema whenever possible
Keep dimension tables on the "one" side, fact tables on the "many" side
One active relationship per table pair
Avoid bidirectional filtering unless you have a specific reason
Resolve Many-to-Many with a bridge table

Wrapping Up

Data modeling isn't the flashy part of Power BI, but it's the part that makes everything else work. Get your schema right, define clean relationships and your reports will be fast, your numbers accurate and your filters will just work.

If you have questions about anything covered here, drop them in the comments!

Excel and Real-World Data Analysis - What I Learned in Week 1

Sylvia Ndili — Sat, 06 Jun 2026 16:24:56 +0000

To be honest, when I signed up for a Data Science and Analytics course, it hadn't crossed my mind that Excel was the very first tool I would start with. I figured we'd jump straight into dashboards, maybe some Python, something that felt more "data sciency". But here we are, Week 1, deep in spreadsheets.

And the best part about this is that I'm actually glad it started here.

So, what is Excel?

Excel is a spreadsheet tool by Microsoft. You work with data in rows and columns, run calculations, sort things, filter things and build reports. Sounds simple, right? But once you start using it on real data, you realize it's literally the backbone of a huge chunk of the business world.

Ways Excel shows up in real work

- Financial Reporting - Accountants and finance teams use Excel to track income, expenses, budgets and forecasts. Every month, someone somewhere is pulling together a financial report in Excel before it ever reaches a boardroom.

- Sales and Business Performance - Sales teams track numbers in Excel — who sold what, which region is hitting targets, which product is underperforming. It's the first place most managers go when they want to understand their numbers.

- Marketing Analysis - Marketers use Excel to measure campaigns, click rates, conversions and customer behavior over time. Before any fancy BI tool, most marketing teams have a spreadsheet tracking what's working.

Features I used this week

Before jumping into formulas, the first thing I had to do was just understand how Excel is laid out. It sounds obvious but getting comfortable with the interface first made everything else easier.

Once I had that down, I started working with these features:

Sorting - Organizing data by numbers, text or dates. Useful when you need to quickly rank results or find the highest/lowest values.
Filtering - Showing only the rows that match a certain condition. Instead of scrolling through hundreds of entries, you just filter and focus on what matters.
Data Validation - This one is about keeping data clean at the entry point. You can set rules so that only certain values are accepted in a column. It stops messy, inconsistent data before it becomes a problem.
Freeze Panes - When you're scrolling through a big dataset, your headers disappear off the top of the screen. Freeze Panes keeps them visible no matter how far down you scroll. Simple but incredibly useful.

Functions I Learned

SUM, AVERAGE and COUNT - These feel basic but they're everywhere. I used SUM to total a column of sales figures, AVERAGE to find a mean score and COUNT to quickly see how many entries were in a dataset.

COUNTIF - This was my favourite this week. Instead of manually counting how many times something appears, COUNTIF does it automatically based on a condition. I used it to count how many entries matched a specific category. Such a small thing that makes a big difference.

SUMIF and SUMIFS - Add values that meet one or more conditions.

AVERAGEIF and AVERAGEIFS - Calculate averages based on selected conditions.

These are the functions that help you answer actual business questions - total sales by product, customer count by region, average performance across departments.

Text and Date Functions - I also got introduced to LEFT(), RIGHT(), LEN(), and CONCAT() for working with text, and TODAY(), NOW(), DAY(), MONTH(), YEAR() for dates. These are used a lot in data cleaning — pulling out parts of a string, combining columns, or breaking a date into components you can analyze separately.

How this changed the way I see data

Before this week, I looked at a spreadsheet and just saw a table. Now I see questions. What's the total? What's the average? What's pulling the numbers up or down? Excel didn't just teach me formulas, it taught me to ask better questions about data.

I'm only in Week 1 and I already feel like I'm thinking differently. That's quite the leap.

If you're also starting out in data analytics, don't skip Excel thinking it's too basic. It's the foundation everything else is built on.

💬 Are you also learning data analytics or just getting started with Excel? Drop a comment - I'd love to connect with others on the same path.

DEV Community: Sylvia Ndili

An Introduction to Object-Oriented Programming (OOP) in Python

1. What is Object-Oriented Programming?

Why OOP?

2. Classes and Objects

What is a class?

What is an object?

Understanding __init__()

What is self?

3. Attributes and Methods

Attributes

Methods

4. Python Naming Conventions

5. The Four Pillars of OOP

5.1 Encapsulation

Example: A bank account

Another example: An M-Pesa account

5.2 Inheritance

Example: Farm animals

What does super() do?

5.3 Polymorphism

5.4 Abstraction

6. Putting the Concepts Together

Conclusion

# Learning Python Data Structures and Algorithms Through Practical Examples

1. Lists: Working with Collections of Data

2. Tuples: Storing Data That Should Not Change

3. Dictionaries: Organising Data Using Keys and Values

4. Sets: Handling Unique Values

5. Strings: Cleaning, Searching and Validating Text

6. Bringing the Concepts Together: Bundle Purchase Simulator

Final Thoughts

Write Code Once, Use It Forever: Python Functions Explained

The problem with repeating code

Defining and calling a function

Functions can have more than one parameter

Printing isn't the same as returning

Functions can contain decisions

Returning multiple values

Scope: where variables exist

The global keyword

Default arguments

*args

Putting Functions Together: Payslip Generator Program

Finally

Loops In Python: Making Programs Repeat Without Repeating Yourself

Starting with a for loop

Using range()

Loop Calculations

The accumulator pattern

An if inside a loop

while loops

while True and break

continue

enumerate()

Nested loops

Putting It All Together: Mini Bank Loop

To Sum Up

Learning Python? Here's how you can get started

So, What Is Python?

My First Line of Python

Printing Blank Lines

Variables: Giving Information a Name

What Does the = Sign Actually Mean?

Naming Variables

Data Types: What Type of Information Are We Storing?

Strings

Integers

Floats

Booleans

How Do I Know What Type Something Is?

"5" Is Not the Same as 5

Converting Between Types

input(): Letting the User Talk to Python

f-Strings: A Cleaner Way to Print

Operators and Conditionals

Comparison Operators

Comparing Strings

if: Conditionals

if and else

Understanding `init()`

What is `self`?

What does `super()` do?

The `global` keyword

`*args`

Starting with a `for` loop

Using `range()`

An `if` inside a loop

`while` loops

`while True` and `break`

`continue`

`enumerate()`

What Does the `=` Sign Actually Mean?

`"5"` Is Not the Same as `5`

`input()`: Letting the User Talk to Python

`if`: Conditionals

`if` and `else`

`elif`: ELSE IF

Why the Order of `if` and `elif` Matters

`and`

`or`

`not`

Nested `if`: A Decision Inside a Decision

Nested `if` vs `elif`