DEV Community: Victor Karanja

Python for Beginners (Part 2): Mastering Python Fundamentals

Victor Karanja — Mon, 27 Jul 2026 06:30:16 +0000

Welcome back!

In Part 1 we learned variables and how to print information. Now it’s time to make our programs smarter and more useful.

In this part you will learn:

Comparison operators
if, elif, and else
for and while loops
Functions
Lists
Dictionaries
A complete Student Grade Calculator project

Let’s get started.

1. Comparison Operators

Comparison operators check the relationship between two values and return True or False.

x = 10
y = 5

print(x > y)    # True  (greater than)
print(x < y)    # False (less than)
print(x == y)   # False (equal to)
print(x != y)   # True  (not equal to)
print(x >= 10)  # True  (greater than or equal)
print(x <= 5)   # False (less than or equal)

These operators are the foundation of decision-making in Python.

2. if, elif, and else

These statements let your program choose different actions based on conditions.

score = 85

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

How it works:

if checks the first condition
elif checks the next condition only if the previous ones were False
else runs when none of the conditions are True

Always remember to:

Put a colon : at the end of each condition
Indent the code under each block (4 spaces)

3. for and while Loops

Loops allow you to repeat code.

for loop – best when you know how many times to repeat:

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

Output:

while loop – best when you want to keep repeating as long as a condition is True:

count = 0

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

Output:

0
1
2

Extra tools:

break → stop the loop immediately
continue → skip the rest of the current loop and move to the next one

4. Functions

Functions help you write reusable code. You define it once and use it many times.

def greet(name):
    print("Hello,", name)

greet("Alex")
greet("Sam")

You can also return a value:

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

result = add(10, 5)
print(result)   # 15

5. Lists

A list stores multiple items in a specific order.

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

print(fruits[0])          # apple
fruits.append("mango")    # add a new item
print(len(fruits))        # 4

You can also loop through a list:

for fruit in fruits:
    print(fruit)

6. Dictionaries

A dictionary stores data as key-value pairs.

student = {
    "name": "Alex",
    "age": 20,
    "grade": "B"
}

print(student["name"])     # Alex
student["grade"] = "A"     # update a value
print(student)

Mini Project: Student Grade Calculator

Now let’s combine everything we learned into a small real project.

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

# List of students (each student is a dictionary)
students = [
    {"name": "Alex", "score": 92},
    {"name": "Sam", "score": 78},
    {"name": "Jordan", "score": 65},
    {"name": "Taylor", "score": 55}
]

print("Student Grade Report")
print("-------------------")

for student in students:
    grade = calculate_grade(student["score"])
    print(f"{student['name']}: {student['score']} → Grade {grade}")

Output:

Student Grade Report
-------------------
Alex: 92 → Grade A
Sam: 78 → Grade C
Jordan: 65 → Grade D
Taylor: 55 → Grade F

What You Learned Today

How to compare values
How to make decisions with if / elif / else
How to repeat actions with loops
How to create reusable functions
How to store data with lists and dictionaries
How to build a complete mini project

Great work!

Try changing the scores or adding more students to practice. The more you experiment, the faster you will improve.

See you in the next part!

Python for Beginners (Part 1): From Zero to Writing Your First Programs

Victor Karanja — Mon, 27 Jul 2026 06:21:00 +0000

Python for Beginners (Part 1): From Zero to Writing Your First Programs

Python is one of the most beginner-friendly programming languages in the world. Whether you want to become a data analyst, data scientist, backend developer, automation engineer, or AI engineer, Python is an excellent place to start.

In this first part of the series, you'll learn the fundamentals you need before moving on to decision-making, loops, and functions in Part 2.

Why Learn Python?

Python is known for its simple syntax, making it easy to read and write. It is used in many fields, including:

Data Analysis
Artificial Intelligence and Machine Learning
Web Development
Automation
Cybersecurity
Scientific Computing

If you've never written code before, don't worry. We'll take it one step at a time.

Installing Python

Download the latest version of Python from the official website.

During installation on Windows, remember to check "Add Python to PATH" before clicking Install Now.

To verify your installation, open a terminal and type:

python --version

python3 --version

If Python is installed correctly, you'll see the installed version number.

Writing Your First Program

Let's start with the classic program.

print("Hello, World!")

Output:

Hello, World!

Congratulations! You've written your first Python program.

Variables

Variables store information that your program can use later.

name = "Alice"
age = 22
height = 1.68

You can display them using print().

print(name)
print(age)
print(height)

Common Data Types

Python has several built-in data types.

name = "Alice"      # String
age = 22            # Integer
height = 1.68       # Float
is_student = True   # Boolean

Understanding data types helps you write reliable programs and avoid common mistakes.

Getting User Input

Programs become more useful when they interact with users.

name = input("Enter your name: ")

print("Hello,", name)

Example output:

Enter your name: Victor
Hello, Victor

Basic Operators

Python supports arithmetic operators.

a = 20
b = 5

print(a + b)
print(a - b)
print(a * b)
print(a / b)

You can also calculate remainders using %.

print(20 % 3)

Output:

Writing Comments

Comments explain your code and are ignored by Python.

# This is a comment

name = "Alice"

Comments make your code easier for you and others to understand.

Summary

By completing this article, you've learned how to:

Install Python
Write your first program
Create variables
Work with common data types
Accept user input
Perform basic calculations
Write comments

These are the building blocks you'll use in almost every Python program.

What's Next?

In Part 2, we'll make our programs smarter by learning:

Comparison operators
if, elif, and else
for and while loops
Functions
Lists
Dictionaries

Happy coding, and see you in Part 2!

https://dev.to/victak36lgtm/python-for-beginners-part-2-mastering-python-fundamentals-4i6n

Importance of Hypothesis Testing in Data Science

Victor Karanja — Mon, 27 Jul 2026 05:47:03 +0000

A hypothesis is a clear, testable statement about a population or process. Hypothesis testing then uses sample data to decide whether there is enough evidence to support or reject that statement.

Hypothesis Testing: The Statistical Compass of Data Science

Collecting data and training models are only part of the story. The real power of data science emerges when numbers are turned into decisions that can be trusted. Hypothesis testing is the method that makes those decisions rigorous rather than guesswork.

It gives analysts a structured way to ask: “Is the pattern I see strong enough that random chance is an unlikely explanation?” Whether the question involves customer behavior, medical outcomes, marketing results, or operational improvements, the same disciplined process applies. Without it, conclusions rest on visual impressions or gut feeling. With it, they rest on quantified evidence.

Defining the Framework

Hypothesis testing evaluates whether sample evidence supports a claim about a larger population. It begins with two carefully worded statements:

The null hypothesis (H₀) represents the status quo—no difference, no effect, no relationship.
The alternative hypothesis (H₁) expresses the claim the analyst wants to investigate.

A p-value measures how surprising the observed data would be if the null were true. When that probability falls below a chosen threshold (usually 0.05), the null is rejected. When it does not, the analyst simply fails to reject the null—an important distinction from “proving” it true.

Practical Value for Data Teams

The method delivers several concrete benefits:

It separates genuine signals from noise.
It supplies a shared language of uncertainty for stakeholders.
It allows fair comparison of algorithms, treatments, or customer groups.
It turns vague observations (“sales seem higher”) into precise statements backed by probability.

In short, it elevates analysis from description to inference.

A Clear Workflow

Translate the business question into explicit null and alternative hypotheses.
Select the significance level and the test that matches the data structure and assumptions.
Calculate the test statistic and p-value.
Interpret the result in context, ideally reporting effect size and confidence intervals alongside the p-value.

The Main Families of Tests

t-Tests remain the most frequently used tools for continuous outcomes.

One-sample versions check a sample mean against a known benchmark.
Independent two-sample versions compare two separate groups (classic A/B tests).
Paired versions examine the same units before and after a change.

When data are roughly normal and groups are independent, these tests are efficient and easy to communicate.

Z-tests serve a narrower role—large samples with known population variance—yet still appear in large-scale proportion testing.

Chi-square procedures handle categorical variables. The test of independence asks whether two factors are associated; the goodness-of-fit test checks whether observed frequencies match expected proportions.

ANOVA extends the comparison of means to three or more groups. One-way ANOVA is the standard starting point; two-way versions add a second factor. When normality or equal-variance assumptions fail, the Kruskal-Wallis rank test provides a robust alternative.

Non-parametric rank tests fill the gaps left by parametric methods:

Mann-Whitney U for two independent groups with skewed or ordinal data,
Wilcoxon signed-rank for paired non-normal differences,
Kruskal-Wallis for multiple groups under the same conditions.

Quick Selection Guide

Situation	Preferred approach
Single mean vs. fixed value	One-sample t-test
Two independent groups, normal data	Independent or Welch t-test
Two independent groups, non-normal data	Mann-Whitney U
Matched pairs, normal differences	Paired t-test
Matched pairs, non-normal differences	Wilcoxon signed-rank
Three or more groups, normal data	One-way ANOVA
Three or more groups, non-normal data	Kruskal-Wallis
Relationship between categories	Chi-square independence
Observed vs. theoretical frequencies	Chi-square goodness-of-fit

Everyday Applications and Caveats

In day-to-day work these tests support A/B experimentation, model comparison, feature screening, process monitoring, and quasi-experimental evaluation. They appear both in formal research and in rapid business experiments.

Experienced practitioners treat p-values as only one piece of evidence. Practical importance (effect size), multiple-testing corrections, and assumption checks are equally essential. Large samples can make tiny differences statistically significant; domain knowledge must still decide whether those differences matter.

Final Perspective

Hypothesis testing is the quiet discipline that keeps data science accountable. It forces clear claims, quantifies uncertainty, and protects teams from mistaking noise for insight. When used thoughtfully—paired with effect sizes, diagnostics, and subject-matter judgment—it becomes one of the most reliable tools for turning data into decisions that stand up to scrutiny.

Understanding SQL: DDL, DML, and Data Transformation

Victor Karanja — Fri, 24 Apr 2026 04:59:22 +0000

Introduction

Structured Query Language (SQL) is the standard language for managing and manipulating relational databases.

This article explores:

Data Definition Language (DDL)
Data Manipulation Language (DML)
Filtering with WHERE
Conditional logic using CASE WHEN

What Are DDL and DML?

SQL commands are broadly categorized into two groups: DDL and DML.

Data Definition Language (DDL)

DDL commands define and modify the structure of database objects. They shape of your database—creating tables, altering columns, and removing schemas. DDL operations take effect immediately and permanently.

Command	Purpose
`CREATE`	Build new database objects (schemas, tables, columns)
`ALTER`	Modify existing structures
`DROP`	Delete objects entirely
`RENAME`	Change object names

Data Manipulation Language (DML)

DML commands manage the data inside tables, adding rows, updating values, and deleting records. Unlike DDL, DML changes can be rolled back using transactions if something goes wrong.

Command	Purpose
`INSERT`	Add new rows to a table
`UPDATE`	Modify existing data
`DELETE`	Remove specific rows
`SELECT`	Retrieve data (sometimes classified as DQL)

The Key Difference

Aspect	DDL	DML
Focus	Structure	Data
Commands	`CREATE`, `ALTER`, `DROP`, `RENAME`	`INSERT`, `UPDATE`, `DELETE`, `SELECT`
Reversibility	Permanent (auto-commit)	Can be rolled back
Example	Adding a new column	Changing a student's grade

DDL in Action: Building the Nairobi Academy Database

In the Nairobi Academy assignment, DDL commands established the entire database framework from scratch.

Creating the Schema and Tables

The first step was creating a dedicated schema to organize all school-related tables:


sql
CREATE SCHEMA nairobi_academy;
SET search_path TO nairobi_academy;
Then three tables were built using CREATE TABLE:
sql
-- Students table stores pupil information
CREATE TABLE students (
    student_id SERIAL PRIMARY KEY,
    first_name VARCHAR(50) NOT NULL,
    last_name VARCHAR(50) NOT NULL,
    gender CHAR(1) CHECK (gender IN ('M', 'F')),
    class VARCHAR(20),
    city VARCHAR(50),
    date_of_birth DATE
);

-- Subjects table stores courses offered
CREATE TABLE subjects (
    subject_id SERIAL PRIMARY KEY,
    subject_name VARCHAR(100) NOT NULL,
    department VARCHAR(50),
    credits INTEGER
);

-- Exam_results links students to their scores
CREATE TABLE exam_results (
    result_id SERIAL PRIMARY KEY,
    student_id INTEGER REFERENCES students(student_id),
    subject_id INTEGER REFERENCES subjects(subject_id),
    marks INTEGER CHECK (marks >= 0 AND marks <= 100),
    exam_date DATE
);
Modifying Structure with ALTER
Real-world databases evolve. When the school forgot to include phone numbers, ALTER TABLE resolved it:
sql
Copy
ALTER TABLE students ADD COLUMN phone_number VARCHAR(20);
Later, the credits column needed clearer naming:
sql

ALTER TABLE subjects RENAME COLUMN credits TO credit_hours;
When the requirement changed again, the column was removed:
sql

ALTER TABLE students DROP COLUMN phone_number;
These ALTER operations demonstrate DDL's flexibility—structures adapt without rebuilding everything.
DML in Action: Populating and Managing Data
Once tables existed, DML commands brought them to life with real student records.
INSERT: Adding Data
Ten students, ten subjects, and ten exam results were inserted:
sql

INSERT INTO students (first_name, last_name, gender, class, city, date_of_birth) 
VALUES ('James', 'Mwangi', 'M', 'Form 4', 'Nairobi', '2006-03-15');
The INSERT statement follows a clear pattern: specify the table, list columns, then provide values in matching order. Bulk inserts use comma-separated value sets.
UPDATE: Correcting Data
When Esther Akinyi moved from Nakuru to Nairobi, UPDATE reflected this change:

sql
UPDATE students 
SET city = 'Nairobi' 
WHERE student_id = 5;
A marks entry error was also fixed:

sql

UPDATE exam_results 
SET marks = 59 
WHERE result_id = 5;
Critical rule: Always use WHERE with UPDATE. Without it, every row changes.
DELETE: Removing Data
When an exam was cancelled, DELETE removed it cleanly:
sql

DELETE FROM exam_results 
WHERE result_id = 9;
Again, WHERE is essential—omitting it empties the entire table.
Filtering Data with WHERE
The WHERE clause is SQL's gatekeeper. It filters rows based on conditions, ensuring queries return only relevant data.
Basic Comparison Operators
Table
Operator    Meaning Example
=   Equal to    WHERE class = 'Form 4'
>   Greater than    WHERE marks > 70
<   Less than   WHERE marks < 40
>=  Greater than or equal   WHERE marks >= 70
<=  Less than or equal  WHERE marks <= 50
<> or !=    Not equal   WHERE city <> 'Nairobi'
Logical Operators
Combine conditions with AND and OR:

sql
-- Form 3 students from Nairobi (both conditions must be true)
SELECT * FROM students WHERE class = 'Form 3' AND city = 'Nairobi';

-- Students in Form 2 or Form 4 (either condition can be true)
SELECT * FROM students WHERE class = 'Form 2' OR class = 'Form 4';
Special Operators
BETWEEN checks ranges inclusively:

sql
-- Marks from 50 to 80, including both endpoints
SELECT * FROM exam_results WHERE marks BETWEEN 50 AND 80;
IN checks membership in a list:

sql

-- Students in any of these three cities
SELECT * FROM students WHERE city IN ('Nairobi', 'Mombasa', 'Kisumu');
N IN excludes values:

sql

-- Students in Form 1 or Form 4 only
SELECT * FROM students WHERE class NOT IN ('Form 2', 'Form 3');

LIKE enables pattern matching with wildcards:
Table
Pattern Matches
'A%'    Starts with 'A'
'%Studies%' Contains 'Studies' anywhere
'_a%'   Second letter is 'a'

sql

-- First names starting with A or E
SELECT * FROM students 
WHERE first_name LIKE 'A%' OR first_name LIKE 'E%';
Transforming Data with CASE WHEN
Raw data often needs interpretation before it becomes useful. CASE WHEN acts as SQL's if-then-else logic, creating new calculated columns based on conditions.
Grading Exam Results
Instead of displaying raw marks, the assignment labeled each score with a performance grade:
sql

SELECT 
    result_id,
    marks,
    CASE 
        WHEN marks >= 80 THEN 'Distinction'
        WHEN marks >= 60 THEN 'Merit'
        WHEN marks >= 40 THEN 'Pass'
        ELSE 'Fail'
    END AS performance
FROM exam_results;
SQL evaluates conditions top to bottom. A mark of 85 hits the first condition (>= 80) and becomes "Distinction"—it never reaches the >= 60 check. This ordering is crucial.
Categorizing Students
Students were grouped into academic levels:
sql

SELECT 
    first_name,
    last_name,
    class,
    CASE 
        WHEN class IN ('Form 3', 'Form 4') THEN 'Senior'
        WHEN class IN ('Form 1', 'Form 2') THEN 'Junior'
    END AS student level
FROM students;
Every CASE must end with END, and AS names the new column.    

Inconclusion, DDL builds the container, while DML fills and shapes the content. The Nairobi Academy data, demonstrated this relationship—CREATE and ALTER established tables, then INSERT, UPDATE, and DELETE managed student records. Filtering with WHERE and operators like BETWEEN, IN, and LIKE narrowed results to specific needs. Finally, CASE WHEN transformed numerical marks into meaningful categories, proving that SQL is not just about storing data—it's about making data understandable.
Mastering these basics prepares you for;
*joins
*windows functions
*Query optimization
*subqueries.
 In SQL real understanding comes from writing queries and lots of practice.

Unlocking Insights: Transforming Messy Data Into Action Using Power BI

Victor Karanja — Mon, 09 Feb 2026 06:37:03 +0000

## How Analysts Clean Messy Data, Use DAX, and Build Dashboards Using Power BI Power BI is an intelligent tool that helps organizations visualize and analyze their data. Raw day-to-day data can be messy and unfiltered. Analysts often deal with missing values, inconsistent formats, duplicates, and poorly structured tables. Power BI stands out because it allows analysts to clean, model, analyze, and visualize data. This article explains how analysts transform messy data into meaningful insights.

Cleaning Messy Data with Power Query

After loading your dataset, open transform data to access the Power Query Editor.

common data problems

Duplicate records- Inconsistent text (e.g. 'cardiology' 'cardio dep' 'Cardiolgy')
Numbers stored as text
Multiple values in a single column
Inconsistent date form

Some of the common Power query Transformation are:

Common Data Problems

Real-world datasets are rarely perfect. Analysts often encounter the following data issues:

Missing values (nulls or blanks)
Duplicate records
Inconsistent text values (cardiology, Cardiology, Cardiology dept)
Incorrect data types (numbers stored as text)
Inconsistent date formats
Spelling errors and typos
Extra spaces or hidden characters
Multiple values stored in a single column
Inconsistent units of measurement
Outliers and extreme values
Poorly structured tables
Mismatched keys between tables
Changing data definitions over time

Addressing these problems during data preparation ensures accurate analysis, reliable dashboards, and trustworthy business insights.

Power Query automatically records every step, so you can modify your transformation at any time.

🧩 Understanding Data Modelling in Power BI

Before you start writing DAX, it’s important to understand data modelling. A data model is simply the way your tables connect inside Power BI. Think of it as the “map” that tells Power BI how your data fits together.

A good data model usually includes:

Fact tables – contain numbers you want to analyze (sales, revenue, quantities).
Dimension tables – contain descriptive information (dates, products, customers).
Relationships – links between tables that allow Power BI to filter and calculate correctly.

A clean model makes your reports faster, your calculations easier, and your DAX formulas more accurate.

Once your data model is organized, you can start adding DAX logic to create measures, calculations, and business rules.

Using Data Analysis Expressions(DAX) To create Business Logic

With a clean data we use dax to create calculations questions.
Dax is used for:
-conditional logic
-time intelligence
-Measures ratios and percentages

Examples of Dax measure
Total Sales =
SUM(Fact Sales[Sales Amount])

Sales Growth =
DIVIDE([Total Sales] - [Last Year Sales], [Last Year Sales])

Building Simple and Clean Dashboards

An effective dashboard presents only the most important metrics, allowing users to understand insights at a glance without being overwhelmed by unnecessary visuals. By prioritizing key KPIs, using consistent layouts analysts create dashboards that are intuitive, easy to navigate, and focused on actionable insights.

Common Power BI visuals are like;

-Bar graphs and column chats

-Line charts for trends

-KPI cards

-Tables and matrices for detail

-Maps for geographic analysis

Using Power Query to clean and Dax, adding logic to data you can transform raw data into meaningful insights.

Inconclusion cleaning and preparing data is the basic foundation of every Insightful Power BI . When you build a clear data model and choose the rightful visuals, your dashboards become intuitive data or report.

#Schemas and Data Modelling in Power BI

Victor Karanja — Sun, 01 Feb 2026 22:01:17 +0000

Schemas and Data Modelling in Power BI

Data modelling is one of the most important steps in Power BI. A well-designed data model improves performance, accuracy, and ease to analyse, while a poor model can lead to slow reports and incorrect insights.

This article explains schemas and data modelling concepts in Power BI.

What Is Data Modelling?

Data Modelling involves organizing data sources into a structured model. In Power BI, this means organizing tables and defining relationships between them to support accurate reporting and efficient calculations.

What Is a Schema?

A schema is the structure and organization of data in a table. It's the logical arrangement of tables used in reports on Power BI.

In Power BI, schemas help determine:

How data is connected
How filters flow between tables
How efficiently queries are executed.

****Types of schemas in Power BI.

-Galaxy schema
-Snowflakes schema
-star schema

Snowflakes schema

Here dimensions are split into sub dimensions, that can also be split into further smaller tables.

Star schema

It's the mostly schema used in Excel, where it has multiple dimensions and one fact table.
its advantages are;

Faster query performance
Easier to write DAX formulas
Better filter -Easy to understand.

Fact Tables

A fact table stores quantitative data (measures) that can be analysed.

Characteristics of Fact Tables:

Contain numerical values
Have many rows
Reference dimension tables using keys

Examples:

Costomer Id
Name
Age
Region

Dimension Tables

A dimension table contains descriptive information that provides context to facts.

Characteristics of Dimension Tables:

Contain text or categorical data
Have fewer rows than fact tables
Used for filtering and grouping data

Examples:

Date
Product
Customer ID
Location

What Is a Relationship in Power BI?

A relationship connects a column in one table to a column in another table, usually through a key.

Example:

Sales[ProductID] → Product[ProductID]

This allows Power BI to understand how records relate across tables.

Relationship Types in Power BI

One-to-Many

This is the most common and recommended relationship type.

One record in a dimension table
Many matching records in a fact table

Example:

One product → many sales records

Used in star schemas.

Many-to-Many (:)

Occurs when both tables contain duplicate values.

Can cause ambiguous results
Should be avoided when possible

Use only when necessary and with caution.

One-to-One (1:1)

Each value appears once in both tables
Rarely used in analytical models

Relationship Direction

Single Direction (Recommended)

Filters flow from dimension tables to fact tables
Predictable and efficient behavior

Best practice for star schemas.

Both Direction (Bi-Directional)

Filters flow both ways
Can cause confusion and performance issues

Use only when absolutely necessary.

Relationships in Star Schema

In a star schema:

All dimension tables connect directly to the fact table
Relationships are one-to-many
Filter direction is single

This results in:

Faster performance
Simpler DAX formulas
Accurate filtering

Relationships in Snowflake Schema

In a snowflake schema:

Dimension tables connect to other dimension tables
More relationships are required
More joins occur during queries

This can:

Reduce performance in Power BI
Complicate filter behavior
Make DAX harder to write and maintain

Why Relationships Matter in Power BI

Correct relationships:

Ensure accurate calculations
Control how filters behave
Improve report performance
Prevent incorrect totals

Poor relationships can lead to:

Incorrect results
Slow visuals
Broken slicers and filters

Best Practices for Power BI Relationships

Use star schema whenever possible
Keep relationships one-to-many
Use single-direction filtering

- Avoid many-to-many relationships

Conclusion

Good data modelling is the foundation of effective Power BI reporting. By using well-structured schemas such as the star and snowflake schema and defining correct relationships, you can improve performance, ensure accurate calculations, and create reports that are easy to understand and maintain. Investing time in proper modelling leads to faster insights and more reliable decision-making.