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

## Конструкция `if - elif - else`

В Python конструкция `if - elif - else` используется для ветвления кода.  
То есть определяет выполнения разных блоков в зависимости от условий.  
Отсюда и название - **условные операторы** (*condition statement*)

Базовый синтаксис:

```python
if условие1:
    # Блок кода, если условие1 истинно
elif условие2:
    # Блок кода, если условие1 ложно, но условие2 истинно
elif условие3:
    # Блок кода, если выше все ложные, но условие3 истинно
else:
    # Блок кода, если все условия выше ложные
```

### Пример:

```python
x = 10

if x > 15:
    print("x больше 15")
elif x > 5:
    print("x больше 5, но не больше 15")
else:
    print("x меньше или равно 5")

# результат ВСЕГДА будет ТОЛЬКО один!
# 
# В данном случае: 
# x больше 5, но не больше 15
```


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

1. `elif` можно использовать несколько раз или не использовать совсем;
2. Для нескольких `elif`:
   1. Проверка идёт сверху вниз, 
   2. выполняется первый блок, условие которого истинно. 
   3. Остальные блоки игнорируются.
3. В `else` попадает всё, что не выполнилось выше (необязательный оператор!)
4. Условия могут быть любыми объектами, которые возвращают `True` или `False`.


В Python можно использовать несколько отдельных `if`, и они НЕ ЗАВИСЯТ друг от друга.  

* `if - elif - else`, 
  * срабатывает ТОЛЬКО ОДИН блок  
* несколько независимых `if` 
  * могут сработать все, если их условия истинны.

## Несколько отдельных блоков `if`:

Предыдущий пример мы можем записать с помощью нескольких `if`:

…

В Python тернарный оператор — это способ записать условную конструкцию в одну строку.  
Подходит ТОЛЬКО для простых конструкций.  
Но даже в этом случае проигрывает классическому блочному оператору в читабельности.

Синтаксис:

```python
<значение_если_True> if <условие> else <значение_если_False>
```

### Пример 1: простое условие

```python
x = 10
result = "Положительное" if x > 0 else "Отрицательное"
print(result)  # Положительное
```

Эквивалентно:

```python
if x > 0:
    result = "Положительное"
else:
    result = "Отрицательное"
```

---

### Пример 2: вложенный тернарный оператор

```python
x = 0
result = "Положительное" if x > 0 else "Отрицательное" if x < 0 else "Ноль"
print(result)  # Ноль
```

Используется КРАЙНЕ редко, т.к. плохо читается.

---

### Пример 3: с функциями

```python
x = 0
print("Положительное") if x > 0 else print("Отрицательное") if x < 0 else print("Ноль")
```

Или ещё короче: весь тернарный оператор использовать в качестве аргумента функции.

```python
x = 5
print("Положительное" if x > 0 else "Отрицательное" if x < 0 else "Ноль")
```
---

### Пример 4: с числами

```python
a, b = 5, 10
…

## Вложенные условные конструкции

В Python вложенные конструкции `if` — это когда один блок `if` находится внутри другого.  
Это используется, когда нужно проверить несколько условий поэтапно.

---

### Базовый синтаксис

```python
if условие1:
    # код выполняется, если условие1 истинно
    if условие2:
        # код выполняется, если оба условия истинны
    else:
        # код выполняется, если условие1 истинно, но условие2 ложно
else:
    # код выполняется, если условие1 ложно
```

---

### Пример 1: простая вложенность

```python
x = 10
if x > 0:
    if x % 2 == 0:
        print("Положительное чётное число")
    else:
        print("Положительное нечётное число")
else:
    print("Отрицательное или ноль")
```

---

### Пример 2: вложенные `if-elif-else`

```python
x = 15
if x > 0:
    if x < 10:
        print("Маленькое положительное число")
    elif x < 20:
        print("Среднее положительное число")
    else:
        print("Большое положительное число")
else:
    print("Не положительное число")
```

---

## Альтернатива вложенным конструкциям: условия с логическими операторами

Альтернатива вложенным `if` в Python — использовать **логические операторы** `and`, `or`, `not`.  
Они позволяют объединять условия и записывать проверки короче и читаемее.

---
…

В Python в конструкции `if` любое значение приводится к булевому типу по правилам языка.  
Фактически срабатывает функция `bool()`, которая возвращает `True` или `False`.

---

## Как это работает

* Если значение приводится к `True`, условие выполняется.
* Если значение приводится к `False`, условие не выполняется.

---

## Булевы значения для разных типов данных

| Тип данных                     | Когда `False`                                                               | Когда `True`                               |
| ------------------------------ | --------------------------------------------------------------------------- | ------------------------------------------ |
| `None`                         | Всегда `False`                                                              | —                                          |
| `bool`                         | `False`                                                                     | `True`                                     |
| `int`, `float`                 | `0`, `0.0`                                                                  | Любое ненулевое число                      |
| `str`                          | Пустая строка `""`                                                          | Любая непустая строка                      |
| `list`, `tuple`, `set`, `dict` | Пустые коллекции `[]`, `()`, `{}`, `set()`                                  | Любые непустые коллекции                   |
| Пользовательские объекты       | Если определён метод `__bool__` или `__len__`, возвращающий `0` или `False` | Если метод возвращает ненулевое или `True` |

---

## Примеры

### Числа

```python
x = 0
if x:
    print("Ненулевое число")
else:
    print("Ноль или False")  # сработает
```

---

### Строки

```python
s = "Привет"
if s:
    print("Строка не пустая")  # сработает
else:
    print("Пустая строка")
```

---

### Списки

```python
items = []
if items:
    print("Список не пустой")
else:
    print("Список пустой")  # сработает
```
…

## Конструкция `match-case`

`match-case`** в Python — это новый способ организации условной логики, появившийся в Python 3.10.  
Он похож на `switch-case` из других языков, но гораздо более мощный и интеллектуальный.  
Поддерживает **паттерн-матчинг**, включая структуры данных и проверки значений.

---

### 1. Синтаксис

```python
match <выражение>:
    case <паттерн_1>:
        # код, если совпал паттерн_1
    case <паттерн_2>:
        # код, если совпал паттерн_2
    case _:
        # "default", если ничего не совпало
```

* `match <выражение>:` — выражение, которое проверяется.
* `case  <паттерн_1>:` — паттерн, с которым сравнивается выражение.
* `_` — универсальный паттерн, аналог `else`.


---

### 2. Простейший пример (замена `if-elif-else`)

```python
x = 2

match x:
    case 1:
        print("Один")
    case 2:
        print("Два")  # сработает
    case 3:
        print("Три")
    case _:
        print("Другое число")
```

---

### 3. Несколько значений в одном `case` через знак `|`

```python
x = 5

match x:
    case 1 | 2 | 3:
        print("Малое число")
    case 4 | 5 | 6:
        print("Среднее число")  # сработает
    case _:
        print("Другое число")
```

`|` означает "или" — если выражение совпадает с любым значением, паттерн срабатывает.
…