name = "Alice"
age = 25
height = 5.6
is_student = True

print(name, age, height, is_student)

x = 42
y = -100
big = 1_000_000   # underscores for readability
binary = 0b1010   # binary literal → 10
hexval = 0xFF    # hexadecimal → 255

print(type(x))   # <class 'int'>
print(big)        # 1000000

pi = 3.14159
sci = 1.5e10     # scientific notation: 15000000000.0
neg = -2.7

print(type(pi))  # <class 'float'>

# Floating point precision caveat:
print(0.1 + 0.2)   # 0.30000000000000004 (IEEE 754)

s1 = "Hello, World!"
s2 = 'Single quotes work too'
s3 = """Triple-quoted strings
span multiple lines"""

# Escape sequences
s4 = "Line 1\nLine 2"     # \n = newline
s5 = "Tab\there"         # \t = tab
s6 = "Quote: \"hi\""      # \" = literal quote

# f-strings (Python 3.6+) — the preferred way
name = "Bob"
age = 30
msg = f"My name is {name} and I am {age} years old"
print(msg)

t = True
f = False

print(type(t))   # <class 'bool'>
print(True + True)  # 2 — bools are ints (True=1, False=0)

# Truthiness — these evaluate as False:
# 0, 0.0, "", [], {}, None
print(bool(0))    # False
print(bool(""))   # False
print(bool(42))   # True

# Explicit conversion (casting)
x = int("42")        # str → int: 42
y = float("3.14")    # str → float: 3.14
z = str(100)          # int → str: "100"
b = bool(1)           # int → bool: True

# Getting user input (always returns str)
name = input("Enter your name: ")
age  = int(input("Enter your age: "))  # must cast!
print(f"Hello {name}, you are {age}")

x = 10
print(type(x))   # <class 'int'>
x = "hello"
print(type(x))   # <class 'str'>
x = [1, 2, 3]
print(type(x))   # <class 'list'>

a, b = 17, 5

print(a + b)    # Addition:       22
print(a - b)    # Subtraction:    12
print(a * b)    # Multiplication: 85
print(a / b)    # Division:       3.4   (always float!)
print(a // b)   # Floor division: 3     (truncates decimal)
print(a % b)    # Modulo:         2     (remainder)
print(a ** b)   # Exponentiation: 1419857

x = 10
print(x == 10)   # Equal:              True
print(x != 5)    # Not equal:          True
print(x > 8)     # Greater than:       True
print(x < 8)     # Less than:          False
print(x >= 10)   # Greater or equal:   True
print(x <= 9)    # Less or equal:      False

# Chained comparisons (Pythonic)
age = 20
print(18 <= age <= 65)    # True — very readable!

a = True
b = False

print(a and b)   # False — both must be True
print(a or b)    # True  — at least one True
print(not a)     # False — flips the boolean

# Short-circuit evaluation
x = 0
result = x or "default"
print(result)    # "default" — x is falsy, so "or" returns right side

name = "Alice"
greeting = name and f"Hello, {name}"
print(greeting)  # "Hello, Alice" — name is truthy

x = 10
x += 5    # x = x + 5  → 15
x -= 3    # x = x - 3  → 12
x *= 2    # x = x * 2  → 24
x //= 4   # x = x // 4 → 6
x **= 2   # x = x ** 2 → 36
print(x)  # 36

# Multiple assignment
a, b, c = 1, 2, 3
x = y = z = 0   # all set to 0

# Swap variables (Pythonic!)
a, b = b, a

# Identity: is / is not (checks memory identity)
x = [1, 2, 3]
y = x
z = [1, 2, 3]

print(x is y)      # True  — same object in memory
print(x is z)      # False — same values, different objects
print(x == z)      # True  — same values

# Membership: in / not in
fruits = ["apple", "banana", "cherry"]
print("banana" in fruits)     # True
print("grape" not in fruits)  # True

print(2 + 3 * 4)      # 14 (multiplication first)
print((2 + 3) * 4)    # 20 (parentheses override)
print(2 ** 3 ** 2)    # 512 (** is right-associative: 2**(3**2))

temperature = 35

if temperature > 30:
    print("It's hot outside!")
    print("Stay hydrated.")

age = 16

if age >= 18:
    print("You can vote.")
else:
    years_left = 18 - age
    print(f"You need to wait {years_left} more years.")

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}")

username = "admin"
password = "secret123"

if username == "admin":
    if password == "secret123":
        print("Access granted!")
    else:
        print("Wrong password.")
else:
    print("Unknown user.")

age = 20
status = "adult" if age >= 18 else "minor"
print(status)   # adult

# Equivalent to:
if age >= 18:
    status = "adult"
else:
    status = "minor"

command = "quit"

match command:
    case "start":
        print("Starting...")
    case "stop" | "quit":
        print("Stopping.")
    case _:
        print("Unknown command")

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

for fruit in fruits:
    print(f"I like {fruit}")

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

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

# range(start, stop)
for i in range(1, 6):
    print(i, end=" ")   # 1 2 3 4 5

# range(start, stop, step)
for i in range(0, 20, 5):
    print(i, end=" ")   # 0 5 10 15

# Counting backwards
for i in range(10, 0, -1):
    print(i, end=" ")   # 10 9 8 7 6 5 4 3 2 1

# enumerate gives index + value
animals = ["cat", "dog", "bird"]
for i, animal in enumerate(animals, start=1):
    print(f"{i}. {animal}")
# 1. cat  2. dog  3. bird

# zip iterates multiple lists simultaneously
names   = ["Alice", "Bob", "Carol"]
scores  = [95, 87, 92]

for name, score in zip(names, scores):
    print(f"{name}: {score}")

count = 0
while count < 5:
    print(f"Count: {count}")
    count += 1

# Interactive while loop
while True:
    answer = input("Say 'quit' to exit: ")
    if answer == "quit":
        break
    print(f"You typed: {answer}")

# break — exits the loop immediately
for i in range(10):
    if i == 5:
        break
    print(i, end=" ")  # 0 1 2 3 4

# continue — skips current iteration
for i in range(10):
    if i % 2 == 0:
        continue   # skip even numbers
    print(i, end=" ")  # 1 3 5 7 9

# pass — does nothing, placeholder
for i in range(3):
    pass   # useful for empty loops/stubs

# Standard way
squares = []
for i in range(1, 6):
    squares.append(i ** 2)

# List comprehension — same thing, one line!
squares = [i ** 2 for i in range(1, 6)]
print(squares)   # [1, 4, 9, 16, 25]

# With a filter
evens = [x for x in range(20) if x % 2 == 0]
print(evens)     # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

def greet():
    """Prints a greeting message."""
    print("Hello! Welcome to Python.")

greet()     # Call the function
greet()     # Can be called many times

def greet(name, greeting="Hello"):   # default parameter
    print(f"{greeting}, {name}!")

greet("Alice")               # Hello, Alice!
greet("Bob", "Good morning") # Good morning, Bob!
greet(greeting="Hi", name="Carol")  # keyword args

def add(a, b):
    return a + b

result = add(3, 5)
print(result)   # 8

# Return multiple values (as a tuple)
def min_max(numbers):
    return min(numbers), max(numbers)

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

# *args: variable positional arguments (tuple)
def total(*numbers):
    return sum(numbers)

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

# **kwargs: variable keyword arguments (dict)
def describe(**info):
    for key, value in info.items():
        print(f"{key}: {value}")

describe(name="Alice", age=30, city="Paris")

x = 10   # global variable

def my_func():
    y = 20   # local — only exists inside function
    print(x)  # can READ global
    print(y)

my_func()
# print(y)  # NameError — y doesn't exist here

# To MODIFY a global inside a function:
count = 0
def increment():
    global count
    count += 1

increment()
print(count)   # 1

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

add = lambda a, b: a + b
print(add(3, 4))   # 7

# Most useful with map(), filter(), sorted()
numbers = [5, 2, 8, 1, 9]
sorted_nums = sorted(numbers, key=lambda x: -x)
print(sorted_nums)   # [9, 8, 5, 2, 1]

def factorial(n):
    """Returns n! recursively."""
    if n <= 1:
        return 1
    return n * factorial(n - 1)

print(factorial(5))   # 120 (5*4*3*2*1)
print(factorial(10))  # 3628800

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

# Indexing (0-based, negative counts from end)
print(fruits[0])    # apple
print(fruits[-1])   # cherry

# Slicing [start:stop:step]
print(fruits[0:2])  # ['apple', 'banana']
print(fruits[::-1]) # reversed: ['cherry', 'banana', 'apple']

# Modifying
fruits.append("date")       # add to end
fruits.insert(1, "avocado") # insert at index 1
fruits.remove("banana")    # remove first occurrence
popped = fruits.pop()        # remove and return last item

# Useful methods
nums = [3, 1, 4, 1, 5, 9]
nums.sort()                  # in-place sort
print(sorted(nums))         # returns new sorted list
print(len(nums))            # 6
print(nums.count(1))       # 2

point = (3, 7)
rgb   = (255, 128, 0)

x, y = point         # tuple unpacking
r, g, b = rgb

# Tuples are faster and use less memory than lists
# Use tuples for data that shouldn't change
# point[0] = 5  # TypeError: tuple is immutable

single = (42,)      # single-element tuple needs trailing comma

person = {
    "name": "Alice",
    "age": 30,
    "city": "London"
}

# Access
print(person["name"])           # Alice
print(person.get("phone", "N/A")) # N/A (safe get)

# Modify
person["age"] = 31
person["email"] = "alice@example.com"
del person["city"]

# Iterate
for key, value in person.items():
    print(f"{key}: {value}")

# Dictionary comprehension
squares = {x: x**2 for x in range(1, 6)}
# {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

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

print(a | b)   # Union:        {1, 2, 3, 4, 5, 6}
print(a & b)   # Intersection: {3, 4}
print(a - b)   # Difference:   {1, 2}
print(a ^ b)   # Sym. diff:    {1, 2, 5, 6}

# Deduplicate a list
nums = [1, 2, 2, 3, 3, 3]
unique = list(set(nums))   # [1, 2, 3]

s = set()   # empty set (NOT {} — that's a dict!)
s.add(42)

s = "Hello, World!"

print(s[0])       # H
print(s[-1])      # !
print(s[7:12])    # World
print(s[::2])     # Hlo ol!
print(s[::-1])    # !dlroW ,olleH  (reversed)
print(len(s))     # 13

s = "  Hello, World!  "

print(s.strip())         # "Hello, World!" (removes whitespace)
print(s.upper())         # "  HELLO, WORLD!  "
print(s.lower())         # "  hello, world!  "
print(s.title())         # "  Hello, World!  "

t = "Hello, World!"
print(t.replace("World", "Python"))  # Hello, Python!
print(t.split(", "))               # ['Hello', 'World!']
print(t.startswith("Hello"))       # True
print(t.endswith("!"))             # True
print(t.find("World"))             # 7
print(t.count("l"))                # 3

words = ["one", "two", "three"]
print(" | ".join(words))            # one | two | three

name = "Alice"
score = 98.5678
items = 1000000

# Basic
print(f"Name: {name}")

# Number formatting
print(f"Score: {score:.2f}")     # 2 decimal places
print(f"Items: {items:,}")       # thousands separator
print(f"Score: {score:10.2f}")  # width 10, right-aligned

# Padding and alignment
print(f"{'Left':<10}")           # left-align in 10 chars
print(f"{'Right':>10}")          # right-align
print(f"{'Center':^10}")         # center

# Expressions in f-strings
print(f"2 + 2 = {2 + 2}")
print(f"Upper: {name.upper()}")

# Raw strings: backslash is literal (useful for regex and paths)
path = r"C:\Users\Alice\Documents"
print(path)   # C:\Users\Alice\Documents

# Bytes: prefix b""
b = b"Hello"
print(type(b))        # <class 'bytes'>
print(b.decode())     # "Hello" — bytes to str
print("Hello".encode()) # b'Hello' — str to bytes

import re

text = "My email is alice@example.com and bob@test.org"

# Find all email addresses
emails = re.findall(r'\b[\w.+-]+@[\w-]+\.\w+\b', text)
print(emails)   # ['alice@example.com', 'bob@test.org']

# Check if a string is a valid phone number
phone = "123-456-7890"
match = re.match(r'^\d{3}-\d{3}-\d{4}$', phone)
print(bool(match))   # True

class Dog:
    """A simple Dog class."""

    species = "Canis lupus familiaris"   # class variable

    def __init__(self, name, age):     # constructor
        self.name = name               # instance variable
        self.age  = age

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

    def __str__(self):                 # string representation
        return f"Dog({self.name}, {self.age})"

# Creating instances
rex  = Dog("Rex", 3)
luna = Dog("Luna", 5)

rex.bark()          # Rex says: Woof!
print(luna)         # Dog(Luna, 5)
print(rex.species)  # Canis lupus familiaris

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

    def speak(self):
        raise NotImplementedError

    def __str__(self):
        return f"{self.__class__.__name__}({self.name})"


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


class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)   # call parent __init__
        self.breed = breed

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


animals = [Cat("Whiskers"), Dog("Rex", "Labrador")]
for animal in animals:
    print(animal.speak())   # polymorphism!

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

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

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

    def deposit(self, amount):
        self._balance += amount

    def withdraw(self, amount):
        if amount > self._balance:
            raise ValueError("Insufficient funds")
        self._balance -= amount

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

class Vector:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __add__(self, other):    # +
        return Vector(self.x + other.x, self.y + other.y)

    def __len__(self):           # len()
        return 2

    def __repr__(self):          # repr()
        return f"Vector({self.x}, {self.y})"

v1 = Vector(1, 2)
v2 = Vector(3, 4)
print(v1 + v2)     # Vector(4, 6)
print(len(v1))     # 2

# Writing a file
with open("greetings.txt", "w") as f:
    f.write("Hello, World!\n")
    f.write("Python is awesome!\n")

# Reading entire file
with open("greetings.txt", "r") as f:
    content = f.read()
    print(content)

# Reading line by line
with open("greetings.txt", "r") as f:
    for line in f:
        print(line.strip())

# Appending to a file
with open("greetings.txt", "a") as f:
    f.write("Added a new line!\n")

import csv
import json

# CSV writing
with open("data.csv", "w", newline="") as f:
    writer = csv.writer(f)
    writer.writerow(["Name", "Score"])
    writer.writerow(["Alice", 95])

# CSV reading
with open("data.csv") as f:
    for row in csv.DictReader(f):
        print(row)  # {'Name': 'Alice', 'Score': '95'}

# JSON serialization
data = {"name": "Alice", "scores": [95, 87, 92]}

with open("data.json", "w") as f:
    json.dump(data, f, indent=2)

with open("data.json") as f:
    loaded = json.load(f)
    print(loaded["name"])   # Alice

# try / except / else / finally
try:
    num = int(input("Enter a number: "))
    result = 100 / num
except ValueError:
    print("That's not a valid number!")
except ZeroDivisionError:
    print("Can't divide by zero!")
except Exception as e:
    print(f"Unexpected error: {e}")
else:
    print(f"Result: {result}")   # runs only if no exception
finally:
    print("This always runs")    # cleanup code

class InsufficientFundsError(Exception):
    """Raised when a withdrawal exceeds the balance."""
    def __init__(self, amount, balance):
        self.amount  = amount
        self.balance = balance
        super().__init__(
            f"Cannot withdraw {amount}; balance is {balance}"
        )

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

try:
    withdraw(100, 200)
except InsufficientFundsError as e:
    print(e)   # Cannot withdraw 200; balance is 100

import math
import os
import sys
from datetime import datetime, timedelta
from random import randint, choice
import json as j   # alias

print(math.pi)          # 3.141592...
print(math.sqrt(16))   # 4.0
print(math.floor(3.9)) # 3

now = datetime.now()
print(now.strftime("%Y-%m-%d %H:%M"))

tomorrow = now + timedelta(days=1)
print(tomorrow)

"""Custom math utilities module."""

def is_prime(n):
    if n < 2: return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0: return False
    return True

def celsius_to_fahrenheit(c):
    return c * 9/5 + 32

PI = 3.14159265358979

from mathutils import is_prime, celsius_to_fahrenheit

print(is_prime(17))              # True
print(celsius_to_fahrenheit(100))  # 212.0

pip install requests          # HTTP requests
pip install numpy             # numerical computing
pip install pandas            # data analysis
pip install matplotlib        # plotting
pip install flask             # web framework
pip install pytest            # testing

pip list                      # see installed packages
pip freeze > requirements.txt # export dependencies
pip install -r requirements.txt  # install from file

# Create a virtual environment
python -m venv venv

# Activate (macOS/Linux)
source venv/bin/activate

# Activate (Windows)
venv\Scripts\activate

# Deactivate
deactivate

task_manager/
├── main.py          # entry point & CLI loop
├── task.py          # Task and TaskManager classes
├── storage.py       # JSON file persistence
└── tasks.json       # auto-created data file

from datetime import datetime
import uuid

class Task:
    """Represents a single task."""

    def __init__(self, title, priority="medium"):
        self.id        = str(uuid.uuid4())[:8]
        self.title     = title
        self.priority  = priority
        self.done      = False
        self.created   = datetime.now().isoformat()

    def complete(self):
        self.done = True

    def to_dict(self):
        return vars(self)

    @classmethod
    def from_dict(cls, data):
        t = cls(data["title"], data["priority"])
        t.id      = data["id"]
        t.done    = data["done"]
        t.created = data["created"]
        return t

    def __str__(self):
        status = "✓" if self.done else "○"
        return f"[{status}] {self.id} | {self.title} ({self.priority})"


class TaskManager:
    """Manages a collection of tasks."""

    def __init__(self):
        self.tasks = []

    def add(self, title, priority="medium"):
        task = Task(title, priority)
        self.tasks.append(task)
        return task

    def complete(self, task_id):
        task = self._find(task_id)
        if task:
            task.complete()
            return task
        raise ValueError(f"Task {task_id} not found")

    def delete(self, task_id):
        task = self._find(task_id)
        if task:
            self.tasks.remove(task)
        else:
            raise ValueError(f"Task {task_id} not found")

    def filter(self, status="all"):
        if status == "done":
            return [t for t in self.tasks if t.done]
        elif status == "pending":
            return [t for t in self.tasks if not t.done]
        return self.tasks

    def _find(self, task_id):
        return next((t for t in self.tasks if t.id == task_id), None)

import json
from pathlib import Path
from task import Task

FILE = Path("tasks.json")

def load():
    if not FILE.exists():
        return []
    with FILE.open() as f:
        return [Task.from_dict(d) for d in json.load(f)]

def save(tasks):
    with FILE.open("w") as f:
        json.dump([t.to_dict() for t in tasks], f, indent=2)

from task import TaskManager
import storage

def show_menu():
    print("\n── Task Manager ──────────────")
    print("  1. Add task")
    print("  2. List tasks")
    print("  3. Complete task")
    print("  4. Delete task")
    print("  5. Quit")
    print("──────────────────────────────")

def main():
    mgr = TaskManager()
    mgr.tasks = storage.load()

    while True:
        show_menu()
        choice = input("Choice: ").strip()

        if choice == "1":
            title    = input("Task title: ")
            priority = input("Priority (low/medium/high): ") or "medium"
            task = mgr.add(title, priority)
            print(f"Added: {task}")

        elif choice == "2":
            filt = input("Filter (all/pending/done): ") or "all"
            tasks = mgr.filter(filt)
            if not tasks:
                print("No tasks found.")
            else:
                for t in tasks:
                    print(" ", t)

        elif choice == "3":
            tid = input("Task ID to complete: ")
            try:
                t = mgr.complete(tid)
                print(f"Completed: {t}")
            except ValueError as e:
                print(f"Error: {e}")

        elif choice == "4":
            tid = input("Task ID to delete: ")
            try:
                mgr.delete(tid)
                print("Deleted.")
            except ValueError as e:
                print(f"Error: {e}")

        elif choice == "5":
            storage.save(mgr.tasks)
            print("Goodbye! Tasks saved.")
            break

        storage.save(mgr.tasks)   # auto-save after every action


if __name__ == "__main__":
    main()