Forem: Owen Avedi

Python 101 Basics for Data Analysis

Owen Avedi — Sun, 15 Mar 2026 11:02:48 +0000

Python is a very readable programming language that became the number one choice for data analysis, mainly because it is easy to read, has a large number of ready-made tools, is free, and works everywhere.

Step-by-step guide on how to start

Install the Python version of your choice on your computer.
Check if Python has been successfully installed by running this in your CMD: python --version
Install a text editor of your choice, such as VS Code, Sublime Text, or Anaconda.

Foundations to starting Python coding like a pro

Python is an interpreted programming language, meaning you are supposed to write Python (.py) files in a text editor, then put those files into a Python interpreter to be executed.

We can write our first Python file, let's call it test.py, which can be done in any text editor.

print("Hello World")

After running this code in the Python file, save your file. Open CMD, navigate to the directory where you saved the file, and run:

You have just written and executed your first Python Program.

1. Python Indentation

Indentation refers to the spaces in the beginning of a code line

In many programming languages, indentation is optional and used only for readability. In Python, it is part of the syntax, meaning Python uses indentation to determine the structure of your code.

If indentation is incorrect, Python will raise an error. Python uses indentation to indicate a block of code.

Python convention is to use 4 spaces for each indentation level.

Example:
Correct indentation

weight = 80
if weight >= 70:
   print("You are overweight")

Wrong indentation

weight = 80
if weight >= 70:
print(You are overweight")

You have to use the same number of spaces in the same block of code, or Python will return an error.

2. Python Variables

A variable is a name used to store data in memory. In Python, a variable is created when you assign a value to it:

name = "Python"
version = 3
level = "Beginner"

print(name)
print(version)
print(level)

The equal sign = is called the assignment operator. Basically means store the value on the right side, the variable on the left.

Rules for naming Variables

Must always start with a letter or underscore
Can contain letters, numbers, and underscores
Cannot contain spaces, fill spaces with underscore
Cannot contain special symbols
It is case sensitive

3. Comments

Python has a commenting capability for the purpose of in-code documentation. Comments start with a #, and Python will render the rest of the line as a comment:

#This is a comment
print("Python Basics")

4. Python Data Types

Data type tells Python what kind of value is stored and what operations can be performed on it. Major data types include:
Text Type: str
Numeric Types: int, float, complex
Sequence Types: list, tuple, range
Mapping Type: dict
Set Types: set, frozenset
Boolean Type: bool
Binary Types: bytes, bytearray, memoryview
None Type: NoneType

Numeric data types

Integer (int) - Whole numbers

version = 3
level = 1

print(version, level)
print(type(version))

Float (float) - Decimal numbers

weight = 80.6
price = 100.40

print(weight, price)
print(type(weight))

Complex numbers - used in advanced math

z = 3 + 2j
print(z)
print(type(z))

Strings

Strings store text and are written in quotes.

name = "Python"
level = "Beginner" 

print(name)
print(level)
print(type(name))

Boolean type

Booleans represent True or False.

print(10 > 9)
a = 10
b = 9

print(a > b)
print(b > a)

version = 3
print(version >= 2)

Lists

Lists are ordered and mutable collections.

coding_languages = ["Python", "HTML", "CSS"]
print(coding_languages)

Tuples

Tuples are ordered but immutable.

language = ("Python", 3, "Beginner")
print(language)
print(type(language))

Range

Range represents a sequence of numbers.

print(list(range(5)))
print(list(range(1,10)))
print(list(range(3,20,2)))

Dictionaries

This stores key-value pairs.

language = {
            "name": "Python",
            "version":  3,
            "level": "Beginner"
           }

print(language)
print(type(language))

Sets

Sets store unique values and remove duplicates automatically.

numbers = {1, 2, 2, 3, 4}
print(numbers)
print(type(numbers))

Frozen sets

Immutable version of sets.

f = frozenset([1, 2, 2, 3, 4])
print(f)
print(type(f))

Type conversion

version = int("3")
price = float(100)
level = str(1)

print(version, type(version))
print(price, type(price))
print(level, type(level))

Difference between mutable and immutable data types

Mutable data types are the ones that can be changed after creation. Immutable cannot be changed.
Mutable data types:

list
dict
set
bytearray

Immutable data types:

int
float
bool
str
tuple
range
frozenset

Those are the basics to start being comfortable with Python. Happy Coding.

How to connect Power BI to a SQL database

Owen Avedi — Sat, 14 Mar 2026 15:09:36 +0000

Power BI is a Microsoft tool that helps turn raw data into clear visuals like charts, dashboards, and graphs. It is mainly and widely used by companies for data analysis and business intelligence (BI). This basically means that companies use it to understand trends, track performance, and share effective business insights with teams.

Most companies connect Power BI to databases mainly because most business data is stored in databases rather than files. This connection, therefore, gives Power BI access to large amounts of reliable data.

SQL databases, on the other hand, are especially important because they store and manage analytical data in an organized and more secure way. They also handle a huge volume of information, support fast queries, ensure data is consistent, and allowing multiple users to access the same data safely.

Connecting Power BI to a Local PostgreSQL Database

Follow these steps for a local PostgreSQL database:

Download and open Power BI Desktop.
Click Get Data on the Home tab.
Choose Database > PostgreSQL database > Connect

Enter the server name and database name credentials to load data into Power BI.

Choose import mode.
Input your password and username when prompted, then connect.

Connecting Power BI to a cloud database like Aiven PostgreSQL

Aiven is a cloud service that hosts managed PostgreSQL databases.
Follow these steps to connect Power BI to Aiven database:

Log in to Aiven, then select your PostgreSQL service.
Go to the connection information section, where you will get:
1. Host
2. Port
3. Username
4. Password

Download the CA certificate. This is important because it encrypts the data between Power BI and the cloud database, so no one can read the data as it travels through the internet.
Back in Power BI Desktop, Click Get Data on the Home tab. Choose Database > PostgreSQL database > Connect.
Enter the server as host:port and the database name.
If Power BI asks for SSL settings, install it into your trusted root certificates on Windows for a smoother connection.

How to install an SSL certificate on Windows

Download the certificate from Aiven.
Press Windows + R to open the Run dialog.
Type mmc and press Enter to open the Microsoft Management Console.
Select File > Add/Remove Snap - in...
Find and select certificates in the left pane, click Add > my user account
Click Finish then Ok
In the left pane of MMC, expand Certificates > expand Trusted Root Certification Authorities
Right-click on the Certificates
Select All Tasks > Import
The Certificate Import wizard opens.
Click Next > Browse
In File Browser, change the dropdown at bottom-right from "Certificate Files (.cer;.crt)" to All Files (.) This is crucial so you can see your .pem file
Navigate to your downloaded Aiven .pem file, select it, and click Open
Click Next
It should auto-select Place all certificates in the following store: Trusted Root Certification Authorities
Click Next > Finish
Click Yes, it's safe for your own CA cert
You should see "The import was successful."
Provide username and password, then connect.

Choose the required tables.

Loading tables and creating relationships in Power BI

Once connected, in the navigator, click on the tables you want to connect. e.g., customers, sales, inventory, and products. Click Load to bring them into Power BI.

What Power BI does is load them as separate tables. To analyze them correctly, you need to model them or create relationships between them.

Basics of data modelling - link tables using common columns so Power BI knows how the data connects. This allows filter and calculations to flow properly.

Common relationships in our table:

Customers > Sales (Via Customer ID)
Products > Sales (Via Product ID)
Products > Inventory (Via Product ID)

These relationships help Power BI to correctly aggregate data for accurate reports and visuals.

Why SQL Skills Are Important for Power BI Analysts

Most real - world data lives in databases, not Excel files. This is where SQL becomes essential when dealing with databases for Power BI analysts.
Here's how SQL directly helps Power BI analysts:

Retrieve data efficiently - Power BI connects to databases, but sometimes you don't want to pull everything. With SQL, you write precise queries to fetch only relevant data.
Filter data sets - SQL lets you apply filters at the source before data reaches BI, making your imported tables cleaner and visuals more focused.
Perform aggregations- you can load pre-aggregated results much more efficiently than doing it all in Power BI for quicker refreshes and simpler DAX.
Prepare data before building dashboards - SQL is efficient in the ETL (Extract, Transform, Load) phase from joining tables, cleaning data, and creating derived columns.

Power BI is great for visualization and modeling, but SQL is the key to controlling and preparing the raw data underneath. Without SQL, analysts are limited to what Power BI's Power Query can do (which is powerful but slower for massive databases and lacks the precision of database-level operations). With SQL, you become more independent, optimize performance, and deliver faster, more reliable dashboards.

A Simple Guide to JOINs and Window Functions

Owen Avedi — Sun, 01 Mar 2026 17:06:47 +0000

1. Joins

Think of joins as putting puzzles together. They combine tables. Let's say you want information from two tables that belong to the same person or thing, then JOINs relates this information. For instance:

Most Common JOIN types

INNER JOIN - Only matching records from both tables.
In the example in the table above, INNER JOIN returns 3 rows: only people who have a department.
LEFT JOIN - All from the left table + matching from the right.
In the example in the table above, LEFT JOIN returns 3 rows: all people, even those without a department.
RIGHT JOIN - All from the right table + matching from the left.
In the example in the table above, RIGHT JOIN returns 4 rows: all departments, even those without people.
FULL OUTER - All records from both. In the example in the table above, it returns 4 rows: everyone and every department.

Sample Queries:

 -- INNER JOIN (most common)
SELECT employees.name, departments.dept_name
FROM employees 
INNER JOIN departments ON employees.dept_id = departments.dept_id;
-- Result: Alice→Sales, Bob→Marketing, Charlie→Sales

-- LEFT JOIN (very popular for "show all + extra info if exists")
SELECT employees.name, departments.dept_name
FROM employees
LEFT JOIN departments ON employees.dept_id = departments.dept_id;
-- Result: Alice→Sales, Bob→Marketing, Charlie→Sales (no missing people)

2. Window Functions

These are calculations across rows without grouping. The normal GROUP BY collapses rows, but window functions let you see the group result while still keeping every row.

Think of it as: for each row, tell me something about its group.

Sample Queries:

-- Running total
SELECT sale_date, amount,
SUM(amount) OVER (ORDER BY sale_date) AS running_total
FROM sales;

-- Result example:
sale_date   | amount | running_total
------------|--------|---------------
2025-01-01  | 100    | 100
2025-01-02  | 150    | 250
2025-01-03  | 80     | 330

-- Rank of each person
SELECT name, salary,
RANK() OVER (ORDER BY salary DESC) AS rank,
DENSE_RANK() OVER (ORDER BY salary DESC) AS dense_rank
FROM employees;

-- Result:
name    | salary | rank | dense_rank
--------|--------|------|------------
King    | 12000  | 1    | 1
Alice   | 9000   | 2    | 2
Bob     | 9000   | 2    | 2          
Charlie | 7000   | 4    | 3

dense_rank doesn't skip

-- Previous / next row value (great for time series)
SELECT sale_date, amount,
LAG(amount) OVER (ORDER BY sale_date)  AS previous_day_amount,
LEAD(amount) OVER (ORDER BY sale_date) AS next_day_amount
FROM sales;

Quick guide to not get confused:

JOIN = glue 2 tables together horizontally
Window = look around your row (up/down/same group) and bring back smart numbers

How Analysts Translate Messy Data, DAX, and Dashboards into Action Using Power BI

Owen Avedi — Sun, 08 Feb 2026 16:29:19 +0000

Power BI helps analysts transform messy data into clear, interactive dashboards that eventually help in driving business decisions. The whole process, however, follows a structured workflow: clean the data, build a reliable model, calculate with DAX, create compelling visualizations, and then extract insights that lead to decision-making.

This is exactly how it is approached step by step:

1. Transforming Messy Data with Power Query

Real-world data is always messy, and includes missing values, inconsistent word spacing and spellings, wrong data types, and extra junk columns.

Power Query handles all these before the data even reaches the model. Analysts have key techniques to follow to fix this:

Profile the data - To spot issues quickly and save on time, use column quality, column distribution, and column profile.
Remove errors and duplicates - Fill blanks or filter invalid rows where appropriate.
Standardize and clean - Apply trim, case transformations, and replace values where applicable.
Handle missing values - Replace with "Null", "Unknown", "0", or averages based on context.
Fix data types - Manually set whole numbers, dates, text, decimal numbers to avoid later errors.

2. Building a Data Model

A good model is the foundation of fast, accurate reports. The design commonly followed and easy to use by analysts is the Star Schema design. It contains:

Facts table in the center.
Dimension tables around the facts table to provide context.

What you do is create one-to-many relationships from dimensions to facts. Hide unnecessary fields from report view and optimize by removing unused columns.

This structure prevents performance issues in larger data sets and ensures slicers and filters work correctly.

3. Adding Intelligence with DAX

DAX (Data Analysis Expressions) is Power BI's language formula. It creates measures and calculated columns.

Essential examples:

Basic aggregation: Total Sales = SUM(Sales[Amount])
Division: Profit Margin = DIVIDE([Total Profit], [Total Sales], 0)
Time intelligence: Revenue LY = CALCULATE([Total Revenue], SAMEPERIODLASTYEAR('Date'[Date]))
Conditional logic: SWITCH(TRUE(), ...) use this with branded categories.

Use variables (VAR) for readability and performance. Prefer measures over calculated columns when possible, as they are more efficient.

4. Building Dashboards

Dashboards help analysts turn numbers into stories, focusing on:

KPI Cards for headline numbers.
Trend Charts line/area for time series, bar/column for comparisons.
Breakdowns Pie/donut for composition, maps for geography.
Interactivity Slicers, cross-filtering, and tool tips.

Best practice: Use one page for an executive overview, include a clear visual hierarchy, and use a consistent theme.

5. Turning Insights into Action

This is the final and most important step. This is done by:

Spotting trends, anomalies, and outliers.
Using what-if parameters for scenario planning.
Add commentary on the report.
Publish to the Power BI service for sharing, scheduled refresh, alerts, and collaboration.

Copilot helps in accelerating summarized reports in plain language, generating entire report pages, or creating narrative insights automatically.

Mastering this flow enables analysts not to just produce pretty dashboards, but to be trusted advisors who turn messy data into clear, evidence-based decisions.

Dummy Guide to Schemas and Data Modelling In Power BI

Owen Avedi — Sun, 01 Feb 2026 21:17:02 +0000

Here is a super simple explanation of schemas and data modelling in Power BI. Think of Power BI like building with interlocking blocks.

What is Data Modelling?

Data Modelling is deciding which block is going to interlock with another, and how they should interlock so that you can build something useful.
You take all your messy tables, organize them, and connect them properly so that Power BI can, in turn, answer questions like:

"How much did each client spend last year?"
"Which products sell best in a particular country?"

What is a Schema?

First off, we need to know what a schema consists of. It has the fact table, which is the biggest table with lots of rows: it can contain numbers you want to add up (measures) or IDs linking to other tables.

It also consists of Dimension tables, which are smaller tables with unique rows that also contain descriptive attributes you use to filter.

The schema is the final blueprint that shows:

The tables you have
The columns inside each table
How the tables are connected to each other

There are 3 very common schemas in PowerBI:

1. Star Schema

This is the easiest for beginners and highly recommended in Power BI. It looks like one big central table with many small tables around it.

The fact table has the numbers you want to add up: Amount, Quantity e.t.c.
All the other tables are called dimension tables; they connect to the fact table usually with one number column, e.g., Customer ID, Product ID, or Date.

2. Snowflake Schema

It looks like star schema, but some dimensions are split further. It still has the fact table, but the dimension tables are split into extra levels.

It's best for very large data bases where storage matters a lot. Only use when you really need it, as it's harder and slightly slower than star schema.

Something to know,

Relationships - How tables talk to each other

In Power BI, it is a line connecting two tables so filters flow between them.
Relationships almost always in good models → one-to-many because it offers fast calculations, correct filtering, and no wrong totals, there's also:

One Side- Has unique values, for example, customer ID in customer table, each ID appears only once.
Many Side- Has repeating values, many rows can have the same values, for example, customer ID in sales table, same customer buys many times.

Overall, stick with star schema, it's what most good Power BI models use.

Introduction to Ms Excel for Data Analytics

Owen Avedi — Sun, 25 Jan 2026 16:16:15 +0000

What Is Microsoft Excel?

Ms Excel is a tool used for working with data. It's super easy to use, and you don't need any fancy tools installed, just the same Excel on your desktop or laptop.

What Does Excel Do?

Organize and clean data
Calculate data
Find highest and lowest value
Filter data to narrow on specifics
Create summary tables for your data
Make appealing visuals and charts for your data
Highlight numbers or characters in your data

Now to the steps...

1. Getting Your Data to Excel

If you already have data saved in your device, open it in Excel by clicking open then browse and look for youra data.

If you're starting from scratch, click on new then open blank workbook.

Clean your data correctly if you do have an existing data uploaded on your Excel by following these steps:

Format the cells to auto fit in the cells if they aren't by clicking on the Home ribbon, then the Format tab and choose the cells you ant to autofit.

Format the columns to their respective inputs. Right click on any column you want to format cells, then click format and format as desired , if text format to Text, if dates Date e.t.c

2. Easy Calculations

The biggest strength in Excel is formulas. Here are some beginner formulas:

=SUM(B2:B32)→ total of numbers in B column
=AVERAGE(C2:32) → average
=COUNT(D2:D32) → how many cells have numbers
=MAX(E2:E32) → highest value
=MIN(F2:F32) → lowest value

3. Sort and Filter

Steps:

Click anywhere in your data table
Go to Data tab → Sort & Filter → Filter
→ little arrows appear in every header

Now you can sort from highest to lowest, filter dates or even search for specific names.

Clicking the dropdown arrow beside the title shows sort options and checkboxes to filter.

4. Conditional Formatting (Excel Highlights Important Stuff)

This basically makes patterns appear visually so you can sort or update data as desired. Steps to do this:

Click on the Home tab → Conditional Formatting
→ little arrows appear in every format you want.

5. PivotTables – The Most Powerful Beginner Tool

This let's you summarize hundreds of rows in seconds.

How to create one:

Click anywhere in your data
Go to Insert tab → PivotTable → OK (new sheet usually best)
In the PivotTable Fields pane (right side)

6. Charts (Turn Numbers into Pictures)

Make beautiful Charts in just 2 clicks. There are several charts in Excel, but for starters you only need this main 3: Column bar chart, Line chart and Pie Chart.

How:

Select your data (including headers)
PivotTable Analyze tab → PivotChart → pick one

You can change colors,titles, e.t.c

Quick Summary

Paste or type data → make it a proper table (headers!)
Home → Format as Table (optional but nice look + auto-filters)
Add quick calculations at the bottom (SUM, AVERAGE…)
Add filters / sort to explore
Use Conditional Formatting to spot patterns
Create a PivotTable for summaries
Insert a chart from the PivotTable or raw data

That's already real data analysis, now you are on your way to becoming a pro.

Next Steps for Beginners

Practice with free sample datasets (search "Excel sample sales data csv")
Learn these extra helpful functions: IF, VLOOKUP, COUNTIF, SUMIF
Get comfortable with Tables (Insert → Table) — they make formulas and charts much smarter

Excel is friendly just start small, make mistakes and you'll be a pro in no time.

Git for Absolute Beginners: Understand Version Control, Track Changes, Commit, Push & Pull

Owen Avedi — Sat, 17 Jan 2026 15:22:45 +0000

A super simple guide to Git basics. Learn why version control is important, track changes, save snapshots (commit), send code to the cloud (push), and get updates from others (pull).

If you've ever experienced:

loss of important code changes
Wanting to go back to a code that "worked yesterday."
Scared to break something that used to work
Wondering how teams work on the same project without interfering with each other

Then Git is the one tool that solves all these.

Git is the most popular version control system simply because it lets you:

Take snapshots of your project (commit)
Track exactly what changed and when
Go back in time if something breaks
Work conveniently with others (push & pull)

Now to the essentials, nothing overwhelming, just some everyday commands.

1. What is Version Control?

Let's say you have a project folder and it's the only one you have,

Without git → You only have that one copy, and if you delete something or break the code, it's gone unless you manually saved copies or otherwise.

With git → Every important change is snapshotted (a commit). Which means you can:

Read any previous project
Compare projects
Go back to an older project
Let someone else add their own project safely

2. Quick Setup

Install Git
Let git know who you are (do this after opening git)

git config --global user.name "Your Name"
git config --global user.email "your.email@example.com"

Use the same email as in your GitHub account

3. The Core Git Workflow (The Repeat Cycle)

Edit files → See what changed → Stage changes → Save snapshot (commit) → Send to cloud (push) → Get others' changes (pull)

Let's go through each one of them step by step.

Step 1: Create or move into a project folder

mkdir my-first-project
cd my-first-project

Step 2: Tell Git to start tracking this folder

git init

(You only do this once per project)

Step 3: Make some changes & see what's different

Create or edit a file (e.g index.html, app.js, README.md)

Ask git what changed?

git status

It'll bring something like:

Changes not staged for commit:
(use "git add <file>..." to update what will be committed)
modified: index.html
new file: styles.css

Untracked files - new files Git doesn't know yet
Modified - Git knows but have changes

Step 4: Choose which changes to save (Staging)

# Add one file
git add index.html

# Add everything that changed
git add .

# Or add interactively
git add -p

git status now shows:

Changes to be committed:
new file: index.html
modified: styles.css

Step 5: Save the snapshot (Commit)

git commit -m "Add homepage layout and basic styling"

Make the message short and clear, e.g:

"Add user login form"
"Fix mobile menu not closing"
"Update README with installation steps"

Step 6: See the history of snapshots

git log --oneline

Example output of what it'll show:

a1b2c3d Add homepage layout
e4f5g6h Initial project structure

Each line - snapshot with its unique ID

Step 7: Send your work to the cloud (Push)

First, create an empty repository on GitHub.
Then connect your local project:

git remote add origin https://github.com/your-username/your-repo-name.git

Then send your commits:

git push -u origin main

(If default name is master instead of main, replace main with master)

From here now, you can just do:

git push

Step 8: Get changes from others/another computer (Pull)

git pull

This does 2 things:

Download new commits from the remote (fetch)
Merges them into your current branch

Important: Always git pull before starting new work

Quick Reference (Commands and when to use them)

See what changed - git status - All the time!
Add specific changes - git add filename - Before committing
Add all changes - git add . - Common & fast
Save snapshot - git commit -m "message" - After staging good changes
See commit history - git log --oneline - When you want to remember what you did
Send to GitHub - git push - When your work is ready to share/backup
Get latest changes - git pull - Before starting work / after coming back
Undo staging (if you added by mistake) - git restore --staged filename - Oops moments

That's it! You now know how to track changes, save versions, push your work, and pull updates.
Happy coding and committing!