DEV Community: Ron Njuguna

Python Basics: Getting Started with Variables, Data Types Input and Output

Ron Njuguna — Fri, 18 Sep 2026 08:56:31 +0000

After learning the basics of SQL, I started working with Python. Python is one of the programming languages that is widely used in areas such as web development, automation, data analysis, artificial intelligence and scripting.

As a beginner, I found that understanding the basic syntax and how Python handles data is important before moving on to more advanced topics.

In this article, I will go through some of the Python basics I have learned, including variables, data types, input/output and basic Python syntax.
A simple python syntax can be written as:

The print() function displays information on the screen.

Variables
A variable is used to store a value that we can use later in a program.
For example:

Here, name stores the text "Ron" while age stores the number 22.
We can then use these variables:

The output would then be:

One thing I noticed when learning Python is that I don't have to specify the data type when creating a variable. Python determines the type based on the value assigned to it.
For example:

Python Data Types
Python has several built-in data types. Some of the common ones I have learned are:
str – used for text
int – used for whole numbers
float – used for decimal numbers
bool – represents True or False
list – stores multiple values in a collection
A good example which shows the use of the types above are:

We can use the type() function to check the data type of a variable:

This is useful when working with data because it helps us understand what type of information a variable contains.
Input and output
Programs are more useful when they can interact with users. Python provides the input() function to receive information from a user.
An example is:

If the user enters:
Ron
The program will display:
One important thing I learned is that input() returns the user's response as a string. If we want to work with a number, we need to convert it. For example:

Here, int() converts the input into an integer.
Basic Python Syntax
Python syntax is relatively straightforward, but indentation is very important. For example:The indentation tells Python which statements belong to the if and else blocks. Unlike some programming languages, Python does not require curly brackets {} to define these blocks.
Python also allows us to add comments to our code:Comments are useful because they help explain what different parts of our code are doing.
A Practical Example
We can combine some of these concepts to create a simple program for calculating the total cost of a product.If I put the product name as Sugar, Quantity as 5 and Price as KSh2,000 the output would be:Conclusion
Learning Python starts with understanding the fundamentals. Variables allow us to store information, data types tell us what kind of information we are working with and input/output allows our programs to interact with users.
I have also learned that Python's syntax is designed to be readable, but things such as indentation, correct data types and variable names are still important when writing programs.
These concepts may seem simple, but they provide the foundation for more advanced Python topics such as loops, functions, object-oriented programming, file handling and working with databases.
For me, the most important lesson at this stage is not just memorizing Python syntax but understanding how these basic concepts can be combined to solve simple, real-world problems.

SQL Window Functions: Understanding PARTITION BY, ORDER BY, ROW_NUMBER and RANK

Ron Njuguna — Thu, 17 Sep 2026 06:48:05 +0000

As I continued learning SQL, I came across a concept that was initially a little confusing to me which was window functions.

At first, they seemed similar to aggregate functions such as SUM() and AVG(). However, there is an important difference. Aggregate functions usually combine multiple rows into a single result while window functions allow us to perform calculations across related rows without removing the individual rows from the result.

Window functions are particularly useful when working with rankings, running totals and data analysis.

What are window functions
Window functions are a powerful SQL feature that allows us to perform calculations across related rows while keeping the original data available in the result.
The basic syntax looks like this:

The OVER() clause tells SQL that a window function is being used.

Understanding Partition By
PARTITION BY divides the results into groups before the window function is applied.
For example, suppose we want to rank each customer's orders separately:

Here, PARTITION BY customer_id creates a separate group for each customer. The ranking then starts again for each customer.This could be useful for answering the question "What is the highest-value order for each customer?"

Understanding ORDER BY
Inside a window function, ORDER BY determines the order in which the calculation is performed.
For example:

This means that the rows will be ordered from the highest amount to the lowest amount before the row numbers are assigned.

ROW_NUMBER()
This gives each row a unique sequential number
An example is:

Even if two orders have the same amount, they will still receive different row numbers.
This can be useful when we need to identify the first, second or third record in a group.

RANK()
This is similar to ROW_NUMBER(), but it handles ties differently. For example

If two orders have the same amount, they receive the same rank.

Conclusion
The concepts that I found the most important to understand are OVER(), PARTITION BY and ORDER BY. Once these make sense, functions such as ROW_NUMBER(), RANK() and DENSE_RANK() become much easier to understand.

For me, the biggest difference between window functions and regular aggregate functions is that window functions allow us to analyze rows in relation to other rows without grouping them into a single row.

They are especially useful when working with reports, business data, rankings and analytics making them an important concept to learn as you move beyond basic SQL queries.

SQL Functions: Data Analysis just got better

Ron Njuguna — Wed, 09 Sep 2026 07:58:11 +0000

Introduction
When working with databases, we often need to do more than just retrieve data. We may need to calculate an average, count records, find the highest value, convert text to uppercase or work with dates. This is where SQL functions become really useful.

What are SQL Functions
SQL functions are built-in operations that allow us to perform calculations and manipulate data directly inside a SQL query. Instead of retrieving all the data and doing the calculations manually, we can let the database do the work for us.
Some common functions are:
Aggregate functions
This can perform calculations on multiple rows and then return a single result. For example
Total amount of orders

Highest order

Count number of orders

Date Functions
This are useful when working with information such as orders, payments or records. An example is

This returns the current date

Conclusion
SQL functions are an important part of working with databases. They help us perform calculations and manipulate information without having to process everything manually.
The key thing I have learned is that SQL is not only about retrieving data. It also provides tools for understanding and transforming that data.
As datasets become larger, knowing how to use functions effectively can make queries shorter, more useful and much easier to analyze.

SQL Subqueries and CTEs: Writing More Powerful Queries

Ron Njuguna — Wed, 09 Sep 2026 07:38:12 +0000

As you dive deeper into SQL queries, you'll find that sometimes a straightforward SELECT, WHERE, or JOIN just won't be efficient.

A good example is you're managing an e-commerce database, and your boss comes to you with a question:
"Can you tell me which customers have spent more than the average customer?"

Sure, you could work with the numbers manually and produce another query, but SQL has a more efficient way to tackle this. That’s where subqueries and Common Table Expressions come in.

SubQueries
This is a SQL query placed inside another SQL query. The inner query runs first, and its result is then used by the outer query.
An example is this orders table below

If we want to find orders that are above the average order value, we can use a subquery:

The inner query calculates the average order amount while the outer query returns only orders where the amount is greater than the average.
Subqueries are really useful when the result of one query is needed by another query

Common Table Expressions
This is a temporary named result set that can be referenced within a larger SQL query. An example is:

The CTE first calculates how much each customer has spent. We then query the temporary result shown and find customers who have spent more than 5,000.

Conclusion
The main two differences between the two that I would say are first Subqueries are written inside another query while CTEs are defined using WITH
Another difference I'd say is that Subqueries are good for smaller operations while CTEs are good for breaking down complex queries. The most important thing is not simply knowing the syntax but knowing when to use each technique.

SQL Joins: Understanding How to combine Data from Multiple Tables

Ron Njuguna — Tue, 08 Sep 2026 09:52:50 +0000

When you're diving into databases, you'll quickly notice that data isn't usually crammed into a single table. Take an e-commerce site, for instance, you'd typically find one table for customers, another for orders, a separate one for products and yet another for payments.

What are SQL Joins
A SQL join is a tool that lets you combine rows from two or more tables based on a shared column between them.
For example, suppose we have these two tables:

Customers

Orders

The customer_id column connects the two tables. Instead of looking at customers and orders separately, we can use a join to find out who placed each order.

The result would be:

Types of SQL Joins
INNER JOIN

An INNER JOIN returns only records that have a match in both tables. It should be used when you only want records where a relationship exists.

For example, if you are generating a report showing customers who have actually placed orders, an INNER JOIN makes sense. Customers who have never placed an order will not appear.

LEFT JOIN

A LEFT JOIN returns all records from the left table, even when there is no matching record in the right table.

This becomes particularly useful when you want to identify customers who have not placed any orders.

RIGHT JOIN

A RIGHT JOIN works similarly to a LEFT JOIN, except that all records from the right table are returned.

In practice, RIGHT JOIN is used less frequently because the same result can usually be achieved by reversing the order of the tables and using a LEFT JOIN.

FULL OUTER JOIN

A FULL OUTER JOIN returns all records from both tables. Where a matching record doesn't exist, SQL returns NULL for the missing data.

This can be useful when comparing two datasets and you want to identify both matching and unmatched records.

For example, a company could use it to compare customer records from two different systems and find customers that exist in one system but not the other.

Conclusion
SQL joins may seem confusing when you first encounter them, but the basic idea is straightforward which is joins allow us to connect related data stored in different tables.
The key is understanding what information you want in the final result.
Once you understand joins, working with real-world databases becomes much easier. Whether you are building an e-commerce application, analyzing business data or creating reports in tools such as Power BI, joins are a skill you will use constantly.

Building an Interactive Sales Dashboard with Power BI and PostgreSQL

Ron Njuguna — Fri, 24 Jul 2026 10:08:23 +0000

Data-driven decision-making has become an essential part of modern business operations. In this project, I built an interactive sales dashboard using Power BI and PostgreSQL to analyze vehicle sales data for a car dealership. The goal was to transform raw transactional data into meaningful insights that can help managers monitor performance and make informed business decisions.

Connecting PostgreSQL to Power BI

The first step was importing the dataset into a PostgreSQL database. PostgreSQL provided a reliable and structured environment for storing the sales data before connecting it to Power BI. Using Power BI's PostgreSQL connector, I established a connection to the database and imported the required table into Power BI for analysis.

This approach demonstrates how Power BI can integrate seamlessly with relational databases, making it suitable for handling real-world business datasets.

(https://dev-to-uploads.s3.us-east-2.amazonaws.com/uploads/articles/zlng0kn2hk2ood37htxu.PNG)

Cleaning Data with Power Query

The imported dataset contained several inconsistencies, including mixed date formats, currency symbols (such as KSh and KES), percentage values, and missing data. These issues had to be resolved before analysis.

Using Power Query Editor, I:

Converted inconsistent date formats into valid date values.
Removed currency symbols and thousand separators from numeric fields.
Standardized discount values into decimal percentages.
Replaced invalid or missing values with nulls where appropriate.
Assigned correct data types to every column.

Cleaning the data ensured that calculations and visualizations were accurate and reliable.

Creating DAX Measures

After loading the cleaned data into Power BI, I created several DAX measures to calculate important business metrics. These included:

Total Revenue
Gross Profit
Gross Profit Margin
Total Units Sold
Total Orders
Average Customer Rating
Average Delivery Days

These measures allowed the dashboard to dynamically calculate key performance indicators as users interacted with filters and slicers.

Building the Interactive Dashboard

The dashboard was designed to provide an executive overview of sales performance through interactive visualizations. It includes KPI cards, revenue trends over time, revenue by vehicle type, car make, branch, customer type, payment method, and sales representative performance. Interactive slicers enable users to filter the dashboard by region, branch, vehicle type, payment status, and order date, making it easy to explore different aspects of the business.

Key Takeaways

This project strengthened my understanding of integrating PostgreSQL with Power BI, performing data transformation using Power Query, and developing reusable DAX measures for business reporting. Most importantly, it demonstrated how interactive dashboards can transform raw data into actionable insights that support strategic decision-making. Power BI's combination of data preparation, modeling, and visualization makes it a powerful tool for business intelligence and analytics.

HOW EXCEL IS USED IN REAL WORLD DATA ANALYSIS

Ron Njuguna — Sat, 06 Jun 2026 18:43:46 +0000

Microsoft Excel is used as a tool for organizing, analyzing and presenting information. This spreadsheet application, made by Microsoft, helps users to efficiently collect, calculate, analyze and visualize data. Whether you're in business, education, finance or marketing, Excel can be used in transforming raw data into valuable data that helps in decision-making.

A good example of Excel's real-world application is in business decision making. Companies gather a lot of sales, customer and operational data. With Excel's sorting and filtering capabilities, managers can get information, spot trends and focus on specific data sets. For instance, a sales manager might filter sales records to see only transactions from a certain region or sort products by the revenue they generate.

Another key use of Excel is in financial reporting and budgeting. Businesses rely on it to get numbers related to expenses, revenues, profits and taxes. Due to its formulas and functions, these calculations are both accurate and efficient. Functions like SUM() can quickly tally total sales, while AVERAGE() helps determine average monthly expenses. These calculations enable organizations to keep a close eye on their financial health and make well-informed decisions.

Excel has become an excellent tool for analyzing marketing performance. Marketing teams analyze campaign results, customer feedback and sales conversions to monitor effectiveness. With features like Conditional Formatting, they can easily spot key trends, whether it’s campaigns that succeed or those that fail. This allows analysts to quickly recognize patterns and improve strategies for better outcomes in future marketing efforts.

Some of the Excel functions and features that I have learned include SUM(), AVERAGE() and TRIM(). The SUM() function is great for tallying up figures like total sales revenue, while AVERAGE() helps me figure out average performance metrics, such as student grades or monthly sales figures. TRIM() is used for data cleaning, as it removes extra spaces in text entries, making everything more consistent and reliable.

Excel has taught me how simple tools like formulas, sorting, filtering and formatting can turn raw data into meaningful information that helps in making better decisions. As I keep learning Excel, I’m confident it will become a crucial skill for my academic and professional journey.