DEV Community: Lameck Odhiambo

Understanding NumPy

Lameck Odhiambo — Tue, 20 Oct 2026 07:56:49 +0000

Numerical Python also known as Numpy is used for numerical computing in Data Science, Engineering, Artificial Intelligence and Machine Learning
Clean python lists cannot be compared to ndarrays of numpy which are faster.

Getting started with numpy

If you have Python and PIP already installed on a system, then installation of NumPy is very easy.

Install it using this command:

pip install numpy

Once NumPy is installed, import it in your applications by adding the import keyword

import numpy as np

Checking NumPy Version
The version string is stored under version attribute.

import numpy as np

print(np.__version__)

Creating Arrays in Numpy

NumPy is used to work with arrays. The array object in NumPy is called ndarray.
We can create a NumPy ndarray object by using the array() function. import numpy as np


arr = np.array([1, 2, 3, 4, 5])

print(arr)

print(type(arr))

Output:

[1 2 3 4 5]
<class 'numpy.ndarray'>

Dimensions in Arrays

1-D Arrays

An array that has 0-D arrays as its elements is called uni-dimensional or 1-D array.

import numpy as np

arr = np.array([1, 2, 3, 4, 5])

print(arr)

Output:

[1 2 3 4 5]

2-D Arrays

An array that has 1-D arrays as its elements is called a 2-D array.

import numpy as np

arr = np.array([[1, 2, 3], [4, 5, 6]])

print(arr)

Output:

[[1 2 3]
 [4 5 6]]

3-D arrays

An array that has 2-D arrays (matrices) as its elements is called 3-D array.

import numpy as np

arr = np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]])

print(arr)

Check Number of Dimensions

NumPy Arrays provides the ndim attribute that returns an integer that tells us how many dimensions the array have.

import numpy as np

a = np.array(42)
b = np.array([1, 2, 3, 4, 5])
c = np.array([[1, 2, 3], [4, 5, 6]])
d = np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]])

print(a.ndim)
print(b.ndim)
print(c.ndim)
print(d.ndim)

Output:

Indexing and Slicing

The indexes in NumPy arrays start with 0, meaning that the first element has index 0, and the second has index 1 etc.
Slicing in python means taking elements from one given index to another given index. We pass slice instead of index like this: [start:end]. We can also define the step, like this: [start:end:step].

import numpy as np

arr = np.array([
    [10, 11, 12, 13],
    [20, 21, 22, 23],
    [30, 31, 32, 33]
])

Accessing Rows

Single Row: Pass the zero-based index of the row

arr[0]      # Returns the 1st row: [10, 11, 12, 13]
arr[-1]     # Returns the last row:  [30, 31, 32, 33]

Range of Rows: Use a slice for the row position. The end index is exclusive

arr[0:2]    # Returns rows 0 and 1 (first two rows)

Accessing Columns

To extract columns, you must tell NumPy to look at all rows by using a standalone colon (:) in the row slot, followed by your column index.

Single Column

arr[:, 1]   # Returns the 2nd column: [11, 21, 31]

Range of Columns

arr[:, 1:3] # Returns columns 1 and 2 across all rows

Arithmetic

Scalar arithmetic

Scalar arithmetic in NumPy refers to performing standard mathematical operations between a single numerical value (a scalar) and a NumPy array.

import numpy as np

# Create a simple 1D array
arr = np.array([10, 20, 30, 40])
scalar = 5

# 1. Addition
print("Addition (+):", arr + scalar)
# Output: [15 25 35 45]

# 2. Subtraction
print("Subtraction (-):", arr - scalar)
# Output: [ 5 15 25 35]

# 3. Multiplication
print("Multiplication (*):", arr * scalar)
# Output: [ 50 100 150 200]

# 4. Division (returns floats)
print("Division (/):", arr / scalar)
# Output: [2.  4.  6.  8.]

# 5. Exponentiation (Power)
print("Power (**):", arr ** 2)
# Output: [ 100  400  900 1600]

Element-Wise Arithmetic (Same Shape)

When you use standard mathematical operators (+, -, , /, *) on two arrays of the same shape, NumPy automatically applies the operation to corresponding elements

import numpy as np

a = np.array([1, 2, 3, 4])
b = np.array([10, 20, 30, 40])

# Element-wise addition
print(a + b)  # Output: [11 22 33 44]

# Element-wise multiplication
print(a * b)  # Output: [10 40 90 160]

Universal Functions (uFuncs)

NumPy provides built-in functions (called ufuncs) designed to execute vectorized operations across entire arrays for more complex math

angles = np.array([0, np.pi/2, np.pi])

# Vectorized sine calculation
print(np.sin(angles))  # Output: [0.0000000e+00 1.0000000e+00 1.2246468e-16]

# Vectorized square root
values = np.array([4, 9, 16])
print(np.sqrt(values))  # Output: [2. 3. 4.]

Broadcasting (Different Shapes)

If you attempt arithmetic on two arrays with different shapes, NumPy uses its Broadcasting Rules to implicitly "stretch" the smaller array across the larger one so their dimensions match

matrix = np.array([[1, 2, 3], 
                   [4, 5, 6]])
row_vector = np.array([10, 20, 30])

# The row vector is automatically broadcasted down both rows of the matrix
print(matrix + row_vector)
# Output:
# [[11 22 33]
#  [14 25 36]]

Comparison Operators

In NumPy, comparison operators perform element-wise evaluations on arrays, returning a Boolean array (True or False) of the same shape.

Comparing an Array with a Scalar
NumPy automatically broadcasts the scalar value across every element in the array

import numpy as np

arr = np.array([10, 20, 30, 40])
print(arr > 25) 
# Output: [False False  True  True]

Comparing Two Arrays
Arrays must have matching or compatible shapes. The comparison happens between corresponding element pairs

a = np.array([1, 5, 3])
b = np.array([2, 4, 3])

print(a == b) 
# Output: [False False  True]

Filtering Data (Boolean Masking)
You can use the resulting Boolean array to index or filter the original array

arr = np.array([5, 12, 8, 21])
filtered_arr = arr[arr > 10]

print(filtered_arr) 
# Output: [12 21]

Combining Conditions

Standard Python logical operators (and, or) do not work on entire NumPy arrays. Instead, use bitwise operators (&, |, ~) or NumPy functions like np.logical_and(). Always wrap individual comparisons in parentheses

arr = np.array([5, 12, 18, 25])
# Find elements greater than 10 AND less than 20
mask = (arr > 10) & (arr < 20)

print(arr[mask]) 
# Output: [12 18]

Aggregate Functions

Aggregate functions in NumPy (also known as reductions) take an array of values and summarize them into a single value or a reduced set of values

prices = np.array([10, 25, 40, 15, 60])

print("--- 1D Array Basics ---")
print("Total Sum :", np.sum(prices))   # Adds all elements: 10 + 25 + 40 + 15 + 60
print("Average   :", np.mean(prices))  # Finds the average: 150 / 5
print("Lowest    :", np.min(prices))   # Finds the smallest value
print("Highest   :", np.max(prices))   # Finds the largest value

Filtering

np.where() and np.select() are conditional operations used to transform or filter data based on specific criteria. While np.where() evaluates a single condition to choose between two paths, np.select() evaluates an ordered list of multiple conditions to choose from multiple options.
The np.where(condition, x, y) function returns elements from x when the condition is True, and from y when it is False.

import numpy as np

arr = np.array([10, 20, 30, 40, 50])

# If an element is greater than 25, keep it; otherwise, replace it with 0
result = np.where(arr > 25, arr, 0)

print(result)
# Output: [ 0  0 30 40 50]

The np.select(condlist, choicelist, default=0) function maps an ordered list of conditions to a corresponding list of outcomes. It evaluates them in order and stops at the first True condition it hits

import numpy as np

arr = np.array([5, 15, 25, 35, 45])

# Define a list of criteria
conditions = [
    arr < 10,                 # Condition 1
    (arr >= 10) & (arr < 30), # Condition 2
    arr >= 30                 # Condition 3
]

# Define what to assign for each true condition
choices = [
    'Low',
    'Medium',
    'High'
]

# Apply the mapping, using a default value for unmatched entries
result = np.select(conditions, choices, default='Unknown')

print(result)
# Output: ['Low' 'Medium' 'Medium' 'High' 'High']

Conclusion

NumPy is the foundational library for scientific computing in Python, providing the essential structure for data science and machine learning. At its core is the ndarray, a multi-dimensional array object that enables lightning-fast mathematical computations by storing data in contiguous memory and using compiled C code. By supporting vectorized operations and broadcasting, it eliminates the need for slow, explicit Python loops, allowing developers to manipulate massive datasets efficiently. Because of this speed and versatility, NumPy serves as the critical backbone powering almost all major Python data libraries, including Pandas, SciPy, Scikit-learn, and TensorFlow.

These are ALL you NEED to get started with Python PANDAS

Lameck Odhiambo — Sun, 18 Oct 2026 04:47:51 +0000

Pandas is a Python library used for data manipulation, analysis, and cleaning. It provides fast and flexible data structures designed to work with tabular data (similar to an Excel spreadsheet or a SQL table)

Dataframes and Series

DataFrame: A 2-dimensional labeled data structure with rows and columns (a complete table)
Series: A 1-dimensional labeled array capable of holding any data type (like a single column in a spreadsheet).

Before getting started with pandas we need to install it first.

pip install pandas

import pandas as pd

# 1. Create a simple DataFrame
data = {
    'Name': ['Alice', 'Bob', 'Charlie'],
    'Age': [25, 30, 35],
    'City': ['New York', 'London', 'Paris']
}
df = pd.DataFrame(data)

# 2. Load data from an external file
# df = pd.read_csv('data.csv')

# 3. View the first 5 rows
print(df.head())

Reading files in pandas

CSV Files (.csv): Use pd.read_csv() to import comma-separated values.

df = pd.read_csv('data.csv')

Excel Spreadsheets (.xlsx, .xls): Use pd.read_excel() to load spreadsheets. You can specify a sheet using the sheet_name parameter.

df = pd.read_excel('budget.xlsx', sheet_name='Q1_Report')

JSON Data (.json): Use pd.read_json() to convert JSON strings or files into tabular format.

df = pd.read_json('users.json')

Parquet Files (.parquet): Use pd.read_parquet() for highly optimized, columnar storage files common in big data workflows.

df = pd.read_parquet('large_dataset.parquet')

SQL Database Tables: Use pd.read_sql() to pull data directly into Pandas via a database connection (e.g., utilizing an engine from the SQLAlchemy project)

import sqlalchemy
engine = sqlalchemy.create_engine('sqlite:///my_database.db')
df = pd.read_sql('SELECT * FROM employees', con=engine)

Exploratory Data Analysis (EDA)

Exploratory Data Analysis (EDA) using Pandas is the foundational step in any data science workflow. It allows you to understand the structure, distributions, relationships, and anomalies within a dataset before moving to modeling

.head()

first n rows of a DataFrame or Series. It is primarily used to quickly inspect and verify the structure, column names, and data types of a dataset after loading it.
Inside the brackets you can put the number of rows you want to inspect.

df.head()
df.head(10)

.tail

The df.tail() method in pandas returns the last n rows of a DataFrame or Series.

df.tail()

.shape

df.shape is an attribute that returns a tuple representing the dimensions of a DataFrame or Series. It provides a quick way to see how many rows and columns your dataset contains.

df1.shape

Output:

(5632, 27)

Structural & Descriptive Summaries

Before analyzing trends, verify how data types are registered and look at basic statistical summaries.

# Check data types, memory usage, and non-null counts
df.info()

Output:

# Summary statistics for numerical columns (mean, min, max, quartiles)
df.describe()

Output

# Summary statistics for ALL columns (including categorical frequencies)
df.describe(include="all")

Output

Exploring Single Variables

Examine individual variables to understand their distribution, frequency, and pull out any categorical unique counts

# For Categorical Data: Count frequencies of unique values
df["category_column"].value_counts()
df["category_column"].unique()  # List unique entries
df["category_column"].nunique()  # Total number of unique entries

# For Numerical Data: Quick pandas native plotting
df["numeric_column"].hist(bins=20)  # Check skewness and distribution
df["numeric_column"].plot(kind="box")  # Identify outliers

Data Cleaning

Before cleaning is done, a quick EDA must be done to know the areas to clean and what to clean. Below is a sample code to have a sneek- peek of what to actually clean.

# Find duplicate rows and drop them
print(df.duplicated().sum())
df.drop_duplicates(inplace=True)

# Find missing values
print(df.isnull().sum())

Deal with missing values

Missing values in a dataset can either be dropped or imputed depending on the size of the data, importance and number of missing values.
Here are some of the ways to deal with missing values:

df.dropna(subset=["critical_column"], inplace=True)  # Drop missing rows

df["numeric_column"] = df["numeric_column"].fillna(
    df["numeric_column"].median()
)  # Impute with median

Dealing with DataTypes

Values may be recorded in a datatype which may not be fit for them. In anycase this occurs, they can be changed to the correct datatypes.
Using pd.to_numeric() Best for converting text or mixed-type columns into numbers. Use errors='coerce' to turn unconvertible entries (like random text or symbols) into NaN.

df['price'] = pd.to_numeric(df['price'], errors='coerce')

Using pd.to_datetime() Converts date and time strings into proper datetime64 objects

df['sale_date'] = pd.to_datetime(df['sale_date'], errors='coerce')

Dealing with mixed date formats e.g dd/mm/yyyy, mm/dd/yyyy, yyyy/mm/dd

df1['order_date'] = pd.to_datetime(
    df1['order_date'],
    format='mixed',
    errors='coerce'
)

df1['payment_method'] = df1['payment_method'].str.strip().str.capitalize()

replace(), used when you want to change items inside a column to ensure consistency in values recorded and reliability.

df1['payment_method'] = df1['payment_method'].replace({
    'Mpesa' : 'M-pesa',
    'Visa': 'Card'
})

If the column has mixed characters and values for example here in unit_price, you can also use replace function to standardize the column and maybe change the datatype if need be.

df1['unit_price_kes'] = df1['unit_price_kes'].str.strip().str.replace(r'[^0-9]','', regex = True).astype(float)

Creating new columns

You can also be required to create a new column maybe from from a condition as below or from a calculation. In such a scenario, here's how to deal with it.

df1['phone_validity'] = np.where(df1['customer_phone'].astype(str).str.len() == 10, 'valid', 'invalid')

# Calculate total cost (multiplication)
df['total_cost'] = df['price'] * df['quantity']

The code above will create a new column called total_cost.

Deleting columns

You can delete columns from a DataFrame using .drop()

# deleting a single column
df = df.drop(columns=['B'])

#  deleting multiple columns
df = df.drop(columns=['C', 'D'])

Aggregation in pandas

Aggregations in Pandas reduce a collection of numerical or categorical values into a single summary value (such as a sum, mean, or count). You can perform these operations on an entire Pandas DataFrame, specific columns, or groups of data using the groupby()

# Clean, flat DataFrame output with custom column names
clean_summary = df.groupby('Department').agg(
    total_salary=('Salary', 'sum'),
    average_bonus=('Bonus', 'mean'),
    employee_count=('Employee', 'count')
).reset_index()

Concatenation and Merging in Pandas

Concatenation (pd.concat)

Use pd.concat() when your datasets have the same structure and you want to glue them together along an axis. • axis=0 (Default): Stacks DataFrames vertically (appends rows). • axis=1: Stacks DataFrames horizontally (appends columns) aligned by their index.

import pandas as pd

df1 = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
df2 = pd.DataFrame({'A': [5, 6], 'B': [7, 8]})

# Stack vertically (Row-wise)
vertical_stack = pd.concat([df1, df2], ignore_index=True)

# Stack horizontally (Column-wise)
horizontal_stack = pd.concat([df1, df2], axis=1)

Merging (pd.merge)

Use pd.merge() when you have different datasets that share a common identifier column (like an ID or SKU) and you want to align them side-by-side.

left = pd.DataFrame({'User_ID': [1, 2, 3], 'Name': ['Alice', 'Bob', 'Charlie']})
right = pd.DataFrame({'User_ID': [1, 2, 4], 'Salary': [50000, 60000, 70000]})

# Merge on a matching column
merged_df = pd.merge(left, right, on='User_ID', how='inner')

Saving the final dataframe

You can save a Pandas DataFrame to different file formats in Python using specific df.to_*() export methods

import pandas as pd

# Assume 'df' is your existing DataFrame
# 1. Save as CSV (excluding the default index)
df.to_csv("data.csv", index=False)

# 2. Save as Excel
df.to_excel("data.xlsx", index=False)

# 3. Save as JSON
df.to_json("data.json", orient="records")

# 4. Save as Parquet (requires pyarrow or fastparquet)
df.to_parquet("data.parquet")

# 5. Save as Pickle
df.to_pickle("data.pkl")

Conclusion

Python pandas is the foundational, industry-standard tool for modern data manipulation, cleaning, and analysis. Built around its core DataFrame and Series structures, it transforms raw, messy data into structured, tabular insights by providing powerful, intuitive functions for merging datasets, handling missing values, and performing complex aggregations like groupby. While it integrates seamlessly with the broader Python ecosystem—including NumPy, Matplotlib, and scikit-learn—pandas does suffer from high memory usage and reduced performance when processing massive, multi-gigabyte datasets. Despite these scaling limitations, it remains an indispensable cornerstone of data science workflows, unmatched for exploratory data analysis and rapid prototyping.

File Handling in Python

Lameck Odhiambo — Sat, 17 Oct 2026 03:32:08 +0000

File handling in Python is important as it allows you to create, read, update, and delete files directly from your code. Python manages these operations using a built-in open() function, which creates a file object to interact with the file system.

with Statement

This is best practice and recommended method for opening files in Python is using the with keyword. It automatically closes the file once the block of code finishes, even if errors occur. This prevents memory leaks and file corruption.

# The file closes automatically outside this block
with open("example.txt", "r") as file:
    content = file.read()
    print(content)

File Open Modes

The second argument of open() specifies the "mode" (how you want to interact with the file)

• "r" (Read): Default mode. Opens a file for reading. Throws a FileNotFoundError if the file doesn't exist.
• "w"(Write): Opens a file for writing. Overwrites existing content. Creates a new file if it doesn't exist.
• "a" (Append): Opens a file to add data to the end. It does not erase existing content. Creates a new file if it doesn't exist.
• "x" (Create): Creates a specific file. Returns an error if the file already exists.

Reading Files

.txt
Python provides several methods to extract text from an open file:
• read(size): Reads the entire file as a single string. You can pass an optional integer size to read only a specific number of characters.
• readline(): Reads just one line at a time. Helpful for reading large files line by line.
• readlines(): Reads all lines at once and returns them as a list of strings.
• Line Loop (Efficient): You can iterate directly over the file object using a loop, which is memory-efficient for large files.

# Reading line-by-line efficiently
with open("large_file.txt", "r") as file:
    for line in file:
        print(line.strip()) # strip() removes extra newlines

# Reading entire content at once
with open("example.txt", "r", encoding="utf-8") as file:
    content = file.read()
    print(content)

.json

Python converts JSON data directly into dictionaries and lists

import json

with open('data.json', 'r') as file:
  data = json.load(file)

print(data)

.csv

import csv

with open('data.csv', mode='r', encoding='utf-8') as file:
    # Create the reader object
    reader = csv.reader(file)

    # Optional: Skip the header row if your file has one
    header = next(reader) 

    for row in reader:
        # Each row is a list. Access columns by index (e.g., row[0])
        print(row)

Writing Files

.txt
To add content, open the file in write ("w") or append ("a") mode:
• write(string): Inserts a string into the file.
• writelines(list): Inserts a list of strings into the file all at once

lines_to_write = ["First line\n", "Second line\n"]

with open("output.txt", "w") as file:
    file.writelines(lines_to_write)

.json

import json

# Your data structure (Python dictionary)
user_data = {
    "name": "Alice Smith",
    "age": 30,
    "active": True,
    "roles": ["admin", "user"]
}

# Writing to a file
with open("user.json", "w") as file:
    json.dump(user_data, file)

.csv

import csv

# Data structured as a list of lists (rows)
data = [
    ["Name", "Age", "City"],
    ["Alice", 30, "New York"],
    ["Bob", 25, "Los Angeles"],
    ["Charlie", 35, "Chicago"]
]

# Open the file in write mode ('w')
with open('output.csv', mode='w', newline='', encoding='utf-8') as file:
    writer = csv.writer(file)

    # Write all rows at once
    writer.writerows(data)

Deleting and Deleting Files

For file system operations like deleting or renaming, you need to import Python's built-in os module

import os

# Delete a file safely
if os.path.exists("old_file.txt"):
    os.remove("old_file.txt")

Conclusion

File handling is critical because it enables data persistence, allowing programs to save information permanently to a storage disk so it isn't lost when the application closes or the system powers down. It serves as a universal bridge for software interoperability, letting different systems exchange data using standardized formats like CSV or JSON, and allows programs to efficiently stream massive datasets that are too large to fit into a computer's temporary memory (RAM). Additionally, it is essential for maintaining application configuration settings and generating long-term audit logs, making it a foundational tool for building functional, scalable, and secure software.

Decorators in Python

Lameck Odhiambo — Fri, 16 Oct 2026 11:04:10 +0000

Decorators in Python allow you to dynamically inject new functionality into a function without altering its internal logic. This powerful metaprogramming technique promotes clean, modular code by letting you reuse standard utilities like logging, authentication, and caching across multiple functions.

Basic decorator structure:

def my_decorator(func):
    def wrapper():
        print("Something is happening BEFORE the function is called.")
        func()  # Call the original function
        print("Something is happening AFTER the function is called.")
    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

say_hello()

Output:

Something is happening BEFORE the function is called.
Hello!
Something is happening AFTER the function is called.

If the function you are decorating accepts arguments, your inner wrapper function must be built to accept and pass them through using *args and **kwargs. This ensures your decorator remains flexible and can work on any function.

def log_arguments(func):
    def wrapper(*args, **kwargs):
        print(Log: Function '{func.__name__}' was called with inputs: {args} {kwargs}")
        return func(*args, **kwargs)  # Capture and return the original function's result
    return wrapper

@log_arguments
def add_numbers(a, b):
    return a + b

result = add_numbers(5, 10)

Real world application of Decorators

def pandas_decorator(fx):

    def mainfunc(*args):
        response = fx(*args)
        # Do some pandas specific processing here
        response.to_parquet("Ch-3_Polymorphism&Decorators\\temp.parquet")
        return response

    return mainfunc

@pandas_decorator
def csv_to_parquet(file_path:str):
    import pandas as pd
    df = pd.read_csv(file_path)
    return df


response = csv_to_parquet("Ch-3_Polymorphism&Decorators\\orders.csv")
print(response.head())

This code demonstrates how Python decorators can be used to add extra functionality to an existing function without changing its original logic. The pandas_decorator(fx) function takes another function as an argument, while its inner function, mainfunc(*args), accepts the arguments passed to the original function and executes it using fx(*args). The returned result is stored in response, which is a Pandas DataFrame. The decorator then uses response.to_parquet() to save the DataFrame as a Parquet file named temp.parquet before returning the DataFrame. The @pandas_decorator syntax applies this decorator to the csv_to_parquet() function, which uses pd.read_csv(file_path) to load data from orders.csv. Finally, response = csv_to_parquet(...) executes the decorated function, reads the CSV file, saves the data as Parquet, and returns the DataFrame, while print(response.head()) displays its first five rows. In summary, the decorator automates saving the DataFrame to Parquet while allowing the original function to continue returning the data for further analysis.

Python Object Oriented Programming(OOP)

Lameck Odhiambo — Tue, 13 Oct 2026 11:22:52 +0000

Object Oriented Programming(OOP) is a way of writing programs by modelling real-world things as "objects". Instead of writing code as a long list of instructions that act on separate variables, OOP groups related data(attributes) and behaviour (methods) together into a single object called an object.

Real world Analogy
Think about a real world car.

A car has attributes(color, fuel type, brand, max-speed) it can do things like(accelerate, braking, honk).
In OOP we would create a Car object that bundles those attributes and behaviours together, instead of tracking color, brand, fuel type, max-speed acceleration,braking etc as disconnected variables.

Four Pillars of OOP

Encapsulation
Inheritance
Polymorphism
Abstraction

Classes and Object

What is a class?

A class is a blueprint or template for creating objects. It defines what attributes(data) and methods(functions) the objects created from it will have. Note: A class does not hold any actual data itself, it only describes the shape that objects of that type will take.

a. Class Attributes
Defined directly inside the class body, outside of any method(function). They are shared by all objects of that class unless an individual object overrides them.

Example

class Dog:
    species = "Canis familiaris" # class attribute (Shared by all Dogs)

b. Instance attributes
Defined inside init(or any method) using self.attribute_name = value.
Each object gets its own independent copy.

class Dog:
    def __init__(self, name, breed):
        self.name = name # Instance attribute, unique per dog/instance of the class
        self.breed = breed # Instance attribute, unique per dog/instance of the class

Methods

Methods are functions defined inside a class. They define/describe the behaviours an object can perform. Like init, regular methods take 'self' as their first parameter so they can access and modify the object's own attributes.

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"The dog '{self.name}' of breed '{self.breed}' can reach a maximum speed of {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
The dog 'Bosco' of breed 'African Shepherd' can reach a maximum speed of 72km/h.

# German Shepherd Instance
german_shepherd = Dog("Max", "German Shepherd")

german_shepherd.bark()
german_shepherd.play(60)
german_shepherd.fact(56)

Output:

Max says: Woof!
Max played for 60 minutes
The dog 'Max' of breed 'German Shepherd' can reach a maximum speed of 56km/h.

MPESA Example

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

    def deposit(self, amount):
        self.balance += amount # self.balance = self.balance + amount
        print(f"You have successfully deposited KES {amount}, new acc balance KES {self.balance}")

    def withdraw(self, amount):
        self.balance -= amount # self.balance = self.balance - amount
        print(f"You have successfully withdrawn KES {amount}, new acc balance KES {self.balance}")

    def check_balance(self):
        print(f"Balance: KES {self.balance}")

emmanuel_acc = MpesaAccount("+254712345678", "Emmanuel", 0)
emmanuel_acc.deposit(500)

Output:

You have successfully deposited KES 500, new acc balance KES 500

emmanuel_acc.withdraw(250)

Output:

You have successfully withdrawn KES 250, new acc balance KES 250

emmanuel_acc.check_balance()

Output:

Balance: KES 250

Four Pillars Of Object Oriented Programming

1. Encapsulation

Encapsulation means bundling an object's data(attributes) and the methods that operate on that data into a single class, and restricting direct access to some of that data from outside the class. This protects the object's internal state from being change in unexpected or invalid ways.

In Python encapsulation is a convention rather a strict:

name - public, accessible from anywhere.
_name - protected, a signal to other developers "Don't touch this directly".
__name - private, Python renames it internally(name mangling) to discourage outside access.

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 <= 49:
            print("Deposit must be a minimum of KES 50.")
        else:
            self.__balance += amount
            print(f"You have successfully deposited {amount} ne acc bal is KES {self.__balance}")

    def withdraw(self, amount):  
        if amount > self.__balance:
            print("Insufficient Funds")
        else:
            self.__balance -= amount
            print(f"You have successfully withdrawn {amount} ne acc bal is KES {self.__balance}")

    def check_balance(self):
        return f"You account balance is KES {self.__balance}"

emmanuel_mpesa = MpesaAccount("Emm", "0701000000")
emmanuel_mpesa.deposit(150)

Output:

You have successfully deposited 150 ne acc bal is KES 150

2. Inheritance

Inheritance allows a new class to(child class/subclass/derived class) reuse the attributes and methods of an existing class(parent class/super class/base class).

# Parent Class
class PublicService:
    def __init__(self, reg_number, route):
        self.reg_number = reg_number
        self.route = route   

    def describe(self):
        return f"Vehicle registaration number {self.reg_number} plies the {self.route} route."

    def collect_fare(self, amount):
        return f"KES {amount} fare collected on {self.reg_number}."


# Child class 1   
class Matatu(PublicService):
    def __init__(self, reg_number, route, sacco_name, capacity):
        super().__init__(reg_number, route)
        self.sacco_name = sacco_name
        self.capacity = capacity

    def describe(self):
        return f"Vehicle registaration number {self.reg_number}, of the sacco {self.sacco_name} plies the {self.route} route."

kabuku = Matatu("KDQ 221Z", "Nairobi-Thika", "Super-Metro", 33)
kabuku.collect_fare(100)

Output:

'KES 100 fare collected on KDQ 221Z.'

# Child Class 2
class BodaBoda(PublicService):
    def __init__(self, reg_number, route, rider_name):
        super().__init__(reg_number, route)
        self.rider_name = rider_name

    # def describe(self):
    #     return f"Boda Boda {self.reg_number}, rider {self.rider_name} is on the {self.route} route"

bodaboda = BodaBoda("KMZT 300Z", "CBD-Upper-Hill", "Emmanuel")
bodaboda.describe()

Output:

'Vehicle registaration number KMZT 300Z plies the CBD-Upper-Hill route.'

Multi-level inheritance

Multilevel inheritance in Python is an object-oriented programming feature where a derived (child) class inherits from another derived class, forming a sequential, multi-generational chain (e.g., Grandparent → Parent → Child). This structure allows the deepest child class to automatically access all attributes and methods across the entire ancestor hierarchy
Also inherited attributes and methods without super() function - another way of inheriting attributes and methods besides using super() function.

class company:

    title:str = "consultancy"

    def __init__(self, company_name:str):
        self.company_name:str = company_name

    def info(self):
        print(f"Company Name: {self.company_name}")
        return f"Company Name: {self.company_name}"


class manager(company):

    def __init__(self, manager_name:str, company_name:str):

        self.manager_name = manager_name
        self.company_name = company_name

    def info(self):
        response = company.info(self)
        print(f"The manager : {self.manager_name}, {response} ")
        return f"The manager : {self.manager_name}, {response} "

class employee(manager):

    def __init__(self,employee_name:str, manager_name:str, company_name:str):

        self.employee_name = employee_name
        self.manager_name = manager_name
        self.company_name = company_name

    def info(self):
        response = manager.info(self)
        print(f"The employee : {self.employee_name}, {response} ")
        return f"The employee : {self.employee_name}, {response} "

obj = employee("John Doe", "Alice Johnson", "Tech Solutions")
obj.info()

Multiple Inheritance

Multiple inheritance is an object-oriented programming feature where a class inherits behaviors and attributes from more than one parent class

class company:

    title:str = "consultancy"

    def __init__(self, company_name:str):
        self.company_name:str = company_name

    def info(self):
        print(f"Company Name: {self.company_name}")
        return f"Company Name: {self.company_name}"


class employee(company):

    def __init__(self,employee_name:str, company_name:str):

        self.employee_name = employee_name
        self.company_name = company_name

    def info(self):
        response = company.info(self)
        print(f"The employee : {self.employee_name}, {response} ")


class contractor(company):

    def __init__(self, contractor_name:str, company_name:str):

        self.contractor_name = contractor_name
        self.company_name = company_name

    def info(self):
        response = company.info(self)
        print(f"The contractor : {self.contractor_name}, {response} ")


obj = employee("John Doe", "Tech Solutions")
obj.info()

obj2 = contractor("Jane Smith", "Tech Solutions")
obj2.info()

3. Polymorphism

Polymorphism(Greek word for "many forms") means objects of different classes can respond to the same method call in their own way. You call the same method name on different objects, and each one behaves according to its own class's implementation.

Python supports polymorphism naturally through method overriding(child classses redefine a parent's method as seen in the Delivery() and VanDelivery()).

4. Abstraction

Abstraction means hiding complicated implementation details and exposing only the essential features that a user of the class actually needs. IN python, abstraction is commonly implemented using the abc module to define abstract base classes. (Classes that define required methods but cannot be instantiated directly, forcing the subclasses/child classes to provide the actual implentation)

from abc import ABC, abstractmethod

# Parent Class
class Shape(ABC):  # Inherits from ABC, it cannot be instantiated

    @abstractmethod
    def area(self):
        pass            # No implementation on purpose

    @abstractmethod
    def perimeter(self):
        pass          # No implementation on purpose

# Child Class
class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        area = self.width * self.height

        return area

    def perimeter(self):
        perimeter = 2 * (self.height + self.width)
        return perimeter

rect = Rectangle(10, 6)

rect.area()

Output:

rectange = Shape()

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[69], line 1
----> 1 rectange = Shape()

TypeError: Can't instantiate abstract class Shape without an implementation for abstract methods 'area', 'perimeter'

Conclusion

Object-Oriented Programming (OOP) in Python is a powerful paradigm that shifts the programming focus from functions to structured objects, making software more modular, scalable, and maintainable. Because "everything in Python is an object," OOP is not just an optional tool; it forms the core DNA of the language and its most popular libraries.

Python Data Structures

Lameck Odhiambo — Sat, 10 Oct 2026 08:11:29 +0000

Python features four primary built-in data structures used for storing collections of data: lists, tuples, sets, and dictionaries. Each serves a specific purpose based on whether you need order, unique items, fast key-value lookups, or unchangeable data.

1. Lists

Lists are ordered, mutable arrays that can hold a mix of different data types. They track elements by their position, meaning you can access them using zero-based index values
Best used for your default choice for a general collection of items that you expect to change, sort, or append to.

Accessing list items through indexing and slicing

The syntax for slicing is list_name[start : end : step]

• start: The index where the slice begins (inclusive, defaults to 0).
• end: The index where the slice stops (exclusive, meaning this item is not included; defaults to the end of the list).
• step: The interval or step size between items (defaults to 1)

thislist = ["apple", "banana", "cherry"]
print(thislist[1])

This will print the second item in the list.

thislist = ["apple", "banana", "cherry"]
print(thislist[-1])

This prints the last item in the list

thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
print(thislist[2:5])

Returns the third, fourth, and fifth item

thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
print(thislist[:4])

This example returns the items from the beginning to, but NOT including, "kiwi"

Unpacking lists

List unpacking in Python is a clean, readable syntax that allows you to extract elements from a list (or any iterable) and assign them directly to variables

fruits = ["apple", "banana", "cherry"]

# The number of variables matches the list size
first, second, third = fruits

print(first)   # Output: apple
print(second)  # Output: banana
print(third)   # Output: cherry

Methods used in lists

List Comprehension

List comprehension is a concise, readable way to create new lists in Python by iterating over an existing iterable (like a list, tuple, range, or string). It serves as a shorter alternative to traditional for loops.
List comprehension offers a shorter syntax when you want to create a new list based on the values of an existing list.

Syntax:

newlist = [expression for item in iterable if condition == True]

Example

fruits = ["apple", "banana", "cherry", "kiwi", "mango"]

newlist = [x for x in fruits if "a" in x]

print(newlist)

Condition

The condition is like a filter that only accepts the items that evaluate to True.

fruits = ["apple", "banana", "cherry", "kiwi", "mango"]

newlist = [x for x in fruits if x != "apple"]

print(newlist)

Iterable

The iterable can be any iterable object, like a list, tuple, set etc.

newlist = [x for x in range(10)]

print(newlist)

Expression

The expression is the current item in the iteration, but it is also the outcome, which you can manipulate before it ends up like a list item in the new list:

fruits = ["apple", "banana", "cherry", "kiwi", "mango"]

newlist = [x.upper() for x in fruits]

print(newlist)

2. Tuples

A Python tuple is a built-in collection data type used to store an ordered and immutable (unchangeable) sequence of items. While they are very similar to lists, the core difference is that once a tuple is created, you cannot modify, add, or remove its elements.
Tuples are written with round brackets (), and elements are separated by commas. They can hold duplicate values and mixed data types.

Accessing Items

Use 0-based indexing or negative indexing.

fruits = ("apple", "banana", "cherry")
print(fruits[0])   # Output: apple
print(fruits[-1])  # Output: cherry (last item)

Slicing

Get a sub-part of the tuple using [start:stop:step]

numbers = (1, 2, 3, 4, 5)
print(numbers[1:4])  # Output: (2, 3, 4

)

Tuple Unpacking

You can easily extract the elements of a tuple back into individual variables.

coordinates = (4, 10)
x, y = coordinates
print(x)  # Output: 4
print(y)  # Output: 10

3. Sets

Sets are built-in data types used to store an unordered collection of unique items. Because sets enforce uniqueness, any duplicate values you attempt to add are automatically removed. Sets themselves are mutable (you can add or remove items), but the individual elements within the set must be of an immutable data type (like strings, integers, or tuples).

# Creating a set with elements
fruits = {"apple", "banana", "cherry", "apple"}
print(fruits)  # Output: {'banana', 'apple', 'cherry'} (Duplicates removed, order varies)

# Creating an empty set
empty_set = set()

Mathematical Set Operations

Python sets natively support classic mathematical operations, which can be called via methods or operators.

set_a = {1, 2, 3, 4}
set_b = {3, 4, 5, 6}

print(set_a | set_b)  # Output: {1, 2, 3, 4, 5, 6}
print(set_a & set_b)  # Output: {3, 4}
print(set_a - set_b)  # Output: {1, 2}
print(set_a ^ set_b)  # Output: {1, 2, 5, 6}

4. Dictionaries

A Python dictionary is a built-in, mutable data structure that stores data in key-value pairs. Instead of using a numeric index like a list, dictionaries use unique, immutable keys (like strings, numbers, or tuples) to quickly look up and retrieve values.

1. Creating a Dictionary

You can create a dictionary using curly braces {} or the built-in dict() constructor.

# Using curly braces
user = {
    "name": "Alice",
    "age": 30,
    "is_admin": True
}

# Using the dict() constructor
user_alt = dict(name="Alice", age=30, is_admin=True)

2. Accessing Values

You can access a value by placing its key inside square brackets []. Alternatively, the .get() method provides a safer way to access values because it returns None (instead of throwing a KeyError) if the key doesn't exist.

# Square bracket lookup
print(user["name"])  # Output: Alice

# Safe lookup with .get()
print(user.get("email"))        # Output: None
print(user.get("email", "N/A")) # Output: N/A (with a fallback default)

3. Adding and Updating Items

Because dictionaries are mutable, you can add new key-value pairs or change existing ones using the assignment operator (=) or the .update() method. Keys must be unique; assigning a new value to an existing key will overwrite it.

# Adding a new key-value pair
user["email"] = "alice@example.com"

# Updating an existing value
user["age"] = 31

# Updating multiple values at once
user.update({"age": 32, "city": "New York"})

4. Removing Items

Python offers several ways to delete entries based on your specific needs.

# .pop() removes a key and returns its value
age = user.pop("age")

# .popitem() removes and returns the last inserted key-value pair
last_item = user.popitem()

# 'del' statement deletes an item directly
del user["is_admin"]

# .clear() empties the entire dictionary
user.clear()

5. Iterating Through Dictionaries

By default, looping over a dictionary iterates through its keys. You can use specific methods to target keys, values, or both simultaneously.

my_dict = {"a": 1, "b": 2, "c": 3}

# Loop through keys
for key in my_dict.keys():
    print(key)

# Loop through values
for value in my_dict.values():
    print(value)

# Loop through both keys and values (most common)
for key, value in my_dict.items():
    print(f"Key: {key}, Value: {value}")

Conclusion

In conclusion, choosing the right built-in data structure in Python depends entirely on your data's requirement for order, mutability, uniqueness, and structural relationship. Selecting the correct collection optimizes memory usage, enhances execution speed, and prevents logical bugs.

Python Functions

Lameck Odhiambo — Sat, 03 Oct 2026 07:54:23 +0000

Python functions are reusable blocks of code designed to perform a specific task. They help prevent code repetition, break complex programs into smaller manageable pieces, and only run when explicitly called.

Basic Syntax - Defining and Calling a Function

Functions are defined using the def keyword, followed by a custom name, parentheses (), and a colon :. The body of the function must be indented.

# 1. Defining the function
def greet():
    print("Hello! Welcome to Python.")

# 2. Calling the function
greet()

Parameter vs Arguments

Parameters are names used in a function defination that describes what data the function expects.
Arguments are the actual values passed in a function call that are assigned to parameters.

def greet_user(username):  # username is a parameter
    print(f"Hello, {username}!")

greet_user("Alice")       # "Alice" is an argument

Core Argument Types

Positional

Values map directly to parameters based on the order they are written.

# 'name' is the first parameter, 'age' is the second
def greet(name, age):
    print(f"Hello {name}, you are {age} years old.")

# Calling the function using positional arguments
greet("Alice", 25)  
# Output: Hello Alice, you are 25 years old.

Keyword

Keyword argument (or named argument) is an argument passed to a function by explicitly stating the parameter name and its value using the syntax parameter_name = value

def greet_user(name, greeting, punctuation="!"):
    return f"{greeting}, {name}{punctuation}"

# 1. Standard positional call (order matters)
print(greet_user("Alice", "Hello"))  # Output: Hello, Alice!

# 2. Keyword argument call (order doesn't matter)
print(greet_user(greeting="Hi", name="Bob"))  # Output: Hi, Bob!

# 3. Mixing both (positional MUST come first)
print(greet_user("Charlie", greeting="Welcome", punctuation="."))  # Output: Welcome, Charlie.

Default argument

Default argument is a fallback value assigned to a function parameter during its definition. If you omit that argument when calling the function, Python automatically uses this predefined default value; if you provide a value, it overrides the default

def greet(name="Guest"):
    print(f"Hello, {name}!")

greet()        # Output: Hello, Guest! (Uses default)
greet("Alice") # Output: Hello, Alice! (Overrides default)

Args

*args is a special syntax used in function definitions to allow a function to accept a variable number of positional arguments.

def multiply_all(*args):
    result = 1
    # args is treated as a tuple: (2, 3, 4)
    for number in args:
        result *= number
    return result

# You can call the function with any number of inputs
print(multiply_all(2, 3))        # Output: 6
print(multiply_all(2, 3, 4, 5))  # Output: 120

Kwargs

**kwargs stands for keyword arguments. It is a special syntax used in function definitions to allow a function to accept an arbitrary (variable) number of named arguments
The values are stored in a dictionary.

def display_info(**kwargs):
    # kwargs is a dictionary inside the function
    print(kwargs) 

# Calling the function with different keyword arguments
display_info(name="Alice", age=30, city="New York")
# Output: {'name': 'Alice', 'age': 30, 'city': 'New York'}

Return Values

Use the return statement to exit a function and send data back to the program. If no return statement is defined, the function automatically returns None.

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

result = add_numbers(5, 10)
print(result)  # Output: 15

You can return multiple values by separating them with commas. Python automatically packs them into a tuple, which you can then unpack into separate variables

def get_user_data():
    name = "Bob"
    age = 25
    return name, age  # Returns a tuple: ("Bob", 25)

user_name, user_age = get_user_data()  # Unpacking
print(user_name)  # Output: Bob

Lambda Functions

In Python, a lambda function is a small, anonymous (unnamed) function that is defined in a single line of code. It is created using the lambda keyword and is typically used for short, temporary operations.

Syntax:

lambda arguments: expression

Examples

# Regular function
def add_ten_def(x):
    return x + 10

# Lambda function
add_ten = lambda x: x + 10

print(add_ten(5))  # Output: 15

add = lambda x, y: x + y
print(add(3, 5))  # Output: 8

Using with filter()

Filters an iterable by keeping only elements that return True for a specific condition

numbers = [1, 2, 3, 4, 5, 6]
# Keep only even numbers
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)  # Output: [2, 4, 6]

Using with map()

Applies a transformation to every element in an iterable

numbers = [1, 2, 3, 4]
# Square each number
squared = list(map(lambda x: x ** 2, numbers))
print(squared)  # Output: [1, 4, 9, 16]

Conclusion

Python functions are the fundamental building blocks of clean, efficient, and reusable code. They allow developers to group a specific block of logic together, reducing repetition and making complex programs manageable.

Python Loops

Lameck Odhiambo — Sat, 26 Sep 2026 11:09:13 +0000

Introduction

Loops control the flow of a code, repeats a block of code until a condition is met.
In Python, loops are used to repeatedly execute a block of code. Python provides two main types of loops: for loops and while loops

Iterables : An object/collection that can return its elements one at a time allowing it to be iterated in a loop.

For loops

A for loop is used for iterating over a sequence (that is either a list, a tuple, a dictionary, a set, or a string).
Goes through a list of item one by one, to do something for each item.

fruits = ["apple", "banana", "cherry"]
for x in fruits:
  print(x)

Output:

apple
banana
cherry

For loop ends immediately it reaches the last item in the collection; for example in this case, when it reached cherry - the last item, it automatically ends the loop.

Looping Through a String

Even strings are iterable objects, they contain a sequence of characters.

for x in "banana":
  print(x)

Output

b
a
n
a
n
a

Python Looping Through a Range

To loop through a set of code a specified number of times, we can use the range() function, The range() function returns a sequence of numbers, starting from 0 by default, and increments by 1 (by default), and ends at a specified number.

for x in range(6):
  print(x)

Output:

The range() function defaults to 0 as a starting value, however it is possible to specify the starting value by adding a parameter: range(2, 6), which means values from 2 to 6 (but not including 6)
The range() function defaults to increment the sequence by 1, however it is possible to specify the increment value by adding a third parameter: range(2, 30, 3)

Break statement

With the break statement we can stop the loop before it has looped through all the items, if a condition is met.

fruits = ["apple", "banana", "cherry"]
for x in fruits:
  print(x)
  if x == "banana":
    break

Once a condition is met in the loop, then it will stop at that condition and will not loop over the remaining items in the iterable.
In this case it will stop at the banana and will not loop upto the cherry.

Output:

apple
banana

Continue statement

Continue statement is used to skip an item in an iterable when it matches the condition given and continue on to loop over the others.

fruits = ["apple", "banana", "cherry"]
for x in fruits:
  if x == "banana":
    continue
  print(x)

In this case it will print all items in the iterable but banana.

Output:

apple
cherry

Nested Loops

A nested loop is a loop inside a loop.
For every outer loop print all the inner loop. The "inner loop" will be executed one time for each iteration of the "outer loop".
Round one of the outer loop prints all items in the inner loop.

adj = ["red", "big", "tasty"]
fruits = ["apple", "banana", "cherry"]

for x in adj:
  for y in fruits:
    print(x, y)

Output:

red apple
red banana
red cherry
big apple
big banana
big cherry
tasty apple
tasty banana
tasty cherry

While Loops

With the while loop we can execute a set of statements as long as a condition is true.
Break and continue statements can also be used here.

While Condition

i = 1
while i < 6:
  print(i)
  i += 1

output:

The loop will continue as long as its i is under 6 is True but when it becomes greater than 6 it becomes False and hence breaks the loop and stops.

While True

It creates an infinite loop, meaning the code inside it will repeat indefinitely because the condition is permanently set to True.To stop a while True: loop, you must explicitly exit it from the inside—usually by using a break statement when a certain condition is met.

Common Use Cases

Validating User Input: Keep asking the user for data until they provide a valid response.
Game Loops or Event Listeners: Keep a program running continuously to listen for user actions, network data, or events.
Emulating a "Do-While" Loop: Forcing a block of code to run at least once before checking an exit condition

while True:
    user_input = input("Type 'exit' to stop the loop: ")

    if user_input.lower() == 'exit':
        print("Exiting the loop...")
        break  # Immediately exits the loop

    print(f"You typed: {user_input}")

If you forget to include a break statement (or if your if condition can never be met), the loop will run forever and lock up your program.
You can stop it by pressing Ctrl + C to force-kill the program.

Difference between while condition and while true

While condition exits normaly when the condition is false, while true must have if and break statements
While condition is safer and more readable, while true has risks of infinite loop and is more flexible
While condition is used in counters and retries, while true is used when getting response from databases, APIs or stream

Difference between for loops and while loops

For loops loop over a fixed sequence, while loops loop while the condition is true
For loops uses predefined condition, while loops uses your condition
For loops number of iteration is known, while loop number of iteration is unknown

Enumerate

The enumerate() function in Python adds a counter to an iterable (like a list, tuple, or string) and returns it as an enumerate object. This allows you to loop through a collection while keeping track of both the index and the value simultaneously, eliminating the need to manage a counter variable manually.

fruits = ["apple", "banana", "cherry"]

for count, fruit in enumerate(fruits, start=1):
    print(f"Line {count}: {fruit}")

Output:

Line 1: apple
Line 2: banana
Line 3: cherry

Conclusion

Loops in Python are essential control flow structures that allow you to execute a block of code repeatedly, eliminating the need for redundant code and making programs more efficient. Python primarily relies on two types of loops: for loops (for iterating over a known sequence or iterable) and while loops (for repeating code as long as a specific condition remains true).

Python basics, Operators and Conditions

Lameck Odhiambo — Sun, 20 Sep 2026 08:57:36 +0000

Introduction

Python is a high-level language (its closer to the natural language such as English compared to C++, Assembly which are low level languages - closer to the Machine language), general-purpose programming language known for its clear syntax and readability.

How python works

Python code in your source code is Compiled, the converted to Byte Code (which is a low level language) then to a Virtual Machine (which converts the code to 1s and 0s to be understood by the machine) after these steps the Output is produced.
The step from compiler to virtual machine is called Interpreter

Common Uses

Python is applied across many different industries and technical fields:

Web Development: Building server-side applications with frameworks like Django and FastAPI.
Data Science & Machine Learning: Processing numbers and training models using Pandas, NumPy, and PyTorch.
Automation: Writing simple scripts to handle repetitive daily file management or data entry tasks

Getting started with Python

Print()

Print() function displays values or text on the screen. It shows the result of a particular program that was run. Basically it displays an output of a program.

print("Hello World")

You can also use single quotes

print('Hello World')

A variable can also be printed as shown but in this case we do not use quatation

age = 30 print(age)

Variables

Variables are containers or box holding a particular value. It can be text, number or a float

first_name = 'Lameck' 
first_name = "Lameck"

print(first_name)

first_name here is a variable.

Data types in Python

Strings

Strings are surrounded by either single quatation marks or double quatation.

first_name = 'Lameck' 
first_name = "Lameck"

print(first_name)

'Lameck' here is a string

Integer

Integers are whole numbers and are not inside any quatatation.

age = 30
quantity = 3
number_of_students = 68

Float

Float are numbers containing a decimal point, also they are not put inside quatations.

price = 10.99
weight = 75.3

Booleans

These are True of False values. The are also not put inside the quatations and the first letters must be capital.

is_student = True
is_adult = False

Type Casting

Type casting is converting a variable to another data type. For example converting a float to an integer or a string to an integer and so forth.

gpa = 3.2
new_gpa = int(gpa)
print(new_gpa)

age = 32
new_age = float(age)
print(new_age)

F - Strings / String formatting

Format strings, f-strings or String formatting inserts variables, expressions, or specific formatting rules directly into a text string.

age = 33
name = "Nashon"
print(f"{name} is {age} years old.")

Input()

This is a function that prompts the user to enter data. It returns the entered value as a string.

name = input("Enter your name: ")
print(f"Hello {name}")

Operators in Python

1. Arithmetic operators

Used to perform standard mathematical calculations

2. Comparison (Relational) Operators

Used to compare two values. They always return a Boolean value: either True or False

3. Logical Operators

Used to combine conditional statements

and: Returns True if both statements are true

or: Returns True if at least one statement is true

not: Inverts the result (returns False if the result is true)

4. Membership Operators

Used to test if a sequence (like a string, list, or tuple) is present in an object.

in: Returns True if a sequence with the specified value is present in the object (e.g., 'a' in 'apple' → True).

not in: Returns True if a sequence with the specified value is not present in the object.

5. Identity Operators

Used to compare objects, not if they are equal, but if they are actually the same object with the same memory location.

is: Returns True if both variables point to the same object.

is not: Returns True if both variables do not point to the same object.

Conditions in Python

Conditional statements control the flow of execution by evaluating expressions to either True or False.
Operators discussed above can be used within these conditional statements.

1. The if Statement

Executes a block of code only if the condition evaluates to True

age = 20
if age >= 18:
    print("You are an adult.")  # Runs because the condition is True

2. The if-else Statement

Executes one block if the condition is True, and an alternate block if it is False

score = 45
if score >= 50:
    print("Passed")
else:
    print("Failed")

3. The if-elif-else Chain

Used to evaluate multiple sequential conditions. It stops evaluating as soon as it finds the first True condition

temperature = 25

if temperature > 30:
    print("It's hot.")
elif temperature >= 15:
    print("It's warm.")  # Runs and skips the rest
else:
    print("It's cold.")

Nested Conditions

Nested conditionals occur when you place a conditional statement (if, elif, or else) inside another conditional statement. They are used to test a secondary condition only after a primary condition has already passed.

is_logged_in = True
age = 20

if is_logged_in:
    print("User is authenticated.")

    # Secondary check inside the first one
    if age >= 21:
        print("Purchase approved.")
    else:
        print("Purchase denied: You must be at least 21.")

else:
    print("Purchase denied: Please log in first.")

Conclusion

Python operators and conditional statements are the fundamental building blocks that give programs the ability to process data, make decisions, and control execution flow.

Window Functions in SQL

Lameck Odhiambo — Tue, 15 Sep 2026 12:29:10 +0000

SQL window functions perform calculations across a set of table rows that are related to the current row - window functions allow you to perform advanced data analysis (like calculating running totals, rankings, or moving averages) on a specific group of related rows without losing the details of individual rows. Unlike regular aggregate functions (GROUP BY), window functions do not collapse your rows into a single output row; every individual row retains its separate identity while displaying the calculated value.
A window function performs a calculation across a set of table rows that are somehow related to the current row. This is comparable to the type of calculation that can be done with an aggregate function. But unlike regular aggregate functions, use of a window function does not cause rows to become grouped into a single output row — the rows retain their separate identities. Behind the scenes, the window function is able to access more than just the current row of the query result.
They are commonly used for tasks like aggregates, rankings and running totals. The OVER clause defines the “window” of rows for the calculation

Window function syntax

The defining element of a window function is the OVER() clause.

PARTITION BY: Divides the rows into groups or "partitions" (similar to GROUP BY, but without collapsing rows). If omitted, the function treats the entire table as one single group.

ORDER BY: Dictates the sequence in which the rows are processed within each partition. Crucial for running totals, moving averages, and rankings.

ROWS/RANGE (Frame Clause): Further subsets the rows within the partition (e.g., "only the last 3 rows up to the current row").

Common types of Window Functions

1. Aggregate Window Functions
These perform standard math calculations but keep the row-level detail intact
SUM(), AVG(), COUNT(), MIN(), MAX()

SUM()

select 
      t.rider_id,
      t.trip_id, 
      t.fare,
      sum(fare) over(partition by rider_id) as rider_spend
from safari.trips t;

AVG()

select
    t.rider_id,
    t.trip_id,
    t.fare,
    avg(t.fare) over(partition by t.rider_id) as rider_avg_fare
from safari.trips t ;

COUNT()

select 
    t.trip_id,
    t.fare,
    count(*) over() as driv_tt_trip_count
from safari.trips t 
where t.driver_id = 2
order by t.trip_id;

2. Ranking Window Functions
Used to assign a sequential rank or number to rows based on a specific order.

ROW_NUMBER(): Assigns a unique, sequential integer to every row starting at 1.

select 
    t.driver_id, 
    t.trip_id,
    t.trip_date, 
    row_number() over(partition by driver_id) as fare_rank
from safari.trips t;

RANK(): Assigns ranks, but skips numbers if there are duplicate values (e.g., 1, 2, 2, 4).

select
      d.driver_id,
      d.driver_name,
      rank() over(partition by driver__id) as driver_rank
from safari.drivers d;

DENSE_RANK(): Assigns ranks, but does not skip numbers for duplicates (e.g., 1, 2, 2, 3).

select
      name, 
      department, 
      salary,
      dense_rank() over (partition by department order by salary desc) as emp_dense_rank
from employee;

3. Value & Offset Functions
Used to grab values from other rows relative to the current row without doing math.

LAG(): Fetches data from a previous row (great for calculating month-over-month growth).

select
    t.trip_date,
    t.fare,
    lag(t.fare) over(partition by t.driver_id order by t.trip_date ) as prev_fare
from safari.trips t
order by t.trip_date asc;

LEAD(): Fetches data from a subsequent row.

select 
    t.trip_id,
    t.trip_date,
    t.rider_rating,
    lead(t.rider_rating) over(partition by t.rider_id order by t.trip_date) as next_trip
from safari.trips t 
where t.rider_id = 2;

FIRST_VALUE() / LAST_VALUE(): Grabs the very first or very last value in the partitioN

Functions in SQL

Lameck Odhiambo — Fri, 11 Sep 2026 12:19:54 +0000

SQL functions are built-in, reusable blocks of code that accept input values, manipulate or perform calculations on them, and return a specific output. They make writing queries significantly easier by handling complex formatting, transformations, and math directly inside the database engine.SQL functions are broadly divided into two major execution types: Single-Row (Scalar) Functions and Multi-Row (Aggregate/Window) Functions

Multi-Row (Aggregate) Functions
These functions look at a set of values across multiple rows and condense them down into a single, summarized output. They are frequently paired with the GROUP BY clause.

SUM(): Adds all numeric values in a column together.

AVG(): Calculates the average value of a set.

COUNT(): Returns the total number of rows or non-null values.

MAX() / MIN(): Returns the highest or lowest value in a group

SELECT Department, COUNT(EmployeeID), AVG(Salary)
FROM Employees
GROUP BY Department;

Single-Row (Scalar) Functions

These functions operate on an individual value in a single row and return exactly one result per row. They are widely used for data cleaning and formatting.

LOWER() / UPPER(): Converts text to lowercase or uppercase.

CONCAT(): Joins two or more strings together.

SUBSTRING() / SUBSTR(): Extracts a specific section of text.

LENGTH() / LEN(): Returns the total character count of a string.

Mathematical / Numeric Functions

Used to handle arithmetic operations

ROUND(): Rounds a number to a designated decimal place.

ABS(): Returns the absolute (positive) value of a number.

CEILING() / FLOOR(): Rounds a number up or down to the nearest integer.

Date and Time Functions

Used to manage calendar inputs, timelines, and intervals:

NOW() / CURRENT_TIMESTAMP: Pulls the database server's exact current date and time.

DATEDIFF(): Calculates the difference in days/months/years between two dates.

DATE_ADD(): Adds a time interval (e.g., 30 days) to an existing date.

SELECT UPPER(FirstName), ROUND(Bonus, 2), NOW() 
FROM Employees;

Subqueries and CTEs in SQL

Lameck Odhiambo — Thu, 10 Sep 2026 12:43:15 +0000

Subqueries

From what I understand, a subquery is a query within a query.Subquery (also known as an inner query or nested query) is simply a SQL query embedded inside another SQL statement. It is used to fetch an intermediate dataset that the main (outer) query can use to filter, calculate, or manipulate data.

Common locations of Subqueries

1. In the WHERE Clause (Dynamic Filtering)

This filters rows based on a calculation or a list generated by the inner query.

-- Finds all employees who make more than the company average
SELECT name, salary 
FROM employees 
WHERE salary > (SELECT AVG(salary) FROM employees);

2. In the FROM Clause (Derived Tables)

The subquery acts like a temporary table that the outer query selects data from. These must be given a table alias

-- Treats the subquery results as a temporary table named "dept_salaries"
SELECT department_id, max_salary
FROM (SELECT department_id, MAX(salary) AS max_salary FROM employees GROUP BY department_id) AS dept_salaries
WHERE max_salary > 100000;

3. In the SELECT Clause

Calculates a single value to display as a standalone column alongside individual row data

-- Shows each employee's salary right next to the overall company average
SELECT name, salary, (SELECT AVG(salary) FROM employees) AS overall_average
FROM employees;

Important to know:

Isolating a single calculation or subset to filter main data.
Can only return columns from the outer table
Easier to read for multi-step, sequential logic.
Can be slower if highly nested or poorly optimized by the engine.

CTEs

In PostgreSQL, a Common Table Expression (CTE) is a temporary result set that you can reference within a larger SQL statement (SELECT, INSERT, UPDATE, or DELETE). They act like temporary tables that exist only for the duration of a single query execution, making complex queries much easier to write, read, and maintain.

1. Basic CTE Syntax

A standard CTE begins with the WITH keyword, followed by the CTE name and the inner query.

WITH regional_sales AS (
    SELECT region, SUM(amount) AS total_sales
    FROM orders
    GROUP BY region
)
SELECT region, total_sales
FROM regional_sales
WHERE total_sales > 10000;

2. Chaining Multiple CTEs

You can define multiple CTEs sequentially by separating them with a comma. A later CTE can even reference a previously defined CTE within the same query.

WITH total_orders AS (
    SELECT customer_id, COUNT(*) AS order_count
    FROM orders
    GROUP BY customer_id
),
top_customers AS (
    SELECT customer_id 
    FROM total_orders
    WHERE order_count > 5
)
SELECT name, email 
FROM customers 
WHERE id IN (SELECT customer_id FROM top_customers);