Python¶

# Variables and types (dynamic typing)
name = "Python"              # str
version = 3.12               # int
is_awesome = True            # bool
items = [1, 2, 3]            # list (mutable)
coords = (10, 20)            # tuple (immutable)
unique = {1, 2, 3}           # set
config = {"key": "value"}    # dict

# String formatting (use f-strings)
user = "Alice"
age = 30
message = f"{user} is {age} years old"  # Modern way
# Avoid: message = user + " is " + str(age)  # Old way

# Conditionals
if age >= 18:
    print("Adult")
elif age >= 13:
    print("Teen")
else:
    print("Child")

# Loops
for item in items:
    print(item)

for i, item in enumerate(items):  # With index
    print(f"{i}: {item}")

# Comprehensions (Pythonic way)
squares = [x**2 for x in range(10)]
evens = [x for x in range(10) if x % 2 == 0]
squared_dict = {x: x**2 for x in range(5)}

# Functions
def greet(name: str, age: int = 0) -> str:  # Type hints (recommended)
    """Greet user with name and optional age."""
    return f"Hello, {name}! Age: {age}"

# Lambda (anonymous functions)
double = lambda x: x * 2
numbers = [1, 2, 3, 4]
doubled = list(map(double, numbers))

# Classes
class Person:
    def __init__(self, name: str, age: int):
        self.name = name
        self.age = age

    def greet(self) -> str:
        return f"Hi, I'm {self.name}"

    @property  # Getter
    def is_adult(self) -> bool:
        return self.age >= 18

# Context managers (automatic cleanup)
with open("file.txt", "r") as f:
    content = f.read()  # File closed automatically

# Exception handling
try:
    result = 10 / 0
except ZeroDivisionError as e:
    print(f"Error: {e}")
finally:
    print("Always runs")

# Virtual environments (isolate project dependencies)
# Use uv (modern, fast) or venv (standard library)
uv venv                       # Create virtual env with uv
source .venv/bin/activate     # Activate (Linux/macOS)
.venv\Scripts\activate        # Activate (Windows)

# Package management
uv pip install requests       # Install package with uv
uv pip install -r requirements.txt  # Install from file
uv pip freeze > requirements.txt    # Save current packages

# Or use pip (slower but standard)
pip install requests
pip install --upgrade package
pip uninstall package

# Web scraping pattern
import requests
from bs4 import BeautifulSoup

response = requests.get("https://example.com")
soup = BeautifulSoup(response.content, "html.parser")
titles = [h2.text for h2 in soup.find_all("h2")]

# REST API pattern (Flask)
from flask import Flask, jsonify, request

app = Flask(__name__)

@app.route("/api/users", methods=["GET"])
def get_users():
    users = [{"id": 1, "name": "Alice"}]
    return jsonify(users)

@app.route("/api/users", methods=["POST"])
def create_user():
    data = request.get_json()
    # Validate and save user
    return jsonify({"id": 2, "name": data["name"]}), 201

if __name__ == "__main__":
    app.run(debug=True)

# Async/await (modern Python)
import asyncio
import aiohttp

async def fetch_url(url: str) -> str:
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            return await response.text()

async def main():
    urls = ["https://example.com", "https://example.org"]
    tasks = [fetch_url(url) for url in urls]
    results = await asyncio.gather(*tasks)  # Concurrent execution
    return results

# Run async code
asyncio.run(main())

# Dataclasses (modern data containers)
from dataclasses import dataclass

@dataclass
class User:
    id: int
    name: str
    email: str
    active: bool = True  # Default value

user = User(1, "Alice", "alice@example.com")
print(user.name)  # Alice

# File operations (Pathlib - modern way)
from pathlib import Path

file = Path("data/users.json")
file.parent.mkdir(parents=True, exist_ok=True)  # Create dirs
file.write_text('{"users": []}')                # Write file
content = file.read_text()                      # Read file

# Iterate files
for py_file in Path(".").rglob("*.py"):
    print(py_file)

# Logging (better than print)
import logging

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
)
logger = logging.getLogger(__name__)

logger.info("Application started")
logger.warning("Deprecated feature used")
logger.error("Failed to connect to database")

# Testing with pytest
# test_calculator.py
def add(a: int, b: int) -> int:
    return a + b

def test_add():
    assert add(2, 3) == 5
    assert add(-1, 1) == 0
    assert add(0, 0) == 0

# Run tests: pytest test_calculator.py