udpate content

Signed-off-by: Kirill Mokevnin <mokevnin@gmail.com>

Author: mokevnin

modules/40-define-functions/500-named-arguments/ru/EXERCISE.md

@@ -1,6 +1,4 @@
-
-Реализуйте функцию `trim_and_repeat()`, которая принимает три параметра: строку, `offset` — число символов, на которое нужно обрезать строку слева и `repetitions` — количество обрезанных строк, которые нужно вывести. Функция обрезает строку и повторяет ее столько раз, чтобы общее количество обрезанных строк равнялось `repetitions`. Функция должна записать результат в одну строку и вернуть его.
-Число символов для среза по умолчанию равно 0, а повторений — 1.
+Реализуйте функцию `trim_and_repeat()`, которая принимает три параметра: строку, `offset` — число символов, на которое нужно обрезать строку слева и `repetitions` — количество обрезанных строк, которые нужно вывести. Функция обрезает строку и повторяет ее столько раз, чтобы общее количество обрезанных строк равнялось `repetitions`. Функция должна записать результат в одну строку и вернуть его. Число символов для среза по умолчанию равно 0, а повторений — 1.
 
 ```python
 text = 'python'

modules/40-define-functions/500-named-arguments/ru/README.md

@@ -1,50 +1,36 @@
-В этом уроке разберем, какие параметры существуют, чем они отличаются и в каких случаях их применять.
+Функции в Python можно вызывать по`разному. До этого мы передавали значения строго по порядку: первое значение шло в первый параметр, второе — во второй и так далее. Такой способ называется **позиционным вызовом**.
 
-**Аргументы** — это данные, которые передаются в вызов функции. Они бывают двух типов:
-
-Первый тип — **позиционные аргументы**. Они передаются в том же порядке, в котором определены параметры функции:
+Но в Python есть ещё один вариант — **именованные аргументы**. При вызове функции мы явно указываем имя параметра, которому передаём значение. Он особенно удобен, когда у функции много параметров или не все из них нужно менять — тогда можно указать только нужные по имени, а остальные оставить со значениями по умолчанию.  
 
 ```python
-# (text, length)
-truncate('My Text', 3)
-```
-
-Второй тип — **именованные аргументы**. Они передаются не просто как значения, а как пара «имя=значение». Поэтому их можно передавать в любом порядке:
+def repeat(text, times=1):
+    return text * times
 
-```python
-# Аргументы переданы в другом порядке
-truncate(length=3, text='My Text')
+repeat("Hi", 3)             # позиционный вызов  
+repeat(text="Hi", times=3)  # именованный вызов  
 ```
 
-Если внимательно посмотреть на два примера выше, то можно понять, что это две одинаковые функции.
-
-Теперь разберемся, в каких случаях нужно применять эти типы аргументов.
-
-Выбор типа параметра зависит от того, кто вызывает функцию.
+Оба варианта делают одно и то же. Но во втором случае мы явно написали, что "Hi" — это text, а 3 — это times. С точки зрения определения функции ничего не поменялось, именованные аргументы могут использоваться для любой функции, сама функция об этом ничего не знает. Она получает значения, так как они описаны в определении.
 
-Есть две причины использовать именованные аргументы:
+Именованные аргументы можно указывать в любом порядке. Это не меняет результат работы функции, потому что значения связываются именно по имени параметра.  
 
-* Они повышают читаемость, так как сразу видно имена
+```python
+repeat(times=3, text="Hi")  # => HiHiHi
+```
 
-* Можно не указывать все промежуточные параметры, которые нам сейчас не нужны
+## Когда использовать именованные аргументы
 
-Последнее полезно, если у функции много необязательных параметров. Посмотрим на примере:
+Именованные аргументы полезны, когда у функции есть несколько параметров и не все из них нужно менять. В таких случаях можно указать только те параметры, которые действительно важны в конкретном вызове, а остальные оставить со значениями по умолчанию.  
 
 ```python
-def print_params(a=1, b=2, c=3, d=4):
-    print(a, b, c, d)
+def make_line(symbol="-", length=10):
+    return symbol * length
 
-# Нужно передать только d, но приходится передавать все
-f(1, 2, 3, 8)
+make_line()          # все параметры по умолчанию  
 
-# Именованные аргументы позволяют передавать только d
-# Для остальных аргументов используются значения по умолчанию
-f(d=8)
+make_line(length=5)  # меняем только длину  
+# Без этого пришлось бы писать так
+make_line("-", 5)
 ```
 
-Именованные аргументы можно передавать одновременно с позиционными. Тогда позиционные должны идти в самом начале:
-
-```python
-# Передаем только a (позиционно) и d (как именованный)
-f(3, d=3)
-```
+Нам не пришлось указывать явно символ, даже несмотря на то, что он идет в списке параметров раньше длины. Это также делает вызовы функций более понятными для чтения: сразу видно, какое именно значение относится к какому параметру.  

modules/40-define-functions/600-type-annotations/ru/EXERCISE.md

@@ -1,4 +1,3 @@
-
 Реализуйте функцию `word_multiply()`. Она должна принимать два параметра:
 
 * Строку

modules/40-define-functions/600-type-annotations/ru/README.md

@@ -1,33 +1,64 @@
-**Аннотации типов** — это возможность указать типы параметров и возвращаемое значение у функции в Python. Это не является обязательным требованием языка, но может помочь программистам в дальнейшей разработке, улучшить читаемость кода и повысить его надежность.
+В Python в функцию можно передать любые значения. Иногда это усложняет понимание кода: не всегда ясно, что именно ожидает функция и что она возвращает.  
 
-Давайте рассмотрим простой пример функции без аннотаций типов:
+Чтобы сделать код понятнее, в Python есть **аннотации типов**. С их помощью можно явно указать, какие значения принимает функция и какой результат она возвращает. Эти подсказки полезны в редакторах кода: они показывают ожидаемые типы аргументов и помогают быстрее разобраться, как пользоваться функцией.  
+
+## Как указывать типы параметров
+
+Аннотация функции описывает два элемента:  
+
+1. **Типы параметров** — указываются прямо в определении функции после имени каждого параметра через двоеточие.
+2. **Тип возвращаемого результата** — указывается после списка параметров с помощью стрелки ``>`.
+
+Разберем на примере функции, которая вычисляет сумму двух переданных значений:
 
 ```python
-def concat(first, second):
-    return first + second
+def add(a: int, b: int) -> int:
+    return a + b
+
+print(add(2, 3))   # => 5
 ```
 
-Эта функция конкатенирует две строки в одну. При этом с первого взгляда на код сложно понять, что происходит в нем: какие типы у аргументов, почему функция работает со строками, а не складывает, например, два числа.
+Теперь редактор кода будет подсказывать, что функция `add` принимает два числа и возвращает число. Если попытаться передать строку, редактор подсветит это как проблему и предупредит.
+
+## Какие типы используются в аннотациях
 
-Если в дальнейшем использовать эту функцию в коде, то может возникнуть необходимость проверять типы аргументов перед передачей их в функцию, что увеличивает объем кода и затрудняет его понимание.
+На этом этапе достаточно знать аннотации для простых, примитивных типов данных:  
 
-Теперь давайте добавим аннотации типов к функции:
+* `int` — целые числа  
+* `float` — числа с плавающей точкой  
+* `str` — строки  
+* `bool` — логические значения (True или False)
 
 ```python
-def concat(first: str, second: str) -> str:
-    return first + second
+def describe(name: str, age: int, height: float) -> str:
+    return f"{name}, {age} лет, рост {height}"
+
+print(describe("Anna", 25, 1.70))
+# => Anna, 25 лет, рост 1.7
 ```
 
-Здесь мы указали, что аргументы `first` и `second` должны быть строкового типа (`str`). Возвращаемое значение тоже будет строковым. Когда мы будем использовать эту функцию в коде, нам будет проще понять, какие типы аргументов можно передавать и какой тип возвращаемого значения ожидается.
+## Пример с параметрами по умолчанию
 
-Аннотации типов также могут быть использованы для определения типов переменных внутри функции. Например:
+Аннотации работают одинаково как для обязательных параметров, так и для тех, у которых есть значение по умолчанию. Сначала указывается тип, потом через `=` — стандартное значение.  
 
 ```python
-def double(n: int) -> int:
-    result: int = n * 2
-    return result
+def greet(name: str, greeting: str = "Hello") -> str:
+    return f"{greeting}, {name}"
+
+print(greet("Anna"))          # => Hello, Anna
+print(greet("Kirill", "Hi"))  # => Hi, Kirill
 ```
 
-В этом примере мы определили тип переменной `result` как `int`, используя аннотацию типа.
+В этом примере `name` — обязательный параметр, а `greeting` имеет значение по умолчанию. Аннотации показывают типы обоих параметров и возвращаемого результата.  
+
+## Аннотации и проверка кода
+
+Хотя сам Python не проверяет аннотации во время выполнения программы, есть отдельные инструменты, которые умеют это делать. Такой подход называют **статической проверкой кода**.  
+
+"Статическая" значит, что проверка происходит ещё до запуска программы. Инструмент читает исходный код и сверяет, соответствуют ли переданные значения указанным типам.  
+
+Например, если функция принимает строку, а вы передадите число, то при статической проверке это будет показано как ошибка.  
+
+Особенно удобно, когда такие ошибки подсвечивает редактор прямо во время написания кода. Это позволяет сразу увидеть проблему и исправить её, не дожидаясь запуска программы. Благодаря этому в работающем коде становится меньше неожиданных ошибок — многие из них отлавливаются заранее.  
 
-Аннотации типов — это не строгая проверка типов в Python. Их использование не гарантирует, что функция будет вызвана с аргументами и возвращаемым значением указанных типов. Все таки Python остается динамически типизированным языком. В нем аннотации типов не влияют на возможность передачи аргументов различных типов или возвращения значений других типов. Тем не менее их использование упрощает чтение и понимание кода и помогает отслеживать ошибки.
+Аннотации типов не являются обязательными. Функции можно писать и без них — Python всё равно будет работать. Но когда аннотации есть, код становится понятнее для людей и удобнее для редакторов. Нужно ли аннотировать функции в своем коде? Да, это считается хорошей практикой.

modules/45-logic/10-bool-type/ru/README.md

@@ -1,4 +1,3 @@
-
 Кроме арифметических операций в математике есть операции сравнения, например, `5 > 4` или `3 < 1`. Они есть и в программировании. Допустим, когда мы заходим на сайт, введенные логин и пароль сравниваются с теми, какие есть в базе. Если они есть, нас пускают внутрь — аутентифицируют. В этом уроке разберем операции сравнения.
 
 Языки программирования адаптировали все математические операции сравнения в неизменном виде, кроме операторов равенства и неравенства. В математике для этого используется обычное равно `=`, но в программировании такое встречается редко.