Functions serve as the foundational building blocks in Python, enabling developers to encapsulate logic, promote reusability, and maintain clean architecture. The following examples demonstrate various function design patterns, ranging from basic arithmetic operations to file handling and algorithmic optimizations. Each snippet incorporates type hints and modern Python practices to illustrate production-ready patterns.

Computing Arithmetic Sums

def compute_total(first_operand: float, second_operand: float) -> float:
    """Returns the arithmetic sum of two numeric values."""
    return first_operand + second_operand

total = compute_total(12.5, 7.3)
print(f"Computed total: {total}")

This routine accepts two numeric arguments and immediately returns their combined value. By leveraging type hints, the function signature clearly communicates expected input types and return values, reducing runtime ambiguity.

Calculating Dataset Mean

from typing import List

def calculate_mean(dataset: List[float]) -> float:
    if not dataset:
        raise ValueError("Dataset cannot be empty")
    accumulated = sum(val for val in dataset)
    return accumulated / len(dataset)

sample_data = [88.0, 91.5, 76.0, 84.5]
print(f"Dataset mean: {calculate_mean(sample_data):.2f}")

Instead of blindly dividing by length, this implementation includes a guard clause to prevent division-by-zero errors. It aggregates values using a generator expression before computing the final average, ensuring memory efficiency for larger sequences.

Primality Verification

def verify_prime(candidate: int) -> bool:
    if candidate < 2:
        return False
    if candidate in (2, 3):
        return True
    if candidate % 2 == 0 or candidate % 3 == 0:
        return False

    divisor = 5
    while divisor * divisor <= candidate:
        if candidate % divisor == 0 or candidate % (divisor + 2) == 0:
            return False
        divisor += 6
    return True

target_num = 29
status = "prime" if verify_prime(target_num) else "composite"
print(f"{target_num} is classified as {status}")

This algorithm utilizes the 6k±1 optimization to skip unnecessary divisibility checks. By eliminating multiples of 2 and 3 early and iterating in steps of 6, the function achieves O(√n) time complexity while maintaining readability.

Sequence Inversion

def invert_sequence(text_payload: str) -> str:
    return "".join(reversed(text_payload))

original_phrase = "Functional programming"
print(f"Inverted: {invert_sequence(original_phrase)}")

Rather than relying on slice notation, this approach uses the built-in reversed() iterator combined with str.join(). This pattern explicitly conveys intent and works consistently across any iterable that supports reversal.

Greatest Common Divisor Resolution

def resolve_gcd(alpha: int, beta: int) -> int:
    if beta == 0:
        return abs(alpha)
    return resolve_gcd(beta, alpha % beta)

val_a, val_b = 56, 98
print(f"GCD of {val_a} and {val_b}: {resolve_gcd(val_a, val_b)}")

The Euclidean algorithm is implemented recursively here. Each call reduces the problem size by swapping parameters and applying the modulo operator until the remainder reaches zero, at which point the absolute value of the divisor is returned.

Fibonacci Term Generation

from typing import Generator

def yield_fibonacci_terms(limit: int) -> Generator[int, None, None]:
    current, subsequent = 0, 1
    for _ in range(limit):
        yield current
        current, subsequent = subsequent, current + subsequent

term_count = 8
sequence = list(yield_fibonacci_terms(term_count))
print(f"Generated sequence: {sequence}")

Transforming the traditional list-building approach into a generator function drastically reduces memory overhead. The yield keyword produces values lazily, allowing callers to consume terms on-demand or materialize them into a collection only when necessary.

Order-Preserving Deduplication

from typing import Sequence, List

def filter_unique_elements(source: Sequence) -> List:
    return list(dict.fromkeys(source))

raw_collection = [4, 7, 2, 4, 9, 2, 1]
print(f"Deduplicated: {filter_unique_elements(raw_collection)}")

While converting to a set removes duplicates, it destroys insertion order. Leveraging dict.fromkeys() takes advantage of Python's guaranteed dictionary ordering (3.7+) to eliminate redundancies while preserving the original sequence arrangement.

Safe File Content Extraction

from pathlib import Path

def extract_file_contents(target_path: str) -> str:
    file_ref = Path(target_path)
    if not file_ref.exists():
        return "Error: Target path does not exist"
    try:
        return file_ref.read_text(encoding="utf-8")
    except IOError as io_err:
        return f"I/O failure: {io_err}"

content_payload = extract_file_contents("data.log")
print(f"Retrieved payload: {content_payload}")

Modern Python I/O benefits greatly from the pathlib module. This function validates path existence before attempting reads and isolates I/O exceptions into a dedicated handler, preventing unhandled crashes while providing actionable feedback.

Batch Numeric Transformation

from typing import Iterable, List

def transform_to_squares(numeric_stream: Iterable[int]) -> List[int]:
    return [pow(item, 2) for item in numeric_stream]

base_values = range(1, 6)
print(f"Squared results: {transform_to_squares(base_values)}")

List comprehensions remain the idiomatic choice for mapping operations. By accepting any Iterable, the function stays flexible enough to process renges, generators, or standard lists with out requiring type conversions upfront.

Iterative Factorial Computation

import math

def compute_iterative_factorial(target: int) -> int:
    if target < 0:
        raise ValueError("Factorial undefined for negative integers")
    return math.prod(range(1, target + 1)) if target > 0 else 1

input_val = 6
print(f"{input_val}! evaluates to {compute_iterative_factorial(input_val)}")

Replacing recursion with math.prod() over a range eliminates call-stack limitations and improves execution speed. The conditional expression cleanly handles the base case (0! = 1) while delegating the multiplication workload to optimized C-level routines.