Cookbook

numbers = [1, 2, 3, 4, 5]
squares = [n ** 2 for n in numbers]

evens = [n for n in numbers if n % 2 == 0]

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = [item for row in matrix for item in row]

positive_squares = [n ** 2 for n in [-2, -1, 0, 1, 2] if n > 0]

colors = ['red', 'blue']
sizes = ['S', 'M', 'L']
combinations = [(color, size) for color in colors for size in sizes]

numbers = [1, 2, 3, 4, 5]
squares_dict = {n: n ** 2 for n in numbers}

keys = ['name', 'age', 'city']
values = ['Alice', 30, 'NYC']
person = {k: v for k, v in zip(keys, values)}

scores = {'Alice': 85, 'Bob': 92, 'Charlie': 78, 'Diana': 95}
high_scores = {name: score for name, score in scores.items() if score >= 90}

celsius = {'morning': 20, 'afternoon': 25, 'evening': 22}
fahrenheit = {time: (temp * 9/5) + 32 for time, temp in celsius.items()}

original = {'a': 1, 'b': 2, 'c': 3}
swapped = {v: k for k, v in original.items()}

numbers = [1, 2, 2, 3, 3, 3, 4, 5]
unique_squares = {n ** 2 for n in numbers}

items = ['apple', 'banana', 'apple', 'cherry', 'banana']
unique_items = list(dict.fromkeys(items))

set_a = {1, 2, 3, 4, 5}
set_b = {4, 5, 6, 7, 8}

union = set_a | set_b

intersection = set_a & set_b

difference = set_a - set_b

sym_diff = set_a ^ set_b

is_subset = {1, 2} <= set_a  # True
is_superset = set_a >= {1, 2}  # True

from collections import defaultdict, Counter

word_lists = defaultdict(list)
words = [('fruit', 'apple'), ('fruit', 'banana'), ('veggie', 'carrot')]
for category, item in words:
    word_lists[category].append(item)

word_counts = defaultdict(int)
sentence = "the quick brown fox jumps over the lazy dog"
for word in sentence.split():
    word_counts[word] += 1

text = "hello world"
letter_counts = Counter(text)

letter_counts.most_common(3)

c1 = Counter(['a', 'b', 'c', 'a'])
c2 = Counter(['b', 'c', 'd', 'b'])
combined = c1 + c2

words = ['apple', 'banana', 'apple', 'cherry', 'banana', 'apple']
fruit_counts = Counter(words)

numbers = range(1, 1000000)
squares_gen = (n ** 2 for n in numbers)  # No computation yet

for square in squares_gen:
    if square > 100:
        print(square)
        break  # Only computed up to this point

def fibonacci():
    """Generate fibonacci sequence infinitely"""
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

fib = fibonacci()
first_ten = [next(fib) for _ in range(10)]

def read_large_file(filepath):
    """Memory-efficient file reading"""
    with open(filepath, 'r') as f:
        for line in f:
            yield line.strip()

for line in read_large_file('data.txt'):
    process(line)  # Only one line in memory at a time

def read_csv(filepath):
    with open(filepath) as f:
        for line in f:
            yield line.strip().split(',')

def filter_rows(rows, min_value):
    for row in rows:
        if int(row[1]) >= min_value:
            yield row

rows = read_csv('data.csv')
filtered = filter_rows(rows, 100)
for row in filtered:
    print(row)

from itertools import groupby, chain, combinations, product

data = [
    {'name': 'Alice', 'dept': 'Engineering'},
    {'name': 'Bob', 'dept': 'Sales'},
    {'name': 'Charlie', 'dept': 'Engineering'},
    {'name': 'Diana', 'dept': 'Sales'}
]

from collections import defaultdict
grouped = defaultdict(list)
for person in data:
    grouped[person['dept']].append(person['name'])

data_sorted = sorted(data, key=lambda x: x['dept'])
for dept, group in groupby(data_sorted, key=lambda x: x['dept']):
    people = [person['name'] for person in group]
    print(f"{dept}: {people}")

nested = [[1, 2, 3], [4, 5], [6, 7, 8]]
flattened = list(chain.from_iterable(nested))

flattened = list(chain(*nested))

items = ['A', 'B', 'C']
pairs = list(combinations(items, 2))

colors = ['red', 'blue']
sizes = ['S', 'M']
variants = list(product(colors, sizes))

def greet(name: str) -> str:
    return f"Hello, {name}"

def sum_numbers(numbers: list[int]) -> int:
    return sum(numbers)

def get_scores() -> dict[str, int]:
    return {'Alice': 95, 'Bob': 87}

def unique_items(items: list[str]) -> set[str]:
    return set(items)

def find_user(user_id: int) -> str | None:
    users = {1: 'Alice', 2: 'Bob'}
    return users.get(user_id)  # Returns str or None

def parse_value(value: int | str) -> int:
    if isinstance(value, str):
        return int(value)
    return value

def get_coordinates() -> tuple[float, float]:
    return (40.7128, -74.0060)

def divide(a: int, b: int) -> tuple[int, int]:
    return a // b, a % b  # quotient, remainder

def process_data() -> dict[str, list[tuple[int, str]]]:
    return {
        'users': [(1, 'Alice'), (2, 'Bob')],
        'admins': [(10, 'Admin')]
    }

from typing import TypeVar, Generic, Protocol, Callable, Any, NewType

T = TypeVar('T')

def first_element(items: list[T]) -> T | None:
    return items[0] if items else None

numbers = [1, 2, 3]
first_num = first_element(numbers)  # Type: int | None

strings = ['a', 'b', 'c']
first_str = first_element(strings)  # Type: str | None

class Stack(Generic[T]):
    def __init__(self) -> None:
        self.items: list[T] = []

    def push(self, item: T) -> None:
        self.items.append(item)

    def pop(self) -> T | None:
        return self.items.pop() if self.items else None

    def is_empty(self) -> bool:
        return len(self.items) == 0

int_stack: Stack[int] = Stack()
int_stack.push(1)
int_stack.push(2)
value: int | None = int_stack.pop()

class Drawable(Protocol):
    def draw(self) -> str:
        ...

class Circle:
    def draw(self) -> str:
        return "⭕"

class Square:
    def draw(self) -> str:
        return "⬜"

def render(shape: Drawable) -> None:
    print(shape.draw())

render(Circle())  # ✅ Works - has draw() method
render(Square())  # ✅ Works - has draw() method

def apply_operation(x: int, operation: Callable[[int], int]) -> int:
    return operation(x)

result = apply_operation(5, lambda x: x ** 2)  # 25

UserId = NewType('UserId', int)
OrderId = NewType('OrderId', int)

def get_user(user_id: UserId) -> str:
    return f"User {user_id}"

user_id = UserId(123)
order_id = OrderId(456)
get_user(user_id)  # ✅ OK

import functools
import time
from typing import Callable, Any

def timer(func: Callable[..., Any]) -> Callable[..., Any]:
    """Measure and print function execution time"""
    @functools.wraps(func)
    def wrapper(*args: Any, **kwargs: Any) -> Any:
        start = time.perf_counter()
        result = func(*args, **kwargs)
        end = time.perf_counter()
        print(f"{func.__name__} took {end - start:.4f} seconds")
        return result
    return wrapper

@timer
def slow_function():
    time.sleep(1)
    return "Done"

result = slow_function()

def retry(max_attempts: int = 3, delay: float = 1.0):
    """Retry function on exception"""
    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
        @functools.wraps(func)
        def wrapper(*args: Any, **kwargs: Any) -> Any:
            for attempt in range(max_attempts):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    if attempt == max_attempts - 1:
                        raise
                    print(f"Attempt {attempt + 1} failed: {e}")
                    time.sleep(delay)
        return wrapper
    return decorator

@retry(max_attempts=3, delay=0.5)
def unreliable_network_call():
    # Might fail occasionally
    import random
    if random.random() < 0.7:
        raise ConnectionError("Network error")
    return "Success"

import functools
from typing import Any

@functools.lru_cache(maxsize=128)
def fibonacci(n: int) -> int:
    """Fibonacci with memoization"""
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

result = fibonacci(100)

def memoize(func: Callable[..., Any]) -> Callable[..., Any]:
    """Simple memoization decorator"""
    cache: dict[str, Any] = {}

    @functools.wraps(func)
    def wrapper(*args: Any, **kwargs: Any) -> Any:
        # Create cache key from arguments
        key = str(args) + str(kwargs)
        if key not in cache:
            cache[key] = func(*args, **kwargs)
        return cache[key]

    # Add cache control methods
    wrapper.cache = cache
    wrapper.clear_cache = lambda: cache.clear()
    return wrapper

@memoize
def expensive_computation(x: int, y: int) -> int:
    print(f"Computing {x} + {y}")
    time.sleep(1)
    return x + y

result1 = expensive_computation(5, 3)  # Prints "Computing 5 + 3"
result2 = expensive_computation(5, 3)  # Returns cached result

import functools
from typing import Callable, Any

def validate_positive(func: Callable[..., Any]) -> Callable[..., Any]:
    """Ensure all numeric arguments are positive"""
    @functools.wraps(func)
    def wrapper(*args: Any, **kwargs: Any) -> Any:
        for arg in args:
            if isinstance(arg, (int, float)) and arg <= 0:
                raise ValueError(f"Argument must be positive: {arg}")
        for value in kwargs.values():
            if isinstance(value, (int, float)) and value <= 0:
                raise ValueError(f"Argument must be positive: {value}")
        return func(*args, **kwargs)
    return wrapper

@validate_positive
def calculate_area(width: float, height: float) -> float:
    return width * height

area = calculate_area(5, 10)  # ✅ OK: 50

def validate_types(**type_hints: type):
    """Validate argument types at runtime"""
    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
        @functools.wraps(func)
        def wrapper(*args: Any, **kwargs: Any) -> Any:
            # Get function signature
            import inspect
            sig = inspect.signature(func)
            bound = sig.bind(*args, **kwargs)

            # Validate types
            for name, value in bound.arguments.items():
                if name in type_hints:
                    expected_type = type_hints[name]
                    if not isinstance(value, expected_type):
                        raise TypeError(
                            f"{name} must be {expected_type.__name__}, "
                            f"got {type(value).__name__}"
                        )
            return func(*args, **kwargs)
        return wrapper
    return decorator

@validate_types(name=str, age=int)
def create_user(name: str, age: int) -> str:
    return f"{name} is {age} years old"

user = create_user("Alice", 30)  # ✅ OK

with open('data.txt', 'r') as f:
    content = f.read()
    # File automatically closed, even if exception occurs

with open('input.txt', 'r') as infile, open('output.txt', 'w') as outfile:
    for line in infile:
        outfile.write(line.upper())

class DatabaseConnection:
    def __init__(self, connection_string: str):
        self.connection_string = connection_string
        self.connection = None

    def __enter__(self):
        print(f"Connecting to {self.connection_string}")
        self.connection = f"Connection({self.connection_string})"
        return self.connection

    def __exit__(self, exc_type, exc_val, exc_tb):
        print("Closing connection")
        self.connection = None
        # Return False to propagate exceptions
        return False

with DatabaseConnection("postgresql://localhost") as conn:
    print(f"Using {conn}")

from contextlib import contextmanager

@contextmanager
def temporary_value(obj, attr, new_value):
    """Temporarily change object attribute"""
    old_value = getattr(obj, attr)
    setattr(obj, attr, new_value)
    try:
        yield obj
    finally:
        setattr(obj, attr, old_value)

class Config:
    debug = False

config = Config()
print(config.debug)  # False
with temporary_value(config, 'debug', True):
    print(config.debug)  # True (temporarily)
print(config.debug)  # False (restored)

import time
from contextlib import contextmanager
from typing import Generator

@contextmanager
def timer(label: str = "Operation") -> Generator[None, None, None]:
    """Context manager to measure execution time"""
    start = time.perf_counter()
    try:
        yield
    finally:
        end = time.perf_counter()
        print(f"{label} took {end - start:.4f} seconds")

with timer("Database query"):
    time.sleep(0.5)
    result = "data"

class Timer:
    def __init__(self, label: str = "Operation"):
        self.label = label
        self.elapsed = 0.0

    def __enter__(self):
        self.start = time.perf_counter()
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.end = time.perf_counter()
        self.elapsed = self.end - self.start
        print(f"{self.label} took {self.elapsed:.4f} seconds")
        return False

with Timer("Complex operation") as t:
    time.sleep(1)

print(f"Total time was {t.elapsed:.2f}s")

import asyncio

async def fetch_data(url: str) -> str:
    """Simulate async data fetching"""
    print(f"Fetching {url}")
    await asyncio.sleep(1)  # Simulate network delay
    return f"Data from {url}"

async def main():
    result = await fetch_data("https://api.example.com")
    print(result)

asyncio.run(main())

async def fetch_all():
    urls = [
        "https://api.example.com/users",
        "https://api.example.com/posts",
        "https://api.example.com/comments"
    ]

    # Run all concurrently
    results = await asyncio.gather(*[fetch_data(url) for url in urls])
    return results

results = asyncio.run(fetch_all())

async def main_with_tasks():
    task1 = asyncio.create_task(fetch_data("url1"))
    task2 = asyncio.create_task(fetch_data("url2"))
    task3 = asyncio.create_task(fetch_data("url3"))

    # Wait for all tasks
    results = await asyncio.gather(task1, task2, task3)
    return results

import asyncio
import aiohttp
from typing import Any

async def fetch_url(session: aiohttp.ClientSession, url: str) -> str:
    """Fetch URL content asynchronously"""
    async with session.get(url) as response:
        return await response.text()

async def fetch_multiple_urls(urls: list[str]) -> list[str]:
    """Fetch multiple URLs concurrently"""
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_url(session, url) for url in urls]
        results = await asyncio.gather(*tasks)
        return results

urls = [
    'https://httpbin.org/delay/1',
    'https://httpbin.org/delay/1',
    'https://httpbin.org/delay/1'
]
results = asyncio.run(fetch_multiple_urls(urls))

async def fetch_with_error_handling(url: str) -> dict[str, Any]:
    """Fetch URL with error handling"""
    try:
        async with aiohttp.ClientSession() as session:
            async with session.get(url, timeout=aiohttp.ClientTimeout(total=5)) as response:
                return {
                    'url': url,
                    'status': response.status,
                    'data': await response.text()
                }
    except asyncio.TimeoutError:
        return {'url': url, 'error': 'Timeout'}
    except Exception as e:
        return {'url': url, 'error': str(e)}

async def fetch_stream(url: str):
    """Stream large response line by line"""
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            async for line in response.content:
                yield line.decode('utf-8')

import asyncio
from asyncio import Queue

async def producer(queue: Queue, num_items: int):
    """Produce items to queue"""
    for i in range(num_items):
        item = f"Item {i}"
        await queue.put(item)
        print(f"Produced: {item}")
        await asyncio.sleep(0.1)

    # Signal completion
    await queue.put(None)

async def consumer(queue: Queue, consumer_id: int):
    """Consume items from queue"""
    while True:
        item = await queue.get()

        if item is None:
            # Put None back for other consumers
            await queue.put(None)
            break

        print(f"Consumer {consumer_id} processing: {item}")
        await asyncio.sleep(0.5)  # Simulate work
        queue.task_done()

async def main():
    queue: Queue = Queue(maxsize=10)

    # Start producer and multiple consumers
    prod_task = asyncio.create_task(producer(queue, 10))
    consumer_tasks = [
        asyncio.create_task(consumer(queue, i))
        for i in range(3)
    ]

    # Wait for producer to finish
    await prod_task

    # Wait for all items to be processed
    await queue.join()

    # Wait for consumers to finish
    await asyncio.gather(*consumer_tasks)

asyncio.run(main())

try:
    result = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero")

try:
    value = int("not a number")
except (ValueError, TypeError) as e:
    print(f"Conversion error: {e}")

import logging

try:
    risky_operation()
except Exception as e:
    logging.error(f"Operation failed: {e}", exc_info=True)
    raise  # Re-raise after logging

try:
    file = open('data.txt', 'r')
    content = file.read()
except FileNotFoundError:
    print("File not found")
    content = ""
except IOError as e:
    print(f"I/O error: {e}")
    content = ""
else:
    # Runs if no exception occurred
    print("File read successfully")
finally:
    # Always runs, even if exception occurs
    if 'file' in locals():
        file.close()

class ValidationError(Exception):
    """Custom exception for validation failures"""
    def __init__(self, field: str, message: str):
        self.field = field
        self.message = message
        super().__init__(f"{field}: {message}")

class InvalidEmailError(ValidationError):
    """Specific validation error for emails"""
    pass

def validate_email(email: str):
    if '@' not in email:
        raise InvalidEmailError('email', 'Must contain @')

try:
    validate_email('invalid')
except InvalidEmailError as e:
    print(f"Validation failed - {e.field}: {e.message}")

from contextlib import contextmanager

@contextmanager
def handle_errors(error_handler):
    """Context manager for centralized error handling"""
    try:
        yield
    except Exception as e:
        error_handler(e)

def log_error(error: Exception):
    logging.error(f"Error occurred: {error}")

with handle_errors(log_error):
    risky_operation()

def load_config(filename: str):
    try:
        with open(filename) as f:
            return json.load(f)
    except FileNotFoundError as e:
        raise ConfigError(f"Config file not found: {filename}") from e
    except json.JSONDecodeError as e:
        raise ConfigError(f"Invalid JSON in config: {filename}") from e

try:
    config = load_config("config.json")
except ConfigError as e:
    print(f"Error: {e}")
    print(f"Caused by: {e.__cause__}")
    # Output: Error: Config file not found: config.json
    #         Caused by: [Errno 2] No such file or directory: 'config.json'

import logging

class DatabaseError(Exception):
    """Custom exception with context preservation."""
    pass

class ConnectionError(DatabaseError):
    """Database connection failed."""
    pass

def connect_to_database(url: str):
    """Connect with detailed error chain."""
    try:
        # Simulate connection attempt
        if "invalid" in url:
            raise ValueError(f"Invalid URL format: {url}")

        # Simulate network error
        raise OSError("Connection refused")

    except ValueError as e:
        # Explicitly chain - shows both original and new error
        raise ConnectionError(f"Failed to parse database URL") from e
    except OSError as e:
        # Chain network errors
        raise ConnectionError(f"Failed to connect to database") from e

def initialize_app():
    """Initialize with full error context."""
    try:
        connect_to_database("invalid://localhost")
    except DatabaseError as e:
        # Full error chain is preserved
        logging.error("Application initialization failed", exc_info=True)

        # Access error chain
        print(f"Main error: {e}")
        if e.__cause__:
            print(f"Root cause: {e.__cause__}")
        # Output: Main error: Failed to parse database URL
        #         Root cause: Invalid URL format: invalid://localhost

def safe_conversion(value: str) -> int | None:
    """Convert string to int, hide implementation details."""
    try:
        return int(value)
    except ValueError:
        # Hide internal error, raise clean error
        raise TypeError(f"Cannot convert '{value}' to integer") from None

try:
    result = safe_conversion("abc")
except TypeError as e:
    # No __cause__, cleaner for user-facing errors
    print(f"Error: {e}")
    print(f"Cause: {e.__cause__}")  # None

from pathlib import Path

path = Path('data/files/document.txt')

print(path.name)       # document.txt
print(path.stem)       # document
print(path.suffix)     # .txt
print(path.parent)     # data/files
print(path.parts)      # ('data', 'files', 'document.txt')

base = Path('data')
full_path = base / 'files' / 'document.txt'  # Pythonic!

if path.exists():
    print("File exists")

if path.is_file():
    print("It's a file")

if path.is_dir():
    print("It's a directory")

output_dir = Path('output/results')
output_dir.mkdir(parents=True, exist_ok=True)  # Create all parent dirs

data_dir = Path('data')
for item in data_dir.iterdir():
    print(item)

for txt_file in data_dir.glob('*.txt'):
    print(txt_file)

for py_file in data_dir.rglob('*.py'):
    print(py_file)

path = Path('config.txt')
path.write_text('key=value')
content = path.read_text()

data = b'\x00\x01\x02'
path.write_bytes(data)
binary_content = path.read_bytes()

absolute = path.resolve()

home = Path.home()
config_file = home / '.config' / 'app' / 'settings.ini'

import tempfile
with tempfile.TemporaryDirectory() as temp_dir:
    temp_path = Path(temp_dir)
    # Use temp_path
    # Automatically cleaned up after with block

from pathlib import Path
from typing import Iterator

content = Path('data.txt').read_text()

def read_lines(filepath: Path) -> Iterator[str]:
    with filepath.open('r') as f:
        for line in f:
            yield line.strip()

for line in read_lines(Path('large_file.txt')):
    process(line)

lines: list[str] = Path('data.txt').read_text().splitlines()

import csv
from pathlib import Path

def read_csv(filepath: Path) -> list[dict[str, str]]:
    with filepath.open('r') as f:
        reader = csv.DictReader(f)
        return list(reader)

import json

def read_json(filepath: Path) -> dict:
    return json.loads(filepath.read_text())

def read_json_stream(filepath: Path) -> dict:
    with filepath.open('r') as f:
        return json.load(f)

import yaml

def read_yaml(filepath: Path) -> dict:
    return yaml.safe_load(filepath.read_text())

content = Path('data.txt').read_text(encoding='utf-8')

data = Path('image.png').read_bytes()

def process_file(filepath: Path):
    with filepath.open('r') as f:
        header = f.readline()
        for line in f:
            if line.startswith('#'):
                continue
            yield line.strip()

name = "Alice"
age = 30
balance = 1234.5678

message = f"Hello, {name}! You are {age} years old."

status = f"{name} has ${balance:.2f} in account"

upper_name = f"Name: {name.upper()}"

pi = 3.14159
formatted = f"Pi is approximately {pi:.2f}"  # 3.14

num = 1234567
formatted_num = f"{num:,}"  # 1,234,567
formatted_num = f"{num:_}"  # 1_234_567

text = "hello"
print(f"|{text:>10}|")  # Right-align:  |     hello|
print(f"|{text:<10}|")  # Left-align:   |hello     |
print(f"|{text:^10}|")  # Center:       |  hello   |

from datetime import datetime
now = datetime.now()
formatted_date = f"{now:%Y-%m-%d %H:%M:%S}"

person = {
    'name': 'Alice',
    'age': 30,
    'city': 'NYC'
}
formatted = f"""
Name: {person['name']}
Age: {person['age']}
City: {person['city']}
"""

message = "Hello, {}! You are {} years old.".format(name, age)
message = "Hello, {name}! You are {age} years old.".format(name=name, age=age)

from string import Template
template = Template("Hello, $name! You are $age years old.")
result = template.substitute(name=name, age=age)

text = "apple,banana,cherry"
fruits = text.split(',')  # ['apple', 'banana', 'cherry']
joined = ', '.join(fruits)  # 'apple, banana, cherry'

dirty = "  hello world  "
clean = dirty.strip()  # "hello world"
left_clean = dirty.lstrip()  # "hello world  "
right_clean = dirty.rstrip()  # "  hello world"

text = "Hello World"
replaced = text.replace("World", "Python")  # "Hello Python"
replaced_all = text.replace("l", "L")  # "HeLLo WorLd"

text = "Hello World"
print(text.lower())      # hello world
print(text.upper())      # HELLO WORLD
print(text.capitalize()) # Hello world
print(text.title())      # Hello World
print(text.swapcase())   # hELLO wORLD

text = "hello123"
print(text.isalnum())    # True (alphanumeric)
print(text.isalpha())    # False (has numbers)
print(text.isdigit())    # False (has letters)
print(text.islower())    # True
print(text.isupper())    # False

filename = "document.txt"
if filename.endswith('.txt'):
    print("Text file")

url = "https://example.com"
if url.startswith('https://'):
    print("Secure URL")

text = "hello world hello"
count = text.count('hello')  # 2

position = text.find('world')  # 6
position = text.rfind('hello')  # 12 (last occurrence)

text = "42"
padded = text.zfill(5)  # "00042"
padded = text.rjust(5, '0')  # "00042"
padded = text.ljust(5, '0')  # "42000"

text = "https://example.com"
without_protocol = text.removeprefix('https://')  # "example.com"

filename = "document.txt"
without_ext = filename.removesuffix('.txt')  # "document"

import re

text = "My email is john@example.com"
pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'

match = re.search(pattern, text)
if match:
    print(f"Found email: {match.group()}")
    # Output: Found email: john@example.com

text = "Contact us: info@company.com or support@company.com"
emails = re.findall(pattern, text)
print(f"Found {len(emails)} emails: {emails}")

phone_text = "Call me at (555) 123-4567"
phone_pattern = r'\((\d{3})\)\s*(\d{3})-(\d{4})'

match = re.search(phone_pattern, phone_text)
if match:
    area_code, prefix, number = match.groups()
    print(f"Area: {area_code}, Prefix: {prefix}, Number: {number}")
    # Output: Area: 555, Prefix: 123, Number: 4567

import re

log_line = "2025-12-18 14:30:45 ERROR [UserService] Failed to authenticate user_id=123"

log_pattern = r'(?P<date>\d{4}-\d{2}-\d{2})\s+(?P<time>\d{2}:\d{2}:\d{2})\s+(?P<level>\w+)\s+\[(?P<component>\w+)\]\s+(?P<message>.+)'

match = re.match(log_pattern, log_line)
if match:
    log_data = match.groupdict()
    print(f"Level: {log_data['level']}, Component: {log_data['component']}")
    # Output: Level: ERROR, Component: UserService

text = "Price: $100, Discount: $20"
cleaned = re.sub(r'\$(\d+)', r'\1 USD', text)
print(cleaned)

version_text = "App version: 2.5.3-beta"
version_pattern = r'(\d+)\.(\d+)\.(\d+)(?:-(\w+))?'

match = re.search(version_pattern, version_text)
if match:
    major, minor, patch, tag = match.groups()
    print(f"Version: {major}.{minor}.{patch} ({tag or 'release'})")
    # Output: Version: 2.5.3 (beta)

import re

def validate_email(email: str) -> tuple[bool, str]:
    """Validate email address format."""
    pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'

    if not email:
        return False, "Email cannot be empty"

    if not re.match(pattern, email):
        return False, "Invalid email format"

    if len(email) > 254:  # RFC 5321
        return False, "Email too long"

    return True, "Valid"

test_emails = [
    "user@example.com",
    "invalid.email",
    "user@domain.co.uk",
]

for email in test_emails:
    is_valid, message = validate_email(email)
    status = "✓" if is_valid else "✗"
    print(f"{status} {email}: {message}")

import re
from dataclasses import dataclass

@dataclass
class ValidationResult:
    is_valid: bool
    errors: list[str]

    def __bool__(self):
        return self.is_valid

class StringValidator:
    """Collection of string validation methods."""

    @staticmethod
    def validate_password(password: str, min_length: int = 8) -> ValidationResult:
        """Validate password strength."""
        errors = []

        if len(password) < min_length:
            errors.append(f"Must be at least {min_length} characters")

        if not re.search(r'[A-Z]', password):
            errors.append("Must contain uppercase letter")

        if not re.search(r'[a-z]', password):
            errors.append("Must contain lowercase letter")

        if not re.search(r'\d', password):
            errors.append("Must contain digit")

        if not re.search(r'[!@#$%^&*()]', password):
            errors.append("Must contain special character")

        return ValidationResult(len(errors) == 0, errors)

    @staticmethod
    def validate_username(username: str) -> ValidationResult:
        """Validate username (alphanumeric, underscore, 3-20 chars)."""
        errors = []

        if len(username) < 3 or len(username) > 20:
            errors.append("Must be 3-20 characters")

        if not re.match(r'^[a-zA-Z0-9_]+$', username):
            errors.append("Only letters, numbers, underscores allowed")

        if not re.match(r'^[a-zA-Z]', username):
            errors.append("Must start with a letter")

        return ValidationResult(len(errors) == 0, errors)

validator = StringValidator()

pwd_result = validator.validate_password("weak")
if not pwd_result:
    print("Password errors:")
    for error in pwd_result.errors:
        print(f"  - {error}")

strong_pwd = validator.validate_password("MyP@ssw0rd!")
print(f"Strong password valid: {strong_pwd.is_valid}")  # True

user_result = validator.validate_username("user_123")
print(f"Username valid: {user_result.is_valid}")  # True