Basic Syntax — Practical Tasks¶

from datetime import datetime


def main():
    name = input("Enter your name: ")
    age = int(input("Enter your age: "))
    city = input("Enter your city: ")
    language = input("Enter your favorite programming language: ")

    birth_year = datetime.now().year - age

    print("╔══════════════════════════╗")
    print("║     PROFILE CARD         ║")
    print("╠══════════════════════════╣")
    print(f"║ Name:     {name:<15}║")
    print(f"║ Age:      {age:<15}║")
    print(f"║ City:     {city:<15}║")
    print(f"║ Language: {language:<15}║")
    print(f"║ Born:     ~{birth_year:<14}║")
    print("╚══════════════════════════╝")


if __name__ == "__main__":
    main()

KM_TO_MILES = 0.621371
KG_TO_LBS = 2.20462


def km_to_miles(km: float) -> float:
    return km * KM_TO_MILES


def miles_to_km(miles: float) -> float:
    return miles / KM_TO_MILES


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


def fahrenheit_to_celsius(f: float) -> float:
    return (f - 32) * 5 / 9


def kg_to_lbs(kg: float) -> float:
    return kg * KG_TO_LBS


def lbs_to_kg(lbs: float) -> float:
    return lbs / KG_TO_LBS


def main():
    print("=== Unit Converter ===")
    print("1. Kilometers to Miles")
    print("2. Miles to Kilometers")
    print("3. Celsius to Fahrenheit")
    print("4. Fahrenheit to Celsius")
    print("5. Kilograms to Pounds")
    print("6. Pounds to Kilograms")
    print()

    choice = int(input("Choose option (1-6): "))
    value = float(input("Enter value: "))

    converters = {
        1: ("km", "miles", km_to_miles),
        2: ("miles", "km", miles_to_km),
        3: ("°C", "°F", celsius_to_fahrenheit),
        4: ("°F", "°C", fahrenheit_to_celsius),
        5: ("kg", "lbs", kg_to_lbs),
        6: ("lbs", "kg", lbs_to_kg),
    }

    if choice in converters:
        from_unit, to_unit, func = converters[choice]
        result = func(value)
        print(f"{value}{from_unit} = {result:.2f}{to_unit}")
    else:
        print("Invalid choice!")


if __name__ == "__main__":
    main()

def ask_question(question: str, options: list, correct: int) -> bool:
    """Ask a multiple-choice question and return True if answered correctly.

    Args:
        question: The question text
        options: List of answer options
        correct: Index of the correct answer (0-based)

    Returns:
        True if the user answered correctly
    """
    print(f"\n{question}")
    for i, option in enumerate(options):
        print(f"  {i + 1}) {option}")

    try:
        answer = int(input("Your answer (number): ")) - 1
    except ValueError:
        print("Invalid input!")
        return False

    if answer == correct:
        print("Correct!")
        return True
    else:
        print(f"Wrong! The correct answer was: {options[correct]}")
        return False


def main():
    """Run a Python syntax quiz."""
    questions = [
        {
            "q": "What does Python use to define code blocks?",
            "opts": ["Curly braces {}", "Parentheses ()", "Indentation", "Semicolons"],
            "ans": 2,
        },
        {
            "q": "What does input() return?",
            "opts": ["int", "float", "str", "bytes"],
            "ans": 2,
        },
        {
            "q": "Which is the floor division operator?",
            "opts": ["/", "//", "%", "**"],
            "ans": 1,
        },
        {
            "q": "What naming convention do Python functions use?",
            "opts": ["camelCase", "PascalCase", "snake_case", "kebab-case"],
            "ans": 2,
        },
        {
            "q": "What starts a comment in Python?",
            "opts": ["//", "#", "/*", "--"],
            "ans": 1,
        },
    ]

    score = 0
    total = len(questions)

    print("=== Python Syntax Quiz ===")
    for item in questions:
        if ask_question(item["q"], item["opts"], item["ans"]):
            score += 1

    print(f"\n=== Results ===")
    print(f"Score: {score}/{total} ({score / total * 100:.0f}%)")

    if score == total:
        print("Perfect score!")
    elif score >= total * 0.7:
        print("Great job!")
    else:
        print("Keep studying!")


if __name__ == "__main__":
    main()

import re


def parse_expression(expr: str) -> tuple[float, str, float] | None:
    """Parse a simple math expression into (left, operator, right).

    Args:
        expr: String like "5 + 3" or "10.5 / 2"

    Returns:
        Tuple of (left_number, operator, right_number) or None if invalid
    """
    pattern = r"^\s*(-?\d+\.?\d*)\s*([+\-*/])\s*(-?\d+\.?\d*)\s*$"
    if match := re.match(pattern, expr):
        left = float(match.group(1))
        op = match.group(2)
        right = float(match.group(3))
        return left, op, right
    return None


def evaluate(left: float, op: str, right: float) -> float:
    """Evaluate a binary math operation.

    Args:
        left: Left operand
        op: Operator (+, -, *, /)
        right: Right operand

    Returns:
        Result of the operation

    Raises:
        ZeroDivisionError: If dividing by zero
        ValueError: If operator is unknown
    """
    match op:
        case "+":
            return left + right
        case "-":
            return left - right
        case "*":
            return left * right
        case "/":
            if right == 0:
                raise ZeroDivisionError("Cannot divide by zero")
            return left / right
        case _:
            raise ValueError(f"Unknown operator: {op}")


def main() -> None:
    """Run the expression evaluator in a loop."""
    print("=== Expression Evaluator ===")
    print("Enter expressions like '5 + 3' or 'quit' to exit\n")

    while (expr := input(">>> ")) != "quit":
        if parsed := parse_expression(expr):
            left, op, right = parsed
            try:
                result = evaluate(left, op, right)
                print(f"  = {result}")
            except (ZeroDivisionError, ValueError) as e:
                print(f"  Error: {e}")
        else:
            print("  Invalid expression. Use format: number operator number")


if __name__ == "__main__":
    main()

from dataclasses import dataclass
from pathlib import Path


@dataclass
class StyleIssue:
    line_number: int
    column: int
    code: str
    message: str


def analyze_file(filepath: str | Path) -> list[StyleIssue]:
    """Analyze a Python file for common style issues.

    Args:
        filepath: Path to the Python file

    Returns:
        List of StyleIssue objects
    """
    issues: list[StyleIssue] = []
    filepath = Path(filepath)

    with open(filepath, "r", encoding="utf-8") as f:
        lines = f.readlines()

    for i, line in enumerate(lines, start=1):
        # Check line length
        if len(line.rstrip("\n")) > 79:
            issues.append(StyleIssue(i, 80, "E501", f"Line too long ({len(line.rstrip())} > 79)"))

        # Check for tabs
        if "\t" in line:
            col = line.index("\t") + 1
            issues.append(StyleIssue(i, col, "W191", "Indentation contains tabs"))

        # Check trailing whitespace
        stripped = line.rstrip("\n")
        if stripped != stripped.rstrip():
            issues.append(StyleIssue(i, len(stripped.rstrip()) + 1, "W291", "Trailing whitespace"))

    # Check for module docstring
    content = "".join(lines)
    if not content.lstrip().startswith(('"""', "'''")):
        if not content.lstrip().startswith("#"):
            issues.append(StyleIssue(1, 1, "D100", "Missing module docstring"))

    return issues


def main() -> None:
    import sys

    if len(sys.argv) < 2:
        print("Usage: python analyzer.py <file.py>")
        sys.exit(1)

    filepath = sys.argv[1]
    issues = analyze_file(filepath)

    if not issues:
        print(f"{filepath}: All checks passed!")
    else:
        for issue in issues:
            print(f"{filepath}:{issue.line_number}:{issue.column}: {issue.code} {issue.message}")
        print(f"\nTotal issues: {len(issues)}")


if __name__ == "__main__":
    main()

import ast
import traceback
from typing import Any


class SimpleREPL:
    """A simplified Python REPL with history and safe evaluation."""

    def __init__(self):
        self._namespace: dict[str, Any] = {}
        self._history: list[str] = []

    def evaluate(self, source: str) -> Any | None:
        """Safely evaluate a Python expression or statement.

        Uses ast.parse to validate syntax before execution.
        """
        self._history.append(source)

        try:
            # Try as expression first
            tree = ast.parse(source, mode="eval")
            code = compile(tree, "<repl>", "eval")
            return eval(code, {"__builtins__": __builtins__}, self._namespace)
        except SyntaxError:
            pass

        try:
            # Try as statement
            tree = ast.parse(source, mode="exec")
            code = compile(tree, "<repl>", "exec")
            exec(code, {"__builtins__": __builtins__}, self._namespace)
            return None
        except SyntaxError as e:
            raise SyntaxError(f"Invalid syntax: {e}")

    def run(self) -> None:
        """Run the REPL loop."""
        print("Simple Python REPL (type 'exit' to quit)")
        while True:
            try:
                source = input(">>> ")
                if source.strip() == "exit":
                    break
                if source.strip() == "":
                    continue
                result = self.evaluate(source)
                if result is not None:
                    print(repr(result))
            except KeyboardInterrupt:
                print("\nKeyboardInterrupt")
            except Exception as e:
                traceback.print_exc()


if __name__ == "__main__":
    repl = SimpleREPL()
    repl.run()