ONE – PYTHON BASICS: VARIABLES & DATATYPES & OPERATORS
E-COMMERCE PRICE CALCULATIONS [1]
price = 999.0 # LIST PRICE
discount= 0.15 # 15 % OFF
tax = 0.08 # 8 % SALES TAX
subtotal = price * (1-discount)
total = subtotal * (1+tax)
print(f"FINAL CHECK-OUT TOTAL: ₹{total:,.2f}")
IOT SENSOR DATA PROCESSING [1]
import random, time
def read_sensor(): # FAKE TEMPERATURE SENSOR
return round(random.uniform(20, 30), 2) # °C
BUFFER = [] # IN-MEMORY CACHE
while len(BUFFER) < 5: # COLLECT 5 READINGS
BUFFER.append(read_sensor())
time.sleep(1)
avg = sum(BUFFER)/len(BUFFER)
print("MEAN ROOM TEMPERATURE:", avg, "°C")
TWO – CONTROL FLOW: CONDITIONAL STATEMENTS & LOOPS
AUTOMATED TRADING SYSTEMS [1]
price_feed = [105, 99, 101, 96, 92] # LIVE TICKS
TARGET_BUY = 100
TARGET_SELL = 104
for tick in price_feed: # LOOP OVER STREAM
if tick <= TARGET_BUY:
print("BUY @", tick)
elif tick >= TARGET_SELL:
print("SELL @", tick)
CHATBOT CONVERSATION FLOW [1]
intents = {"HI": "HELLO! 👋", "BYE": "GOOD-BYE!", "HELP": "SURE, HOW CAN I HELP?"}
while True:
msg = input("YOU: ").upper()
if msg in intents:
print("BOT:", intents[msg])
else:
print("BOT: SORRY, I DIDN’T UNDERSTAND.")
if msg == "BYE":
break
THREE – DATA STRUCTURES: LISTS & TUPLES & SETS & DICTIONARIES
SOCIAL MEDIA FEED ALGORITHMS [1]
posts = [
{"id": 1, "likes": 120, "ts": 1718600000},
{"id": 2, "likes": 250, "ts": 1718700000},
{"id": 3, "likes": 180, "ts": 1718650000},
]
feed = sorted(posts, key=lambda p: (p["likes"], p["ts"]), reverse=True)
print([p["id"] for p in feed]) # [2,3,1]
INVENTORY MANAGEMENT SYSTEMS [1]
inventory = {"LAPTOP": 12, "MOUSE": 85, "MONITOR": 7}
order = {"LAPTOP": 2, "MOUSE": 3}
for item, qty in order.items():
if inventory.get(item,0) >= qty:
inventory[item] -= qty
print("UPDATED STOCK:", inventory)
FOUR – FUNCTIONS: LAMBDA & MAP & FILTER
DATA CLEANING PIPELINES [1]
raw = ["Alice ", None, " Bob", "", "Eve "]
clean = list(map(lambda s: s.strip(), filter(None, raw)))
print(clean) # ['Alice', 'Bob', 'Eve']
IMAGE PROCESSING APPLICATIONS [1]
from PIL import Image, ImageFilter # pip install pillow
img = Image.open("photo.jpg")
blurred = img.filter(ImageFilter.GaussianBlur(4))
blurred.save("photo_blur.jpg")
FIVE – MODULES: IMPORT & STANDARD OVERVIEW
MICROSERVICES ARCHITECTURE [1]
# user_service.py
def get_user(uid): return {"id": uid, "name": "ALICE"}
# order_service.py
from user_service import get_user
def place_order(uid, item):
user = get_user(uid)
return {"user": user, "item": item}
print(place_order(1, "BOOK"))
API DEVELOPMENT [1]
from flask import Flask, jsonify
app = Flask(__name__)
@app.route("/ping")
def ping(): return jsonify(status="OK")
if __name__ == "__main__":
app.run()
SIX – FILE HANDLING: FILE OPERATION & FILE PATH
LOG ANALYSIS SYSTEMS [1]
with open("server.log") as f:
errors = [line for line in f if "ERROR" in line]
print("ERROR COUNT:", len(errors))
DOCUMENT MANAGEMENT SYSTEMS [1]
from pathlib import Path
uploads = Path("uploads")
pdfs = list(uploads.rglob("*.pdf"))
print("TOTAL PDF FILES:", len(pdfs))
SEVEN – EXCEPTION HANDLING
PAYMENT PROCESSING SYSTEMS [1]
def charge(card, amount):
if amount <= 0: raise ValueError("INVALID AMOUNT")
# SIMULATE GATEWAY FAILURE
raise ConnectionError("NETWORK DOWN")
try:
charge("4111-xxxx-xxxx-1234", 250)
except ConnectionError as e:
print("RETRY LATER ‑", e)
except Exception as e:
print("PAYMENT FAILED:", e)
AUTONOMOUS VEHICLE SOFTWARE [1]
def read_lidar():
raise RuntimeError("SENSOR BLOCKED")
try:
distance = read_lidar()
except RuntimeError as e:
print("ENGAGE SAFE-STOP 🚨:", e)
EIGHT – CLASS AND OBJECTS (OOP)
GAME DEVELOPMENT [1]
class Player:
def __init__(self, name, hp=100): self.name, self.hp = name, hp
def attack(self, target): target.hp -= 10
def __str__(self): return f"{self.name}:{self.hp}HP"
p1, p2 = Player("KNIGHT"), Player("ORC")
p1.attack(p2)
print(p1, p2)
ENTERPRISE RESOURCE PLANNING (ERP) [1]
class Employee: # BASE CLASS
def __init__(self, eid, name): self.eid, self.name = eid, name
class Manager(Employee): # INHERITANCE
def approve_leave(self, days): print(self.name, "APPROVED", days, "DAYS")
mgr = Manager(101, "PRIYA")
mgr.approve_leave(3)
NINE – ADVANCED PYTHON CONCEPTS: ITERATORS & GENERATORS &
DECORATORS
BIG DATA PROCESSING [1]
def stream_file(path):
with open(path) as f:
for line in f: # GENERATOR YIELDS ONE ROW AT A TIME
yield line.strip().split(",")
for row in stream_file("huge.csv"):
pass # PROCESS
API RATE LIMITING [1]
from time import time, sleep
def rate_limit(calls_per_sec):
def deco(fn):
last=[^0]
def wrapper(*a, **k):
elapsed=time()-last[^0]
if elapsed < 1/calls_per_sec:
sleep(1/calls_per_sec - elapsed)
last[^0]=time()
return fn(*a, **k)
return wrapper
return deco
@rate_limit(5) # MAX 5 CALLS/SEC
def fetch():
print("API HIT")
for _ in range(10):
fetch()
TEN – DATA ANALYSIS WITH PYTHON
FINANCIAL MARKET ANALYSIS [1]
import pandas as pd, matplotlib.pyplot as plt
df = pd.read_csv("prices.csv", parse_dates=["Date"], index_col="Date")
df["SMA20"] = df["Close"].rolling(20).mean()
df[["Close","SMA20"]].plot(title="20-DAY MOVING AVERAGE")
plt.show()
HEALTHCARE DATA ANALYTICS [1]
import seaborn as sns, pandas as pd
patients = pd.read_csv("patients.csv")
sns.boxplot(x="Diagnosis", y="Age", data=patients)
ELEVEN – WORKING WITH DATABASES: SQLITE
MOBILE APP DEVELOPMENT [1]
import sqlite3, pathlib
db = pathlib.Path("app.db")
con = sqlite3.connect(db)
cur = con.cursor()
cur.execute("CREATE TABLE IF NOT EXISTS prefs(key TEXT, val TEXT)")
cur.execute("INSERT INTO prefs VALUES(?,?)", ("THEME","DARK"))
con.commit()
SMALL BUSINESS MANAGEMENT [1]
def total_sales():
with sqlite3.connect("shop.db") as con:
cur = con.cursor()
cur.execute("SELECT SUM(amount) FROM orders")
print("TOTAL SALES:", cur.fetchone()[^0])
total_sales()
TWELVE – LOGGING IN PYTHON
PRODUCTION WEB APPLICATIONS [1]
import logging, logging.config
logging.basicConfig(level=logging.INFO, filename="app.log",
format="%(asctime)s %(levelname)s %(message)s")
logging.info("SERVICE STARTED")
CYBERSECURITY MONITORING [1]
sec_log = logging.getLogger("security")
net_log = logging.getLogger("network")
handler = logging.FileHandler("security.log")
sec_log.addHandler(handler); net_log.addHandler(handler)
sec_log.warning("UNUSUAL LOGIN LOCATION")
THIRTEEN – FLASK
FINTECH APPLICATIONS [1]
from flask import Flask, request, jsonify
app = Flask(__name__)
@app.post("/transfer")
def transfer():
data = request.json
# FAKE FUNDS MOVE
return jsonify(status="SUCCESS", ref="TXN123")
app.run()
HEALTHCARE MANAGEMENT SYSTEMS [1]
@app.get("/patient/<pid>")
def patient(pid):
record = {"id": pid, "name": "JOHN", "bp": "120/80"}
return jsonify(record)
FOURTEEN – STREAMLIT
MACHINE LEARNING MODEL DEPLOYMENT [1]
# streamlit_app.py
import streamlit as st, joblib
clf = joblib.load("model.pkl")
val = st.slider("SEPAL LENGTH", 4.0, 8.0, 5.1)
pred = clf.predict([[val,3.5,1.4,0.2]])[^0]
st.write("PREDICTED SPECIES:", pred)
BUSINESS INTELLIGENCE DASHBOARDS [1]
import pandas as pd, streamlit as st
sales = pd.read_csv("sales.csv")
st.bar_chart(sales.groupby("Region")["Revenue"].sum())
FIFTEEN – MEMORY MANAGEMENT
HIGH-FREQUENCY TRADING SYSTEMS [1]
import array # LOW-OVERHEAD NUMERIC BUFFER
ticks = array.array('d', (0.0 for _ in range(1_000_000)))
SCIENTIFIC COMPUTING [1]
import numpy as np, sys
mat = np.zeros((1000,1000), dtype=np.float32)
print("MEMORY USED (MB):", sys.getsizeof(mat)/1e6)
SIXTEEN – MULTITHREADING & MULTIPROCESSING
WEB SCRAPING OPERATIONS [1]
from concurrent.futures import ThreadPoolExecutor
import requests, bs4
URLS = ["https://example.com"]*10
def fetch(url):
soup = bs4.BeautifulSoup(requests.get(url).text, "html.parser")
return soup.title.string
with ThreadPoolExecutor(8) as ex:
titles = list(ex.map(fetch, URLS))
print(titles)
CRYPTOCURRENCY MINING SOFTWARE [1]
import hashlib, os
from multiprocessing import Pool
def sha256(nonce): # CPU-INTENSIVE HASH
return hashlib.sha256(str(nonce).encode()).hexdigest()
with Pool(os.cpu_count()) as p:
hashes = p.map(sha256, range(1_000_000))
print("COMPUTED", len(hashes), "HASHES")
1. REAL-USE-CASES.pdf
