fix language name for code blocks

Author: corsicanec82

modules/10-basics/30-instructions/ru/README.md

@@ -8,7 +8,7 @@
 
 Вот пример кода с двумя инструкциями:
 
-```Python
+```python
 print('Mother of Dragons.') # Первая инструкция
 print('Dracarys!') # Вторая инструкция
 ```
@@ -27,7 +27,7 @@ print('Dracarys!') # Вторая инструкция
 Интерпретатор Python исполняет код в строгом порядке — как вы его написали.
 Если поменять местами строки:
 
-```Python
+```python
 print('Dracarys!')
 print('Mother of Dragons.')
 ```
@@ -43,7 +43,7 @@ print('Mother of Dragons.')
 
 Обычно инструкции пишутся на отдельных строках, но Python допускает объединение нескольких инструкций в одну строку с помощью ;:
 
-```Python
+```python
 print('Mother of Dragons.'); print('Dracarys!')
 ```
 

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

@@ -6,7 +6,7 @@
 
 В математике для сложения мы пишем 3 + 4. В Python — всё точно так же:
 
-```Python
+```python
 3 + 4
 ```
 
@@ -19,7 +19,7 @@
 
 Для этого используем функцию `print()`:
 
-```Python
+```python
 print(3 + 4)
 ```
 
@@ -47,7 +47,7 @@ Python поддерживает все привычные операции:
 
 Вот как можно вывести результат деления и возведения в степень:
 
-```Python
+```python
 print(8 / 2)    # => 4.0
 print(3 ** 2)   # => 9
 ```
@@ -56,7 +56,7 @@ print(3 ** 2)   # => 9
 
 Эта операция называется **взятие остатка от деления**. Она показывает, **что «остаётся»**, когда одно число делится на другое *не полностью*. Пример:
 
-```Python
+```python
 print(7 % 3)  # => 1
 ```
 
@@ -67,7 +67,7 @@ print(7 % 3)  # => 1
 
 Другие примеры:
 
-```Python
+```python
 print(10 % 4)  # => 2 (10 делится на 4 дважды: 4 * 2 = 8, остаток 2)
 print(15 % 5)  # => 0 (делится без остатка)
 ```

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

@@ -2,7 +2,7 @@
 
 Рассмотрим пример:
 
-```Python
+```python
 print(2 * 4 * 5 * 10)
 ```
 
@@ -18,7 +18,7 @@ print(2 * 4 * 5 * 10)
 
 Всё просто, пока используются одинаковые операторы. Но что произойдёт, если объединить, например, умножение и сложение?
 
-```Python
+```python
 print(2 + 3 * 4)
 ```
 

modules/20-arithmetics/43-float/ru/README.md

@@ -5,7 +5,7 @@
 
 С точки зрения математики — всё просто. Но с точки зрения компьютера между этими типами чисел — настоящая пропасть. Попробуйте мысленно решить: Сколько будет `0.2` + `0.1`? Очевидно, `0.3`. А вот что скажет Python:
 
-```Python
+```python
 print(0.2 + 0.1)  # => 0.30000000000000004
 ```
 
@@ -26,7 +26,7 @@ print(0.2 + 0.1)  # => 0.30000000000000004
 - Когда вы явно пишете дробное число — например, 0.1, 2.5, 3.14.
 - Когда выполняете деление — даже если делите два целых числа:
 
-```Python
+```python
 print(1 / 2)  # => 0.5
 print(2 / 3)  # => 0.6666666666666666
 ```

modules/20-arithmetics/45-linting/ru/README.md

@@ -28,7 +28,7 @@
 
 Рассмотрим пример:
 
-```Python
+```python
 result = 1+ 3
 ```
 
@@ -40,7 +40,7 @@ E225: missing whitespace around operator
 
 Это значит, что перед и после + не хватает пробелов. Согласно стандарту, должно быть так:
 
-```Python
+```python
 result = 1 + 3
 ```
 

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

@@ -4,7 +4,7 @@
 
 В Python строки объединяются с помощью оператора +. Несмотря на то что этот оператор используется и для сложения чисел, в случае строк он означает объединение — склеивание содержимого:
 
-```Python
+```python
 print('Dragon' + 'stone')
 # => Dragonstone
 ```
@@ -13,7 +13,7 @@ print('Dragon' + 'stone')
 
 Примеры:
 
-```Python
+```python
 print('Kings' + 'wood')       # => Kingswood
 print('Kings' + 'road')       # => Kingsroad
 print("King's" + 'Landing')   # => King'sLanding
@@ -25,7 +25,7 @@ Python позволяет объединять строки, даже если 
 
 При объединении Python не вставляет пробелы автоматически. Если между частями должен быть пробел, его нужно указать вручную:
 
-```Python
+```python
 # Пробел в конце первой строки
 print("King's " + 'Landing')  # => King's Landing
 

modules/25-strings/30-encoding/ru/EXERCISE.md

@@ -2,7 +2,7 @@
 
 В Python есть специальная команда chr(число), которая показывает, какой символ стоит за этим числом. Например:
 
-```Python
+```python
 print(chr(63))
 ```
 
@@ -29,7 +29,7 @@ print(chr(63))
 
 ## ✅ Примерный шаблон
 
-```Python
+```python
 print(chr(...))  # какой-то символ
 print(chr(...))  # ещё один
 print(chr(...))  # и третий

modules/30-variables/19-naming-style/ru/README.md

@@ -20,7 +20,7 @@
 
 ## Как правильно в Python
 
-```Python
+```python
 user_name = "Daenerys"
 max_length = 280
 total_orders = 17

modules/31-advanced-strings/30-symbols/ru/README.md

@@ -6,13 +6,13 @@
 
 Представим, что у нас есть строка:
 
-```Python
+```python
 first_name = 'Alexander'
 ```
 
 Чтобы получить первую букву, указываем её позицию (индекс) в квадратных скобках:
 
-```Python
+```python
 print(first_name[0])  # => A
 ```
 
@@ -25,13 +25,13 @@ print(first_name[0])  # => A
 
 Чтобы получить, например, последний символ, можно написать:
 
-```Python
+```python
 print(first_name[8])  # => r
 ```
 
 А если выйти за границы строки:
 
-```Python
+```python
 print(first_name[9])
 ```
 
@@ -41,7 +41,7 @@ IndexError: string index out of range
 
 Часто нужно получить последний символ строки, но заранее неизвестна её длина. В этом случае можно использовать отрицательные индексы:
 
-```Python
+```python
 print(first_name[-1])  # => r
 print(first_name[-2])  # => e
 ```
@@ -59,7 +59,7 @@ print(first_name[-2])  # => e
 
 Индекс можно хранить в переменной, а не записывать прямо:
 
-```Python
+```python
 index = 0
 print(first_name[index])  # => A
 ```
@@ -68,7 +68,7 @@ print(first_name[index])  # => A
 
 ## 💡 Подумайте: что выведет этот код?
 
-```Python
+```python
 magic = '\nyou'
 print(magic[1])  # => ?
 ```

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

@@ -13,23 +13,23 @@
 
 Получается, год начинается с индекса 6 и заканчивается на 9. Чтобы извлечь его, мы используем срез:
 
-```Python
+```python
 value = '12-08-2034'
 year = value[6:10]
 print(year)  # => 2034
 ```
 
 Срез `value[6:10]` берёт символы с индекса 6 по 9 включительно. Формат среза:
 
-```Python
+```python
 строка[начало:конец]
 ```
 
 Важно: символ с индексом, указанным как "конец", не включается.
 
 ## 📘 Срез — это тоже строка
 
-```Python
+```python
 value = '01-12-9873'
 
 value[1:2]   # => '1'
@@ -42,7 +42,7 @@ value[3:5]   # => '12'
 
 Иногда нужно взять часть строки до конца или от начала — такие ситуации тоже легко обрабатываются срезами:
 
-```Python
+```python
 value = 'Hexlet'
 
 value[3:]   # => 'let'     # С 3 символа до конца
@@ -55,7 +55,7 @@ value[:3]   # => 'Hex'     # От начала до 3 символа
 
 Python позволяет считать не только слева направо, но и с конца строки. Для этого используются отрицательные индексы:
 
-```Python
+```python
 value = 'Hexlet'
 
 value[-1]      # => 't'      # Последний символ
@@ -69,7 +69,7 @@ value[-5:3]    # => 'ex'     # С 1 до 3 включительно
 
 У среза есть третий параметр — шаг. По умолчанию шаг равен 1, то есть символы идут подряд. Но шаг можно изменить, например, взять каждый второй символ:
 
-```Python
+```python
 value = 'Hexlet'
 
 value[1:5:2]   # => 'el'
@@ -83,7 +83,7 @@ value[1:5:2]   # => 'el'
 
 Можно комбинировать с открытыми границами:
 
-```Python
+```python
 value[:5:2]    # => 'Hxe'
 value[1::2]    # => 'elt'
 ```
@@ -92,7 +92,7 @@ value[1::2]    # => 'elt'
 
 Одна из самых популярных «фишек» с шагом — реверс строки. Для этого используют отрицательный шаг:
 
-```Python
+```python
 value = 'Hexlet'
 
 value[::-1]    # => 'telxeH'
@@ -104,7 +104,7 @@ value[::-1]    # => 'telxeH'
 
 Если вы используете отрицательный шаг, помните: индексы тоже нужно указывать в обратном порядке. Иначе срез не сработает (возвратит пустую строку):
 
-```Python
+```python
 value = 'Hexlet'
 
 value[4:1:-1]  # => 'elx'
@@ -117,7 +117,7 @@ Python начнёт с индекса 4 и пойдёт влево до инде
 
 Срезы не обязаны быть жёстко зафиксированы числами. Можно использовать переменные:
 
-```Python
+```python
 start = 1
 end = 5
 
@@ -129,7 +129,7 @@ print(value[start:end])  # => 'exle'
 
 ## 🧪 Быстрая шпаргалка
 
-```Python
+```python
 value = 'Hexlet'
 
 value[::]       # 'Hexlet'  — вся строка