update

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

Author: mokevnin

modules/33-data-types/40-primitive-data-types/ru/README.md

@@ -1,24 +1,97 @@
+Программы работают с разной информацией: текст, числа, даты, списки, булевы значения. У каждого фрагмента данных в программе есть тип — его “категория”.
 
-Бывают разные способы представлять данные в программах. Есть **строки** — наборы символов в кавычках вроде `"Hello, World!"`. Есть **целые числа** — например, `7`, `-198`, `0`. Это две разные категории информации — два разных **типа данных**. Операция умножения имеет смысл для категории «целые числа», но не для категории «строки»: нет смысла умножать слово «мама» на слово «блокнот».
+Например:
 
-Тип данных определяет, что можно делать с элементами конкретного множества информации. В этом уроке мы изучим типы данных и узнаем, как работает типизация в Python.
+- "Hello, World!" — это строка (набор символов)
+- 7, -198, 0 — это целые числа
+- 3.14, -0.01, 1.0 — это рациональные числа (или числа с плавающей точкой)
 
-Язык программирования распознает типы данных, поэтому Python не позволит нам умножать строку на строку — нельзя умножать текст на текст. При этом можно умножать целое число на другое целое число. Наличие типов и таких ограничений в языке защищает программы от случайных ошибок.
+## 🔍 Что такое тип данных?
 
-В отличие от строк, числа оборачивать в кавычки не нужно. Чтобы напечатать число 5, достаточно написать:
+Тип данных определяет:
+
+- как интерпретировать значение;
+- какие операции с ним можно делать.
+
+Например, числа можно складывать, делить и умножать. А вот строки складываются по-другому — при помощи конкатенации (склеивания). Но умножать строку на строку нельзя — это бессмысленно:
+
+```python
+# Нельзя: 'мама' * 'блокнот'  ❌
+```
+
+## 🧮 Числа и строки — разные типы
+
+Пример вывода числа:
 
 ```python
 print(5)  # => 5
 ```
 
-Число `5` и строка `'5'` — совершенно разные вещи, хотя вывод у `print()` для этих данных идентичный. Целые числа (`1`, `34`, `-19` и т.д.) и рациональные числа (`1.3`, `1.0`, `-14.324` и т.д.) — это два отдельных **типа данных**. Такое разделение связано с особенностями устройства компьютеров. Есть и другие типы, с ними мы познакомимся позже.
+Пример вывода строки:
+
+```python
+print('5')  # => 5
+```
+
+На экране результат выглядит одинаково, но внутри программы это совершенно разные вещи:
+
+| Значение | Тип данных       |
+|----------|------------------|
+| `5`      | `int` (целое число) |
+| `'5'`    | `str` (строка)    |
+
+Строку '5' нельзя сложить с числом 5, как и '10' / 2 не даст числа 5.0.
+Python будет ругаться, если вы попытаетесь смешать несовместимые типы без явного преобразования.
+
+## 🔢 Целые и рациональные числа
+
+Python различает два вида чисел:
+
+- int — целые числа: -3, 0, 7, 100000
+- float — вещественные (рациональные) числа: 1.0, -3.14, 2.718
 
-Вот еще один пример, но уже с рациональным числом:
+Пример:
 
 ```python
 print(10.234)  # => 10.234
 ```
 
-Типы данных «строка», «целое число» и «рациональное число» — это *примитивные типы*, то есть они встроены в сам язык Python. В язык встроены также и некоторые составные типы, но пока мы будем работать только с примитивными. Программисты также могут создавать собственные типы данных.
+Числа с точкой Python воспринимает как float — с ними можно делать арифметику с десятичной точностью.
+
+## ⚙️ Почему типы вообще нужны?
+
+Типы помогают компьютеру понимать, как обрабатывать данные. Они:
+
+- определяют набор допустимых операций;
+- влияют на поведение функций и выражений;
+- позволяют языку выявлять ошибки ещё до выполнения программы.
+
+Например, если вы случайно попытаетесь сложить строку с числом, Python остановит программу и покажет ошибку — именно благодаря строгой типизации.
+
+🧱 Примитивные типы
+
+Типы вроде:
+
+- str (строка),
+- int (целое число),
+- float (рациональное число)
+
+называются примитивными — они встроены прямо в язык. Существуют и составные типы: списки, словари, кортежи и другие. С ними мы познакомимся позже. Более того, в Python можно создавать и свои собственные типы (например, классы), но для начала важно хорошо разобраться с примитивами.
+
+## 📚 Терминология: строка или строчка?
+
+В программировании есть терминологическая ловушка:
+
+- строка (string) — это тип данных, например 'hello'
+- строчка (line) — это строка текста в файле или в коде
+
+Например, в коде ниже есть строчка, но не строка:
+
+```python
+print(5)
+```
+
+Чтобы избежать путаницы, в этом курсе мы будем использовать:
 
-По-английски строки в программировании называются strings, а строчки текстовых файлов — lines. Например, в коде кода выше есть строчка (line), но нет никаких строк (strings). В русском иногда может быть путаница, поэтому во всех уроках мы будем говорить **строка** для обозначения типа данных «строка», и **строчка** для обозначения строчек кода (lines) в файлах.
+- строка — когда говорим о данных типа str;
+- строчка — когда речь идёт о строках кода (lines).

modules/33-data-types/50-strong-typing/ru/EXERCISE.md

@@ -1,2 +1 @@
-
 Выведите на экран результат выражения: `7 - (-8 - -2)`. Попробуйте сделать число 7 не числом, а строкой. Сработает ли такой код? Поэкспериментируйте с другими числами тоже.

modules/33-data-types/50-strong-typing/ru/README.md

@@ -1,22 +1,50 @@
+Python относится к типам данных очень серьёзно. Если вы попытаетесь выполнить операцию между несовместимыми типами — программа выдаст ошибку. Всё дело в том, что Python — язык со строгой (или сильной) типизацией.
 
-Python — один из языков, который строго относится к типам данных. Поэтому на любую несовместимость типов он ответит ошибкой. Все дело в сильной типизации.
+## 🧮 Что это значит на практике?
 
-Нам известно про два разных типа данных: числа и строки. Например, мы могли складывать числа, потому что операция сложения — это операция для типа «числа». А что, если применить эту операцию не к двум числам, а к числу и строке?
+Допустим, вы складываете два числа:
 
-```python
-print(1 + '7')  # TypeError: unsupported operand type(s)...
+```Python
+print(1 + 7)  # => 8
 ```
 
-Python не разрешит сложить число `1` и строку `'7'`, потому что это значения разных типов. Нужно сначала либо сделать строку числом, либо число строкой. Как это сделать, мы поговорим позже.
+Всё отлично. Операция сложения допустима для чисел.
+А что будет, если попробовать сложить число и строку?
 
-Такое педантичное отношение к совместимости типов называется **строгой типизацией** или **сильной типизацией**. Python — язык со строгой типизацией.
+```Python
+print(1 + '7')  
+# TypeError: unsupported operand type(s) for +: 'int' and 'str'
+```
+
+Python сообщает, что не может сложить int и str. Это ошибка типов: значения принадлежат к разным категориям, и программа отказывается продолжать.
+
+## 🔎 Почему так строго?
+
+Python защищает вас от неочевидных и опасных ошибок. Он требует, чтобы вы явно указали, как вы хотите преобразовать данные:
+
+- либо сделать строку числом (`int('7')`);
+- либо число строкой (`str(1)`).
+
+Мы научимся делать это чуть позже.
 
-Не все языки так делают. Например, PHP — это язык со **слабой типизацией**. Он знает о существовании разных типов, но относится к их использованию не очень строго. PHP пытается преобразовывать информацию, когда это кажется разумным. То же самое относится к JavaScript:
+## 🔁 А как в других языках?
 
-```javascript
-// Как тебе такое, Илон Маск?
-// Число 1 + Строка 7 = Строка 17
-1 + '7'; // '17'
+Не все языки такие. Например, PHP и JavaScript используют слабую типизацию — они автоматически преобразуют типы, когда считают это «разумным»:
+
+```Python
+1 + '7';  // => '17'
 ```
 
-С одной стороны, автоматическое неявное преобразование типов и правда кажется удобным. Но на практике это свойство языка создает множество ошибок и проблем, которые трудно найти. Код может иногда работать, а иногда не работать — в зависимости от того, «повезло» ли с автоматическим преобразованием. Программист это заметит не сразу и потратит много времени на отладку.
+В этом примере число 1 неявно превращается в строку '1', и результатом становится '17'.
+
+Сначала может показаться, что слабая типизация — это удобно. Меньше кода, всё "просто работает". Но на практике это приводит к:
+
+- Неявным преобразованиям, о которых программист даже не подозревает.
+- Непредсказуемому поведению кода.
+- Трудным для отладки ошибкам, которые появляются в самых неожиданных местах.
+
+Такие ошибки особенно сложно поймать, потому что программа может «иногда работать, иногда нет» — в зависимости от типа данных, которые в неё попали.
+
+## 📌 Вывод
+
+Python — язык со строгой типизацией. Он не позволяет выполнять операции между несовместимыми типами без явного преобразования. Это делает программы надёжнее и понятнее. Мы ещё научимся преобразовывать данные из одного типа в другой — и делать это всегда сознательно.

modules/33-data-types/52-data-types-immutability/ru/README.md

@@ -1,20 +1,48 @@
-
-Представим, что нам нужно изменить символ в строке. Вот, что из этого выйдет:
+Представим, что у нас есть строка, и мы хотим заменить в ней один символ — например, первую букву имени:
 
 ```python
 first_name = 'Alexander'
-first_name[0] = 'B'
-# Ошибка: TypeError: 'str' object does not support item assignment
+first_name[0] = 'B'  # ❌
+```
+
+Python сразу выдаст ошибку:
+
 ```
+TypeError: 'str' object does not support item assignment
+```
+
+Что это значит? Строки в Python нельзя изменять по частям. Как только они созданы — всё, они неизменяемы (или, как говорят программисты, иммутабельны).
+
+## 🧱 Почему строки неизменяемые?
+
+Python устроен так, что примитивные типы (строки, числа, булевы значения и т. д.) нельзя менять. Это даёт важные преимущества:
 
-Такое происходит из-за неизменяемости примитивных типов в Python — язык не дает никакой физической возможности поменять строку. Неизменяемость примитивных типов важна по многим причинам. Ключевая причина — производительность.
+- 🔐 Безопасность: значения не изменятся случайно
+- ⚡️ Производительность: с неизменяемыми объектами проще работать внутри интерпретатора
+- 🧠 Предсказуемость: меньше неожиданных эффектов при передаче данных в функции
 
-Но иногда нам нужно изменить строку. Для этого и существуют переменные:
+## 🔁 А как тогда изменить строку?
+
+Если нужно "изменить" строку — мы не редактируем её, а создаём новую строку и сохраняем в ту же переменную:
 
 ```python
 first_name = 'Alexander'
 first_name = 'Blexander'
+
 print(first_name)  # => Blexander
 ```
 
-Есть большая разница между *изменением значения переменной* и *изменением самого значения*. Примитивные типы в Python поменять нельзя, а составные — можно. Также можно без проблем заменить значение переменной.
+Переменная first_name теперь просто указывает на другую строку. Это не изменение самой строки, а замена значения переменной.
+
+## 🔄 В чём разница?
+
+Важно различать два действия:
+
+| Действие                       | Можно? | Пример                         |
+|-------------------------------|--------|--------------------------------|
+| Изменить содержимое строки    | ❌ Нет | `first_name[0] = 'B'` — ошибка |
+| Заменить значение переменной  | ✅ Да  | `first_name = 'Blexander'`     |
+
+## 📌 Вывод
+
+Примитивные типы данных в Python — такие как строки (str), целые числа (int), вещественные числа (float) и логические значения (bool) — являются неизменяемыми (immutable). Это означает, что после создания их внутреннее значение изменить нельзя. Вы не можете поменять один символ в строке или один разряд в числе — любые "изменения" происходят путём создания нового значения и переопределения переменной.

modules/33-data-types/55-data-types-casting/ru/EXERCISE.md

@@ -1,4 +1,3 @@
-
 Выведите на экран строку `2 times`, полученную из числа 2.9 (хранится в переменной `value`) и строки `times`, используя преобразования типов и конкатенацию. Для этого нужно выполнить два преобразования: сначала в целое число, а затем в строку
 
 <pre class='hexlet-basics-output'>