update

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

Author: mokevnin

modules/25-strings/20-string-concatenation/ru/README.md

@@ -16,11 +16,23 @@ print('Dragon' + 'stone')
 ```python
 print('Kings' + 'wood')       # => Kingswood
 print('Kings' + 'road')       # => Kingsroad
+# Здесь снаружи двойные кавычки, потому что внутри есть одиночная
 print("King's" + 'Landing')   # => King'sLanding
 ```
 
 Python позволяет объединять строки, даже если они записаны в разных кавычках — главное, чтобы обе части были строками.
 
+## Тип кавычек
+
+Независимо от того где мы работаем со строками, Python позволяет в качестве ограничителей использовать как одиночные кавычки, так и двойные. Поэтому оба примера ниже работают абсолютно идентично:
+
+```python
+print('Dragon' + 'stone')
+print("Dragon" + "stone")
+```
+
+По умолчанию лучше придерживаться одиночных кавычек, так как это соответствует стандарту языка.
+
 ## Пробел — тоже символ
 
 При объединении Python не вставляет пробелы автоматически. Если между частями должен быть пробел, его нужно указать вручную:
@@ -35,6 +47,20 @@ print("King's" + ' Landing')  # => King's Landing
 
 Результат будет одинаковый. Но если пробел не добавить, то слова склеятся.
 
+## Управляющие символы
+
+В строках можно использовать управляющие символы, например `\n` для переноса строки или `\t` для табуляции. При конкатенации они работают так же, как и любые другие символы:
+
+```python
+print('Hello,' + '\n' + 'World!')
+# =>
+# Hello,
+# World!
+
+print('A' + '\t' + 'B')
+# => A	B
+```
+
 ## Заключение
 
 - Конкатенация — это объединение строк через +

modules/30-variables/18-variable-concatenation/ru/README.md

@@ -1,9 +1,9 @@
-Ранее мы уже склеивали строки напрямую. Теперь попробуем использовать переменные при конкатенации. Хорошая новость: синтаксис остаётся тем же. Просто подставляются значения переменных.
+Ранее мы уже склеивали строки напрямую используя конкатенацию. Теперь сделаем тоже самое, но с использованием переменных. Хорошая новость: синтаксис остаётся тем же. Просто подставляются значения переменных.
 
 ## 🧪 Склеиваем две строки напрямую
 
 ```python
-what = "Kings" + "road"
+what = 'Kings' + 'road'
 print(what)  # => Kingsroad
 ```
 
@@ -14,8 +14,8 @@ print(what)  # => Kingsroad
 Если в переменной first лежит строка "Kings", мы можем спокойно склеить её с другой строкой:
 
 ```python
-first = "Kings"
-what = first + "road"
+first = 'Kings'
+what = first + 'road'
 print(what)  # => Kingsroad
 ```
 
@@ -26,8 +26,8 @@ Python подставит значение переменной, выполни
 Точно так же можно объединить значения двух переменных, если обе содержат строки:
 
 ```python
-first = "Kings"
-last = "road"
+first = 'Kings'
+last = 'road'
 what = first + last
 print(what)  # => Kingsroad
 ```
@@ -52,14 +52,14 @@ age = 42
 
 ```python
 age = 42
-print("Age: " + str(age))  # ✅ Age: 42
+print('Age: ' + str(age))  # ✅ Age: 42
 ```
 
 То же самое касается переменных с результатами вычислений:
 
 ```python
 price = 50 * 1.25 * 6.91  # => 431.875
-print("Price in yuans: " + str(price))  # ✅
+print('Price in yuans: ' + str(price))  # ✅
 ```
 
 Функция `str()` превращает любое значение (число, результат вычисления, булево и т.д.) в строку. Подробнее про функции мы поговорим в будущих уроках.

modules/31-advanced-strings/70-slices/ru/README.md

@@ -25,42 +25,68 @@ print(year)  # => 2034
 строка[начало:конец]
 ```
 
-Важно: символ с индексом, указанным как "конец", не включается.
+Символ с индексом, указанным как "конец", не включается. Его можно воспринимать как естественный порядок символа, который нужно взять последним. То есть если там стоит 11, значит это будет 11 символ по порядку.
+
+```python
+# Последний символ имеет индекс 10, а всего букв 11
+value = 'code-basics'
+
+print(value[5:11])  # => basics (с 5 по 10 индекс)
+print(value[0:7])   # => code-ba (с 0 по 7 индекс)
+print(value[2:6])   # => de-b
+print(value[:4])    # => code
+print(value[5:])    # => basics
+```
+
+Как все это считать? Если мы работаем с конкретной строкой, то почти всегда это делается на глаз.
 
 ## 📘 Срез — это тоже строка
 
 ```python
 value = '01-12-9873'
 
-value[1:2]   # => '1'
-value[3:5]   # => '12'
+value[1:2]   # => 1
+value[3:5]   # => 12
 ```
 
 Срез всегда возвращает строку, даже если в ней только цифры. Это значит, что результат можно использовать, как обычную строку: конкатенировать, печатать, передавать в функции и так далее.
 
+```python
+part = value[3:7]   # => 12-9
+print(part[0:2])    # => 12
+```
+
+Сначала мы получили подстроку `'12-9'`, а потом сделали из неё новый срез `'12'`.
+
 ## ⬅️ Срез до конца или с начала
 
 Иногда нужно взять часть строки до конца или от начала — такие ситуации тоже легко обрабатываются срезами:
 
 ```python
 value = 'Hexlet'
 
-value[3:]   # => 'let'     # С 3 символа до конца
-value[:3]   # => 'Hex'     # От начала до 3 символа
+value[3:]   # => let     # С 3 символа до конца
+value[:3]   # => Hex     # От начала до 3 символа
 ```
 
 Если не указать границу, Python сам подставит нужное значение: начало строки или её конец.
 
 ## ↩️ Срезы с отрицательными индексами
 
-Python позволяет считать не только слева направо, но и с конца строки. Для этого используются отрицательные индексы:
+Python позволяет считать не только слева направо, но и с конца строки. Для этого используются отрицательные индексы.
 
 ```python
 value = 'Hexlet'
 
-value[-1]      # => 't'      # Последний символ
-value[3:-1]    # => 'le'     # От 3 до предпоследнего
-value[-5:3]    # => 'ex'     # С 1 до 3 включительно
+value[-1]   # => t      # Последний символ
+value[3:-1] # => le     # От 3 до предпоследнего
+value[-5:3] # => ex     # С 1 до 2
+```
+Индекс `-1` в этом случае соответствует последнему символу в строке. Поэтому здесь мы видим разный результат:
+
+```python
+value[3:-1] # => let
+value[3:]   # => le
 ```
 
 Это удобно, когда заранее неизвестна длина строки, но нужно взять «хвост» или «середину» строки относительно конца.
@@ -72,8 +98,8 @@ value[-5:3]    # => 'ex'     # С 1 до 3 включительно
 ```python
 value = 'Hexlet'
 
-value[1:5:2]   # => 'el'
-# Индексы 1, 3 → символы 'e', 'l'
+value[1:5:2]   # => el
+# Индексы 1, 3 → символы e, l
 ```
 
 В этом примере:
@@ -84,8 +110,8 @@ value[1:5:2]   # => 'el'
 Можно комбинировать с открытыми границами:
 
 ```python
-value[:5:2]    # => 'Hxe'
-value[1::2]    # => 'elt'
+value[:5:2]    # => Hxe
+value[1::2]    # => elt
 ```
 
 ## 🔄 Переворот строки
@@ -95,7 +121,7 @@ value[1::2]    # => 'elt'
 ```python
 value = 'Hexlet'
 
-value[::-1]    # => 'telxeH'
+value[::-1]    # => telxeH
 ```
 
 Это полностью переворачивает строку — с конца к началу. Очень удобно и лаконично.
@@ -107,8 +133,8 @@ value[::-1]    # => 'telxeH'
 ```python
 value = 'Hexlet'
 
-value[4:1:-1]  # => 'elx'
-# Индексы: 4, 3, 2 → 'e', 'l', 'x'
+value[4:1:-1]  # => elx
+# Индексы: 4, 3, 2 → e, l, x
 ```
 
 Python начнёт с индекса 4 и пойдёт влево до индекса 2 включительно. Индекс 1 — не включается.
@@ -122,7 +148,7 @@ start = 1
 end = 5
 
 value = 'Hexlet'
-print(value[start:end])  # => 'exle'
+print(value[start:end])  # => exle
 ```
 
 Это особенно полезно, когда границы вычисляются во время работы программы.
@@ -132,14 +158,14 @@ print(value[start:end])  # => 'exle'
 ```python
 value = 'Hexlet'
 
-value[::]       # 'Hexlet'  — вся строка
-value[:]        # 'Hexlet'
-value[::2]      # 'Hxe'     — чётные символы
-value[1::2]     # 'elt'     — нечётные символы
-value[::-1]     # 'telxeH'  — строка в обратном порядке
-value[5:]       # 't'
-value[:5]       # 'Hexle'
-value[-2:1:-1]  # 'elx'     — с предпоследнего до третьего
+value[::]       # Hexlet  — вся строка
+value[:]        # Hexlet
+value[::2]      # Hxe     — чётные символы
+value[1::2]     # elt     — нечётные символы
+value[::-1]     # telxeH  — строка в обратном порядке
+value[5:]       # t
+value[:5]       # Hexle
+value[-2:1:-1]  # elx     — с предпоследнего до третьего
 ```
 
 Когда делаете срез от большего индекса к меньшему, не забудьте задать отрицательный шаг — иначе срез не сработает.

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

@@ -6,4 +6,4 @@
 4. Пятый символ из второй строки
 5. Третий символ из второй строки
 
-Попробуйте использовать интерполяцию: внутри фигурных скобок можно помещать не только целые переменные, но и отдельные символы с помощью квадратных скобок.
+Попробуйте использовать интерполяцию (f-строки): внутри фигурных скобок можно помещать не только целые переменные, но и отдельные символы с помощью квадратных скобок.