DEV Community: Maureen Kipkosgei

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!