Различные подходы к отображению данных из функций в языке Python

Расширенные примеры с пояснениями

Рекурсивный вывод с накоплением

def factorial(n, depth=0):
    prefix = "  " * depth
    print(f"{prefix}Вызов factorial({n})")
    if n == 0:
        print(f"{prefix}Базовый случай: 1")
        return 1
    result = n * factorial(n-1, depth+1)
    print(f"{prefix}Возврат {result} для n={n}")
    return result

factorial(3)

Вызов factorial(3)
  Вызов factorial(2)
    Вызов factorial(1)
      Вызов factorial(0)
      Базовый случай: 1
    Возврат 1 для n=1
  Возврат 2 для n=2
Возврат 6 для n=3

Вывод с таймингом выполнения

import time

def timed_output(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        elapsed = time.time() - start
        print(f"Выполнение {func.__name__} заняло {elapsed:.4f} сек")
        return result
    return wrapper

@timed_output
def slow_sum(n):
    total = 0
    for i in range(n):
        total += i
    return total

slow_sum(1000000)

Выполнение slow_sum заняло 0.0432 сек

Форматированный вывод таблицы с выравниванием

def table_output(data):
    """data - список списков, первая строка - заголовки"""
    if not data:
        return
    col_widths = [max(len(str(item)) for item in col) for col in zip(*data)]
    for row in data:
        formatted = " | ".join(f"{str(item).ljust(width)}" for item, width in zip(row, col_widths))
        print(formatted)
        if row == data[0]:
            print("-" * len(formatted))

table_output([
    ["Имя", "Возраст", "Город"],
    ["Анна", 25, "Москва"],
    ["Иван", 30, "Санкт-Петербург"]
])

Имя | Возраст | Город
----+---------+------------------
Анна | 25      | Москва
Иван | 30      | Санкт-Петербург

Вывод в несколько файлов с использованием логирования

import logging

def setup_loggers():
    logger = logging.getLogger('multi')
    logger.setLevel(logging.DEBUG)
    fh1 = logging.FileHandler('debug.log')
    fh1.setLevel(logging.DEBUG)
    fh2 = logging.FileHandler('errors.log')
    fh2.setLevel(logging.ERROR)
    formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
    fh1.setFormatter(formatter)
    fh2.setFormatter(formatter)
    logger.addHandler(fh1)
    logger.addHandler(fh2)
    return logger

logger = setup_loggers()
def divide(a, b):
    try:
        result = a / b
        logger.info(f"divide({a},{b}) = {result}")
        return result
    except ZeroDivisionError as e:
        logger.error(f"divide({a},{b}) -> {e}")
        return None

divide(10, 2)
divide(10, 0)

(в файл debug.log записана строка INFO, в errors.log - строка ERROR)

Использование pprint для сложных структур

from pprint import pprint

def get_nested():
    return {
        "users": [
            {"name": "Alice", "skills": ["Python", "SQL"]},
            {"name": "Bob", "skills": ["Java", "C++"]}
        ],
        "version": 2.0
    }

pprint(get_nested())

{'users': [{'name': 'Alice', 'skills': ['Python', 'SQL']},
           {'name': 'Bob', 'skills': ['Java', 'C++']}],
 'version': 2.0}

Динамический выбор способа вывода через параметр

def flexible_output(func, output='print'):
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        if output == 'print':
            print(result)
        elif output == 'return':
            return result
        elif output == 'log':
            import logging
            logging.info(str(result))
        else:
            raise ValueError(f"Неизвестный output: {output}")
        return result
    return wrapper

@flexible_output(output='print')
def add(a, b):
    return a + b

add(2, 3)

5