update content

Signed-off-by: Kirill Mokevnin <[email protected]>

Author: mokevnin

modules/20-arithmetics/20-basic/ru/EXERCISE.md

@@ -1,2 +1 @@
-
 Выведите на экран результат деления числа `81` на `9`.

modules/20-arithmetics/20-basic/ru/README.md

@@ -1,49 +1,81 @@
-На базовом уровне компьютеры оперируют только числами. Даже в прикладных программах на высокоуровневых языках внутри много чисел и операций над ними. Но для старта достаточно знать обычную арифметику — с нее и начнем.
+На базовом уровне компьютеры работают только с числами. Даже если вы пишете сложное приложение на современном языке программирования, внутри него всегда происходят многочисленные вычисления: сложение, вычитание, деление и т.д.
 
-Например, для сложения двух чисел в математике мы пишем: `3 + 4`. В программировании — то же самое. Вот программа, которая складывает два числа:
+К счастью, чтобы начать программировать, достаточно знать обычную школьную арифметику. С неё мы и начнём.
 
-```python
+## Сложение в Python
+
+В математике для сложения мы пишем 3 + 4. В Python — всё точно так же:
+
+```Python
 3 + 4
 ```
 
-Арифметика в программировании практически не отличается от школьной арифметики.
+Этот код действительно можно запустить — интерпретатор выполнит вычисление.
+Но... он не сделает с результатом ничего. То есть 7 получится, но вы его не увидите.
 
-Строчка кода `3 + 4` заставит интерпретатор сложить числа и узнать результат. Эта программа будет работать, но в ней нет смысла. По сути, мы не даем команду интерпретатору, мы просто говорим ему: «смотри, сумма трех и четырех». В реальной работе недостаточно сообщать интерпретатору о математическом выражении.
+## Чтобы увидеть результат, нужно его вывести
 
-Например, если создавать интернет-магазин, недостаточно просить интерпретатор посчитать стоимость товаров в корзине. Нужно просить посчитать стоимость **И** показать цену покупателю.
+В реальной программе просто посчитать значение — недостаточно. Нужно сделать что-то с результатом, например, показать его пользователю.
 
-Нам нужно попросить интерпретатор сложить `3 + 4` **И** дать команду сделать что-то с результатом. Например, вывести его на экран:
+Для этого используем функцию `print()`:
 
-```python
-# Сначала вычисляется сумма,
-# затем она передается в функцию печати
+```Python
 print(3 + 4)
 ```
 
-После запуска на экране появится результат:
+💡 Здесь сначала вычисляется сумма, затем она передаётся в функцию печати.
+
+Результат выполнения:
+
+<pre class='hexlet-basics-output'> 7 </pre>
 
-<pre class='hexlet-basics-output'>
-7
-</pre>
+## 🧮 Другие арифметические операции
 
-Кроме сложения доступны следующие операции:
+Python поддерживает все привычные операции:
 
-* `-` — вычитание
-* `*` — умножение
-* `**` — возведение в степень
-* `/` — деление
-* `//` — [целочисленное деление](https://ru.wikipedia.org/wiki/Деление_с_остатком#В_программировании)
-* `%` — [остаток от деления](https://ru.wikipedia.org/wiki/Деление_с_остатком)
+| Операция               | Символ | Пример       | Результат |
+|------------------------|--------|--------------|-----------|
+| Сложение               | `+`    | `2 + 3`      | `5`       |
+| Вычитание              | `-`    | `7 - 2`      | `5`       |
+| Умножение              | `*`    | `4 * 3`      | `12`      |
+| Деление                | `/`    | `8 / 2`      | `4.0`     |
+| Возведение в степень   | `**`   | `3 ** 2`     | `9`       |
+| Целочисленное деление  | `//`   | `7 // 3`     | `2`       |
+| Остаток от деления     | `%`    | `7 % 3`      | `1`       |
 
-Теперь выведем на экран результат деления, а потом результат возведения в степень:
+🔍 Обратите внимание: В результате деления `/` мы получаем **число с точкой** (`4.0`), даже если на вид оно целое. Мы разберёмся с этим подробнее в уроках про **типы данных**.
 
-```python
-print(8 / 2)   # => 4.0 (При делении двух чисел получается тип данных float)
-print(3 ** 2)  # => 9
+Вот как можно вывести результат деления и возведения в степень:
+
+```Python
+print(8 / 2)    # => 4.0
+print(3 ** 2)   # => 9
 ```
 
-https://replit.com/@hexlet/python-basics-arithmetics-basics
+## ℹ️ Что такое остаток от деления (`%`)
+
+Эта операция называется **взятие остатка от деления**. Она показывает, **что «остаётся»**, когда одно число делится на другое *не полностью*. Пример:
+
+```Python
+print(7 % 3)  # => 1
+```
+
+📘 Почему результат — 1?
+
+  - 7 делится на 3 дважды: 3 * 2 = 6
+  - До 7 остаётся 1 — это и есть остаток.
+
+Другие примеры:
+
+```Python
+print(10 % 4)  # => 2 (10 делится на 4 дважды: 4 * 2 = 8, остаток 2)
+print(15 % 5)  # => 0 (делится без остатка)
+```
+
+
+Операция % часто используется в программировании, например:
 
-Иногда для удобства мы будем показывать в комментариях результат запуска строчек кода вот так: `=> РЕЗУЛЬТАТ`. Например, `# => 4`.
+  - чтобы проверить, делится ли число нацело (если остаток 0)
+  - чтобы выполнять циклические действия, например, поведение по чётным/нечётным индексам
 
-Первая инструкция выведет на экран `4` (потому что 8 / 2 равно 4), а вторая инструкция выведет на экран 9 (потому что 3<sup>2</sup> равно 9).
+Мы ещё неоднократно встретим % в задачах и разберём его применение на практике.

modules/20-arithmetics/25-operator/ru/EXERCISE.md

@@ -1,2 +1 @@
-
 Напишите программу, которая посчитает разность между числами `6` и `-81` и выведет ответ на экран.

modules/20-arithmetics/25-operator/ru/README.md

@@ -1,20 +1,40 @@
+В математике и программировании мы часто используем знаки операций, такие как `+`, `-`, `*` и другие. В программировании такие знаки называются операторами.
 
-Знак операции, такой как `+`, называют **оператором**. Операторы выполняют операции над определенными значениями, которые называются **операндами**. Сами операторы — это обычно один или несколько символов. Реже — слово. Подавляющее большинство операторов соответствуют математическим операциям.
+- Оператор — это символ или слово, которое обозначает действие.
+- Операнды — это значения, к которым применяется оператор.
+
+Пример:
 
 ```python
 print(8 + 2)
 ```
 
-https://replit.com/@hexlet/python-basics-arithmetics-operators
+Здесь:
+
+- `-` — это оператор
+- `8` и `2` — это операнды
+- результат — `10`
+
+## Бинарные операторы
 
-В этом примере `+` — это оператор, а числа `8` и `2` — это **операнды**.
+Большинство операторов в Python — бинарные, то есть они работают с двумя операндами: один слева, второй справа. Если вы напишете выражение с одним операндом, например `3 +`, то получите синтаксическую ошибку. Оператор не может работать без всех нужных данных.
 
-Когда мы складываем, у нас есть два операнда: один слева, другой справа от знака `+`. Операции, которые требуют наличия двух операндов, называются **бинарными**. Если пропустить хотя бы один операнд, например, `3 +`, то программа завершится с синтаксической ошибкой.
+## Унарные операторы
 
-Операции бывают не только бинарными, но и унарными — с одним операндом, и тернарными — с тремя операндами. Причем операторы могут выглядеть одинаково, но обозначать разные операции.  Символы `+` и `-` используются не только как операторы. Когда речь идет про отрицательные числа, то знак минуса становится частью числа:
+Существуют и унарные операции — они работают с одним операндом. Пример:
 
 ```python
 print(-3)  # => -3
 ```
 
-Выше пример применения унарной операции к числу `3`. Оператор минус перед тройкой говорит интерпретатору взять число `3` и найти противоположное, то есть `-3`. Это может сбить с толку, потому что `-3` — это одновременно и число само по себе, и оператор с операндом. Но у языков программирования такая структура.
+В этом случае `-` — унарный оператор, а `3` — операнд. Интерпретатор получает команду: «возьми число 3 и измени его знак». Важно понимать: `-3` — это не "отрицательное число как единое целое", а выражение, где `-` — оператор, а `3` — значение.
+
+## Ошибки при вычислениях и парсинге
+
+Если воспринимать `-3` как единое число, можно не заметить, что `-` — это активный оператор. Например:
+
+```python
+print(-3**2)
+```
+
+Кажется, что (-3) в квадрате даст 9, но результат будет `-9`. Почему? Потому что `-3**2 = -(3**2) = -9`, а не `(-3)**2`. Понимание того, что - — это отдельная операция, помогает избежать таких ошибок.

modules/20-arithmetics/27-commutativity/ru/EXERCISE.md

@@ -1,2 +1 @@
-
 Напишите программу, которая считает и выводит на экран последовательно (по одному значению в каждой строчке) значения следующих математических выражений: «3 в степени 5» и «-8 разделить на -4».

modules/20-arithmetics/27-commutativity/ru/README.md

@@ -1,3 +1,37 @@
-«От перемены мест слагаемых сумма не меняется» — это один из базовых законов арифметики, который также называется **коммутативным законом**. Бинарная операция считается коммутативной, если вы получаете тот же самый результат, поменяв местами операнды. В этом случае сложение — это коммутативная операция: `3 + 2 = 2 + 3`.
+Фраза «от перемены мест слагаемых сумма не меняется» знакома каждому со школы. Этот принцип называется коммутативным законом и является одним из основных законов арифметики.
 
-Но вычитание — это не коммутативная операция: `2 - 3 ≠ 3 - 2`. В программировании этот закон работает точно так же, как в арифметике. Более того, большинство операций, с которыми мы сталкиваемся в реальной жизни, не являются коммутативными. Отсюда вывод: всегда обращайте внимание на порядок того, с чем работаете.
+## Что такое коммутативность
+
+Операция называется коммутативной, если порядок операндов не влияет на результат. То есть, поменяв местами значения, вы получите тот же ответ. Пример с коммутативной операцией — сложением:
+
+```python
+print(3 + 2)  # => 5
+print(2 + 3)  # => 5
+```
+
+Результат одинаковый — значит, операция коммутативна.
+
+## Некоммутативные операции
+
+Но не все операции обладают таким свойством. Например, вычитание — уже не коммутативная операция:
+
+```python
+print(2 - 3)  # => -1
+print(3 - 2)  # => 1
+```
+
+Поменяли операнды — и получили другой результат.
+
+## 🤖 В программировании — всё то же самое
+
+Коммутативность в программировании работает точно так же, как в арифметике. Python строго следует математическим правилам.
+
+Другие некоммутативные операции:
+
+- Деление: _8 / 2 ≠ 2 / 8_
+- Возведение в степень: *2 **3 ≠ 3** 2*
+
+Поэтому:
+
+- Всегда внимательно проверяйте порядок аргументов, особенно при работе с незнакомыми операциями;
+- не предполагаете коммутативность «по умолчанию» — лучше убедиться экспериментально.

modules/20-arithmetics/30-composition/ru/EXERCISE.md

@@ -1,4 +1,3 @@
-
 Реализуйте программу, которая вычисляет и выводит на экран значение выражения:
 
 ```

modules/20-arithmetics/30-composition/ru/README.md

@@ -1,15 +1,34 @@
+В Python (и в программировании вообще) можно объединять несколько операций в одну строку. Такие выражения интерпретатор обрабатывает шаг за шагом, по определённым правилам.
+
 Рассмотрим пример:
 
-```python
+```Python
 print(2 * 4 * 5 * 10)
 ```
 
-https://replit.com/@hexlet/python-basics-arithmetics-composition
+Этот код состоит из нескольких операций умножения, объединённых в одно выражение. Python умеет последовательно выполнять такие вычисления. Чтобы понять, как интерпретатор выполняет выражение, разберём его по этапам:
+
+- Сначала вычисляется `2 * 4`: `8 * 5 * 10`
+- Затем `8 * 5`: `40 * 10`
+- И наконец `40 * 10`: `400`
+
+Итоговый результат — `400`.
+
+## А если разные операции?
+
+Всё просто, пока используются одинаковые операторы. Но что произойдёт, если объединить, например, умножение и сложение?
+
+```Python
+print(2 + 3 * 4)
+```
+
+Получится ли `20` или `14`? Ответ: `14`.
 
-Операции можно соединять друг с другом и вычислять все более сложные составные выражения. Чтобы представить, как происходят вычисления внутри интерпретатора, разберем пример: `2 * 4 * 5 * 10`.
+🔑 Почему? Потому что в Python, как и в математике, у операций есть приоритет.
+Умножение выполняется раньше сложения, если не использовать скобки. Мы разберём это подробнее в следующем уроке.
 
-1. Сначала вычисляется `2 * 4` и получается выражение `8 * 5 * 10`
-2. Затем `8 * 5`. В итоге имеем `40 * 10`
-3. В итоге происходит последнее умножение, и получается результат `400`
+## 🧠 Что нужно запомнить
 
-Операции могут содержать разные операторы, из-за чего появляется вопрос об их приоритете.
+- Выражения могут состоять из нескольких операций.
+- Python вычисляет их поэтапно — слева направо, соблюдая приоритет операций.
+- Скобки можно использовать, чтобы явно указать порядок вычислений.

modules/20-arithmetics/40-priority/ru/EXERCISE.md

@@ -1,4 +1,3 @@
-
 Дано вычисление `70 * 3 + 4 / 8 + 2`.
 
 Расставьте скобки так, чтобы оба сложения (`3 + 4`) и (`8 + 2`) высчитывались в первую очередь. Выведите на экран результат.