📦 Репозиторий занятия 40

## Модуль `time`

Предоставляет функции для работы со временем: 
* получение текущего времени,
* паузы выполнения программы, 
* работу с таймерами 
* преобразование времени между различными форматами,
* и т.д. и т.п.

---

## **Основные функции**

1. **`time.time()`**

   * Возвращает текущее время в секундах с начала эпохи (обычно 1 января 1970 года, UTC).
   * Пример:

      ```python
     
      import time
      print(time.time())  # 1700000000.123456
      ```

2. **`time.sleep(secs)`**

   * Приостанавливает выполнение программы на указанное количество секунд.
   * Пример:

       ```python
       import time
       time.sleep(2)  # пауза на 2 секунды
       ```

3. **`time.strftime(format, t)`**

   * Преобразует структуру времени `t` в строку по заданному формату.
   * Пример:

       ```python
       import time
     
       t = time.localtime()
       print(time.strftime("%Y-%m-%d %H:%M:%S", t))  # '2025-10-19 14:23:01'
       ```
     
[Таблица перекодировки](https://docs.python.org/3.12/library/time.html#time.strftime)

4. **`time.strptime(string, format)`**

   * Преобразует строку времени в структуру времени по заданному формату.
   * Пример:

      ```python
      import time
     
      t = time.strptime("2025-10-19 14:23:01", "%Y-%m-%d %H:%M:%S")
      print(t)
      ```

…

# Модуль `collections`

Это стандартный модуль Python, который предоставляет альтернативные структуры данных  
к встроенным типам (list, dict, tuple, set), с дополнительной функциональностью.  
Он упрощает работу с данными и делает код более читаемым и эффективным.

## 1. `OrderedDict`
   
Словарь, который запоминает порядок добавления элементов (более корректно, чем обычный dict).  

Поддерживает все методы `dict`, плюс два дополнительных метода:

* `move_to_end(key, last=True)` — перемещает элемент в конец или начало,
* `popitem(last=True)` — удаляем пару из конца (`last=True`) или начала (`last=False`)

---

## 2. `Counter`

Counter — это подкласс словаря (`dict)`, специально предназначенный для подсчёта количества   
вхождений элементов в коллекции (например, в списке, строке или другом итерируемом объекте).

Каждый элемент хранится как ключ, а количество его вхождений — как значение.

`Counter` принимает итерированную последовательность и возвращает отсортированный по убыванию словарь,  
где 
- ключи - элементы итерированной последовательности
- значения - частота их повторений

```python
from collections import Counter

iterable_object = ['a','b','a','c','a','b']
c = Counter(iterable_object)
print(c)                 # Counter({'a': 3, 'b': 2, 'c': 1})
print(c.most_common(2))  # [('a', 3), ('b', 2)]
```

### Основные методы `Counter`

#### 1. `most_common([n])`

Возвращает список из `n` самых частых элементов и их счётчиков.
Если `n` не указано — возвращает все элементы, отсортированные по убыванию частоты.

```python
c = Counter('abracadabra')
print(c.most_common(3))
# [('a', 5), ('b', 2), ('r', 2)]
```
#### 2. `elements()`

Возвращает итератор по элементам, повторённым столько раз, сколько их количество.
Элементы возвращаются в порядке, не обязательно упорядоченном.

```python
c = Counter(a=3, b=2, c=1)
print(list(c.elements()))
# ['a', 'a', 'a', 'b', 'b', 'c']
```
…

## Что такое LRU cache?

LRU (Least Recently Used) — это стратегия, при которой из кэша удаляются  
"наименее недавно использованные" элементы, когда кэш заполняется.


### Пример, создания LRU кэша с помощью OrderedDict:

```python
from collections import OrderedDict

cache = OrderedDict()
MAX_SIZE = 3

def put(key, value):
    # если ключ уже есть — удаляем его, чтобы потом вставить как "новый"
    if key in cache:
        cache.pop(key)
    cache[key] = value  # вставляем в конец (новый элемент)
    # если переполнен — удаляем самый старый (первый)
    if len(cache) > MAX_SIZE:
        cache.popitem(last=False)

    print(cache)  # просто показываем текущее состояние

# наполняем кэш
put('a', 1)
put('b', 2)
put('c', 3)
put('a', 1)  # "a" снова используется → переносим в конец
put('d', 4)  # переполнение → удалится "b"

# OrderedDict({'a': 1})
# OrderedDict({'a': 1, 'b': 2})
# OrderedDict({'a': 1, 'b': 2, 'c': 3})
# OrderedDict({'b': 2, 'c': 3, 'a': 1})
# OrderedDict({'c': 3, 'a': 1, 'd': 4})
```

## `functools.lru_cache` 

Это декоратор из стандартной библиотеки Python, который автоматически кэширует результаты функции.  
Он хранит последние (или наиболее часто используемые) результаты вызовов,  
чтобы при повторном вызове с теми же аргументами не пересчитывать результат заново.


## Синтаксис

```python
from functools import lru_cache

@lru_cache(maxsize=128)
def func(args):
    ...
```

**Параметры:**

* `maxsize` — максимальное количество сохранённых вызовов (по умолчанию `maxsize=128`)
  * Если `maxsize=None`, кэш не ограничен по размеру.
* `typed` (по умолчанию `False`) — если `True`, то аргументы разных типов кэшируются отдельно 
  * например, (`1` и `1.0` считаются разными ключами).

---

## Пример с функцией, вычисляющей числа Фибоначчи

```python
from functools import lru_cache

@lru_cache
def fib(n):
    if n < 2:
        return n
    print(n, end=' ')
    return fib(n-1) + fib(n-2)

for i in range(1, 10):
    print(fib(i))
```