Python

# Basic types
name: str = "Alice"
age: int = 30
price: float = 9.99
is_active: bool = True
none_val = None

# Type checking
type(name)        # <class 'str'>
isinstance(age, int)  # True

# String formatting
f"Hello, {name}!"     # f-string (preferred)
"Hello, {}!".format(name)
"%s is %d" % (name, age)

# List (mutable, ordered)
fruits = ["apple", "banana", "cherry"]
fruits.append("date")
fruits[0]          # "apple"
fruits[-1]         # "date"
fruits[1:3]        # ["banana", "cherry"]

# Tuple (immutable)
coords = (10, 20)

# Dict
user = {"name": "Alice", "age": 30}
user["email"] = "[email protected]"
user.get("phone", "N/A")   # Safe access

# Set
tags = {"python", "web", "python"}  # {"python", "web"}

app_name = "inventory-service"
version = 3
is_active = True
latency_ms = 18.73

status_line = f"{app_name} v{version} active={is_active} latency={latency_ms:.1f}ms"
print(status_line)

# Type conversion (common with env vars / user input)
port = int("8080")
timeout = float("2.5")

def handle_event(event: dict) -> str:
    if not event.get("type"):
        return "invalid"

    match event["type"]:
        case "user_created":
            return f"welcome:{event['user_id']}"
        case "payment_failed":
            return f"retry:{event['invoice_id']}"
        case _:
            return "ignored"

print(handle_event({"type": "payment_failed", "invoice_id": "INV-102"}))

prices = [19.99, 5.0, 13.49, 0.0]
nonzero_prices = [p for p in prices if p > 0]
with_tax = [round(p * 1.2, 2) for p in nonzero_prices]

for idx, price in enumerate(with_tax, start=1):
    print(f"#{idx}: ${price}")

# Fast membership checks with set
allowed_roles = {"admin", "editor", "viewer"}
print("admin" in allowed_roles)

from typing import Iterable

def calculate_total(amounts: Iterable[float], discount: float = 0.0) -> float:
    subtotal = sum(amounts)
    discount = min(max(discount, 0.0), 1.0)
    return round(subtotal * (1 - discount), 2)

print(calculate_total([10.0, 20.0, 5.0], discount=0.1))

from dataclasses import dataclass, field
from datetime import datetime

@dataclass
class Order:
    id: str
    customer_email: str
    amount: float
    created_at: datetime = field(default_factory=datetime.utcnow)

order = Order(id="ORD-1", customer_email="[email protected]", amount=49.99)
print(order)

class PaymentError(Exception):
    pass

def charge(amount: float) -> str:
    if amount <= 0:
        raise PaymentError("Amount must be positive")
    return "charged"

try:
    result = charge(-10)
except PaymentError as exc:
    print(f"Payment failed: {exc}
")
else:
    print(result)
finally:
    print("Audit log written")

# Conditional
if x > 0:
    print("positive")
elif x == 0:
    print("zero")
else:
    print("negative")

# Ternary
result = "yes" if condition else "no"

# For loop
for i in range(10):
    print(i)

for i, val in enumerate(["a", "b", "c"]):
    print(i, val)

for k, v in user.items():
    print(k, v)

# While
while count > 0:
    count -= 1

# List comprehension
squares = [x**2 for x in range(10)]
evens = [x for x in range(20) if x % 2 == 0]

# Dict comprehension
word_len = {word: len(word) for word in words}

# Set comprehension
unique_lengths = {len(w) for w in words}

# Generator (lazy — saves memory)
sum_sq = sum(x**2 for x in range(1_000_000))

from pathlib import Path

log_dir = Path("logs")
log_dir.mkdir(exist_ok=True)
log_file = log_dir / "app.log"

with log_file.open("a", encoding="utf-8") as f:
    f.write("service started\n")

print(log_file.resolve())

import json
from pathlib import Path

config = {
    "env": "prod",
    "retries": 3,
    "features": ["search", "alerts"]
}

Path("config.json").write_text(json.dumps(config, indent=2), encoding="utf-8")
loaded = json.loads(Path("config.json").read_text(encoding="utf-8"))
print(loaded["env"])

import requests

url = "https://api.github.com/repos/python/cpython"
resp = requests.get(url, timeout=10)
resp.raise_for_status()
repo = resp.json()

print({
    "name": repo["name"],
    "stars": repo["stargazers_count"]
})

# Basic
def greet(name: str, greeting: str = "Hello") -> str:
    return f"{greeting}, {name}!"

# *args and **kwargs
def log(*args, **kwargs):
    print(args, kwargs)

log(1, 2, 3, level="info")  # (1,2,3) {'level': 'info'}

# Lambda
double = lambda x: x * 2

# Type hints (Python 3.9+)
def process(items: list[int]) -> dict[str, int]:
    return {"sum": sum(items), "count": len(items)}

from dataclasses import dataclass

@dataclass
class Point:
    x: float
    y: float

    def distance(self) -> float:
        return (self.x**2 + self.y**2) ** 0.5

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

    def speak(self) -> str:
        raise NotImplementedError

class Dog(Animal):
    def speak(self) -> str:
        return f"{self.name} says Woof!"

dog = Dog("Rex")
dog.speak()  # "Rex says Woof!"

def normalize_email(email: str) -> str:
    return email.strip().lower()

def test_normalize_email():
    assert normalize_email("  [email protected] ") == "[email protected]"

from unittest.mock import patch
import requests

def fetch_status(url: str) -> int:
    r = requests.get(url, timeout=5)
    return r.status_code

@patch("requests.get")
def test_fetch_status(mock_get):
    mock_get.return_value.status_code = 200
    assert fetch_status("https://example.com") == 200

# Install tools
# pip install ruff black

# Format code
# black .

# Lint and auto-fix simple issues
# ruff check . --fix

# Create and activate venv
# python -m venv .venv
# source .venv/bin/activate  # Linux/macOS
# .venv\Scripts\activate     # Windows

# Install deps
# pip install requests pytest

# Freeze exact versions
# pip freeze > requirements.txt

import argparse

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--name", default="world")
    args = parser.parse_args()
    print(f"Hello, {args.name}!")

if __name__ == "__main__":
    main()

try:
    result = 10 / 0
except ZeroDivisionError as e:
    print(f"Error: {e}")
except (TypeError, ValueError) as e:
    print(f"Type/Value error: {e}")
else:
    print("No error")     # Runs if no exception
finally:
    print("Always runs")  # Cleanup code

# Raise custom exception
class ValidationError(Exception):
    pass

raise ValidationError("Invalid input")

# Context manager
with open("file.txt") as f:
    data = f.read()        # File auto-closed