DEV Community: Maureen Kipkosgei

Making Decisions in Python: Operators and Conditional Logic

Maureen Kipkosgei — Fri, 18 Sep 2026 11:22:14 +0000

Every program eventually has to make a choice, charge tax or don't, grant access or deny it, show one message instead of another. Python makes these decisions using a small set of tools that work together: operators that compute or compare values, and if/else statements that act on the result. This article covers all of them, and how they combine to give your code the ability to respond differently depending on the situation.

Arithmetic Operators: Doing the Math

These are the operators you likely already recognize, plus a couple that are easy to overlook.

a, b = 7, 2

a + b   # 9  - addition
a - b   # 5  - subtraction
a * b   # 14 - multiplication
a / b   # 3.5 - division (always returns a float)
a // b  # 3  - floor division (drops the remainder)
a % b   # 1 - modulus (the remainder)
a ** b  # 49 - exponent ( 7 squared)

// and % are the two operators that are forgotten. // is how you get a whole number (like splitting items evenly), and % is how you check things like even or odd, or wrap a value around a fixed range:

total_items = 23
items_per_box = 5

boxes = total_items // items_per_box  # 4 full boxes
leftover = total_items % items_per_box   # 3 items left over

Comparison Operators: Asking Questions About Values

Comparison operators do not calculate a new value, they ask a yes/ no question and return True or False.

== - equal to
!= - not equal to
> - greater than
< - less than
>= - greater than or equal to
<= - less than or equal to

x, y = 10, 20
x == y       # False   
x != y       # True
x > y        # False
x < y        # True
x >= 10      # True 
x <= 5       # False

A common early mistake is confusing =(assignment) with ==(comparison):

x = 5   # assigns 5 to x
x == 5  # asks: is x equal to 5? True

This distinction matters because it's the difference between setting a value and checking one, mixing them up is one of the most common early bugs in any language, not just Python.

Logical Operators: Combining Conditions

Logical operators let you combine multiple True/ False conditions into one.

and - returns true only if both conditions on either side of it are true. If one condition is false the whole thing becomes false. Useful for requirements that must all be met (old enough and has id).

age = 20
has_id = True

age >= 18 and has_id # True - both conditions are true
age <= 18 and has_id # False - both conditions are not true.

or - returns true if at least one of the conditions is true. Returns false if every condition is false. Useful for alternative paths to the same outcome ( has a membership card or is a first-time visitor).

is_student = True
is_senior = False

is_student or is_senior # True - at least one condition is true

not - reverses the result. It turns true into false and vice versa. Useful for checking the absence of something.

is_raining = False

not is_raining # True - flips False to True (or vice versa)

Combining the operators:

is_weekend = True
is_holiday = False
has_ticket True

can_enter = (is_weekend or is_holiday) and has_ticket
print(can_enter)   # True

If Else Statements: Acting on the Result

Operators produce True or False. if statements are what you actually do with that answer.
The if-else statement is used to execute one block of code when a condition is True and another block when the condition is False. It helps programs make decisions based on different conditions.

Example:

score = 75

if score >= 50:
    print("Congragulations! You passed")
else:
    print("Sorry! You did not pass. Try again")

# Output

Congragulations! You passed

When there are more than two possible outcomes, elif ("else if") lets you check additional conditions in order:

score = 75 

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 - Fail")

# Output
GRADE B - Good

How this works: Python checks each condition top to bottom and stops at the first one that is True. Since 75 >= 80 is False, it moves to the next condition, 75 >= 70 is True, so grade becomes B and every condition after that is skipped.

Order Matters in Condition Statements

score = 75

if score >= 50:
    print("GRADE D - Average")
elif score >= 70:
    print("GRADE B - Good")
else: 
    print("GRADE F - Fail")

# Output
GRADE D - Average

Here, grade ends up as D, not B because 75 >= 50 is checked first, matches, and the rest is skipped.

Nesting Conditions

if statements can live inside other if statements, which is useful when a decision only makes sense after another one has already been settled.

Basic nested if example:

passed_test = True
age = 16

if passed_test:
    # This inner check only happens if passed_test is True
    if age >= 18:
        print("You can get your driving license!")
    else:
        print("You passed, but you are too young to drive.")
else:
    print("You need to pass the test first.")

# Output
You passed, but you are too young to drive.

Multiple Levels nesting:

username = "admin"
password = "Python145!"
two_factor_code = 1287

if username == "admin":
    if password == "Python145!":
        if two_factor_code == 1287:
            print("Welcome admin.")
        else: 
            print("Invalid 2FA code.")
    else:
        print("Incorrect Password.")
else:
    print("User not found.")

You can frequently flatten nested if statements by combining conditions with the logical and operator.

Example:

passed_test = True
age = 16

if passed_test and age >= 18:
    print("You can get your driving license!")
elif passed_test and age < 18:
    print("You passed, but you are too young to drive.")
else:
     print("You need to pass the test first.")

Practical Example

Here is an example combining operators and conditionals.

account = input("Enter your account type (basic/premium): ")
amount = int(input("Enter amount to send (Ksh): "))

if account == "basic" and amount <= 70000:
    print("Transaction approved")
elif account == "basic" and amount > 70000:
    print("Limit exceeded for basic account(max Ksh 70000)")
elif account == "premium" and amount <= 300000:
    print("Transcation approved")
elif account == "premium" and amount > 300000:
    print("Limit exceed for premium account (max Ksh 300000)")
else:
    print("Unknown account type")

Output

Enter your account type (basic/premium): basic
Enter amount to send (Ksh): 100000
Limit exceeded for basic account(max Ksh 70000)

Conclusion
Operators and conditionals are two halves of the same skill: operators produce an answer, and if/else decides what to do with it. Nearly every piece of interesting program behavior: validation, pricing, access control, game rules comes down to combinations of these tools.

Write Once, Run Many: Understanding Python Loops

Maureen Kipkosgei — Wed, 16 Sep 2026 09:46:08 +0000

A loop is a programming structure that is used to execute a block of code repeatedly. In Python, loops are essential for automating repetitive tasks, processing collections of data, and creating efficient, concise code. Rather than writing the same instructions over and over, loops let you write them once and let the computer repeat it as many times as necessary. This article covers how loops work in python, but more importantly, why they matter.

Problems Loops Solve

Imagine you need to print the numbers 1 through 5. Without loops you would write:

print(1)
print(2)
print(3)
print(4)
print(5)

That works. Now imagine printing 1 through 1,000 or a million or a number you do not know in advance, because it depends on how many rows are in a file a user uploads.
This is where approach breaks down completely. You can't write code for a quantity you do not know yet, and you shouldn't write a thousand near identical lines even when you do.
A loop replaces all:

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

Change 6 to 10000001 and the code doesn't get any longer. That is the fundamental purpose of a loop, the length of your code stops depending on the size of your data.

Loops Separate Logic From Volume

When writing a loop, you are separating what should happen from how many times it should happen.

Example:

for customer in customers:
    print(customer)

The print statement is written once. The volume (however many customers exist) is handled independently. If the business grows from 10 to 10,000 customers the code does not change.

For Loop

A for loop is used to iterate over a sequence like (list, tuple, string or range). It executes a specific number of times based on how many items are in the sequence.

students = ["Amina","Brian","Njeri","Faith","Otieno","Wanjiku","Fatuma"]
for student in students:
    print(f"Good morning, {student}"

# output
Good morning, Amina
Good morning, Brian
Good morning, Njeri
Good morning, Faith
Good morning, Otieno
Good morning, Wanjiku
Good morning, Fatuma

The variable student acts as a placeholder that automatically updates to the next item in the list during each iteration of the loop.

Range()

range() is a function that is used to generate a sequence of numbers. The range() function takes up three arguments range(start, stop, step).

With One Argument range(stop): The range will start at 0 and count up by 1 and stops before it reaches the stop number.

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

# Output
0
1
2
3
4

With Two Arguments range(start, stop):

for i in range(3,8):
    print(i)

# Output
3
4
5
6
7

With Three Arguments range(start, stop, step):

The third number tells Python how much to add to the number during each round of the loop.

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

# Output
1
3
5
7
9

Counting Backwards:

You can count down by using a negative step value. When counting backwards the start value should be greater than the stop value.

for i in range (5,0,-1):
    print(i)

# Output
5
4
3
2
1

You can loop through everything that holds multiple items:

# strings prints character by character of that word
for char in "hello":
    print(char)

# dictionaries, prints key and value together
for key, value in person.items():
    print(key, value)

Calculations inside a loop:

transcations = [1500, 3000, 800, 12000, 450, 2700]

total = 0

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

Output

    Added Ksh 1500 Running total: Ksh 1500
    Added Ksh 3000 Running total: Ksh 4500
    Added Ksh 800 Running total: Ksh 5300
    Added Ksh 12000 Running total: Ksh 17300
    Added Ksh 450 Running total: Ksh 17750
    Added Ksh 2700 Running total: Ksh 20450
Final total: Ksh 20450

Using if statement inside the loop:

prices = [250,980,120,1500,75]
for price in prices:
    if price >= 500:
        category = 'Expensive'
    else:
        category = 'Affordable'
    print(f"Ksh {price} - {category}")

Output

Ksh 250 - Affordable
Ksh 980 - Expensive
Ksh 120 - Affordable
Ksh 1500 - Expensive
Ksh 75 - Affordable

Nested for loop:

days = ["Monday", "Tuesday","Wednesday"]
periods = ["period 1","period 2", "period 3"]

for day in days:
    print(f"---{day} ---")
    for period in periods:
        print(f"   {period}")
    print()

Output

---Monday ---
   period 1
   period 2
   period 3

---Tuesday ---
   period 1
   period 2
   period 3

---Wednesday ---
   period 1
   period 2
   period 3

Enumerate()

enumerate() is a built-in function that is used to loop through a sequence while keeping track of the index and value of each item. By default, enumerate() starts counting at 0, therefore, you need to pass the start argument initialized at 1.

Example:

students = ["Bob","John","Njeri","Wanjiku"]

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

Output

1. Bob
2. John
3. Njeri
4. Wanjiku

While Loop

A while loop repeats as long as a condition stays true. Use it when the number of iterations is not known ahead of time.

Example

count = 1

while count < 5:
    print(f"Count: {count}")
    count += 1   # Increases count by 1 each time

Output

Count: 1
Count: 2
Count: 3
Count: 4

A while loop stops if something inside it eventually makes the condition false. If nothing does, it runs forever:

count = 1

while count < 5:
    print(f"Count: {count}")
    # forgot to increment count - this never ends

This is the classic infinite loop. It's the main reason to prefer a for loop whenever you're iterating over a known collection because the loop will terminate.

password = ''

while password != 'secret'
    password = input('Enter the password: ')

print('Access granted')

You can't write this with a for loop, because you have no idea how many attempts the user will need. The loop keeps going until the condition changes.

Using if statement inside while loop:

score = -1
while score < 0 or score > 100:
    score = int(input("Enter score (0-100): "))
    if score < 0 or score > 100:
        print("Invalid! Score must be between 0 and 100")

print(f"Valid score accepted: {score}")

Controlling The Flow: `break` and `continue`

Sometimes you need to exit early or skip an iteration. The break statement stops the loop completely and immediately exits out of it. It lets you stop work as soon as you have your answer, rather than pointlessly processing the rest.

Example:

scores = [78,85,91,35,66,55,42]

for score in scores:
    if score < 40:
        print(f"First failing score found: {score}")
        break
    print(f" {score} --> OK")
print("Search complete")

Output

 78 --> OK
 85 --> OK
 91 --> OK
First failing score found: 35
Search complete

The continue statement skips the rest of the remaining iteration and jumps to the next cycle. It used to filter out things you want to ignore.

Example:

for num in range(1,6):
    if num % 2 == 0:
        continue  #skips even numbers
    print(num)

Output:

1
3
5

Using break & continue together:

sales = [1200, -500, 800, 0, 950, 300]
total = 0

for sale in sales:
    if sale < 0:
        continue
    if sale == 0:
        break
    total += sale
print(f"Total valid sales: Ksh {total}")

The code skips -500 but stops when it gets to 0.
Output

Total valid sales: Ksh 2000

Conclusion

Loops matter because they are the point where your code stops being a fixed list of instructions and starts being a process. They automate repetitive tasks, saves time and prevent messy code. Learning to write clear, correct loops isn't just one topic among many in Python; it's the skill that lets you write programs that handle real-world data at real-world scale.

The Right Container for the Job: Python Data Structures

Maureen Kipkosgei — Mon, 14 Sep 2026 14:12:28 +0000

Data structures is a format that is used for organizing, managing, and storing data in computer's memory so that it can be accessed and modified efficiently. Data structures act as containers that hold multiple values at once. Choosing the right data structure affects how fast your program runs, how much memory it uses, and how readable the code is.

Python has four highly optimized built-in data structures: lists, dictionaries, tuples and sets.

List(`[]`)

A list is an ordered collection that can hold items of any type, and it can grow, shrink, or be modified after creation. It is mainly used to store items where order matters, and you expect to add, remove or change items over time.

Example of a list

shopping_list = ['Bread','Sugar','Rice','Milk']
print(shopping_list) # ['Bread','Sugar','Rice','Milk']

Indexing a List

A list can be accessed using an index which is its position number. List indexing is zero-based, meaning the first item on the list is at index 0, then second item is at index 1. Python also supports negative indexing to count backward from the end of the list.

shopping_list = ['Bread','Sugar','Rice','Milk']
# pos indexing      0       1       2      3
# neg indexing      -4      -3      -2     -1

Positive indexing
Starts at 0 from the left side

shopping_list = ['Bread','Sugar','Rice','Milk']
print(shopping_list[0]) # 'Bread' (first item)
print(shopping_list[1]) # 'Sugar' (second item)

Negative indexing
Starts at -1 from the right side. This is perfect when you want the item but you do not know how long the list is.

shopping_list = ['Bread','Sugar','Rice','Milk']
print(shopping_list[-1]) # 'Milk' (last item)
print(shopping_list[-2]) # 'Rice' ( second-last-item)

Changing an item by index

shopping_list = ['Bread','Sugar','Rice','Milk']
shopping_list[3] = 'Fresh Milk'
shopping_list[1] = 'Honey'
print(shopping_list) # ['Bread','Honey','Rice','Fresh Milk']

Slicing a list

List slicing is the technique used to extract a subset of a list instead of just a single item. Slicing uses the syntax list[start:stop:step].It creates a brand new list without altering the original list.

Slicing parameters

start - the index where the slice begins(this item is included)
stop - the index where the slice ends( this item is not included)
step - this is optional it determines the increment, i.e a step of 2 skips every other item.
There are some shortcuts used, if you leave a parameter blank, Python assumes you mean the very beginning or the end.

Example of slicing

numbers = [10, 20, 30, 40, 50, 60, 70, 80, 90]
#           0   1  2   3   4   5   6   7   8

print(numbers[1:4]) # [20, 30, 40]
print(numbers[:3])  # [10, 20, 30]
print(numbers[4:]) # [50, 60, 70, 80, 90]

print(numbers[::2])    #every 2nd item [10, 30, 50, 70, 90]
print(numbers[::-1]) # from the last item to the first

List Methods

List methods are built-in functions that allow one to manipulate, modify, or search lists directly.
Let's assume we start with an initial list :
students = ['Amos','Faith','Wanjiku','Brian','Kevin']

Adding Items

.append(item) - adds a single item to the end of the list.

students.append('Dennis')              
print(students) # ['Amos','Faith','Wanjiku','Brian','Kevin','Dennis']

.extend(items) - used to add multiple items or append all items from another list.

students.extend(['Peter','Mercy'])     
print(students)# ['Amos','Faith','Wanjiku','Brian','Kevin','Dennis','Peter','Mercy']

insert(index,item) - inserts an item at a specific position, shifting everything to the right.

students.insert(1, 'Grace')
print(students) # ['Amos','Grace','Faith','Wanjiku','Brian','Kevin','Dennis','Peter','Mercy']

Removing Items

.pop(index) - removes and returns the item at the given index. if no index is provided, it removes the very last item.

print(students.pop(0)) # removes and returns 'Amos'
print(students.pop()) # removes and returns 'Mercy'

.remove(item) - searches the first occurrence of a specific value and deletes it. Throws a ValueError if the value is not there.

students.remove('Brian')
print(students) # removes 'Brian' from the list

del - this is a python keyword that deletes an item by its index position. Del can delete multiple items using slices and it raises an IndexError if the index does not exist.

del students[:3]
print(students) # removes from start up to position 3 'Grace', 'Faith', 'Wanjiku

.clear() - removes all items leaving the list empty.

students.clear()
print(students) # []

Ordering a list

.sort - sorts items of the list in place(ascending by default, alphabetically for strings, ascending for numbers). Set reverse=True to sort descending.

numbers = [3,1,7,4,9,5]
numbers.sort()
print(numbers) # [1,3,4,5,7,9]

numbers = [3,1,7,4,9,5]
numbers.sort(reverse=True)
print(numbers) # [9,7,5,4,3,1]

The list can also be sorted by the length of the characters in strings.

students = ['Amos','Wanjiku','Faith','Dennis']
students.sort(key=len)
print(students) # ['Amos','Faith','Dennis','Wanjiku']

.reverse() - reverses the order of items in the list in place.

numbers.reverse()
print(numbers) # [5,9,4,7,1,3]

.copy() - returns a backup copy of the list incase you remove the wrong item, there is another list.

numbers_backup = numbers.copy() # creates a shallow copy.

Tuples (`()`)

A tuple looks like a list but is immutable meaning once created it cannot be modified. This makes tuples slightly faster than lists and safer to use when you want to guarantee the data won't change.
Tuples is used for fixed collections of related values, like coordinates, RGB colors, or function return values.

Example of a tuple

student = ('Njeri',19,'Kisumu')
name,age,city = student # unpacking the tuple

print(f"{name} is {age} years old, from {city}") # Njeri is 19 years old, from Kisumu

Accessing & Slicing Tuples

Tuples supports indexing and slicing.

print(student[0]) # 'Njeri' indexing
print(student[:1]) # ('Njeri', 19) slicing

Immutability - tuples cannot change

students[1] = 25 # CRASH! tuples can't be modified.

Dictionaries (`{key: value}`)

A dictionary stores data as key-value pairs, giving instant lookups by key. It is used to store structured database records, caching and JSON data handling. Use dictionary when you need to look things up by a meaningful key rather than the numeric position like mapping usernames to profiles.

Example of a dictionary

contacts = {'Amina': '0712345678','Bob':'0798765432','Faith': '0799404040'}

Accessing Data

Use square brackets [] to enclose the key that needs to be fetched.

print(contacts['Amina']) # 0712345678

Use .get() to fetch if you are not sure the key exists. It will return None if the key is missing.

print(contacts.get('Brian')) # None
print(contacts.get('Bob')) # 0798765432

Adding & Updating Data

contacts['Njeri'] = '0700111122'   # adds a new key
contacts['Amina'] = '0711000000'   # updates an existing key

Removing Data

del dict[key] - deletes the key-value pair entirely.

del contacts['Amina'] # removes 'Amina': '0711000000'

.pop(key) - removes the key and returns its value.

contacts.pop('Faith') #removes 'Faith' and returns '0799404040'

.clear() - empties the entire dictionary.

contacts.clear() # {}

Looping through Dictionaries

Dictionaries can be iterated through keys, values, or both at the same time.

prices = {'Sugar': 150, 'Rice': 180, 'Milk': 65, 'Bread': 120}

# loop through the keys only
for key in prices:
    print(key) 

# loop through the values only
for value in prices.value():
    print(value) 

# loop through both keys and values using .items()
for key, value in prices.items():
    print(f"{key} is {value}")

Dictionary Methods

keys() - returns a list-like view of all keys.

prices.keys() #['Sugar','Rice','Milk','Bread']

.values() - returns a list-like view of all values.

prices.values() # [150,180,65,120]

.items() - returns a view of all key-value tuples.

prices.items() # [('Sugar',150), ('Rice',180),('Milk', 65), ('Bread',120)]

Sets (`{}`)

A set stores unique, unordered items. Duplicates are automatically discarded, and sets are optimized for fast membership tests. Sets support mathematical operations, which is useful for comparing collections.

# creating an empty set
empty_set = set()

routes = {'Route 46','Route 34','Route 46','Route 11','Route 11'}
print(routes) # {'Route 34','Route 46','Route 11'} # remove duplicates

Modifying a Set

.add(item) - adds a single item.
.remove(item) - removes a specific item. Crashes with a KeyError if the item is missing.
.discard(item) - safely removes an item. If the item does not exist, it does not crash.

routes = {'Route 46','Route 34'}

routes.add('Route 11') # {'Route 46','Route 34','Route 11'}

routes.remove('Route 34') # {'Route 46','Route 11'}

route.add('Route 46') # does nothing , 'Route 46' already exists.

route.discard('Route 55') # does nothing because 'Route 55' does not exist (it does not crash)

'Route 46' in routes # True - fast lookup in sets.

Mathematical Operations

Sets in python are optimized for mathematical set operations, which are useful in programming.

a = {1, 2, 3}
b = {2, 3, 4}

# union(|) - combines elements from both sides
print(a | b) # {1,2,3,4}

# intersection(&) - finds items present in both sets
print(a & b) # {2,3}

# difference(-) - finds items in `a` that are not in `b`
print(a - b) # {1}

# symmetric difference(^) - finds items that are in one of the sets not both
print(a ^ b) # {1,4}

Quick Comparison

Structure	Ordered	Mutable	Duplicates	Access by
List	Yes	Yes	Allowed	Index
Tuple	Yes	No	Allowed	Index
Dictionary	No	Yes	Unique Keys	Key
Set	No	Yes	Not Allowed	Membership

Comprehensions

Comprehensions in Python are a concise, elegant way to create new collections (lists, dictionaries, or sets) from existing iterables in a single line of code. they are not a separate data structures, they are just fast, readable way to build the ones above.

Syntax:[expression for item in iterable if condition]

squares = [n  2 for n in range(6)]

# [0, 1, 4, 9, 16, 25]



# adding if filter

evens_only = [n for n in range(10) if n % 2 == 0]

# [0, 2, 4, 6, 8]



square_map = {n: n  2 for n in range(5)}

# {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}



# dictionaries

unique_lengths = {len(word) for word in ["hi", "hey", "hello", "yo"]}

# {2, 3, 5}

Conclusion

Most Python programs are lists, tuples, dictionaries and sets working together, understanding strengths of each one is often valuable than knowing advanced syntax. As a general rule: reach for a list when order and flexibility matter, a tuple when the data shouldn't change, a dictionary when you need fast lookups by a meaningful key, and a set when uniqueness or fast membership checks matter most. Getting this choice right early on tends to make the rest of your code simpler.

The Only Python String Methods Cheat Sheet You Need

Maureen Kipkosgei — Wed, 09 Sep 2026 05:55:47 +0000

String is a sequence of characters (letters, numbers, or symbols). Strings are one of the most common data types you'll work with in Python, whether you're cleaning user input, parsing files, or building web applications. Python gives you a rich set of built-in string methods that make text manipulation fast and readable, without needing extra libraries. This guide walks through the most useful ones, grouped by what they actually help you do.

Strings as sequence

String is a list of characters in an ordered sequence.

Key Features of a string as sequence

Ordered - Each character in a string occupies a specific position
Indexed - You can access individual characters in a string using an index number.
Iterable - You can loop through each character in a string.
Immutable - Every string is immutable, therefore it cannot be modified but returns a new string.

Slicing - Slicing a string is extracting part of it without modifying the string. This uses index position. Counting characters in a string starts with [0] and the end is [-1] and [::-1] reverses the substring.

city = 'Nairobi'
print(city[0])   # N -- the first character
print(city[-1])  # i -- the last character
print(city[:-1]) # Nairob -- all characters excluding the last character.
print(city[0:3])  # Nai -- slices from the first character upto 2
print(city[3:])   # robi -- slices from the character in 3rd position to the end
print(city[::-1]) # iboriaN -- reverses the string.

Concatenation - is the process of joining together two or more strings to form one string. It uses a + sign to join the strings.

city1 = 'Nairobi'
city2 = 'Kisumu'
city3 = 'Mombasa'

city = city1 + ',' + city2 + ' and ' + city3
print(city)  # Nairobi, Kisumu and Mombasa

Changing case

String methods lets you standardize text before comparing it, or for display formatting.
There is;

upper() - converts all characters to uppercase.
lower() - converts all characters to lowercase.
capitalize() - capitalizes only the first letter of the whole string(use it for sentences).
title() - capitalizes the first letter of every word(use it for names or headings).
swapcase() - it swaps cases of the strings i.e. (lowercase becomes uppercase and vice versa).

Examples

raw_name = 'bRIAN oTIENO'
print(raw_name.upper())    # BRIAN OTIENO
print(raw_name.lower())    # brian otieno
print(raw_name.title())    # Brian Otieno
print(raw_name.swapcase()) # Brian Otieno
print(raw_name.capitalize()) # Brian otieno

Trimming and cleaning whitespace

Text from files, forms, or user input often comes with unwanted spaces, tabs, or new lines, These methods clean it up.

strip() - removes spaces from both sides.
lstrip() - removes spaces from left side only.
rstrip() - removes spaces from right side only.

name = '    Python   '
print(name.strip())     # Python
print(name.lstrip())    # Python     '
print(name.rstrip())    # '     Python

strip() can also be used to remove characters instead of whitespaces.

code = "----Promo2025----"
print(code.strip('-'))  # Promo2025

Search and Replacing Inside Strings

These methods let you check for the presence or position of substrings.

in - it is the simple member check with yes/no.
find() - returns the lowest index where the value is found.
index() - works like find but crashes with a value error if the text is not there.
count() - returns the total number of occurrences of a substring.
replace() - replaces occurrences of the substring with another one

text = "Learning Python is fun."
print('Python' in text) # True 
print('SQL' in text)    # False

text = "Learning Python is fun."
print(text.find('Python')) # 9 index where the word starts
print(text.find('SQL')) # -1 because SQL is not found instead of crashing it return -1

text = "Learning Python is fun."
print(text.index('Python')) # 9 index where the word starts
print(text.index('SQL')) # it crashes and gives a valueError

Use find() when a missing substring is a normal case you want to handle gracefully, and index() when a missing substring should raise an error and stop execution.

text = "Learning Python is fun."
print(text.count('i')) # 2 - number of occurrence

text = "Learning Python is fun."
new_text = text.replace('Python','SQL')
print(new_text) #Learning SQL is fun.

Splitting and joining

Split() turns a string into a list, .join() does the reverse. Together they help with parsing tasks.

Split():

sentence = "Moses is learning Python in Nairobi"
words = sentence.split()
print(words) # ['Moses', 'is', 'learning', 'Python', 'in', 'Nairobi']

Split() can be used with a custom separator.

csv_line = "a,b,c,d"
fields = csv_line.split(",") # ['a', 'b', 'c', 'd']

There's also splitlines(), which is useful when processing multi-line text:

notes = "Buy bread\nPay rent\nCall Mum"
lines = notes.splitlines()
print(lines) # ['Buy bread', 'Pay rent', 'Call Mum']

.join():

words = ['Moses', 'is', 'learning', 'Python', 'in', 'Nairobi']
sentence = ' '.join(words)
print(sentence) # Moses is learning Python in Nairobi

notes = ['Buy bread', 'Pay rent', 'Call Mercy']
lines = '\n'.join(notes)
print(lines) # It outputs each item in its own line.

. join() can also be used to clean spaces between strings where strip cannot.

dirty = "      Brian  ,  24    ,      Nairobi  "
clean = " ".join(dirty.split())
print(clean)  # Brian , 24 , Nairobi

name = 'Python            Programming'
clean_name = " ".join(name.split())
print(clean_name) # Python Programming

Checking string content

These return True or False and are especially handy for validating input.

isdigit() - true if all characters are digits.
isalnum() - true if all characters are alphabets and numbers.
isalpha() - true if all characters are alphabets.
isupper() - true if all characters are uppercase.
islower() - true if all characters are lowercase.

print("12345".isdigit())  #True
print("Amina".isdigit())  #False
print("Amina23".isalnum()) #True
print("Amina 123".isalnum()) #False (there is space)
print("Amina".isalpha())   #True
print("Amina234".isalpha()) #False
print("amina".islower())  #True
print("AmIna".islower())  #False
print("AMINA".isupper()) #True

Example of how it is used to validate inputs.

while True:
    age = input('Enter your age: ')
    if age.isdigit():         #checks if it is a digit
        age = int(age)
        print(f"You are {age} years old.")
        break   # stops once you enter a valid age
    else:
        print('That is not a valid whole number. Please try again.')

Prefixes and Suffixes

This checks the boundaries of a string and returns True or False.

phone = "0712345678"
print(phone.startswith('07')) #True
print(phone.startswith('01')) #False
print(phone.endswith('678'))  #True

Padding and Formating

This is used to make the code look clean and aligned.

{value: <width} - left - aligns the string inside a specific width, padding the rest.
{value: >width} - right-aligns the string inside a specific width, padding the rest.
{value: ^width} - center- align the string inside a specific width, padding the rest.

name = 'String'
print(f"[{name:<10}]") # [String     ]
print(f"[{name:>10}]") # [    String]
print(f"[{name:^10}]") # [  String  ]

It can also be used to pad specific characters on a number

number = 50
print(f"{number:=>5}")   # ===50

The zfill() method is a simpler option when you just need zero-padding:

receipt_no = "42"
print(f"Receipt #{receipt_no.zfill(5)}") # Receipt #00042

Formatting in Python is handled by f-strings for readability.
Number and currency formating

Controlling decimals - rounds the value to the specified number i.e. {val:.2f} rounds to two decimal places

price = 349.6789        
print(f"KES {price:.2f}") # KES 349.68

Thousands separator - adds a comma to large numbers

salary = 1450000
print(f"KES {salary:,}") # KES 1,450,000

Combining decimals, currency and thousand separator

salary = 1455678.986
print(f"KES {salary:,.2f}") # KES 1,455,678.99

Combining all methods: A Small Example

Here's how several of these methods might combine in a realistic task, cleaning and validating a list of email addresses:

raw_emails = "  Alice@Example.com, BOB@test.org ,carol@site.net  "

emails = [e.strip().lower() for e in raw_emails.split(",")]
print(emails)
# ['alice@example.com', 'bob@test.org', 'carol@site.net']

for email in emails:
    if "@" in email and email.endswith((".com", ".org", ".net")):
        print(f"{email} looks valid")

Conclusion

You don't need to memorize every string method to write good Python, but knowing this core set will cover the vast majority of everyday text processing you'll encounter, from cleaning user input to parsing files and generating readable output.

Learning SQL by Building a School Management Database

Maureen Kipkosgei — Wed, 22 Jul 2026 13:12:39 +0000

Introduction

Data is only useful if you can store it properly and ask the right questions of it. For my week 2 SQL assignment, i was tasked with designing and building a small relational database from scratch, Greenwood Academy, that has student, subjects, teachers and exams records.
The goal of this assignment was going through the full lifecycle of working with a database from defining its structure, populating it with data, querying it to answer real questions and using SQL's targeted tools to turn raw rows into actual insights.

1. Data Definition Language - Building the Database

DDL is the main subset of SQL that is used to create, modify and delete the structure of database objects like schemas, tables and indexes.
CREATE - defines a new schema, database or table.
ALTER- changes the structure of an existing table like adding a column, renaming a column or changing the data type.
DROP - permanently deletes a table or column and its content from the system.

Create a Schema

Schema is a logical container within a database that organizes tables, data types and functions.

Create schema greenwood_academy;
set search_path to greenwood_academy;

I configured the search_path to instruct the database to know where to look for the tables, views and functions.

Create a Table

create table greenwood_academy.students(
   student_id int SERIAL 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 table greenwood_academy.subjects(
   subject_id int SERIAL primary key,
   subject_name varchar(100) not null unique,
   department varchar(50),
   teacher_name varchar(50),
   credits int
);

create table greenwood_academy.exam_results(
   result_id int SERIAL primary key,
   student_id int not null references greenwood_academy.students(student_id),
   subject_id int not null references greenwood_academy.subjects(subject_id),
   marks int not null,
   exam_date date,
   grade varchar(2)
);

I used SERIAL to automatically generate unique row identifiers for the table instead of doing it manually. Postgresql has constraints which are rules used on tables and rows that limit the invalid data entered.

Types of Constraints:

not null - prevents a column from having null values.
unique - guarantees all values are distinct.
Primary Key - marks a column as the unique identifier for each row in a table.
Foreign Key - links a column in one table to the primary key of another.

Alter table

alter table greenwood_academy.students add column phone_number varchar(20);

alter table greenwood_academy.subjects rename column credits to credit_hours;

alter table greenwood_academy.students drop phone_number;

2. Data Manipulation Language - Inserting the database

DML is a subset of SQL that has commands that are used to manage and modify data stored in existing tables.
INSERT - adds rows to the table.
UPDATE - modifies existing rows based on specified conditions.
DELETE - removes existing rows on the table.

Populating the table

insert into greenwood_academy.students(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'),

------Quick Check-----------------------
select * from greenwood_academy.students;
select * from greenwood_academy.subjects;
select * from greenwood_academy.exam_results;

After inserting values into the table, use select *-means all from the specific table to check if the inserted values are there.

Output on DBeaver

Modifying the table

update greenwood_academy.exam_results
set marks = 59
where result_id = 5;

delete from greenwood_academy.exam_results
where result_id = 9;

3. Data Query Language - Querying The Data

DQL is used to retrieve and read data from a relational database. It returns a temporary table with the results. DQL has one primary command SELECT that is paired by other commands to retrieve data.
SELECT - chooses which column to return.
FROM - specifies which table the data comes from.
WHERE - filters rows based on specified condition.
ORDER BY- sorts the result set, ascending is default or DESC descending.
GROUP BY - collapses rows into summary groups, always paired with aggregate functions like count() or avg().
HAVING - filters groups created by group by.
As - alias is a temporary name assigned to a table or column to make the code easier to read.

select marks
from greenwood_academy.exam_results 
where marks >= 70
order by marks;

select subject_id,
       count(*) as total_results,
       AVG(marks) as average_mark
from greenwood_academy.exam_results
group by subject_id
order by subject_id;

4. Range, Membership, Operator

This section covered operators that make filtering more precise and more readable that long chains of OR conditions.
BETWEEN- filters values within a range.
IN- checks whether a column's value matches any item in the list
NOT IN - checks column's values that do not match any item in the list.
LIKE - pattern-matches text using % as a wildcard for any number of characters and _for exactly one character.
ILIKE -it works same as LIKE, but is case-insensitive.

Like 'A%' - finds any value that begins with "A".
Like '%A' - finds any value that ends with "A".
Like '%A%' - finds any value that contains "A" in any position.

where exam_date between '2024-03-15' and '2024-03-18';
where city in ('Nairobi','Mombasa','Kisumu');
where class not in ('Form 2','Form 3');
where first_name like 'A%' or first_name like 'E%';
where subject_name like '%Studies%';

5. Count

Count() is an aggregate function that is used to total up rows.

select count(*) as form3_students
from greenwood_academy.students 
where class = 'Form 3';

6. Case When

The Case statement is a way of adding conditional logic directly inside a query. It is similar to if/else statements in most programming languages.

CASE...WHEN...THEN...ELSE...END-It evaluates conditions in order, top to bottom and returns the result tied to the first condition that matches. ELSE is the fallback if nothing matches.

select marks,
case
    when marks >=80 then 'Distinction'
    when marks >=60 then 'Merit'
    when marks >=40 then 'Pass'
    else 'Fail'
end as Performance
from greenwood_academy.exam_results
order by marks;

Case Output

Conclusion

Working through Greenwood academy's database from create table statement to case when gave me a much clearer picture of how a relational database works end to end.
You can find the full set of SQL files for this project, including the complete Greenwood Academy schema and all six sections, in my github Repository

Mastering Power BI Data Modelling: Joins, Schemas & Relationships.

Maureen Kipkosgei — Wed, 24 Jun 2026 19:58:27 +0000

Introduction

In Power BI, data is your raw material. However, raw data alone cannot answer complex business questions. To transform scattered table to actionable insights, a structure or blueprint is needed. Data modelling is the important process that determines how data can be analyzed, how accurate reports are, and how well the solution performs. Data modelling relies on Joins, Schemas and Relationships to simplify report development.

What is Data Modelling and Its Importance in Power Bi?

Data modelling is the process of identifying and defining how multiple tables connect and interact. It acts as a structural foundation of your reports, allowing different tables to communicate so that you can accurately filter, analyze and visualize data. Data modelling is important because;

Lightning-fast performance- improves on speed and performance of the calculations and visuals.
Accuracy- The calculations are accurate and consistent.
Scalability- A clean data allows one to easily plug in new data sources without having to rebuild existing reports.
Intuitive User Experience- Users can navigate through categorized dimensions and clearly defined metrics.

Joins in Power BI

Joins, also known as Merging Queries, are operations used to combine multiple tables into a single table based on a common column or relationship. Joins is mainly performed in Power Query Editor using the Merge Queries feature.

Types of Joins

Left Outer Join- Returns all rows from the left(first) table and only the matching rows on the right(second) table. If there is no match it places a null. For example, keeping all your sales transactions and bringing matching store details, even if a store hasn't made a sale.
Right Outer Join- Returns all rows from the right(second) table and only the matching rows on the left(first) table. If there is no match it places a null. It is the opposite of left outer join.
Full Outer Join- Returns all rows from both tables, combining where there are matches and placing null where there are no matches. For example, emptying two completely different junk drawers into a single large bin.
Inner Join- Returns only the rows that have matching values in both tables. For example, a VIP Lounge where one can enter if your name is on both the guest list and ticket holder list.
Left Anti Join- Returns only the rows from the left table that do not have matching row in the right table. For example, finding which customers registered for an event but never showed up.
Right Anti Join - Returns only the rows from the right table that do not have matching row in the left table.

Data Schema

A Schema is the blueprint or structural design that defines how data is organized, cleaned and stored in a database. It outlines the tables, fields, relationships, views and other elements within a database. The schema defines the specific rules that govern the data, including its types, constraints and relationships.

Tables and Keys in a Schema

Fact Table
A fact table is a central table in data warehouse which stores quantitative, numerical data about events, transaction or business processes. It is usually long and narrow. A fact table contains:

Measures-Numerical data like quantities sold, profit margin, sales amount or duration.
Foreign Keys-IDs that link fact table to dimension table like customer key, Product Key or Date Key.

Dimension Table
A dimension table stores qualitative data that describe the items in the fact table. It provide the who, where, why, which and when context of the fact table data. They are usually short and wide.
Primary Key
A primary key is a column that uniquely identifies each row. Here are rules of a primary key:

No duplicates
No null values
One primary key per table
Foreign Key
A foreign key is a column in one table that uniquely points primary key of another table. It establishes logical link between the data and prevents disconnected records.

Schema Designs

Star Schema
Star Schema is used for storing and analyzing large amounts of data. It features a central fact table connected by several dimension table like a star.

Uses-Business Intelligence, data warehouse and analytical dashboards.
Pros-Easy to understand and fast for running aggregations, filters and business reports.
Cons-Introduces data redundancy and is not ideal for rapid, everyday transactional update.

Snowflake Schema
A Snowflake schema is a multi dimensional data model where a central fact table is surrounded by normalized dimension tables, which split into sub-dimension tables.

Uses-Financial reporting, logistics & transportation and e-commerce & retail supply chains.
Pros-Saves storage, easier data maintenance and better for complex hierarchical data.
Cons-Slower query performance and design is hard to build and maintain.

Flat Schema
A flat schema is a 2-D array in which every column contains the same type of data and the elements in the row are related to each other. It is like a table or a spreadsheet.

Uses-No SQL database, log management, and real-time streaming data.
Pros-Fast read performance, simple queries and seamless integration with BI tools.
Cons-Consumes significantly more storage and makes data update tedious.

Relationships in Power BI

A relationship in Power BI connects two tables based on a shared column. It allows one to calculate metrics, filter or slice across multiple tables without merging them.

Cardinality
Cardinality defines the relationship between rows in different tables.

Types of Cardinality Relationship

One-to-Many- This is the most common type, where one record in the primary table is linked to many records in the other table. For example, one customer can make many orders.
One-to-One- A single record in the first table relates exactly to one record in the second table. For example, one citizen has one national ID record.
Many-to Many- Records in both tables can relate to multiple tables in the other table. For example, one student can take many courses and one course can have many students.

Cross-filter Direction
Cross-filter direction determines how filters propagate between the related tables in the data model.

Types of Cross-filter Direction

Single(one-way)- This is default setting where filters flow from the dimension table to the fact table.
Both(Bi-directional)- Filters propagate in both directions.

Active vs Inactive Relationship

Active- This is the default relationship used by Power BI and the tables are connected by a solid line.
Inactive- It is represented by a dashed line.

Conclusion

A strong data model is the foundation of efficient reporting, accurate analytics, and scalable Power BI solutions. Understanding joins, schemas and relationships allows you to build reports that are both performant and easy to maintain.

How Excel is Used in Real-World Data Analysis

Maureen Kipkosgei — Sun, 07 Jun 2026 11:32:45 +0000

Microsoft Excel is a spreadsheet tool that is used to organize, format, analyze and store data in rows and columns. It allows users to input text, do mathematical functions, create charts and analyze vast amounts of information. Its user-friendly interface makes it a great starting point for anyone beginning a journey in data analytics.

Application of Excel on Real-World Data Analysis

Excel is a powerful tool that is used by professionals to clean raw data, visualize trends and patterns and make actionable insights. Here is how Excel is used across industries every day:

Financial Analysis & Reporting - Financial teams rely heavily on Excel for budgeting, forecasting and risk analysis.
Business Operations & Logistics - Companies analyze sales performance, inventory levels, and customer data to improve efficiency. By organizing large amounts of information into spreadsheets managers can monitor key performing indicators.
Marketing Analytics - Marketing teams use Excel to evaluate campaign performance, track customer engagement, and compare results across different channels.

Excel Features and Functions

As part of my data science and analytics bootcamp, i have learnt several Excel features that are essential in data analysis.

Data cleaning and formatting
Raw data is most times dirty. I have learnt to use tools like trim,Ctrl + H to find and replace, and conditional formatting to eliminate duplicate entries, fix erratic spacing, or identify correlations before starting analysis.
Data organization
Data should be arranged in a way that is easy to read and analyze. I learnt to use sort & filter option in the (Data tab) which allows one to remove outliers, change values to correct data type, and group similar data together. I also learnt about Data validation which is a feature that helps control the type of data entered into a spreadsheet. This reduces errors and improves data quality.
Data analysis
I learnt about aggregate functions such as SUM(), AVERAGE(), COUNT(), MAX(), MIN()and MODE(). These functions help summarize large datasets and provide quick insights. I was also introduced to conditional functions like SUMIF()/COUNTIF()which is used to calculate or count frequencies for a single condition. SUMIFS()/COUNTIFS() allows for multi-criteria segmenting.

Conclusion

Before i started learning Excel, i viewed data as information stored in rows and columns. Now i see it as valuable information that can tell stories, reveal patterns, and support decision-making. Excel has shown me that when data is properly cleaned and organized it can uncover meaningful patterns. I am looking forward to learning about advanced data merging like XLOOKUP,VLOOKUP, Pivot tables and Modern Data transformation.

Are you currently learning Excel or using it in your daily workflow? What is your favorite go-to formula? Let's connect and chat in the comments below!

DEV Community: Maureen Kipkosgei

Making Decisions in Python: Operators and Conditional Logic

Arithmetic Operators: Doing the Math

Comparison Operators: Asking Questions About Values

Logical Operators: Combining Conditions

If Else Statements: Acting on the Result

Nesting Conditions

Practical Example

Write Once, Run Many: Understanding Python Loops

Problems Loops Solve

Loops Separate Logic From Volume

For Loop

Range()

Enumerate()

While Loop

Controlling The Flow: break and continue

Conclusion

The Right Container for the Job: Python Data Structures

List([])

Indexing a List

Slicing a list

List Methods

Adding Items

Removing Items

Ordering a list

Tuples (())

Accessing & Slicing Tuples

Immutability - tuples cannot change

Dictionaries ({key: value})

Accessing Data

Adding & Updating Data

Removing Data

Looping through Dictionaries

Dictionary Methods

Sets ({})

Modifying a Set

Mathematical Operations

Quick Comparison

Comprehensions

Conclusion

The Only Python String Methods Cheat Sheet You Need

Strings as sequence

Key Features of a string as sequence

Changing case

Trimming and cleaning whitespace

Search and Replacing Inside Strings

Splitting and joining

Checking string content

Prefixes and Suffixes

Padding and Formating

Combining all methods: A Small Example

Conclusion

Learning SQL by Building a School Management Database

Introduction

1. Data Definition Language - Building the Database

Create a Schema

Create a Table

Types of Constraints:

Alter table

2. Data Manipulation Language - Inserting the database

Populating the table

Output on DBeaver

Modifying the table

3. Data Query Language - Querying The Data

4. Range, Membership, Operator

5. Count

6. Case When

Case Output

Conclusion

Mastering Power BI Data Modelling: Joins, Schemas & Relationships.

Introduction

What is Data Modelling and Its Importance in Power Bi?

Joins in Power BI

Types of Joins

Data Schema

Tables and Keys in a Schema

Schema Designs

Relationships in Power BI

Types of Cardinality Relationship

Types of Cross-filter Direction

Controlling The Flow: `break` and `continue`

List(`[]`)

Tuples (`()`)

Dictionaries (`{key: value}`)

Sets (`{}`)