.

Why Choose Python?

Python is frequently recommended for beginners and pros alike due to several key features:

• Simple Syntax: It uses an English-like syntax that is straightforward, significantly reducing the learning curve.

• Readability through Indentation: Unlike many languages that use curly braces { }, Python uses whitespace (indentation) to group blocks of code. This enforces clean, easy-to-follow code by design.

• “Batteries Included”: It comes with an extensive standard library that provides built-in modules for tasks like file operations, math, and web services right out of the box.

• Cross-Platform Portability: Python is “write once, run anywhere.” Programs can run on Windows, macOS, and Linux without needing significant modifications.

Choosing Your Python Environment (IDE)

To start coding, you need a development environment. Depending on your goals, you can start with:

1. Anaconda: A popular distribution that simplifies package management. It automatically installs Python, Jupyter Notebook, and hundreds of scientific libraries like NumPy and Pandas.

2. Jupyter Notebook: A powerful interactive tool that allows you to run code in individual “cells.” This makes it the industry standard for data science and iterative experimentation.

3. VS Code (Visual Studio Code): Currently the most popular general-purpose editor. It is highly customizable and works seamlessly with modern tools like venv, conda, and the ultra-fast uv package manager.

4. PyCharm: A “professional-grade” Integrated Development Environment (IDE). It offers deep “intelligence” for finding bugs and managing massive, complex codebases.

5. Google Colab: A cloud-based environment that requires zero installation. It runs in your browser and provides free access to powerful hardware (GPUs), which is ideal for machine learning.

The Fundamental Building Blocks

To write effective Python code, you must understand its core components:

1. Variables and Data Types

Variables are labels used to point to specific objects in memory. Python handles various built-in data types, including:

• Numeric: Integers (whole numbers) and Floats (decimals).

• Sequences: Strings (text), Lists (ordered, changeable collections), and Tuples (ordered collections that cannot be changed after creation).

• Mappings: Dictionaries, which store information as key-value pairs (e.g., 'name': 'Gemini').

2. Control Flow

Control flow allows your program to make decisions and repeat actions:

• if statements: Examine the state of a program and respond accordingly (e.g., “If the price is low, buy”).

• for loops: Iterate over items in a sequence, such as a list of users or a string of text.

• while loops: Repeat a block of code as long as a specific condition remains true.

3. Functions

Functions are named blocks of organized, reusable code designed to perform a single action. They are defined using the def keyword. Instead of writing the same logic ten times, you write a function once and “call” it whenever needed.

Thinking in Objects (OOP)

Python is an Object-Oriented Programming (OOP) language, which means it models complex problems as “objects.”

Think of a Class as a blueprint for a house. The blueprint itself isn’t a house, but it defines the attributes (windows, doors) and behaviors (opening the door). An Object is the actual house built from that blueprint. By using Classes as templates, you can create multiple instances that reuse code efficiently, helping you avoid messy “spaghetti code.”

Don’t wait for permission to be who you already are. ~ Oprah Winfrey

So many of us are sitting on ideas we haven’t shared, steps we haven’t taken, and versions of ourselves we haven’t fully stepped into. Not because we are not ready, but because we are waiting. Waiting to feel certain. Waiting to feel chosen. Waiting for a sign.

But what if you don’t need permission?

What if this new month is your reminder that you are already allowed to start, to try, to show up as the person you are becoming?

Not perfectly. Not all at once. But intentionally.

Welcome to a new month — a fresh page to take bolder steps, trust yourself a little more, and move with clarity.

The Science of the Everyday: Data in Action

To be truly effective in the tech world, we must recognize the sophisticated data models working behind the scenes in our most common tools. Here is how data is currently transforming the sectors we interact with every single day:

1. Your Inbox: Every time you open your email, a complex experiment is running. Using Supervised Learning, your email provider acts as a filter. Specifically, algorithms like Naive Bayes—a probabilistic model—are used to calculate the likelihood that an incoming message is "Spam," "Not Spam," or a "Promotion." By looking at word frequencies and historical data, the system effectively keeps your digital workspace clean.

   

2. Communication: When you use predictive text on your phone or talk to a virtual assistant, you are engaging with Natural Language Processing (NLP). This sector of the data world is incredibly effective at bridging the gap between human speech and machine understanding. NLP allows machines to read the sentiment of your messages or translate languages in real-time, proving that data isn't just about numbers, it is about the very way we connect.

3. Urban Living and Commerce: The Smart Sector from the maps that predict traffic patterns, to the apps that suggest your next favorite song, data is the "orbital line" circling our daily lives. In these sectors, data effectiveness is measured by efficiency. Logistics companies use data to optimize routes, while retail sectors use recommendation engines to ensure that the lightbulb of discovery happens exactly when you need a new product.

This month, I challenge you to find one everyday object—your fridge, your car, your favorite app and think about the data lifecycle behind it.

Stay Analytical. Stay Innovative

I have put together a set of 8 Digital Flashcards to help you test your memory.

How to use them:

1. Look at the Questions in the first image below.

2. Try to answer as many as you can (mentally or on paper).

3. Scroll down to the second image to reveal the answers and see how you did!

The Questions

The Answers

A popular quote we all know says:

The expert in anything was once a beginner. — Helen Hayes

So don’t worry if you didn’t get them all! The art of data is all about practice.

Happy weekend! Stay curious and keep exploring data :))

The Post Aggregation Filter

If you look at the query below, you will notice a specific line that wasn’t there in our previous session: HAVING total_mileage > 500000

Why HAVING and not WHERE?

This is the most common point of confusion for data analysts, but the distinction is simple once you understand the SQL Order of Operations:

1. WHERE is a pre-filter. It looks at individual rows before any math happens.

2. HAVING is a post-filter. It looks at the results after the math(SUM) is finished.

In our dataset, the database doesn’t know the total_mileage for Ford or Dodge until it finishes grouping them and adding up the numbers, because total_mileage is a calculated aggregate, a WHERE clause would actually cause an error here. It can’t filter a number that doesn’t exist yet.

If you are filtering by a raw column (like color or year), use WHERE. If you are filtering by a calculated total (like SUM or AVG), you must use HAVING.

Happy Querying!!!

Here is the technical breakdown of how we get from raw rows to an ordered leaderboard.

The Anatomy of the Query

To get this result, I used two critical SQL features: Aliasing and Ordering.

1. The Alias (AS total_mileage) : In the SELECT statement, SUM(mileage) is a calculation. Without an alias, the database would output a messy column header like SUM(mileage).

   1. What I did: I used the AS keyword to create a clean, human readable name; total_mileage

   2. Why it matters: Aliasing isn’t just about aesthetics; it makes the output professional for stakeholders and more importantly allows us to reference that new name later in the query(like what I did in the sorting phase).

2. The Sort Logic (ORDER BY … DESC) : Data is only as good as its accessibility. By default, SQL returns data in whatever order it finds it. To find the top brand, we have to force a hierarchy.

   1. The Clause: ORDER BY total_mileage tells the database which column to use as the anchor list.

   2. The Modifier: I added DESC(Descending). This ensures the highest mileage (Ford, at over 64 million) appears at the top, while lower values like Mercedes scale down toward the bottom.

Key Takeaways:

• Alias for Clarity: Always rename your aggregates, total_mileage reads better than SUM(mileage).

• Order for Impact: Use DESC for leaderboards (highest to lowest) and ASC for things like chronological timelines or bottom-performers list.

That’s where the GROUP BY clause comes in.

The Mechanics: Sorters vs. Counters

A common mistake is thinking GROUP BY does the counting. It doesn’t.

Think of it this way:

1. Group By is the Sorter: It takes 2000+ messy rows and sorts them into neat ‘bucket’ based on the brand.

2. COUNT(*) is the Tool: Once the buckets are sorted, COUNT reaches into each one and tells us exactly how many items are inside.

When you combine them you transform a massive table into a high level summary.

As the economist Ronald Coase famously said, Torture the data and it will confess to anything. As analysts, GROUP BY is how we start our interrogation. Looking at my results above, the confession is clear: Ford is the heavyweight here. With 1,235 records, it dominates the dataset.
​
​Once you have grouped your data and seen the distribution, how do you handle the "Long Tail" (those brands with only 1 or 2 entries)?
​Do you filter them out to keep the analysis clean? Or do you keep them in to show the full market reality?
​Drop your strategy in the comments. Let's talk shop.

In my query today, I used the pattern ‘%or%’. This tells the database: find me any state that has the letters ‘or’ anywhere in the name.

How to use it

The syntax is straightforward. You select your columns as usual, but you swap the equals sign for the LIKE operator

In the query shown in the image, I am defining exactly what I want to pull from the usa_cars_datasets table:

• state, model, year: I have narrowed the focus to these three columns. This tells the database to show me the location, the specific model name and the make of the car.

• FROM usa_cars_datasets: This identifies the specific table where the data is stored.

• WHERE state LIKE ‘%or%’: This is the filter. It scans the state column for the ‘or’ sequence

The Results

By using this query, the database returns state like Florida, Georgia, California. As you can see in my screenshot above the database doesn’t just look for a single letter, it finds every state where that specific "‘or’ pattern exists. It is the perfect tool for grouping data by shared patterns without needing to know the exact name in the list.

Have you ever opened a massive spreadsheet and felt your eyes glaze over trying to find just one specific thing? Maybe you were looking for every Ford sold in Georgia, but you got stuck scrolling through 5,000 rows of Chevrolets in California instead.

Last week, I talked about grabbing ranges of data. But what if you don’t want a range? What if you have a “VIP list” and you want the database to ignore the rest?

Today, we will be using the = and IN operators to cut through the noise and get exactly what we want.

The Sticky Notes of SQL: Comments

Before you look at the queries, notice those sentence at the top of my queries. Those are comments. In SQL, comments are notes written for humans that the database engine completely ignores. They are like breadcrumbs that help you or your team remember why you wrote a specific query.

In the screenshot, I used the double dash method, but you actually have three ways to leave notes in MySQL:

• The Double Dash (- -) : This is the standard single-line comment you see in my code. In MySQL, you must put a space after the second dash. Without that space, the database will get confused and throw an error.

• The Hash/Pound Sign (#) : A MySQL-specific shortcut. It is great for quick, one-line notes because it doesn’t require that extra space at the end

• The C-Style/Multi-line (/* … */) : If you have a lot to say, you wrap your text in these bookends. This is perfect for long explanations or for turning off a chunk of queries while you are testing something else.

How to use it

The syntax is straightforward. You select your columns, then use the WHERE clause followed by the specific value you want to capture:

• state, model, brand: These are the specific columns (headers) I want to see. Instead of pulling everything, I’m telling the database to only show us the location, the specific model, and the make of the car.

• FROM usa_cars_datasets: This identifies the specific table where all this car data is stored.

Using WHERE and IN

To filter the data, we combine WHERE clause with our specific operators:

• The Equals Operator(=): This acts like a laser. In the first query, WHERE state = ‘Georgia’ tells the database: Don’t show me everything, only show me rows that match Georgia exactly.

• The IN operator: This is used to select values within a specific list. It is much faster and cleaner than writing multiple OR commands

How it works: The database looks at the state column and grabs every car that fits into our VIP list(New Jersey or Florida). As you can see in the “Action Output” at the bottom of my image above, this refined our list down to 333 rows in just 0.015 second. It is a simple way to isolate specific categories without losing the big picture of the data.

When you need to filter results within a specific minimum and maximum value, BETWEEN is the most efficient tool for the job. It saves you from writing multiple AND operators and keeps your code clean.

How to use it

The syntax is straightforward. You select your column(s), then use the WHERE clause followed by the column name and the range you want to capture:

In the query shown in the image, we start by defining exactly what information we want to pull:

• brand, model, year: These are the specific columns (headers) we want to see from the table. Instead of pulling everything, we are telling the database to only show us the make of the car, the specific model, and the year it was made.

• FROM usa_cars_datasets: This identifies the specific table where all this car data is stored.

  ---

Using WHERE and BETWEEN

To filter the data, we combine the WHERE clause with the BETWEEN operator.

1. WHERE clause: This acts as a filter. It tells the database, don’t show me everything; only show me the rows that meet this specific condition.

2. BETWEEN operator: This is used to select values within a given range. It is much faster and cleaner than writing multiple greater than or less than commands.

How it works: The database looks at the year column and grabs every car where the year is 2010, 2015, or anything in between. As you can see in the "Action Output" at the bottom of my image in the screenshot, this refined our list down to 494 rows. It’s a simple way to isolate a specific era of cars without losing the big picture of the data.

But seeing is believing. Today, I am showing you how to actually put those concepts into practice using a dataset I already have.

What’s in this video:

• Importing Data : A walk through the table data import process, which allows you to take raw CSV(Comma-Separated Values) or JSON(JavaScript Object Notation) files and turn them into a structured table.

• The Workbench Interface: A quick look at the Local Instance of MySQL where all the magic happens.

• Running a Query: Watch me use the SELECT* command (where the asterisk acts as a ‘select all’ shortcut) to pull every piece of data from the table instantly.

As I mentioned before, SQL is about efficiency. It is the tool that allows you to stop guessing and start making decisions based on hard facts.

Happy Querying!!!

The Big Reveal

It is not luck, and they are not eavesdropping. It is Data Analysis

Behind every “personalized” experience from your Netflix recommendations to that “We Miss You” coupon, is an analyst using a language called SQL to sift through millions of rows of data to find patterns.

Today, I am going to demystify it for you.

What exactly is SQL?

Think of a company’s data like a giant, messy warehouse full of millions of boxes. You can not find anything just by walking around, and you certainly can not open every box by hand.

SQL (which stands for Structured Query Language and is pronounced “sequel”) is the highly trained retriever you send into that warehouse to bring back exactly what you asked for.

In the world of Data Analysis, we use SQL to ask the database questions. We call these questions Queries.

From “Human” to “SQL”

To give you an idea of how simple it actually is, look at how you can translate a business question into SQL code:

The Human Question: Who are the customers who have not bought anything in 30 days but have a birthday this month?

The SQL Translation:

SELECT email_address

FROM customers

WHERE last_purchase_date > 30

AND birthday_month = ‘January’;

That is it! That tiny block of code is how a company knows to send you a “Happy Birthday!” coupon at the exact moment you are most likely to use it.

Why does this matter to you?

You do not need to be a tech person to find value in this, SQL is the “secret sauce” for:

• Trend Spotting : Finding out that your product sells better on rainy Tuesdays than sunny Saturdays.

• Problem Solving : Seeing exactly where customers get stuck in a checkout process so you can fix it.

• Efficiency: Doing in 2 seconds what would take a human 4 hours to do manually in a spreadsheet.

Your SQL Starter Glossary

Before I wrap up, here are few building blocks you will see every time you look at a database:

• Database: The digital filing cabinet where all info is stored.

• Table: A specific list inside that cabinet (like “Orders” or “Products”).

• SELECT: The command that means Show me…

• WHERE: The filter (like saying only show me people in Chicago)

SQL is the bridge between I think this is happening and I know this is happening. It is the tool that allows you to stop guessing and start making decisions based on facts.

Happy Weekend!!

When working with data, the tools may change, but the cleaning logic stays the same. Take a look at the summarized table below

Whether you are using Power BI, Excel, or SQL, you will always encounter core data cleaning steps such as filtering rows, changing data types, handling nulls, and creating conditional logic.

For example:

1. In Power BI, filtering rows is done through the Filter Rows option in Power Query.

2. In Excel, the same task is handled using column filters.

3. In SQL, filtering is done using the WHERE clause

   ---

   The same pattern applies to changing data types, cleaning text, replacing values, and handling missing data. While each tool uses different buttons or syntax, the underlying principles are universal

Data Transformation Processes

Before you can analyze data, you must clean it. While these processes often happen in a unique order depending on the messiness of your dataset, here is a breakdown of the essential steps in no chronological order:

• Removing Duplicates : Ensuring each row of data is unique.

• Splitting Columns: Breaking one column into multiple parts for better organization.

• Filtering Rows: Removing data that isn’t relevant to your specific analysis.

• Changing Data Types: Ensuring numbers are treated as numbers and dates as dates.

• Trimming and Cleaning Text: Removing invisible spaces at the beginning or end of words (which can duplicates not to be recognized)

• Replacing Values: Correcting specific errors or ‘N/A’ entries.

• Handling Nulls(Fill Up/Down): Closing gaps in your data where info is missing.

• Formatting Text: Using Trim and Clean to standardize messy entries.

• Merging Queries: Combining two different tables based on matching columns.

• Unpivoting Columns: Turning wide data into long data for better reporting.

• Conditional Columns: Creating ‘If/Then’ logic to categorize and standardize your record.

Today’s Focus: Removing Duplicates and Splitting Columns

1. Removing Duplicates: Before you do anything else, you must ensure your data is free from duplicate records.

   ~ How to do it : Select the column that should be unique, such as the transaction_id column as seen below

   

   ~ Action: Right-click the column header and select Remove Duplicates.

   ~ Reason for this: If transaction_id records appear twice, your total sales or quantity counts will be higher than they actually are.

   ---

2. Splitting Columns: Look at the transaction_time column in the data below. It is cluttered with a placeholder date (12/31/1899). Since we already have a dedicated date column that is correct and not repeated over and over again like the one in the transaction_time column , it’s best to remove this from the dataset.

   How to clean this column using a delimiter: A delimiter is just a divider (like a space or a comma).

   
   ~ Select Column : Click on the transaction_time header.

   ~ Transform Tab: Click the Transform tab in the top ribbon.

   

   ~ Split Column: Click the Split Column and select By Delimiter.

   ~ The Strategy : Choose Space as your delimiter and select Left-most delimiter.

   ~ Clean Up : Power Query peels the 12/31/1899 date into its own column. Right-click that column and hit Remove.

   ~ Fix Data Type: Change the remaining time column to the Time data type to finalize the cleanup.

   ---

   Cleaning data might feel like the ‘boring’ part of the job, but it is actually where the magic happens. By removing duplicates and splitting columns, we have moved a little bit from a messy data to a more structured dataset that can actually tell a story.

   Once your data is clean, the analysis becomes effortless.

   See you in the next one!!

In Part 1, I introduced Power Query and why it’s an essential tool for automating data cleaning and settled the common debate between power query and power pivot.

But before diving into transformations, it’s important to understand the Power Query Editor - where all your cleaning, shaping, and preparation work happens.

Opening Power Query

In Excel:

• Open your excel

• Click any cell inside your data

• Press Ctrl + T to convert it to a table(or go to Home ~ Format as Table)

• With the table selected, go to the Data tab

• Click From Table/Range

This opens the Power Query Editor.

You can also open it from existing queries via Data ~ Queries & Connections ~ double-click a query.

In Power BI:

• Open Power BI Desktop.

• Click Get Data and select your source(From File - Excel, CSV, Folder

~ From Database

~ From Web)

• Click Transform Data instead of loading directly.

This opens the Power Query Editor.

You can also open it anytime via Home ~ Transform Data.

Power Query Editor Interface

The editor has five key areas:

1. Ribbon (Top Menu)

Contains the main commands you use to clean and transform data:

• Home: Remove rows, keep columns, merge or append queries

• Transform: Change column types, split columns, format data

• Add Column: Create new calculated columns

View: Show or hide formula bar, column quality, column distribution.

2. Queries Pane (Left Side)

Shows all queries (datasets) in your file. Each query represents a separate dataset and keeps track of all steps applied to it.

3. Data Preview (Center)

Displays the data for the selected query.

• You can sort and filter columns.

• Column headers show the data type (text, number, date).

• Nothing you do here affects the source data until you apply it.

4. Formula Bar (Above the Data Preview)

Displays the M code for the currently selected step.

• You do not need to write code to use Power Query.

• It shows exactly what Power Query is doing behind the scenes.

5. Applied Steps Pane (Right Side)

Lists each action applied to your query in order, such as:

• Changed Type

• Removed Columns

• Filtered Rows

• Split Column

Important:

• The Applied Steps pane does not store the final data.

• It stores the instructions (steps) Power Query will run on the source data.

When you click Refresh, Power Query:

• Reads the raw source data

• Applies all steps in order

• Produces the cleaned output

This ensures that your cleaning process is repeatable and consistent for new or updated data.

Now that you are familiar with the Power Query interface, you are ready to start transforming your data with confidence 😌.Comment below which part of the data transformation process you would like me to cover next, and feel free to share this with friends who are trying to get into the data space!

​Welcome to my very first post! As we step into 2026, many of us are looking for ways to work smarter, not harder. If you deal with data in Excel or Power BI, you have probably heard of the "Power" siblings: Power Query and Power Pivot.

​Today, I want to simplify these tools so you can start your year with a clear data strategy.

The Engine Room: What is Power Query?

​Imagine you have a messy room. Power Query is the automated robot that goes in, picks up the trash, organizes the shelves, and makes everything spotless.

​In technical terms, it’s an ETL tool (Extract, Transform, Load). It allows you to:

• ​Connect to data from various sources (Web, Folders, SQL).

• Clean it (remove nulls, fix date formats, split columns).

• Automate it (next time the data changes, you just click "Refresh").

The Architect: Power Query vs. Power Pivot

​A common question I get is: "If I have Power Query, why do I need Power Pivot?" Think of it this way:

​• Power Query is for PREPARING your data. It gives you a clean, flat table.

• Power Pivot is for ANALYZING your data. This is where you create relationships between different tables and write complex formulas (DAX).

​The Golden Rule: You "clean" in Power Query so that you can "calculate" in Power Pivot.

What’s Next?

​This is just the beginning. I want to help you master these tools one step at a time.

​Mark your calendars: This time next week, I will be dropping Part 2, where we will dive deeper into the specific "Must-Know" transformations in Power Query to save you hours of manual work.

​Thank you for joining me on this journey. Let’s make 2026 the year we finally master our data!