DEV Community: mwang-cmn

Exploration of Digital Banking Transactions: A SQL Analysis

mwang-cmn — Sat, 17 Aug 2024 08:47:07 +0000

Introduction

Data Bank, a cutting-edge digital bank, is pioneering the integration of banking and distributed data storage. By linking customers' cloud storage limits to their account balances, Data Bank offers a unique blend of financial services and secure data storage. As the digital banking landscape evolves, understanding customer behavior and forecasting data needs are crucial for strategic growth and efficient resource allocation.

Problem Statement

This project aims to explore customer nodes and transaction patterns within the Data Bank system to identify key metrics that will help the management team optimize customer allocation, improve transaction tracking, and accurately forecast future data storage requirements. View the data challenge here

Data Structure and SQL Environment

The dataset used in this analysis was intergrated into a SQL Server database. The database structure is designed with clarity featuring three key tables:

1. Regions:
2. Customer Nodes
3. Customer Transactions
The Entity Relationship Diagram for this dataset is as follows:

Data Cleaning

The dataset has been thouroughly examined and all three tables are clean and suited for analysis. There are no null values, duplicates or incorrect data types.

Question and Answers

How many unique nodes are there on the Data Bank system?

SELECT COUNT(DISTINCT node_id) as unique_nodes
  FROM dbo.customer_nodes;

What is the number of nodes per region?

SELECT r.region_name, COUNT(c.node_id) as nodes
  FROM customer_nodes c
 INNER JOIN regions r
    ON c.region_id = r.region_id
 GROUP BY r.region_name;

How many customers are allocated to each region?
Counts the unique number of customers from each Region, in descending order. Australia has the largest number of customers

SELECT r.region_name, COUNT(DISTINCT c.customer_id) as customer_count
  FROM customer_nodes c
 INNER JOIN regions r
    ON c.region_id = r.region_id
 GROUP BY r.region_name
 ORDER BY customer_count DESC;

How many days on average are customers reallocated to a different node?

SELECT AVG(DATEDIFF(DAY, start_date, end_date)) AS avg_days
FROM customer_nodes
WHERE end_date != '9999-12-31';

What is the median, 80th and 95th percentile for this same reallocation days metric for each region?
The CTE date_diff calculates the number of days each customer spends on a node before being reallocated, linking this data to specific regions. The query then computes the median (50th percentile), 80th percentile, and 95th percentile of these reallocation days for each region

WITH date_diff AS(
    SELECT  c.customer_id,
            r.region_name,
            r.region_id,
            DATEDIFF(DAY, start_date, end_date) AS reallocation_days
    FROM customer_nodes c
    INNER JOIN regions r
    ON c.region_id = r.region_id
    WHERE end_date != '9999-12-31'
)
SELECT DISTINCT region_id,
       region_name,
       PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY reallocation_days) OVER (PARTITION BY region_name) AS median_days,
       PERCENTILE_CONT(0.8) WITHIN GROUP (ORDER BY reallocation_days) OVER (PARTITION BY region_name) AS eighty_perc_days,
       PERCENTILE_CONT(0.95) WITHIN GROUP (ORDER BY reallocation_days) OVER (PARTITION BY region_name) AS ninety_five_perc_days
FROM date_diff
ORDER BY region_id, region_name;

What is the unique count and total amount for each transaction type?

SELECT txn_type AS transaction_type, 
        COUNT(*) AS unique_transactions,
        SUM(txn_amount) AS total_amount
  FROM customer_transactions
 GROUP BY txn_type
 ORDER BY unique_transactions DESC, total_amount DESC;

There were 4,777 unique transactions during the period, 56% of which were deposits. Additionally, the total amount transacted during the period was $2,958,708.

What is the average total historical deposit counts and amounts for all customers?
The CTE customer_deposits calculates the total number of deposits and the total amount of money deposited for each customer in the customer_transactions table. Itfilters the transactions to include only those where the transaction type is 'deposit', then grouping the results by each customer_id.

WITH customer_deposits AS (
SELECT  customer_id,
        COUNT(txn_type) as deposit_count,
        SUM(txn_amount) as deposit_amount
FROM customer_transactions
WHERE txn_type='deposit'
GROUP BY customer_id
)
 SELECT AVG(deposit_count) AS avg_count,
    AVG(deposit_amount) AS avg_amount
    FROM customer_deposits;

For each month - how many Data Bank customers make more than 1 deposit and either 1 purchase or 1 withdrawal in a single month?
The CTE customer_trends tracks customer transaction behavior on a monthly basis. It calculates, for each month and each customr id:

The number of deposits (deposit_count)
The number of purchases (purchase_count)
The number of withdrawals (withdrawal_count) The main query then determines, for each month, how many unique customers, made more than 1 deposit (deposit_count > 1).Additionally, made either at least 1 purchase or at least 1 withdrawal (purchase_count > 0 OR withdrawal_count > 0) in the same month.

WITH customer_trends AS 
(
SELECT customer_id,
       DATEPART(MONTH, txn_date) AS month_id,
       DATENAME(MONTH, txn_date) AS month_name,
       COUNT(CASE WHEN txn_type = 'deposit' THEN 1 END) AS deposit_count,
       COUNT(CASE WHEN txn_type = 'purchase' THEN 1 END) AS purchase_count,
       COUNT(CASE WHEN txn_type='withdrawal' THEN 1 END) AS withdrawal_count
  FROM customer_transactions
 GROUP BY customer_id, DATEPART(MONTH, txn_date),DATENAME(MONTH, txn_date)
)
SELECT  month_id,
      month_name,
      COUNT(DISTINCT customer_id) AS total_customers
  FROM customer_trends
 WHERE deposit_count>1 AND (purchase_count>0 OR withdrawal_count>0)
 GROUP BY month_id, month_name
 ORDER BY month_id, month_name;

This analysis identifies customers who are more actively engaged by tracking those who not only deposit money multiple times within a month but also use the account for other types of transactions like purchases or withdrawals.

What is the closing balance for each customer at the end of the month?

WITH cashflows AS (
    SELECT 
        customer_id,
        DATEPART(MONTH, txn_date) AS month_id,  -- Use month number for proper ordering
        DATENAME(MONTH, txn_date) AS month_name,
        SUM(CASE WHEN txn_type = 'deposit' THEN txn_amount ELSE -txn_amount END) AS inflow
    FROM 
        customer_transactions
    GROUP BY 
        customer_id, DATEPART(MONTH, txn_date), DATENAME(MONTH, txn_date)
)
SELECT 
    customer_id, 
    month_name, 
    SUM(inflow) OVER (
        PARTITION BY customer_id 
        ORDER BY month_id 
        ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
    ) AS closing_balance
FROM 
    cashflows
ORDER BY 
    customer_id, month_id;

To calculate the closing balance for each customer as of the maximum transaction date (txn_date) within each month;

WITH cashflows AS (
    SELECT 
        customer_id,
        txn_date,
        SUM(CASE WHEN txn_type = 'deposit' THEN txn_amount ELSE -txn_amount END) AS inflow
    FROM 
        customer_transactions
    GROUP BY 
        customer_id, txn_date
),
latest_cashflows AS (
    SELECT 
        customer_id,
        txn_date,
        SUM(inflow) OVER (PARTITION BY customer_id ORDER BY txn_date ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS closing_balance,
        ROW_NUMBER() OVER (PARTITION BY customer_id ORDER BY txn_date DESC) AS rn
    FROM 
        cashflows
)
SELECT 
    customer_id, 
    txn_date, 
    closing_balance
FROM 
    latest_cashflows
WHERE 
    rn = 1
ORDER BY 
    customer_id;

cashflows CTE:
This CTE calculates the net inflow for each customer_id and each txn_date. The result includes the transaction date (txn_date) along with the month information.
latest_cashflows CTE:
In this step, the ROW_NUMBER() function is used to assign a rank (rn) to each row within the partition of customer_id and month_id, ordered by txn_date in descending order. This ensures that the latest transaction date within each month is given the rank of 1.
Final Query:
The final SELECT statement retrieves the closing balance (inflow) for the latest transaction date in each month by filtering for rn = 1.
What is the percentage of customers who increase their closing balance by more than 5%?

What is the percentage of customers who increase their closing balance by more than 5%?

The cashflows CTE calculates the net cash flow for each customer per month by summing up the transaction amounts, treating deposits as positive inflows and other transactions as outflows.
ClosingBalance CTE:calculates the running (cumulative) closing balance for each customer over time by summing the monthly inflows up to and including the current month.
PercentChange CTE: This calculates the percentage change in the closing balance for each customer from one month to the next, using the LAG function to compare the closing balance of the current month with the previous month.

WITH cashflows AS (
    SELECT customer_id,
           DATEPART(YEAR, txn_date) * 12 + DATEPART(MONTH, txn_date) AS month_id,
           SUM(CASE WHEN txn_type = 'deposit' THEN txn_amount ELSE -txn_amount END) AS inflow
    FROM 
        customer_transactions
    GROUP BY 
        customer_id, DATEPART(YEAR, txn_date) * 12 + DATEPART(MONTH, txn_date)
),
ClosingBalance AS 
(
    SELECT customer_id, 
           month_id, 
           SUM(inflow) OVER (PARTITION BY customer_id ORDER BY month_id ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS closing_balance
      FROM cashflows
),
PercentChange AS 
(
    SELECT customer_id,
           month_id,
           closing_balance,
           100 * (closing_balance - LAG(closing_balance) OVER (PARTITION BY customer_id ORDER BY month_id)) / NULLIF(LAG(closing_balance) OVER (PARTITION BY customer_id ORDER BY month_id), 0) AS percent_increase
    FROM ClosingBalance
)
SELECT 100 * COUNT(DISTINCT customer_id) / CAST((SELECT COUNT(DISTINCT customer_id) FROM customer_transactions) AS float) AS percent_customers
  FROM PercentChange
 WHERE percent_increase > 5;

Full sql script - Github

Customer Segmentation - Time Based Cohort Analysis

mwang-cmn — Wed, 24 Jul 2024 08:27:44 +0000

Introduction

In the competitive landscape of modern business, understanding customer behavior is crucial for sustaining growth and maintaining a competitive edge. One of the most effective methods for gaining these insights is cohort analysis, which groups customers based on shared characteristics and tracks their behavior over time. This project demonstrates a comprehensive approach to conducting a time-based cohort analysis, focusing on customer retention, purchase behavior, and engagement.

Importance of Cohort Analysis for Businesses

Cohort analysis offers deep insights into customer behavior by tracking groups of customers (cohorts) who share common characteristics or experiences. This approach helps businesses:

Identify patterns and trends in customer behavior over time
Understand the impact of marketing efforts and product changes
Improve customer relationship management strategies

Data Preparation and Data Cleaning

The Data used in this analysis contains transactions ,made by customers from 28 countries.
Load and preprocess the dataset to ensure it is ready for analysis.

import pandas as pd

# Load the data
url = r"C:\Users\user.DESKTOP-1OSCPEL\Documents\Cohort Analysis\Ecommerce.csv"
data = pd.read_csv(url1, parse_dates = ['InvoiceDate'])
data.head()

Data Description
The dataset used in this cohort analysis is a transactional dataset from an unspecified retail business. It includes detailed records of customer purchases over a specific period. The dataset contains the following columns:

InvoiceNo: A unique identifier for each transaction. Each transaction can involve multiple items.
InvoiceDate: The date and time when the transaction was generated. This column is essential for time-based analysis, as it allows us to track the timing of each purchase.
CustomerID: A unique identifier for each customer. This column enables us to group purchases by customer and track their behavior over time.
StockCode: A unique identifier for each product. This column helps in identifying different products purchased.
Description: A brief description of the product. This column provides a human-readable name for each product.
Quantity: The number of units of the product purchased in each transaction. This column helps in understanding the volume of items sold.
UnitPrice: The price per unit of the product. This column, combined with the quantity, allows us to calculate the total sales for each product in each transaction.
Country: The country where the customer resides. This column helps in analyzing geographical patterns in customer behavior. I removed the null values and there were no duplicates in the dataset.

Exploratory Data Analysis

Quantity Sold by Country
These are the top 10 countries by Quantity sold:

These are the bottom 10 countries by Quantity sold:

Users by Country
These are the top 10 countries by number of unique customers:

These are the bottom 10 countries by number of unique customers:

Trend in Monthly Sales
A new column, Sales was calculated. I calculated the Monthly Sales and plotted a line graph using seaborn as follows

#  Calculate the Sales column
data['Sales'] = data['Quantity'] * data['UnitPrice']
# Extract Year-Month
data['Year-Month'] = data['InvoiceDate'].dt.to_period('M')

# Monthly sales
monthly_sales = data.groupby(['Year-Month'])['Sales'].sum()

#monthly_sales
plt.figure(figsize=(12,6))
sns.lineplot(x=monthly_sales.index.strftime('%y-%m'), y=monthly_sales.values, data=monthly_sales, ci=None)
plt.title('Monthly Trend of Sales')
plt.xlabel('Date')
plt.ylabel('Sales in millions')
plt.xticks(rotation=0)
plt.grid(True, which='both',linewidth=0.5)
plt.tight_layout()
plt.show()

The result was as follows:

Observations

December 2010 to August 2011: Noticeable fluctuations in sales quantity.
August 2011 to November 2011: A significant sales increase occurred.
November 2011 to December 2011: Sales experienced a sudden and substantial decline.

Cohort Analysis

Defining Cohorts

Identify cohorts based on the initial purchase dates and calculate the cohort indices.
1. Define Cohort Date
Since this is a time-based cohort analysis, the cohorts will be grouped according to the dates they made their first purchase

2. Define Cohort Index
The cohort Index is a measure of the time interval in months since a particular cohort made their first purchase. Index 4 for instance, indicates that this cohort made their first purchase 4 months ago. The cohort index is the difference between the Cohort Date and Invoice Date i.e. recent purchase time.

The resulting dataset with the Cohort Date and Cohort Index was as follows:

3. Calculating Cohort Metrics

Aggregate the data to calculate metrics such as unique users, average quantity, and retention rates.

# Group data by CohortDate and CohortIndex, and count unique CustomerIDs
cohort_data = data.groupby(['CohortDate', 'CohortIndex'])['CustomerID'].nunique().reset_index()

# Rename the 'CustomerID' column to 'Customers' for better clarity
cohort_data.rename(columns={"CustomerID": "Customers"}, inplace=True)

# Pivot the data to create a matrix where rows represent CohortDate, columns represent CohortIndex, and values represent the number of unique Customers
cohortdata = cohort_data.pivot(index='CohortDate', columns='CohortIndex', values='Customers')

# Display the pivoted cohort data
cohortdata

Visualizing Cohort Analysis

Generate heatmaps to visualize average quantity per cohort, retention rates, and users per cohort.
1. Average Quantity ordered per Cohort

average_quantity = data.groupby(['CohortDate', 'CohortIndex'])['Quantity'].mean().reset_index()
average_quantity['Quantity'] = average_quantity['Quantity'].round(1)
#Rename the Quantity column
average_quantity.rename(columns={'Quantity': 'Avg. Quantity'}, inplace=True)
#pivot the table 
quantity_pivot = average_quantity.pivot(index='CohortDate', columns=['CohortIndex'], values='Avg. Quantity')
# Convert index to the name of the month and year
quantity_pivot.index = quantity_pivot.index.strftime('%B %Y')
# Visualize using a heatmap
plt.figure(figsize = (15,8))
sns.heatmap(quantity_pivot, annot=True, cmap ='Dark2')
plt.title("Heatmap - Average Quantity Bought per Cohort", fontsize=14, fontweight='bold')
plt.show()

Insights

The Average Quantity bought is almost constant after a few months. While there maybe fluctuations in customer retention, the volume of sales does not fluctuate, indicating that few customers purchase a large quantity of products.
Target marketing can be increased in countries where more quantity is sold, rather than where more customers are acquired e.g. Tunisia, South Africa, Rwanda, Somalia etc

2. Retention Rate
Retention rate is a metric that measures the percentage of customers who continue to engage with a business over a specified period. It is calculated by dividing the number of retained customers by the total number of customers at the start of the period.
Importance of Retention Rate:

Indicates customer loyalty and satisfaction
Helps businesses understand long-term engagement
Provides insights into the effectiveness of customer retention strategies

# Calculate the Retention Rates 
cohort_retention_table = cohortdata.divide(cohortdata.iloc[:,0], axis=0)
cohort_retention_table

Heatmap for Retention Rates

# Visualize the retention rates for each cohort in a heatmap
plt.figure(figsize=(15,8))
sns.heatmap(cohort_retention_table, annot=True, cmap='Dark2', fmt='.0%')
plt.title("Heatmap - Retention Rates per cohort", fontsize=14, fontweight='bold')
plt.show()

3. Users per Cohort

# Convert Index to a readable format
cohortdata.index = cohortdata.index.strftime("%B-%Y")
# Plot heatmap
plt.figure(figsize=(15,8))
sns.heatmap(cohortdata, annot=True,cmap= 'Dark2_r', fmt=".2f")
plt.title("Heatmap - Users per Cohort", fontsize=14, fontweight='bold')
plt.show()

Analysis and Insights

The following are observations from the analysis:

Retention Rates: The retention rate ranges between 20% and 40%, meaning that 20% to 40% of customers continue to make purchases from the e-commerce platform.
December 2010 Cohort Outperforms Others: The December 2010 cohort has a retention rate above 30%, indicating strong customer engagement likely due to effective marketing or customer retention strategies.
Decline in December 2011: A noticeable decline in retention rates for all cohorts in December 2011 suggests potential issues during that period, warranting further investigation.
Variability in Retention Rates: Retention rates vary significantly, from a minimum of 8% to a maximum of 50%, indicating differing customer behaviors across cohorts.
Average Quantity Bought: The average quantity purchased remains relatively constant after a few months, suggesting stable sales volume despite fluctuations in customer retention. This indicates that fewer customers purchase larger quantities of products.

Recommendations

Identify Factors Driving High Retention (December 2010): Analyze the factors contributing to the high retention rate for the December 2010 cohort and replicate successful strategies for other cohorts.
Investigate December 2011 Drop: Investigate the causes behind the low retention rates in December 2011 by analyzing customer feedback, product quality, customer service, or any changes in business operations.
Set Realistic Targets: Set specific retention targets based on historical data and industry benchmarks, aiming to improve retention rates gradually over time.
Implement Retention Strategies: Develop and implement tailored retention strategies such as personalized marketing, loyalty programs, and targeted communication to improve retention rates.
Continuously Monitor and Adapt: Regularly monitor retention rates and cohort data to adapt strategies as needed, ensuring informed decisions to enhance customer retention.
Target Marketing in High-Quantity Regions: Increase target marketing efforts in countries where higher quantities are sold, such as Tunisia, South Africa, Rwanda, and Somalia, rather than focusing solely on customer acquisition.

Conclusion

Understanding customer behavior through cohort analysis provides invaluable insights that can drive strategic decision-making. This analysis highlights the importance of customer segmentation, as it allows businesses to identify and understand different customer groups' behavior over time. By segmenting customers based on their initial purchase dates, we can track retention rates, average purchase quantities, and overall engagement. This granular understanding helps in tailoring marketing strategies, improving customer retention efforts, and ultimately driving business growth. Proper segmentation ensures that resources are allocated effectively, catering to the specific needs and preferences of different customer cohorts.
Find the Notebook - Here

Energy Market Resilience Metrics: Analyzing Vulnerabilities and Preparing for Disruptions

mwang-cmn — Wed, 17 Jul 2024 08:26:27 +0000

Introduction
In the dynamic and competitive energy market, companies like EnergiX Enterprise face numerous challenges that can significantly impact their operations and profitability. Understanding these challenges and devising effective strategies to address them is crucial for maintaining stability and growth. This blog post delves into a comprehensive analysis of how regulatory changes, infrastructure and technology capabilities affect EnergiX's operational costs, revenue, demand and energy production and consumption using Python for data analysis and visualization.

Problem Statement
EnergiX Enterprise is currently grappling with several key issues:

Fluctuations in Energy Demand and Supply: The energy market experiences volatility due to evolving consumer behavior and market dynamics, impacting the company's operations and profitability.
Rising Competition from Renewable Energy Providers: The growth of renewable energy providers has intensified competition, affecting EnergiX's market share and pricing strategies.
Regulatory Changes and Environmental Regulations: Evolving regulations necessitate compliance measures that increase operational costs.
Aging Infrastructure and Technology Limitations: Outdated infrastructure and technology hinder operational efficiency and the company's ability to adapt to market dynamics.

Data Description

The four datasets in this analysis can be found here

Historical Energy Data: Contains information on energy production, consumption, prices, and operational costs.
Market Data: Provides insights into market prices, competitor strategies, and market trends.
Infrastructure and Maintenance Records: Details the condition of infrastructure, maintenance activities, and technology limitations.
Regulatory and Compliance Data: Tracks changes in regulations, compliance status, and associated costs. ## Data Cleaning Missing Values and Duplicates - There were no missing values or duplicates in the data Datatypes - Converted the Date/Time column in each dateset to Datetime format.

**Exploratory Data Analysis*

Univariate Analysis of Categorical Columns

I plotted bar plots for all categorical columns in each dataset as follows:

Analysis

1.Energy Demand, Production and Consumption over Time
Plot the Monthly Aggregate of Energy Demand , Production and Consuption over time.

#Extract Year and Month from Date/Time column in historical data
historical_data["Year"] = historical_data["Date/Time"].dt.year
historical_data["Month"] = historical_data["Date/Time"].dt.month
#Create new column Year-Month
historical_data["Year-Month"] = historical_data["Date/Time"].dt.to_period('M')

#Aggregate data on Monthly basis
monthly_data = historical_data.groupby("Year-Month").mean()
# Plot demand, production and consumption
plt.figure(figsize = (12,6))
sns.lineplot(data = monthly_data, x = monthly_data.index.astype(str), y = "Energy Demand", label = "Energy Demand", color="blue",ci=None)
sns.lineplot(data = monthly_data, x = monthly_data.index.astype(str), y = "Energy Consumption (kWh)", label = "Energy Consumption", color="brown",ci=None)
sns.lineplot(data = monthly_data, x = monthly_data.index.astype(str), y = "Energy Production (kWh)", label = "Energy Production", color="green",ci=None)
plt.title("Monthly aggregate of Energy Demand, Consumption and Production over time",  fontsize=14, fontweight='bold')
plt.xlabel("Date")
plt.ylabel("kwh")
labels = monthly_data.index.astype(str).tolist()
n=6
plt.xticks(labels[::n],rotation = 360)
plt.legend(loc='upper left', bbox_to_anchor=[1,1])
plt.grid(True, which='both',linewidth=0.5)
plt.subplots_adjust(hspace=0.5)
plt.tight_layout()
plt.show()

It appears that across the years, energy demand has exceeded both energy production and consumption. The company is unable to meet the market demand for energy. As energy is being produced, it is being consumed , i.e. the enery production is directly proportional to consumption. Investigate why they are unable to produce sufficient energy to meet the current market demand.

Market Price vs Energy Price

Investigate current pricing dynamics in relation to market trends

Energy price is the price at which the company currently charges for its product. Overall,both prices appear to fluctuate over time which maybe due to macroeconomic factors or regulatory factors. Market price is higher than the energy price, thus an indication of a competitive market. While the current energy prices may give the company a competitive edge, it may affect the profitablity of the company.

Investigate correlation between energy demand and energy price.

The correlation between Price and Demand of Energy is -0.005, a negative relationship, thus no linear relationship between these two variables. There may be other factors that affect the price or demand of their products.

Infrastructure Status and Technology Limitations

Investigate the distribution of these two categories.

The company is unable to produce sufficient energy to meet demand probably due to the poor state of their infrastructure and the high technology limitations they face during production

There is a high relationship between Poor Infrastructure and High technology limitations. This consolidates the idea that their infrastructure needs an upgrade or overhaul, to upscale their production.
To ascertain this, investigate the correlation between Infrastructure Status, Technology limitations and Energy demand

A correlation score of -0.015, suggests there is a weak negative linear relationship between demand and these infrastructure and technology limitations. Energy Production tends to decrease as Infrastructure and Technology limitations increase. While these constraints have a direct on production, demand is affected by other factors. This might also suggest there is a very competitive business environment in the energy sector, that may influence demand.

Regulatory Changes and Compliance Costs

Regulatory changes and amendments are frequent during this period of operations. Subsequent compliance costs are quite significant as well.

Investigate how these compliance costs impact the operational costs and the revenue generated by the company as well.

Operational costs are the day to day costs incurred by the business. All three metrics fluctuate over time, with the costs exceeding the revenue genated by the business. This business is running at a loss and must adjust its revenue strategies to meet its expenses. They need to adjust their pricing strategies and revenue allocation strategy.

Competition Analysis

Analyse Energy source column, visualize trends in production based on energy source over time.

There are fluctuations in production of both energy sources, with the renewable fuels seeing spikes in production during certain periods.
In other periods the production of the renewable sources declined,indicating possible competition, that impacted their overall market share. Focus on renewable sources should be considered, by working on the infrastructure and technology limitations to increase production. This may boost their market share and revenue over time.

Insights

Dynamic Energy Landscape - EnergiX Enterprise faces considerable variations in energy production, consumption, and demand patterns. Notably, there are specific periods where demand surpasses production, underlining potential market stability and supply consistency concerns.
Pricing Volatility - EnergiX's energy pricing exhibits significant volatility within broader market price trends. The energy price remains uncorrelated with energy demand, posing challenges for sales predictability and revenue forecasting.
Infrastructure & Technology Concerns - A significant portion of the company’s infrastructure is rated as 'Poor'. Combined with severe technology limitations, this necessitates comprehensive infrastructure rejuvenation. Initial analysis indicates that areas of 'Poor' infrastructure status and high technological constraints could result in reduced energy production.
Regulatory & Financial Implications -EnergiX is currently navigating a challenging regulatory landscape, with new mandates and modifications to existing ones. These financial ramifications, particularly in terms of compliance costs and operational expenditures, are significant. A juxtaposition of these costs with the firm’s current revenue trajectory indicates a pressing profitability challenge.
Emergence of Renewables- The energy market is experiencing a substantial shift towards renewables. Data trends suggest that renewable energy production instances have exceeded those of fossil fuels. For EnergiX, this highlights the dual challenges of evolving competition and potential market share erosion.

Recommendations

To address the identified challenges, we recommend the following strategies:

Enhance Market Resilience: Develop strategies to enhance the company's resilience to market fluctuations and regulatory changes.
Invest in Infrastructure and Technology: Prioritize investments in modernizing infrastructure and adopting advanced technologies to improve operational efficiency.
Optimize Energy Production and Pricing: Implement data-driven strategies to optimize energy production and pricing, ensuring competitiveness in the market.
Strengthen Compliance Measures: Proactively address regulatory requirements to minimize compliance costs and avoid potential penalties.

Conclusion

This analysis highlights the significant impact of regulatory changes on EnergiX Enterprise's operational costs, revenue, and compliance expenses. By leveraging data analysis and visualization, we have provided actionable insights and recommendations to help the company navigate the complex energy market effectively.

Find Full Notebook here

Floods Prediction in Lagos, Nigeria.

mwang-cmn — Mon, 08 Jul 2024 12:36:13 +0000

Introduction

Lagos is a city on Nigeria's Atlantic Coast with a population of 16.5 million people according to the UN in 2023. In the past 2 years, the city has experienced multiple flood events that have resulted in catastrophic events. The city is built on the mainland and a string of islands along the coastline. While the floods may be attributed to factors such as the rising sea levels, shoreline erosion and sand mining, it is imperative that the city implements effective disaster risk management system to deal with the effects of floods.
In this project I will implement an ARIMA model to predict when the city is likely to experience the floods.

Time series is widely used for forecasting and predicting future observations in a time series. AutoRegressive Intergrated Moving average models (ARIMA) are used for predicting time series data.

Data Understanding

The data used in this analysis ranges from 1st January 2002 to 28th February 2025. This data can be found on Visual Crossing.Find a description of each variable here

Notes
View notebook on Github

The data contains 44498 records and 36 columns.
I renamed the 'precip' column to 'Precipitation'
I renamed the datetime column to Date
I dropped the name column and set the Date column as the index.

#Drop name column
data.drop(['name'], axis=1, inplace=True)
#rename datetime to DATE
data.rename(columns={'datetime': 'Date'}, inplace=True)
#Rename precip to Precipitation
data.rename(columns={'precip': 'Precipitation'}, inplace=True)
#set date to index
data.set_index('Date', inplace=True)

Exploratory Data Analysis

A line plot showing Daily Precipitation from 2002 to 2024

A line plot showing Monthly Precipitation from 2002 to 2024

ARIMA Model

An ARIMA model is defined with the notation ARIMA(p,d,q), where
p - The number of lagged observations
d - Number of differencing operations
q - The size of the moving average window
When adopting an ARIMA model,the above parameters must be specified, the time series must be made stationary via differencing and the residuals should be uncorrelated. I conducted an adfuller test that confirmed the data series to be stationary.

An ARIMA model was used to forecast future daily precipitation based on historical data. The model provided a 30-day forecast of daily precipitation for the next year. This forecast was plotted along with historical data to visualize the forecast values.

# Forecast the next 12 months
forecast_steps = 12
forecast = arima_model.forecast(steps=forecast_steps)
# Plot the historical data and forecast
plt.figure(figsize=(10, 6))
plt.plot(monthly_data, label='Historical')
plt.plot(forecast, label='Forecast', color='red')
plt.title('Monthly Precipitation Forecast')
plt.xlabel('Date')
plt.ylabel('Precipitation (inches)')
plt.legend()
plt.show()

Recall, our values in Precipitation column are in inches. Therefore, given the tropical climate in Nigeria, I set a threshhold of 200 mm or 8 inches to indicate potential of a flood.Local studies in Nigeria have shown that rainfall events exceeding 150 mm often lead to significant flooding in Lagos.
I then subset the forecasted data to obtain the next 12 periods Lagos is likely to experience floods, that is, rainfall above 8 inches or 200 mm.

# Set the flood threshold
flood_threshold = 8.0
# Identify months with predicted precipitation above the threshold in the future forecast
flood_months = forecast_future[forecast_future > flood_threshold]

print("Predicted flood months:")
print(flood_months)

Conclusions

The ARIMA models provides a flexible and structured way to model a time series data that relies on historical observations as well as past prediction errors. Ho
Summary of Findings
In this study, I utilized historical rainfall data and time series techniques to predict flood occurrences in Lagos. By leveraging the ARIMA model, I generated accurate monthly precipitation forecasts. The analysis identified specific months with a high likelihood of flooding, providing valuable insights for urban planning and disaster management in Lagos.
Key findings include:

Prediction Accuracy: The ARIMA model demonstrated robust predictive capabilities, accurately forecasting rainfall trends.
Flood Threshold: We established a realistic flood threshold of 200 mm of rainfall within 24 hours, based on historical data and scientific literature.
Identified Risk Periods: Our model identified several months with predicted precipitation exceeding the flood threshold, indicating potential flood risk periods.
Implications for Stakeholders
The results of this analysis can significantly aid local authorities, urban planners, and disaster management agencies in:
Proactive Flood Management: Implementing early warning systems and preparedness measures during identified high-risk months.
Infrastructure Planning: Enhancing drainage systems and urban infrastructure to mitigate flood impacts.
Public Awareness: Informing and educating the public about flood risks and necessary precautions.

Limitations

While the analysis provides valuable insights, there are several limitations to consider:

Data Quality and Availability: The accuracy of predictions depends on the quality and granularity of historical rainfall data.
Model Assumptions: The ARIMA model assumes linearity and may not capture complex, non-linear interactions in climate data.
External Factors: Factors such as urbanization, land use changes, and climate change were not explicitly modeled but can significantly influence flood risks.

Find the full notebook on Github

Outlier Detection in Election Data Using Geospatial Analysis - AKWA IBOM

mwang-cmn — Fri, 05 Jul 2024 20:33:21 +0000

Introduction

The aim of this project is to uncover potential election irregularities to enable the electoral commission to ensure transparency of election results. In this project , I will identify outlier polling units where the voting results deviate significantly from neighbouring units.

Data Understanding

The dataset used in this analysis, represents polling units in the state of Akwa Ibom only.The data used can be found here. I conducted this analysis in Python as follows

from google.colab import drive, files
drive.mount('/content/drive')
#Import Libraries
import pandas as pd
from geopy.geocoders import OpenCage
#path = '/content/drive/MyDrive/Colab Notebooks/Nigeria_Elections/'
data = pd.read_csv(path + "AKWA_IBOM_crosschecked.csv")

Here is a summary about columns in the data set

State: The name of the Nigerian state where the election took place (e.g., “AKWA IBOM”).
LGA (Local Government Area): The specific local government area within the state (e.g., “ABAK”).
Ward: The electoral ward within the local government area (e.g., “ABAK URBAN 1”).
PU-Code (Polling Unit Code): A unique identifier for the polling unit (e.g., “3/1/2001 0:00”).
PU-Name (Polling Unit Name): The name or location of the polling unit (e.g., “VILLAGE SQUARE, IKOT AKWA EBOM” or “PRY SCH, IKOT OKU UBARA”).
Accredited Voters: The number of voters accredited to participate in the election at that polling unit.
Registered Voters: The total number of registered voters in that polling unit.
Results Found: Indicates whether results were found for this polling unit (usually TRUE or FALSE).
Transcription Count: The count of how many times the results were transcribed (may be -1 if not applicable).
Result Sheet Stamped: Indicates whether the result sheet was stamped (TRUE or FALSE).
Result Sheet Corrected: Indicates whether any corrections were made to the result sheet (TRUE or FALSE).
Result Sheet Invalid: Indicates whether the result sheet was deemed invalid (TRUE or FALSE).
Result Sheet Unclear: Indicates whether the result sheet was unclear (TRUE or FALSE).
Result Sheet Unsigned: Indicates whether the result sheet was unsigned (TRUE or FALSE).
APC: The number of votes received by the All Progressives Congress (APC) party.
LP: The number of votes received by the Labour Party (LP).
PDP: The number of votes received by the People’s Democratic Party (PDP).
NNPP: The number of votes received by the New Nigeria People’s Party (NNPP).

I then created the Address column by concatenating the Polling unit Name, Ward, the Local government Area and State, which will be useful during geocoding:

data['Address'] = data['PU-Name'] + ',' + data['Ward'] + ',' + data['LGA'] + ',' + data['State']

To obtain the Latitude and Longitude columns, I utilized geospatial encoding techiniques.
I generated an API key on OpenCage Geocoding API, and defined a function geocode_address to geocode our new Address column to obtain the Latitude and Longitude columns

def geocode_address(Address):
  try:
    location = geolocator.geocode(Address)
    return location.latitude, location.longitude
  except:
    return None, None

data[['Latitude', 'Longitude']] = data['Address'].apply(lambda x: pd.Series(geocode_address(x)))

A quick at our dataset:

Looks like our function works and I was able to obtain the Latitude and Longitude column.
As there are still null values in these 2 columns, I will Impute them using the Simple Imputer, which will replace the missing values with the mean.

from sklearn.impute import SimpleImputer
imputer = SimpleImputer(strategy = 'mean')
data[['Latitude', 'Longitude']] = imputer.fit_transform(data[['Latitude', 'Longitude']])
data.to_csv('AKWA_IBOM_geocode.csv', index = False)

Identifying Neighbours

I defined a radius of 1 km to identify which polling units are considered neighbours

#Calculate distance and find neighbours
from geopy.distance import geodesic
neighbours= {}
def neighbouring_pu(data, radius = 1.0):
  for i, row in data.iterrows():
    neighbours[i] = []
    for j, row2 in data.iterrows():
      if i != j:
        distance = geodesic((row['Latitude'],row['Longitude']), (row2['Latitude'],row2['Longitude'])).km
        if distance <= radius:
          neighbours[i].append(j)
  return neighbours

neighbours = neighbouring_pu(data, radius =1.0)

Outlier Calculation - Score
I will define a function, get_outlier_scores, that calculates the outlier scores for voting data in this dataset. It does so by comparing the votes each row received for various parties (APC, LP, PDP, NNPP) to the average votes received by its neighboring rows, which are specified in a dictionary, neighbours.
For each row, the function computes the absolute difference between the votes in that row and the average votes of its neighbors for each party, and stores these differences as outlier scores. Finally, it returns a new DataFrame that combines the original voting data with the calculated outlier scores. This allows for the identification of rows with voting patterns that significantly differ from their neighbors.

def get_outlier_scores(data, neighbours):
  outlier_scores = []
  parties = ['APC', 'LP', 'PDP', 'NNPP']
  for i, row in data.iterrows():
    scores = {}
    for party in parties:
      votes = row[party]
      neighbour_votes = data.loc[neighbours[i], party].mean() if neighbours[i] else 0
      scores[party + '_outlier_score'] = abs(votes - neighbour_votes)
    outlier_scores.append(scores)
    outlier_scores_data = pd.DataFrame(outlier_scores)
  return pd.concat([data, outlier_scores_data], axis = 1)

outlier_scores_df = get_outlier_scores(data, neighbours)

Sorting and Reporting
I sorted the data by the outlier scores for each party and obtained the following detailed report that includes the top five outliers for each party, with the 'PU-Code', number of votes, and the outlier score.

: All Progressives Congress (APC) party

PU-Code	APC	APC_outlier_score
03-05-11-009	324	228.52
03-29-05-013	194	167.334
03-30-07-001	180	153.325
03-05-09-014	194	152.149
03-28-05-003	180	138.132

: Labour Party (LP)

PU-Code	LP	LP_outlier_score
03-05-11-009	59	45.451
03-29-05-013	42	6.65894
03-30-07-001	29	6.34942
03-05-09-014	3	26.5831
03-28-05-003	91	61.5261

: People’s Democratic Party (PDP)

PU-Code	PDP	PDP_outlier_score
03-05-11-009	7	27.3627
03-29-05-013	181	145.232
03-30-07-001	17	18.8739
03-05-09-014	36	24.2221
03-28-05-003	12	48.2519

: New Nigeria People’s Party - NNPP

PU-Code	NNPP	NNPP_outlier_score
03-05-11-009	0	0.27451
03-29-05-013	6	4.14865
03-30-07-001	0	1.85521
03-05-09-014	0	2.36104
03-28-05-003	0	2.36104

Visualize the neighbours

Generate scatterplots to visualize the geographical distribution of polling units based on their outlier scores for four political parties (APC, LP, PDP, NNPP).
Each point represents a polling unit plotted by its latitude and longitude.
Each plot provides a clear visual representation of how the outlier scores are geographically distributed, making it easier to identify patterns or anomalies in the data.

import matplotlib.pyplot as plt
import seaborn as sns

parties = ['APC', 'LP', 'PDP', 'NNPP']
for party in parties:
  plt.figure(figsize=(10, 6))
  sns.scatterplot(data=outlier_scores_df, x='Latitude', y='Longitude', hue=party + '_outlier_score', palette='viridis')
  plt.title(f'Polling Units by {party} Outlier Score')
  plt.xlabel('Latitude')
  plt.ylabel('Longitude')
  plt.legend(title=party + ' Outlier Score')
  plt.savefig(f'polling_units_{party}_outlier_score.png')
  plt.show()

Deliverables

Find the full Notebook here
Full Report - Top five outliers for each party.
File with Latitude and Longitude - CSV
File with sorted polling units by outlier scores - CSV

Retail Sales Analysis - Python and Power BI

mwang-cmn — Fri, 05 Jul 2024 13:44:48 +0000

Introduction

One of the most crucial steps in improving business performance is to identify opportunities and evaluate sales performance in order to establish an effective strategy. This can be accomplished through descriptive analysis of sales data.
In this project, I will do a simple sales analysis of a retail store based on a historical dataset.
The dataset used in this analysis can be found on Kaggle.
The main objective of this analysis is to better understand business performance by tracking historical transactions. The tools used in this analysis in Colab Notebooks for data cleaning and EDA analysis, and Power BI for a dashboard.
The dataset contains records of transactions/ orders of a retail company specializing in transport by selling cars, trucks, planes, ships and trains

Data Cleaning and Transformation

Importing data

from google.colab import drive
drive.mount('/content/drive')
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
path = "/content/drive/MyDrive/Colab Notebooks/Retail_Sales/"
data = pd.read_csv(path + "sales_data_sample.csv", encoding='latin1', parse_dates= ['ORDERDATE'])
#Make a copy of dataset
retail_data = data.copy()
data.info()

From this initial assessment, there is one datetime column, nine numerical columns and fifteen categorical columns.
Check for duplicates and null values:

#Check for duplicates
retail_data.duplicated().sum()

There were no duplicated rows in the dataset.
Check for null values

# Check for null values
retail_data.isnull().sum()

The territory column has 1074 null values, which correspond to transactions in the USA and Canada. I imputed these null values with AMER to represent the Americas territory.

null_territory = retail_data['TERRITORY'].isnull().sum()
print(f'Number of null values in territory column: {null_territory}')
# view countries in Each territory
countries_by_territory = retail_data.groupby('TERRITORY')['COUNTRY'].unique()
print(f'Countries by territory:\n{countries_by_territory}')
# Impute null values in territorry column with AMER - Americas consisting the USA and Canada
retail_data['TERRITORY'] = retail_data['TERRITORY'].fillna('AMER')

I then converted the object dtypes to categoricy dtypes.

#copy of our dataset
retail_df = retail_data.copy()
#Convert object dtypes to categorical columns
categorical_columns = retail_df.select_dtypes(include=['object']).columns
#retail_df[categorical_columns] = retail_df[categorical_columns].astype('category')
categorical_columns

Notably, the dataset had a sales column, quantity ordered and price of each product line, per order. I created a REVENUE column to find out if it was equivalent to the SALES column.

#Create Revenue Column
retail_df['REVENUE'] = retail_df['QUANTITYORDERED'] * retail_df['PRICEEACH']

I then dropped irrelevant columns.Checking the final dtypes:

#Check dtypes
retail_df.info()

Exploratory Data Analysis

Correlation

**Correlation heatmap**
numerical_columns = retail_df.select_dtypes(include=['int64', 'float64']).columns
plt.figure(figsize = (10,6))
sns.heatmap(retail_df[numerical_columns].corr(), annot=True, cmap='coolwarm')
plt.title('Correlation Heatmap')
plt.show()

The correlation co-efficient indicates the linear relationship between two variables.

Quantity Ordered and Priceeach (0.0056) - this indicates a weak positive correlation. The two features are hardly related.
Quantity Ordered and Revenue (0.75) - Indicates a strong positive correlation. When the quantity ordered increases, revenue also increases.
Priceeach and Revenue (0.64) - Indicates a moderate correlation. When the price increases, revenue increases.

Outlier Detection

I plotted boxplots of Price, Revenue and Sales columns to check for possible outliers

**Identifying Outliers**
plt.figure(figsize=(8,6))
outlier = pd.DataFrame(data=retail_data, columns = ['REVENUE', 'QUANTITYORDERED', 'SALES'])
sns.boxplot(data=outlier, color='cyan')
plt.title('Outliers in the Revenue, Quantity and Sales columns')
plt.show()

The boxplots above identified possible outliers in the Sales column. However, the revenue column appears to have none. This indicates that there are discrepancies in the sales column. Recall the Revenue column was a direct calculation, of Quantity ordered and Price of each item, therefore, should have been equivalent to the Sales column values. The number of dicrepancies is 1304, about 46% of the dataset Since this is not the case, its important to find out why these discrepancies exist and their source.

After completion of the EDA analysis, I exported the dataset to Power BI for further analysis.

Analysis in Power BI

At this stage I used the dataset to create meaningful insights. The data collected contains data from 6th January 2003 to 31st May 2005.
Here is a preview of the final dashboard and insights from this dataset.

Insights and Recommendations.

There are 307 distinct orders, the total quantity of products sold over the 27 months was ninety nine thousand, revenue of 8 million USD and a shipping rate of 93%.

Revenue Trend
The revenue trend across all years remained consistent with its highest peak in November.This is consistent with sales trends during holiday seasons where sales are expected to rise.

Revenue also surged in the 4th quarter respectivelly and the retail company sold more units from Tuesday to Friday, compared to other days of the week.

Product Analysis

Classic Cars is the most popular product line, accounting for $3 million in revenue, about 37.5% of the total revenue during the entire period. Therefore, the company should extend extensive marketing of this product to their clientelle to improve revenue from this core product.

On the other hand, trains and ships were the least popular products, accounting for only 12.5% of the total revenue. The average prices of a ship, train and a classic car are $87.34, $83.86 and $75.65 respectively. Trains and ships are mostly purchased for commercial purposes, compared to classic cars that are used by individuals and this could explain the variance in revenue performance by these products. Due to the poor performance of the ships, marketing efforts can be redirected to cruise companies in Europe.
However, the retailer could consider smaller boats or yatchs, for private buyers as a potential investment.

Regional Analysis

The United States market recorded the highest revenue of $3 million while, Madrid city in Spain recorded the highest revenue during the period at $902,094, i.e. 10.88% of total revenue.
Additionally, the EMEA region, that is countries in Europe, accounted for 49.79% of the total revenue, followed closely by the Americas territory, AMER, at 38.35%. Marketing should also focus on these territories.

Link to Dashboard and Notebook

The final dashboard and notebook can be found below.

Ultimate Introduction to Python

mwang-cmn — Mon, 02 May 2022 08:35:40 +0000

Python is a general-purpose interpreted, interactive, object-oriented, and high-level programming language created by Guido van Rossum during 1985- 1990.
Why Python?

Easy-to-learn: Python has few keywords, simple structure, and a clearly defined syntax. This allows the student to pick up the language quickly.
Easy-to-read: Python code is more clearly defined and visible to the eyes.
Easy-to-maintain: Python's source code is fairly easy-to-maintain.
A broad standard library: Python's bulk of the library is very portable and cross platform compatible on UNIX, Windows, and Macintosh.
Interactive Mode: Python has support for an interactive mode which allows interactive testing and debugging of snippets of code.
Scalable: Python provides a better structure and support for large programs than shell scripting.
Databases: Python provides interfaces to all major commercial databases

Installing Python

Download the latest version for Windows, Linux and MacOS at this link
Variables
Variables store information that can be used and/or changed in your program. This information can be an integer, text, collection, etc. Variables are used to hold user inputs, local states of your program, etc. Variables have a name so that they can be referenced in the code. The fundamental concept to understand is that everything is an object in Python.
Python supports numbers, strings, sets, lists, tuples, and dictionaries. These are the standard data types.
To assign variable a value, use the equals sign (=)
Var_1= 1
var_2 = ‘dog’
var_3 = "Caroline"

Data structures and sequences

They include numbers, strings, lists, tuples, sets and dictionaries
Numbers
Include integers, decimals, floats
Strings
Textual information. Strings are sequence of letters. They are enclosed in quotation marks (single, double or triple). They are immutable. This means, once created, they cannot be changed

Tuples
A tuple is a fixed length, immutable sequence of python objects separated by commas enclosed in parathesis

{
tup1= (8,9,10) #create a tuple by enclosing a sequence in parathesis
tup2=tuple(‘string’) #convert any sequence to a tuple
tup1[2] =10 #access any item in a tuple using square brackets
}

Lists
Lists are variable length and their contents can be modified in place (mutable). They are defined by square brackets [] or the list type function.

{
List_1= [2,3,4] #create list by enclosing sequence in square brackets
List_2=list(tup1) #use the list type function
Output= [8,9,10]
}

Operations in lists
The following operations can be carried out in lists.

{
del(List_1[1])  #delete the second element using  the del() function
cop_list=List_1[:] #clone a list or create a copy by using a colon in square brackets
List_2.append(‘cats’) #add an element at the end of the list
Output:
 List_2
[8,9,10,’cats’]
List_2.insert(1, ‘fox’) #insert and element at index 1 of list 2
List_2
[8,’fox’,9,10,’cats’]
List_2.pop(3) #remove element at index 3
List_2
Output: [8,’fox’,9,’cats’]
List_2.extend([6, ‘dogs’]) #append multiple elements to a list using the extend function
List_2
Output: [8,’fox’,9,’cats’, 6, ‘dogs’]
Print(len(List_2)) #obtain number of elements in list
Output:6
}

Dictionaries
A dictionary is a flexibly sized collection of key-value pairs, where key and value are Python objects. One approach for creating one is to use curly braces {} and colons to separate keys and values. Keys can be strings, numbers or tuples. Values can be any data type.

{
dict_a={‘a’:[2,3], ‘b’:[4,5], ‘c’:[8,9]} #create a dictionary by assigning values to keys
dict_a[‘a’] =[2,3] #access value of a key using square brackets

}

Sets
A set is an unordered collection of unique elements. They are like dictionaries, but keys only, no values. A set can be created in two ways: via the set function or via a set literal with curly braces.
They do not record element position and have unique elements. They also support arithmetic operations.

{
Set1=(‘apple’, ‘banana’,’ apple’, ‘mango’, ‘kiwi’) #create a set and excludes duplicates
Set1
Output: {‘apple’, ‘banana’, ‘mango’, ‘kiwi’}
List3= [6,7,8]
Set2= set(List3) #covert a list to a set
Set2={6,7,8}
Set1.remove(‘banana’)
Set1: {‘apple’, ‘mango’, ‘kiwi’}
}

Arithmetic operations

Python supports the following operations

{
a+b #Addition 
a-b #Subtraction 
a*b #Multiplication
a/b #Division
a%b #Modulus that returns remainder of division
a**b #Exponentiation
a//b #Floor division that rounds the result to nearest whole number
}