import asyncio

def cache(func):
    cache = {}
    
    async def wrapper(*args):
        if args not in cache:
            cache[args] = await func(*args)
        return cache[args]
    
    return wrapper

@cache
async def expensive_operation(x):
    await asyncio.sleep(1)
    return x * 2

async def main():
    tasks = [expensive_operation(i) for i in range(3)]
    results = await asyncio.gather(*tasks)
    print(results)

asyncio.run(main())

f = open("data.txt", "r")
data = f.read()
f.close()

with open("data.txt", "r") as f:
    data = f.read()

with open("output.txt", "w") as f:
    f.write("Hello, Python!")

from itertools import groupby
from operator import itemgetter

data = [
    {"user": "alice", "score": 8},
    {"user": "bob",   "score": 5},
    {"user": "alice", "score": 7},
    {"user": "bob",   "score": 9},
]

# Сортируем по ключу
data.sort(key=itemgetter("user"))

# Группируем и считаем средний балл
for user, items in groupby(data, key=itemgetter("user")):
    scores = [i["score"] for i in items]
    print(user, "avg score:", sum(scores) / len(scores))

import time
import threading
from collections import OrderedDict

class TTLLRUCache:
    def __init__(self, maxsize=1024):
        self.maxsize = maxsize
        self._cache = OrderedDict()
        self._lock = threading.RLock()
        self._expiry_times = {}

    def get(self, key):
        with self._lock:
            if key not in self._cache:
                return None
            
            # Ленивое удаление просроченного ключа
            if self._is_expired(key):
                self._delete(key)
                return None
            
            # Обновляем порядок использования (LRU)
            self._cache.move_to_end(key)
            return self._cache[key]

    def set(self, key, value, ttl=None):
        with self._lock:
            # Вытеснение старых записей при достижении лимита
            if len(self._cache) >= self.maxsize:
                self._evict()
            
            self._cache[key] = value
            self._cache.move_to_end(key)
            self._expiry_times[key] = time.time() + ttl if ttl else None

    def delete(self, key):
        with self._lock:
            self._delete(key)

    def _delete(self, key):
        self._cache.pop(key, None)
        self._expiry_times.pop(key, None)

    def clear(self):
        with self._lock:
            self._cache.clear()
            self._expiry_times.clear()

    def _is_expired(self, key):
        expiry = self._expiry_times.get(key)
        return expiry is not None and expiry < time.time()

    def _evict(self):
        # Сначала удаляем просроченные ключи
        expired_keys = [k for k in self._cache if self._is_expired(k)]
        for k in expired_keys:
            self._delete(k)
        
        # Если после этого кэш всё ещё полон, применяем LRU
        if len(self._cache) >= self.maxsize:
            self._cache.popitem(last=False)

    def __contains__(self, key):
        with self._lock:
            if key not in self._cache:
                return False
            if self._is_expired(key):
                self._delete(key)
                return False
            return True