Python
Fundamentals

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Pick only the even numbers
evens = [n for n in numbers if n % 2 == 0]

print("Even numbers:", evens)

print("Hello, World!")

print("Hello, World!")          # text string
print(42)                       # whole number
print(3.14)                     # decimal number
print(True)                     # boolean value
print("Python" + " is fun!")    # joining two strings
print(10 + 5)                   # arithmetic result
print(2 ** 8)                   # 2 to the power of 8

# This whole line is a comment — Python ignores it
print("This line runs normally")

print("This runs too")  # comment at end of a line

# You can disable code temporarily by commenting it out:
# print("This line is skipped")

# Calculate the total price including GST
# GST rate for most goods in India: 18%

price = 1200
gst_rate = 0.18          # 18% expressed as a decimal

gst_amount = price * gst_rate
total = price + gst_amount

print(f"Price:    ₹{price}")
print(f"GST 18%:  ₹{gst_amount}")
print(f"Total:    ₹{total}")

name = "Alice"       # stores text
age = 25             # stores a whole number
height = 5.6         # stores a decimal
is_student = True    # stores True or False

# Use the variable by writing its name
print(name)          # Alice
print(age)           # 25
print(height)        # 5.6
print(is_student)    # True

score = 0
print("Start:", score)        # Start: 0

score = 10
print("After level 1:", score) # After level 1: 10

score = score + 5              # add 5 to whatever score currently is
print("After bonus:", score)   # After bonus: 15

# Good names — descriptive and clear
user_name = "Bob"
total_score = 95
is_logged_in = True
max_retry_attempts = 3

# Case sensitivity in action
city = "Delhi"
City = "Mumbai"     # completely different variable!

print(city)   # Delhi
print(City)   # Mumbai

age = 25
price = 99.99
city = "Mumbai"
is_open = False

print(type(age))       # <class 'int'>
print(type(price))     # <class 'float'>
print(type(city))      # <class 'str'>
print(type(is_open))   # <class 'bool'>

# You can also check the type of a literal value directly
print(type(3.14))      # <class 'float'>
print(type("hello"))   # <class 'str'>

# The + operator behaves differently per type
print(42 + 8)        # 50  → addition (numbers)
print("42" + "8")    # 428 → concatenation (strings)

# Confirming the types
print(type(42))      # <class 'int'>
print(type("42"))    # <class 'str'>

# String → Integer
num_str = "42"
num_int = int(num_str)
print(num_int + 8)          # 50  ✓ (now it's a number)

# Integer → String
age = 25
age_text = str(age)
print("Age: " + age_text)   # "Age: 25" ✓ (now it's text)

# String → Float
price_str = "99.99"
price = float(price_str)
print(price + 0.01)         # 100.0

# Float → Int (decimal is TRUNCATED, not rounded)
x = int(3.9)
y = int(7.1)
print(x, y)                 # 3  7  (not 4 and 7!)

# input() always returns a string, even if the user types a number
user_input = "50"      # imagine this came from input()

# WRONG — tries to join text, not add numbers:
# print(user_input + 10)   # TypeError!

# RIGHT — convert first, then calculate:
amount = int(user_input)
print(amount + 10)          # 60

# One-liner version you'll see often:
# amount = int(input("Enter amount: "))

name = "Alice"
age = 25

# Multiple values: print() adds a space between them by default
print("Name:", name, "| Age:", age)

# Change the separator with sep=
print("A", "B", "C", sep=" → ")    # A → B → C

# Change the ending with end= (default is a newline)
print("Loading", end="... ")
print("Done!")                       # Loading... Done!

name = "Alice"
age = 25
score = 88.5

# Old way — messy, easy to forget str() conversion
print("Name: " + name + ", Age: " + str(age))

# f-string — clean, readable, handles types automatically
print(f"Name: {name}, Age: {age}")

# Any expression works inside {}
print(f"Next year you'll be {age + 1}")
print(f"Score: {score:.1f}%")        # .1f = 1 decimal place → 88.5%
print(f"Uppercase name: {name.upper()}")
print(f"{'Python':>15}")             # right-align in 15 chars

a, b = 10, 3   # assign two variables at once

print(f"{a} + {b}  = {a + b}")      # 13
print(f"{a} - {b}  = {a - b}")      # 7
print(f"{a} * {b}  = {a * b}")      # 30
print(f"{a} / {b}  = {a / b:.4f}")  # 3.3333 (always a float)
print(f"{a} // {b} = {a // b}")     # 3  (whole part only)
print(f"{a} % {b}  = {a % b}")      # 1  (remainder after dividing)
print(f"2 ** 10   = {2 ** 10}")     # 1024

x = 10

print(x == 10)    # True  — equal to
print(x != 5)     # True  — not equal to
print(x > 5)      # True  — greater than
print(x < 5)      # False — less than
print(x >= 10)    # True  — greater than or equal
print(x <= 9)     # False — less than or equal

# Critical distinction:
# x = 10   means "set x to 10"     (assignment)
# x == 10  means "is x equal to 10?" (comparison → True/False)

# and — BOTH conditions must be True
print(True and True)    # True
print(True and False)   # False
print(False and False)  # False

# or — AT LEAST ONE must be True
print(True or False)    # True
print(False or False)   # False

# not — FLIPS the value
print(not True)         # False
print(not False)        # True

# Real example: club entry check
age = 20
has_id = True

can_enter = age >= 18 and has_id
print(f"Can enter: {can_enter}")    # True

# Another real example: discount eligibility
is_student = False
is_senior = True

gets_discount = is_student or is_senior
print(f"Gets discount: {gets_discount}")  # True

age = 20

if age >= 18:
    print("You are an adult.")
elif age >= 13:
    print("You are a teenager.")
else:
    print("You are a child.")

# Change age to 15 or 8 and re-run to see the difference

score = 78

if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
elif score >= 60:
    grade = "D"
else:
    grade = "F"

print(f"Score: {score}  →  Grade: {grade}")

age = 25
has_id = True
is_vip = False

# AND — both must be True
if age >= 18 and has_id:
    print("Entry allowed.")

# OR — at least one True
if age >= 18 or is_vip:
    print("Can purchase ticket.")

# NOT — inverts
if not is_vip:
    print("Regular pricing applies.")

# Combining operators — use parentheses for clarity
if (age >= 18 and has_id) or is_vip:
    print("Full access granted.")

# range(n) generates numbers 0 to n-1
for i in range(5):
    print(f"Step {i}")

print("---")

# range(start, stop, step)
for i in range(1, 10, 2):
    print(i, end=" ")   # prints: 1 3 5 7 9
print()

# Looping over a string
for char in "Python":
    print(char, end="-")  # P-y-t-h-o-n-

# Sum 1 to 100
total = 0
for n in range(1, 101):
    total += n
print(f"Sum 1–100 = {total}")   # 5050

# Countdown using reversed range
for i in range(5, 0, -1):
    print(i, end=" ")
print("Lift off! 🚀")

# enumerate() gives index + value together
fruits = ["apple", "banana", "cherry"]
for idx, fruit in enumerate(fruits):
    print(f"{idx + 1}. {fruit}")

count = 1

while count <= 5:
    print(f"Count: {count}")
    count += 1          # always update the counter — or you get infinite loop!

print("Done!")

# Simulating a simple retry loop
attempts = 0
max_attempts = 3

while attempts < max_attempts:
    print(f"Attempt {attempts + 1}: trying...")
    attempts += 1

print("No more attempts.")

# break — exit as soon as we find 5
for n in range(1, 10):
    if n == 5:
        print(f"Found 5, stopping!")
        break
    print(n)

print("---")

# continue — skip even numbers, print only odd
for n in range(1, 11):
    if n % 2 == 0:
        continue        # skip even numbers
    print(n, end=" ")   # prints: 1 3 5 7 9
print()

# Multiplication table for 1-3
for i in range(1, 4):
    for j in range(1, 6):
        print(f"{i} × {j} = {i*j}")
    print("---")          # separator after each row

# Number Guessing Game — Module 03 Mini Project
import random

secret = random.randint(1, 20)   # random number 1–20
attempts = 0
max_tries = 5

print("=== Number Guessing Game ===")
print(f"Guess a number between 1 and 20. You have {max_tries} tries.")

guesses = [7, 12, 15, secret]    # simulated guesses (replace with input() in real app)

for guess in guesses:
    attempts += 1
    print(f"\nAttempt {attempts}: guessing {guess}")

    if guess < secret:
        print("Too low! Try higher.")
    elif guess > secret:
        print("Too high! Try lower.")
    else:
        print(f"🎉 Correct! You got it in {attempts} attempt(s)!")
        break

    if attempts == max_tries:
        print(f"❌ Out of attempts! The number was {secret}.")

# Creating lists
fruits  = ["apple", "banana", "cherry"]
numbers = [10, 20, 30, 40, 50]
mixed   = [1, "hello", 3.14, True]

# Indexing — starts at 0
print(fruits[0])    # apple
print(fruits[-1])   # cherry  (negative = from the end)

# Slicing  [start : stop]  stop is exclusive
print(numbers[1:4]) # [20, 30, 40]
print(numbers[:3])  # [10, 20, 30]
print(numbers[2:])  # [30, 40, 50]

# Length
print(len(fruits))  # 3

scores = [85, 92, 78, 95, 88]

scores.append(100)        # add to end
scores.insert(0, 70)      # insert at index 0
scores.remove(78)         # remove first occurrence of 78
popped = scores.pop()     # remove and return last item
scores.sort()             # sort ascending
scores.sort(reverse=True) # sort descending
print(scores)
print(sum(scores), max(scores), min(scores))

fruits = ["apple", "banana", "cherry"]

# Update a single item by index
fruits[1] = "mango"
print(fruits)    # ['apple', 'mango', 'cherry']

# Replace a slice (indices 0 and 1)
fruits[0:2] = ["kiwi", "grape"]
print(fruits)    # ['kiwi', 'grape', 'cherry']

# Extend — add multiple items at the end
fruits.extend(["papaya", "guava"])
print(fruits)

scores = [85, 92, 78, 95, 88]

# Basic for loop — just values
for s in scores:
    print(s)

# enumerate — index + value together
for i, s in enumerate(scores):
    print(f"Rank {i+1}: {s}")

# while loop with index
i = 0
while i < len(scores):
    print(scores[i])
    i += 1

# Squares of 1 to 5
squares = [x**2 for x in range(1, 6)]
print(squares)   # [1, 4, 9, 16, 25]

# Even numbers only
evens = [x for x in range(20) if x % 2 == 0]
print(evens)

# Convert all strings to uppercase
words = ["sql", "python", "pandas"]
upper = [w.upper() for w in words]
print(upper)

# Creating tuples
point   = (27.1751, 78.0421)
rgb_red = (255, 0, 0)
single  = (42,)           # trailing comma needed for single-item tuple

print(point[0])    # 27.1751
print(rgb_red[-1]) # 0

# Tuple unpacking
lat, lng = point
print(f"Latitude: {lat}, Longitude: {lng}")

x, y, z = rgb_red
print(f"R={x} G={y} B={z}")

# Swap two variables (uses tuple packing/unpacking)
a, b = 10, 20
a, b = b, a
print(a, b)   # 20 10

days = ("Mon", "Tue", "Wed", "Thu", "Fri")

# Basic loop
for day in days:
    print(day)

# enumerate — index + value
for i, day in enumerate(days):
    print(f"Day {i+1}: {day}")

# Unpack all at once when length is known
mon, tue, wed, thu, fri = days
print(f"Weekend starts after {fri}")

# Duplicates removed automatically
tags = {"python", "sql", "python", "data", "sql"}
print(tags)   # {'python', 'sql', 'data'}

tags.add("pandas")
tags.discard("sql")    # no error if missing
print(tags)

# Membership — O(1), very fast
print("python" in tags)   # True

# Set operations
backend  = {"python", "sql", "django"}
frontend = {"javascript", "css", "python"}

print(backend | frontend)  # union
print(backend & frontend)  # intersection
print(backend - frontend)  # difference
print(backend ^ frontend)  # symmetric difference

skills = {"python", "sql"}

# Add one item
skills.add("pandas")

# Add many items at once
skills.update(["spark", "airflow", "dbt"])
print(skills)

# Remove — raises KeyError if missing
skills.remove("airflow")

# Discard — safe, no error if missing
skills.discard("java")   # java wasn't there — no crash
print(skills)

# Clear all items
backup = skills.copy()
skills.clear()
print(skills)   # set()

techs = {"python", "sql", "pandas", "spark"}

# Loop — order varies each run
for t in techs:
    print(t)

# Sorted loop — predictable order
for t in sorted(techs):
    print(t)

# Set comprehension — keep long names only
long_names = {t for t in techs if len(t) > 3}
print(long_names)

student = {
    "name":   "Priya Sharma",
    "age":    22,
    "course": "Data Engineering",
    "score":  91
}

print(student["name"])               # Priya Sharma
print(student.get("grade", "N/A"))   # N/A  (safe — no KeyError)

student["city"]  = "Bangalore"       # add new key
student["score"] = 95                # update existing key

del student["age"]
removed = student.pop("city")
print(removed)

salary = {
    "Data Analyst":   65000,
    "Data Engineer":  90000,
    "ML Engineer":   110000,
}

# Loop through key-value pairs
for role, sal in salary.items():
    print(f"{role:20} -> Rs {sal:,}")

# Dict comprehension — 10% hike
hiked = {r: int(s * 1.10) for r, s in salary.items()}
print(hiked)

# List of dicts — like a database table
students = [
    {"name": "Arjun",  "score": 88, "course": "SQL"},
    {"name": "Priya",  "score": 95, "course": "Python"},
    {"name": "Ravi",   "score": 72, "course": "SQL"},
    {"name": "Sneha",  "score": 91, "course": "Python"},
]

for s in students:
    print(s["name"], s["score"])

# Filter: Python students only
py_students = [s for s in students if s["course"] == "Python"]
print(py_students)

avg = sum(s["score"] for s in students) / len(students)
print(f"Average: {avg:.1f}")

# Grade Book — Module 04 Mini Project
gradebook = {
    "Arjun": {"Math": 82, "Python": 91, "SQL": 88},
    "Priya": {"Math": 95, "Python": 97, "SQL": 93},
    "Ravi":  {"Math": 70, "Python": 74, "SQL": 68},
}

def get_grade(avg):
    if avg >= 90: return "A"
    if avg >= 80: return "B"
    if avg >= 70: return "C"
    return "D"

print(f"{'Student':<10} {'Average':>8} {'Grade':>6}")
print("-" * 28)
for name, marks in gradebook.items():
    avg = sum(marks.values()) / len(marks)
    print(f"{name:<10} {avg:>8.1f} {get_grade(avg):>6}")

best = max(gradebook, key=lambda n: sum(gradebook[n].values()))
print(f"\nTop performer: {best}")

name = "Python"

# Indexing
print(name[0])    # P
print(name[-1])   # n  (last character)
print(name[-2])   # o  (second from end)

# Slicing  [start : stop : step]
print(name[0:3])   # Pyt
print(name[2:])    # thon
print(name[:4])    # Pyth
print(name[::2])   # Pto  (every other char)
print(name[::-1])  # nohtyP  (reversed!)

# Concatenation and repetition
lang = "Data " + name
print(lang)           # Data Python
print(len(lang))      # 11
print(name * 3)       # PythonPythonPython

text = "  Hello, World!  "

print(text.upper())       # "  HELLO, WORLD!  "
print(text.lower())       # "  hello, world!  "
print(text.strip())       # "Hello, World!"
print(text.lstrip())      # "Hello, World!  "
print(text.rstrip())      # "  Hello, World!"

clean = text.strip()
print(clean.find("World"))     # 7
print(clean.count("l"))        # 3
print(clean.replace("World", "Python"))  # Hello, Python!

# split() — string to list
csv_row = "Priya,91,Python,Bangalore"
parts = csv_row.split(",")
print(parts)    # ['Priya', '91', 'Python', 'Bangalore']

# join() — list to string
words = ["Data", "Science", "is", "awesome"]
print(" ".join(words))   # Data Science is awesome

# Normalise user input
raw = "  data ENGINEER  "
print(raw.strip().lower().replace(" ", "_"))  # data_engineer

# startswith / endswith
filename = "report_2024.csv"
print(filename.endswith(".csv"))    # True
print(filename.startswith("rep"))  # True

name   = "Priya"
score  = 91.5
salary = 85000

# Basic embedding
print(f"Hello, {name}!")
print(f"Score + bonus = {score + 5}")
print(f"Upper: {name.upper()}")

# Format specifiers
print(f"Salary: Rs {salary:,}")       # Rs 85,000
print(f"Score:  {score:.2f}")         # 91.50
print(f"Score:  {score:.0f}")         # 92 (rounded)

# Alignment
print(f"{'Role':<15} {'Score':>6}")
print(f"{'Data Engineer':<15} {score:>6.1f}")

# Multi-line
report = (
    f"Student Report\n"
    f"  Name  : {name}\n"
    f"  Score : {score}\n"
)
print(report)

email = "priya@marutinovatech.com"
print("@" in email)                   # True
print(email.startswith("priya"))      # True
print(email.endswith(".com"))         # True

text = "Data Engineering is the future of tech"
print(text.count("e"))               # 5
words = text.split()
print(f"Word count: {len(words)}")

# Palindrome check
def is_palindrome(s):
    s = s.lower().replace(" ", "")
    return s == s[::-1]

print(is_palindrome("racecar"))  # True
print(is_palindrome("Madam"))    # True
print(is_palindrome("Python"))   # False

# Build string from list
digits = [str(x) for x in range(10)]
print("".join(digits))           # 0123456789

# Text Analyser — Module 05 Mini Project
text = """
Python is a versatile programming language.
It is used in data science, web development, and automation.
Python is easy to learn and powerful to use.
Data engineers love Python for pipeline and ETL work.
"""

words     = text.lower().split()
sentences = [s.strip() for s in text.split(".") if s.strip()]

print(f"Characters : {len(text.strip())}")
print(f"Words      : {len(words)}")
print(f"Sentences  : {len(sentences)}")

# Word frequency
freq = {}
for word in words:
    clean = word.strip(".,!?").lower()
    freq[clean] = freq.get(clean, 0) + 1

sorted_words = sorted(freq.items(), key=lambda x: x[1], reverse=True)
print("\nTop 5 words:")
for word, count in sorted_words[:5]:
    print(f"  {word:<15} {count} time(s)")

# Most common letter
all_chars = [c.lower() for c in text if c.isalpha()]
char_freq = {}
for c in all_chars:
    char_freq[c] = char_freq.get(c, 0) + 1

top_char = max(char_freq, key=char_freq.get)
print(f"\nMost common letter: '{top_char}' ({char_freq[top_char]} times)")

def greet():
    print("Hello, world!")

greet()   # call the function
greet()   # call it again — reusable!

# Function that returns a value
def square(n):
    return n ** 2

result = square(7)
print(result)          # 49
print(square(10))      # 100

def classify_score(score):
    if score >= 90:
        return "A"
    elif score >= 75:
        return "B"
    elif score >= 60:
        return "C"
    else:
        return "F"

scores = [95, 82, 67, 45]
for s in scores:
    print(f"{s}  →  Grade {classify_score(s)}")

# Positional — order matters
def greet(name, city):
    print(f"Hi {name} from {city}!")

greet("Priya", "Bangalore")

# Default parameter — used when argument is omitted
def power(base, exp=2):
    return base ** exp

print(power(5))     # 25  (exp defaults to 2)
print(power(2, 10)) # 1024

# Keyword arguments — order doesn't matter
greet(city="Mumbai", name="Arjun")

# *args — variable number of positional arguments
def total(*numbers):
    return sum(numbers)

print(total(1, 2, 3))           # 6
print(total(10, 20, 30, 40))    # 100

# **kwargs — variable number of keyword arguments
def show_profile(**info):
    for key, val in info.items():
        print(f"{key}: {val}")

show_profile(name="Ravi", role="Data Engineer", city="Pune")

# Multiple return values — returns a tuple
def min_max(nums):
    return min(nums), max(nums)

lo, hi = min_max([5, 1, 9, 3])
print(f"Min: {lo}, Max: {hi}")

# lambda syntax:  lambda arguments : expression
double = lambda x: x * 2
print(double(7))   # 14

# Sort list of dicts by a field
employees = [
    {"name": "Priya",  "salary": 90000},
    {"name": "Arjun",  "salary": 75000},
    {"name": "Sneha",  "salary": 110000},
]
by_salary = sorted(employees, key=lambda e: e["salary"], reverse=True)
for e in by_salary:
    print(f"{e['name']:10}  Rs {e['salary']:,}")

nums = [1, 2, 3, 4, 5, 6]

# map — square every number
squares = list(map(lambda x: x**2, nums))
print(squares)   # [1, 4, 9, 16, 25, 36]

# filter — keep only even numbers
evens = list(filter(lambda x: x % 2 == 0, nums))
print(evens)     # [2, 4, 6]

# Useful built-ins
data = [8, 3, 9, 1, 7]
print(sum(data), min(data), max(data))
print(sorted(data))
print(list(reversed(data)))

import math
import random
from datetime import date

# math module
print(math.sqrt(144))   # 12.0
print(math.pi)           # 3.14159...
print(math.ceil(4.2))   # 5
print(math.floor(4.9))  # 4

# random module
print(random.randint(1, 100))  # random int 1–100
names = ["Priya", "Arjun", "Ravi"]
print(random.choice(names))    # random pick

# datetime — today's date
today = date.today()
print(today)                   # e.g. 2025-06-01
print(today.year, today.month)

import math as m          # alias — shorter to type
print(m.sqrt(25))          # 5.0

from math import sqrt, pi  # import specific names
print(sqrt(81))            # 9.0
print(pi)                  # 3.14159...

# Third-party — install first:  pip install requests
# import requests
# resp = requests.get("https://api.example.com/data")

# List everything inside a module
print(dir(math))[:6]

import math

# ── Helper functions ──────────────────────────

def letter_grade(score):
    if score >= 90: return "A"
    elif score >= 75: return "B"
    elif score >= 60: return "C"
    else: return "F"

def stats(*scores):
    avg = sum(scores) / len(scores)
    return {
        "count":  len(scores),
        "avg":    round(avg, 2),
        "high":   max(scores),
        "low":    min(scores),
        "pass":   sum(1 for s in scores if s >= 60),
    }

def report(class_name, **students):
    print(f"\n{'='*40}")
    print(f"  Class: {class_name}")
    print(f"{'='*40}")
    for name, score in sorted(students.items()):
        print(f"  {name:12} {score:>3}  [{letter_grade(score)}]")
    s = stats(*students.values())
    print(f"{'─'*40}")
    print(f"  Average : {s['avg']}")
    print(f"  Highest : {s['high']}")
    print(f"  Lowest  : {s['low']}")
    print(f"  Pass %  : {s['pass']*100//s['count']}%")

# ── Run the report ────────────────────────────

report("Python Batch A",
    Priya=92, Arjun=78, Ravi=55,
    Sneha=88, Kiran=64, Meera=71)