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

## Определение

**List comprehension** (LC) — это способ создания списка из итерируемого объекта в одной строке  
с помощью выражения, цикла и (опционально) условий.

Общий шаблон:

```python
[выражение for переменная in итерируемый_объект if условие]
```

⚠️ ⚠️ ⚠️ 
ВАЖНО: 
Если логика выражения сложнее базового шаблона, его КРАЙНЕ ЖЕЛАТЕЛЬНО разбить на блоки. 

---

## 1. Базовый LC

```python
nums = [1, 2, 3, 4, 5]
squares = [x**2 for x in nums]
print(squares)  # [1, 4, 9, 16, 25]
```

---

## 2. LC с условием (`if` после цикла)

```python
nums = [1, 2, 3, 4, 5]
even = [x for x in nums if x % 2 == 0]
print(even)  # [2, 4]
```

---

## 3. LC с тернарным оператором (`if ... else ...`)

Тут `if` стоит **внутри выражения**, а не после цикла.

```python
nums = [1, 2, 3, 4, 5]
labels = ["even" if x % 2 == 0 else "odd" for x in nums]
print(labels)  # ['odd', 'even', 'odd', 'even', 'odd']
```
Аналогично:
```python
labels_2 = []
for x in nums:
    labels_2.append("even" if x % 2 == 0 else "odd")
    
print(labels_2)  # ['odd', 'even', 'odd', 'even', 'odd']

# --- или -------------------------------------

labels_3 = []
for x in nums:
    if x % 2 == 0:
        labels_3.append("even")
…

## Определение

`zip()` ― это функция, которая **объединяет несколько итерируемых объектов** в ОДИН итератор тюплов. 

Если объекты разной длины, длина результата будет равна длине наименьшего объекта.


Синтаксис:

```python
zip(iter1, iter2, ..., iterN)
```

---

## 1. Простейший пример

```python
nums = [1, 2, 3]
letters = ['a', 'b', 'c']

zipped = list(zip(nums, letters))
print(zipped)  # [(1, 'a'), (2, 'b'), (3, 'c')]
```

---

## 2. Несколько списков

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

print(list(zip(a, b, c)))
# [(1, 4, 7), (2, 5, 8), (3, 6, 9)]
```

---

## 3. Разная длина списков

⚠️ `zip()` работает до минимальной длины.

```python
a = [1, 2, 3, 4]
b = ['x', 'y']

print(list(zip(a, b)))
# [(1, 'x'), (2, 'y')]
```

## Определение

**Стек (stack)** — это структура данных типа **LIFO** 
(*Last In, First Out* — «последним пришёл, первым ушёл»).



## Простейшая реализация на списке

```python
stack = []  # создаём пустой стек

# push
stack.append(1)
stack.append(2)
stack.append(3)
print(stack)  # [1, 2, 3]

# pop
top = stack.pop()
print("Сняли:", top)      # 3
print("Стек:", stack)     # [1, 2]

# peek (смотрим верхний элемент) - просто название операции из теории структур данных, а не метод списков!
print("Верхний:", stack[-1])  # 2
```


---

## Пример использования (проверка скобок)

```python
def check_parentheses(s):
    stack = []
    for char in s:
        if char == "(":
            stack.append(char)  # push
        elif char == ")":
            if not stack:
                return False
            stack.pop()         # pop
    return not stack

print(check_parentheses("(())"))   # True
print(check_parentheses("(()"))    # False
print(check_parentheses("())("))   # False
```

## Определение

**Очередь (queue)** — это структура данных типа **FIFO**  
(*First In, First Out* — «первым пришёл, первым ушёл»).

Пример из жизни: очередь в магазине — первый вошёл, первый обслужен.


---

## 1. Реализация на `list`

```python
queue = []

# enqueue
queue.append(1)
queue.append(2)
queue.append(3)
print(queue)  # [1, 2, 3]

# dequeue (удаляем из начала!)
first = queue.pop(0)
print("Обслужили:", first)  # 1
print("Очередь:", queue)    # [2, 3]

# peek
print("Первый:", queue[0])  # 2
```

⚠️ Минус: `pop(0)` медленный (O(n)), потому что все элементы сдвигаются.

---

## 2. Реализация на `collections.deque` (рекомендуется)

```python
from collections import deque

queue = deque()

# enqueue
queue.append("a")
queue.append("b")
queue.append("c")
print(queue)  # deque(['a', 'b', 'c'])

# dequeue
print(queue.popleft())  # a
print(queue.popleft())  # b
print(queue)            # deque(['c'])

# peek
print(queue[0])         # c
```

Здесь `popleft()` работает за O(1), поэтому `deque` → идеален для очередей.

## Определение

**Устойчивость сортировки** (англ. **stable sort**) — это свойство алгоритма сортировки,  
при котором **сохраняется относительный порядок элементов с одинаковыми ключами**.

То есть, если два элемента равны с точки зрения сравнения критерия сортировки,  
то ПОСЛЕ сортировки они будут расположены в том же порядке, что и БЫЛИ ДО сортировки.

В Python `sorted` и `.sort()` всегда устойчивы.
---

## Пример

### Устойчивый алгоритм

```python
words = ["apple", "dog", "bat", "cat", "banana"]

# сортируем по длине слов
sorted_words = sorted(words, key=len)
print(sorted_words)
# ['dog', 'bat', 'cat', 'apple', 'banana']
```

ВОПРОС "на засыпку":

Почему тогда здесь равные по длине элементы изменили свой порядок?

```python
words = ["apple", "dog", "bat", "cat", "banana"]

# сортируем по длине слов
sorted_words = sorted(words)
print(sorted_words)
# ['apple', 'banana', 'bat', 'cat', 'dog']
```