Forem: Nivesh Bansal

Learning Python Standard Libraries in 60 Days — A Build in Public Journey

Nivesh Bansal — Thu, 22 Jan 2026 03:44:09 +0000

Today, I’m starting a 60-day “build in public” learning journey focused on Python Standard Libraries.

Instead of learning Python privately, I’ve decided to document and share my progress publicly — one Python standard library every day, with simple and practical examples.

This journey is also connected to my short-form content series on Instagram, where I explain each library visually.

📸 Instagram handle:
@notdonebuilding
👉 https://www.instagram.com/notdonebuilding/

📌 What this journey includes

One Python standard library every day
Clean, beginner-friendly code examples
Practical, real-world use cases
Daily source code uploaded to GitHub
Short visual explanations shared on Instagram

🧠 Why Python Standard Libraries?

Python’s real strength lies in its standard libraries.
They allow developers to build automation tools, system scripts, schedulers, and utilities without relying on external packages.

By mastering these libraries, we improve:

Core Python understanding
Code efficiency
Real-world problem-solving skills

🔗 Project Links

GitHub (Daily source code):
https://github.com/niveshbansal07/python-libraries
Instagram (Daily short explanations):
https://www.instagram.com/notdonebuilding/
LinkedIn (Journey updates & documentation):
https://www.linkedin.com/in/nivesh-bansal-0641272b5/

🎯 Goal of this series

The goal is simple:

Learn consistently
Share transparently
Improve communication skills
Help others learn Python through clear examples

I’ll be posting regular updates as the journey continues.
If you’re learning Python, automation, or backend development, feel free to follow along, share feedback, or contribute.

If you want next, I can:

Create a DEV.to series index post
Write Day-wise DEV.to summaries
Align GitHub + Instagram + DEV branding
Help you turn this into future opportunities

Just say next 🚀

Password Hashing in Python: Werkzeug vs bcrypt (Best Secure Way for Flask Developers)

Nivesh Bansal — Wed, 07 Jan 2026 09:50:59 +0000

📌 Introduction

Password security is one of the most important parts of any web application.
In Python and Flask, developers commonly use Werkzeug and bcrypt to hash passwords securely.

Storing passwords as plain text is extremely dangerous.
That’s why password hashing is used instead of encryption.

In this article, we will clearly explain:

What is password hashing
What is Werkzeug
What is bcrypt
How they work
Code examples
Real-world usage
Differences between Werkzeug and bcrypt

This guide is beginner-friendly, SEO-optimized, and interview-ready.

🔑 What is Password Hashing?

Password hashing is a one-way process that converts a password into a fixed-length string (hash).

Hashing is not reversible
Original password cannot be recovered
Used to protect user credentials

✅ Example:

Password: niveshbansal
Hash: pbkdf2:sha256:260000$abc$xyz

🛠️ Werkzeug in Python (Flask Security Library)

✅ Definition

Werkzeug is a Python web utility library and the core backbone of Flask.
It provides built-in tools for secure password hashing, request handling, and file uploads.

Flask internally uses Werkzeug.

⚙️ How Werkzeug Works (Theory)

Werkzeug uses:

PBKDF2 algorithm
SHA256 hashing
Automatic salt
High iteration count

This makes passwords resistant to brute-force attacks.

🧪 Werkzeug Password Hashing Example

from werkzeug.security import generate_password_hash, check_password_hash

password = "niveshbansal"

## Hashing password
hashed_password = generate_password_hash(password)

## Verifying password
check = check_password_hash(hashed_password, "niveshbansal")

print(check)  # True

📌 Where Werkzeug is Used

Flask authentication systems
Login & signup forms
Admin panels
REST APIs
Beginner to production Flask apps

🧠 Why Use Werkzeug?

Easy to use
No external dependency
Flask recommended
Secure by default
Industry standard (OWASP compliant)

🔐 bcrypt in Python (Advanced Password Hashing)

✅ Definition

bcrypt is a dedicated password hashing library designed for maximum security.

It is widely used in:

Banking apps
Enterprise systems
Authentication services

bcrypt does slow hashing, which makes brute-force attacks very difficult.

⚙️ How bcrypt Works (Theory)

bcrypt uses:

Blowfish-based hashing
Random salt
Cost factor (rounds)
Adaptive slow hashing

Same password → different hash every time

🧪 bcrypt Password Hashing Example

import bcrypt

password = "niveshbansal".encode("utf-8")

## Hash password
hashed = bcrypt.hashpw(password, bcrypt.gensalt())

## Verify password
bcrypt.checkpw(password, hashed)

📌 Where bcrypt is Used

High-security authentication systems
Finance & payment apps
APIs with JWT authentication
Enterprise-grade applications
Cross-language authentication systems

🧠 Why Use bcrypt?

Very strong security
Built-in salt
Cost factor control
Resistant to GPU attacks
Trusted industry-wide

⚔️ Werkzeug vs bcrypt (Difference Table)

Feature	Werkzeug	bcrypt
Type	Web utility library	Password hashing library
Algorithm	PBKDF2 + SHA256	bcrypt
Salt handling	Automatic	Automatic
Speed	Faster	Slower (more secure)
Flask integration	Built-in	External
Best for	Flask apps	High-security systems
Beginner friendly	✅ Yes	⚠️ Medium

✅ Which One Should You Use?

Flask projects → Werkzeug
High-security apps → bcrypt
Beginners & interviews → Werkzeug
Advanced authentication → bcrypt

🎯 Interview-Friendly Summary

Werkzeug is a Flask utility library that provides secure password hashing using PBKDF2, while bcrypt is a dedicated password hashing algorithm designed for high-security authentication systems using slow hashing and cost factors.

🧠 Final Conclusion

Password hashing is mandatory for secure applications.
Both Werkzeug and bcrypt are trusted, secure, and production-ready.

Choose based on:

Project complexity
Security requirements
Framework usage

✍️ Written by Nivesh Bansal
Portfolio | Linkedin | GitHub

Master Python Set Methods with Simple Visuals (Emoji Guide Inside!)

Nivesh Bansal — Tue, 18 Nov 2025 04:36:51 +0000

.add() → Add one item to set

.remove() → Remove item (error if missing)

.discard() → Remove safely without any error

.union() → Combine elements from both sets

.intersection() → Return only common elements

.difference() → Keep elements unique in first set

.clear() → Remove all items from set

Mastering Python doesn’t have to feel overwhelming — especially when the concepts are broken down visually.
In this post, I’m sharing a minimal, emoji-based infographic that explains the most important Python Set methods in the simplest way possible.

Whether you're learning Python for Data Science, Automation, Backend Development, Machine Learning, or DSA, understanding set operations like add(), remove(), union(), and intersection() can help you write cleaner, faster, and more efficient code.

Sets play a huge role in deduplication, filtering, comparisons, and mathematical operations — and this visual guide makes each method super easy to understand.

Minimal visuals. Maximum clarity.
Perfect for beginners, and a refreshing quick-reference for experienced developers.

If you love clean learning resources, this guide will make Python feel simple, logical, and even fun! 🐍⭐

4 Best Power BI & Data Analytics Projects That You Must See!

Nivesh Bansal — Wed, 29 Oct 2025 15:18:36 +0000

Data isn’t just numbers — it’s stories waiting to be told 📊✨.
I’ve spent months exploring real-world datasets and building impactful dashboards using Power BI, Excel, and SQL to turn raw information into meaningful insights.
Here are my top 4 portfolio projects that truly reflect my journey as a Data Analyst — from HR insights to restaurant analytics, pandemic visualization, and mobile sales trends.

By Nivesh Bansal: Portfolio | Linkedin | GitHub

💼 1. IBM HR Dashboard — Employee Insights at a Glance

GitHub: View Project on GitHub →

Description:
A complete HR analytics dashboard that helps companies track key employee metrics like department-wise headcount, attrition rate, gender ratio, performance, and salary distribution.

🧰 Tech Stack:
Power BI, Excel, DAX, Data Modeling

📂 Data Source:
HR Analytics dataset (Kaggle / simulated employee records)

💡 Highlights:

Gender & department-wise employee distribution
Attrition & satisfaction analysis
KPI cards for HR decisions
Trend insights for hiring and retention

🍽️ 2. Zomato Dashboard — Restaurant Business Analytics

GitHub: View Project on GitHub →

Description:
This Power BI dashboard visualizes restaurant data from Zomato, analyzing key factors like cuisine trends, restaurant ratings, price levels, and city-wise performance.

🧰 Tech Stack:
Power BI, Excel, Power Query, DAX

📂 Data Source:
Public Zomato dataset from Kaggle

💡 Highlights:

City-wise restaurant distribution
Top cuisines & rating trends
Cost vs. rating correlation
Insights for restaurant business strategy

🦠 3. COVID-19 Analytics Dashboard — Tracking the Global Pandemic

GitHub: View Project on GitHub →

Description:
A data-driven visualization of the global COVID-19 situation — showing total cases, recoveries, deaths, and vaccination progress across countries.

🧰 Tech Stack:
Power BI, Excel, Power Query, API data import

📂 Data Source:
COVID-19 World Data (Johns Hopkins, WHO, or Kaggle)

💡 Highlights:

Country & continent-wise comparison
Real-time refresh from API
Trend lines for daily new cases
Dynamic slicers for analysis by region

📱 4. Mobile Sales Dashboard — Business Performance Tracking

GitHub: View Project on GitHub →

Description:
A sales performance dashboard analyzing smartphone sales trends, top brands, revenue, and customer ratings.

🧰 Tech Stack:
Power BI, Excel, SQL, DAX

📂 Data Source:
Mobile Sales dataset from Kaggle / Google Sheets

💡 Highlights:

Region & brand-wise sales
Revenue and profit margin analysis
Year-over-year comparison charts
KPI indicators for business growth

🌟 Final Thoughts

Each of these projects helped me explore different aspects of business intelligence — from people analytics to real-time data visualization.
If you’re a data enthusiast, feel free to explore the GitHub repositories, try the dashboards, and maybe even fork them to learn from the logic and visual design.

By Nivesh Bansal: Portfolio | Linkedin | GitHub

IBM HR Analytics Dashboard — Power BI + Python Project

Nivesh Bansal — Sat, 11 Oct 2025 05:30:21 +0000

Author: Nivesh Bansal
Tech Stack: Power BI | Python (Pandas, Matplotlib) | Power Query | DAX | Excel

🔗 Explore the project on GitHub: IBM HR Dashboard Repo

🔗 Explore the project on LinkedIn: IBM HR Dashboard Post

📊 Project Overview

I'm excited to share my latest IBM HR Analytics Dashboard, built to explore and visualize insights from the IBM HR Analytics Dataset (Kaggle).

This project focuses on understanding key human resource trends — including attrition, job satisfaction, salary distribution, employee engagement, and performance.

The dashboard is designed to help HR professionals and data analysts uncover insights that drive data-informed decisions.

🧠 Objectives

Analyze employee attrition and performance trends
Understand salary distribution by department and job role
Visualize travel frequency and demographic patterns
Monitor key HR KPIs like job satisfaction, training, and promotions
Highlight the relationship between employee involvement and retention

💡 Key Features

✅ Department-wise Analysis — Breakdown of Research, Sales, and HR departments
✅ Travel Frequency Insights — Compare frequent vs. rare travelers
✅ Salary & Income Visualization — Hourly, Monthly, and Annual income tracking
✅ Attrition & Performance Dashboard — Identify high-performing roles and retention risks
✅ Gender Distribution — Insights into diversity within the organization

⚙️ Tools & Technologies

Power BI — Interactive visual dashboard creation
Python (Pandas, Matplotlib) — Data preprocessing and visualization
Power Query & DAX — Data transformation and calculated measures
Excel — Data cleaning and structure setup

📂 Dataset Source

Dataset: IBM HR Analytics Employee Attrition & Performance – Kaggle

📈 Insights Discovered

Research & Development department has the highest employee count
Rare Travelers form the largest segment of the workforce
Average Employee Age: 36 years
Average Performance Rating: 3 / 4
Most employees have 0 previous companies worked (low external mobility)

🧩 Conclusion

This project demonstrates how data analytics empowers HR management to make evidence-based decisions.
By analyzing workforce data visually, HR teams can improve retention, engagement, and overall productivity.

Zomato Global Restaurant Insights Dashboard

Nivesh Bansal — Tue, 30 Sep 2025 12:16:12 +0000

🍴 Zomato Global Restaurant Insights Dashboard: Explore Dining Trends Worldwide 🌍

Discover patterns in restaurant ratings, pricing, and delivery options across countries with my interactive Zomato Dashboard! Built using Power BI and Python, this dashboard provides a deep dive into global restaurant insights.

✨ Key Highlights:

Interactive KPIs & Metrics: Track restaurant ratings, votes, and cost trends.
Global Map Visualization: See restaurant distribution across continents.
Filters & Insights: Analyze by country, city, cuisine, or delivery options.
Business Impact: Identify top-rated restaurants, market trends, and delivery availability.

📂 Tech Stack: Power BI, Python (Pandas, Seaborn, Matplotlib), Power Query, DAX.

🔗 Explore the project on GitHub: Zomato Dashboard Repo

🔗 Explore the project on LinkedIn: Zomato Dashboard Post

Data Cleaning & Preparation: The Ultimate Guide for Any Dataset

Nivesh Bansal — Thu, 25 Sep 2025 11:47:26 +0000

When we start working as a Data Analyst, the first step is not building dashboards or making charts.
The first step is always cleaning and preparing the dataset.

👉 If the dataset is not clean, the final analysis will be wrong or misleading.

In this post, we will go through every important task you should do with a fresh dataset (no matter if it is sales data, HR data, COVID data, banking data, or any other).

We will use Python (pandas) for examples, but the steps apply to any dataset.

Step 1: Import Libraries and Load Dataset

import pandas as pd

## Example for CSV file
df = pd.read_csv("data.csv")

## Example for Excel file
## df = pd.read_excel("data.xlsx")

## Example for SQL database
## import sqlite3
## conn = sqlite3.connect("data.db")
## df = pd.read_sql("SELECT * FROM table_name", conn)

print(df.head())

Always start by loading the dataset and looking at the first few rows.

Step 2: Check Dataset Shape

print(df.shape)

Example Output:

(10000, 15)

10,000 rows (data entries)
15 columns (variables)

Helps you know how big the dataset is.

Step 3: Get Dataset Info

print(df.info())

This shows:

Column names
Data types (int, float, object, datetime)
Non-null counts

Example:

order_id        10000 non-null int64
order_date      9990 non-null object
sales_amount    9800 non-null float64
customer_name   10000 non-null object

Step 4: Check First and Last Few Rows

print(df.head(10))
print(df.tail(10))

Helps you:

Confirm column order
Check sorting (time, id, etc.)
Spot strange values

Step 5: Check Column Names

print(df.columns)

Example:

['Order ID', 'Order Date', 'Sales Amount', 'Customer Name']

Sometimes names have spaces, symbols, or capital letters. Clean them:

df.columns = df.columns.str.strip().str.lower().str.replace(" ", "_")

Now column names are:

['order_id', 'order_date', 'sales_amount', 'customer_name']

Step 6: Handle Data Types

Always check if each column has the correct type:

print(df.dtypes)

Example fixes:

## Convert date column
df['order_date'] = pd.to_datetime(df['order_date'], errors='coerce')

## Convert numeric columns
df['sales_amount'] = pd.to_numeric(df['sales_amount'], errors='coerce')

## Convert categorical columns
df['customer_name'] = df['customer_name'].astype('category')

Step 7: Check Missing Values

print(df.isnull().sum())

Example Output:

order_date      10
sales_amount   200
customer_name    0

Ways to handle missing values:

Drop rows/columns

df.dropna(subset=['order_date'], inplace=True)

Fill with mean/median/mode

df['sales_amount'].fillna(df['sales_amount'].median(), inplace=True)

Fill forward/backward (time series)

df['sales_amount'].fillna(method='ffill', inplace=True)

Step 8: Check for Duplicates

print(df.duplicated().sum())
df = df.drop_duplicates()

Avoid double counting.

Step 9: Explore Unique Values

print(df['customer_name'].unique())
print(df['customer_name'].nunique())

Helps find spelling mistakes like "John Smith" vs "Jon Smith".

Step 10: Descriptive Statistics

print(df.describe(include='all'))

Example:

sales_amount   min: -50   max: 100000   mean: 2500

Helps detect:

Outliers
Negative values (not possible for sales)
Very large values

Step 11: Handle Outliers

Example: Negative sales amount should not exist.

df = df[df['sales_amount'] >= 0]

Or cap extreme values:

q1 = df['sales_amount'].quantile(0.25)
q3 = df['sales_amount'].quantile(0.75)
iqr = q3 - q1
lower = q1 - 1.5 * iqr
upper = q3 + 1.5 * iqr

df = df[(df['sales_amount'] >= lower) & (df['sales_amount'] <= upper)]

Step 12: Standardize Text Data

Example: customer names, product names, cities

df['customer_name'] = df['customer_name'].str.strip().str.title()

Removes extra spaces and standardizes case.

Step 13: Rename or Drop Columns

df.rename(columns={'sales_amount': 'revenue'}, inplace=True)

df.drop(columns=['unnecessary_column'], inplace=True)

Step 14: Create New Features

Examples:

Profit Margin
Year, Month from date
Age group

df['year'] = df['order_date'].dt.year
df['month'] = df['order_date'].dt.month

Step 15: Check Data Consistency

Dates should be in correct order
IDs should be unique
Categories should make sense

print(df['year'].unique())
print(df['order_id'].nunique(), df.shape[0])

Step 16: Sort and Reset Index

df = df.sort_values(by=['order_date'])
df = df.reset_index(drop=True)

Step 17: Final Save

df.to_csv("clean_data.csv", index=False)

Now dataset is ready for analysis or dashboard (Power BI, Tableau, etc.).

Final Checklist for Any Dataset

✅ Import dataset
✅ Check shape, info, head/tail
✅ Clean column names
✅ Fix data types
✅ Handle missing values
✅ Remove duplicates
✅ Check unique values
✅ Descriptive statistics
✅ Handle outliers
✅ Standardize text
✅ Drop/rename columns
✅ Create new features
✅ Check consistency
✅ Sort and reset index
✅ Save clean dataset

Conclusion

No matter what dataset you are working on (Sales, HR, Finance, COVID, Marketing, Banking, Ecommerce),
these steps will always help you make the dataset clean and ready for analysis.

👉 Clean data = Better insights + Correct dashboards + Happy clients.

By Nivesh Bansal

The Ultimate MySQL Queries Cheat Sheet (With Examples & Outputs)

Nivesh Bansal — Tue, 23 Sep 2025 05:26:32 +0000

🗄️ The Ultimate MySQL Queries Cheat Sheet (With Examples & Outputs)

SQL (Structured Query Language) is the standard way to interact with databases.
If you’re learning MySQL, here’s the all-in-one guide with all essential queries, simple explanations, and real examples with outputs.

We’ll build this step by step with a students table + courses table for clarity.

🏗️ Setup: Create Tables

CREATE TABLE students (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(100),
    age INT,
    course VARCHAR(100),
    marks INT
);

CREATE TABLE courses (
    course_id INT AUTO_INCREMENT PRIMARY KEY,
    course_name VARCHAR(100),
    instructor VARCHAR(100)
);

Insert sample data:

INSERT INTO students (name, age, course, marks) VALUES
('Alice', 20, 'Computer Science', 85),
('Bob', 22, 'Mathematics', 90),
('Charlie', 21, 'Physics', 75),
('Daisy', 23, 'Computer Science', 95);

INSERT INTO courses (course_name, instructor) VALUES
('Computer Science', 'Dr. Smith'),
('Mathematics', 'Dr. John'),
('Physics', 'Dr. Lee');

✅ Now let’s dive into queries.

🔹 Basic SQL Queries

1. Show All Databases

SHOW DATABASES;

👉 Output:

Database
mysql
information_schema
test_db

2. Use a Database

USE test_db;

3. Show All Tables

SHOW TABLES;

👉 Output:

Tables_in_test_db
students
courses

4. Describe a Table

DESCRIBE students;

👉 Output:

Field	Type	Null	Key	Default	Extra
id	int	NO	PRI	NULL	auto_increment
name	varchar(100)	YES		NULL
age	int	YES		NULL
course	varchar(100)	YES		NULL
marks	int	YES		NULL

🔹 Data Retrieval

5. SELECT – Fetch Data

SELECT * FROM students;

👉 Output:

id	name	age	course	marks
1	Alice	20	Computer Science	85
2	Bob	22	Mathematics	90
3	Charlie	21	Physics	75
4	Daisy	23	Computer Science	95

6. WHERE – Filter Data

SELECT name, marks FROM students WHERE marks > 80;

👉 Output:

name	marks
Alice	85
Bob	90
Daisy	95

7. ORDER BY – Sorting

SELECT * FROM students ORDER BY marks DESC;

👉 Output:

name	marks
Daisy	95
Bob	90
Alice	85
Charlie	75

8. LIMIT – Restrict Rows

SELECT * FROM students LIMIT 2;

👉 Output:

name	age	course	marks
Alice	20	Computer Science	85
Bob	22	Mathematics	90

9. DISTINCT – Unique Values

SELECT DISTINCT course FROM students;

👉 Output:

course
Computer Science
Mathematics
Physics

🔹 Data Modification

10. INSERT – Add Data

INSERT INTO students (name, age, course, marks)
VALUES ('Eve', 20, 'Mathematics', 88);

11. UPDATE – Modify Data

UPDATE students SET marks = 92 WHERE name = 'Alice';

12. DELETE – Remove Data

DELETE FROM students WHERE name = 'Charlie';

13. DROP – Remove a Table

DROP TABLE students;

🔹 Advanced SQL Queries

14. GROUP BY – Aggregation

SELECT course, AVG(marks) AS avg_marks
FROM students
GROUP BY course;

👉 Output:

course	avg_marks
Computer Science	90
Mathematics	89
Physics	75

15. HAVING – Filter Groups

SELECT course, AVG(marks) AS avg_marks
FROM students
GROUP BY course
HAVING avg_marks > 80;

👉 Output:

course	avg_marks
Computer Science	90
Mathematics	89

16. JOIN – Combine Tables

SELECT s.name, s.course, c.instructor
FROM students s
JOIN courses c ON s.course = c.course_name;

👉 Output:

name	course	instructor
Alice	Computer Science	Dr. Smith
Bob	Mathematics	Dr. John
Daisy	Computer Science	Dr. Smith

17. LIKE – Pattern Matching

SELECT * FROM students WHERE name LIKE 'A%';

👉 Output:

id	name	age	course	marks
1	Alice	20	Computer Science	92

18. BETWEEN & IN

-- Marks between 80 and 95
SELECT * FROM students WHERE marks BETWEEN 80 AND 95;

-- Students in specific courses
SELECT * FROM students WHERE course IN ('Mathematics', 'Physics');

🔹 Transactions

19. START TRANSACTION, COMMIT, ROLLBACK

START TRANSACTION;

UPDATE students SET marks = 100 WHERE name = 'Bob';

ROLLBACK;  -- undo changes
-- COMMIT; -- confirm changes

🔹 Triggers & Stored Procedures

20. DELIMITER + TRIGGER

DELIMITER //

CREATE TRIGGER after_insert_student
AFTER INSERT ON students
FOR EACH ROW
BEGIN
    INSERT INTO courses (course_name, instructor)
    VALUES ('New Course', 'TBD');
END //

DELIMITER ;

21. STORED PROCEDURE

DELIMITER //

CREATE PROCEDURE GetHighScorers()
BEGIN
    SELECT name, marks FROM students WHERE marks > 85;
END //

DELIMITER ;

CALL GetHighScorers();

👉 Output:

name	marks
Alice	92
Bob	90
Daisy	95

🔹 Views & Indexes

22. CREATE VIEW

CREATE VIEW high_scorers AS
SELECT name, course, marks
FROM students
WHERE marks > 85;

SELECT * FROM high_scorers;

👉 Output:

name	course	marks
Alice	Computer Science	92
Bob	Mathematics	90
Daisy	Computer Science	95

23. INDEX

CREATE INDEX idx_course ON students(course);

👉 Helps speed up searches on course.

🎯 Final Thoughts

We just covered all essential MySQL queries:

✅ Basic (CREATE, SELECT, WHERE, ORDER, LIMIT, DISTINCT)
✅ Modification (INSERT, UPDATE, DELETE, DROP)
✅ Advanced (GROUP BY, HAVING, JOIN, LIKE, IN, BETWEEN)
✅ Transactions (COMMIT, ROLLBACK)
✅ Triggers, Procedures, Views, Indexes

This is your complete MySQL cheat sheet 📖. Bookmark it, copy-paste it, and practice with real data.

✍️ Written by Nivesh Bansal

Seaborn Complete Roadmap - in 2 Days (with "tips" dataset)

Nivesh Bansal — Tue, 16 Sep 2025 12:51:17 +0000

A focused 2-day roadmap to master Seaborn for data analytics using the tips dataset.
This guide includes setup, explanations, code examples, pitfalls, checkpoints, and a mini-project.
By the end, you’ll have job-ready visualization skills.

Source Code: Click here
Written By: Nivesh Bansal Linkedin GitHub Instagram

Seaborn Roadmap for Data Analytics (Using `tips`)

Goal: Master Seaborn’s essentials in 2 days (or one power-day).
This roadmap covers every necessary topic with explanations, code snippets, and practice tasks—focused purely on practical analytics.

Key Outcomes:

Dataset: sns.load_dataset("tips")
Focus: EDA • Storytelling • Clean visuals
Result: Job-ready plotting skills

Tip: Don’t memorize. For each topic:

Run the example
Tweak 2–3 parameters
Write one insight in plain English

Requirements:

Python ≥ 3.9
Libraries: pandas, numpy, matplotlib, seaborn
IDE: Jupyter/Colab or any Python IDE

0) Quick Setup

pip install seaborn matplotlib pandas numpy

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd

sns.set_theme(style="whitegrid", context="notebook")
tips = sns.load_dataset("tips")
tips.head()

Dataset Columns:
total_bill, tip, sex, smoker, day, time, size

📅 Day 1 — Foundations & Core EDA

Goal: Understand Seaborn’s API, explore distributions, compare categories, and scan pairwise relationships quickly.

1) Seaborn Basics: Figure-level vs Axes-level

Axes-level → e.g., sns.scatterplot (draws on Matplotlib Axes, returns Axes)
Figure-level → e.g., sns.catplot, sns.pairplot (manages own figure/layout)
Common params: data=, x=, y=, hue=, style=, size=

2) Univariate Distributions

Use these to understand shape, center, spread, and outliers:

histplot — histogram (+ KDE option)
kdeplot — kernel density estimate
ecdfplot — empirical CDF (great for medians & quantiles)
countplot — frequency for categorical variables

# Histogram & KDE
sns.histplot(tips, x="total_bill", bins=20, kde=True)
plt.title("Distribution of Total Bill")
plt.show()

# ECDF
sns.ecdfplot(tips, x="tip")
plt.title("ECDF of Tip")
plt.show()

# Count
sns.countplot(data=tips, x="day")
plt.title("Count by Day")
plt.show()

When to use: sanity checks, skewness, choosing transforms, spotting outliers.

3) Categorical ↔ Numerical

Compare distributions across groups:

boxplot — median, IQR, whiskers, outliers
violinplot — full distribution via KDE
boxenplot — for large samples
stripplot / swarmplot — raw points
barplot / pointplot — aggregated means/CI

# Box vs Violin
fig, ax = plt.subplots(1,2, figsize=(10,4))
sns.boxplot(data=tips, x="day", y="total_bill", ax=ax[0])
sns.violinplot(data=tips, x="day", y="tip", ax=ax[1])
ax[0].set_title("Total Bill by Day")
ax[1].set_title("Tip by Day")
plt.tight_layout(); plt.show()

# Strip plot
sns.stripplot(data=tips, x="smoker", y="tip", jitter=True)
plt.title("Raw Tips by Smoker")
plt.show()

# Mean with CI
sns.barplot(data=tips, x="sex", y="tip", estimator=pd.Series.mean, ci=95)
plt.title("Avg Tip by Sex")
plt.show()

Combine violinplot + stripplot for distributions + raw data.

4) Numeric ↔ Numeric Relationships

Start with scatterplots, optionally add regression.

# Basic scatter
sns.scatterplot(data=tips, x="total_bill", y="tip")
plt.title("Total Bill vs Tip")
plt.show()

# Add hue/style/size
sns.scatterplot(data=tips, x="total_bill", y="tip", hue="sex", style="smoker", size="size")
plt.title("Bill vs Tip by Sex/Smoker/Size")
plt.show()

# Trend line
sns.regplot(data=tips, x="total_bill", y="tip", scatter_kws={"alpha":0.6})
plt.title("Trend: Tip ~ Total Bill")
plt.show()

5) Fast Pairwise Scans

sns.pairplot(tips, hue="sex", diag_kind="hist")
plt.suptitle("Pairwise Relationships (tips)", y=1.02)
plt.show()

✅ Checkpoint (Day 1 done): You can read distributions, compare groups, and see pairwise trends. Write 3 insights from the dataset.

📅 Day 2 — Multivariate, Facets, Correlations & Pro Styling

Goal: Add faceting, correlations, palettes, and create presentation-ready visuals.

6) Faceting & Small Multiples

Split data into subplots by category.

# Facet by smoker
sns.catplot(data=tips, x="day", y="tip", hue="sex", col="smoker", kind="bar")
plt.suptitle("Tips by Day (faceted by Smoker)", y=1.02)
plt.show()

# Scatter with facets
sns.relplot(data=tips, x="total_bill", y="tip", hue="sex", col="time", kind="scatter")
plt.show()

Facets make comparisons obvious without clutter.

7) Correlations & Heatmaps

corr = tips[["total_bill","tip","size"]].corr()
sns.heatmap(corr, annot=True, fmt=".2f", cmap="coolwarm", square=True)
plt.title("Correlation (tips)")
plt.show()

# Clustered heatmap
sns.clustermap(corr, annot=True, fmt=".2f", cmap="coolwarm")
plt.show()

Read values: ±1 → strong linear relation, 0 → weak/none.

8) Time/Ordered Trends

avg = tips.groupby("size", as_index=False)["tip"].mean()
sns.lineplot(data=avg, x="size", y="tip")
plt.title("Average Tip by Party Size")
plt.show()

9) Styling, Palettes & Layout

sns.set_theme(style="whitegrid", context="talk", palette="deep")

ax = sns.scatterplot(data=tips, x="total_bill", y="tip", hue="sex")
ax.set_title("Tips vs Total Bill")
ax.set_xlabel("Total Bill ($)")
ax.set_ylabel("Tip ($)")
sns.despine()
plt.tight_layout(); plt.show()

10) Legends, Annotations & Saving

ax = sns.regplot(data=tips, x="total_bill", y="tip")
ax.annotate("Higher tips with higher bills",
            xy=(40,7), xytext=(25,8.5),
            arrowprops=dict(arrowstyle="->", color="white"))
ax.legend_.remove() if ax.legend_ else None
plt.tight_layout()
plt.savefig("tips_scatter.png", dpi=300, bbox_inches="tight", transparent=True)
plt.show()

11) Cheat-Sheet: Axes vs Figure Level

Axes-level: scatterplot, lineplot, histplot, kdeplot, boxplot, violinplot, heatmap, regplot…
Use when you manage subplots manually.
Figure-level: relplot, catplot, jointplot, pairplot, lmplot…
Use for quick grids/facets and auto layouts.

12) Common Pitfalls

Overplotting → use alpha, hexbin, or kdeplot
Don’t rely on defaults → always set titles/labels
For groups → prefer violin/box + strip over bar means
Keep consistent color semantics

✅ Checkpoint (Day 2 done): You can facet, compare multivariate trends, style for clarity, and export.

Mini-Project (Deliverable)

Question: What factors drive higher tips?

Steps:

Univariate: distribution of total_bill, tip
Groups: tip by day, sex, smoker, time
Relationship: total_bill ↔ tip (add hue & regression)
Correlation heatmap for numeric vars
Facet by smoker/time
Report: 5 insights + 2 charts for LinkedIn/portfolio

import numpy as np
tips = sns.load_dataset("tips").assign(tip_pct=lambda d: d["tip"] / d["total_bill"] * 100)

# 1) Distribution
sns.histplot(tips, x="tip_pct", bins=20, kde=True)
plt.title("Tip % Distribution"); plt.show()

# 2) Groups
sns.boxplot(tips, x="day", y="tip_pct", hue="smoker")
plt.title("Tip % by Day & Smoker"); plt.show()

# 3) Relationship with hue
sns.scatterplot(tips, x="total_bill", y="tip_pct", hue="time", style="sex")
plt.title("Tip % vs Total Bill by Time/Sex"); plt.show()

# 4) Correlation
num = tips[["total_bill","tip","size","tip_pct"]]
sns.heatmap(num.corr(), annot=True, fmt=".2f", cmap="coolwarm")
plt.title("Correlation (with Tip %)"); plt.show()

Practice Checklist

Plot hist+KDE for total_bill; describe skewness
Compare tip across day using box+strip
Scatter total_bill vs tip with hue=sex, style=smoker
Create pairplot with hue=time
Build correlation heatmap; write 2 interpretations
Facet bar chart by smoker and time
Export one figure at 300 DPI with transparent background

Quick Reference

Most-used APIs:

scatterplot, lineplot, histplot, kdeplot, ecdfplot
boxplot, violinplot, stripplot, barplot, pointplot
pairplot, jointplot, relplot, catplot
heatmap, clustermap, regplot

Styling:

sns.set_theme(style, palette, context)
sns.despine(), plt.tight_layout()
Palettes: deep, muted, pastel, bright, dark, colorblind

Written for: Nivesh Bansal — Data Analytics Journey, Day 10.
You can copy any code block and practice directly.

Happy plotting!

Source Code: Click here
Written By: Nivesh Bansal Linkedin GitHub Instagram

Advanced Seaborn: Facets, Correlations & Pro Styling

Nivesh Bansal — Sun, 07 Sep 2025 16:05:08 +0000

Day 2 — Advanced Seaborn
Seaborn is one of the most popular Python libraries for data visualization.

If you already know the basics (scatter plots, bar plots, etc.), this guide will help you level up.

We’ll cover:

Faceting & small multiples
Correlations & heatmaps
Ordered/time trends
Styling & palettes
Legends, annotations, and saving plots
Common pitfalls and pro tips

Let’s get started 👇

Faceting & Small Multiples

Faceting means splitting your data into subplots by category.

This makes comparisons easier without cluttering a single plot.

Common Methods

Method	Description
`FacetGrid`	Low-level, flexible faceting
`catplot` / `relplot`	High-level figure-level plots with built-in facets

Example 1: Bar plot faceted by smoker

import seaborn as sns
import matplotlib.pyplot as plt

tips = sns.load_dataset("tips")

sns.catplot(
    data=tips, x="day", y="tip", hue="sex", col="smoker", kind="bar"
)
plt.suptitle("Tips by Day (Faceted by Smoker)", y=1.02)
plt.show()

Example 2: Scatter plot with facets

sns.relplot(
    data=tips, x="total_bill", y="tip", hue="sex", col="time", kind="scatter"
)
plt.show()

Correlations & Heatmaps

Heatmaps summarize numeric relationships visually.
They’re perfect for spotting patterns and strengths of correlation.
Repo link — GitHub

Example 1: Simple correlation heatmap

corr = tips[["total_bill", "tip", "size"]].corr()

sns.heatmap(corr, annot=True, fmt=".2f", cmap="coolwarm", square=True)
plt.title("Correlation (tips)")
plt.show()

Example 2: Clustered heatmap (groups similar variables)

sns.clustermap(corr, annot=True, fmt=".2f", cmap="coolwarm")
plt.show()

👉** Quick Tip:**

Values near +1 or -1 = strong relationship
Values near 0 = weak or no relationship

Time/Ordered Trends

For ordered variables (like time, size, or sequence), line plots are ideal.

Example: Average tip by table size

avg = tips.groupby("size", as_index=False)["tip"].mean()

sns.lineplot(data=avg, x="size", y="tip")
plt.title("Average Tip by Party Size")
plt.show()

Styling, Palettes & Layout

Good styling = professional plots.

Use sns.set_theme() to apply global settings.

Options

Parameter	Examples
`style`	`"white"`, `"whitegrid"`, `"dark"`, `"darkgrid"`, `"ticks"`
`palette`	`"deep"`, `"muted"`, `"bright"`, `color_palette()`
`context`	`"notebook"`, `"talk"`, `"paper"`, `"poster"`

Example: Styled scatter plot

sns.set_theme(style="whitegrid", context="talk", palette="deep")

ax = sns.scatterplot(data=tips, x="total_bill", y="tip", hue="sex")
ax.set_title("Tips vs Total Bill")
ax.set_xlabel("Total Bill ($)")
ax.set_ylabel("Tip ($)")

sns.despine()
plt.tight_layout()
plt.show()

Legends, Annotations & Saving

Always label plots clearly and save in high resolution for reports.

Example: Annotated regression plot

ax = sns.regplot(data=tips, x="total_bill", y="tip")
ax.annotate("Higher tips with higher bills",
            xy=(40,7), xytext=(25,8.5),
            arrowprops=dict(arrowstyle="->", color="white"))

# Remove legend if not needed
ax.legend_.remove() if ax.legend_ else None  

plt.tight_layout()
plt.savefig("tips_scatter.png", dpi=300, bbox_inches="tight", transparent=True)
plt.show()

Figure- vs Axes-level Functions

Type	Examples	When to Use
Axes-level	`scatterplot`, `lineplot`, `histplot`, `boxplot`, `violinplot`, `heatmap`, `regplot`	Manage subplots manually
Figure-level	`relplot`, `catplot`, `jointplot`, `pairplot`, `lmplot`	Automatic grids/facets

👉 Rule of thumb:

Axes-level = more control, manual layouts
Figure-level = quick grids, less code

Common Pitfalls (and Fixes)

Problem	Solution
Too many overlapping points	Use `alpha=0.5`, `hexbin`, or `kdeplot`
Default labels are unclear	Always set titles, labels, legends
Comparing groups poorly	Use `violinplot`/`boxplot` + `stripplot` instead of bar means
Colors inconsistent	Stick to one palette across related charts

Repo link — GitHub

Complete Seaborn Tutorial (Day 01 & Day 02) — Master Data Visualization with Python, Data Analytics, AI & Machine Learning

Nivesh Bansal — Sat, 06 Sep 2025 17:07:43 +0000

Data visualization is one of the most powerful skills for Data Science, Machine Learning, AI, and Analytics.
I recently created a complete Seaborn tutorial with full source code covering almost all major plots in Python. Whether you are a student, developer, or data enthusiast, this guide will help you understand Seaborn from scratch with step-by-step examples.

👉 Full GitHub Repository (Day 01 & Day 02 Source Code):
🔗 Repo - All Source Code

Topics Covered in This Seaborn Tutorial

✅ Scatter Plots
✅ Line Plots
✅ Bar Plots
✅ Box Plots
✅ Violin Plots
✅ Distribution Plots
✅ Pair Plots
✅ Heatmaps
✅ Categorical Plots
✅ Advanced Styling & Themes

Why Learn Seaborn?

Seaborn is a Python data visualization library built on top of Matplotlib, making it simple to create beautiful, statistical, and publication-ready plots.
It is widely used in Data Analytics, Machine Learning, and AI projects for:

Exploring datasets 📊
Identifying hidden patterns 🔍
Improving model insights 🤖
Making reports more professional 📑

Who Should Read This Post?

This project is perfect for:

Data Science Students learning visualization
Machine Learning Beginners exploring datasets
Python Developers building projects
AI & Analytics Enthusiasts wanting better insights

Why This Repository Stands Out

Covers all basic to advanced plots in Seaborn
Organized into Day 01 & Day 02 lessons
Fully documented Python source code
Beginner-friendly but useful for professionals too

GitHub Repository

🔗 Repo - All Source Code
⭐ Don’t forget to star the repo and share your feedback!

Final Thoughts

Data visualization is not just about making graphs — it’s about telling a story with data.
With this Seaborn tutorial, you’ll gain the confidence to explore datasets visually and enhance your Data Science, AI, and Machine Learning journey.

Mastering Distribution & Category Plots in Data Visualization

Nivesh Bansal — Wed, 03 Sep 2025 16:03:59 +0000

Data visualization is one of the most powerful skills in data analysis, machine learning, and reporting. Among all visualization techniques, distribution plots and category plots are the two most essential families that every analyst, data scientist, or developer must master.

🔗 Full resource + code here: GitHub Repo

In this article, we’ll go step by step to understand:

What are Distribution Plots?
What are Category Plots?
Their types with comparison tables
Industry-level examples with Python & Seaborn code
Best practices and when to use which plot

By the end, you’ll know exactly which plot to use for your data storytelling.

What are Distribution Plots?

👉 Definition: Distribution plots are used to understand how data values are spread out. They help in analyzing the frequency, density, outliers, and shape of numeric variables.

👉 Use Case: Whenever you want to answer: “How are my values distributed?” (e.g., customer spending, test scores, sales revenue).

Top 5 Industry-Level Distribution Plots

Plot	Use Case	Example Code
Histogram	First step in EDA, shows frequency distribution of numeric values.	`sns.histplot(tips["total_bill"])`
KDE Plot	Smooth curve showing probability density (better for comparing).	`sns.kdeplot(tips["tip"])`
Box Plot	Detects outliers, median, quartiles. Standard in dashboards.	`sns.boxplot(x=tips["day"], y=tips["total_bill"])`
Violin Plot	Combination of Box + KDE. Shows full shape of distribution.	`sns.violinplot(x="day", y="tip", data=tips)`
Pair Plot	Scatterplot matrix for relationships between multiple numeric variables.	`sns.pairplot(tips, vars=["total_bill","tip","size"])`

Pro Tip: Start with a Histogram → then refine with KDE, Box, or Violin depending on what you need (frequency, density, or outliers).

What are Category Plots?

👉 Definition: Category plots are used when one variable is categorical (like gender, day, region) and another is numeric. They help in comparing groups or categories.

👉 Use Case: Whenever you want to answer: “How do categories compare on a metric?” (e.g., average sales by region, tips by day).

Top 5 Industry-Level Category Plots

Plot	Use Case	Example Code
Count Plot	Shows frequency of each category.	`sns.countplot(x="day", data=tips)`
Bar Plot	Shows mean/aggregate of numeric value per category.	`sns.barplot(x="day", y="tip", data=tips)`
Box Plot	Category-wise spread + outliers.	`sns.boxplot(x="day", y="total_bill", data=tips)`
Violin Plot	Category-wise distribution + density shape.	`sns.violinplot(x="day", y="tip", data=tips)`
Point Plot	Highlights category trends with confidence intervals.	`sns.pointplot(x="day", y="tip", data=tips)`

Pro Tip: Use Count/Bar for summary, Box/Violin for deeper distribution, and Point Plot for trends.

Distribution vs Category Plots (Comparison)

Feature	Distribution Plots	Category Plots
Data Type	Numeric-only	Categorical + Numeric
Purpose	Shape, spread, outliers of numeric data	Compare metrics across groups
Best First Step	Histogram	Count Plot
Industry Use	EDA, density analysis, outlier detection	Reporting, dashboards, comparisons

Code Previews (Seaborn + Tips Dataset)

Histogram Example

sns.histplot(tips["total_bill"])
plt.title("Histogram of Total Bill")
plt.show()

Count Plot Example

sns.countplot(x="day", data=tips)
plt.title("Count of Customers per Day")
plt.show()

Box Plot Example

sns.boxplot(x="day", y="total_bill", data=tips)
plt.title("Bill Distribution by Day")
plt.show()

Violin Plot Example

sns.violinplot(x="day", y="tip", data=tips)
plt.title("Tip Distribution by Day")
plt.show()

Pair Plot Example

sns.pairplot(tips, vars=["total_bill", "tip", "size"], hue="sex")
plt.suptitle("Pairwise Numeric Relationships")
plt.show()

Best Practices

Start simple: Use Histogram or Count Plot first.
For outlier detection, always check Box Plot.
For comparison of categories, prefer Bar/Point Plot.
For distribution shape, use KDE or Violin.
For multi-variable insights, use Pair Plot.

Final Thoughts

Distribution Plots = Shape & spread of numeric data.
Category Plots = Comparison across groups/categories.

Both are equally essential for industry-level data analysis, machine learning feature exploration, and dashboards. If you master these 10 plots, you’ll cover 80–90% of real-world visualization needs.

🔗 Full resource + code here: GitHub Repo

Save this article as your cheatsheet for distribution & category plots. Next time you do data analysis, you’ll know exactly which plot to choose!