Photo by Chris Ried on Unsplash

Topic A: Why Python for Data Science?

Theoretical Framework

Python has become the lingua franca of data science. But why? It's not just hype. Python offers a unique combination of readability (it reads like English), a massive ecosystem of libraries (Pandas, NumPy, Scikit-Learn), and a vibrant community.

Code Implementation

Part A: Readability

# Python: Simple and Readable
users = ["Alice", "Bob"]
for user in users:
    print(f"Hello, {user}")

Part B: The Power of Libraries

import math
print(math.pi)

Photo by Mika Baumeister on Unsplash

Topic B: Numeric & Boolean Types

Theoretical Framework

Python supports integers, floating-point numbers, and complex numbers. Booleans represent truth values. These are the fundamental building blocks of data.

Code Implementation

Part A: Numeric Types

x = 10        # int
y = 3.14      # float
z = 2 + 3j    # complex

print(f"Type of x: {type(x)}")
print(f"Type of z: {type(z)}")
print(f"Real part of z: {z.real}")

Part B: Booleans

is_active = True
is_admin = False
print(10 > 5)

Photo by Patrick Fore on Unsplash

Topic C: Text Sequence Type (Strings)

Theoretical Framework

Strings are immutable sequences of Unicode characters. Text processing is central to data analysis (e.g., cleaning names, parsing logs).

Code Implementation

Part A: Slicing & Indexing

text = "Data Science"
print(text[0])      # First char
print(text[-1])     # Last char
print(text[0:4])    # First 4 chars

Part B: String Methods

s = "  python  "
print(s.strip().upper())
print(s.replace("python", "pandas"))

Photo by Glenn Carstens-Peters on Unsplash

Topic D: Sequence Types (List & Tuple)

Theoretical Framework

Lists are mutable (changeable) sequences. Tuples are immutable (unchangeable). Use lists for data that changes, tuples for fixed data.

Code Implementation

Part A: Lists (Mutable)

nums = [1, 2, 3]
nums[0] = 100    # Change
nums.append(4)   # Add
print(nums)

Part B: Tuples (Immutable)

coords = (10, 20)
# coords[0] = 5  # This would cause an error!
print(coords[0])

Photo by Anastasiya Badun on Unsplash

Topic E: Set & Mapping Types

Theoretical Framework

Sets are unordered collections of unique items (no duplicates). Dictionaries (Mappings) store data in key-value pairs. Frozensets are immutable sets.

Code Implementation

Part A: Sets & Frozensets

# Set (Mutable)
unique_ids = {101, 102, 101}
print(unique_ids)  # Duplicates removed

# Frozenset (Immutable)
const_set = frozenset([1, 2, 3])
# const_set.add(4)  # Error!

Part B: Dictionaries (Mappings)

user = {"name": "Eve", "role": "Admin"}
print(user["name"])
user["role"] = "User"  # Update
print(user)

Photo by Markus Spiske on Unsplash

Topic F: Binary Types

Theoretical Framework

Computers think in 0s and 1s. Bytes and Bytearrays let you work with raw binary data (like images or network packets). Memoryview allows accessing memory without copying.

Code Implementation

Part A: Bytes & Bytearray

# Bytes (Immutable)
b_data = b"Hello"
print(b_data[0])  # ASCII for 'H' is 72

# Bytearray (Mutable)
ba = bytearray(b"Hello")
ba[0] = 87  # Change 'H' to 'W' (ASCII 87)
print(ba)

Photo by Brendan Church on Unsplash

Topic G: Control Flow (Logic & Loops)

Theoretical Framework

Code doesn't always run in a straight line. Control Flow allows your program to make decisions (if/else) and repeat tasks (loops).

Code Implementation

Part A: Making Decisions

score = 85
if score >= 90:
    print("A")
elif score >= 80:
    print("B")
else:
    print("C")

Part B: Loops

for i in range(3):
    print(f"Count {i}")

Photo by Aaron Burden on Unsplash

Topic H: Functions & Libraries

Theoretical Framework

Functions let you save code and reuse it later. Libraries are collections of functions written by others.

Code Implementation

Part A: Functions

def greet(name):
    return f"Hello, {name}!"

print(greet("Coder"))

Part B: Libraries

import math
print(math.sqrt(25))

Photo by Chris Ried on Unsplash

Topic I: Libraries in Python

Last Updated : 13 Nov, 2025

Theoretical Framework

In Python, a library is a group of modules that contain functions, classes and methods to perform common tasks like data manipulation, math operations, web scraping and more. Python libraries make coding faster, cleaner and more efficient by providing ready-to-use solutions for different domains such as data science, web development, machine learning and automation.

Working of Python Library

When you import a library in Python, it gives access to pre-written code stored in separate modules. In simple terms instead of writing the logic for a task, you import the library that already has it.

For example, on Windows, libraries are stored as .dll (Dynamic Link Libraries) and on Linux/macOS as .so files. When you run your code, Python automatically loads these modules and makes their functions available to use.

Types of Python Library

Python libraries are divided into two main types:

1. Built-in Python Standard Library

It is a collection of modules that come bundled with every Python installation, we don’t need to install anything separately. Most of these modules are written in C for better performance.

Examples of built-in modules:

• math: Mathematical operations
• os: Interact with the operating system
• datetime: Date and time operations
• random: Generate random numbers
• json: Handles JSON data encoding and decoding.

2. External Python Libraries

External (third-party) libraries are not included with Python by default. You can install them easily using the pip package manager. Popular External Python Libraries:

Using Libraries in Python Programs

To use any library, it first needs to be imported into your Python program using the import statement. Once imported, you can directly call the functions or methods defined inside that library. You can import libraries in three main ways:

• Import the entire library: import library_name for example, import math
• Import a specific function or class: from library_name import function_name for example, from math import sqrt
• Import a library with an alias: import library_name as alias for example, import pandas as pd

Example 1

This program imports the entire math library and uses one of its functions.

import math

A = 16

print(math.sqrt(A))

Example 2

This program imports only selected functions from an external library to simplify usage.

from numpy import array, mean

a = array([10, 20, 30, 40, 50])

print(mean(a))

Photo by Nikola Jovanovic on Unsplash

Topic 1: Data Ingestion from Diverse Formats

Theoretical Framework

Economic data is rarely clean. It comes in legacy formats (fixed-width text), spreadsheets (Excel), or modern web standards (JSON). The first step in analysis is parsing this byte-stream into a structured DataFrame. Without proper ingestion, analysis is impossible.

Code Implementation

Part A: Reading Indian Census Data (Text Files)

import pandas as pd
from io import StringIO
import json

# Simulating a pipe-separated (|) file
census_data = """State|Population_Millions|Literacy_Rate
Maharashtra|112.4|82.3
Uttar Pradesh|199.8|67.7
Kerala|33.4|94.0
Bihar|104.1|61.8"""

# Reading the string as if it were a file
df_census = pd.read_csv(StringIO(census_data), sep='|')
print("--- Text File Ingestion ---")
print(df_census)

Part B: Reading JSON Data (API Format)

# Simulating a JSON response from an API
json_str = '{"Country": {"0": "India", "1": "USA"}, "GDP_Trillion": {"0": 3.7, "1": 23.0}}'

# Ingesting JSON
data_dict = json.loads(json_str)
df_json = pd.DataFrame.from_dict(data_dict)

print("--- JSON API Ingestion ---")
print(df_json)

Part C: SQL Database Ingestion (SQLite)

import sqlite3

# Create a dummy database in memory
conn = sqlite3.connect(':memory:')
cursor = conn.cursor()
cursor.execute('CREATE TABLE sales (id INT, amount REAL)')
cursor.execute('INSERT INTO sales VALUES (1, 100.5), (2, 200.0)')
conn.commit()

# Read from SQL into DataFrame
query = "SELECT * FROM sales"
df_sql = pd.read_sql_query(query, conn)

print("--- SQL Ingestion ---")
print(df_sql)

Photo by Roman Mager on Unsplash

Topic 2: NumPy Arithmetic Operations

Theoretical Framework

Vectorization is the process of applying mathematical operations to an entire array at once, rather than looping through individual elements. This utilizes SIMD (Single Instruction, Multiple Data) processor features, making calculations millions of times faster for large datasets.

Code Implementation

Part A: Real vs Nominal GDP (Vectorization)

import numpy as np

# Nominal GDP for 3 States (in Lakh Crores)
nominal_gdp = np.array([20.5, 15.2, 8.9]) 

# GDP Deflator (Base 100)
deflator = np.array([120, 115, 110])

# Calculate Real GDP
real_gdp = (nominal_gdp / deflator) * 100

print(f"Nominal GDP: {nominal_gdp}")
print(f"Real GDP:    {np.round(real_gdp, 2)}")

Part B: Logic Masks (Filtering)

incomes = np.array([50000, 120000, 45000, 80000])

# Who earns more than 60k?
high_earners = incomes[incomes > 60000]

print(f"High Income Segments: {high_earners}")

Photo by Luke Chesser on Unsplash

Topic 3: Advanced Slicing

Theoretical Framework

Slicing allows us to view specific subsets of data without copying memory. This is done by manipulating Memory Strides. This is critical for time-series analysis (e.g., comparing Q1 vs Q4 performance). Efficient slicing prevents memory overload when working with massive economic datasets.

NIFTY 50 Market Analysis

import numpy as np

# Simulated NIFTY 50 prices (20 days)
prices = np.linspace(19000, 20000, 20)

print(f"First Week: {np.round(prices[:5], 0)}")
print(f"Last Week:  {np.round(prices[-5:], 0)}")
print(f"Net Growth: {np.round(prices[-1] - prices[0], 0)}")

Photo by Luke Chesser on Unsplash

Topic 3B: Statistical Analysis & Hypothesis Testing

Beyond slicing and dicing data, Data Science is about inference. Can we prove that a trend is real, or is it just random noise? This module introduces the rigorous framework of Statistical Testing.

Part 1: The Inference Framework (Theory)

Part 2: The Toolbelt (SciPy)

Python's scipy.stats library is the industry standard for these tests.

from scipy import stats

# T-Test (Group A vs Group B)
t_stat, p_val = stats.ttest_ind(group_a, group_b)

# ANOVA (Group A vs Group B vs Group C)
f_stat, p_val = stats.f_oneway(group_a, group_b, group_c)

Part 3: Capstone - The "Black Friday" Analysis

We have a dataset of 10,000 transactions from a retail store. We want to answer critical business questions using Statistics.

Hypothesis 1: Gender Gap

import pandas as pd
from scipy import stats
import numpy as np

# 1. Load Data (Simulated for this demo)
# In real life: df = pd.read_csv('black_friday.csv')
np.random.seed(42)
men_spend = np.random.normal(9500, 2500, 5000)  # Men mean: $9500
women_spend = np.random.normal(8800, 2200, 5000) # Women mean: $8800

# 2. Run T-Test
t_stat, p_val = stats.ttest_ind(men_spend, women_spend)

print(f"T-Statistic: {t_stat:.2f}")
print(f"P-Value: {p_val:.10f}")

if p_val < 0.05:
    print("RESULT: Reject Null Hypothesis. The spending difference is REAL.")
else:
    print("RESULT: Fail to reject Null Hypothesis.")

Hypothesis 2: Age demographics (ANOVA)

Do different age groups (18-25, 26-35, 36+) have different spending habits? Since we have >2 groups, we use ANOVA.

# Simulated Data for 3 Age Groups
age_18_25 = np.random.normal(9000, 2000, 1000)
age_26_35 = np.random.normal(11000, 3000, 1000) # Big spenders?
age_36_plus = np.random.normal(10500, 2500, 1000)

# Run ANOVA (F-Test)
f_stat, p_val = stats.f_oneway(age_18_25, age_26_35, age_36_plus)

print(f"ANOVA P-Value: {p_val:.10f}")

Photo by Markus Spiske on Unsplash

Topic 4: Array Metadata & Memory

Theoretical Framework

Understanding metadata is vital for optimization. A 64-bit float takes twice as much RAM as a 32-bit float. Knowing the shape and dtype prevents dimension mismatch errors in linear algebra (e.g., you cannot multiply a 3x3 matrix by a 2x2 matrix).

Inspecting & Optimising Memory

import numpy as np

# A matrix of 3 Sectors across 4 Quarters (Standard Float64)
data = np.zeros((3, 4))

print(f"Initial Memory: {data.nbytes} bytes")

# Optimisation: Convert to Float32
data_optimized = data.astype('float32')
print(f"Optimised Memory: {data_optimized.nbytes} bytes")

Photo by Isaac Smith on Unsplash

Topic 5: DataFrames

Theoretical Framework

The DataFrame is the core of pandas. Before analysis, we must "audit" the data using summary statistics to check for sanity (e.g., ensuring no negative prices exist) and to understand the distribution (mean vs median).

Indian Startup Ecosystem Audit

import pandas as pd

data = [
    ['Flipkart', 'Bengaluru', 37.6],
    ['Paytm', 'Noida', 16.0],
    ['Ola', 'Bengaluru', 7.3],
    ['Zomato', 'Gurugram', 12.0],
    ['Swiggy', 'Bengaluru', 10.7]
]

df = pd.DataFrame(data, columns=['Name', 'City', 'Valuation_B'])

print("--- Statistical Summary ---")
print(df.describe())

print("\n--- Mega Unicorns (> $15B) ---")
print(df[df['Valuation_B'] > 15.0])

Photo by Red Charlie on Unsplash

Topic 6: Basic GroupBy

Theoretical Framework

The Split-Apply-Combine strategy is fundamental. 1. Split data into groups based on keys (e.g., 'Crop'). 2. Apply a function to each group (e.g., 'Mean'). 3. Combine results into a new table. This allows for rapid comparative analysis between categories.

Indian Agriculture Yield Analysis

import pandas as pd

agri_data = {
    'State': ['Punjab', 'Punjab', 'Haryana', 'Haryana'],
    'Crop': ['Wheat', 'Rice', 'Wheat', 'Rice'],
    'Yield_Kg_Ha': [5000, 4000, 4800, 3900]
}
df = pd.DataFrame(agri_data)

print("--- Average Yield by Crop ---")
print(df.groupby('Crop')['Yield_Kg_Ha'].mean())

Part B: Multi-Column Grouping

# Grouping by State and Crop
print(df.groupby(['State', 'Crop'])['Yield_Kg_Ha'].mean())

Photo by Isaac Smith on Unsplash

Topic 7: Multi-Aggregation

Theoretical Framework

Often we need different summaries for different variables. For Income, we want the Average. For Literacy Rate, we might want the Maximum to see the best performing zone. Pandas allows passing a dictionary of rules to achieve this in a single pass.

Regional Economic Profiling

import pandas as pd

data = {
    'District': ['Mumbai', 'Pune', 'Mumbai', 'Pune'],
    'Income': [85000, 70000, 88000, 72000],
    'Literacy': [90, 88, 91, 89]
}
df = pd.DataFrame(data)

# Complex Aggregation Rules
rules = {
    'Income': 'mean', 
    'Literacy': 'max'
}

print(df.groupby('District').agg(rules))

Photo by Austin Distel on Unsplash

Topic 7b: Merging DataFrames

Theoretical Framework

In economics, data often lives in separate tables (e.g., GDP data in one file, Population data in another). Merging (or Joining) is the process of combining these tables based on a common key (like 'Country' or 'Year'). This corresponds to SQL JOINS.

Joining GDP and Population Data

# Table 1: GDP
df_gdp = pd.DataFrame({
    'Country': ['India', 'USA', 'China'],
    'GDP': [3.5, 23.0, 18.0]
})

# Table 2: Population
df_pop = pd.DataFrame({
    'Country': ['India', 'USA', 'Japan'],
    'Pop': [1.4, 0.33, 0.12]
})

# Merge (Inner Join - China and Japan will be dropped as they don't match)
df_merged = pd.merge(df_gdp, df_pop, on='Country', how='inner')

print(df_merged)

Photo by M. B. M. on Unsplash

Topic 8: Data Integrity & Cleaning

Theoretical Framework

Real-world data has holes (NaNs) and errors (Outliers). Imputation fills holes with logic (mean/median/interpolation). Outlier Detection uses stats (like Z-Score or IQR) to flag suspicious values that could skew your average.

Part A: Handling Missing AQI Data (Interpolation)

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'Day': [1, 2, 3, 4],
    'AQI': [350, np.nan, np.nan, 320]
})

df['AQI_Clean'] = df['AQI'].interpolate()
print(df)

Part B: String Cleaning

df_messy = pd.DataFrame({'Country': [' India ', 'usa', 'UK']})

# Clean the strings
df_messy['Country'] = df_messy['Country'].str.strip().str.upper()

print(df_messy)

Part C: Handling Missing Values (Fill/Drop)

df_messy = pd.DataFrame({'A': [1, 2, None], 'B': [5, None, 7]})
# Fill missing values with 0
print("Filled:\n", df_messy.fillna(0))
# Drop rows with any missing values
print("Dropped:\n", df_messy.dropna())

Part D: Removing Duplicates

df_dup = pd.DataFrame({'ID': [1, 1, 2], 'Name': ['A', 'A', 'B']})
print("Unique:\n", df_dup.drop_duplicates())

Photo by Luke Chesser on Unsplash

Topic 9: WEO Case Study

Theoretical Framework

In Time Series analysis (like Vector Autoregression models), raw data is often "noisy" due to daily fluctuations. We use Rolling Windows to smooth out short-term noise and reveal long-term structural trends, which is essential for forecasting.

Part A: Rolling Averages (Smoothing)

import pandas as pd

df = pd.DataFrame({
    'Month': ['Jan', 'Feb', 'Mar', 'Apr', 'May'],
    'Inflation': [5.1, 5.3, 5.2, 6.8, 5.4]
})

# 3-Month Moving Average
df['Rolling_Avg'] = df['Inflation'].rolling(window=3).mean()

print(df)

Part B: Year-over-Year Growth

df_gdp = pd.DataFrame({'GDP': [100, 105, 110, 108]})
df_gdp['Growth_Rate'] = df_gdp['GDP'].pct_change() * 100
print(df_gdp)

Photo by CHUTTERSNAP on Unsplash

Topic 10: Trade Case Study

Theoretical Framework

International trade data is complex. We often use Pivot Tables to reorganize data from a "Long Format" (Transaction Logs) to a "Wide Format" (Matrix) for better readability. This helps in spotting trade deficits or surpluses visually.

Pivot Table Analysis

import pandas as pd

df = pd.DataFrame({
    'Exporter': ['India', 'India', 'China', 'China'],
    'Sector': ['Tech', 'Pharma', 'Tech', 'Pharma'],
    'Value': [200, 50, 500, 20]
})

# Create Matrix
matrix = df.pivot_table(index='Exporter', columns='Sector', values='Value', aggfunc='sum')

print("--- Trade Matrix ---")
print(matrix)

Photo by Nikola Jovanovic on Unsplash

Advanced Visualisation

While pandas handles the data, Matplotlib and Seaborn handle the aesthetics.

Part A: Seaborn Scatter Plot

import seaborn as sns
import matplotlib.pyplot as plt

# Dummy Data
data = pd.DataFrame({
    'GDP': [10, 20, 30, 40, 50],
    'Life_Exp': [60, 65, 70, 75, 80],
    'Region': ['A', 'A', 'B', 'B', 'C']
})

# Create Plot
sns.scatterplot(data=data, x='GDP', y='Life_Exp', hue='Region')
plt.title('GDP vs Life Expectancy')
plt.show()

Part B: Plotly Interactive Chart

import plotly.express as px

fig = px.bar(data, x='Region', y='GDP', color='Region', title='Regional GDP')
fig.show()

Part C: Matplotlib Basics

import matplotlib.pyplot as plt

years = [2020, 2021, 2022, 2023]
gdp = [2.5, 3.0, 3.2, 3.7]

plt.figure(figsize=(8, 4))
plt.plot(years, gdp, marker='o', linestyle='--', color='blue')
plt.title('India GDP Trend (Trillions USD)')
plt.grid(True)
plt.show()

Advanced Geospatial Analytics

From static shapefiles to interactive spinning globes. This unit covers the complete spectrum of spatial analysis in Python using GeoPandas, Leaflet, Basemap, and Bokeh.

pip install geopandas shapely fiona matplotlib bokeh basemap basemap-data-hires

import geopandas as gpd
import matplotlib.pyplot as plt

# 1. Load dataset (Updated for GeoPandas 1.0+)
url = "https://raw.githubusercontent.com/nvkelso/natural-earth-vector/master/geojson/ne_110m_admin_0_countries.geojson"
world = gpd.read_file(url)

# 2. Clean data
# Columns in new dataset are often uppercase (POP_EST, GDP_MD)
world.columns = world.columns.str.lower()

# Filter invalid data
world = world[(world.pop_est > 0) & (world.name != "Antarctica")]

# 3. Create metric (GDP per Capita)
world['gdp_per_cap'] = world.gdp_md / world.pop_est

# 4. Plot
fig, ax = plt.subplots(1, 1, figsize=(15, 6))
world.plot(column='gdp_per_cap', ax=ax, legend=True,
           cmap='OrRd', legend_kwds={'label': "GDP Per Capita"})
plt.title('Global Economic Disparity')
plt.show()

from shapely.geometry import Point

# Load India Map (from URL)
url = "https://gist.githubusercontent.com/jbrobst/56c13bbbf9d97d187fea01ca62ea5112/raw/e388c4cae20aa53cb5090210a42ebb9b765c0a36/india_states.geojson"
india = gpd.read_file(url)

# Define Mumbai
mumbai = Point(72.8777, 19.0760)

# The Magic: Find the containing state
state = india[india.contains(mumbai)]
print(f"Mumbai is in: {state['ST_NM'].values[0]}")
# Expected Output: Mumbai is in: Maharashtra

4. Workflow C: Real-Time Pipeline (Live Earthquakes)

Static maps are useful, but the real world moves. In this workflow, we connect directly to the USGS Live API to fetch earthquake data occurring right now. We don't download a file; we read the stream.

Detailed Syntax Breakdown

• gpd.read_file(url): GeoPandas is smart enough to read GeoJSON directly from a live web URL.
• markersize=...: We scale the size of the dots based on the earthquake's magnitude column. Dynamic styling!

The Python Code

import geopandas as gpd
import matplotlib.pyplot as plt

# 1. Fetch Live Data (USGS Feed: 2.5+ Mag, Past Day)
live_url = "https://earthquake.usgs.gov/earthquakes/feed/v1.0/summary/2.5_day.geojson"
quakes = gpd.read_file(live_url)

# 2. Load Background Map (Stable URL)
world_url = "https://raw.githubusercontent.com/nvkelso/natural-earth-vector/master/geojson/ne_110m_admin_0_countries.geojson"
world = gpd.read_file(world_url)

# 3. Plot
fig, ax = plt.subplots(figsize=(12, 8))
world.plot(ax=ax, color='lightgrey', edgecolor='white')

# Plot events (Size = Magnitude)
if not quakes.empty:
    quakes.plot(ax=ax,
                markersize=quakes['mag'] * 20,
                color='red',
                alpha=0.6,
                edgecolor='darkred')

plt.title(f"Live Feed: {len(quakes)} Earthquakes > M2.5 (Past 24h)")
plt.show()

Expected Output

Generating Live Map...

Red circles appear where quakes happened today.

🚀 Pipeline Challenge: The 'Big One' Filter

Modify the code to print the location (place column) of the single largest earthquake in the dataset. Hint: quakes.sort_values('mag', ascending=False).iloc[0].

🧠 Homework: ISS Tracker

Use the OPEN-NOTIFY API (http://api.open-notify.org/iss-now.json) to get the current latitude/longitude of the ISS. Turn it into a shapely.Point and plot it!

from bokeh.plotting import figure, show, output_file
from bokeh.models import GeoJSONDataSource

# 1. Convert Data
geo_source = GeoJSONDataSource(geojson=world.to_json())

# 2. Setup Plot
p = figure(title="Interactive World Map", width=800, height=500)

# 3. Add Polygons
p.patches('xs', 'ys', source=geo_source,
          fill_color='blue', line_color='white', fill_alpha=0.6)

# 4. Save & Show
output_file("world_map.html")
show(p)

# !pip install folium
import folium
import requests
import webbrowser
import os

# 1. Fetch Real-time Data (USGS)
url = "https://earthquake.usgs.gov/earthquakes/feed/v1.0/summary/4.5_week.geojson"
data = requests.get(url).json()

# 2. Create Map (Dark Mode)
m = folium.Map(location=[20, 0], zoom_start=2, tiles='CartoDB dark_matter')

# 3. Add Loop
for feature in data['features']:
    coords = feature['geometry']['coordinates'] # [lon, lat]
    mag = feature['properties']['mag']
    place = feature['properties']['place']
    
    # Note: Folium uses [Lat, Lon], GeoJSON is [Lon, Lat]
    folium.CircleMarker(
        location=[coords[1], coords[0]],
        radius=mag * 2,
        color='#ff5555',
        fill=True,
        popup=f"<b>{place}</b><br>Mag: {mag}"
    ).add_to(m)

# 4. Save & Auto-Open
filename = "crisis_dashboard.html"
m.save(filename)

# Print location and Open
print(f"Map saved to: {os.path.abspath(filename)}")
webbrowser.open('file://' + os.path.abspath(filename))

# !pip install basemap basemap-data-hires
from mpl_toolkits.basemap import Basemap
import matplotlib.pyplot as plt

plt.figure(figsize=(10, 10))

# 1. Define Projection (Orthographic = Globe)
m = Basemap(projection='ortho', lat_0=20, lon_0=78)

# 2. Draw Details
m.drawcoastlines()
m.drawcountries()
m.fillcontinents(color='coral', lake_color='aqua')
m.drawmapboundary(fill_color='aqua')

plt.title("Orthographic View centered on India")
plt.show()

Further Learning Resources

A curated list of courses and resources to continue your data science journey.

Frequently Asked Questions

Glossary

References (APA 7)

• Python Software Foundation. (n.d.). Python 3.12 documentation. Retrieved from https://docs.python.org/3/
• McKinney, W. (2017). Python for data analysis: Data wrangling with Pandas, NumPy, and IPython (2nd ed.). O'Reilly Media. [Link]
• VanderPlas, J. (2016). Python data science handbook: Essential tools for working with data. O'Reilly Media. [Link]
• Géron, A. (2019). Hands-on machine learning with Scikit-Learn, Keras, and TensorFlow (2nd ed.). O'Reilly Media. [Link]
• Grus, J. (2019). Data science from scratch: First principles with Python (2nd ed.). O'Reilly Media.
• Pedregosa, F., et al. (2011). Scikit-learn: Machine learning in Python. Journal of Machine Learning Research, 12, 2825-2830. [Link]
• Harris, C. R., et al. (2020). Array programming with NumPy. Nature, 585(7825), 357-362. [Link]
• Hunter, J. D. (2007). Matplotlib: A 2D graphics environment. Computing in Science & Engineering, 9(3), 90-95. [Link]
• Waskom, M. (2021). Seaborn: Statistical data visualization. Retrieved from https://seaborn.pydata.org/
• Real Python. (n.d.). Python tutorials. Retrieved from https://realpython.com/
• Kaggle. (n.d.). Kaggle: Your machine learning and data science community. Retrieved from https://www.kaggle.com/
• Stack Overflow. (n.d.). Stack Overflow. Retrieved from https://stackoverflow.com/
• Downey, A. B. (2015). Think Python: How to think like a computer scientist (2nd ed.). O'Reilly Media. [Link]
• Burkov, A. (2019). The hundred-page machine learning book. Andriy Burkov. [Link]
• Raschka, S., & Mirjalili, V. (2019). Python machine learning (3rd ed.). Packt Publishing.
• Anaconda. (n.d.). Anaconda distribution. Retrieved from https://www.anaconda.com/
• Project Jupyter. (n.d.). Jupyter. Retrieved from https://jupyter.org/
• The pandas development team. (2020). pandas-dev/pandas: Pandas. Zenodo. [Link]
• W3Schools. (n.d.). Python tutorial. Retrieved from https://www.w3schools.com/python/
• International Monetary Fund. (2023). World economic outlook database. Washington, D.C.: IMF. [Link]