Как создать стек в Python

# Добавление элемента в стек (push)
stack.push(item)
 
# Извлечение элемента из стека (pop)
item = stack.pop()
 
# Просмотр верхнего элемента без извлечения (peek)
top_item = stack.peek()

def function_a():
    print("Starting function A")
    function_b()
    print("Back to function A")
 
def function_b():
    print("Inside function B")
 
function_a()

stack = []
stack.append("элемент 1")  # push
stack.append("элемент 2")
last_item = stack.pop()    # pop
print(last_item)  # выведет "элемент 2"

class IneffiecientStack:
    def __init__(self):
        self._items = []
        
    def push(self, item):
        self._items.insert(0, item)  # O(n) операция!
        
    def pop(self):
        if not self._items:
            raise Exception("Стек пуст")
        return self._items.pop(0)    # Тоже O(n)

from collections import deque
 
stack = deque()
stack.append("первый")     # Добавляем в конец
stack.append("второй")
print(stack.pop())         # Получаем с конца: "второй"

class Stack:
    def __init__(self):
        self.__items = []
        
    def push(self, item):
        self.__items.append(item)
        
    def pop(self):
        if len(self) == 0:
            raise Exception("pop() вызван для пустого стека")
        return self.__items.pop()
        
    def peek(self):
        if len(self) == 0:
            raise Exception("peek() вызван для пустого стека")
        return self.__items[-1]
        
    def __len__(self):
        return len(self.__items)
        
    def __str__(self):
        return str(self.__items)

from queue import LifoQueue
 
stack = LifoQueue()
stack.put("задание 1")  # вместо push
stack.put("задание 2")
item = stack.get()      # вместо pop
print(item)             # выведет "задание 2"

from dataclasses import dataclass
from typing import List, Any
 
@dataclass
class StackItem:
    value: Any
    metadata: dict = None
 
class StructuredStack:
    def __init__(self):
        self.__items: List[StackItem] = []
    
    def push(self, value, metadata=None):
        item = StackItem(value, metadata)
        self.__items.append(item)
    
    def pop(self):
        if not self.__items:
            raise Exception("Стек пуст")
        return self.__items.pop()

import array
 
# Создаем массив для целых чисел
int_stack = array.array('i')  # 'i' означает тип signed int
int_stack.append(10)
int_stack.append(20)
print(int_stack.pop())  # выведет 20

import heapq
 
priority_stack = []
# Добавляем элементы с приоритетом (меньшие значения имеют более высокий приоритет)
heapq.heappush(priority_stack, (2, "средний приоритет"))
heapq.heappush(priority_stack, (1, "высокий приоритет"))
heapq.heappush(priority_stack, (3, "низкий приоритет"))
 
# Извлекаем в порядке приоритета
highest_priority = heapq.heappop(priority_stack)
print(highest_priority)  # (1, 'высокий приоритет')

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
 
class LinkedStack:
    def __init__(self):
        self.head = None
        self.size = 0
    
    def push(self, data):
        new_node = Node(data)
        new_node.next = self.head
        self.head = new_node
        self.size += 1
    
    def pop(self):
        if not self.head:
            raise Exception("Стек пуст")
        data = self.head.data
        self.head = self.head.next
        self.size -= 1
        return data
    
    def peek(self):
        if not self.head:
            raise Exception("Стек пуст")
        return self.head.data
    
    def __len__(self):
        return self.size

def create_stack():
    items = []
    
    def push(item):
        items.append(item)
    
    def pop():
        if not items:
            raise IndexError("Попытка извлечь элемент из пустого стека")
        return items.pop()
    
    def peek():
        if not items:
            raise IndexError("Стек пуст")
        return items[-1]
    
    def size():
        return len(items)
    
    return {"push": push, "pop": pop, "peek": peek, "size": size}

my_stack = create_stack()
my_stack["push"](42)
value = my_stack["pop"]()

from contextlib import ExitStack
 
with ExitStack() as stack:
    file1 = stack.enter_context(open('file1.txt'))
    file2 = stack.enter_context(open('file2.txt'))
    # Обе файловые операции будут корректно закрыты

import timeit
import collections
from queue import LifoQueue
 
# Тестирование производительности различных реализаций стека
def test_list_stack():
    stack = []
    for i in range(1000):
        stack.append(i)
    while stack:
        stack.pop()
 
def test_deque_stack():
    stack = collections.deque()
    for i in range(1000):
        stack.append(i)
    while stack:
        stack.pop()
 
def test_lifoqueue_stack():
    stack = LifoQueue()
    for i in range(1000):
        stack.put(i)
    while not stack.empty():
        stack.get()
 
# Измеряем время выполнения
list_time = timeit.timeit(test_list_stack, number=1000)
deque_time = timeit.timeit(test_deque_stack, number=1000)
queue_time = timeit.timeit(test_lifoqueue_stack, number=1000)
 
print(f"Список: {list_time:.4f} сек")
print(f"Deque: {deque_time:.4f} сек")
print(f"LifoQueue: {queue_time:.4f} сек")

class IntuitiveStack:
    def __init__(self):
        self.__items = []
    
    def __iadd__(self, item):
        """Позволяет использовать оператор += для добавления элемента"""
        self.__items.append(item)
        return self
    
    def __isub__(self, _):
        """Позволяет использовать оператор -= для извлечения элемента"""
        if not self.__items:
            raise IndexError("Стек пуст")
        return self.__items.pop()
    
    def __len__(self):
        return len(self.__items)
 
# Использование
stack = IntuitiveStack()
stack += "элемент"  # push
item = stack -= None  # pop

class StateManager:
    def __init__(self):
        self.__undo_stack = []
        self.__redo_stack = []
        self.__current_state = {}
        
    def save_state(self, new_state):
        self.__undo_stack.append(self.__current_state)
        self.__current_state = new_state
        # При создании нового состояния очищаем стек redo
        self.__redo_stack.clear()
        
    def undo(self):
        if not self.__undo_stack:
            return None
            
        self.__redo_stack.append(self.__current_state)
        self.__current_state = self.__undo_stack.pop()
        return self.__current_state
        
    def redo(self):
        if not self.__redo_stack:
            return None
            
        self.__undo_stack.append(self.__current_state)
        self.__current_state = self.__redo_stack.pop()
        return self.__current_state
        
    def get_current_state(self):
        return self.__current_state

import time
from functools import wraps
 
function_stack = []
 
def profiler(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        call_info = {
            'function': func.__name__,
            'args': args,
            'kwargs': kwargs,
            'level': len(function_stack),
            'start_time': time.time()
        }
        
        function_stack.append(call_info)
        print(f"{'  ' * call_info['level']}→ Вызов {func.__name__}")
        
        try:
            result = func(*args, **kwargs)
            return result
        finally:
            if function_stack:
                call_info = function_stack.pop()
                duration = time.time() - call_info['start_time']
                print(f"{'  ' * call_info['level']}← Возврат из {func.__name__} за {duration:.6f} сек")
    
    return wrapper
 
@profiler
def factorial(n):
    if n <= 1:
        return 1
    return n * factorial(n-1)
 
factorial(5)

def check_brackets(expression):
    stack = []
    brackets_map = {')': '(', '}': '{', ']': '['}
    
    for char in expression:
        if char in '({[':
            stack.append(char)
        elif char in ')}]':
            if not stack or stack.pop() != brackets_map[char]:
                return False
    
    return len(stack) == 0
 
# Примеры использования
valid_expr = "{[()]}"
invalid_expr = "([)]"
 
print(check_brackets(valid_expr))    # True
print(check_brackets(invalid_expr))  # False

def dfs_iterative(graph, start_node):
    visited = set()
    stack = [start_node]
    
    while stack:
        current = stack.pop()
        if current not in visited:
            print(f"Обрабатываю узел: {current}")
            visited.add(current)
            
            # Добавляем соседей в стек в обратном порядке,
            # чтобы порядок обхода совпадал с рекурсивной версией
            for neighbor in reversed(graph[current]):
                if neighbor not in visited:
                    stack.append(neighbor)
                    
    return visited
 
# Пример графа в виде списка смежности
graph = {
    'A': ['B', 'C'],
    'B': ['D', 'E'],
    'C': ['F'],
    'D': [],
    'E': ['F'],
    'F': []
}
 
dfs_iterative(graph, 'A')

def infix_to_postfix(expression):
    precedence = {'+': 1, '-': 1, '*': 2, '/': 2, '^': 3}
    stack = []
    output = []
    
    for token in expression.split():
        # Если токен — операнд, добавляем его в выходной список
        if token.isalnum():
            output.append(token)
        # Если токен — открывающая скобка, помещаем её в стек
        elif token == '(':
            stack.append(token)
        # Если токен — закрывающая скобка, выталкиваем всё до открывающей скобки
        elif token == ')':
            while stack and stack[-1] != '(':
                output.append(stack.pop())
            # Удаляем открывающую скобку
            if stack and stack[-1] == '(':
                stack.pop()
        # Если токен — оператор
        else:
            while stack and stack[-1] != '(' and precedence.get(stack[-1], 0) >= precedence.get(token, 0):
                output.append(stack.pop())
            stack.append(token)
    
    # Выталкиваем оставшиеся операторы из стека
    while stack:
        output.append(stack.pop())
        
    return ' '.join(output)
 
# Пример
infix = "3 + 4 * 2 / ( 1 - 5 ) ^ 2"
postfix = infix_to_postfix(infix)
print(f"Инфиксная запись: {infix}")
print(f"Постфиксная запись: {postfix}")

def evaluate_postfix(expression):
    stack = []
    
    for token in expression.split():
        if token.isdigit():
            stack.append(int(token))
        else:
            b = stack.pop()
            a = stack.pop()
            
            if token == '+':
                stack.append(a + b)
            elif token == '-':
                stack.append(a - b)
            elif token == '*':
                stack.append(a * b)
            elif token == '/':
                stack.append(a / b)
            elif token == '^':
                stack.append(a ** b)
    
    return stack.pop()

class RequestContext:
    def __init__(self, service_id, request_data):
        self.service_id = service_id
        self.request_data = request_data
        self.timestamp = time.time()
        
class ServiceBus:
    def __init__(self):
        self._context_stack = []
        
    def call_service(self, service_id, request_data):
        # Сохраняем контекст вызова
        context = RequestContext(service_id, request_data)
        self._context_stack.append(context)
        
        try:
            # Обработка запроса...
            response = self._process_request(service_id, request_data)
            return response
        finally:
            # Возвращаемся к предыдущему контексту
            self._context_stack.pop()
    
    def get_current_context(self):
        if not self._context_stack:
            return None
        return self._context_stack[-1]

def recursive_find(directory, pattern):
    """Рекурсивный поиск файлов по шаблону (для сравнения)"""
    result = []
    for entry in os.listdir(directory):
        full_path = os.path.join(directory, entry)
        if os.path.isdir(full_path):
            result.extend(recursive_find(full_path, pattern))
        elif fnmatch.fnmatch(entry, pattern):
            result.append(full_path)
    return result
 
def iterative_find(directory, pattern):
    """Итеративный поиск с использованием стека"""
    result = []
    stack = [directory]
    
    while stack:
        current_dir = stack.pop()
        for entry in os.listdir(current_dir):
            full_path = os.path.join(current_dir, entry)
            if os.path.isdir(full_path):
                stack.append(full_path)
            elif fnmatch.fnmatch(entry, pattern):
                result.append(full_path)
    
    return result

class LazyProcessor:
    def __init__(self):
        self._operations_stack = []
        self._result = None
        
    def add_operation(self, operation, *args, **kwargs):
        self._operations_stack.append((operation, args, kwargs))
        return self
        
    def compute(self, initial_value=None):
        if self._result is not None:
            return self._result
            
        result = initial_value
        # Выполняем операции в обратном порядке (LIFO)
        while self._operations_stack:
            operation, args, kwargs = self._operations_stack.pop()
            result = operation(result, *args, **kwargs)
            
        self._result = result
        return result

import timeit
import random
from collections import deque
from queue import LifoQueue
 
# Подготовка тестовых данных
test_data = [random.randint(1, 1000) for _ in range(10000)]
 
# Тестирование списка как стека
def test_list():
    stack = []
    for item in test_data:
        stack.append(item)  # push
    while stack:
        stack.pop()  # pop
 
# Тестирование deque как стека
def test_deque():
    stack = deque()
    for item in test_data:
        stack.append(item)  # push
    while stack:
        stack.pop()  # pop
 
# Тестирование LifoQueue как стека
def test_lifo_queue():
    stack = LifoQueue()
    for item in test_data:
        stack.put(item)  # push
    while not stack.empty():
        stack.get()  # pop
 
# Замеры времени
list_time = timeit.timeit(test_list, number=100)
deque_time = timeit.timeit(test_deque, number=100)
queue_time = timeit.timeit(test_lifo_queue, number=100)

import array
import sys
 
# Сравнение потребления памяти
int_list = [i for i in range(10000)]
int_array = array.array('i', range(10000))
 
print(f"Список: {sys.getsizeof(int_list) + sum(sys.getsizeof(i) for i in int_list)} байт")
print(f"Массив: {sys.getsizeof(int_array)} байт")

class ResizableStack:
    def __init__(self, initial_capacity=10):
        self.__capacity = initial_capacity
        self.__size = 0
        self.__items = [None] * initial_capacity
    
    def push(self, item):
        if self.__size == self.__capacity:
            self.__resize(2 * self.__capacity)
        self.__items[self.__size] = item
        self.__size += 1
    
    def pop(self):
        if self.__size == 0:
            raise Exception("Стек пуст")
        
        self.__size -= 1
        item = self.__items[self.__size]
        self.__items[self.__size] = None  # Помогаем сборщику мусора
        
        # Уменьшаем размер массива, если он заполнен менее чем на 25%
        if self.__size > 0 and self.__size == self.__capacity // 4:
            self.__resize(self.__capacity // 2)
            
        return item
    
    def __resize(self, new_capacity):
        new_array = [None] * new_capacity
        for i in range(self.__size):
            new_array[i] = self.__items[i]
        self.__items = new_array
        self.__capacity = new_capacity

import threading
import time
from queue import LifoQueue
 
class SynchronizedListStack:
    def __init__(self):
        self._items = []
        self._lock = threading.Lock()
    
    def push(self, item):
        with self._lock:
            self._items.append(item)
    
    def pop(self):
        with self._lock:
            if not self._items:
                raise IndexError("pop from empty stack")
            return self._items.pop()
 
def threaded_test(stack_type, n_threads, operations_per_thread):
    if stack_type == "lifo_queue":
        stack = LifoQueue()
        push_op = stack.put
        pop_op = stack.get
    else:
        stack = SynchronizedListStack()
        push_op = stack.push
        pop_op = stack.pop
    
    def worker():
        for i in range(operations_per_thread):
            push_op(i)
            pop_op()
    
    threads = []
    start_time = time.time()
    
    for _ in range(n_threads):
        t = threading.Thread(target=worker)
        threads.append(t)
        t.start()
    
    for t in threads:
        t.join()
    
    return time.time() - start_time

class OptimizedStack:
    def __init__(self):
        self._items = []
        self._lock = threading.RLock()  # Позволяет повторно захватывать блокировку одним потоком
    
    def push(self, item):
        with self._lock:
            self._items.append(item)
    
    def pop(self):
        with self._lock:
            if not self._items:
                raise IndexError("pop from empty stack")
            return self._items.pop()
    
    def peek(self):
        with self._lock:
            if not self._items:
                raise IndexError("peek at empty stack")
            return self._items[-1]

class ObjectPool:
    def __init__(self, create_func, max_size=100):
        self._create_func = create_func
        self._pool = []
        self._max_size = max_size
        self._lock = threading.RLock()
    
    def acquire(self):
        with self._lock:
            if self._pool:
                return self._pool.pop()
            return self._create_func()
    
    def release(self, obj):
        with self._lock:
            if len(self._pool) < self._max_size:
                self._pool.append(obj)

import numpy as np
 
class NumPyStack:
    def __init__(self, dtype=np.float64, initial_capacity=1000):
        self._data = np.zeros(initial_capacity, dtype=dtype)
        self._size = 0
        self._capacity = initial_capacity
    
    def push(self, value):
        if self._size == self._capacity:
            self._resize(2 * self._capacity)
        
        self._data[self._size] = value
        self._size += 1
    
    def pop(self):
        if self._size == 0:
            raise IndexError("Pop from empty stack")
        
        self._size -= 1
        return self._data[self._size]
    
    def _resize(self, new_capacity):
        new_data = np.zeros(new_capacity, dtype=self._data.dtype)
        new_data[:self._size] = self._data[:self._size]
        self._data = new_data
        self._capacity = new_capacity

from typing import TypeVar, Generic, List, Optional
 
T = TypeVar('T')  # Определяем обобщенный тип
 
class TypedStack(Generic[T]):
    def __init__(self):
        self._items: List[T] = []
    
    def push(self, item: T) -> None:
        self._items.append(item)
    
    def pop(self) -> T:
        if not self._items:
            raise IndexError("Попытка извлечь элемент из пустого стека")
        return self._items.pop()
    
    def peek(self) -> T:
        if not self._items:
            raise IndexError("Стек пуст")
        return self._items[-1]
    
    def __len__(self) -> int:
        return len(self._items)

# Создаем стек для целых чисел
int_stack = TypedStack[int]()
int_stack.push(42)
int_stack.push("строка")  # Ошибка типа, обнаружимая статическим анализатором

from typing import List, Callable, Any, Dict
 
class Observable:
    def __init__(self):
        self._observers: List[Callable[[str, Any], None]] = []
    
    def add_observer(self, callback: Callable[[str, Any], None]) -> None:
        self._observers.append(callback)
    
    def notify(self, event: str, data: Any) -> None:
        for callback in self._observers:
            callback(event, data)
 
class UndoableStack(Observable):
    def __init__(self):
        super().__init__()
        self._stack: List[Dict[str, Any]] = []
    
    def push(self, action: str, data: Any, metadata: Dict = None) -> None:
        item = {"action": action, "data": data, "metadata": metadata or {}}
        self._stack.append(item)
        self.notify("push", item)
    
    def pop(self) -> Dict[str, Any]:
        if not self._stack:
            raise IndexError("Стек пуст")
        item = self._stack.pop()
        self.notify("pop", item)
        return item

class RobustStack:
    def __init__(self, max_size: Optional[int] = None):
        self._items: List = []
        self._max_size = max_size
    
    def push(self, item, force: bool = False) -> bool:
        if self._max_size and len(self._items) >= self._max_size and not force:
            return False  # Стек переполнен
        
        try:
            self._items.append(item)
            return True
        except Exception as e:
            logging.error(f"Ошибка при добавлении элемента в стек: {e}")
            return False
    
    def pop(self, default=None) -> Any:
        if not self._items:
            return default  # Возвращаем значение по умолчанию вместо исключения
        
        try:
            return self._items.pop()
        except Exception as e:
            logging.error(f"Ошибка при извлечении элемента из стека: {e}")
            return default

import pickle
import os
from typing import TypeVar, Generic, List
 
T = TypeVar('T')
 
class PersistentStack(Generic[T]):
    def __init__(self, storage_path: str):
        self._items: List[T] = []
        self._storage_path = storage_path
        self._load()
    
    def push(self, item: T) -> None:
        self._items.append(item)
        self._save()
    
    def pop(self) -> T:
        if not self._items:
            raise IndexError("Стек пуст")
        item = self._items.pop()
        self._save()
        return item
    
    def _save(self) -> None:
        with open(self._storage_path, 'wb') as f:
            pickle.dump(self._items, f)
    
    def _load(self) -> None:
        if os.path.exists(self._storage_path):
            try:
                with open(self._storage_path, 'rb') as f:
                    self._items = pickle.load(f)
            except Exception as e:
                logging.error(f"Ошибка загрузки стека: {e}")
                self._items = []

import threading
from typing import TypeVar, Generic, List, Optional
 
T = TypeVar('T')
 
class ConcurrentStack(Generic[T]):
def __init__(self):
    self._items: List[T] = []
    self._lock = threading.RLock()  # Рекурсивная блокировка для вложенных вызовов
    self._not_empty = threading.Condition(self._lock)
    
def push(self, item: T) -> None:
    with self._lock:
        self._items.append(item)
        self._not_empty.notify()  # Уведомляем ожидающие потоки
        
def pop(self, timeout: Optional[float] = None) -> T:
    with self._not_empty:
        # Если стек пуст, ждем уведомления или таймаута
        if not self._items and timeout is not None:
            self._not_empty.wait(timeout)
        
        if not self._items:
            raise IndexError("Стек пуст")
            
        return self._items.pop()
        
def try_pop(self) -> Optional[T]:
    with self._lock:
        if not self._items:
            return None
        return self._items.pop()

class BoundedStack(Generic[T]):
def __init__(self, capacity: int):
    if capacity <= 0:
        raise ValueError("Размер стека должен быть положительным числом")
    self._items: List[T] = []
    self._capacity = capacity
    
def push(self, item: T) -> bool:
    if len(self._items) >= self._capacity:
        return False  # Стек переполнен
        
    self._items.append(item)
    return True
    
def pop(self) -> T:
    if not self._items:
        raise IndexError("Стек пуст")
    return self._items.pop()
    
def is_full(self) -> bool:
    return len(self._items) >= self._capacity

class FunctionalStack(Generic[T]):
def __init__(self):
    self._items: List[T] = []
    
def push(self, item: T) -> None:
    self._items.append(item)
    
def pop(self) -> T:
    if not self._items:
        raise IndexError("Стек пуст")
    return self._items.pop()
    
def map(self, func) -> 'FunctionalStack':
    """Создает новый стек, применяя функцию к каждому элементу"""
    result = FunctionalStack()
    # Применяем в обратном порядке, чтобы сохранить исходный порядок
    for item in reversed(self._items):
        result.push(func(item))
    return result
    
def filter(self, predicate) -> 'FunctionalStack':
    """Создает новый стек с элементами, удовлетворяющими предикату"""
    result = FunctionalStack()
    # Фильтруем в обратном порядке
    for item in reversed(self._items):
        if predicate(item):
            result.push(item)
    return result
    
def reduce(self, func, initial_value):
    """Применяет функцию свертки к элементам стека"""
    result = initial_value
    # Проходим от вершины стека к основанию
    for item in self._items:
        result = func(result, item)
    return result

class ImmutableStack(Generic[T]):
def __init__(self, items=None):
    self._items = tuple(items or [])
    
def push(self, item: T) -> 'ImmutableStack[T]':
    """Возвращает новый стек с добавленным элементом"""
    return ImmutableStack((item,) + self._items)
    
def pop(self) -> tuple['ImmutableStack[T]', T]:
    """Возвращает кортеж из нового стека (без верхнего элемента) и верхнего элемента"""
    if not self._items:
        raise IndexError("Стек пуст")
    return ImmutableStack(self._items[1:]), self._items[0]
    
def peek(self) -> T:
    if not self._items:
        raise IndexError("Стек пуст")
    return self._items[0]
    
def __len__(self) -> int:
    return len(self._items)

import asyncio
from typing import TypeVar, Generic, List, Optional
 
T = TypeVar('T')
 
class AsyncStack(Generic[T]):
def __init__(self):
    self._items: List[T] = []
    self._lock = asyncio.Lock()
    self._not_empty = asyncio.Condition(self._lock)
 
async def push(self, item: T) -> None:
    async with self._lock:
        self._items.append(item)
        self._not_empty.notify()
 
async def pop(self, timeout: Optional[float] = None) -> T:
    async with self._not_empty:
        if not self._items:
            try:
                await asyncio.wait_for(self._not_empty.wait(), timeout)
            except asyncio.TimeoutError:
                raise IndexError("Ожидание элемента в стеке превысило таймаут")
                
        if not self._items:
            raise IndexError("Стек пуст")
            
        return self._items.pop()

import time
from typing import TypeVar, Generic, Dict, List, Tuple, Any, Optional
 
T = TypeVar('T')
 
class ExpiringCacheStack(Generic[T]):
def __init__(self, ttl_seconds: float = 60.0):
    self._items: List[Tuple[float, T]] = []  # [(timestamp, item), ...]
    self._ttl = ttl_seconds
    self._cache: Dict[Any, T] = {}  # Кэш для быстрого поиска
 
def push(self, item: T, key: Any = None) -> None:
    timestamp = time.time()
    self._items.append((timestamp, item))
    
    if key is not None:
        self._cache[key] = item
    
    # Очистка устаревших элементов
    self._cleanup()
 
def pop(self) -> Optional[T]:
    self._cleanup()
    
    if not self._items:
        return None
        
    timestamp, item = self._items.pop()
    
    # Удаляем элемент из кэша, если он там есть
    for k, v in list(self._cache.items()):
        if v is item:
            del self._cache[k]
            break
            
    return item
 
def get_by_key(self, key: Any) -> Optional[T]:
    return self._cache.get(key)
 
def _cleanup(self) -> None:
    """Удаляет элементы с истекшим сроком действия"""
    current_time = time.time()
    cutoff_time = current_time - self._ttl
    
    # Удаляем старые элементы с начала списка
    while self._items and self._items[0][0] < cutoff_time:
        _, expired_item = self._items.pop(0)
        
        # Удаляем из кэша
        for k, v in list(self._cache.items()):
            if v is expired_item:
                del self._cache[k]
                break

class LoggingStackDecorator:
def __init__(self, stack):
    self._stack = stack
    self._logger = logging.getLogger(__name__)
 
def push(self, item):
    self._logger.debug(f"Добавление элемента в стек: {item}")
    return self._stack.push(item)
 
def pop(self):
    item = self._stack.pop()
    self._logger.debug(f"Извлечение элемента из стека: {item}")
    return item
 
# Делегирование остальных методов
def __getattr__(self, name):
    return getattr(self._stack, name)

from typing import TypeVar, Generic, List, Dict, Any, Optional, Union, Callable
from collections import deque
import threading
import time
import pickle
import os
import logging
 
T = TypeVar('T')  # Обобщенный тип для элементов стека
 
class StackManager(Generic[T]):
    """Универсальный менеджер стеков с поддержкой различных реализаций"""
    
    IMPLEMENTATIONS = ['list', 'deque', 'thread_safe', 'persistent', 'bounded']
    
    def __init__(self, implementation: str = 'list', **kwargs):
        self._logger = logging.getLogger(__name__)
        self._implementation = implementation
        self._options = kwargs
        
        if implementation == 'list':
            self._stack: List[T] = []
        elif implementation == 'deque':
            self._stack = deque()
        elif implementation == 'thread_safe':
            self._stack = []
            self._lock = threading.RLock()
        elif implementation == 'persistent':
            self._stack = []
            self._storage_path = kwargs.get('storage_path', 'stack.pickle')
            self._load()
        elif implementation == 'bounded':
            self._stack = []
            self._capacity = kwargs.get('capacity', 100)
        else:
            raise ValueError(f"Неподдерживаемая реализация: {implementation}")
        
        self._hooks: Dict[str, List[Callable]] = {
            'before_push': [],
            'after_push': [],
            'before_pop': [],
            'after_pop': []
        }
    
    def push(self, item: T) -> bool:
        """Добавляет элемент в стек"""
        self._run_hooks('before_push', item)
        
        try:
            if self._implementation == 'list' or self._implementation == 'deque':
                self._stack.append(item)
            elif self._implementation == 'thread_safe':
                with self._lock:
                    self._stack.append(item)
            elif self._implementation == 'persistent':
                self._stack.append(item)
                self._save()
            elif self._implementation == 'bounded':
                if len(self._stack) >= self._capacity:
                    self._logger.warning("Стек достиг максимальной емкости")
                    return False
                self._stack.append(item)
                
            self._run_hooks('after_push', item)
            return True
        except Exception as e:
            self._logger.error(f"Ошибка при добавлении элемента: {e}")
            return False
    
    def pop(self) -> Optional[T]:
        """Извлекает элемент из стека"""
        self._run_hooks('before_pop')
        
        if not self._stack:
            self._logger.warning("Попытка извлечь элемент из пустого стека")
            return None
            
        try:
            if self._implementation == 'list' or self._implementation == 'deque':
                item = self._stack.pop()
            elif self._implementation == 'thread_safe':
                with self._lock:
                    item = self._stack.pop()
            elif self._implementation == 'persistent':
                item = self._stack.pop()
                self._save()
            elif self._implementation == 'bounded':
                item = self._stack.pop()
                
            self._run_hooks('after_pop', item)
            return item
        except Exception as e:
            self._logger.error(f"Ошибка при извлечении элемента: {e}")
            return None
    
    def peek(self) -> Optional[T]:
        """Возвращает верхний элемент без извлечения"""
        if not self._stack:
            return None
            
        if self._implementation == 'thread_safe':
            with self._lock:
                return self._stack[-1] if self._stack else None
        
        return self._stack[-1] if self._stack else None
    
    def size(self) -> int:
        """Возвращает текущий размер стека"""
        if self._implementation == 'thread_safe':
            with self._lock:
                return len(self._stack)
        return len(self._stack)
    
    def clear(self) -> None:
        """Очищает стек"""
        if self._implementation == 'thread_safe':
            with self._lock:
                self._stack.clear()
        elif self._implementation == 'persistent':
            self._stack.clear()
            self._save()
        else:
            self._stack.clear()
    
    def add_hook(self, event: str, callback: Callable) -> None:
        """Добавляет хук-функцию для указаного события"""
        if event not in self._hooks:
            raise ValueError(f"Неизвестное событие: {event}")
        self._hooks[event].append(callback)
    
    def _run_hooks(self, event: str, *args) -> None:
        """Запускает все хуки для указаного события"""
        for callback in self._hooks.get(event, []):
            try:
                callback(*args)
            except Exception as e:
                self._logger.error(f"Ошибка в хук-функции {event}: {e}")
    
    def _save(self) -> None:
        """Сохраняет состояние стека на диск (для persistent режима)"""
        if self._implementation != 'persistent':
            return
            
        try:
            with open(self._storage_path, 'wb') as f:
                pickle.dump(self._stack, f)
        except Exception as e:
            self._logger.error(f"Ошибка при сохранении стека: {e}")
    
    def _load(self) -> None:
        """Загружает состояние стека с диска (для persistent режима)"""
        if self._implementation != 'persistent':
            return
            
        if os.path.exists(self._storage_path):
            try:
                with open(self._storage_path, 'rb') as f:
                    self._stack = pickle.load(f)
            except Exception as e:
                self._logger.error(f"Ошибка при загрузке стека: {e}")
                self._stack = []

# Пример использования для отслеживания истории действий
history_stack = StackManager('bounded', capacity=50)
 
def on_user_action(action_type, data):
    history_stack.push({"type": action_type, "data": data, "timestamp": time.time()})
 
# Для сохранения состояния между запусками приложения
settings_stack = StackManager('persistent', storage_path='settings_history.pickle')
 
# Для многопоточной среды
shared_stack = StackManager('thread_safe')
 
# Добавление логирования через хуки
def log_pop(item=None):
    print(f"Извлечен элемент: {item}")
    
shared_stack.add_hook('after_pop', log_pop)