# Python is DYNAMICALLY TYPED — no type declaration needed
name       = "Priya Nair"       # str
roll       = 2601              # int
cgpa       = 8.92              # float
is_placed  = True              # bool
dept       = None              # NoneType — not yet assigned

# Python infers the type at runtime
print(type(cgpa))     # <class 'float'>

# Multiple assignment on one line
x, y, z = 10, 20, 30

# Swap without a temp variable (very Pythonic!)
x, y = y, x           # x=20, y=10 — tuple packing/unpacking

# Type conversion (casting)
int("42")      # → 42        (string to int)
str(3.14)     # → "3.14"    (float to string)
float(7)      # → 7.0       (int to float)
bool(0)       # → False     (0, "", [], None are all Falsy)
bool("CDAC") # → True      (any non-empty string is Truthy)

marks = int(input("Enter marks (0-100): "))

if marks >= 90:
    print("O — Outstanding")
elif marks >= 75:
    print("A — Distinction")
elif marks >= 60:
    print("B — First Class")
elif marks >= 40:
    print("C — Pass")
else:
    print("F — Fail. Please reappear.")

# One-liner ternary — for simple True/False choices
result = "Pass" if marks >= 40 else "Fail"
print(f"Result: {result}")

# Q1: for loop — print 0! to 10!
f, n = 1, 0
for _ in range(11):
    print(f"{n}! = {f}")
    n += 1
    f *= n
# Output: 0!=1, 1!=1, 2!=2, ... 10!=3,628,800

# Q2: while loop — all factorials under 2 billion
f, n = 1, 0
while f < 2_000_000_000:      # underscore separators for readability
    print(f"{n}! = {f:,}")    # :, adds comma formatting to numbers
    n += 1
    f *= n

s = "C-DAC Kharghar Navi Mumbai"

# SLICING — [start:stop:step]  (stop is exclusive!)
print(s[0:5])        # 'C-DAC'
print(s[6:])         # 'Kharghar Navi Mumbai'
print(s[::-1])       # reverse the whole string
print(s[6:14:2])     # every 2nd char from 6 to 14

# IMPORTANT METHODS
print(s.upper())              # 'C-DAC KHARGHAR NAVI MUMBAI'
print(s.lower())              # 'c-dac kharghar navi mumbai'
print(s.replace('Navi','New'))# replace substring
print(s.split(' '))           # ['C-DAC', 'Kharghar', 'Navi', 'Mumbai']
print(', '.join(['a','b','c'])) # 'a, b, c'
print(s.strip())              # remove leading/trailing whitespace
print(s.count('a'))          # count occurrences of 'a'
print(s.find('Kharghar'))    # index position or -1 if not found
print(s.startswith('C-DAC'))# True
print(s.endswith('Mumbai'))  # True

# F-STRINGS — modern, fast, readable string formatting
batch, cgpa = 2026, 8.9247
print(f"PG-DBDA {batch} — C-DAC Kharghar")
print(f"CGPA: {cgpa:.2f}")        # 'CGPA: 8.92' (2 decimal places)
print(f"Rank: {1:04d}")           # 'Rank: 0001' (zero-padded)
print(f"Total: ₹{75000:,}")      # 'Total: ₹75,000'

import re

# Q3: Phrase palindrome checker
def is_palindrome(phrase):
    """Strip non-letters, lowercase, compare to reverse."""
    clean = re.sub(r'[^a-zA-Z]', '', phrase).lower()
    return clean == clean[::-1]

tests = ["Was it a rat I saw?", "Step on no pets", "Dammit, I'm mad!", "Hello CDAC"]
for t in tests:
    print(f"{'✓' if is_palindrome(t) else '✗'}  {t!r}")

# Q4: Pangram checker (contains all 26 English letters)
def is_pangram(sentence):
    letters = set(sentence.lower())
    return set('abcdefghijklmnopqrstuvwxyz').issubset(letters)

print(is_pangram("The quick brown fox jumps over the lazy dog"))  # True
print(is_pangram("Hello World"))                               # False

# CREATE
student = {
    "name": "Priya Nair",
    "roll": 2601,
    "marks": {"Python": 88, "R": 79},  # nested dict!
    "batch": "PGDBDA-Feb2026"
}

# ACCESS — two ways
print(student["name"])              # KeyError if key missing
print(student.get("dept", "N/A"))  # safe — returns default

# MODIFY & ADD
student["marks"]["Java"] = 83     # add to nested dict
student["graduated"] = False       # add new top-level key

# DELETE
del student["roll"]
popped = student.pop("batch")    # remove and return value

# ITERATION
for key, val in student.items():
    print(f"  {key}: {val}")

# DICT COMPREHENSION — like list comp but for dicts
squares = {x: x**2 for x in range(1, 6)}  # {1:1, 2:4, 3:9, 4:16, 5:25}

# ── ROT-13 CIPHER LAB Q1 ──────────────────────────────────────
def rot13(text):
    upper = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    lower = upper.lower()
    table = str.maketrans(
        upper + lower,
        upper[13:] + upper[:13] + lower[13:] + lower[:13]
    )
    return text.translate(table)

secret = "Pnrfne pvcure? V zhpu cersre Pnrfne fnynq!"
print(rot13(secret))   # Caesar cipher? I much prefer Caesar salad!
print(rot13(rot13(secret)) == secret)  # True — self-inverse!

scores = [88, 72, 95, 61, 84, 91]

--- ADDING ---
scores.append(78)            # add to end
scores.insert(0, 100)         # insert at index 0
scores.extend([55, 67])      # merge another list
scores += [82]               # shorthand extend

--- REMOVING ---
scores.remove(61)            # remove first occurrence of value 61
scores.pop()                 # remove & return last element
scores.pop(2)                # remove & return element at index 2
del scores[0:2]              # delete a slice
scores.clear()               # empty the entire list

--- SEARCHING & STATS ---
print(max(scores), min(scores), sum(scores))
print(scores.index(95))      # position of 95
print(scores.count(88))      # how many times 88 appears
print(95 in scores)          # True — membership test

--- SORTING ---
scores.sort()                # ascending, modifies IN-PLACE
scores.sort(reverse=True)   # descending, in-place
ranked = sorted(scores)     # returns NEW sorted list, original unchanged

--- LIST COMPREHENSION (Pythonic & fast!) ---
passed   = [s for s in scores if s >= 40]
doubled  = [s * 2 for s in scores]
grades   = ['P' if s>=40 else 'F' for s in scores]

--- CRITICAL: Copy vs Reference ---
a = [1, 2, 3]
b = a           # SAME list! b IS a — dangerous!
c = a.copy()   # true independent copy
d = a[:]        # slice copy — also independent
e = list(a)    # another way to copy
# Test: b.append(99) → a also has 99. c.append(99) → a unchanged.

# 1. Named function with default argument
def greet(name, batch="PGDBDA-2026"):
    return f"Welcome {name} to C-DAC Kharghar — {batch}!"

greet("Priya")                # uses default batch
greet("Raj", "AI-ML-2026")   # overrides default

# 2. *args — variable positional arguments (packed as tuple)
def total_marks(*subjects):
    print(f"Got {len(subjects)} subjects")
    return sum(subjects)

total_marks(88, 79, 91, 83)    # 341

# 3. **kwargs — variable keyword arguments (packed as dict)
def student_info(**details):
    for k, v in details.items():
        print(f"  {k}: {v}")

student_info(name="Zara", roll=2610, cgpa=9.1)

# 4. Lambda — anonymous, one-liner, no return keyword
square    = lambda x: x**2
is_even   = lambda n: n % 2 == 0

# Lambda with sorted() — sort students by marks (highest first)
students = [("Priya",88), ("Raj",74), ("Zara",95), ("Dev",81)]
ranked = sorted(students, key=lambda s: s[1], reverse=True)
# [('Zara', 95), ('Priya', 88), ('Dev', 81), ('Raj', 74)]

# 5. Recursive function (Lab Q2 — factorial)
def factorial(n):
    if n == 0: return 1          # BASE CASE — must exist!
    return n * factorial(n - 1)  # recursive case

for i in range(1, 11):
    print(f"{i:2d}  {factorial(i):>10,}")

import pickle

model_data = {
    "batch": "PGDBDA-2026",
    "students": ["Priya", "Raj", "Zara"],
    "accuracy": 0.94
}

# Serialize (pack) to disk — wb = write binary
with open("batch.pkl", "wb") as f:
    pickle.dump(model_data, f)

# Deserialize (unpack) — rb = read binary
with open("batch.pkl", "rb") as f:
    loaded = pickle.load(f)

print(loaded["students"])   # ['Priya', 'Raj', 'Zara']
# Used heavily in ML to save/load trained scikit-learn models!

# Create
coords  = (18.9220, 72.8347)   # lat/lon near C-DAC Kharghar area
rgb     = (255, 140, 0)          # dark orange
single  = (42,)                  # MUST have trailing comma for single-element!
t       = (10, 20, 30, 20, 10)

# Lab Q1: Find repeated items
repeated = [x for x in set(t) if t.count(x) > 1]
print(repeated)     # [10, 20]

# Lab Q2: Sort list of tuples by float element
items = [('item1', '12.20'), ('item2', '15.10'), ('item3', '24.5')]
items_sorted = sorted(items, key=lambda x: float(x[1]), reverse=True)
# [('item3','24.5'), ('item2','15.10'), ('item1','12.20')]

# Lab Q3: Count elements until a tuple is found
mixed = [10, 20, 30, (40, 50), 60]
count = next(i for i, x in enumerate(mixed) if isinstance(x, tuple))
print(count)        # 3

# Lab Q4: Element-wise sum using zip()
t1, t2, t3 = (1,2,3,4), (3,5,2,1), (2,2,3,1)
result = tuple(a+b+c for a,b,c in zip(t1, t2, t3))
print(result)       # (6, 9, 8, 6)

# Tuple unpacking — very Pythonic
lat, lon = coords
x, y, *rest = (1, 2, 3, 4, 5)   # rest = [3,4,5]

class Student:
    course = "PG-DBDA"               # class variable — shared by ALL objects

    def __init__(self, roll, name, marks_dict):
        # Instance variables — unique to EACH object
        self.roll  = roll
        self.name  = name
        self.marks = marks_dict        # {subject: [list of 5 marks]}

    def __str__(self):               # called by print(student)
        return f"[{self.roll}] {self.name} — {self.course}"

    def calculate_gpa(self, m1, m2, m3):
        # GPA formula from syllabus
        return (1/3)*m1 + (1/2)*m2 + (1/4)*m3

    def has_failed(self):
        # any() short-circuits — stops at first True found
        return any(
            m < 40
            for mlist in self.marks.values()
            for m in mlist
        )

# Inheritance — Faculty extends Person
class Person:
    def __init__(self, name): self.name = name
    def speak(self): return "..."

class Faculty(Person):                # inherits Person
    def speak(self):                  # method OVERRIDING
        return f"Prof. {self.name}"

# Polymorphism — same method call, different behaviour
people = [Faculty("Dr. Mehta"), Person("Visitor")]
for p in people: print(p.speak())

# Generator — memory-efficient sequence
class NumberSeries:
    def even_numbers(self, limit):
        n = 0
        while n <= limit:
            yield n      # pauses here; next() call resumes
            n += 2

ns = NumberSeries()
for num in ns.even_numbers(20):
    print(num, end=" ")   # 0 2 4 6 8 10 12 14 16 18 20

# Decorator — wraps a function to add behaviour WITHOUT changing it
# Analogy: a SmartWatch wraps your wrist — your wrist is unchanged
import functools, time

def log_method_call(func):
    @functools.wraps(func)           # preserves original function name
    def wrapper(*args, **kwargs):
        print(f"→ Calling {func.__name__}({args[1:]})")
        start = time.time()
        result = func(*args, **kwargs)
        print(f"← Done in {time.time()-start:.4f}s")
        return result
    return wrapper

class Student:
    @log_method_call                   # apply decorator with @
    def calculate_gpa(self, m1, m2, m3):
        return (1/3)*m1+(1/2)*m2+(1/4)*m3

s = Student()
s.calculate_gpa(80, 75, 90)
# → Calling calculate_gpa((80, 75, 90))
# ← Done in 0.0001s

try:
    marks = int(input("Enter marks: "))   # ValueError if "abc"
    avg   = 500 / marks                    # ZeroDivisionError if 0
    print(f"Average: {avg:.1f}")

except ValueError:
    print("Please enter a valid integer.")

except ZeroDivisionError:
    print("Marks cannot be zero.")

except Exception as e:
    print(f"Unexpected: {type(e).__name__}: {e}")

else:
    print("Calculation successful.")   # runs ONLY if no exception

finally:
    print("Done.")                       # ALWAYS runs (cleanup)

# CUSTOM EXCEPTION — for domain-specific validation
class InvalidMarksError(Exception):
    def __init__(self, val):
        super().__init__(f"Marks {val} out of range (0–100)")

def validate_marks(m):
    if not 0 <= m <= 100:
        raise InvalidMarksError(m)    # explicitly raise
    return m

# LOGGING — structured, persistent, production-grade
import logging
logging.basicConfig(
    level   = logging.DEBUG,
    format  = '%(asctime)s [%(levelname)s] %(message)s',
    handlers = [
        logging.FileHandler('cdac_app.log'),
        logging.StreamHandler()          # also print to console
    ]
)
logging.info("FRAS v2.0 started — C-DAC Kharghar")
logging.warning("DB connection latency > 500ms")
logging.error("Face recognition model load failed")
logging.critical("Disk full — attendance records at risk!")

import numpy as np
import pandas as pd

═══ NumPy Essentials ═══════════════════════════════════════
marks = np.array([88, 92, 76, 95, 61, 84])

# Vectorised — all elements at once
print(marks + 5)                   # add 5 to every element
print(marks[marks > 85])           # [88, 92, 95] — boolean indexing
print(marks.mean(), marks.std())   # statistics
print(np.percentile(marks, [25,50,75]))

# Image array (Lab Q2)
from PIL import Image
img = Image.open('photo.jpg')
arr = np.array(img)               # (H, W, 3) array
restored = Image.fromarray(arr)

═══ Pandas — Diamonds Dataset (Lab Q4) ═════════════════════
df = pd.read_csv('diamonds.csv')

# Print first 6 rows
print(df.head(6))

# Mean of each numeric column
print(df.mean(numeric_only=True))

# Count / min / max price for each cut
print(df.groupby('cut')['price'].agg(['count','min','max']))

# Concise summary
df.info()            # dtypes, non-null counts
df.describe()        # mean, std, quartiles

# Count duplicate rows
print(df.duplicated().sum())

# Data cleaning
df.dropna(inplace=True)         # drop rows with NaN
df.drop_duplicates(inplace=True)

# Add computed column
df['price_per_carat'] = df['price'] / df['carat']

# Filter
premium = df[(df['cut']=='Ideal') & (df['price']>5000)]

import matplotlib.pyplot as plt
import numpy as np

═══ 1. Line Chart ═══════════════════════════════════════════
months = ['Jan','Feb','Mar','Apr','May','Jun']
sales  = [120, 145, 132, 178, 190, 210]

fig, ax = plt.subplots(figsize=(9, 4))
ax.plot(months, sales, marker='o', color='#b34a22',
        linewidth=2, label='Monthly Sales')
ax.fill_between(months, sales, alpha=0.1, color='#b34a22')
ax.set_title('C-DAC Sales Dashboard')
ax.set_xlabel('Month'); ax.set_ylabel('Units Sold')
ax.legend(); ax.grid(True, alpha=0.3)
plt.tight_layout(); plt.show()

═══ 2. Bar Chart ════════════════════════════════════════════
subjects = ['Python', 'R', 'Stats', 'Java', 'Linux']
avg_marks = [82, 76, 88, 71, 85]
colors   = ['#b34a22' if m>=80 else '#d4c8b0' for m in avg_marks]

fig, ax = plt.subplots(figsize=(8, 4))
bars = ax.bar(subjects, avg_marks, color=colors, edgecolor='white')
ax.bar_label(bars, fmt='%d')                # add value labels on bars
ax.axhline(80, color='#1a6e5c', linestyle='--', label='Pass Line')
ax.set_title('PG-DBDA Batch Average Marks')
ax.set_ylim(0, 100); ax.legend()
plt.tight_layout(); plt.show()

═══ 3. Histogram ════════════════════════════════════════════
marks_data = np.random.normal(72, 12, 200)  # simulate marks distribution
fig, ax = plt.subplots(figsize=(8, 4))
ax.hist(marks_data, bins=20, color='#1a6e5c', edgecolor='white', alpha=0.8)
ax.axvline(marks_data.mean(), color='#b34a22', linestyle='--', label=f'Mean={marks_data.mean():.1f}')
ax.set_title('Marks Distribution'); ax.legend()
plt.tight_layout(); plt.show()

═══ 4. Subplot Grid — show multiple charts at once ══════════
fig, axes = plt.subplots(1, 3, figsize=(14, 4))

axes[0].plot([1,2,3], [4,5,6]); axes[0].set_title('Line')
axes[1].bar(['A','B','C'], [3,7,5]); axes[1].set_title('Bar')
axes[2].scatter([1,2,3], [3,1,4]); axes[2].set_title('Scatter')

plt.suptitle('Multi-panel Dashboard')
plt.tight_layout(); plt.show()

═══ 5. Save figure to file ══════════════════════════════════
fig.savefig('report_chart.png', dpi=150, bbox_inches='tight')
fig.savefig('report_chart.pdf')          # vector format for reports

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

═══ Seaborn Themes — set once, applies everywhere ═══════════
sns.set_theme(style='whitegrid', palette='muted')
# Other styles: darkgrid, white, ticks, dark

═══ 1. Heatmap — Lab Q2 Step 1 & 2 ════════════════════════
df = pd.read_csv('data.csv')
corr = df.corr(numeric_only=True)

plt.figure(figsize=(10, 8))
sns.heatmap(
    corr,
    annot     = True,         # show values in cells
    fmt       = '.2f',         # 2 decimal places
    cmap      = 'RdYlGn',      # Red-Yellow-Green diverging
    center    = 0,             # 0 = white centre
    linewidths= 0.5,           # cell borders
    square    = True,          # force square cells
    vmin=-1, vmax=1            # fix scale -1 to +1
)
plt.title('Correlation Matrix — PG-DBDA Dataset', pad=14)
plt.tight_layout(); plt.show()

═══ 2. Find highest correlated pair (Lab Q2 Step 3) ════════
mask = np.triu(np.ones_like(corr, dtype=bool))   # upper triangle
col1, col2 = corr.mask(mask).stack().idxmax()
print(f"Highest correlation: {col1} ↔ {col2}")

═══ 3. Scatter plot (Lab Q2 Step 4) ════════════════════════
fig, ax = plt.subplots(figsize=(8, 6))
sns.scatterplot(data=df, x=col1, y=col2,
                alpha=0.6, color='#b34a22', ax=ax)
sns.regplot(data=df, x=col1, y=col2, scatter=False,
            color='#1a6e5c', ax=ax, label='Trend line')
ax.set_title(f'{col1} vs {col2} (r={corr.loc[col1,col2]:.2f})')
ax.legend()
plt.tight_layout(); plt.show()

═══ 4. Box Plot — compare distributions by category ════════
tips = sns.load_dataset('tips')           # built-in sample dataset
plt.figure(figsize=(9, 5))
sns.boxplot(data=tips, x='day', y='total_bill', hue='sex')
plt.title('Bill Distribution by Day and Gender')
plt.show()

═══ 5. Violin Plot — like boxplot but shows distribution shape
plt.figure(figsize=(9, 5))
sns.violinplot(data=tips, x='day', y='total_bill',
               hue='sex', split=True, palette='muted')
plt.title('Bill Distribution — Violin (shows density shape)')
plt.show()

═══ 6. Pair Plot — all columns vs all columns at once ══════
iris = sns.load_dataset('iris')
sns.pairplot(iris, hue='species', diag_kind='kde')
plt.suptitle('Iris Dataset — Pairwise Relationships', y=1.02)
plt.show()

═══ 7. Count Plot — categorical frequency bar ═══════════════
sns.countplot(data=tips, x='day', order=['Thur','Fri','Sat','Sun'])
plt.title('Number of Customers per Day')
plt.show()

import plotly.express as px
import plotly.graph_objects as go
import pandas as pd

═══ 1. Interactive Scatter with trendline (Lab Q2) ══════════
df = pd.read_csv('data.csv')
fig = px.scatter(
    df, x=col1, y=col2,
    trendline    = "ols",          # OLS regression line
    color        = 'category',     # colour by category column
    hover_data   = ['id'],          # show extra info on hover
    title        = f"{col1} vs {col2} (Interactive)"
)
fig.update_layout(template='plotly_white')
fig.show()                          # opens in browser
fig.write_html("scatter.html")      # save as shareable HTML

═══ 2. Interactive Bar Chart ════════════════════════════════
fig = px.bar(
    df.groupby('cut')['price'].mean().reset_index(),
    x='cut', y='price',
    color='cut', text_auto='.0f',
    title='Average Diamond Price by Cut'
)
fig.show()

═══ 3. Sunburst — hierarchical breakdown ════════════════════
fig = px.sunburst(
    px.data.tips(),
    path=['day', 'time', 'sex'],
    values='total_bill',
    title='Bill Breakdown (Day → Time → Gender)'
)
fig.show()

═══ 4. 3D Scatter ═══════════════════════════════════════════
fig = px.scatter_3d(
    px.data.iris(),
    x='sepal_length', y='sepal_width', z='petal_length',
    color='species', symbol='species',
    title='Iris Dataset — 3D View'
)
fig.show()

═══ 5. Animated Chart — add time dimension ══════════════════
fig = px.scatter(
    px.data.gapminder(),
    x='gdpPercap', y='lifeExp',
    size='pop', color='continent',
    hover_name='country', animation_frame='year',
    log_x=True, title='Gapminder — GDP vs Life Expectancy'
)
fig.show()

# pip install plotnine
from plotnine import *
import pandas as pd
import seaborn as sns

diamonds = sns.load_dataset('diamonds')

═══ Basic scatter ════════════════════════════════════════════
p = (ggplot(diamonds, aes(x='carat', y='price', color='cut'))
     + geom_point(alpha=0.3, size=0.5)
     + labs(title='Diamond Price vs Carat',
            x='Carat Weight', y='Price (USD)')
     + theme_minimal()
)
print(p)

═══ Faceted chart — one panel per cut category ═══════════════
p2 = (ggplot(diamonds.sample(2000), aes(x='carat', y='price'))
      + geom_point(color='#b34a22', alpha=0.5, size=1)
      + geom_smooth(method='lm', color='#1a6e5c')
      + facet_wrap('~cut', ncol=3)            # one panel per cut
      + labs(title='Price vs Carat by Cut Quality')
      + theme_bw()
)
print(p2)

═══ Bar + coord_flip ════════════════════════════════════════
p3 = (ggplot(diamonds, aes(x='cut', fill='cut'))
      + geom_bar()
      + coord_flip()                           # horizontal bars
      + theme_classic()
      + labs(title='Diamond Cut Counts')
)
print(p3)

import pandas as pd
import matplotlib.pyplot as plt

df = pd.read_csv('diamonds.csv')

# Line — index vs value
df['price'][:200].plot(title='First 200 Prices'); plt.show()

# Histogram of numeric columns
df.hist(figsize=(12,8), bins=30, color='#b34a22'); plt.show()

# Box plot by group
df.boxplot(column='price', by='cut'); plt.show()

# Grouped bar chart
df.groupby('cut')['price'].mean().plot(
    kind='bar', color='#1a6e5c', rot=0
)
plt.title('Mean Price by Cut'); plt.show()

import requests
from bs4 import BeautifulSoup
import pandas as pd
import time

═══ Basic Scrape (Lab Q1) ════════════════════════════════════
# Set a header so you look like a real browser
headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0)"}

resp = requests.get("https://books.toscrape.com", headers=headers)
print(resp.status_code)    # 200 = success, 403 = blocked, 404 = not found

soup = BeautifulSoup(resp.text, 'html.parser')

# Find all book titles
titles = [t.find('a')['title'] for t in soup.find_all('h3')]
prices = [p.text for p in soup.find_all('p', class_='price_color')]
ratings= [a['class'][1] for a in soup.find_all('p', class_='star-rating')]

for t, p, r in zip(titles[:5], prices[:5], ratings[:5]):
    print(f"{t[:35]:35s} | {p} | {r} stars")

═══ CSS Selector approach (alternative to find_all) ══════════
# soup.select() uses CSS selectors — very powerful!
book_articles = soup.select('article.product_pod')

books = []
for article in book_articles:
    books.append({
        'title' : article.select_one('h3 a')['title'],
        'price' : article.select_one('.price_color').text,
        'rating': article.select_one('p.star-rating')['class'][1],
        'in_stock': 'In stock' in article.select_one('.availability').text
    })

df_books = pd.DataFrame(books)
print(df_books.head())
df_books.to_csv('books_scraped.csv', index=False)

═══ Multi-page Scraping (paginate through all 50 pages) ══════
all_books = []
base_url = "https://books.toscrape.com/catalogue/page-{}.html"

for page in range(1, 6):           # scrape first 5 pages
    url  = base_url.format(page)
    resp = requests.get(url, headers=headers)
    soup = BeautifulSoup(resp.text, 'html.parser')

    for article in soup.select('article.product_pod'):
        all_books.append({
            'title': article.select_one('h3 a')['title'],
            'price': article.select_one('.price_color').text,
            'page':  page
        })

    time.sleep(1)                   # BE POLITE — 1 second delay between pages!
    print(f"Page {page} done — {len(all_books)} books so far")

df_all = pd.DataFrame(all_books)
print(f"Total scraped: {len(df_all)} books")

═══ Key Parsing Methods Reference ═══════════════════════════
# soup.find('tag')           — first matching tag
# soup.find_all('tag')       — all matching tags (returns list)
# soup.find('tag', class_='x') — tag with specific class
# soup.find('tag', id='x')   — tag with specific id
# soup.select('div.card h2') — CSS selector (most flexible)
# soup.select_one('...')     — CSS selector, first match only
# tag.text / tag.get_text()  — extract text content
# tag['href'] / tag['class'] — extract attribute value
# tag.get('attr', default)   — safe attribute access

═══ Pillow — Image Lab ═════════════════════════════════════
from PIL import Image
import numpy as np

img = Image.open('photo.jpg')
print(img.size, img.mode)      # (1920, 1080) RGB

# Convert to NumPy array (Lab Q2)
arr = np.array(img)
print(arr.shape)                # (1080, 1920, 3) — H×W×channels
print(arr[0, 0])                # [255 255 255] — top-left pixel RGB

# Back to image
restored = Image.fromarray(arr)
restored.save('output.jpg')

# Transforms
img.resize((800, 600))           # new size
img.rotate(90)                   # rotate 90°
img.convert('L')                 # RGB → Grayscale
img.crop((100,100,500,400))      # (left, top, right, bottom)

═══ Virtual Environment — Essential Commands ════════════════
# Create
python3 -m venv myproject_env

# Activate
source myproject_env/bin/activate      # Linux / Mac
myproject_env\Scripts\activate         # Windows PowerShell

# Install packages (only inside this env)
pip install fastapi uvicorn pandas numpy pillow

# Freeze for sharing / deployment
pip freeze > requirements.txt

# Recreate on another machine / production server
pip install -r requirements.txt

# Deactivate
deactivate

import sqlite3, pandas as pd

# Connect (creates file if not exists)
conn = sqlite3.connect('cdac_attendance.db')
cur  = conn.cursor()

# Create table
cur.execute("""
    CREATE TABLE IF NOT EXISTS students (
        id     INTEGER PRIMARY KEY AUTOINCREMENT,
        name   TEXT    NOT NULL,
        roll   TEXT    UNIQUE,
        cgpa   REAL    DEFAULT 0.0,
        batch  TEXT
    )
""")

# Insert — use ? placeholders (NEVER string format — SQL injection!)
batch_data = [
    ("Priya Nair",  "CDAC2601", 8.9, "PGDBDA-26"),
    ("Raj Kumar",   "CDAC2602", 7.4, "PGDBDA-26"),
    ("Zara Sheikh", "CDAC2610", 9.1, "PGDBDA-26"),
]
cur.executemany(
    "INSERT OR IGNORE INTO students(name,roll,cgpa,batch) VALUES(?,?,?,?)",
    batch_data
)
conn.commit()

# Query directly into Pandas DataFrame — best practice!
df = pd.read_sql("SELECT * FROM students WHERE cgpa > 8", conn)
print(df)

# Always close
conn.close()

═══ MySQL Connection ═══════════════════════════════════════
# pip install mysql-connector-python
import mysql.connector
conn = mysql.connector.connect(
    host="localhost", user="root",
    password="cdac@123", database="pgdbda"
)
# Identical cursor/execute/commit/close API as SQLite

═══ PostgreSQL Connection ══════════════════════════════════
# pip install psycopg2-binary
import psycopg2
conn = psycopg2.connect(
    host="localhost", port=5432,
    dbname="fras_db", user="cdac", password="cdac@123"
)
# Use %s instead of ? for parameterised queries in psycopg2