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

Вот удобная таблица только **методов списков Python** (без встроенных функций и операторов), сгруппированных по назначению:

| Категория                                                               | Методы                              | Краткое описание                                                                  |
|-------------------------------------------------------------------------| ----------------------------------- |-----------------------------------------------------------------------------------|
| [**Анализ содержимого**](#анализ-содержимого)                           | `count(x)`                          | Возвращает количество вхождений <br> элемента `x` в список.                       |
|                                                                         | `index(x, start=0, stop=len(list))` | Возвращает индекс первого вхождения <br> элемента `x` (ошибка, если нет).         |
| [**Изменение элементов**](#изменение-элементов)                         | `reverse()`                         | Разворачивает список на месте.                                                    |
|                                                                         | `sort(key=None, reverse=False)`     | Сортирует список на месте.                                                        |
| [**Добавление новых элементов**](#добавление-новых-элементов)           | `append(x)`                         | Добавляет элемент `x` в конец списка.                                             |
|                                                                         | `extend(iterable)`                  | Расширяет список элементами из `iterable`.                                        |
|                                                                         | `insert(i, x)`                      | Вставляет элемент `x` на позицию `i`.                                             |
| [**Удаление существующих элементов**](#удаление-существующих-элементов) | `remove(x)`                         | Удаляет первое вхождение элемента `x`.                                            |
|                                                                         | `pop(i=-1)`                         | Удаляет элемент по индексу `i` <br> (по умолчанию — `i=-1`) и возвращает его.     |
|                                                                         | `clear()`                           | Очищает список полностью.                                                         |

## Анализ содержимого

### `count(x)` 

* Подсчитывает количество вхождений `x` в список.
* Возвращает `int` (0, если нет вхождений).

```python
lst = [1, 2, 2, 3, 2]
print(lst.count(2))   # 3
print(lst.count(5))   # 0
```

### `index(x[, start=0[, stop=len(lst)]])`

* Возвращает индекс *первого* вхождения `x` в диапазоне `[start:stop]`.
* Возвращает `int` — индекс.
* Исключение `ValueError`, если `x` не найден.

```python
lst = ['a', 'b', 'c', 'b']
print(lst.index('b'))      # 1
print(lst.index('b', 2))   # 3
# если не найдено — ValueError
# lst.index('z')  -> ValueError: 'z' is not in list
```

## Изменение элементов

### `reverse()`

* Разворачивает порядок элементов *на месте* (in-place).
* Возвращает `None` (типично для методов, которые мутируют список).

```python
lst = [1, 2, 3]
res = lst.reverse()
print(lst)   # [3, 2, 1]
print(res)   # None
```

### `sort(key=None, reverse=False)`

* Сортирует элементы *на месте* согласно ключу `key` и направлению `reverse`.
  * `key` — функция, принимающая элемент и возвращающая значение для сравнения.
…

## `sorted(iterable, *, key=None, reverse=False)`

  * `iterable` — любой итерируемый объект.
  * `key` — функция для вычисления ключа сортировки (например, `key=str.lower`).
  * `reverse` — если `True`, сортирует в обратном порядке.

* Создаёт НОВЫЙ отсортированный список из ЛЮБОГО итерируемого объекта.

* Возвращает новый список с отсортированными элементами (исходный не меняется).

* Исключение: `TypeError` — если элементы нельзя сравнивать между собой и не указан `key`.

```python
nums = [3, 1, 4, 1]
print(sorted(nums))                 # [1, 1, 3, 4]
print(nums)                         # [3, 1, 4, 1] — исходный не изменился

words = ["Banana", "apple", "cherry"]
print(sorted(words))                # ['Banana', 'apple', 'cherry'] (по Unicode)
print(sorted(words, key=str.lower)) # ['apple', 'Banana', 'cherry'] (без учёта регистра)

print(sorted(words, reverse=True))  # ['cherry', 'apple', 'Banana']
```

⚡ В отличие от метода `.sort()`, `sorted()` **не изменяет** исходный объект, а возвращает **новый список**.

---

## `reversed(seq)`
  * `seq` — объект, который поддерживает индексацию или протокол `__reversed__` (обычно список, кортеж, строка).

* Возвращает объект (итератор). Чтобы получить список, можно обернуть в `list()`.

```python
nums = [10, 20, 30]

rev = reversed(nums)
print(rev)              # <list_reverseiterator object ...>
print(list(rev))        # [30, 20, 10]

# Строки тоже работают
print(''.join(reversed("Python")))  # nohtyP

# Кортежи
t = (1, 2, 3)
print(tuple(reversed(t)))  # (3, 2, 1)
```

⚡ В отличие от метода `.reverse()`, функция `reversed()` **не изменяет исходный список**, а возвращает **итератор**, который читает элементы в обратном порядке.

---

### Сравнение функций `sorted()` и `reversed()` с методами `.sort()` и `.reverse()`

|                     | **sorted()**        | **.sort()**      | **reversed()**                                  | **.reverse()**   |
| ------------------- | ------------------- | ---------------- |-------------------------------------------------| ---------------- |
| Возвращает          | Новый список        | `None`           | Итератор                                        | `None`           |
| Исходный изменяется | ❌                   | ✅                | ❌                                               | ✅                |
| Применимо к         | Любому итерируемому | Только к спискам | Последовательности <br> (строки, списки, тюплы) | Только к спискам |
| Тип                 | Функция             | Метод            | Функция                                         | Метод            |
…

# Новый взгляд на функции `min()` и `max()`

## `min()`
  * `iterable` — итерируемый объект (список, строка, кортеж…).
  * `arg1, arg2, *args` — отдельные значения для сравнения.
  * `key` — функция, которая вычисляет значение для сравнения (работает так же, как в `sorted()`).
  * `default` — значение, которое возвращается, если **iterable пуст** (иначе ошибка).

* Находит **минимальный элемент**:
  * `min(iterable, *, key=None, default)`
    * если передан **один аргумент** — должен быть итерируемым (список, строка, множество…);
  * `min(arg1, arg2, *args, key=None)`
    * если передано **несколько аргументов** — сравниваются они напрямую.

* Возвращает:
  * Наименьший элемент 
  * (или `default`, если iterable пуст и указан `default`).

* **Исключения:**

  * `ValueError`, если iterable пуст и `default` не задан.
  * `TypeError`, если элементы несравнимы и не указан `key`.

```python
nums = [5, 2, 9]
print(min(nums))              # 2
print(min(5, 2, 9))           # 2

# Параметр key
words = ["apple", "banana", "pear"]
print(min(words))                 # 'apple' (по алфавиту)
print(min(words, key=len))        # 'pear' (короче всего — длина 4)

# Пустой список
print(min([], default="нет"))     # 'нет'
# min([])  # ValueError: min() arg is an empty sequence
```

---

## `max()`
  * `iterable` — итерируемый объект (список, строка, кортеж…).
  * `arg1, arg2, *args` — отдельные значения для сравнения.
  * `key` — функция, которая вычисляет значение для сравнения (работает так же, как в `sorted()`).
  * `default` — значение, которое возвращается, если **iterable пуст** (иначе ошибка).

* Находит **максимальный элемент**:
  * `min(iterable, *, key=None, default)`
    * если передан **один аргумент** — должен быть итерируемым (список, строка, множество…);
  * `min(arg1, arg2, *args, key=None)`
    * если передано **несколько аргументов** — сравниваются они напрямую.

* Возвращает:
  * Наибольший элемент 
  * (или `default`, если iterable пуст и указан `default`).

* **Исключения:**

  * `ValueError`, если iterable пуст и `default` не задан.
  * `TypeError`, если элементы несравнимы и не указан `key`.
…

## Новый взгляд на функцию `sum(iterable, /, start=0)`

  * `iterable` — итерируемый объект, элементы которого можно складывать (обычно числа).
  * `start` — начальное значение суммы (по умолчанию `0`).

* Суммирует числовые элементы итерируемого объекта (список и т.д.), начиная с начального значения `start`.

* Возвращает сумму всех элементов + значение `start`.

* Исключение: `TypeError`, если элементы не числовые или не итерируемые.


```python
nums = [1, 2, 3, 4]
print(sum(nums))           # 10

# Начальное значение (start)
print(sum(nums, 10))       # 20  (10 + 1 + 2 + 3 + 4)

# Можно суммировать тюплы
t = (5, 5, 5)
print(sum(t))              # 15

# НЕЛЬЗЯ для строк:
# sum(["a", "b", "c"]) -> TypeError: unsupported operand type(s)
```