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

Урок 04. Арифметические операторы, выражения

Как работать с репозиторием

Каждая карточка говорит, о чём файл, что он выводит и что в нём искать. Код виден прямо здесь: его можно скопировать одной кнопкой, скачать файл или открыть его целиком.

Маршрут изучения

  1. Прочитайте описание: по нему уже понятно, о чём файл и что он выведет.
  2. Предскажите вывод: сравните своё предположение со строкой «Что выводит».
  3. Запустите: скачайте файл или скопируйте код кнопкой и выполните его у себя.
  4. Измените: поменяйте одно условие или значение и объясните новый результат.

Файлы: рекомендуемый порядок

1
MarkdownРазбор концепции21 строк

Арифметические операции и приоритет операций

less_03__arithmetic_operations__type_conversion/theory_01__arithmetic_operations.md

Таблица всех семи арифметических операторов Python (+, -, *, /, //, %, **) с примером и пояснением для каждого — отдельно подчёркнуто, что / всегда возвращает float, а // — деление без остатка. Вторая таблица задаёт порядок вычислений: скобки выше степени, степень выше * / // %, а те — выше + и -.

  • + - * — базовые операции
  • / — всегда float, даже для чётного деления
  • // — целочисленное деление, % — остаток
  • ** — возведение в степень
  • Таблица приоритета: () > ** > * / // % > + -
Показать начало файла (21 строк всего) 
## Арифметические операции

| Операция     | Символ | Пример   | Результат  | Пояснение                                           |
|--------------|--------|----------|------------|-----------------------------------------------------|
| Сложение     | `+`    | `7 + 3`  | `10`       | Складывает два числа.                               |
| Вычитание    | `-`    | `7 - 3`  | `4`        | Вычитает второе число из первого.                   |
| Умножение    | `*`    | `7 * 3`  | `21`       | Умножает числа.                                     |
| Деление      | `/`    | `7 / 3`  | `2.333...` | Всегда возвращает число с плавающей точкой (float). |
| Цел. деление | `//`   | `7 // 3` | `2`        | Деление без остатка, возвращает целое число.        |
| Остаток      | `%`    | `7 % 3`  | `1`        | Возвращает остаток от деления.                      |
| Степень      | `**`   | `3 ** 2` | `9`        | Возводит в степень.                                 |


## Приоритет операций

| Приоритет   | Операции            |
|-------------|---------------------|
| 1 (высший)  | Скобки `()`         |
| 2           | `**`                |
| 3           | `*`, `/`, `//`, `%` |
| 4 (низший)  | `+`, `-`            |
Проверьте себя: Почему 7 / 3 возвращает 2.333..., а 6 / 3 всё равно возвращает float 2.0, а не int 2?
Открыть файл →
2
MarkdownРазбор концепции39 строк

Неявное и явное преобразование типов

less_03__arithmetic_operations__type_conversion/theory_02__type_conversion.md

Разделяет два вида преобразований: неявное (implicit) — Python сам решает, что int+float даёт float, и это правило работает даже для //, % и **, что показано отдельной таблицей на каждую операцию; и явное (explicit) — сводная таблица int()/float()/str()/bool() для каждого исходного типа, включая ValueError при попытке int('abc').

  • int+int → int, int+float → float, float+float → float
  • Таблица //, %, ** для всех комбинаций int/float
  • int(), float(), str(), bool() — таблица явных преобразований
  • str (не число) → int()/float() кидают ValueError
  • bool(0) == False, bool('') == False
Показать начало файла (39 строк всего) 
В Python (как и большинстве языков высокого уровня) возможны 2 вида преобразований типов данных
 - явные (explicit);
 - и неявные (implicit).

## Неявное преобразования типов данных для `int` и `float`

| Типы операндов    | Результат операции | Пояснение                       |
|-------------------|--------------------|---------------------------------|
| `int` и `int`     | `int`              | Всегда `int`, кроме деления `/` |
| `int` и `float`   | `float`            | Результат всегда `float`        |
| `float` и `float` | `float`            | Результат всегда `float`        |

Это правило работает ДАЖЕ для целочисленного деления, деления по модулю и степени:

| Операция | Операнды        | Результат | Пример             |
|----------|-----------------|-----------|--------------------|
| //       | int // int      | int       | `7 // 2 → 3`       |
| //       | int // float    | float     | `7 // 2.0 → 3.0`   |
| //       | float // int    | float     | `7.0 // 2 → 3.0`   |
| //       | float // float  | float     | `7.0 // 2.0 → 3.0` |
| %        | int % int       | int       | `7 % 2 → 1`        |
| %        | int % float     | float     | `7 % 2.5 → 2.0`    |
| %        | float % int     | float     | `7.5 % 2 → 1.5`    |
| %        | float % float   | float     | `7.5 % 2.5 → 0.0`  |
| **       | int ** int      | int       | `2 ** 3 → 8`       |
| **       | int ** float    | float     | `2 ** 3.0 → 8.0`   |
| **       | float ** int    | float     | `2.0 ** 3 → 8.0`   |
| **       | float ** float  | float     | `2.0 ** 3.0 → 8.0` |


## Явное преобразование типов

| Исходный тип   | int()                     | float()                     | str()                  | bool()                           |
|----------------|---------------------------|-----------------------------|------------------------|----------------------------------|
| int            | Без изменений             | Добавляется `.0`            | Строка числа           | `False`, если 0, иначе `True`    |
| float          | Обрезается дробная часть  | Без изменений               | Строка числа           | `False`, если 0.0, иначе `True`  |
| str (число)    | Преобразует строку в int  | Преобразует строку в float  | Без изменений          | `False`, если `""`, иначе `True` |
| str (не число) | Ошибка `ValueError`       | Ошибка `ValueError`         | Без изменений          | `False`, если `""`, иначе `True` |
| bool           | `False`→0, `True`→1       | `False`→0.0, `True`→1.0     | `"False"` или `"True"` | Без изменений                    |
Проверьте себя: Что вернёт bool(int(float('0.0'))) и почему на каждом шаге результат меняется?
Открыть файл →
3
MarkdownРазбор концепции36 строк

Расширенное присваивание и проверка mutable/immutable через id()

less_03__arithmetic_operations__type_conversion/theory_03__augmented_assignment_operators.md

Таблица операторов += -= *= /= //= %= **= с примером приращения. Вторая часть — практическое доказательство: id() переменной до и после += показывает, что int пересоздаётся по новому адресу (immutable), а list при += меняется на месте по тому же адресу (mutable) — это ключевая демонстрация файла.

  • x += 3, x -= 2, x *= 4 и другие расширенные операторы
  • id(x) до и после x += 1 для int — адрес меняется
  • id(lst) до и после lst += [1] для list — адрес не меняется
  • print("Is x mutable?", address_1 == address_2)
Показать начало файла (36 строк всего) 

## Операторы расширенного присваивания (augmented assignment operators)

| Оператор | Пример с приращением          | Результат |
|----------|-------------------------------|-----------|
| `+`      | `x = 5; x += 3`               | `8`       |
| `-`      | `x = 5; x -= 2`               | `3`       |
| `*`      | `x = 5; x *= 4`               | `20`      |
| `/`      | `x = 5; x /= 2`               | `2.5`     |
| `//`     | `x = 5; x //= 2`              | `2`       |
| `%`      | `x = 5; x %= 2`               | `1`       |
| `**`     | `x = 2; x **= 3`              | `8`       |


## Доказательство неизменяемости строк (`immutable`)

Как правило, по расширенному присваиванию можно определить,  
является ли тип данных изменяемым (`mutable`) или неизменяемым (`immutable`).

```python
x = 5
address_1 = id(x)
x += 1
address_2 = id(x)

print("Is x mutable?", address_1 == address_2)
# Is x mutable? False

lst = [5]
address_1 = id(lst)
lst += [1]
address_2 = id(lst)

print("Is lst mutable?", address_1 == address_2)
# Is lst mutable? True
```
Проверьте себя: Даст ли lst = lst + [1] (без +=) тот же результат по id(), что и lst += [1], и почему?
Открыть файл →
4
MarkdownРазбор концепции25 строк

Множественное и цепочное присваивание

less_03__arithmetic_operations__type_conversion/theory_04__additional_types_of_assignments.md

Два коротких синтаксиса присваивания: множественное — a, b, c = 1, 5, 10 присваивает разные значения нескольким переменным за одну строку; цепочное — a = b = c = 10 присваивает одно и то же значение сразу всем трём переменным.

  • a, b, c = 1, 5, 10 — множественное присваивание
  • a = b = c = 10 — цепочка присваивания
Показать начало файла (25 строк всего) 
# Дополнительные виды присваивания

## Множественное присваивание (`multiple assignment`)

С помощью множественного присваивания можно присваивать значения  
нескольким переменным в одной строке.

```python
a, b, c = 1, 5, 10
print(a)  # Output: 1
print(b)  # Output: 5
print(c)  # Output: 10
```

## Цепочка присваивания (`chained assignment`)

Если нескольким переменным надо присвоить одно и то же значение,  
можно использовать цепочку присваиваний:

```python
a = b = c = 10
print(a)  # Output: 10
print(b)  # Output: 10
print(c)  # Output: 10
```
Проверьте себя: Если в a = b = c = [1, 2] изменить a.append(3), что произойдёт с b и c, и почему — в отличие от a = b = c = 10?
Открыть файл →