python --version   # e.g. Python 3.11.4
pip --version      # package manager

pip install numpy pandas matplotlib jupyter

# my_first_program.py
print("Hello, World!")
print("Welcome to Python! 🐍")

name    = "Alice"          # str  – text
age     = 30               # int  – whole number
height  = 1.75             # float – decimal
is_cool = True             # bool – True / False
nothing = None             # NoneType – absence of value

print(type(name))          # <class 'str'>
print(type(age))           # <class 'int'>
print(type(height))        # <class 'float'>

a, b = 10, 3
print(a + b)    # 13   addition
print(a - b)    # 7    subtraction
print(a * b)    # 30   multiplication
print(a / b)    # 3.333... true division
print(a // b)   # 3    floor division
print(a % b)    # 1    modulus (remainder)
print(a ** b)   # 1000 exponentiation

print(5 == 5)   # True   equal
print(5 != 3)   # True   not equal
print(5 > 3)    # True   greater than
print(5 <= 5)   # True   less than or equal

print(True and False)  # False
print(True or  False)  # True
print(not True)        # False

x = "42"
y = int(x)          # str → int
z = float(x)        # str → float
w = str(100)        # int → str
b = bool(0)         # int → bool (0 → False)

# Two-step conversion
int(float("3.14"))  # 3

x, y, z = 1, 2, 3

# Swap without a temp variable — pure Python magic!
a, b = 10, 20
a, b = b, a
print(a, b)   # 20 10

# Same value to many variables
p = q = r = 0

s1 = "Hello"             # double quotes
s2 = 'World'             # single quotes (identical)
s3 = """This is a
multi-line string."""     # triple quotes
s4 = r"C:\Users\file"   # raw string — backslash is literal

word = "Python"
#       P y t h o n
#       0 1 2 3 4 5   (positive)
#      -6-5-4-3-2-1   (negative)

print(word[0])      # P      — first character
print(word[-1])     # n      — last character
print(word[2:5])    # tho    — slice [start:stop] (stop excluded)
print(word[:3])     # Pyt    — from start
print(word[3:])     # hon    — to end
print(word[::2])    # Pto    — every 2nd character (step)
print(word[::-1])   # nohtyP — REVERSE the string!

text = "  Hello, World!  "
print(text.strip())              # "Hello, World!"
print(text.strip().lower())      # "hello, world!"
print(text.strip().split(", "))  # ["Hello", "World!"]

words = ["Python", "is", "awesome"]
print(" ".join(words))           # "Python is awesome"

email = "user@example.com"
print(email.split("@")[1])       # "example.com"
print(email.replace("@", " at ")) # "user at example.com"

name  = "Alice"
score = 95.678

print(f"Hello, {name}!")
print(f"Score: {score:.2f}")       # Score: 95.68 (2 decimal places)
print(f"Score: {score:08.2f}")     # Score: 00095.68 (zero-padded)
print(f"2 + 2 = {2 + 2}")          # expressions inside {}
print(f"Name upper: {name.upper()}")

# Debug shorthand (Python 3.8+)
x = 42
print(f"{x = }")                   # x = 42

temperature = 35
if temperature > 30:
    print("It is hot outside!")   # 4-space indent is mandatory

score = 72

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"Grade: {grade}")   # Grade: C

# value_if_true  if  condition  else  value_if_false
age = 20
status = "adult" if age >= 18 else "minor"
discount = 0.20 if age >= 65 else 0.0

# FALSY values — evaluated as False in boolean context:
False, None, 0, 0.0, 0j, "", [], (), {}, set()

# TRUTHY: everything else

name = ""
if not name:
    print("Name cannot be empty!")

items = []
if not items:
    print("Cart is empty")

command = "quit"

match command:
    case "start":
        print("Starting...")
    case "stop" | "quit":
        print("Stopping...")
    case _:          # default (like else)
        print(f"Unknown: {command}")

for i in range(5):        # 0, 1, 2, 3, 4
    print(i)

for i in range(1, 11, 2): # 1, 3, 5, 7, 9
    print(i)

fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit.upper())

students = ["Alice", "Bob", "Carol"]
for i, name in enumerate(students, start=1):
    print(f"{i}. {name}")

names  = ["Alice", "Bob", "Carol"]
scores = [95, 82, 78]
for name, score in zip(names, scores):
    print(f"{name}: {score}")

n = 5
while n > 0:
    print(n)
    n -= 1
print("Blastoff!")

# break — exit loop immediately
for n in range(10):
    if n == 5: break
    print(n)   # prints 0 1 2 3 4

# continue — skip to next iteration
for n in range(10):
    if n % 2 == 0: continue
    print(n)        # prints 1 3 5 7 9

# else on a for loop — runs only if no break
for n in range(2, 10):
    if 100 % n == 0:
        print(f"Factor: {n}"); break
else:
    print("No factor found")

# [expression  for  item  in  iterable  if  condition]

squares = [x**2 for x in range(1, 11)]
# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

evens = [x for x in range(20) if x % 2 == 0]

upper = [n.upper() for n in ["alice", "bob"]]

# Nested — 3×3 multiplication table
table = [[i*j for j in range(1,4)] for i in range(1,4)]

def greet(name):
    """Greet a person by name."""   # docstring
    return f"Hello, {name}!"

message = greet("Alice")
print(message)   # Hello, Alice!

def create_profile(name, age, country="US"):
    return f"{name}, {age}, {country}"

print(create_profile("Alice", 30))          # Alice, 30, US
print(create_profile(age=25, name="Bob"))  # keyword order doesn't matter
print(create_profile("Chen", 22, "CN"))    # override default

# *args — any number of positional arguments (stored as tuple)
def add_all(*numbers):
    return sum(numbers)

print(add_all(1, 2, 3, 4, 5))  # 15

# **kwargs — any number of keyword arguments (stored as dict)
def print_info(**details):
    for key, value in details.items():
        print(f"{key}: {value}")

print_info(name="Alice", job="Engineer", city="NYC")

# lambda  args : expression
square = lambda x: x ** 2
print(square(5))   # 25

# Lambdas shine as sort keys
students = [("Alice", 88), ("Bob", 72), ("Carol", 95)]
students.sort(key=lambda s: s[1], reverse=True)
print(students)   # [("Carol",95), ("Alice",88), ("Bob",72)]

# L → Local   E → Enclosing   G → Global   B → Built-in
x = "global"
def outer():
    x = "enclosing"
    def inner():
        x = "local"
        print(x)    # local
    inner()
    print(x)        # enclosing
outer()
print(x)            # global

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

doubled = list(map(lambda x: x * 2, numbers))    # [2,4,6,8,10,12]
evens   = list(filter(lambda x: x % 2 == 0, numbers))  # [2,4,6]

from functools import reduce
product = reduce(lambda a, b: a * b, numbers)  # 720

fruits = ["apple", "banana", "cherry"]
fruits.append("date")          # add to end
fruits.insert(1, "avocado")    # insert at index
fruits.remove("apple")         # remove by value
popped = fruits.pop()           # remove & return last
fruits.sort()                   # sort in-place
print(fruits.count("date"))    # count occurrences

# Safe copy (important!)
copy = fruits[:]       # slice copy
# WARNING: other = fruits  → NOT a copy, just a reference!

point = (3, 4)
x, y  = point                  # unpacking

from collections import namedtuple
Person = namedtuple("Person", ["name", "age", "city"])
alice  = Person("Alice", 30, "NYC")
print(alice.name)   # Alice

person = {"name": "Alice", "age": 30}
person.get("salary", 0)         # default if key missing
person["email"] = "a@mail.com"  # add key
del person["age"]               # delete key

for key, val in person.items():
    print(f"{key}: {val}")

# Dict comprehension
squares = {x: x**2 for x in range(1, 6)}

a = {1, 2, 3, 4, 5}
b = {4, 5, 6, 7, 8}

a | b    # union         {1,2,3,4,5,6,7,8}
a & b    # intersection  {4, 5}
a - b    # difference    {1, 2, 3}
a ^ b    # symmetric diff {1,2,3,6,7,8}

# Remove duplicates from a list
unique = list(set(["a", "b", "a"]))

# Use "with" — file closes automatically
with open("data.txt", "r") as f:
    content = f.read()          # entire file as string

with open("data.txt", "r") as f:
    for line in f:              # memory-efficient
        print(line.strip())

# "w" = write (overwrites), "a" = append
with open("output.txt", "w") as f:
    f.write("Line 1\n")

import csv, json

# Read CSV
with open("sales.csv") as f:
    for row in csv.DictReader(f):
        print(row["product"], row["revenue"])

# JSON read / write
data = {"name": "Alice", "scores": [95, 82, 78]}
with open("data.json", "w") as f:
    json.dump(data, f, indent=4)

with open("data.json") as f:
    loaded = json.load(f)

try:
    x = int(input("Enter a number: "))
    y = 100 / x
except ValueError:
    print("That is not a number!")
except ZeroDivisionError:
    print("Cannot divide by zero!")
else:
    print(f"Result: {y}")   # runs only if NO exception
finally:
    print("This ALWAYS runs")

class InsufficientFundsError(Exception):
    def __init__(self, amount, balance):
        super().__init__(
            f"Cannot withdraw ${amount}; balance is ${balance}")

def withdraw(balance, amount):
    if amount > balance:
        raise InsufficientFundsError(amount, balance)
    return balance - amount

class Dog:
    species = "Canis lupus familiaris"  # class variable

    def __init__(self, name, breed, age):
        self.name  = name     # instance variables
        self.breed = breed
        self.age   = age

    def bark(self):
        return f"{self.name} says: Woof!"

    def __str__(self):
        return f"{self.name} ({self.breed}, {self.age} yrs)"

rex = Dog("Rex", "Labrador", 3)
print(rex)           # Rex (Labrador, 3 yrs)
print(rex.bark())    # Rex says: Woof!

class Animal:
    def __init__(self, name): self.name = name
    def speak(self): raise NotImplementedError

class Cat(Animal):
    def speak(self): return f"{self.name} says: Meow!"

class Duck(Animal):
    def speak(self): return f"{self.name} says: Quack!"

animals = [Cat("Whiskers"), Duck("Donald")]
for a in animals:
    print(a.speak())   # polymorphism — same call, different result

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner    = owner
        self._balance = balance   # _ = private by convention

    @property
    def balance(self): return self._balance

    @balance.setter
    def balance(self, amount):
        if amount < 0: raise ValueError("Cannot be negative")
        self._balance = amount

    def deposit(self, amount):
        self._balance += amount; return self  # enables chaining

acc = BankAccount("Alice", 1000)
acc.deposit(500)   # method chaining
print(acc.balance)  # 1500

import math
print(math.sqrt(16))      # 4.0

from math import sqrt, pi
print(sqrt(25))           # 5.0

import numpy as np          # alias
import pandas as pd

python -m venv myenv           # create
source myenv/bin/activate      # activate (Mac/Linux)
myenv\Scripts\activate         # activate (Windows)
pip install numpy pandas       # install into env
pip freeze > requirements.txt  # save deps
pip install -r requirements.txt # recreate on another machine
deactivate                     # exit

def main():
    print("Running as main program")

if __name__ == "__main__":
    main()
# Imported: __name__ = "module_name" → main() NOT called
# Run directly: __name__ = "__main__" → main() IS called

import numpy as np

a = np.array([1, 2, 3, 4, 5])
b = np.array([[1,2,3], [4,5,6]])   # 2D

np.zeros((3, 4))              # 3×4 of zeros
np.ones((2, 3))               # 2×3 of ones
np.full((3, 3), 7)            # 3×3 filled with 7
np.eye(4)                     # 4×4 identity matrix
np.arange(0, 10, 2)           # [0,2,4,6,8]
np.linspace(0, 1, 5)          # [0, 0.25, 0.5, 0.75, 1.0]
np.random.rand(3, 3)          # 3×3 uniform [0,1)
np.random.randint(1, 100, (4,4)) # random ints

a = np.array([[1,2,3],[4,5,6]])
a.shape     # (2, 3)   — rows, columns
a.ndim      # 2        — number of dimensions
a.size      # 6        — total elements
a.dtype     # int64    — data type
a.astype(np.float64)   # change dtype

a = np.array([[10,20,30],[40,50,60],[70,80,90]])

a[1, 2]       # 60  — row 1, col 2
a[0, :]       # [10 20 30]  — entire first row
a[:, 1]       # [20 50 80]  — entire second column
a[1:, 1:]     # [[50 60][80 90]]

# Boolean indexing
a[a > 50]      # [60 70 80 90]
a[a < 30] = 0  # set elements < 30 to 0

np.where(a > 50, a, -1)  # conditional fill

a = np.array([1, 2, 3, 4])
b = np.array([10, 20, 30, 40])

a + b       # [11 22 33 44]
a * b       # [10 40 90 160]
a ** 2      # [1  4  9  16]
a * 3       # [3 6 9 12]  — broadcasting (scalar)

np.sqrt(a)  # [1.  1.41 1.73 2.]
np.exp(a)   # e^1, e^2, …
np.log(b)   # natural log

data = np.array([[4,7,2,9],[1,8,5,3],[6,0,4,8]])

np.sum(data)           # 57
np.sum(data, axis=0)  # sum each column
np.sum(data, axis=1)  # sum each row
np.mean(data)
np.median(data)
np.std(data)
np.argmin(data)        # index of min (flattened)
np.argmax(data)
np.cumsum([1,2,3,4])  # [1 3 6 10]

a = np.arange(12)
b = a.reshape(3, 4)       # 3 rows, 4 cols
c = b.T                    # transpose → (4, 3)
d = b.flatten()            # back to 1D

x = np.array([1, 2, 3])
y = np.array([4, 5, 6])
np.vstack([x, y])          # vertical stack → (2,3)
np.hstack([x, y])          # horizontal   → (6,)
np.column_stack([x, y])    # as columns   → (3,2)

A = np.array([[1,2],[3,4]])
B = np.array([[5,6],[7,8]])

A @ B                      # matrix multiplication
np.linalg.det(A)           # determinant: -2.0
np.linalg.inv(A)           # inverse

b = np.array([5, 11])
x = np.linalg.solve(A, b)  # solve Ax = b

import pandas as pd
import numpy as np

prices = pd.Series([1.99, 3.49, 0.99],
                   index=["apple", "bread", "banana"])
print(prices["bread"])         # 3.49
print(prices[prices > 1.5])    # boolean filter

df = pd.DataFrame({
    "name":   ["Alice", "Bob", "Carol", "David"],
    "dept":   ["Eng",   "HR",  "Eng",   "Fin"],
    "salary": [90000, 55000, 95000, 70000],
    "years":  [5, 3, 8, 4],
})
df.shape      # (4, 4)
df.info()     # types + nulls
df.describe() # statistics

df["salary"]               # Series
df[["name", "salary"]]      # DataFrame

df.loc[0]                   # row by label
df.loc[1:3, "name":"salary"] # slice
df.iloc[0, 2]               # row 0, col 2 (integer position)

# Boolean filters
df[df["salary"] > 70000]
df[(df["dept"] == "Eng") & (df["years"] > 4)]
df[df["dept"].isin(["Eng", "Fin"])]

df["bonus"] = df["salary"] * 0.10   # add column
df["salary"] = df["salary"] * 1.05   # 5% raise

df["level"] = df["years"].apply(
    lambda y: "Senior" if y >= 5 else "Junior")

df.drop(columns=["bonus"], inplace=True)
df.rename(columns={"years": "experience"}, inplace=True)

df.isnull().sum()                   # count NaN per column
df.dropna()                         # remove rows with ANY NaN
df["salary"].fillna(df["salary"].mean(), inplace=True)
df.fillna(method="ffill")          # forward fill

grp = df.groupby("dept")

grp["salary"].mean()             # mean salary per dept
grp["salary"].agg(["mean","min","max","std"])
grp.size()                          # headcount

# Transform — keep original shape
df["dept_avg"] = df.groupby("dept")["salary"].transform("mean")

merged = pd.merge(employees, departments,
                  on="dept_id", how="inner")
# how: "inner" | "left" | "right" | "outer"

df_all = pd.concat([df1, df2], ignore_index=True)  # stack rows

pivot = sales.pivot_table(
    values="revenue",
    index="month",
    columns="product",
    aggfunc="sum"
)

df = pd.read_csv("data.csv")
df.to_csv("output.csv", index=False)

df = pd.read_excel("data.xlsx", sheet_name="Sheet1")
df.to_excel("output.xlsx", index=False)

df = pd.read_json("data.json")

# .str accessor
df["name"].str.upper()
df["email"].str.contains("@gmail")
df["phone"].str.replace("-", "")

# .dt accessor
df["date"] = pd.to_datetime(df["date_str"])
df["year"]    = df["date"].dt.year
df["weekday"] = df["date"].dt.day_name()

# Resample time series
monthly = df.set_index("date").resample("ME").sum()