Phase 1: Python Fast Track

# What type is this object?
type("hello")          # <class 'str'>
type([1, 2, 3])        # <class 'list'>
type(42)               # <class 'int'>

# What can I do with this object?
dir("hello")          # shows ALL string methods

# What does this method do?
help("".split)         # full docstring

# Is this what I think it is?
isinstance(42, int)    # True
isinstance("hi", str)  # True

# Quick test: does this list method modify in place or return?
nums = [3, 1, 2]
result = nums.sort()
print(result)           # None — sort() modifies in place!
print(nums)             # [1, 2, 3] — the list changed

# Without hints — valid Python, but hard to read at scale
def process(data, multiplier):
    return data * multiplier

# With hints — self-documenting
def process(data: list[int], multiplier: float) -> list[float]:
    return [x * multiplier for x in data]

# Common built-in types
name:    str
age:     int
score:   float
active:  bool
items:   list[str]
scores:  dict[str, int]
maybe:   str | None        # Python 3.10+ union syntax

# Numbers
x  = 42          # int — arbitrary precision!
y  = 3.14        # float
z  = 2 + 3j      # complex (rarely needed)

# Strings — immutable sequences of characters
s1 = 'single quotes'
s2 = "double quotes"  # same thing
s3 = """triple quotes
span multiple lines"""

# Booleans — note the capitalization
t = True
f = False
print(type(True))   # <class 'bool'>
print(int(True))    # 1 — bool is a subclass of int!

# None — Python's null
result = None
print(result is None)  # True (use 'is', not '==')

# Truthiness — Python evaluates many things as bool
bool(0)       # False
bool("")      # False — empty string is falsy
bool([])      # False — empty list is falsy
bool(None)    # False
bool(42)      # True — any non-zero number
bool("hi")    # True — any non-empty string

# Basic function — no access modifiers, no return type required
def add(a: int, b: int) -> int:
    return a + b

# Default arguments (like Java overloading, but simpler)
def greet(name: str, greeting: str = "Hello") -> str:
    return f"{greeting}, {name}!"

greet("Jude")                   # "Hello, Jude!"
greet("Jude", "What's good")    # "What's good, Jude!"

# Keyword arguments — call by name, any order
greet(greeting="Yo", name="Jude")  # "Yo, Jude!"

# Multiple return values (Java can't do this natively)
def min_max(numbers: list[int]) -> tuple[int, int]:
    return min(numbers), max(numbers)

lo, hi = min_max([3, 1, 7, 2])   # lo=1, hi=7

# Functions are objects — store them in variables
def shout(text: str) -> str:
    return text.upper() + "!!!"

transform = shout         # no () — storing the function itself
print(transform("hello"))  # "HELLO!!!"

# Pass functions as arguments
def apply_to_list(items: list, func) -> list:
    return [func(item) for item in items]

words = ["python", "java", "rust"]
apply_to_list(words, str.upper)
# ['PYTHON', 'JAVA', 'RUST']

# Lambda — anonymous function for simple one-liners
# (like Java's lambda but more concise)
square = lambda x: x ** 2
print(square(5))              # 25

# Sort by custom key using lambda
players = [("Jude", 42), ("Ana", 87), ("Max", 15)]
players.sort(key=lambda p: p[1], reverse=True)
# [('Ana', 87), ('Jude', 42), ('Max', 15)]

# List — ordered, mutable, allows duplicates
skills = ["java", "python", "unity"]
skills.append("rust")
skills[0]           # "java"
skills[-1]          # "rust" — negative indexing!

# Tuple — ordered, IMMUTABLE, allows duplicates
point = (3.0, 7.5)   # x, y coordinate — won't change
x, y = point         # unpack into variables

# Dict — key-value pairs, ordered (Python 3.7+)
player = {"name": "Jude", "hp": 100, "level": 5}
player["hp"]         # 100
player.get("mp", 0)  # 0 — safe access with default

# Set — unordered, unique values only
seen = {"a", "b", "a", "c"}
print(seen)           # {'a', 'b', 'c'} — deduplicated

# 1. Transform every item
names   = ["jude", "ana", "max"]
upper   = [n.upper() for n in names]
# ['JUDE', 'ANA', 'MAX']

# 2. Filter items
numbers  = [1, 2, 3, 4, 5, 6]
evens    = [n for n in numbers if n % 2 == 0]
# [2, 4, 6]

# 3. Transform and filter together
long_upper = [n.upper() for n in names if len(n) > 3]
# ['JUDE']

# 4. Dict comprehension — same idea, for dicts
scores   = {"jude": 85, "ana": 92, "max": 78}
passing  = {k: v for k, v in scores.items() if v >= 80}
# {'jude': 85, 'ana': 92}

# 5. Set comprehension — unique results
words    = ["python", "PYTHON", "Java", "java"]
unique_lower = {w.lower() for w in words}
# {'python', 'java'}

# 6. Flatten nested list
matrix   = [[1,2], [3,4], [5,6]]
flat     = [x for row in matrix for x in row]
# [1, 2, 3, 4, 5, 6]

# Basic tuple unpacking
x, y = 10, 20
first, second, third = ["a", "b", "c"]

# Swap without temp variable
a, b = 1, 2
a, b = b, a    # a=2, b=1 — Pythonic!

# * operator — collect the rest
first, *rest     = [1, 2, 3, 4, 5]
# first=1, rest=[2, 3, 4, 5]

*head, last      = [1, 2, 3, 4, 5]
# head=[1,2,3,4], last=5

first, *mid, last = [1, 2, 3, 4, 5]
# first=1, mid=[2,3,4], last=5

# Unpack in for loop
pairs = [("Jude", 85), ("Ana", 92), ("Max", 78)]
for name, score in pairs:
    print(f"{name}: {score}")

# Unpack dict into function
def make_player(name, hp, level):
    return f"{name} (HP:{hp} LVL:{level})"

data = {"name": "Jude", "hp": 100, "level": 5}
make_player(**data)   # ** unpacks dict as kwargs

items = [0, 1, 2, 3, 4, 5, 6, 7]

items[2:5]        # [2, 3, 4]     — index 2 up to (not including) 5
items[:3]         # [0, 1, 2]     — start to index 3
items[5:]         # [5, 6, 7]     — index 5 to end
items[-3:]        # [5, 6, 7]     — last 3 items
items[::-1]       # [7,6,5,4,3,2,1,0] — reverse!
items[::2]        # [0, 2, 4, 6]  — every 2nd item
items[1:6:2]      # [1, 3, 5]     — every 2nd from 1 to 6

# Works on strings too!
s = "Hello, World!"
s[7:12]     # "World"
s[::-1]     # "!dlroW ,olleH"

# Basic embedding
name  = "Jude"
level = 5
f"{name} is level {level}"     # "Jude is level 5"

# Expressions inside braces
f"{2 ** 10}"                    # "1024"
f"{name.upper()}"               # "JUDE"
f"{level * 100} XP to next"    # "500 XP to next"

# Number formatting
score = 98765.4321
f"{score:,.2f}"                 # "98,765.43"
f"{score:>12.1f}"               # right-align in 12 chars
f"{level:03d}"                  # "005" — zero-padded

# Debug trick — Python 3.8+ self-documenting
x = 42
f"{x = }"                       # "x = 42"  ← prints name AND value

# Multiline f-strings
report = (f"Player: {name}\n"
          f"Level:  {level}\n"
          f"Score:  {score:,.0f}")

s = "  Hello, World!  "

# Clean up
s.strip()          # "Hello, World!"     — remove whitespace
s.lower()          # "  hello, world!  " — lowercase
s.upper()          # "  HELLO, WORLD!  "

# Search
s.startswith("  H") # True
s.endswith("!  ")  # True
s.find("World")     # 9 (index), or -1 if not found
"World" in s       # True — membership test

# Transform
s.replace("World", "Python")  # "  Hello, Python!  "

# Split and join
"a,b,c".split(",")             # ['a', 'b', 'c']
", ".join(["a", "b", "c"])    # "a, b, c"

# Lines
"a\nb\nc".splitlines()          # ['a', 'b', 'c']

# *args collects extra positional arguments into a TUPLE
def total(*numbers: int) -> int:
    return sum(numbers)

total(1, 2)              # 3
total(1, 2, 3, 4, 5)    # 15
total()                  # 0 — empty tuple, sum=0

# Mix required and *args
def log(level: str, *messages: str) -> None:
    for msg in messages:
        print(f"[{level}] {msg}")

log("INFO", "Server started", "Port: 8000")
# [INFO] Server started
# [INFO] Port: 8000

# **kwargs collects extra keyword arguments into a DICT
def create_player(name: str, **stats) -> dict:
    return {"name": name, **stats}

create_player("Jude", hp=100, mp=50, level=5)
# {'name': 'Jude', 'hp': 100, 'mp': 50, 'level': 5}

# The full signature order (must always be in this order):
def full_example(
    pos1,               # required positional
    pos2,               # required positional
    default="value",   # optional with default
    *args,              # extra positional → tuple
    **kwargs            # extra keyword → dict
):
    print(pos1, pos2, default, args, kwargs)

# You see this CONSTANTLY in frameworks:
# def __init__(self, *args, **kwargs):
#     super().__init__(*args, **kwargs)

class Character:
    # Class variable — shared across ALL instances
    game_version: str = "1.0"

    # __init__ is Python's constructor
    def __init__(self, name: str, hp: int = 100) -> None:
        self.name = name   # instance variable
        self.hp   = hp
        self._alive = True  # _ prefix = "private by convention"

    # Regular method — always takes self
    def take_damage(self, amount: int) -> None:
        self.hp = max(0, self.hp - amount)
        if self.hp == 0:
            self._alive = False

    # @property — getter without calling .get_hp()
    @property
    def is_alive(self) -> bool:
        return self._alive

    # __str__ — what print(obj) shows (like toString())
    def __str__(self) -> str:
        status = "alive" if self._alive else "dead"
        return f"{self.name} [{self.hp} HP] ({status})"

# Usage
hero = Character("Jude")
hero.take_damage(30)
print(hero)             # Jude [70 HP] (alive)
print(hero.is_alive)    # True — property, not method call

# Import whole module — access via namespace
import math
math.sqrt(16)       # 4.0
math.pi             # 3.141592...

# Import specific names — no namespace needed
from math import sqrt, pi, ceil
sqrt(25)            # 5.0 — direct access

# Import with alias — long module names
import datetime as dt
dt.datetime.now()

# Your own modules: just other .py files
# my_utils.py in same folder
from my_utils import format_name

# __name__ == "__main__" guard
# Code inside only runs when THIS file is the entry point
# Not when it's imported by another module
if __name__ == "__main__":
    print("Running directly")

from pathlib import Path
from collections import Counter
import json, datetime

# pathlib — read all .py files in current directory
py_files = list(Path(".").glob("**/*.py"))

# Counter — most common words
words   = ["python", "java", "python", "rust", "python"]
counts  = Counter(words)
counts.most_common(2)  # [('python', 3), ('java', 1)]

# json — instant serialization
data    = {"name": "Jude", "skills": ["python", "unity"]}
s       = json.dumps(data, indent=2)
back    = json.loads(s)

# datetime — time arithmetic
now     = datetime.datetime.now()
in_week = now + datetime.timedelta(days=7)
print(f"One week from now: {in_week:%Y-%m-%d}")

from dataclasses import dataclass, field
from enum        import Enum, auto
from pathlib     import Path
import json, datetime

class Priority(Enum):
    LOW    = auto()
    MEDIUM = auto()
    HIGH   = auto()

@dataclass
class Task:
    title:     str
    priority:  Priority    = Priority.MEDIUM
    done:      bool         = False
    created:   str          = field(
        default_factory=lambda: datetime.datetime.now().isoformat()
    )

    def complete(self) -> None:
        self.done = True

    def __str__(self) -> str:
        status = "✓" if self.done else "○"
        return f"[{status}] {self.title} ({self.priority.name})"

class TaskManager:
    def __init__(self, filepath: str = "tasks.json"):
        self._path  = Path(filepath)
        self._tasks: list[Task] = self._load()

    def add(self, title: str, priority: Priority = Priority.MEDIUM) -> Task:
        task = Task(title, priority)
        self._tasks.append(task)
        self._save()
        return task

    def pending(self) -> list[Task]:
        return [t for t in self._tasks if not t.done]

    def complete(self, title: str) -> bool:
        matches = [t for t in self._tasks if title.lower() in t.title.lower()]
        if not matches: return False
        matches[0].complete()
        self._save()
        return True

    def _save(self) -> None:
        data = [
            {"title": t.title, "priority": t.priority.name,
             "done": t.done,  "created": t.created}
            for t in self._tasks
        ]
        self._path.write_text(json.dumps(data, indent=2))

    def _load(self) -> list[Task]:
        if not self._path.exists(): return []
        data = json.loads(self._path.read_text())
        return [
            Task(d["title"], Priority[d["priority"]], d["done"], d["created"])
            for d in data
        ]

if __name__ == "__main__":
    mgr = TaskManager()
    mgr.add("Learn Python Phase 2", Priority.HIGH)
    mgr.add("Finish Death Road prototype", Priority.HIGH)
    mgr.add("Read The Pragmatic Programmer")
    for task in mgr.pending():
        print(task)