Модуль time в Python: управление временем для эффективного кода

import time

import time

# Получение текущего времени в секундах
current_time = time.time()
print(f"Текущее время (в секундах с начала эпохи): {current_time}")

# Конвертация секунд в читаемый формат
readable_time = time.ctime(current_time)
print(f"Читаемый формат: {readable_time}")

# Получение структуры времени
time_struct = time.localtime(current_time)
print(f"Год: {time_struct.tm_year}")
print(f"Месяц: {time_struct.tm_mon}")
print(f"День: {time_struct.tm_mday}")
print(f"Час: {time_struct.tm_hour}")
print(f"Минута: {time_struct.tm_min}")
print(f"Секунда: {time_struct.tm_sec}")

import time
import random

# Использование time.time() для измерения времени выполнения
def measure_with_time():
start = time.time()

# Выполняем какую-то операцию
result = sum(random.random() for _ in range(1000000))

end = time.time()
return end – start

# Использование time.perf_counter() для более точного измерения
def measure_with_perf_counter():
start = time.perf_counter()

# Та же операция
result = sum(random.random() for _ in range(1000000))

end = time.perf_counter()
return end – start

# Сравнение методов
time_measurement = measure_with_time()
perf_measurement = measure_with_perf_counter()

print(f"Измерение с time.time(): {time_measurement:.6f} секунд")
print(f"Измерение с time.perf_counter(): {perf_measurement:.6f} секунд")

import time

def io_bound_operation():
# Операция ввода-вывода (будет исключена из process_time)
time.sleep(1)
return "Завершено"

# Измерение с учетом времени ожидания I/O
start_perf = time.perf_counter()
io_bound_operation()
end_perf = time.perf_counter()

# Измерение только процессорного времени
start_process = time.process_time()
io_bound_operation()
end_process = time.process_time()

print(f"Полное время (perf_counter): {end_perf – start_perf:.6f} секунд")
print(f"Только CPU время (process_time): {end_process – start_process:.6f} секунд")

import timeit

# Измерение производительности с помощью timeit
execution_time = timeit.timeit(
'sum(random.random() for _ in range(100000))', 
setup='import random', 
number=10
)

print(f"Среднее время выполнения: {execution_time/10:.6f} секунд")

import time

# Приостановить выполнение на 2 секунды
time.sleep(2)
print("Прошло 2 секунды")

import time

def countdown(seconds):
"""Простой таймер обратного отсчета"""
for i in range(seconds, 0, -1):
print(f"Осталось {i} секунд...")
time.sleep(1)
print("Время вышло!")

# Запуск таймера на 5 секунд
countdown(5)

import time
import os

def wait_for_file(filepath, timeout=60):
"""Ожидание появления файла с таймаутом"""
start_time = time.time()
while not os.path.exists(filepath):
# Проверяем, не истек ли таймаут
if time.time() – start_time > timeout:
print(f"Таймаут: файл {filepath} не появился за {timeout} секунд")
return False
print(f"Ожидание файла {filepath}...")
time.sleep(2) # Проверяем каждые 2 секунды
print(f"Файл {filepath} обнаружен!")
return True

# Пример использования
wait_for_file("example.txt", timeout=10)

import asyncio

async def async_countdown(seconds):
"""Асинхронный таймер обратного отсчета"""
for i in range(seconds, 0, -1):
print(f"Осталось {i} секунд...")
await asyncio.sleep(1)
print("Время вышло!")

# Запуск асинхронного таймера
asyncio.run(async_countdown(5))

import time

# Получаем текущее время как структуру
current_time = time.localtime()

# Форматируем время в различные строки
date_string = time.strftime("%d.%m.%Y", current_time)
time_string = time.strftime("%H:%M:%S", current_time)
datetime_string = time.strftime("%Y-%m-%d %H:%M:%S", current_time)
custom_string = time.strftime("%A, %d %B %Y, %I:%M %p", current_time)

print(f"Дата: {date_string}")
print(f"Время: {time_string}")
print(f"Дата и время: {datetime_string}")
print(f"Пользовательский формат: {custom_string}")

import time

# Парсинг строки в структуру времени
time_string = "21.09.2023 14:30:00"
time_struct = time.strptime(time_string, "%d.%m.%Y %H:%M:%S")

print(f"Год: {time_struct.tm_year}")
print(f"Месяц: {time_struct.tm_mon}")
print(f"День: {time_struct.tm_mday}")
print(f"Час: {time_struct.tm_hour}")
print(f"Минута: {time_struct.tm_min}")
print(f"Секунда: {time_struct.tm_sec}")

import time

# Получаем текущее время в секундах с начала эпохи
current_seconds = time.time()
print(f"Текущее время в секундах: {current_seconds}")

# Преобразуем в структуру времени
time_struct = time.localtime(current_seconds)
print(f"Структура времени: {time_struct}")

# Преобразуем структуру времени обратно в секунды
seconds_again = time.mktime(time_struct)
print(f"Снова в секундах: {seconds_again}")

from datetime import datetime
import time

# Получаем текущее время в секундах
timestamp = time.time()

# Преобразуем в объект datetime
dt_object = datetime.fromtimestamp(timestamp)

# Форматируем с использованием методов datetime
formatted_date = dt_object.strftime("%d.%m.%Y %H:%M:%S")
print(f"Отформатированная дата: {formatted_date}")

import time
import requests

def monitor_website_response(url, attempts=5):
"""Измерение времени отклика веб-сайта"""
response_times = []

for i in range(attempts):
start_time = time.perf_counter()
try:
response = requests.get(url, timeout=5)
end_time = time.perf_counter()

if response.status_code == 200:
response_time = end_time – start_time
response_times.append(response_time)
print(f"Запрос {i+1}: {response_time:.4f} секунд")
else:
print(f"Запрос {i+1}: Ошибка, код состояния {response.status_code}")
except Exception as e:
print(f"Запрос {i+1}: Ошибка соединения: {e}")

time.sleep(1) # Пауза между запросами

if response_times:
avg_time = sum(response_times) / len(response_times)
print(f"\nСреднее время отклика: {avg_time:.4f} секунд")
print(f"Минимальное время: {min(response_times):.4f} секунд")
print(f"Максимальное время: {max(response_times):.4f} секунд")
else:
print("\nНе удалось получить данные о времени отклика")

# Пример использования
monitor_website_response("https://www.python.org")

import time

class RateLimiter:
"""Класс для ограничения частоты выполнения операций"""

def __init__(self, max_calls, time_frame):
self.max_calls = max_calls # Максимальное количество вызовов
self.time_frame = time_frame # Временной интервал в секундах
self.calls = [] # История вызовов

def __call__(self, func):
"""Декоратор для ограничения вызовов функции"""
def wrapper(*args, **kwargs):
current_time = time.time()

# Удаляем устаревшие записи о вызовах
self.calls = [call_time for call_time in self.calls 
if current_time – call_time <= self.time_frame]

# Проверяем, не превышен ли лимит
if len(self.calls) >= self.max_calls:
time_to_wait = self.time_frame – (current_time – self.calls[0])
if time_to_wait > 0:
print(f"Превышен лимит запросов. Ожидание {time_to_wait:.2f} секунд...")
time.sleep(time_to_wait)
# Обновляем текущее время после ожидания
current_time = time.time()

# Добавляем текущий вызов в историю
self.calls.append(current_time)

# Выполняем функцию
return func(*args, **kwargs)

return wrapper

# Пример использования декоратора
@RateLimiter(max_calls=3, time_frame=10)
def api_request(endpoint):
print(f"Выполняется запрос к {endpoint}. Время: {time.strftime('%H:%M:%S')}")
# Здесь был бы реальный API-запрос
return {"status": "success"}

# Тестируем ограничитель
for i in range(10):
api_request(f"/api/endpoint/{i}")

import time
import functools

def profile(func):
"""Декоратор для профилирования функций"""
@functools.wraps(func)
def wrapper(*args, **kwargs):
start_time = time.perf_counter()
result = func(*args, **kwargs)
end_time = time.perf_counter()

execution_time = end_time – start_time
print(f"Функция '{func.__name__}' выполнилась за {execution_time:.6f} секунд")

return result
return wrapper

# Пример использования декоратора
@profile
def fibonacci(n):
"""Вычисление числа Фибоначчи рекурсивно"""
if n <= 1:
return n
return fibonacci(n-1) + fibonacci(n-2)

# Вызов функции с профилированием
result = fibonacci(30)
print(f"Результат: {result}")

import time
import threading

class TaskScheduler:
"""Простой планировщик задач с периодическим выполнением"""

def __init__(self):
self.tasks = {}
self.running = True

def add_task(self, name, interval, task_func, *args, **kwargs):
"""Добавление задачи для периодического выполнения"""
self.tasks[name] = {
'interval': interval,
'function': task_func,
'args': args,
'kwargs': kwargs,
'last_run': 0,
'thread': None
}

def _run_task(self, name):
"""Выполнение задачи в отдельном потоке"""
task = self.tasks[name]
while self.running:
current_time = time.time()
if current_time – task['last_run'] >= task['interval']:
task['function'](*task['args'], **task['kwargs'])
task['last_run'] = current_time

time.sleep(0.1) # Небольшая задержка для экономии ресурсов

def start(self):
"""Запуск всех задач"""
for name, task in self.tasks.items():
thread = threading.Thread(target=self._run_task, args=(name,))
thread.daemon = True
thread.start()
task['thread'] = thread
print(f"Задача '{name}' запущена")

def stop(self):
"""Остановка всех задач"""
self.running = False
time.sleep(0.2) # Даем потокам время для завершения
print("Планировщик остановлен")

# Функции для тестирования
def log_time():
print(f"Текущее время: {time.strftime('%H:%M:%S')}")

def check_status(service_name):
print(f"Проверка статуса сервиса '{service_name}': OK")

# Пример использования планировщика
scheduler = TaskScheduler()
scheduler.add_task("time_logger", 5, log_time)
scheduler.add_task("service_checker", 7, check_status, "database")

# Запускаем задачи
scheduler.start()

# Даем задачам поработать некоторое время
try:
time.sleep(30)
except KeyboardInterrupt:
pass

# Останавливаем планировщик
scheduler.stop()

import time
import random
import matplotlib.pyplot as plt

def measure_operation_time(operation, sizes):
"""Измерение времени выполнения операции для разных размеров входных данных"""
times = []

for size in sizes:
# Подготавливаем данные
data = [random.random() for _ in range(size)]

# Измеряем время
start = time.perf_counter()
operation(data)
end = time.perf_counter()

times.append(end – start)
print(f"Размер: {size}, Время: {end – start:.6f} секунд")

return times

# Определяем операции для тестирования
def sort_operation(data):
return sorted(data)

def sum_operation(data):
return sum(data)

# Размеры входных данных
sizes = [1000, 10000, 100000, 1000000]

# Измеряем время для каждой операции
sort_times = measure_operation_time(sort_operation, sizes)
sum_times = measure_operation_time(sum_operation, sizes)

# Строим график (требуется matplotlib)
plt.figure(figsize=(10, 6))
plt.plot(sizes, sort_times, 'o-', label='Сортировка')
plt.plot(sizes, sum_times, 's-', label='Суммирование')
plt.xscale('log')
plt.yscale('log')
plt.xlabel('Размер данных')
plt.ylabel('Время выполнения (секунды)')
plt.title('Сравнение производительности операций')
plt.legend()
plt.grid(True)
plt.savefig('performance_comparison.png')
plt.show()

print("График сохранен в файл 'performance_comparison.png'")