Welcome to the AI-assisted Data Analysis Course.
In this course, we will learn how to use AI for data analysis with Python. The examples will use fictional retail data, including sales and refunds. We will work through the analysis and prepare a report with our findings.
We can use AI to suggest an analysis or generate Python code from a request. After running the code, we can provide the result and ask for another calculation or an explanation. This is how we will use AI in the course, with the requests and Python examples included in each lesson.
The course has 35 lessons across twelve sections, with the final project in Section 12. Section 1 contains two free lessons. First, let’s take a look at what we will learn and how to follow the examples.
What we will learn in this course
We will start by using AI to help plan an analysis. For example, we could ask which products have the highest refund amounts or how refunds differ between customer groups. We will provide the dataset information and compare the AI-suggested analysis plans.
Next, we will use AI to generate the Python code for our analysis. We will prepare the data and investigate sales and customer purchases using pandas. We will also try debugging the code by providing the error message or the calculation result in another request.
The course also covers statistical analysis and data visualization. We will examine the methods suggested by AI, including their assumptions and how to interpret the results. After that, we will create charts and write a report using our analysis.
The early lessons include complete examples that you can run while reading. In later exercises, you will write the request or complete part of the analysis before reading the solution. There will also be lessons on comparing prompts and AI responses using calculations we have already checked.
For the final project, you will work with a different dataset and business question. You will submit a notebook and a short report describing the analysis, including how you used AI and what you checked or changed. The final section will provide the assessment and submission instructions for the Certificate of Completion.
You can use the course repository as an index for the notebooks and exercise solutions. The course is still in development, so materials for later lessons will be added as they are prepared. Sections 2–12 will be included in the Non-Brand Data paid subscription.
If you are reading Python Data Analysis, Fourth Edition, this course provides additional practice using AI during an analysis. The book is an optional reference. Each lesson will include the explanation and code needed for its activity.
Before we start
This course assumes you have used Python and pandas before. You should be familiar with loading a dataset and using basic filtering or grouping. The lessons will explain the pandas functions used in the examples.
We will use Google Colab to run the Python examples. Colab is a notebook environment that we can use in the browser. It has text cells for the explanation and code cells where we can run Python.
Let’s open the Lesson 1 notebook in Google Colab. The notebook contains the walkthrough and exercise for this lesson. To keep your work:
Choose Copy to Drive and save your own copy using your Google account.
Read the explanation beside each code cell, then run the cells in order.
Compare the output with the result shown in the lesson before continuing to the exercise.
We will create the dataset in the notebook. You can also download the notebook from GitHub and run it in your own Python environment.
The AI responses in this lesson came from an experiment using Groq on 1 November 2026. The notebook includes the recorded examples, so you can complete the lesson without an AI account or API key. Lesson 2 will cover sending live AI requests from Colab.
In this lesson, we will ask AI to calculate revenue using different requests. We will try a general request first, then add the calculation details and ask for the analysis in several steps. After the lesson, you should be able to:
Explain which information you provided when asking AI for the calculation.
Compare the proposed code with the included orders and their amounts.
Use an intermediate result to continue the conversation.
Our first analysis: calculating revenue
Let’s try using AI to calculate revenue from a fictional order dataset. First, we need to prepare the data using pandas.
import pandas as pd
orders = pd.DataFrame(
[
["A", "delivered", 100, 10, 20],
["B", "delivered", 80, 0, 0],
["C", "cancelled", 200, 0, 0],
["D", "delivered", 60, 0, 10],
],
columns=[
"order_id", "status", "gross_usd", "discount_usd", "refund_usd"
],
)
print(orders.to_string(index=False))The dataset contains the following records:
order_id status gross_usd discount_usd refund_usd
A delivered 100 10 20
B delivered 80 0 0
C cancelled 200 0 0
D delivered 60 0 10Each row represents one order. The gross_usd column contains the order amount before discounts and refunds, while the other two amount columns contain the discount and refund recorded for that order. All amounts are in US dollars.
For example, order A has a gross amount of USD 100. The customer received a USD 10 discount, and USD 20 was refunded. Both amounts are already totals for the order, so we can subtract them directly from the gross amount.
The status column contains two values, delivered and cancelled. Order C is cancelled, while the other three orders are delivered.
1. Asking AI to Calculate Revenue
For this experiment, I used openai/gpt-oss-20b through Groq. The settings were temperature 0, top-p 1, a maximum of 2,048 completion tokens, and low reasoning effort. I sent the table as CSV and explained that each row represents one order, with all amounts in USD. Groq received the data as text; it did not have access to our Python notebook.
Let’s try the following request:
Calculate total revenue from this order table using pandas. Show the code and explain what it calculates.
Groq generated code to subtract discounts and refunds, then select delivered orders. Below is the calculation part of its response; the full response also recreates the table.
orders['revenue_usd'] = orders['gross_usd'] - orders['discount_usd'] - orders['refund_usd']
# ------------------------------------------------------------------
# 3. (Optional) Keep only delivered orders if you want “real” revenue
# ------------------------------------------------------------------
delivered = orders[orders['status'] == 'delivered']
# ------------------------------------------------------------------
# 4. Sum the revenue column to get the total revenue
# ------------------------------------------------------------------
total_revenue = delivered['revenue_usd'].sum()
print("Total revenue (delivered orders only): ${:.2f}".format(total_revenue))The code creates revenue_usd for each row using gross_usd - discount_usd - refund_usd. The status filter then selects the delivered orders, and sum() adds their net amounts.
I ran the generated code and received:
Total revenue (delivered orders only): $200.00In the response itself, Groq showed a different output:
Total revenue (delivered orders only): $140.00The USD 140 was written by the model. It was not the output from running its Python code. Groq also stated that removing the status filter would give the same amount because the cancelled order contributed zero. Order C has a gross amount of USD 200 with no discount or refund. Including it would make the net total USD 400.
The request did not define revenue, and Groq chose delivered-order net revenue. Another response could choose a different definition. In this run, the generated calculation and the amount written below it also disagreed.
2. Adding the Calculation Details to the Request
For our analysis, we will calculate net merchandise revenue from delivered orders. We will subtract the discount and recorded refund from each included order’s gross amount.
Net merchandise revenue = gross sales − discount − refundThe amounts from the table are:
Order Calculation Net amount, USD
A 100 − 10 − 20 70
B 80 − 0 − 0 80
D 60 − 0 − 10 50
Total 70 + 80 + 50 200We use A, B, and D because their status is delivered. Order C is cancelled, so it is excluded. The discount and refund columns contain order totals, which we can subtract directly.
I started a new conversation with the same table and added the calculation details:
Use the four-order table provided. Each row is one order, and all amounts are in USD. The discount and refund columns contain total adjustments for that order.
Calculate net merchandise revenue for delivered orders only. Subtract
discount_usdandrefund_usdfromgross_usdfor each included order.Use pandas without changing the original
ordersDataFrame. Show the included order IDs, their individual net amounts, and the total. Explain how the code calculates the result.
Groq returned the following Python code:
import pandas as pd
# --- 1. Filter to delivered orders ------------------------------------
delivered = orders[orders['status'] == 'delivered']
# --- 2. Compute the net amount for each delivered order ---------------
# net = gross – discount – refund
delivered = delivered.assign(
net_usd = delivered['gross_usd'] - delivered['discount_usd'] - delivered['refund_usd']
)
# --- 3. Show the order IDs, their net amounts, and the grand total ----
summary = delivered[['order_id', 'net_usd']].copy()
summary['net_usd'] = summary['net_usd'].round(2) # optional formatting
print(summary.to_string(index=False))
print("\nTotal net merchandise revenue: ${:.2f}".format(summary['net_usd'].sum()))Running this code gives:
order_id net_usd
A 70
B 80
D 50
Total net merchandise revenue: $200.00As we can see, A contributes USD 70, B contributes USD 80, and D contributes USD 50. The total is USD 200. The table and total written in Groq’s response matched these amounts.
First, orders['status'] == 'delivered' compares each status with delivered. The filter selects the three matching rows. Next, assign() returns a DataFrame with the new net_usd column. Groq stores it in delivered and selects the order ID and net amount for summary.
The code also uses round(2) for the net amounts and formats the printed total with two decimal places. Our example contains whole-dollar amounts, so this does not change the total. I also checked the original orders DataFrame after execution; it was unchanged by this response.
Run the dataset cell again before trying a different approach. The notebook includes this reset before the detailed and staged examples.
3. Asking for the Analysis in Several Steps
Let’s try the calculation in another conversation using the same table. This time, we will ask for the order selection first, followed by the amounts and total.
We are calculating net merchandise revenue from the four-order table. Include delivered orders only and subtract the order-level discounts and recorded refunds from gross sales.
Start by selecting the included orders using pandas. Show their order IDs and statuses without changing the original
ordersDataFrame. We will calculate the amounts in the next step.
Groq returned:
# 1️⃣ Filter for delivered orders (does **not** modify the original DataFrame)
delivered = orders[orders['status'] == 'delivered']
# 2️⃣ Show the relevant columns
delivered[['order_id', 'status']]The last line displays the selected columns in a notebook. Running it gives:
order_id status
A delivered
B delivered
D deliveredThe selected orders are stored in delivered. I used that variable name in the next request and included the result from running the code:
The code selected orders A, B, and D, all with status
delivered.Using
delivered, createnet_usdby subtractingdiscount_usdandrefund_usdfromgross_usd. Show the order ID, the three original amount columns, and the new net amount.
The next response contained:
# 1️⃣ Compute the net amount for each delivered order
delivered = delivered.assign(
net_usd = delivered['gross_usd'] - delivered['discount_usd'] - delivered['refund_usd']
)
# 2️⃣ Show the requested columns
delivered[['order_id', 'gross_usd', 'discount_usd', 'refund_usd', 'net_usd']]The executed result shows:
order_id gross_usd discount_usd refund_usd net_usd
A 100 10 20 70
B 80 0 0 80
D 60 0 10 50Order A has both a discount and a refund, leaving USD 70. Order B has no adjustments, so the amount remains USD 80. For order D, subtracting the USD 10 refund gives USD 50. The table written in this response matched the executed result.
Next, I sent the amounts back and asked for the total:
The net amounts are A = USD 70, B = USD 80, and D = USD 50. These match the source values and the formula.
Calculate the total from
delivered. Then write one sentence describing the result, including which orders and adjustments it covers.
Groq generated:
# Total net merchandise revenue for the delivered orders
total_net = delivered['net_usd'].sum()
total_netThe actual Python output was:
200Groq’s response showed 210 as the result and included the following sentence:
The total net merchandise revenue of USD 210 comes from the delivered orders A, B, and D after subtracting each order’s discount and refund amounts.
The individual amounts were 70, 80, and 50, and the code added them to 200. The written total was still different. I continued the conversation with the actual output:
I ran the code from your last response. The actual Python output was:
200
The preceding DataFrame contains A = 70, B = 80, and D = 50 in
net_usd. Your response showed 210 and described the total as USD 210. Review this difference and give the corrected total and one-sentence description. Keep the calculation definition and code unchanged.
Groq kept the same calculation code and corrected its result to 200. Its revised description also used USD 200 for orders A, B, and D after discounts and refunds. I ran the returned code again and received the same total.
When using a separate chat or API request, we need to send the Python output back ourselves. In this experiment, Groq received the result in the next message; it did not run the code or receive the notebook output automatically.
Comparing the Results
Below are the totals from the experiment:
General request: Python USD 200; Groq wrote USD 140.
Detailed request: Python USD 200; Groq wrote USD 200.
Several steps, before correction: Python USD 200; Groq wrote USD 210.
Follow-up with the actual output: Python USD 200; Groq wrote USD 200.
All three approaches generated code that calculated USD 200. The detailed request also produced a matching written total. With the staged requests, the selected orders and individual amounts matched our calculation, but the final description used USD 210. Providing the actual output in another request corrected that description.
I ran each approach once, with five requests in the original comparison and one additional request to review the mismatch. This is one example using one model and dataset. We cannot use it to conclude that detailed or staged requests always produce more accurate answers. If you repeat the experiment, your responses may differ.
The full experiment record contains the exact prompts, original Groq responses, generated code, and execution results. You can compare those responses with the notebook without making another API request.
Exercise: Changing the Included Orders
Let’s try another dataset using the same amount columns. This time, we have five orders and an additional status called shipped.
You can use the Lesson 1 exercise template in Colab to complete both parts. Save a copy to your Drive and fill in your calculations, requests, code, and notes.
exercise_orders = pd.DataFrame(
[
["E", "delivered", 120, 20, 15],
["F", "delivered", 90, 0, 0],
["G", "cancelled", 150, 0, 0],
["H", "shipped", 60, 10, 0],
["I", "delivered", 80, 0, 80],
],
columns=["order_id", "status", "gross_usd", "discount_usd", "refund_usd"],
)
print(exercise_orders.to_string(index=False))1. Calculate revenue from delivered orders
Calculate the net amount for each delivered order using
gross_usd - discount_usd - refund_usd, then add the amounts. Try the calculation yourself before running the code. Include order I, which has a refund equal to its gross amount.Provide the table to your assistant and write a request for the calculation. You can ask for the complete code or one part at a time. If you are using the supplied examples, adapt the code above for
exercise_orders.Compare the included order IDs and net amounts with your hand calculation. Explain how order I contributes to the total and whether it should still appear in the selected records.
2. Include delivered and shipped orders
Change the calculation to include both
deliveredandshippedorders. Continue to exclude cancelled orders and use the same subtraction. We will call this the net amount across delivered and shipped orders.Identify which order the new filter adds and calculate its net amount. Update your request or Python code.
Run the calculation again and explain the difference between the two totals.
Keep the following in your notebook:
Both calculations and their definitions.
The results and your explanation of the difference.
If you use an assistant, your request and a short explanation of how its code matches the calculation.
The exercise solution contains the answers and code for both parts.
Conclusion
In this lesson, we introduced the course and used Groq to generate pandas code for a revenue calculation. The code returned USD 200 in all three approaches. Two responses gave different totals in their explanations, and we used the actual Python output to correct the staged response.
For the exercise, try changing the order status filter and compare the selected orders and amounts.
In this lesson, we used the code and Groq responses supplied in the notebook. In Lesson 2, we will send the requests to Groq from Google Colab and use the results from our Python code to continue the conversation.