DEV Community: Sharon-nyabuto

Part 3: Understanding Distributions in Data Science

Sharon-nyabuto — Wed, 26 Aug 2026 00:39:23 +0000

Statistics for Data Science (Part 3)

Part 1: Why Statistics Matters in Data Science

Part 2: Descriptive Statistics: A Beginner's Guide

Introduction

In the previous article, we worked through four questions to guide our analysis: What type of data do you have?, Where is it centered?, How spread out is it?, and What does its distribution look like?.

The last question introduced distributions briefly, we saw that some variables formed a bell-shaped curve while others were right-skewed or left skewed.

In this article, we will further explore some of the common distributions, understand what they represent, and examine their key properties. We will also see why understanding the shape of your data matters and how distributions can help you make better decisions about how to analyze and interpret data.

Introduction
What Is a Distribution?
Data Distributions (Empirical Distributions)
- The Normal Distribution
- The Empirical Rule
- Z-Scores
- Skewed Distributions
Probability Distributions
- Uniform Distribution
- Binomial Distribution
- Poisson Distribution
Why Distributions Matter
Conclusion

What Is a Distribution?

A distribution describes how the values of a variable are spread across the possible values or range of values it can take. It tells us the values that occur frequently, those occurring rarely, and how the observations are distributed across the range of the variable.

There are two related ideas that are important to distinguish:

Data Distributions (Empirical Distributions)

Describes the actual observations in our dataset. For example, when we plot histograms, we look at the empirical distributions of variables such as bill amount and distance to the facility.

Probability Distributions

Theoretical model that describes how likely different values or ranges of values are to occur.

1. Data Distributions (Empirical Distributions)

The Normal Distribution

The normal distribution is the distribution most of the statistical methods are built around. In a normal distribution, values tend to cluster around the center, with fewer observations as we move farther away.

The common visual characteristics of a normal distribution include a bell-shaped curve, one central peak, tails extending in both directions and a symmetric appearance.

A normal distribution is defined by two things:

The mean, which determines where the center of the curve sits.
The standard deviation, which determines the spread of the data (how wide or narrow the curve is).

Note: A smaller standard deviation produces a narrower, taller curve, while a larger standard deviation produces a wider, flatter curve.

The data we work with in the real world context rarely follows a theoretical distribution perfectly. However, it may resemble one closely enough for us to use what we already know about that distribution to understand and analyze the data.

Looking at our hospital dataset, age and weight were the variables that came closest to a normal distribution. Neither follows the theoretical bell-shaped curve perfectly, but both show a broadly similar pattern, increasing to a central peak before gradually decreasing.

Let's look at their mean, median, and standard deviation.
To display the mean, median, and standard deviation of multiple variables at once, we can use the .agg() method and specify the summary statistics we want to calculate.

healthaccess_data[["age", "weight_kg"]].agg(["mean", "median", "std"])

Variable	Mean	Median	Mode	Standard Deviation
Age	36.8 years	36 years	36 years	18.89 years
Weight	59.32 kg	62.7 kg	62 kg	19.43 kg

For age, the mean and median are very close, while the difference is somewhat larger for weight. The plots also show that neither variable is perfectly symmetrical.

This is typical of real-world data. We rarely get a distribution that matches a theoretical distribution exactly. The question is often how closely does the data follow the pattern we expect?. To answer this question, we have to explore the empirical rule, tells us roughly what proportion of observations fall within a certain number of standard deviations from the mean.

↑ Top

The Empirical Rule

One useful property of a normal distribution is the empirical rule, also known as the 68-95-99.7 rule. It tells us how much data should fall within one, two, and three standard deviations of the mean if the data follows a normal distribution.

About 68% of observations fall within 1 standard deviation of the mean.
About 95% of observations fall within 2 standard deviations of the mean.
About 99.7% of observations fall within 3 standard deviations of the mean.

We can apply the empirical rule to our age and weight variables by checking the proportion of observations that fall within 1, 2, and 3 standard deviations of their respective means. We would expect approximately 68%, 95%, and 99.7% of observations to fall within these ranges if they follow normal distributions

To check this in Python, we can use the following code:

for column in ["age", "weight_kg"]:
    mean = healthaccess_data[column].mean()
    std = healthaccess_data[column].std()

    print(f"\n{column}")

    for n in [1, 2, 3]:
        lower = mean - n * std
        upper = mean + n * std

        within_std = healthaccess_data[
            (healthaccess_data[column] >= lower) &
            (healthaccess_data[column] <= upper) ]

        proportion = len(within_std) / healthaccess_data[column].notna().sum()

        print(f"Within {n} std: {proportion:.2%}")

Output:

age
=========================
Within 1 std: 67.41%
Within 2 std: 96.35%
Within 3 std: 100.00%

weight_kg
=========================
Within 1 std: 73.82%
Within 2 std: 92.10%
Within 3 std: 100.00%

The results show that age follows the empirical rule quite closely, with 67.41% of observations within 1 standard deviation and 96.35% within 2 standard deviations, compared with the expected 68% and 95%.
Weight is less closely aligned, with 73.82% within 1 standard deviation and 92.10% within 2. Both variables have 100% of observations within 3 standard deviations.

Overall, age appears to follow the pattern of a normal distribution more closely, while weight shows some deviation from the theoretical 68-95-99.7 pattern. However, the empirical rule should not be used on its own to assess normality; it is best considered alongside visual checks such as histograms or density plots.

Z-Scores

The empirical rule helps understand how observations are distributed around the mean. To know how far a single observation is from the mean, we use a z-score.

A z-score tells us how many standard deviations an observation is above or below the mean.

Formula:

z = \frac{x - x ˉ}{s}

Where:

$x$ is the individual observation
$x ˉ$ is the mean
$s$ is the standard deviation

A z-score of 0 means the observation is exactly at the mean. A z-score of 2 means it is 2 standard deviations above the mean, while a z-score of -1.5 means it is 1.5 standard deviations below the mean.

In the hospital dataset, to know how a patient weighing 100 kg compares with the other patients in our dataset:

weight = 100

mean = healthaccess_data["weight_kg"].mean()
std = healthaccess_data["weight_kg"].std()

z_score = (weight - mean) / std
print(f"Z-score: {z_score:.2f}")

Output:

Z-score: 2.09

The z-score of 2.09 means that this patient's weight is approximately 2.09 standard deviations above the mean. Based on the empirical rule, this places the observation toward the upper end of the distribution, beyond the range where we would expect most observations to fall.

Z-scores are also useful when comparing variables measured on different scales(such as the age and weight in our dataset). Once values are converted to z-scores, they are expressed in the same terms: how many standard deviations they are from their respective means.

↑ Top

Skewed Distributions

The empirical rule and z-scores are most useful when data is approximately normally distributed. When a distribution is heavily skewed, these tools may not describe the data as well because extreme values occur more frequently than they would in a normal distribution.

Looking at the distribution of the bill amount from the hospital dataset below,

we can see that small number of patients have exceptionally high bills, creating a long right tail. In this situation, a value several standard deviations above the mean may not be as unusual as it would be in a normal distribution.

This is also why the median is more useful than the mean for heavily skewed data. It is a better representation of a typical observation when the distribution has substantial skew.

The important point is that the shape of our data influences the statistical methods we choose. Before applying a method, we should understand whether the data is approximately normal, skewed, or follows another type of distribution.

↑ Top

2. Probability Distributions

Uniform Distribution

In a uniform distribution, every value within a given range is equally likely to occur. Unlike a normal distribution, there is no central peak; the values are spread roughly evenly across the range.

A simple example is a fair die. Each of the six outcomes has a 1-in-6 chance of occurring. If we rolled the die many times, we would expect the results to be spread fairly evenly across the six values.

In the hospital dataset, the visits by the day of week exhibit a near uniform distribution.

healthaccess_data["day_of_week"].value_counts(normalize = "percent")

Output:

day_of_week
Monday      14.22
Tuesday     13.98
Wednesday   14.21
Thursday    14.41
Friday      14.08
Saturday    14.64
Sunday      14.47
Name: proportion, dtype: float64

We can see that each day accounts for roughly 14% of total visits, close to the 1-in-7 (about 14.3%) we'd expect if visits were split perfectly evenly across the week. Patients arrive at the hospital fairly consistently regardless of the day, which makes day of week a reasonable real-world example of a near-uniform distribution.

Formula
For a discrete uniform distribution across n equally likely outcomes, each outcome has the same probability:

P (x) = \frac{1}{n}

With 7 days in a week, we'd expect each day to account for $\frac{1}{7} \approx 14.3%$ of visits under a perfectly uniform distribution, which lines up closely with what we see in the data.

↑ Top

Binomial Distribution

A binomial distribution describes the number of times a particular outcome, or success, occurs in a fixed number of independent trials.

For the binomial distribution, each trial must have only two possible outcomes. These could be;

Success / failure
Yes / no
Admitted / not admitted
Died / survived etc.

Going to our hospital dataset, if we wanted to estimate how many of the next 50 patients would be admitted,
we could use a binomial distribution to model the number of admissions among those 50 patients.
Each patient gives us one trial:

Inpatient (Admitted) or Outpatient (Not Admitted)

First, we would need to get the proportion of inpatient visits;

inpatient_proportion = (healthaccess_data["visit_class"] == "Inpatient").mean()
print(f"Proportion of inpatient visits: {inpatient_proportion:.2%}")

Output:

Proportion of inpatient visits: 28.56%

Having got that, now we can answer the question:

What is the probability that exactly 10 out of the next 50 patients will be admitted?

from scipy.stats import binom

n = 50
k = 10
p = inpatient_proportion

probability = binom.pmf(k, n, p)
print(f"Probability of exactly 10 inpatients: {probability:.4f}")

Output:

Probability of exactly 10 inpatients: 0.0533

The result confirms that out of the next 50 patients, there's roughly a 5.3% chance that exactly 10 of them are inpatient.

The important distinction is that the binomial distribution is concerned with how many successes occur, rather than which individual patients experience the outcome.

↑ Top

Poisson Distribution

A Poisson distribution is used to model the number of times an event occurs within a fixed interval of time or space.

Unlike the binomial distribution, we are not starting with a fixed number of trials. Instead, we are counting how many times an event occurs during an interval.

For example, consider the number of patients arriving at the hospital daily.

One day might have:

20 visits
another day might have 100
another might have 30

If patient visits occur independently and the average arrival rate is reasonably stable, a Poisson distribution can be used to model the number of arrivals per day.

We might then ask:

What is the probability that 80 patients arrive at the hospital the next day?

Assuming the ~ 89000 visits in our hospital data were evenly spread across 3 years, our daily average visits would be ~62 visits/day

To answer the question above, we would then proceed as follows:

from scipy.stats import poisson

k = 70
lam = 62 

probability = poisson.pmf(k, lam)
print(f"Probability of exactly 70 arrivals: {probability:.4f}")

Output:


Probability of exactly 70 arrivals: 0.0290

So on any given day, there's roughly a 2.76% chance of seeing exactly 70 arrivals.

The Poisson distribution is useful for count data, especially when we are counting events over a defined period of time or area, such as the visits per day or transactions per hour.

↑ Top

Why Distributions Matter

The shape of a distribution influences almost every decision we make with our data afterward.

It tells us which summary statistics to trust. The mean can be misleading for a skewed variable like bill amount, while it works well for an approximately normal variable like age.
It tells us how to spot unusual observations. The empirical rule and z-scores rely on approximate normality, while the IQR rule works regardless of shape.
It tells us which statistical methods are appropriate. Many statistical tests and models assume the underlying data is approximately normally distributed. When that assumption doesn't hold, a different approach is usually needed.

Recognizing the distribution a variable follows shapes the analytical decisions that come after it.

Conclusion

Distributions describe the shape of our data, and that shape carries information. Understanding distributions gives us a connection between descriptive statistics, which describes the data we already have, and probability, which lets us reason about data we haven't observed yet.

Next in this series, we will look at probability, and how it lets us move from describing what has happened to what is likely to happen.

↑ Back to Top

Descriptive Statistics: A Beginner's Guide

Sharon-nyabuto — Thu, 20 Aug 2026 03:08:39 +0000

Introduction

In the previous article, we looked at how statistics helps us take a large amount of information and turn it into something we can understand.

When a hospital administrator receives data on 50,000 patient visits, they will see alot of information on it. There will probably be columns for dates, age, gender, patient vitals, diagnosis, admission status, length of stay, bill amount etc. The administrator can't reasonably look at all 50,000 rows and say, "Okay, I understand this dataset."

Naturally, they would have questions about who the patients are, what a typical patient looks like, patient flow by department, how much patients are paying, and many more. While the answers are contained within the dataset, they are not immediately obvious from looking at individual records.

These questions can be largely answered using descriptive statistics.

Four Questions to Guide Our Analysis

Very simply defined, descriptive statistics summarize and describe a complex set of raw data so it is easy to read and understand.

Descriptive statistics begins with 4 simple questions:

1. What type of data do I have?

2. Where is my data centered?

3. How spread out is my data?

4. What does the distribution of my data look like?

These four questions will form the structure of this article. As we work through each one, we will explore the descriptive statistics that help us summarize, understand and communicate what our data is telling us.

1. What type of data do I have?

Before we start calculating averages, percentages or looking at distributions, we first need to understand what kind of data we are working with.

In statistics, we have different types of data that are summarized in different ways. The first step is to understand what kind of variable we are working with. Data is broadly categorized into Qualitative (Categorical) and Quantitative (Numerical) data.

Qualitative Data

Qualitative data, also known as categorical data, describes characteristics, groups, labels, or names. It is further classified into two sub-types: Nominal and Ordinal data.

Nominal Data: These are groups, labels or names that have no specific order or ranking. Examples include color (green, white), furniture type (desk, table), religion and gender.
Ordinal Data: These are groups, labels or names that have a natural order or ranking. Examples include order of appearance (first, second, last), survey responses (disagree, neutral, agree) and education levels (primary, secondary, tertiary).

Quantitative Data

Quantitative data, also known as numerical data, uses numbers to measure or count things, indicating how much or how many. It is further classified into two types: Discrete and Continuous data.

Discrete Data: Represents whole numbers that can be counted. They do not include decimals or fractions. Examples include the number of students in a class, the number of patients in a hospital or the number of wards in a hospital.
Continuous Data: Represents measurements that can take a range of values, including decimals and fractions. Examples include weight, temperature and time.

Understanding data types is essential because they guide the methods we use to summarize our data.

For example, calculating the mean of the departments variable in a hospital dataset would not be meaningful because departments are categories. Instead, we might look at how many patients went to each department and the percentage they represent. For age, however, calculating the mean or median can be meaningful because age is a numerical variable.

In Python, we can use different methods to summarize these variables.

healthaccess_data["age"].describe()
# .describe() summarizes a numerical variable using statistics such as the mean, standard deviation, minimum, quartiles, and maximum.

Output:

count   50000.00
mean       36.81
std        19.02
min         0.00
25%        24.00
50%        36.00
75%        49.00
max        84.00
Name: age, dtype: float64

For a categorical variable such as department:

healthaccess_data["department"].value_counts()
# .value_counts() counts the number of observations in each category.

Output:

department
General Practice (Gp)    20783
Maternity                 8564
Tb/Hiv Clinic             4150
Oncology                  3362
Emergency & Casualty      3348
Paediatrics               2341
Renal/Dialysis            2206
Cardiology                2176
Surgery                   1127
Icu / Hdu                 1089
Ophthalmology              854
Name: count, dtype: int64

The important point is that different types of data require different ways of summarizing them.

Once we know what type of data we are working with, we can then explore where the data tends to be centered, leading us to the second question:

2. Where is my data centered?

When we talk about the center of a variable, we are looking for a value that gives us an idea of where the observations tend to cluster. These are known as measures of central tendency.
The three main measures are the mean, median and the mode.

The mean

The mean is the sum of all values in the dataset, divided by the number of of values in the dataset.

Formula

x ˉ = \frac{\sum x}{n}

Where:

$x ˉ$ is the mean
$x$ is each value, therefore $\sum x$ is the sum of all values
$n$ is the number of values

If the ages are 20, 25, 30, 35 and 40:

$x ˉ = \frac{20 + 25 + 30 + 35 + 40}{5}$

In Python, we calculate the mean using the .mean() method.

healthaccess_data["age"].mean()

Output:

np.float64(36.80748)

Because it takes every value in the dataset into account, the mean is a strong measure of central tendency because no observation is ignored when calculating the average.

As each value contributes to the final result, an unusually large or unusually small value can pull the mean away from where most of the observations lie. These unusual observations are known as outliers.

In the presence of outliers, therefore, the mean cannot be relied on as an accurate representation of the center, and an alternative measure is chosen.

The median

The median is the middle value of a set of data arranged in order of magnitude. It is less affected by outliers.

If you have ages as 35, 29, 28, 67, 27, 30, 32, 33 and 31

To get the median, you first you sort your ages in order of magnitude, i.e. from the smallest value to the largest value

ages = 27, 28, 29, 30, 31, 32, 33, 35, 67

The median is the value in the middle, i.e. 31

If the dataset has an even number of observations, then you simply add the two middle values, then divide by two to get the median

ages = 28, 29, 30, 31, 32, 33, 35, 67

The median is:

$\frac{31 + 32}{2} = 31.5$
In Python, we calculate the median using the .median() method.

We can compare the mean and median of the bill amount in our hospital dataset to see how the extremely high bill amounts affect the mean.

mean = healthaccess_data["bill_amount_ksh"].mean() 
median = healthaccess_data["bill_amount_ksh"].median() 
print(f"Mean: {mean}")
print(f"Median: {median}")

Output:

Mean: 30011.5429522
Median: 4420.695

The mean is significantly larger than the median because extremely high bill amounts are pulling the mean upwards. The median is less affected by extreme bill amounts, and is therefore a more representative measure of the typical bill amount.

The mode

The mode is the most appearing observation in a dataset.
Unlike the mean and median, which can only be used with numerical data, the mode can be used with both numerical and categorical data. On a bar chart or histogram, the highest bar often represents the mode.

In Python, we get the mode using the .mode() method.

# Department with the most visits.
healthaccess_data["department"].mode() 

# The most observed patient age
healthaccess_data["age"].mode()

Output:

Department with most visits: 0    General Practice (Gp)
Name: department, dtype: object
Most common patient age: 0   36.00
Name: age, dtype: float64

Sometimes, the most frequently occurring value is not close to the center of the data and therefore the mode may not always be the best representation of the center of the data.

The mode can also become difficult to interpret when a dataset has two or more values with the same highest frequency. When two values tie in frequency, it is described as bimodal, while a tie with more than two is multimodal. It may be challenging to interpret and decide the center of the data in such cases.

There is no single measure of central tendency that is universally the best. The best choice depends on the nature of the data, its distribution and the objective of the analysis. Comparing the mean, median, and mode allows us to view our data from different perspectives and choose the measure that best represents it.

Now that we understand the type of data we are working with and where our data is centered, we need to understand how much the observations vary from that center. This brings us to our third question:

3. How spread out is my data?

2 datasets have the same mean of 10

Dataset A: 8, 9, 10, 11, 12

Dataset B: 2, 6, 10, 14, 18

While they have the same mean, we observe the values in Dataset A are closely grouped around the mean, while values in Dataset B are much more spread out.

To understand how spread out our data is, we use measures of dispersion. These are numerical values that describe the extent of variation among data points.

The main measures of dispersion that we will cover in this article are Range, Variance, Standard Deviation and Inter Quartile Range(IQR)

Range

The range is the difference between the largest and smallest values in your observation.

$R an g e = M a x im u m - M inim u m$

In Python, we can get the range using the .max() and .min() methods

age_range = healthaccess_data["age"].max() - healthaccess_data["age"].min()
bill_amount_range = healthaccess_data["bill_amount_ksh"].max() - healthaccess_data["bill_amount_ksh"].min()

print(f"Age Range : {age_range}")
print(f"Bill Amount Range : {bill_amount_range}")

Output:

Age Range : 84.0
Bill Amount Range : 634333.4900000001

The range is easy to calculate and gives a quick idea of the spread, but it only considers the two extreme values. This means it is very heavily influenced by outliers.

Variance

Variance gives us a measure of how far the observations tend to be from the mean.

Variance is calculated by finding the difference between each observation and the mean, squaring those differences, adding all the squared differences, and then dividing their sum by the number of observations.
We square the differences so that negative and positive deviations do not cancel each other out.

Formula

$Variance = \frac{\sum ( x - x ˉ ) ^{2}}{n}$

Where:

$x$ represents each observation (the values of your numeric column)

$x ˉ$ represents the mean

$n$ is the number of observations

$\sum$ means adding all the squared differences

In Python, variance is calculated using the .var() method.

(healthaccess_data["age"].var()).round(2) 
# Calculates the variance and rounds the result to 2 decimal places.

Output:

np.float64(361.92)

Although variance tells us about the spread of our data, its units are squared. For example, as seen in the output, our age column in years ahs its variance expressed in squared years. This can make it difficult to interpret directly. This is why often standard deviation is preferred.

Standard Deviation

Standard deviation is a widely used measure of dispersion. It is achieved by finding the square root of the variance, bringing the measure of spread back to the same units as the original data.

$Standard Deviation = Variance$

A smaller standard deviation means that the observations tend to be closer to the mean, while a larger standard deviation indicates that the observations are more spread out.

In Python, standard deviation is calculated using the .std() method

healthaccess_data["age"].std().round(2)
# Calculates the standard deviation of patient ages and rounds the result to 2 decimal places.

Output:

np.float64(19.02)

The standard deviation of patient age is 19 years, meaning that patient ages have a substantial amount of variation around the mean, with observed ages ranging from 0 to 84 years.

Inter Quartile Range (IQR)

Another useful measure of spread is the interquartile range (IQR), which looks at the middle 50% of the data and is less affected by extreme values. The IQR therefore captures the range containing the middle 50% of observations.

Formula

IQR = Q 3 - Q 1

Where:

Q1 = 25th percentile

Q3 = 75th percentile

In Python, Q1 and Q3 are obtained using the .quantile() method, which identifies the value at a specified position within the distribution. 0.25 gives us the 25th percentile (Q1), 0.5 gives us the 50th percentile (Q2), while 0.75 gives us the 75th percentile (Q3).

To find the IQR for our age variable therefore;

IQR = healthaccess_data["age"].quantile(0.75) - healthaccess_data["age"].quantile(0.25)

Output:

np.float64(25.0)

The IQR is 25 years, meaning the middle 50% of patient ages are spread across a range of 25 years.

Together, the measures of dispersion give us a better understanding of how much our observations vary. The choice of measure depends on the nature of the data and how affected it is by extreme values.

Having understood both the center and spread of data, the next step is to examine the shape and pattern of the distribution, which brings us to the final question:

4. What does the distribution of my data look like?

A distribution shows how the values in a dataset are spread across the possible range of values. Looking at a distribution helps us identify patterns such as where values are concentrated, how widely they are spread, and whether there are unusual observations.

In our hospital dataset, we can use histograms to visualize the distribution of our numerical variables.

A histogram groups numerical values into intervals, or bins, and shows how many observations fall within each interval.

sns.histplot(data=healthaccess_data, x="age")
plt.show()

Output:

We can use the same approach to examine the distribution of bill amounts:

sns.histplot(data=healthaccess_data, x="bill_amount_ksh", kde = True)
plt.show()

Output:

As we can observe from the histograms, the shape of a distribution can vary depending on how the observations are spread across the range of values. These patterns are commonly described as symmetrical, right-skewed, or left-skewed.

Symmetrical Distributions

A symmetrical distribution is one where the observations are distributed in a similar way on either side of the center. A normal distribution is a specific type of symmetrical distribution with a characteristic bell-shaped curve.

In an approximately normal distribution, most observations are concentrated around the center, with fewer observations occurring toward either end. The mean, median, and mode are also typically equal or very close to one another because the data is balanced around the center.

The age distribution in our hospital dataset is approximately bell-shaped, with the mean, median, and mode all equal to 36 years. This suggests that the distribution is approximately symmetrical, with observations concentrated around the center and becoming less frequent toward either end.

Right Skewed Distribution

In some cases, you may find most observations concentrated toward the lower values, while a smaller number of larger values extend the distribution toward the right. This is known as a right-skewed distribution, or positively skewed distribution.

In a right-skewed distribution, the tail extends toward the higher values, while most observations are concentrated on the lower end.

Our bill amount provides an example of this pattern. Most bill amounts are concentrated at the lower end, while a smaller number of extremely high bills create a long tail to the right.

Because the higher values pull the mean toward the right, the mean is typically larger than the median in a right-skewed distribution. making the median a more representative measure of the center.
This is why, when we examined the bill amounts earlier, the median was more useful than the mean for describing a typical bill.

Left Skewed Distribution
A left-skewed distribution, also known as a negatively skewed distribution, occurs when most observations are concentrated toward the higher values, while a smaller number of lower values create a longer tail toward the left.

Because the lower values pull the mean toward the left, the mean is typically smaller than the median in a left-skewed distribution.

Identifying Outliers

As seen above, the tail of a distribution can give us an initial clue about extreme values. To identify outliers more systematically, we need to look at the individual observations and use specific methods for detecting them. The interquartile range (IQR) can be used to identify potential outliers.

The IQR rule

It defines potential outliers as observations that fall below the lower bound or above the upper bound:

$Lower Bound = Q 1 - 1.5 (I QR)$
$Upper Bound = Q 3 + 1.5 (I QR)$

Any observation below the lower bound or above the upper bound is considered a potential outlier.

In Python, we can calculate these boundaries using the first and third quartiles:

# First calculate the IQR
Q1 = healthaccess_data["bill_amount_ksh"].quantile(0.25)
Q3 = healthaccess_data["bill_amount_ksh"].quantile(0.75)

IQR = Q3 - Q1
# Then the upper and lower bounds
lower_bound = Q1 - 1.5 * IQR
upper_bound = Q3 + 1.5 * IQR

# Entries with potential outliers 
outliers = healthaccess_data[(healthaccess_data["bill_amount_ksh"] < lower_bound) |
    (healthaccess_data["bill_amount_ksh"] > upper_bound)]

For our hospital dataset, this is useful for the bill amount observations, where we have some extremely high values. These explain the right-skewed shape of the distribution and why the mean is substantially higher than the median.

Because it focuses on the middle 50% of observations, the IQR rule is less affected by extreme values.

Visualizing Outliers with a Boxplot

A boxplot provides another way to visualize the distribution of a numerical variable. It displays the median, quartiles, upper and lower limits and potential outliers, making it useful for quickly assessing both the spread and outliers.

We can use a box plot to visualize outliers in the bill amounts

sns.boxplot(data=healthaccess_data, x="bill_amount_ksh")
plt.show()

Output:

The box represents the middle 50% of observations, with the line inside the box showing the median. Values that fall beyond the whiskers are typically shown as individual points and may represent potential outliers.

Conclusion

Descriptive statistics gives us a way to make sense of our data before moving on to more advanced analysis. Throughout this article, we have seen how asking four simple questions can help us build a clearer picture of what our data looks like.

The important lesson is that no single statistic tells us everything about our data. We get a much better understanding by looking at the type, center, spread, and distribution together. These descriptive summaries provide a foundation for making informed decisions about how to explore and analyze our data further.

Part 1: Why Statistics Matters in Data Science

Sharon-nyabuto — Sun, 16 Aug 2026 17:45:47 +0000

Introduction

When we hear the term data science, the first things that may come to mind are Python, SQL, machine learning, or perhaps artificial intelligence.

And while all of these are important parts of data science, there is another field that sits underneath much of the work we do with data: statistics.

Statistics gives us ways to describe data, understand variation, identify patterns, quantify uncertainty, and draw conclusions from evidence. Data science brings these ideas together with programming, mathematics, computing, and domain knowledge to solve problems using data.

So before we get into distributions, probability, hypothesis testing, or statistical models, I think it is worth taking a step back and asking a more fundamental question:

Why does statistics matter in data science?

Data Alone Is Not Enough

Having a dataset does not automatically mean that we understand what is happening in it.

For example, imagine we have a dataset containing 50,000 hospital visits. We may have information such as patient age, diagnosis, department, insurance type, admission status, and length of stay. At first, we simply have a collection of records. But if we want to understand what is happening in the hospital, we might ask:

Which departments have the longest patient stays?
What is the typical length of stay?
How much does length of stay vary between patients?
Are some patient groups more likely to be admitted?

Answering these questions requires us to find patterns and relationships within the records.

We might find, for example, that patients in one department have a higher average length of stay than patients in another. But is that difference meaningful? How much variation exists within each department? Could the difference simply be due to the particular patients included in our data?

These are statistical questions.

Statistics gives us a framework for asking these kinds of questions and making sense of the answers. It provides the tools to describe what we are seeing, understand the variation in our data, and draw conclusions from the patterns we observe. We are then able to turn large collections of observations into answers

The University of Michigan describes statistics as a way of learning from data and emphasises the importance of understanding how data is collected and how it can be used to answer questions. This is an important distinction:

Collecting data is not the same as understanding data.

Where Does Statistics Fit Into Data Science?

Data science is an interdisciplinary field. It brings together statistics, mathematics, computer science, programming, analytics, and domain knowledge.

Each of these contributes something different.

Programming helps us work with and manipulate data.
Computer science provides the computational tools and systems we use to process data.
Mathematics provides the foundations behind many of the methods we use.
Statistics helps us understand data, variation, uncertainty, and evidence.
Domain knowledge helps us understand what the data actually represents.

The American Statistical Association describes statistics as an important part of data science and highlights its role in areas such as statistical summaries, inference, uncertainty, and the extraction of knowledge from data.

UCLA similarly describes statistics as a foundation of data science, while recognizing the increasingly close relationship between statistics, mathematics, and computer science.

So while data science is broader than statistics, statistics remains one of the disciplines that helps us reason about the data we work with.

Statistics Helps Us Understand Variation

One of the first things we encounter when working with real-world data is variation.

People do not all earn the same income.

Patients do not all spend the same amount of time in hospital.

Students do not all receive the same grades.

Households do not all have the same number of members.

Even when we are measuring the same thing, our observations can differ.

Statistics gives us tools for describing this variation. Measures such as the mean, median, range, variance, standard deviation, and interquartile range help us understand where our data is centered and how widely the observations are spread.

For example, two hospital departments could both have an average length of stay of 5 days. At first, it might seem that patients in the two departments have similar stays. But suppose the stays in Department A are mostly between 4 and 6 days, while Department B has patients staying anywhere from 1 to 12 days.

The average is the same, but the amount of variation is very different. Looking only at the average would therefore leave out an important part of the story.

A single summary value can sometimes fail to reveal all what is really happening in the data.

And this brings us to one of the concepts we will explore later: distributions.

Statistics Helps Us Understand Uncertainty

Real-world data is rarely perfect. When we analyze data, we are often working with some level of uncertainty.

We may not have information about everyone we are interested in, some observations may be missing or measured inaccurately, and even carefully collected data can contain differences that occur simply due to chance.

Consider a survey of 1,000 people. We might use their responses to learn about a much larger population, but those 1,000 people are only a sample of the population we are interested in. The results we observe in our sample may therefore not be exactly the same as what we would find if we could ask everyone.

Statistics gives us methods for understanding and quantifying this uncertainty, helping us determine how much confidence we can place in the conclusions we draw from our data.

This is another one of the reasons statistics is important in data science: it helps us understand how certain we can be about what the data says.

Statistics Helps Us Ask Better Questions

Statistical thinking is useful before we begin analyzing our data. Good analysis starts with understanding the problem we are trying to solve and whether the data we have can actually help us answer it.

Before any analysis or creating models, we need to understand our data by asking:

What are we trying to find out?
What exactly are we measuring, and who or what does the data represent?
How was the data collected?
What limitations or potential sources of error exist in the data?
Is the data appropriate for answering the question we are asking?

Only then can we determine whether the data is suitable for the analysis we want to perform.

The University of Michigan's introduction to data science places emphasis on starting with a question and using data systematically to investigate it.

This means statistical thinking can influence our analysis, even before we write our code.

Statistics and Data Science Tools

Data science involves many tools, from Python and SQL to visualization and machine learning. Python can calculate a mean, but statistics helps us decide whether the mean is useful. A visualization can reveal a pattern, but statistical thinking helps us determine what that pattern actually tells us. Statistics helps us move from working with data to reasoning about data.

So, Do Data Scientists Need Statistics?

The short answer is yes.

That does not mean every data scientist needs to become a theoretical statistician. Data science is broad, and different roles require different combinations of skills.

But understanding statistics provides a foundation for thinking critically about data.

What We Will Explore Next

This article is the starting point for a deeper exploration of the subject.

Before getting into statistical tests and models, we need to understand some of the building blocks that make those methods possible.

One of the first is distributions

When we collect observations, those observations have a pattern of values and variation. Understanding that pattern helps us describe our data, identify unusual observations, choose appropriate summary measures, and eventually understand which statistical methods may be appropriate.

Final Thoughts

Learning statistics is more about learning how to reason with data.

As we explore the subject in future articles, we will build that understanding step by step, from distributions and descriptive statistics to probability, sampling, inference, and statistical testing.

There is a lot to cover, but we will take it one concept at a time.

I look forward to learning and sharing what I learn!

Building a Student Results Management System with Python

Sharon-nyabuto — Sun, 09 Aug 2026 14:38:31 +0000

From Python basics to a working project.

Over the past weeks, we have worked through an eight-part Python learning series, building the knowledge and skills needed to write clear, structured, and reusable Python programs.

In the series, we explored conditional statements, loops, functions, and other essential programming concepts, gradually learning how each one helps us solve a different kind of problem.

If you missed any of the articles in the series or would like a refresher before continuing, take a moment to explore them here.

Students Result Management System

In this article, we will build a Student Results Management System from scratch. In the process, we will revisit many of the concepts we've covered throughout the series and see how they work together to build a complete program.

Project Scenario

A local High School has hired you to build a system for managing student examination results. The school requires a program that can:

Add a new student and their marks
Read and display all students already saved
Calculate each student's average mark and grade
Find the top student and class average
Save all data to a file (so it persists between runs)
Print a formatted report for the whole class

We'll build the application step by step, and test each component before moving on to the next.

Step 1: Setting Up the Project

For this project, I used Visual Studio Code with the Jupyter Notebook and Python extensions. The main program was developed in a Jupyter Notebook, while the supporting modules were created as Python files. You can use another Python environment if you prefer; the concepts and syntax remain the same.

Begin by creating a folder named Student_results_system on your computer. Inside the project folder, create the following Python files:

Student_results_system/
│
├── main.py
├── logic.py
├── file_handler.py
└── report.py

Each file will have a specific responsibility throughout the project:

main.py : Controls the overall program flow and displays the menu.
logic.py : Contains functions for calculating averages, and assigning grades.
file_handler.py : Saves and loads student records to and from a CSV file.
report.py : Generates and displays the final student report.

With our project structure in place, we're ready to start building.

Step 2: Building the Interactive Menu

In our Students Results Management System, the starting point is the main menu.

We will build the basic menu structure that allows users to select an option. We want the program to keep running so that the user can choose different options until they decide to exit. For this, we will use a while loop.
So in the main.ipynb script, let us create the following menu

print("\n====STUDENT RESULTS MANAGEMENT SYSTEM ====")
print("1. Add Student")
print("2. View Students")
print("3. Generate Report")
print("4. Exit")

while True:
    choice = input("Select an option: ")
    if choice == "1":
        print("Add Student selected.")
    elif choice == "2":
        print("View Students selected.")
    elif choice == "3":
        print("Generate Report selected.")
    elif choice == "4":
        print("Goodbye!")
        break
    else:
        print("Invalid choice. Please try again.")

At this stage, the options will not perform their intended tasks yet. However, we need to test the menu before adding the rest of the code.

Test it: Run the program and test each menu option. Selecting options 1, 2, and 3 should display a confirmation message, while selecting 4 should terminate the program. If any other value is entered, an 'Invalid choice' message is displayed, and you're prompted again.

Step 3: Adding Student Records

We will now begin by asking the user to enter a student's name and marks. Since the system will eventually store multiple students, we will create an empty list named students. Every time a new student is added, their details will be stored in this list as a dictionary.

Let's begin by creating an empty list at the very beginning of the code:

students = []

We'll then modify the Add Student option to collect the student's details.
In the main.ipynb notebook, replace

print("Add Student selected.")

The code then becomes:

students = []

subjects = ["Mathematics", "English", "Science", "History", "Kiswahili", "Physics"]

while True:
    print("\n===== STUDENT RESULTS MANAGEMENT SYSTEM =====")
    print("1. Add Student")
    print("2. View Students")
    print("3. Generate Report")
    print("4. Exit")

    choice = input("Select an option: ")
    if choice == "1":
        name = input("Enter student name: ")
        student = {"name": name}
        for subject in subjects:
            mark = float(input(f"Enter {subject} marks: "))
            student[subject] = mark
        students.append(student)

        print(f"\n{name} has been added successfully!")
    elif choice == "2":
        print("View Students selected.")
    elif choice == "3":
        print("Generate Report selected.")
    elif choice == "4":
        print("Goodbye!")
        break
    else:
        print("Invalid choice. Please try again.")

You'll notice we have introduced a list called subjects, which allows us to use a loop to collect marks for each subject, rather than having multiple separate input statements for each subject.
At this stage, the program can accept multiple student records.

Test it: Add a student and confirm that their name and marks for all six subjects are accepted successfully. Check that the [name] has been added successfully! confirmation appears.

Step 4: Viewing Student Records

When the user selects Option 2, the program should display all the students entered so far, together with their marks in each subject. If no students have been added yet, the program should inform the user instead of displaying an empty report.

So our View Students section is updated as follows;

students = []

subjects = ["Mathematics", "English", "Science", "History", "Kiswahili", "Physics"]

while True:
    print("\n===== STUDENT RESULTS MANAGEMENT SYSTEM =====")
    print("1. Add Student")
    print("2. View Students")
    print("3. Generate Report")
    print("4. Exit")

    choice = input("Select an option: ")
choice = input("Select an option: ")
    if choice == "1":
        name = input("Enter student name: ")
        student = {"name": name}
         while mark < 0 or mark > 100:
                print("Mark must be between 0 and 100.")
                mark = float(input(f"Enter {subject} marks: "))
            student[subject] = mark
        students.append(student)
        print(f"\n{name} has been added successfully!"

    elif choice == "2": 
        if not students: 
            print("\nNo student records found.") 
        else: 
            print("\n===== STUDENT RECORDS =====")        
        for student in students: 
            print(f"\nStudent: {student['name']}") 
            for subject in subjects: 
                print(f"{subject}: {student[subject]}")
    elif choice == "3":
        print("Generate Report selected.")
    elif choice == "4":
        print("Goodbye!")
        break
    else:
        print("Invalid choice. Please try again.")

Test it: Add a few students then select View Students option. The program should display every student and their marks.

Step 5: Calculating Student Averages and Grades

We can now record and retrieve student details and exam results from our Student Records Management System. We would now like to calculate each student's average mark and assign a grade based on that average.

As programs grow, separating different responsibilities into modules makes the code more efficient, easier to read, test and maintain. This next step will be placed in the logic.py file we created in Step 1 above.

In logic.py, create the following function:

def calculate_results(student):
    marks = [
            student["Mathematics"],
            student["English"],
            student["Science"],
            student["History"],
            student["Kiswahili"],
            student["Physics"]]
    average = sum(marks) / len(marks)
    if average >= 80:
        grade = "A"
    elif average >= 70:
        grade = "B"
    elif average >= 60:
        grade = "C"
    elif average >= 50:
        grade = "D"
    else:
        grade = "E"
    return average, grade

Next, import the function into main.py

from logic import calculate_results

This allows main.py to access the grading logic without rewriting it, keeping the code organized, and reusable. If the grading criteria changes in the future, we only need to update the function.
Finally, update the View Students option to calculate and display each student's average and grade:

elif choice == "2":
    if not students:
        print("\nNo student records found.")
    else:
        print("\n===== STUDENT RECORDS =====")

        for student in students:
            average, grade = calculate_results(student)
            print(f"\nStudent: {student['name']}")
            for subject in subjects:
                print(f"{subject}: {student[subject]}")
            print(f"Average: {average:.2f}")
            print(f"Grade: {grade}")

Test it: Run the program again and add a few students with different marks. When you select View Students, each student's marks should now be accompanied by their calculated average and final grade.

Step 6: Saving Student Records to a CSV File

Our Student Results Management System can add students, display their records, and calculate averages and grades. However, once the program closes, all the student records are lost.

To prevent this, we will save each student record to a CSV file. Remember the file_handler.py file we created in step 1? That is where we will add the function responsible for saving student records.

Open file_handler.py and add the following code:

import csv
import os

def save_student(student):
    file_exists = os.path.isfile("students.csv")

    with open("students.csv", "a", newline="") as file:
        writer = csv.DictWriter(
            file,
            fieldnames=["name", "Mathematics","English","Science","History","Kiswahili","Physics"])
        if not file_exists:
            writer.writeheader()
        writer.writerow(student)

The save_student() function saves a student record to students.csv. It first checks whether the file already exists, then opens it in append mode so existing records aren't overwritten. If the file is new, it adds the column headers before writing the student's record as a new row.

We will then import the function from file_handler.py into main.ipynb:

from file_handler import save_student

Finally, update the Add Student option so that each new record is saved immediately after being added to the list:

students.append(student)
save_student(student)

print(f"\n{name} has been added successfully!")

Test it: Run the program and add a few students. A new file named students.csv should automatically be created in your project folder. Opening the file should display all the student records entered into the system.

Step 7: Loading Student Records

Our application now saves student records to a CSV file, ensuring they aren't lost when the program closes. However, each time the application starts, the students list is empty.

We'll create a function that reads the CSV file and loads all existing records into the students list when the program starts.

In the file_handler.py file, we will add the following function:

def load_students():
    students = []
    if not os.path.isfile("students.csv"):
        return students
    with open("students.csv", "r") as file:
        reader = csv.DictReader(file)
        for row in reader:
            student = {"name": row["name"]}
            for subject in row:
                if subject != "name":
                    student[subject] = float(row[subject])
            students.append(student)
    return students

The load_students() function reads the saved records from students.csv and converts them back into a list of student dictionaries that the program can work with. It checks that the file exists, reads each student record, converts the marks back to numbers, and returns the complete list.

Next we import the function into main.ipynb:

from file_handler import load_students

Finally, at the very start of the code replace:

students = []

with:

students = load_students()

Now, whenever the program starts, it will automatically load all previously saved student records from the CSV file.

Test it: Run the program, adding a couple of student records. Close and reopen the program, then select View Students without adding any new records. You should be able to see the previously recorded details.

Step 8: Generating a Student Performance Report

The final feature is to generate a summary report that provides an overview of the class performance.
The report will answer:

How many students are in the system?
What is the class average?
Who is the top-performing student?
Who has the lowest average?

To keep our project organized, we'll create the function in the report.py file.

from logic import calculate_results

def generate_report(students):
    if not students:
        print("\nNo student records found.")
        return

    print("\n="*30)
    print("      EASTSIDE HIGH SCHOOL - REPORT")
    print("="*30)
    print(f"{'Name':<20} {'Average':<10} {'Grade':<5}")
    print("-"*30)

    class_total = 0
    highest_average = -1
    highest_student = ""
    for student in students:
        average, grade = calculate_results(student)
        print(f"{student['name']:<20} {average:<10.1f} {grade:<5}")
        class_total += average
        if average > highest_average:
            highest_average = average
            highest_student = student["name"]
    class_average = class_total / len(students)

    print("-"*30)
    print(f"Class Average: {class_average:.1f}")
    print(f"Top Student: {highest_student} ({highest_average:.1f})")
    print("="*30)

Next, import the generate_report function to the main.ipynb as follows;

from report import generate_report

In the choice == 3 section (Generate Report) in the main.ipynb file, replace

print("Generate Report selected.")

With:

 generate_report(students)

Conclusion

And that's a wrap on the Student Results Management System!

In this project, we brought together many of the concepts from the Python Fundamentals series, including loops, functions, dictionaries, file handling, and modules, and saw how these individual concepts can work together to create a functional Python application.

You can find the folder structure and all the code we have written here: Student Result Management System

The system is simple, but there is plenty of room to experiment and improve it. Keep practicing, keep building, and don't stop learning.

If you build your own version, put your own spin on it, or find a better way of doing something, feel free to share it. I'd love to see what you come up with and hear your ideas for improving the system.

Writing Reusable code in Python

Sharon-nyabuto — Mon, 03 Aug 2026 21:41:41 +0000

Understanding Functions

Previous articles in this series have guided us on how to make decisions, repeat tasks, and solve increasingly complex problems using Python.
As our programs grow, another challenge begins to emerge; repeating codes we need to use more than once.

Say you've written a program that checks a dataset for missing values. Later on, you need to perform the same check on a different dataset. Do you copy and paste the same code, or is there a better way?
Fortunately, Python allows us to group reusable code into a function, making it easy to use the same logic whenever we need it, entirely avoiding the repetition.

What is a Function?

A function is a reusable block of code that performs a specific task.
Functions allow us to package reusable code into a named block so we can call it whenever we need it, instead of writing the same logic repeatedly.
Functions don't just save typing, they make code reusable.

Defining your first function

Consider a task on analyzing several household survey datasets collected over different years. Before analyzing each one, you want Python to display the same message indicating that the analysis has started.

Without functions, you would need to write the same line of code every time.

print("Analyzing household survey dataset...")
print("Analyzing household survey dataset...")
print("Analyzing household survey dataset...")

While this works, repeating the same code easily becomes difficult to maintain. If you later decide to change the message, you would have to edit it everywhere it appears.

Instead, Python allows us to define a function once and call it whenever we need it.

def analyse_dataset():
    print("Analysing household survey dataset...")

Let's break it down:

def Is the keyword that tells Python that you are defining a new function.
analyse_dataset is the function's name. It should be a descriptive name, i.e. it should explicitly describe what the function does.
() is where any information the function needs (known as parameters) will go. For now, the parentheses are empty because our function doesn't require any input.
: marks the beginning of the function body.
The indented code underneath is the set of instructions Python executes each time the function is called.

Notice that nothing happens yet. This is because defining a function only tells Python that it exists. The code inside the function will not run until we explicitly call it.

Calling a function

Once a function has been defined, you can execute it simply by writing its name followed by parentheses. This is what is known as calling the function

In the case of our example above, we simply write the name of the function whenever we need it, as many times as we would need it.

analyse_dataset()
analyse_dataset()

the output:

Analysing household survey dataset...
Analysing household survey dataset...

Let's see how we can have a function performing a specific task.

Scenario: You've received a household survey dataset. Before analyzing it, you want to know how many records are complete.

# The dataset
household_survey = [
    ["HH001", 25000, 4], ["HH002", None, 3],
    ["HH003", 18000, None], ["HH004", 32000, 5],
    ["HH005", None, 6]]  

# The function
def count_complete_records():
    complete = 0

    for row in household_survey:
        if None not in row:
            complete += 1
    print(f"Complete records: {complete}")

# Calling the function
count_complete_records()

What happens Step by Step:

Python defines the function count_complete_records().
When the function is called, it loops through the dataset.
Each row is checked to see if it contains any missing values (None).
If the row is complete, the counter increases by one.
After checking every record, Python prints the total number of complete records, i.e.

Complete records: 2

This function works well, but it has one limitation. It is written specifically for the household_survey dataset because the dataset is hardcoded inside the function.
If we needed to count complete records in a different survey, we would either have to edit the function or create another one. When working with multiple datasets, this becomes a little inefficient.
Fortunately, it is possible to write one function that works with different datasets.

Parameters

Rather than storing the dataset inside the function (as we did in the example above), Python allows us to pass the dataset into the function whenever it is called. We do this using parameters.

A parameter is a variable listed inside a function's parentheses. It acts as a placeholder that receives the information passed to the function when it is called.

def count_complete_records(dataset):
    complete = 0

    for row in dataset:
        if None not in row:
            complete += 1
    print(f"Complete records: {complete}")

Notice the difference between this function and the previous one. This time, the function includes a parameter, dataset.

In this case, dataset acts as a placeholder for the dataset we want the function to work with. Because the dataset is no longer hardcoded into the function, the same code can be used with different datasets.

But where does the parameter get its value?

It receives its value when the function is called. For example:

count_complete_records(household_survey)

Notice another difference here. This time, the parentheses contain the name of the dataset we want to analyse. This is known as an argument.

When the function is called, Python takes the value of household_survey and passes it to the parameter dataset.
From that point onwards, every time the function refers to dataset, it is working with household_survey.

Parameter             Argument

dataset   <─────── household_survey

In simple terms, the parameter is the placeholder inside the function, while the argument is the actual value you provide when calling the function.

Now if we needed to count the number of complete records in the economic impact survey below;

economic_impact_survey = [
    ["B001", None, "Farmer"],
    ["B002", 150000, "Trader"],
    ["B003", None, "Fisher"],
    ["B004", 12000, "Farmer"],
    ["B005", 15000, "Farmer"], 
    ["B006", None, None]
]

we would not need to modify or define the function all over again, but just pass the argument(name of the dataset) when calling the function;

count_complete_records(economic_impact_survey)

The output:

Complete records: 3

Because the function uses a parameter, it can work with any dataset that follows the expected structure.

An important point to remember is that simply existing does not make functions reusable. It is the presence of parameters that allows them to work with different inputs.

Returning Values

In the examples above, we have been displaying the results of our functions immediately using print. This is helpful for when we want to see the result.
In some situations, we do not want to see the result, but want to use the result elsewhere in the program.

Suppose we wanted to compare the number of complete records in two different datasets. Printing the result alone wouldn't allow us to perform that comparison. We would need a way for the function to send the result back to the rest of the program.

The return statement sends a value back to the place where the function was called.
Think of print() as showing the result to the user, while return gives the result back to the program so it can continue working with it.

Let's modify our function;

def count_complete_records(dataset):
    complete = 0

    for row in dataset:
        if None not in row:
            complete += 1

    return complete

Notice that we've replaced:

    print(f"Complete records: {complete}")

with:

    return complete

Now, instead of displaying the result immediately, the function hands the value back to the program. These values can then be stored in variables;

household_complete = count_complete_records(household_survey)
economic_complete = count_complete_records(economic_impact_survey)

The variables now contain the number of complete records for each dataset, and since the values have been stored, they can be printed, compared or used in other calculations.

For example, we can compare the number of complete records in the two datasets as follows:

if household_complete > economic_complete:
    print("The household survey has more complete records.")
else:
    print("The economic impact survey has more complete records.")

The output:

The economic impact survey has more complete records.

Using the return statement makes functions far more flexible and reusable, because they can be stored in a variable and be used later.

Conclusion

In this article, we have seen how functions enable us to write reusable code, by defining them once and calling them whenever we need them. By using parameters, the same function can even work with different datasets, making our programs more flexible and easier to maintain.

This brings us to the end of our introduction to Python series. Throughout this series, we have built the skills needed to write clear, reusable Python programs, from making decisions and repeating tasks to organizing code with functions.

Continue practising beyond the examples we've explored, experiment with your own ideas, and challenge yourself with new problems. The confidence you build comes not from reading code, but from writing it.

In future articles, we will shift our focus from learning Python itself to applying these skills to data analysis, showing how they come together to solve practical problems.

Repeating Tasks Within Tasks

Sharon-nyabuto — Thu, 30 Jul 2026 06:28:44 +0000

Understanding nested loops in Python

Think about an analog clock such as the one below.

Figure 1. An analog clock.

Image: Wikimedia Commons.

For every complete rotation of the second hand, the minute hand advances by one minute. Same goes for the hour hand; for every complete rotation of the minute hand, the hour hand advances by one hour.

Programming sometimes requires this same kind of repetition. But how can we tell Python to repeat one task inside another repeated task?

The answer lies in nestedloops. By definition, a nested loop is simply a loop placed inside another loop.
For every iteration of the outer loop, the inner loop runs from beginning to end before the outer loop moves to its next iteration.

Much like the hour and minute hands on an analog clock, the outer loop advances one step only after the inner loop has completed all of its iterations.

In data analysis, nested loops are particularly useful when you need to work through two levels of data, such as rows and columns in a dataset, households within counties, or regions and their characteristics.

A nested loop can be made from any combination of for and while loops. However, you'll most commonly use a for loop inside another for loop.

Syntax

for outer_variable in outer_sequence:
    # Outer loop
    for inner_variable in inner_sequence:
        # Code to repeat

Let us revisit the clock analogy in Python;

for hour in range(1, 4):
    print(f"Hour {hour}")

    for minute in range(1, 61):
        print(f" Minute {minute}")

Here's what happens, step by step;

Python starts with the outer loop and sets hour to 1.
Before moving to the next hour, Python enters the inner loop.
The inner loop starts with minute = 1 and continues printing every minute until it reaches 60.
Once all 60 minutes have been printed, the inner loop finishes.
Python returns to the outer loop and updates hour to 2.
The inner loop starts again, printing minutes 1 through 60 for the second hour.
The same process repeats for hour = 3.
After the final hour has completed all 60 minutes, both loops end.

Result;

Hour 1
 Minute 1
 Minute 2
 Minute 3
 ...
 Minute 58
 Minute 59
 Minute 60
Hour 2
 Minute 1
 Minute 2
 Minute 3
 ..
 Minute 58
 Minute 59
 Minute 60
Hour 3
 Minute 1
 Minute 2
 Minute 3
 ...
 Minute 58
 Minute 59
 Minute 60

Notice that the minutes restart from 1 every time the hour changes. This is because the inner loop begins again from the start for every iteration of the outer loop, just as the minute hand completes a full revolution before the hour hand moves to the next hour.

Nested Loops Use cases

1. To find missing values (data cleaning)

Imagine you're checking a dataset before analysis. You need to examine every row, and within each row, inspect every column for missing or invalid values. This is a situation for nested loops because you're repeating one task (checking columns) inside another (moving through rows).

dataset = [
    ["HH001", 4, 25000, "Nairobi"],
    ["HH002", None, 18000, "Kisumu"],
    ["HH003", 6, None, "Mombasa"],
    ["HH004", 3, 32000, "Nakuru"]
]
for row in dataset:
    household_id = row[0]
    for value in row:
        if value is None:
            print(f"{household_id} has a missing value.")

The result:

HH002 has a missing value.
HH003 has a missing value.

2. To identify duplicate records (Data Quality)

Imagine you're cleaning survey data before analysis. Some respondents may have been entered twice. You can use nested for loop to compare every respondent against every other respondent to identify duplicate IDs.

respondent_ids = ["R001", "R002", "R003", "R002", "R004"]

for i in range(len(respondent_ids)):
    for j in range(i + 1, len(respondent_ids)):
        if respondent_ids[i] == respondent_ids[j]:
            print(f"Duplicate respondent found: {respondent_ids[i]}")

The result:

Duplicate respondent found: R001
Duplicate respondent found: R002

i and j are index variables. The outer loop i selects one respondent at a time, while the inner loop j compares that respondent with every respondent that follows in the list. This ensures every unique pair is checked once, making it possible to detect duplicate IDs.

3. To find a specific value in your table (Data exploration)

dataset = [
    [12, 25, 18],
    [42, 33, 17],
    [29, 56, 40]
]
target = 33
for row in range(len(dataset)):
    for column in range(len(dataset[row])):
        if dataset[row][column] == target:
            print(f"{target}: Found at Row {row + 1}, Column {column + 1}")

The result:

33: Found at Row 2, Column 2

Although nested for loops are the most common when working with collections of data, you can also combine for and while loops. This is useful when you need to process a collection while repeating a task until a condition is met.

Here are some examples that incorporate both the for and while loops.

4. Data Validation (for + while)

You're collecting survey data. Every respondent must provide a valid age before you move on to the next respondent.

respondents = ["HH001", "HH002", "HH003"]

for respondent in respondents:
    print(f"\nRecording data for {respondent}")

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

    while age < 0 or age > 120:
        print("Invalid age. Please enter an age between 1 and 120.")
        age = int(input("Enter age: "))
    print("Age recorded successfully.")

The for loop processes each respondent.
The while loop keeps asking until a valid value is entered.

The result:


Recording data for HH001
0: Invalid age. Please enter an age between 1 and 120.
-2: Invalid age. Please enter an age between 1 and 120.
21: Age recorded successfully.

Recording data for HH002
68: Age recorded successfully.

Recording data for HH003
178: Invalid age. Please enter an age between 1 and 120.
89: Age recorded successfully.

Limitations of Nested Loops

Like every other tool, nested loops have situations where they're less efficient.

As the amount of data grows, the inner loop must run for every iteration of the outer loop, increasing the total number of operations and potentially slowing down your program.

Imagine comparing every household in a dataset of 10,000 records with every other household to identify duplicates. Although this approach works, it performs a very large number of comparisons. As datasets grow, there are more efficient techniques that avoid checking every possible pair.

Nested loops are an excellent way to solve problems involving multiple levels of repetition. As we continue learning Python, we'll discover more efficient approaches for handling large datasets, particularly when working with libraries such as pandas.(We will cover these in a later series)

Conclusion

In this article, we've seen that nested loops are a practical way to solve real-world problems. Whether you're validating survey responses, checking for missing values, or comparing records, nested loops help you work through data that has multiple levels or repeated relationships.

As usual, keep experimenting by creating your own examples and thinking about tasks that involve one repeated process inside another. The more you practise, the more natural it will become to recognise when a nested loop is the right solution.

What's next?

"We've learned how to solve complex problems with loops, but what if we want to reuse that logic without writing it again?

In the next article, we'll explore functions and learn how to package reusable code into named blocks, making our programs less repetitive and easier to maintain.

Until then, happy coding!

Controlling Loops with break and continue

Sharon-nyabuto — Thu, 23 Jul 2026 08:45:15 +0000

Knowing when to stop or skip a loop in Python

In our last article we saw how we can efficiently repeat processes with for and while loops.
But what if we do not want our loop going all the way? How can we tell Python to stop a loop early or skip a single iteration, without ending the entire program?

The `break` statement

Loops are important, but sometimes we do not want every iteration to execute. This is where the break statement is helpful.
The break statement immediately terminates a loop. Once Python encounters break it exits the loop and goes on to execute the rest of the program.

Syntax:

for item in sequence:
    if condition:
        break

For example:

respondents = ["R001", "R002", "R003", "R004", "R005","R006","R007","R008"]

for respondent in respondents:
    if respondent == "R005":
        print("Respondent found!")
        break
    print(f"Checking respondents : {respondent}")

Here is what happens step by step:

Python starts the for loop and assigns the first value, "R001", to the variable respondent.
It checks whether respondent == "R005", and since "R001" is not equal to "R005", the condition is False.
Python skips the break statement and executes print("Checking", respondent), displaying:
```
   Checking respondents: R001
```
The loop repeats for "R002" all through "R004", and since none of those are still ==R005, Checking respondent is still printed.
On the next iteration, respondent becomes "R005". This time, the condition respondent == "R005"evaluates to True. Python prints:
```
    Respondent found!
```
The break statement is executed, causing Python to immediately exit the loop. The remaining items, "R006" through "R008", are never processed. The output therefore becomes:
```
    Checking respondents : R001
    Checking respondents : R002
    Checking respondents : R003
    Checking respondents : R004
    Respondent found!
```

It is important to note that the break statement does not stop the entire program, it only stops the current loop. Python proceeds to execute the next tines of code after the loop.

Here are a few more examples;

Example 1:

# Q1. A school bus can carry 30 students. Students keep boarding one by one. Stop boarding as soon as the bus is full. Print how many are on board after each student boards.

capacity = 30
students = 0

while True:
    students += 1
    capacity -= 1

    print(f"Students aboard: {students} | Seats left: {capacity}")

    if capacity == 0:
        break 

# The break statement provides the loop with an exit condition by terminating it as soon as capacity reaches 0. Otherwise it would keep running infinitely beyond 0.

Result:

Students aboard: 1 | Seats left: 29
Students aboard: 2 | Seats left: 28
Students aboard: 3 | Seats left: 27
....
Students aboard: 28 | Seats left: 2
Students aboard: 29 | Seats left: 1
Students aboard: 30 | Seats left: 0

Example 2:

#Q2:  A car park has 20 spaces. Cars keep arriving one by one. Ask if a car wants to park. If yes, reduce spaces by 1. Stop when the car park is full. Show spaces remaining after each car.

spaces = 20
cars_parked = 0

while True:
    car_parking = input("Do you want to park? (yes/no): ")

    if car_parking.lower() == "yes":
        cars_parked += 1
        spaces -= 1
        print("Go ahead and park.")
        print(f"Cars parked: {cars_parked}")
        print(f"Spaces left: {spaces}\n")

        if spaces == 0:
            print("The car park is now full.")
            break
    else:
        print("Thank you. Have a good day!")
        break

These are just two examples of where break could be used. Other situations that would require break include:

Stop searching once a specific respondent ID is found.
Exit a password prompt after the correct password is entered.
Stop processing transactions once the daily limit has been reached.
End a quiz when the user chooses to quit.

The `continue` statement

We've seen that thebreakstatement terminates a loop as soon as a specified condition is met. The continue statement behaves differently. Instead of ending the loop, it skips the rest of the current iteration and immediately moves on to the next one, without terminating the loop.

Syntax:

for item in sequence:
    if condition:
        continue

To better understand the difference between break and continue, let's use the same initial example from the break section.
Notice how changing one statement will affect the behavior of the loop.

respondents = ["R001", "R002", "R003", "R004", "R005","R006","R007","R008"]

for respondent in respondents:
    if respondent == "R005":
        continue
    print(f"Checking respondents : {respondent}")

Here is what happens step by step:

Python starts the for loop and assigns the first value, "R001", to the variable respondent.
It checks whether respondent == "R005". Since "R001" is not equal to "R005", the condition evaluates to False.
Python skips the continue statement and executes:
```
print(f"Checking respondent: {respondent}")
```
displaying:
```
Checking respondent: R001
```
The same process repeats for "R002", "R003", and "R004", with each respondent being printed.
On the next iteration, respondent becomes "R005". This time, the condition respondent == "R005" evaluates to True.
Python executes the continue statement, immediately skipping the print() statement for this iteration. As a result, "R005" is NOT displayed.
Instead of ending the loop, Python moves directly to the next iteration and continues processing "R006", "R007", and "R008" until all respondents have been checked.
The output therefore becomes;
```
Checking respondents : R001
Checking respondents : R002
Checking respondents : R003
Checking respondents : R004
Checking respondents : R006
Checking respondents : R007
Checking respondents : R008
```
As you will see from the output, the continue statement skips only the current iteration, which in our case is "R005", then proceeds with the remaining iterations until there are no more items to process.

Here are a few more examples;

#Scenario 1: A customer wants to withdraw money from an ATM. If they enter an amount greater than their account balance, ask them to enter another amount instead of ending the transaction.

balance = 10000

while True:
    amount = int(input("Enter withdrawal amount: "))
    if amount > balance:
        print("Insufficient balance.\n")
        continue

    balance -= amount
    print(f"Successfully withdrawn Kshs. {amount}. New balance: Ksh {balance}")
    break

#Scenario 2: Imagine you're analysing a survey dataset containing household incomes. Respondents who didnt disclose income are marked as -1. How can we skip these missing values while continuing to analyse the rest of the dataset?
household_ids = ["HH001", "HH002", "HH003", "HH004", "HH005", "HH006", "HH007"]
household_incomes = [25000, 18000, -1, 32000, 15000, -1, 27000]

for i in range(len(household_ids)):
    if household_incomes[i] == -1:
        continue

    print(f"{household_ids[i]} | Income: Ksh {household_incomes[i]}")

These are just two examples of where continue could be used. Other situations that would require continue include:

Ignoring duplicate records when cleaning a dataset.
Skipping products that are out of stock while processing customer orders.
Ignoring files with an unsupported format when processing multiple files in a folder.
Skipping weekends and holidays when generating a work schedule or calculating business days.

Conclusion

At the beginning of the article we asked ; How can we tell Python to stop a loop early or skip a single iteration, without ending the entire program?

We've now seen how the break and continue statements give us control over loops. While break allows us to exit a loop as soon as a condition is met, continue lets us skip the current iteration and move on to the next one. Together, they help us write programs that are efficient, flexible and more managable.

As always, don't stop with the examples in this article. Modify them, experiment with different scenarios, and challenge yourself to find other situations where break and continue can simplify your code.

What's next?

So far, we've learned how to control a single loop. But what happens when one loop isn't enough?

In the next article, we'll answer that question as we explore nested loops.

Repeating Tasks Without Repeating Code

Sharon-nyabuto — Fri, 17 Jul 2026 19:38:12 +0000

Using `for` and `while` loops in Python

Now that Python can make decisions, how do we apply those decisions repeatedly?

In the last article, we learned how to guide Python through multiple levels of decision-making using nested if statements. But making decisions is only part of what makes Python pretty powerful.

Picture this: You've just landed your first data analysis task. Your dataset contains 9,000 respondents, and you need to perform the same check on every single record. After writing the same line of code a few times, and dodging errors, you stop and think: There has to be a better way than copying and pasting this thousands of times... right?

There is. It's called a loop, and by the end of this article, you'll know exactly how to use one, and get that task done in a fraction of that time.

The FOR Loop

A for loop is used to repeat a block of code a specific number of times or to iterate over a sequence, such as a list, a string, or a range of numbers.

The general syntax of a for loop looks like this:

for variable in sequence:
    # Code to repeat

Where;

for : Indicates the beginning of the loop
variable: Stores the current value during each repetition. You can name it anything meaningful (number, student, county, letter, etc.).
in: Tells Python to go through each item in the sequence.
sequence: The collection being looped over, such as a range(), list, or string.
: Marks the beginning of the loop body.
Indentation : Indicates code blocks that are in the loop. Everything indented below the for statement is repeated.

Example 1: Looping over a range

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

The Result:

What happens step by Step:

Python reads the statement range(5), which produces the numbers 0, 1, 2, 3, and 4.
The first value, 0, is assigned to the variable number.
Python executes the indented code and prints:
```
0
```
Python returns to the top of the loop, assigns the next value (1) to number, and prints it, the process continues for 2, 3, and 4.
Once there are no more values left in the range, the loop ends and the program moves to the next line of code.

A quick note about range()

You may have noticed that range(5) prints the numbers 0 to 4, not 5. That's because the value passed to range() is the stopping point, and Python does not include it. In other words, range(5) means start at 0 and stop before 5.

Example 2: Looping over a list

students = ["Faith", "Sheila", "Bryan", "Sharon"]
for student in students:
    print(student)

Example 3: Combining a for loop and conditional if statement

temperatures = [22, 35, 18, 40, 29, 15, 33]

for temperature in temperatures:
        if temperature > 30:
            print(f"Temperature is: {temperature}")
        else:
         print(f"Temperature is: {temperature} (below 30)")

Output:

Temperature is: 22 (below 30)
Temperature is: 35
Temperature is: 18 (below 30)
Temperature is: 40
Temperature is: 29 (below 30)
Temperature is: 15 (below 30)
Temperature is: 33

We've seen how for loops make it easy to repeat a block of code when we know what we're looping over, whether that's a range of numbers, a list, or another sequence. But what happens when we don't know in advance how many times a task needs to be repeated? That's where the while loop comes in.

The WHILE loop

The while loop repeatedly executes a block of code as long as a specified condition remains True. Once the condition becomes False, the loop stops.

The general syntax of a while loop looks like this:

while condition:
    # Code to repeat

Where:

while: Indicates the start of the while loop
condition: The expression that evaluates to either True or False
: Marks the beginning of the loop body.
Indented code: The block of code that is repeatedly executed for as long as the condition remains True.

Let's see how this works in practice

Example 1: printing the numbers from 1 to 5.

count = 1

while count <= 5:
    print(count)
    count += 1

The Result:

What happens step by Step:

The variable count is initialized with the value 1.
Python checks the condition count <= 5. Since 1 is less than or equal to 5, the condition is True, so the loop begins.
The statement print(count) is executed, displaying:
```
1
```
The line count += 1 increases the value of count by 1, changing it from 1 to 2.
Python returns to the top of the loop and checks the condition again. Since 2 <= 5 is still True, the loop repeats.
This process continues until count becomes 6. At that point, the condition count <= 5 evaluates to False, so the loop stops and the program moves on to the next line of code.

Why do we need count += 1/count = count + 1?

Without this line, the value of count would never change. It would remain 1, meaning the condition count <= 5 would always be True. As a result, Python would keep printing 1 forever, creating an infinite loop.

For Example:

count = 1

while count <= 5:
    print(count)

The Result:

1
1
1
1
1
...

The loop never ends because count is never updated. Since the condition always remains True, Python keeps executing the loop forever. This is called an infinite loop.
Every while loop should have a stopping condition so that it knows when to stop.

Let's do a few more examples that demonstrate how while loops are commonly used.

#Q1: You have a starting balance of 5k, and you are withdrawing 1000. So you can keep withdrawing as long as the balance is greater than withdrawal

mpesa_balance = 5000
withdrawn_amount = 1000
while mpesa_balance >= withdrawn_amount:
    new_balance = mpesa_balance - withdrawn_amount
    print(f"Request successful.Your new Balance is: Kshs: {new_balance}")
    mpesa_balance -= 1000
print(f"You have insufficient funds. Your Balance is: Ksks: {new_balance}")

# Q2. A savings account starts with Ksh 1,000. It earns 10% interest every month. How many months does it take to reach Ksh 2,000? Print the balance each month.
start_amount = 1000
interest = start_amount * 0.1
month = 0

while start_amount <=2000:
    interest = start_amount * 0.1
    start_amount = interest + start_amount
    month += 1
    print (f"After {month} months, your interest is {interest}. The account balance is {start_amount}")

Conclusion

At the beginning of this article, we imagined having to process thousands of survey responses without writing the same code over and over again. As we've seen, loops provide a much more efficient solution.
Whether you use a for loop when you know what you're iterating over, or awhile loop when repetition depends on a condition, both allow Python to automate repetitive tasks efficiently and with far less effort and error than doing them manually.

As you continue learning, try modifying the examples in this article and create a few of your own. Remember, the more you practise, the more natural it will become to recognise when a loop is the right tool for the job.

Up Next...

We've learned how to repeat a single task. So far, our loops have executed until they naturally reached the end. In the next article, we'll learn how to stop a loop early or skip specific iterations using the break and continue statements. I look forward to sharing it with you!

Making Decisions Within Decisions in Python

Sharon-nyabuto — Wed, 15 Jul 2026 06:11:48 +0000

Taking Conditional Logic Further with Nested if Statements

Previously, we learnt how to use if, elif, and else to make decisions in Python. Those allowed our programs to choose between different paths depending on whether a condition evaluated to True or False.

Most of the real world decisions depend on more than one condition.

Think about logging into your bank account to withdraw money. Entering the correct PIN is only the first step. Once you're in, the system still needs to check whether you have sufficient funds before approving the withdrawal.
How do we build that kind of layered decision-making in Python?
That's exactly what we'll explore in this article as we learn about nested if statements.

Nested `if` Statements

A nested if statement is simply an if statement placed inside another if statement. It allows a program to evaluate another condition only after the first condition has been met.

Syntax

if condition_1:
    if condition_2:
        # Code to execute

The inner if statement is only evaluated if the outer if statement is True.

Example:

Suppose you're analysing survey responses for a scholarship programme. Applicants must first be at least 18 years old. If they meet that requirement, then you can check whether their household income qualifies them for financial assistance.

age = 21
monthly_income = 18000

if age >= 18:
    if monthly_income < 30000:
        print("Eligible for the scholarship.")
    else:
        print("Age requirement met, but income is above the eligibility threshold.")
else:
    print("Applicant does not meet the minimum age requirement.")

Here's what happens step by step:

Python stores the value 21 in the variable age and 18000 in the variable monthly_income.
It evaluates the first condition: age >= 18.
Since 21 is greater than or equal to 18, the first condition evaluates to True.
Because the first condition is True, Python moves to the nested if statement and evaluates the second condition: monthly_income < 30000.
Since 18000 is less than 30000, the second condition also evaluates to True.
Python executes the nested if block and prints:

  Eligible for the scholarship.

Because both conditions were satisfied, the two else blocks are skipped and the program ends.

Notice the order of the checks. Python only evaluates the applicant's income after confirming they meet the minimum age requirement.
If the applicant were under 18, the income would never be checked because the program would immediately execute the outer else block. This is what makes nested ifstatements useful; they allow one decision to depend on the outcome of another.

Here are a few other examples, that demonstrate how multiple conditions can be evaluated one after another.

# Scenario 1: Job Application Screener

# Check whether the applicant has tertiary education. If they do, ask for their years of experience. 
# If they have at least 3 years of experience, ask for their expected salary. If the salary expectation is Ksh 80,000 or less, shortlist them for an interview; otherwise, indicate that their salary expectation is too high. 
# If they have fewer than 3 years of experience, print "Minimum 3 years of experience required." If they do not have tertiary education, print "Higher education is required for this position."

tertiary_education= input("Do you have a diploma, degree or higher?").lower()

if degree == "yes":
    experience = int(input("How many years of experince"))
    if experience >= 3:
        salary = float(input("Enter your expected salary"))
        if salary <= 80000:
            print("Shortlisted for interview")
        else:
            print("Salary expectation too high")
    else:
        print("Minimum 3 years experience required")
else:
    print("Higher education is required for this position")

# Scenario 2: Mobile Money Transfer Validator

# Write a program to validate a mobile money transfer. 
# If the user has an account, check that they have sufficient funds and that the transfer amount does not exceed the daily limit of Ksh 150,000. 
# If the transfer is successful, display the amount sent and the remaining balance. If the user does not have an account, print "Please register first."

mobile_checker = input("Do they have an active account? (Yes/No)")

if mobile_checker == "yes":
    acc_balance = float(input("What is your account balance?"))
    if acc_balance > 0:
        amount_to_send = float(input("How much do you want to send??"))
        if amount_to_send <= acc_balance:
            new_balance = acc_balance - amount_to_send
            if amount_to_send > 150000:
                print("Amount exceeded daily limit")
            else:
                print("Successful transfer")
                print(f"Amount sent: Ksh., {amount_to_send}, Your account balance is: Kshs., {new_balance}")
        else:
            print(f"Insufficient funds: Kshs., {acc_balance}")
    else:
        print("You have a low balance")
else:
    print("Please register first.")

# Scenario 3: School Report Card Generator

# Write a program that generates a student's report card. Ask for the student's name and marks (out of 100) in Mathematics, English, Kiswahili, Science, and Social Studies. For each subject, assign a grade and remark using the grading scale provided. Then calculate the total marks (out of 500), the average score, and the overall grade based on the average using the same grading scale.
# Next, determine the student's promotion status: students with an average of 75 or above are promoted, those with an average between 50 and 74 are promoted but advised to work harder, while those below 50 should repeat the class.
# Finally, check whether the student received a grade E in any subject. If so, display a warning indicating that remedial lessons are required for the relevant subject(s). 

# Print a neatly formatted report showing the student's name, subject grades, total marks, average, overall grade, promotion status and any remedial warning.

subjects = ["Maths", "English", "Kiswahili", "Science", "Social Studies"]
student_name = input("What is your name?")
print(f"{student_name} : Performance Summary")

print("==================================")
total_marks = 0
failed = ""
for subject in subjects:
    marks = int(input(f"What was your score in {subject}"))
    if 75<= marks <= 100:
        grade = "  A  - Excellent"
    elif 60<= marks <= 74:
        grade = "  B  - Very Good"
    elif 50<= marks <= 59:
        grade = "  C  - Good"
    elif 40<= marks <= 49:
        grade = "  D  - Pass"
    else:
        grade = "  E  - Need Improvement"
    total_marks += marks
    print(f"{subject} | Score: {marks} | Grade:{grade}")
    if grade == "  E  - Need Improvement":
        failed += subject + " "  
print(f"Total marks: {total_marks} / 500")
if failed: 
    print(f"NOTE: Remedial lessons required in {failed}")
    print()

average = total_marks / len(subjects)
print(f"Average Score: {average}")
if average >= 75:
    print("PROMOTED to next class")
elif 50 <= average <= 74:
    print("PROMOTED -  work harder next term")
else: 
    print("REPEAT - see your class teacher")

Result:

Mary Nancy : Performance Summary
==================================

Maths          | Score: 43 | Grade:  D  - Pass
English        | Score: 23 | Grade:  E  - Need Improvement
Kiswahili      | Score: 56 | Grade:  C  - Good
Science        | Score: 89 | Grade:  A  - Excellent
Social Studies | Score: 67 | Grade:  B  - Very Good
Total marks: 278 / 500

NOTE: Remedial lessons required in English 

Average Score: 55.6
PROMOTED - Work harder next term

Don't stop with the examples in this article. Modify them, build your own, and experiment with different scenarios, because the best way to master programming is by writing and testing your own code.
As you continue practicing, you may find yourself using nested conditionals whenever a problem requires multiple levels of decision-making.

Bonus Tip: f-Strings

Before we wrap up, there's one small feature you've probably noticed throughout the examples in this article. Many of the print() statements begin with the letter f, like this;

print(f"{subject} | Score: {marks} | Grade:{grade}")

The f stands for formatted string (or f-string). It allows you to insert the value of a variable directly into a string by placing it inside curly braces {}.

Without an f-string, you would have to write:

print(subject, " | Score: ", marks, " | Grade: ", grade)

While both approaches work, f-strings are easier to read and become especially useful as your programs grow longer and your output includes multiple variables.

As we continue through this series, we'll use f-strings regularly to produce cleaner and more readable output.

Teaching Python to Make Decisions

Sharon-nyabuto — Mon, 13 Jul 2026 21:11:20 +0000

Understanding if, elif, and else

In the previous article, we explored what Python is and why it's such a valuable tool for data analysts. We also wrote a few simple programs that followed instructions exactly as we wrote them.

In this article, we will explore how to teach Python to make decisions using conditional statements. By the end, you'll understand how to use if, elif, and else to control the flow of your programs and hopefully solve simple real-world problems.

So what is a conditional statement?

We make decisions all the time in our lives. If it rains, we carry an umbrella. If we're hungry, we eat. If an assignment is due tomorrow, we probably shouldn't leave it until midnight. Programs need to make decisions too, that is what conditional statements are for.

Conditional Statements allow a program to evaluate conditions and choose what to do based on whether those conditions are True or False.
The three keywords you'll most commonly use when writing conditional statements are if, elif, and else.

Comparison Operators

Before we can make decisions in Python, we need a way to compare values.
Comparison operators evaluate two values and return either True or False, which are the outcomes that drive if, elif, and else statements. Common comparison operators are:

Operator	Meaning
`==`	Equal to
`!=`	Not equal to
`>`	Greater than
`<`	Less than
`>=`	Greater than or equal to
`<=`	Less than or equal to

Example:


age = 25

print(age == 25)   # equal to        -> True
print(age != 18)   # not equal to    -> True
print(age > 18)    # greater than    -> True
print(age < 18)    # less than       -> False
print(age >= 25)   # greater or equal -> True
print(age <= 20)   # less or equal    -> False

Note: The = operator assigns a value to a variable, (like age = 25), while == checks whether two values are equal. This is one of the most common mix-ups I had when I started out.

The IF statement

The if statement is what lets your code actually make a decision : It runs a block of code only if a condition is True.

Example:

age = 25
if age >= 18:
    print("You're an adult.")

Here's what happens step by step:

age = 25 - Python stores the value 25 in the variable age.
age >= 18 - It evaluates the condition.
Since 25 is greater than 18 the condition is True
The indented line is executed, and the output prints:

You're an adult.

The colon : shows the end of the condition, and indicates everything after is what needs to be done if the condition is met.

The indentation (usually 4 spaces) is how Python knows which lines of code belong inside the if statement.

The ELSE statement

In an if statement, you specify what needs to be done if the condition is True.
You can also tell Python what to do if the condition is not met, using else. The statement then becomes;

Example:

score = 68
if score >= 70:
    print("You have passed")
else:  
    print("Please retake the test")

Here's what happens step by step:

Python stores the value 68 in the variable score.
It evaluates the condition score >= 70.
Since 68 is less than 70, the condition evaluates to False.
Because the if condition is False, Python skips the if block.
Python then executes the else block and prints:

Please retake the test

The else block acts as a fallback, and is only executed when the condition in the if statement evaluates to False.

The if-else statement is always used when you have two possible outcomes.

The ELIF statement

Suppose there are more than two possible outcomes?
The if-else statements will not sufficiently represent all of them. This is where the elif statement becomes useful

elif ("else if") lets you check additional conditions in order.

Example:

age = 34

if age >= 40:
    print("Older Adults")
elif age >= 20:
    print("Youth")
else:
    print("Teens")

Here's what happens step by step:

Python stores the value 34 in the variable age.
It evaluates the first condition: age >= 40.
Since 34 is less than 40, the first condition evaluates to False, so Python moves to the next condition.
Python evaluates the elif condition: age >= 20.
Since 34 is greater than 20, the elif condition evaluates to True.
Python executes the elif block and prints:

Youth

Python then skips the else block and the conditional statement ends.

Think of elif as Python saying, "If the first condition wasn't true, check this one instead."
The conditions are evaluated from top to bottom and only the first condition that evaluates to True is executed.

Putting Conditionals into Practice

Now that we've covered the basics of if, elif, and else, it's time to see how they work together.
The following examples are a little more practical, and demonstrate how Python can make decisions based on multiple conditions.

Examples

# Q1. A cinema allows entry if: age >= 18 AND has_ticket == True. Write the condition and test it with different values.

age = int(input("How old are you?")) # Ask for age
has_ticket = True

if age >= 18 and has_ticket == True:
    print("Welcome to the Movies!")
else: 
    print("Restricted")

# Q2. Build an electricity bill calculator. Units used: 0–50 → Ksh 12/unit, 51–200 → Ksh 15/unit, 201+ → Ksh 18/unit. Ask for units used and print the total bill.

electricity_units = int(input("How many units have you used?"))
print(electricity_units)
if electricity_units <= 50:
    print("Your bill is ",electricity_units * 12)
elif electricity_units <= 200:
      print("Your bill is ",electricity_units * 15)
else:
     print("Your bill is ",electricity_units * 18)

# Q3. Ask for a student's marks (0–100). Print their KCSE grade: A (75+), B (60–74), C (50–59), D (40–49), E (below 40).
student_marks = int(input("What were your marks?"))
if student_marks >= 75:
    print("A")
elif student_marks >= 60:
    print("B")
elif student_marks >= 50:
    print("C")
elif student_marks >= 40:
    print("D")
else:
    print("E")

Don't worry about counting your elif statements! You can have as many as your program needs, as you can see in the last example. Python simply checks each condition in order and stops as soon as it finds one that's True.

Your turn, try it yourself!

The examples in this article are just a starting point. Experiment with different values, create your own conditions, and see how changing the logic affects the output. Programming is one of those skills that's learned best by doing.

What's Next?

We've now learned how to make Python choose between different paths. Next, we'll build on that foundation with nested if statements, where one condition is evaluated inside another. It's a small step in syntax, but a big step towards writing more realistic programs.

Thanks for reading, and I hope you'll join me for the next part of the series. Until then, happy coding!

Python for Data Analysts: Getting Started

Sharon-nyabuto — Sun, 12 Jul 2026 14:44:43 +0000

Understanding what Python is, why it matters, and the concepts every beginner will encounter.

A month ago, if you'd asked whether I could write Python, the answer would have been no, simply because Python just looked intimidating.

As a research and data analyst however, I do love a challenge, and I asked myself the practical question: How could I actually use Python in my day-to-day work?
A dive into Python revealed one certainty: Python is not easy, but it's nowhere near as intimidating as I'd built it up to be. This is a look back at my first week learning Python: the assumptions I walked in with, and how quickly most of them fell apart.

So what is Python and why does it matter in Data analysis?

Python is a programming language: a way of giving a computer clear, step-by-step instructions to perform tasks. The tasks can be as simple as basic calculations or as involved as cleaning data, analysing thousands of data entries, automating repetitive tasks, or building applications.

One of the reasons Python is so popular among both beginners and data analysts is its readable syntax. It often resembles plain English, making it easier to learn while remaining powerful enough for real-world data analysis.

For example, one of the first programs most people write looks like this:

print("Hello, World!")

It simply tells Python to display Hello, World! on the screen. It's a tiny program, but it marks the beginning of almost every programmer's journey, including mine.

Why does Python matter?

If you've spent enough time working with spreadsheets, you've probably thought, "There has to be an easier way to do this." Whether it's cleaning data, repeating the same steps every week, or working with increasingly large datasets, there comes a point where spreadsheets begin to show their limits. That's where Python comes in.

In data analytics, Python is particularly useful for:

Automating repetitive tasks
- Tasks you'd normally repeat manually (cleaning files, renaming columns, merging spreadsheets) can be scripted once and reused.
Scale
- As datasets grow, spreadsheets can become slow, cumbersome, or even unresponsive. Python is designed to handle much larger amounts of data efficiently. We'll look at the tools that make this possible including Python libraries, in a later article.
Reproducibility
- Every step of your analysis is written into a script. That means you can run the same code tomorrow, next month, or even next year and reproduce the same results, without having to memorize or manually repeat every step.
Collaboration
- Because each step of the analysis is written into the script, colleagues can review, understand, and build on your work without having to guess what was done. This makes teams work seamlessly on the same project.
Flexibility in connectivity
- Python can pull data directly from a database, an API, or a folder of raw files, instead of relying on someone exporting a CSV for you.
Specialized Tools
- One of Python's greatest strengths is its ecosystem of libraries. Libraries are tools created by the Python community that extend what Python can do, without you having to build everything from scratch. (We'll introduce some of them as we progress through the series).

Learning why Python matters gave me the motivation to begin. Learning how to use it, however, came with a few surprises. Looking back, many of the things that intimidated me at first weren't really difficult, but simply unfamiliar.

Common Terms You'll Encounter in Python - Getting familiar with the Python Environment

Far from jumping into data analysis, my first few days were spent learning the basic concepts and getting familiar with common terms, most of which had names that were new to me.

Here are five that stood out to me when I was getting started;

Terminal: I assumed one wrong command could break my computer, only to realize it's really just another way of talking to your machine, and it stops feeling like a 'black box' after a handful of basic commands.
Integrated Development Environment/IDE: This is where you actually write your code. Think of it as a text editor built specifically for writing and running programs, with extra features like error highlighting, autocomplete, and a built-in terminal. VS Code is one of the most popular choices.
Script: This is the file containing Python code, usually with a .py extension. Instead of typing commands one at a time into the terminal, you write them all into a script and run the whole thing at once.
Library: Pre-written code that someone else has already built, so you don't have to write everything from scratch. Need to work with dates, analyse data, or make charts? There's very likely a library for that — you just import it into your script and use it. Pandas is one of the most common ones for data analysis.
Indentation: Indentation isn't cosmetic in Python, it's part of the syntax, defining which lines belong together. It took me a couple of errors and examples before fully comprehending, but once that clicked, it stopped feeling confusing.

Early on, I felt like I had to fully understand every new term, variables, functions, loops, modules, packages, libraries, before I could write code. Turns out you only need to understand the concept you're using today. The rest will fall into place as you keep writing code.

My first few lines of Python

A variable is just a name that stores information:

name = "Sharon"
print(name)

name , nationality, city = "Sharon", "Kenyan", "Kisumu" 
print("My name is ",name,". I am a ",nationality," and I live in ",city)

Python can do calculations for you:

income = 25000
expenses = 18000
print(income - expenses)

Or take input from the user:

name = input("What is your name? ")
print("Welcome, ", name)

While these may not be impressive on their own, together they show programming isn't about writing something complex from day one, but about stacking small blocks to solve a bigger problem.

Biggest lessons so far

Progress comes from consistent practice.
Errors are part of the workflow, not a verdict on your ability.
Typing code yourself teaches more than copy-pasting it.
Small projects teach more than another hour of tutorials.
Looking things up is normal, sometimes even the best analysts do it.

Programming isn't about knowing every answer. It's about knowing how to find one. This is the first article in my Python learning series, documenting the process as I go.

In the next article, we'll look at how Python uses if statements nested if statements to make choices based on different conditions. This i think is one of the biggest steps towards writing programs that actually think before they act.

Final thoughts

If you're on the fence, don't wait until you feel "ready." Write one line of code and trust that understanding builds with reps.

I'm still learning too, and that's exactly what this series is for.

Cleaning Messy Phone Numbers in PostgreSQL Using REGEXP_REPLACE

Sharon-nyabuto — Mon, 18 May 2026 22:34:00 +0000

Introduction

The first thing anyone that has worked with real world data will tell you is that rarely does data come in the clean, uniform format you expect. Phone numbers are one of the biggest culprits.

One person enters +254712345678, another writes 0712345678, someone else throws in 254-712-345-678, another (254)-712345678 and another 254 712 345 678. Before you know it, your database has a different version of phone numbers in every row.

In this article, we will explore how to fix that, using a powerful PostgreSQL function called regexp_replace.

By the end, you will understand what it does, how to build the pattern, and how to apply it to actually clean your data.

First, What Even Is `regexp_replace`?

First things first, we need to understand what this function is and what it does.

regexp_replace is a PostgreSQL function that finds a pattern inside a string and replaces whatever matches that pattern with something else you specify. The word regexp is short for regular expression.

The syntax looks like this:

regexp_replace(source, pattern, replacement_string, flag)

Let us break each part down simply:

Part	What It Means
`source`	The string you are searching inside. In our case, this is the column `passenger_phone`
`pattern`	What you are looking for : What do you want to find and remove or replace?
`replacement_string`	What do you want to put in place of what you found? If you just want to delete it, you pass an empty string `''`
`flag`	Controls how the matching behaves. The two you will use most are `i` for case-insensitive matching and `g` for global, meaning it applies the replacement to everything it finds in the string, not just the first match

Now that we have the hang of it, let us move on to building the pattern.

Understanding the Special Characters in Patterns

A pattern is basically a set of rules that tells PostgreSQL what to look for. It is like saying "find any character that is not a digit" or "find this pattern, but only at the beginning" etc.

To write these rules/instructions, there are special characters that are used.

Here are the ones we will use today:

The `^` character

Depending on where it is placed, this will do either of 2 things;

When ^ is at the beginning of a pattern it means: start matching from the very beginning of the string.

^'hello'

This means: only match hello if it appears at the start of the string.

^[0-9]

This means: Only the first character of a string is checked and matched if it is a digit. Anything after that is ignored.

When ^ is inside square brackets [ ], it means: NOT these characters.

[^0-9]

This means: Every character in the string is checked, any one that is not a digit gets matched.

Same symbol, two different purposes depending on its position.

The `\` character (backslash)

The backslash is used to tell PostgreSQL: treat the next character as a character, not as a special operator.

For example, the + sign in regular expressions has a special meaning (we will cover it in a moment). So if you want to find a plus sign + in your data, like +254, you write it as \+ to tell PostgreSQL "I mean the actual plus sign, not the operator."

Square brackets `[ ]`

Square brackets let you define a group of characters to match. For example:

[0-9] means match any digit from 0 to 9
[a-z] means match any lowercase letter
[^0-9] means match anything that is NOT a digit (the ^ inside means NOT, as we've mentioned above)

The `+` operator

When used outside brackets, + means: keep matching one or more of the preceding character or group.

So [0-9]+ means: Match the digits as long as they are all next to each other with no other characters in between. (Without the + , it stops after the first match)

The `$` character

Just like ^ marks the start of a string, $ marks the end. When you write $ at the end of your pattern, you are saying: the string must end here, nothing else allowed after this.

Putting them together: `^[0-9]+$`

Now that you know each piece, read this pattern again:

^[0-9]+$

^ → start from the beginning of the string
[0-9] → the characters must be digits
+ → keep going, there can be one or more of them
$ → and this must be the end of the string, nothing else after

All together: the entire string, from start to finish, must contain only digits.

This is the pattern we will use to identify which phone numbers are already clean and which ones need fixing.

Our Problem: What Does the Messy Data Look Like?

Let us say when we run this:

SELECT passenger_phone FROM dirty_safari_data;

We get back a mix of things like:

+254712345678
254712345678
0712345678
0712-345-678
+254 712 345 678
(0) 712345678

The goal is to standardize all of these into the local format starting with 0, containing only digits, like:

0712345678

Two problems to solve:

Some numbers start with +254 or 254 instead of 0
Some numbers have extra characters like brackets, spaces, dashes, or plus signs

Step 1: Replace `+254` or `254` at the Start With `0`

The first thing we want to do is find any phone number that starts with +254 or 254 and swap that prefix out for 0.

SELECT regexp_replace(passenger_phone, '^(\+254|254)', '0', 'g')
FROM contacts;

Let us read the pattern ^(\+254|254) carefully:

^ → look at the start of the string only
( ) → group what is inside together
\+254 → literally the characters +254 (the backslash makes + a literal character)
| → OR
254 → literally the characters 254

So the full pattern says: at the start of the string, find either +254 or 254.

The replacement is '0', so wherever that prefix is found, replace it with 0.

The flag is 'g' for global.

After this step, +254712345678 becomes 0712345678 and 254712345678 also becomes 0712345678.

Step 2: Remove Any Character That Is Not a Digit

Some numbers still have spaces, dashes, or other characters sitting in them. The second regexp_replace cleans all of that up.

SELECT regexp_replace(passenger_phone, '[^0-9]', '', 'g')
FROM contacts;

The pattern [^0-9] means: any character that is NOT a digit.

The replacement is '' (an empty string), so we are just deleting those characters.

The 'g' flag means do this for every non-digit character found in the string, not just the first one.

So 0712-345-678 becomes 0712345678 and 0712 345 678 also becomes 0712345678.

Step 3: The `WHERE` Clause — Only Update What Needs Fixing

We do not want to touch phone numbers that are already clean. That is where our ^[0-9]+$ pattern comes in handy. We use it in the WHERE clause to filter for records where the phone number is not already a clean string of digits.

You might be tempted to write it like this:

WHERE passenger_phone != '^[0-9]+$'

But this is not correct. The != operator just compares strings literally, so this would check if the phone number is literally equal to the text ^[0-9]+$, which is not what we want.

In PostgreSQL, to check whether a string does NOT match a regular expression, you use the !~ operator. The corrected version should be:

WHERE passenger_phone !~ '^[0-9]+$'

This now correctly says: only return (or update) rows where the phone number does not match the pattern of being purely digits from start to finish.

Putting It All Together

The SELECT query (to preview your cleaned data before changing anything)

Always preview before you update. This is a good habit.

SELECT 
    passenger_phone AS original,
    regexp_replace(
        regexp_replace(passenger_phone, '^(\+254|254)', '0', 'g'),
        '[^0-9]', '', 'g'
    ) AS cleaned_phone
FROM contacts
WHERE passenger_phone !~ '^[0-9]+$';

Notice how we nested one regexp_replace inside another. The inner one runs first (fixing the prefix), and then the outer one runs on the result (removing non-digits). It is like running two cleaning steps in one go.

The UPDATE query (to actually apply the changes)

Once you are happy with the preview, run the update:

UPDATE contacts
SET passenger_phone = regexp_replace(
    regexp_replace(passenger_phone, '^(\+254|254)', '0', 'g'),
    '[^0-9]', '', 'g'
)
WHERE passenger_phone !~ '^[0-9]+$';

This updates only the rows that have messy phone numbers, leaving the already clean ones untouched.

Quick Recap

Here is a summary of everything covered:

Pattern	What It Does
`^` at the start of a pattern	Anchors the match to the start of the string
`^` inside `[ ]`	Means NOT — match anything except what follows
`\+`	Treat `+` as a literal plus sign, not an operator
`[0-9]`	Match any digit from 0 to 9
`[^0-9]`	Match any character that is NOT a digit
`+`	One or more of the preceding character/group
`$`	Anchors the match to the end of the string
`^[0-9]+$`	The entire string must be digits only, nothing else
`g` flag	Apply the replacement globally (every match, not just the first)

Final Thoughts

Regular expressions can look intimidating and confusing at first, but once you understand what each character means and why it is there, they start making a lot of sense. The key takeaway here is to build your pattern step by step, rather than trying to write the whole thing at once.

Also, always test with a SELECT before running an UPDATE. You can never be too careful when modifying data directly in a table.

DEV Community: Sharon-nyabuto

Part 3: Understanding Distributions in Data Science

Statistics for Data Science (Part 3)

Introduction

Table of Contents

What Is a Distribution?

1. Data Distributions (Empirical Distributions)

The Normal Distribution

The Empirical Rule

Z-Scores

Skewed Distributions

2. Probability Distributions

Uniform Distribution

Binomial Distribution

Poisson Distribution

Why Distributions Matter

Conclusion

Descriptive Statistics: A Beginner's Guide

Introduction

Four Questions to Guide Our Analysis

1. What type of data do I have?

Qualitative Data

Quantitative Data

2. Where is my data centered?

3. How spread out is my data?

4. What does the distribution of my data look like?

Identifying Outliers

Conclusion

Part 1: Why Statistics Matters in Data Science

Introduction

Data Alone Is Not Enough

Where Does Statistics Fit Into Data Science?

Statistics Helps Us Understand Variation

Statistics Helps Us Understand Uncertainty

Statistics Helps Us Ask Better Questions

Statistics and Data Science Tools

So, Do Data Scientists Need Statistics?

What We Will Explore Next

Final Thoughts

Building a Student Results Management System with Python

From Python basics to a working project.

Students Result Management System

Project Scenario

Step 1: Setting Up the Project

Step 2: Building the Interactive Menu

Step 3: Adding Student Records

Step 4: Viewing Student Records

Step 5: Calculating Student Averages and Grades

Step 6: Saving Student Records to a CSV File

Step 7: Loading Student Records

Step 8: Generating a Student Performance Report

Conclusion

Writing Reusable code in Python

Understanding Functions

What is a Function?

Defining your first function

Calling a function

Parameters

Returning Values

Conclusion

Repeating Tasks Within Tasks

Understanding nested loops in Python

Syntax

Nested Loops Use cases

1. To find missing values (data cleaning)

2. To identify duplicate records (Data Quality)

3. To find a specific value in your table (Data exploration)

4. Data Validation (for + while)

Limitations of Nested Loops

Conclusion

What's next?

Controlling Loops with break and continue

Knowing when to stop or skip a loop in Python

The break statement

The continue statement

Conclusion

What's next?

Repeating Tasks Without Repeating Code

Using for and while loops in Python

The FOR Loop

The `break` statement

The `continue` statement

Using `for` and `while` loops in Python

Nested `if` Statements

First, What Even Is `regexp_replace`?

The `^` character

The `\` character (backslash)

Square brackets `[ ]`

The `+` operator

The `$` character

Putting them together: `^[0-9]+$`

Step 1: Replace `+254` or `254` at the Start With `0`

Step 3: The `WHERE` Clause — Only Update What Needs Fixing