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

## 1. Определение списка

**Список** — это упорядоченная изменяемая коллекция элементов,  
которая может содержать объекты любых типов, включая другие списки.

Пример списка:

```python
my_list = [1, 2, 3, 4, 5]
```

* Упорядоченный: элементы имеют определённый индекс (начиная с 0).
* Возможность дублирования элементов: значения элементов в списке могут повторяться
* Изменяемый: можно менять, добавлять или удалять элементы 
  (но без использования встроенных методов мы можем менять только через индексы и слайсы).
* Разнотипный: один список может содержать числа, строки, другие списки и т.д.


---

## 2. Функция `list()`

`list()` — это встроенная функция Python, которая создаёт новый список.

* Если аргумент **не указан**, создаётся пустой список.
* Если аргумент **итерируемый** (например, строка, кортеж, диапазон),  
  `list()` превращает его в список элементов.

---

#### Примеры создания списка

**Пустой список**

```python
a = list()
print(a)       # []

b = []
print(b)       # []
```

**Из строки**

```python
s = "hello"
a = list(s)
print(a)       # ['h', 'e', 'l', 'l', 'o']
```
**Из `range()`**

```python
r = range(5)
a = list(r)
print(a)       # [0, 1, 2, 3, 4]
```

**Из `tuple()`**

…

## 1. Slicing (срезы)

Slicing позволяет получать список из исходного списка.

Общий синтаксис:

```python
sublist = my_list[start:stop:step]
```

* `start` — индекс начала (включительно, по умолчанию 0)
* `stop` — индекс конца (не включительно, по умолчанию длина списка)
* `step` — шаг (по умолчанию 1, может быть отрицательным)

Примеры:

```python
a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

print(a[2:5])     # [2, 3, 4]   элементы с индексами 2, 3, 4
print(a[:4])      # [0, 1, 2, 3] с начала до индекса 4 (не включительно)
print(a[6:])      # [6, 7, 8, 9] с индекса 6 до конца
print(a[::2])     # [0, 2, 4, 6, 8] каждый второй элемент
print(a[1::3])    # [1, 4, 7] начиная с 1, каждый третий
print(a[::-1])    # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0] разворот списка
```

### Особенности слайсинга

* ВСЕГДА возвращается список
* Если `start > stop` и `step > 0`, вернётся пустой список.
* Отрицательные индексы считаются с конца (`-1` — последний элемент).

---

### Замена значений через слайсинг

С помощью слайсов можно заменять **несколько элементов сразу**, даже менять длину списка:

```python
a = [0, 1, 2, 3, 4, 5]

# Замена части списка
a[1:4] = [10, 11, 12]  # заменяем элементы с индексами 1,2,3
print(a)  # [0, 10, 11, 12, 4, 5]

# Можно заменить разное количество элементов
a[1:3] = [100, 101, 102, 103]
print(a)  # [0, 100, 101, 102, 103, 12, 4, 5]

# Можно удалить элементы, заменив на пустой список
a[2:5] = []
print(a)  # [0, 100, 12, 4, 5]
```

---


## 2. Индексы

…

## 1. Конкатенация списков (concatenation)

**Конкатенация** — это объединение двух (или более) списков в один новый список.

```python
a = [1, 2, 3]
b = [4, 5, 6]

c = a + b
print(c)  # [1, 2, 3, 4, 5, 6]
```

### Особенности:

* Оригинальные списки `a` и `b` **не изменяются**.
* Оба операнда должны быть списками, иначе будет ошибка.

```python
a + [7, 8]  # Работает
a + (7, 8)  # TypeError
```

---

## 2. Умножение списка на число (repetition)

**Повторение** — это создание нового списка, в котором исходный список повторяется указанное число раз.

```python
a = [1, 2, 3]

b = a * 3
print(b)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]
```

### Особенности:

* Умножение на 0 даёт пустой список:

```python
print(a * 0)  # []
```

* Умножение на отрицательное число тоже даёт пустой список:

```python
print(a * -2)  # []
```

* Операция создаёт **новый список**, исходный `a` не меняется.


⚠️ **Важное замечание!**
<span id="mutable-objects"></span>
## 3. Неожиданное поведение изменяемых объектов

Будьте осторожны с изменяемыми (mutable) объектами (вложенные списки, словари, множества):

* Новый список создаётся, но все повторённые элементы ссылаются на один и тот же объект*.
* Изменение одного вложенного элемента **затронет все копии**, включая исходный список.
…

## 1. Сравнение списков по элементам

Python сравнивает списки лексикографически, поэлементно слева направо.

* Сначала сравниваются первые элементы: `1 == 1` → идём дальше.
* Вторые элементы: `2 == 2` → идём дальше.
* Третьи: `3 < 4` → значит весь список `x < y`.

Пример:

```python
x = [1, 2, 3]
y = [1, 2, 4]
print(x < y)  # True
```

---

## 2. Списки с элементами разных типов

В Python 3 напрямую сравнивать элементы разных типов НЕЛЬЗЯ!

Примеры:

```python
a = [1, 2, 3]
b = [1, "2", 3]

print(a == b)  # False, просто проверка на равенство – работает
print(a < b)   # Ошибка!
```

### Объяснение:

* `==` и `!=` работают всегда, даже если типы разные.
* `<`, `>`, `<=`, `>=` работают **только если элементы сравнимы между собой**.

  * `int < str` → вызовет `TypeError: '<' not supported between instances of 'int' and 'str'`.

То есть при лексикографическом сравнении Python пытается сравнить первую пару элементов, которые различаются.  

Если они разных типов и не поддерживают `<`, `<`/`>` не сработает и выбросит ошибку.

---

## 3. Примеры

```python
# Сравнение с разными типами
print([1, 2] == [1, "2"])   # False, работает
print([1, 2] != [1, "2"])   # True, работает

print([1, 2] > [0, "abc"])  # True, работает
print([1, 2] < [1, "2"])    # Ошибка! TypeError
```

---

## Вывод:
* `==` и `!=` работают для любых типов.
…

## Общее правило для коллекций:

* Функция **`len()`** возвращает количество элементов в коллекции   
  (список, тюпл, строка, множество, словарь и т. д.).
* Оператор **`in`** проверяет, содержится ли элемент в коллекции   
  (возвращает `True` или `False`).

---

### Примеры:

```python
# len()
text = "python"
print(len(text))  # 6 (количество символов)

my_list = [1, 2, 3]
print(len(my_list))  # 3 (количество элементов в списке)

my_dict = {"a": 1, "b": 2}
print(len(my_dict))  # 2 (количество ключей)
```

```python
# in
print(2 in my_list)       # True (элемент 2 есть в списке)
print("a" in my_dict)     # True (ключ "a" есть в словаре)
print("python" in text)   # True (подстрока "python" есть в строке)
```

---

## Резюме

- Функция `len()` -  измеряет **размер коллекции**

- Оператор `in` проверяет **наличие элемента** внутри неё.

Повторим это пример [пример](./theory_03__concatenation_repetition.md#3-неожиданное-поведение-изменяемых-объектов) ещё раз.  

Только на этот раз добавим функцию `id()` для каждого элемента:

```python
n1, n2, n3, n4 = 1, 2, 3, 4
list1 = [n1, n2]
list2 = [n3, n4]

a = [list1, list2]
b = a * 3

print(id(a[0]), id(a[1]))
print(id(b[0]), id(b[1]), id(b[2]), id(b[3]), id(b[4]), id(b[5]))

# 134592101944128 134592101945856
# 134592101944128 134592101945856 134592101944128 134592101945856 134592101944128 134592101945856

b[0][0] = 100
print(a)  # [[100, 2], [3, 4]]
print(b)  # [[100, 2], [3, 4], [100, 2], [3, 4], [100, 2], [3, 4]]

print(id(a[0]), id(a[1]))
print(id(b[0]), id(b[1]), id(b[2]), id(b[3]), id(b[4]), id(b[5]))

# 134592101944128 134592101945856
# 134592101944128 134592101945856 134592101944128 134592101945856 134592101944128 134592101945856
```

Как видим, в обоих списках (и `a`, и `b`) идёт повторений одних и тех же id - `id(list1)` и `id(list2)`

А теперь заменим `mutable` список на `immutable` целое.

ID объектов снова дублируется в двух списках (только теперь `n1` и `list2`).

Но теперь меняется только один элемент: `b[0]`

```python
n1, n2, n3, n4 = 1, 2, 3, 4
list1 = [n1, n2]
list2 = [n3, n4]

a = [n1, list2]
b = a * 3

print(id(a[0]), id(a[1]))
print(id(b[0]), id(b[1]), id(b[2]), id(b[3]), id(b[4]), id(b[5]))

# 11755688 132729522639360
# 11755688 132729522639360 11755688 132729522639360 11755688 132729522639360

b[0] = 100
print(a)  # [1, [3, 4]]
print(b)  # [100, [3, 4], 1, [3, 4], 1, [3, 4]]

print(id(a[0]), id(a[1]))
print(id(b[0]), id(b[1]), id(b[2]), id(b[3]), id(b[4]), id(b[5]))

# 11755688 132729522639360
# 11755688 132729522639360 11755688 132729522639360 11755688 132729522639360
```