5 проверенных способов получить имя функции в Python: инструкция

def calculate_total(price, tax_rate):
"""Calculates total price with tax."""
return price * (1 + tax_rate)

print(calculate_total.__name__) # Выводит: calculate_total

def timing_decorator(func):
def wrapper(*args, **kwargs):
import time
start = time.time()
result = func(*args, **kwargs)
end = time.time()
print(f"Функция {func.__name__} выполнялась {end – start:.4f} секунд")
return result
return wrapper

@timing_decorator
def slow_function():
import time
time.sleep(1)
return "Done!"

print(slow_function.__name__) # Выводит: wrapper

from functools import wraps

def timing_decorator(func):
@wraps(func) # Сохраняет метаданные оригинальной функции
def wrapper(*args, **kwargs):
import time
start = time.time()
result = func(*args, **kwargs)
end = time.time()
print(f"Функция {func.__name__} выполнялась {end – start:.4f} секунд")
return result
return wrapper

@timing_decorator
def slow_function():
import time
time.sleep(1)
return "Done!"

print(slow_function.__name__) # Теперь выводит: slow_function

import inspect

def get_my_name():
# Получение имени текущей функции
current_function_name = inspect.currentframe().f_code.co_name
return current_function_name

def outer_function():
# Получение имени вызывающей функции
caller_name = inspect.currentframe().f_back.f_code.co_name
print(f"Меня вызвала функция: {caller_name}")

def call_outer():
outer_function() # Выведет: "Меня вызвала функция: call_outer"

print(get_my_name()) # Выведет: "get_my_name"
call_outer()

import inspect

def get_function_details():
# Получение информации о текущем фрейме
current_frame = inspect.currentframe()

# Информация о текущей функции
current_func_name = current_frame.f_code.co_name

# Получение стека вызовов
call_stack = inspect.stack()

# Имя вызывающей функции (если есть)
caller_name = call_stack[1].function if len(call_stack) > 1 else "None"

# Имя модуля текущей функции
module_name = inspect.getmodule(current_frame).__name__

return {
"function_name": current_func_name,
"caller_name": caller_name,
"module_name": module_name,
"file_name": call_stack[0].filename,
"line_number": call_stack[0].lineno
}

def caller_function():
details = get_function_details()
print(f"Функция: {details['function_name']}")
print(f"Вызвана из: {details['caller_name']}")
print(f"Модуль: {details['module_name']}")
print(f"Файл: {details['file_name']}")
print(f"Строка: {details['line_number']}")

caller_function()

import inspect
import logging

# Настройка логгера
logging.basicConfig(level=logging.INFO,
format='%(asctime)s – %(levelname)s – %(message)s')
logger = logging.getLogger(__name__)

def log_with_caller(message, level=logging.INFO):
# Получение фрейма вызывающей функции
frame = inspect.currentframe().f_back

# Извлечение имени функции
func_name = frame.f_code.co_name

# Извлечение номера строки
line_no = frame.f_lineno

# Извлечение имени модуля
module_name = inspect.getmodule(frame).__name__

# Форматирование сообщения с контекстом
context_message = f"[{module_name}.{func_name}:{line_no}] {message}"

# Логирование с нужным уровнем
logger.log(level, context_message)

def process_data(data):
log_with_caller(f"Обработка {len(data)} элементов")
# Какая-то логика обработки...
log_with_caller("Обработка завершена успешно")

process_data([1, 2, 3, 4, 5])

import functools
import logging
import time
from typing import Callable, Any

logging.basicConfig(level=logging.INFO,
format='%(asctime)s – %(name)s – %(levelname)s – %(message)s')

def logged(func: Callable) -> Callable:
"""
Декоратор для автоматического логирования вызовов функции.
Сохраняет оригинальное имя функции и добавляет информацию
о времени выполнения и аргументах.
"""
logger = logging.getLogger(func.__module__)

@functools.wraps(func) # Сохраняем метаданные оригинальной функции
def wrapper(*args: Any, **kwargs: Any) -> Any:
args_repr = [repr(a) for a in args]
kwargs_repr = [f"{k}={v!r}" for k, v in kwargs.items()]
signature = ", ".join(args_repr + kwargs_repr)

logger.info(f"Вызов {func.__name__}({signature})")
start_time = time.time()

try:
result = func(*args, **kwargs)
elapsed_time = time.time() – start_time
logger.info(f"{func.__name__} завершена за {elapsed_time:.4f} сек")
return result
except Exception as e:
elapsed_time = time.time() – start_time
logger.exception(
f"{func.__name__} вызвала исключение после {elapsed_time:.4f} сек: {str(e)}"
)
raise

return wrapper

@logged
def divide(a: float, b: float) -> float:
return a / b

# Пример использования
try:
result = divide(10, 2)
print(f"Результат: {result}")

# Вызовет исключение и будет залогировано
result = divide(10, 0)
except Exception:
pass

def log_all_methods(cls):
"""
Декоратор класса, автоматически добавляющий логирование ко всем методам.
"""
for attr_name, attr_value in cls.__dict__.items():
if callable(attr_value) and not attr_name.startswith('__'):
setattr(cls, attr_name, logged(attr_value))
return cls

@log_all_methods
class Calculator:
def add(self, a, b):
return a + b

def subtract(self, a, b):
return a – b

def multiply(self, a, b):
return a * b

def divide(self, a, b):
return a / b

# Теперь все методы будут автоматически логироваться
calc = Calculator()
calc.add(5, 3)
calc.subtract(10, 4)

import asyncio
import functools
import logging
import time
from typing import Callable, Any

logging.basicConfig(level=logging.INFO,
format='%(asctime)s – %(name)s – %(levelname)s – %(message)s')

def async_logged(func: Callable) -> Callable:
"""Декоратор для логирования асинхронных функций."""
logger = logging.getLogger(func.__module__)

@functools.wraps(func)
async def wrapper(*args: Any, **kwargs: Any) -> Any:
args_repr = [repr(a) for a in args]
kwargs_repr = [f"{k}={v!r}" for k, v in kwargs.items()]
signature = ", ".join(args_repr + kwargs_repr)

logger.info(f"Вызов async {func.__name__}({signature})")
start_time = time.time()

try:
result = await func(*args, **kwargs)
elapsed_time = time.time() – start_time
logger.info(f"async {func.__name__} завершена за {elapsed_time:.4f} сек")
return result
except Exception as e:
elapsed_time = time.time() – start_time
logger.exception(
f"async {func.__name__} вызвала исключение после {elapsed_time:.4f} сек: {str(e)}"
)
raise

return wrapper

@async_logged
async def fetch_data(url: str) -> dict:
# Имитация асинхронного запроса
await asyncio.sleep(1)
if "error" in url:
raise ValueError("URL содержит ошибку")
return {"status": "success", "url": url}

# Пример использования
async def main():
try:
data = await fetch_data("https://example.com/api")
print(f"Получены данные: {data}")

# Вызовет исключение
await fetch_data("https://example.com/error")
except Exception:
pass

# asyncio.run(main()) # Раскомментировать для запуска

import contextlib
import logging
from typing import Optional

@contextlib.contextmanager
def function_log_level(func_name: str, level: int, logger: Optional[logging.Logger] = None):
"""
Контекстный менеджер, временно изменяющий уровень логирования для конкретной функции.

Пример:
with function_log_level("process_data", logging.DEBUG):
process_data() # Логи этой функции будут на уровне DEBUG
"""
if logger is None:
logger = logging.getLogger()

# Создаём специальный фильтр для выбранной функции
class FunctionFilter(logging.Filter):
def filter(self, record):
# Проверяем, содержит ли запись логов имя нашей функции
if func_name in record.funcName:
record.levelno = level
record.levelname = logging.getLevelName(level)
return True

# Добавляем фильтр
function_filter = FunctionFilter()
logger.addFilter(function_filter)

try:
yield
finally:
# Удаляем фильтр после завершения контекста
logger.removeFilter(function_filter)

import functools
import time
from collections import defaultdict
import statistics

class Profiler:
"""Класс для профилирования выполнения функций."""

def __init__(self):
self.function_stats = defaultdict(list)
self.enabled = True

def profile(self, func):
"""Декоратор для профилирования функций."""
@functools.wraps(func)
def wrapper(*args, **kwargs):
if not self.enabled:
return func(*args, **kwargs)

start_time = time.time()
result = func(*args, **kwargs)
execution_time = time.time() – start_time

# Сохраняем статистику по имени функции
self.function_stats[func.__name__].append(execution_time)

return result
return wrapper

def print_stats(self):
"""Вывод статистики профилирования."""
print("\nПРОФИЛИРОВАНИЕ ФУНКЦИЙ")
print("-" * 50)
print(f"{'Функция':<30} | {'Вызовы':<8} | {'Сред. время (мс)':<15} | {'Мин. (мс)':<10} | {'Макс. (мс)':<10}")
print("-" * 50)

for func_name, times in sorted(
self.function_stats.items(),
key=lambda x: statistics.mean(x[1]),
reverse=True
):
calls = len(times)
avg_time = statistics.mean(times) * 1000 # в миллисекундах
min_time = min(times) * 1000
max_time = max(times) * 1000

print(f"{func_name:<30} | {calls:<8} | {avg_time:<15.2f} | {min_time:<10.2f} | {max_time:<10.2f}")

@contextlib.contextmanager
def disabled(self):
"""Временно отключает профилирование."""
original = self.enabled
self.enabled = False
try:
yield
finally:
self.enabled = original

# Создание экземпляра профилировщика
profiler = Profiler()

# Применение к функциям
@profiler.profile
def fibonacci(n):
if n <= 1:
return n
return fibonacci(n-1) + fibonacci(n-2)

@profiler.profile
def factorial(n):
if n == 0:
return 1
return n * factorial(n-1)

# Использование функций
fibonacci(20)
factorial(10)

# Вывод статистики
profiler.print_stats()

import functools
import uuid
import time
import json
import threading

# Имитация системы распределенной трассировки
class DistributedTracer:
def __init__(self):
self.traces = {}
self.local = threading.local()

def start_trace(self):
"""Начинает новую трассировку для текущего потока."""
trace_id = str(uuid.uuid4())
self.local.trace_id = trace_id
self.local.span_stack = []
self.traces[trace_id] = {
"start_time": time.time(),
"spans": []
}
return trace_id

def get_current_trace_id(self):
"""Возвращает ID текущей трассировки."""
return getattr(self.local, "trace_id", None)

def trace_function(self, service_name):
"""Декоратор для трассировки функций."""
def decorator(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
# Проверяем, есть ли активная трассировка
trace_id = self.get_current_trace_id()
if trace_id is None:
return func(*args, **kwargs)

# Создаем новый span (сегмент трассировки)
span_id = str(uuid.uuid4())
parent_id = self.local.span_stack[-1] if self.local.span_stack else None

span_data = {
"span_id": span_id,
"parent_id": parent_id,
"function_name": func.__name__,
"service": service_name,
"start_time": time.time()
}

self.local.span_stack.append(span_id)

try:
result = func(*args, **kwargs)
return result
finally:
# Завершаем span
span_data["end_time"] = time.time()
span_data["duration"] = span_data["end_time"] – span_data["start_time"]
self.traces[trace_id]["spans"].append(span_data)
self.local.span_stack.pop()
return wrapper
return decorator

def export_traces(self):
"""Экспортирует собранные трассировки в JSON."""
return json.dumps(self.traces, indent=2)

# Создание трейсера
tracer = DistributedTracer()

# Использование в микросервисах
@tracer.trace_function("auth-service")
def authenticate_user(username, password):
time.sleep(0.1) # Имитация работы
return {"user_id": 123, "username": username}

@tracer.trace_function("profile-service")
def get_user_profile(user_id):
time.sleep(0.2) # Имитация работы
return {"name": "John Doe", "email": "john@example.com"}

@tracer.trace_function("api-gateway")
def process_request():
# Начинаем новую трассировку
tracer.start_trace()

# Имитация процесса обработки запроса через несколько сервисов
user = authenticate_user("user123", "password")
profile = get_user_profile(user["user_id"])

return {"status": "success", "user": user, "profile": profile}

# Выполняем запрос
process_request()

# Экспортируем трассировки
trace_data = tracer.export_traces()
print(trace_data)