diff --git a/modules/10-basics/10-hello-world/ru/README.md b/modules/10-basics/10-hello-world/ru/README.md index 25186c3f..9609f038 100644 --- a/modules/10-basics/10-hello-world/ru/README.md +++ b/modules/10-basics/10-hello-world/ru/README.md @@ -1,3 +1,5 @@ +![Hello World](./assets/hello-world.png) + Изучение нового языка программирования традиционно начинается с 'Hello, World!'. Это простая программа, которая выводит приветствие на экран и заодно знакомит с новым языком — его синтаксисом и структурой программы. ```text diff --git a/modules/10-basics/10-hello-world/ru/assets/hello-world.png b/modules/10-basics/10-hello-world/ru/assets/hello-world.png new file mode 100644 index 00000000..9bf2299f Binary files /dev/null and b/modules/10-basics/10-hello-world/ru/assets/hello-world.png differ diff --git a/modules/10-basics/30-instructions/ru/README.md b/modules/10-basics/30-instructions/ru/README.md index b4772658..34284c72 100644 --- a/modules/10-basics/30-instructions/ru/README.md +++ b/modules/10-basics/30-instructions/ru/README.md @@ -1,3 +1,5 @@ +![Инструкции](./assets/instructions.png) + Когда мы готовим блюдо, то следуем рецепту шаг за шагом. Пропустим этап — и результат будет отличаться от ожидаемого. В программировании работает тот же принцип: чёткий порядок инструкций определяет, как работает программа. Инструкция (или оператор) — это команда для компьютера. Она говорит: «сделай что-то прямо сейчас». Интерпретатор Python (специальная программа, которая понимает и выполняет код) выполняет код сверху вниз, по строкам. Он обрабатывает каждую инструкцию по очереди, как если бы читал рецепт по шагам. diff --git a/modules/10-basics/30-instructions/ru/assets/instructions.png b/modules/10-basics/30-instructions/ru/assets/instructions.png new file mode 100644 index 00000000..98ffb498 Binary files /dev/null and b/modules/10-basics/30-instructions/ru/assets/instructions.png differ diff --git a/modules/20-arithmetics/20-basic/ru/README.md b/modules/20-arithmetics/20-basic/ru/README.md index 54e9f8b8..3b39164c 100644 --- a/modules/20-arithmetics/20-basic/ru/README.md +++ b/modules/20-arithmetics/20-basic/ru/README.md @@ -1,3 +1,5 @@ +![Счетные палочки](./assets/arithmetics.png) + На базовом уровне компьютеры работают только с числами. Даже если вы пишете сложное приложение на современном языке программирования, внутри него всегда происходят многочисленные вычисления: сложение, вычитание, деление и т.д. К счастью, чтобы начать программировать, достаточно знать обычную школьную арифметику. С неё мы и начнём. diff --git a/modules/20-arithmetics/20-basic/ru/assets/arithmetics.png b/modules/20-arithmetics/20-basic/ru/assets/arithmetics.png new file mode 100644 index 00000000..ae492022 Binary files /dev/null and b/modules/20-arithmetics/20-basic/ru/assets/arithmetics.png differ diff --git a/modules/20-arithmetics/45-linting/ru/README.md b/modules/20-arithmetics/45-linting/ru/README.md index fb159b78..5f8f1dbe 100644 --- a/modules/20-arithmetics/45-linting/ru/README.md +++ b/modules/20-arithmetics/45-linting/ru/README.md @@ -1,3 +1,5 @@ +![Ошибки](./assets/errors-python.png) + Вы уже умеете писать простые программы. Теперь стоит разобраться с тем, как писать код, чтобы его было легко читать и поддерживать. Это важный навык, особенно если вы работаете не в одиночку. Когда разные разработчики пишут в разном стиле, код становится трудночитаемым: где-то пробел лишний, где-то отступы разные, а где-то переменные называются непонятно. Чтобы избежать хаоса, программисты договорились соблюдать единый стиль кодирования. Это свод правил, которые описывают, как должен выглядеть код — от расстановки пробелов до оформления функций и названий переменных. diff --git a/modules/20-arithmetics/45-linting/ru/assets/errors-python.png b/modules/20-arithmetics/45-linting/ru/assets/errors-python.png new file mode 100644 index 00000000..60b0d8c5 Binary files /dev/null and b/modules/20-arithmetics/45-linting/ru/assets/errors-python.png differ diff --git a/modules/25-strings/10-quotes/ru/README.md b/modules/25-strings/10-quotes/ru/README.md index 4a855f4c..8e38224b 100644 --- a/modules/25-strings/10-quotes/ru/README.md +++ b/modules/25-strings/10-quotes/ru/README.md @@ -1,3 +1,5 @@ +![Строки](./assets/strings.png) + Строки в программировании на Python используются очень часто и в самых разных ситуациях. С их помощью мы работаем с текстом: выводим сообщения на экран, обрабатываем пользовательский ввод, читаем данные из файлов, формируем запросы к базам данных или внешним системам. С точки зрения Python, строка — это просто набор символов, заключённый в кавычки. Посмотрим на примеры: diff --git a/modules/25-strings/10-quotes/ru/assets/strings.png b/modules/25-strings/10-quotes/ru/assets/strings.png new file mode 100644 index 00000000..4cce3286 Binary files /dev/null and b/modules/25-strings/10-quotes/ru/assets/strings.png differ diff --git a/modules/25-strings/15-escape-characters/ru/README.md b/modules/25-strings/15-escape-characters/ru/README.md index 854f62e2..2b9c8e9a 100644 --- a/modules/25-strings/15-escape-characters/ru/README.md +++ b/modules/25-strings/15-escape-characters/ru/README.md @@ -49,7 +49,7 @@ print("Hello\nWorld") # World print("Hello \nWorld") -# Hello +# Hello # World (в конце первой строки есть пробел) print("Hello\n World") diff --git a/modules/30-variables/10-definition/ru/README.md b/modules/30-variables/10-definition/ru/README.md index 64d4a545..b1822b98 100644 --- a/modules/30-variables/10-definition/ru/README.md +++ b/modules/30-variables/10-definition/ru/README.md @@ -27,6 +27,8 @@ Father! Father! ``` +![Определение переменной](./assets/variable-definition.png) + **Переменная** — это имя, за которым хранится значение. В нашем примере мы создали переменную с именем `greeting` и записали в неё строку `'Father!'`. Строчка `greeting = 'Father!'` читается так: «возьми значение `'Father!'` и присвой его переменной с именем `greeting`». Знак `=` здесь не означает равенство, как в математике, а является оператором присваивания. Он кладёт значение в переменную. diff --git a/modules/30-variables/10-definition/ru/assets/variable-definition.png b/modules/30-variables/10-definition/ru/assets/variable-definition.png new file mode 100644 index 00000000..7ea3324c Binary files /dev/null and b/modules/30-variables/10-definition/ru/assets/variable-definition.png differ diff --git a/modules/30-variables/13-variables-naming/ru/README.md b/modules/30-variables/13-variables-naming/ru/README.md index ab51812b..1f4f8e04 100644 --- a/modules/30-variables/13-variables-naming/ru/README.md +++ b/modules/30-variables/13-variables-naming/ru/README.md @@ -1,3 +1,5 @@ +![Именование](./assets/naming.png) + Представьте, что у нас есть такая программа: ```python diff --git a/modules/30-variables/13-variables-naming/ru/assets/naming.png b/modules/30-variables/13-variables-naming/ru/assets/naming.png new file mode 100644 index 00000000..a1380ac9 Binary files /dev/null and b/modules/30-variables/13-variables-naming/ru/assets/naming.png differ diff --git a/modules/31-advanced-strings/30-symbols/ru/README.md b/modules/31-advanced-strings/30-symbols/ru/README.md index e89f7643..61d8ec57 100644 --- a/modules/31-advanced-strings/30-symbols/ru/README.md +++ b/modules/31-advanced-strings/30-symbols/ru/README.md @@ -1,3 +1,5 @@ +![Извлечение символов из строки](./assets/symbols.png) + Иногда нужно получить один символ из строки. Например, если сайт знает имя и фамилию пользователя и нужно вывести их в сокращённом формате — A. Ivanov. Для этого потребуется взять первую букву имени. В Python для таких задач есть специальный механизм — индексация. diff --git a/modules/31-advanced-strings/30-symbols/ru/assets/symbols.png b/modules/31-advanced-strings/30-symbols/ru/assets/symbols.png new file mode 100644 index 00000000..6093469e Binary files /dev/null and b/modules/31-advanced-strings/30-symbols/ru/assets/symbols.png differ diff --git a/modules/33-data-types/40-primitive-data-types/ru/README.md b/modules/33-data-types/40-primitive-data-types/ru/README.md index eeb98246..092763dd 100644 --- a/modules/33-data-types/40-primitive-data-types/ru/README.md +++ b/modules/33-data-types/40-primitive-data-types/ru/README.md @@ -37,10 +37,10 @@ print('-5') # => -5 На экране результат выглядит одинаково, но внутри программы это совершенно разные вещи: -| Значение | Тип данных | -|----------|------------------| +| Значение | Тип данных | +|----------|---------------------| | `5` | `int` (целое число) | -| `'5'` | `str` (строка) | +| `'5'` | `str` (строка) | Строку '5' нельзя сложить с числом 5, как и '10' / 2 не даст числа 5.0. Python будет ругаться, если вы попытаетесь смешать несовместимые типы без явного преобразования. diff --git a/modules/33-data-types/55-data-types-casting/ru/README.md b/modules/33-data-types/55-data-types-casting/ru/README.md index 14a9a9b1..85f31a03 100644 --- a/modules/33-data-types/55-data-types-casting/ru/README.md +++ b/modules/33-data-types/55-data-types-casting/ru/README.md @@ -1,3 +1,5 @@ +![Число в виде строки](./assets/number-as-string.png) + В реальных программах часто возникает ситуация, когда данные одного типа нужно превратить в другой. Это особенно актуально, например, при обработке ввода пользователя или данных из веб-форм. Там всё приходит в виде строк, даже если вы ввели число. Чтобы работать с такими значениями, их нужно явно преобразовать в нужный тип. Python предоставляет для этого простые и понятные инструменты. diff --git a/modules/33-data-types/55-data-types-casting/ru/assets/number-as-string.png b/modules/33-data-types/55-data-types-casting/ru/assets/number-as-string.png new file mode 100644 index 00000000..76d69af3 Binary files /dev/null and b/modules/33-data-types/55-data-types-casting/ru/assets/number-as-string.png differ diff --git a/modules/35-calling-functions/100-call/ru/README.md b/modules/35-calling-functions/100-call/ru/README.md index 1eda4922..91b1f5c9 100644 --- a/modules/35-calling-functions/100-call/ru/README.md +++ b/modules/35-calling-functions/100-call/ru/README.md @@ -1,3 +1,5 @@ +![Функция](./assets/function.png) + Программирование нужно для того, чтобы выполнять самые разные операции. Иногда это простые действия, например сложение чисел или объединение строк. Но чаще речь идёт о сложных процессах: перевод денег со счёта на счёт, оформление заказа в интернет-магазине, расчёт налогов или подготовка отчёта. Такие операции невозможно выразить одной командой. За действием вроде «перевести деньги» может скрываться десятки, сотни и даже тысячи строк кода: проверка баланса, списание суммы, учёт комиссии, обновление базы данных, отправка уведомления пользователю. @@ -54,13 +56,13 @@ backup_database() Функции бывают двух видов: встроенные в язык (built-in) и созданные программистами. -**Встроенные функции** — это те, что идут вместе с языком Python. Их можно использовать сразу, без дополнительных действий. Пример — функция `print()`, которая выводит данные на экран: +**Встроенные функции** — это те, что идут вместе с языком Python. Их можно использовать сразу, без дополнительных действий. Пример — функция `print()`, которая выводит данные на экран: ```python print('Hello, World!') ``` -**Функции, определяемые программистами**, создаются тогда, когда нужно оформить свою логику в отдельный блок. Такую функцию можно назвать любым именем и использовать в коде так же, как встроенные. Мы научимся этому позже. +**Функции, определяемые программистами**, создаются тогда, когда нужно оформить свою логику в отдельный блок. Такую функцию можно назвать любым именем и использовать в коде так же, как встроенные. Мы научимся этому позже. Кроме того, существуют функции, которые находятся в отдельных библиотеках. Чтобы ими пользоваться, их нужно подключать с помощью механизма импорта. Подробно импорт мы пока не разбираем, но в двух словах: это способ «подключить» внешний набор функций и сделать их доступными в программе. @@ -78,7 +80,7 @@ print(count) # => 6 ## Возврат значения -Возврат значения — один из ключевых принципов работы функций. Благодаря ему мы можем соединять результаты разных действий и строить более сложную логику. Если функция возвращает значение, то мы можем сохранить его в переменную, передать в другую функцию или использовать в вычислениях. Именно так работает `len()`: она считает количество элементов и отдаёт результат «наружу». +Возврат значения — один из ключевых принципов работы функций. Благодаря ему мы можем соединять результаты разных действий и строить более сложную логику. Если функция возвращает значение, то мы можем сохранить его в переменную, передать в другую функцию или использовать в вычислениях. Именно так работает `len()`: она считает количество элементов и отдаёт результат «наружу». ```python message1 = 'Hello!' @@ -91,7 +93,7 @@ combined_length = length1 + length2 # используем результат в print(combined_length) ``` -Если бы `len()` сразу печатала результат на экран (как делает `print()`), то мы бы увидели число, но не смогли бы его использовать: +Если бы `len()` сразу печатала результат на экран (как делает `print()`), то мы бы увидели число, но не смогли бы его использовать: ```python # воображаемая функция, которая только печатает результат @@ -102,7 +104,7 @@ fake_len('Hello!') # напечатает 6 result = fake_len('Hello!') # здесь в result ничего нет ``` -Вот почему возврат значения — настолько важная концепция. Он позволяет связывать функции между собой: одни функции возвращают данные, другие используют их в своей работе. Именно так из маленьких шагов строятся большие и сложные программы. +Вот почему возврат значения — настолько важная концепция. Он позволяет связывать функции между собой: одни функции возвращают данные, другие используют их в своей работе. Именно так из маленьких шагов строятся большие и сложные программы. ## Функция с несколькими параметрами @@ -123,8 +125,8 @@ print(pow(5, 2)) # => 25 Часто вместе с функциями упоминают два слова: **параметры** и **аргументы**. Они связаны, но не одно и то же. -- **Параметры** — это имена «мест для данных», которые ожидает функция. -- **Аргументы** — это конкретные значения, которые мы передаём в эти места при вызове. +- **Параметры** — это имена «мест для данных», которые ожидает функция. +- **Аргументы** — это конкретные значения, которые мы передаём в эти места при вызове. ```python # функция pow ожидает два параметра: основание и степень diff --git a/modules/35-calling-functions/100-call/ru/assets/function.png b/modules/35-calling-functions/100-call/ru/assets/function.png new file mode 100644 index 00000000..f89fee08 Binary files /dev/null and b/modules/35-calling-functions/100-call/ru/assets/function.png differ diff --git a/modules/35-calling-functions/135-calling-functions-default-params/ru/README.md b/modules/35-calling-functions/135-calling-functions-default-params/ru/README.md index e44c5003..f5d001b5 100644 --- a/modules/35-calling-functions/135-calling-functions-default-params/ru/README.md +++ b/modules/35-calling-functions/135-calling-functions-default-params/ru/README.md @@ -1,36 +1,38 @@ -Некоторые функции в Python имеют **необязательные параметры**. Это значит, что для них заранее задано значение по умолчанию, и при вызове можно этот параметр не указывать. +![Автосервис](./assets/default-parameters.png) -Рассмотрим встроенную функцию `round()`, которая округляет число: +Некоторые функции в Python имеют **необязательные параметры**. Это значит, что для них заранее задано значение по умолчанию, и при вызове можно этот параметр не указывать. + +Рассмотрим встроенную функцию `round()`, которая округляет число: ```python result = round(10.25, 0) # 10.0 ``` -Мы передали в неё два значения: +Мы передали в неё два значения: -- число, которое нужно округлить -- точность округления +- число, которое нужно округлить +- точность округления -`0` означает, что округление будет до целого числа. +`0` означает, что округление будет до целого числа. -Так как чаще всего нужно именно округление до целого, создатели функции `round()` сделали второй параметр необязательным и задали ему значение по умолчанию `0`. Поэтому результат будет тем же, даже если второй параметр не указывать: +Так как чаще всего нужно именно округление до целого, создатели функции `round()` сделали второй параметр необязательным и задали ему значение по умолчанию `0`. Поэтому результат будет тем же, даже если второй параметр не указывать: ```python result = round(10.25) # 10.0 ``` -Если нужна другая точность, то её можно указать явно: +Если нужна другая точность, то её можно указать явно: ```python # округление до одного знака после запятой result = round(10.25, 1) # 10.2 ``` -В Python необязательные параметры всегда идут после обязательных. Их количество зависит от конкретной функции, но порядок остаётся тем же — сначала обязательные, потом необязательные. +В Python необязательные параметры всегда идут после обязательных. Их количество зависит от конкретной функции, но порядок остаётся тем же — сначала обязательные, потом необязательные. ## Сигнатура функции -У каждой функции есть **сигнатура** — описание её имени, параметров и порядка их использования. Сигнатура помогает понять, какие данные функция ожидает и что будет происходить, если параметры не указаны. +У каждой функции есть **сигнатура** — описание её имени, параметров и порядка их использования. Сигнатура помогает понять, какие данные функция ожидает и что будет происходить, если параметры не указаны. Посмотрим на [документацию](https://docs.python.org/3/library/functions.html#round) для функции `round()`: @@ -38,7 +40,7 @@ result = round(10.25, 1) # 10.2 round(number, ndigits=None) ``` -Это и есть сигнатура. Она читается так: +Это и есть сигнатура. Она читается так: - функция называется `round`; - первый параметр `number` — обязательный, это число, которое нужно округлить; @@ -46,10 +48,10 @@ round(number, ndigits=None) ## Как работать с новыми функциями -Когда вы встречаете новую функцию, можно использовать простой паттерн: +Когда вы встречаете новую функцию, можно использовать простой паттерн: -1. Открыть документацию и найти сигнатуру функции. -2. Посмотреть примеры использования. -3. Перейти в интерактивную оболочку Python (REPL) и попробовать вызвать функцию с разными аргументами. +1. Открыть документацию и найти сигнатуру функции. +2. Посмотреть примеры использования. +3. Перейти в интерактивную оболочку Python (REPL) и попробовать вызвать функцию с разными аргументами. Такой подход помогает быстро разобраться, как именно работает функция, какие у неё обязательные и необязательные параметры и какие результаты она возвращает. diff --git a/modules/35-calling-functions/135-calling-functions-default-params/ru/assets/default-parameters.png b/modules/35-calling-functions/135-calling-functions-default-params/ru/assets/default-parameters.png new file mode 100644 index 00000000..97e4297a Binary files /dev/null and b/modules/35-calling-functions/135-calling-functions-default-params/ru/assets/default-parameters.png differ diff --git a/modules/35-calling-functions/150-calling-functions-expression/ru/README.md b/modules/35-calling-functions/150-calling-functions-expression/ru/README.md index 18228fd1..71a92b65 100644 --- a/modules/35-calling-functions/150-calling-functions-expression/ru/README.md +++ b/modules/35-calling-functions/150-calling-functions-expression/ru/README.md @@ -22,7 +22,7 @@ print(salary) ## Выражения как аргументы функций -Аргументом функции всегда является какое-то значение. Но значение не обязательно записывать напрямую — его можно вычислить. А значит, в аргументы функции можно подставлять любые выражения. +Аргументом функции всегда является какое-то значение. Но значение не обязательно записывать напрямую — его можно вычислить. А значит, в аргументы функции можно подставлять любые выражения. ```python # Здесь аргумент функции print — это число 150 @@ -38,11 +38,11 @@ bonus = 50 print(rate * hours + bonus) # => 200 ``` -Функция `print()` просто получает готовое значение и выводит его на экран. Каким образом это значение было получено — не имеет значения. Именно поэтому вызовы функций отлично сочетаются с любыми выражениями. +Функция `print()` просто получает готовое значение и выводит его на экран. Каким образом это значение было получено — не имеет значения. Именно поэтому вызовы функций отлично сочетаются с любыми выражениями. ## Вызов функции внутри функции -Так как вызов функции сам по себе является выражением, его результат можно сразу передавать другой функции. Это позволяет строить ещё более сложные конструкции. +Так как вызов функции сам по себе является выражением, его результат можно сразу передавать другой функции. Это позволяет строить ещё более сложные конструкции. ```python name = 'python' @@ -52,9 +52,9 @@ name = 'python' print(len(name)) # => 6 ``` -Здесь `len(name)` вычисляется первым и отдаёт результат — число 6. Затем это значение подставляется в вызов `print()`. Такая комбинация может быть сколько угодно глубокой: результат одной функции можно использовать в другой, а потом ещё в следующей. +Здесь `len(name)` вычисляется первым и отдаёт результат — число 6. Затем это значение подставляется в вызов `print()`. Такая комбинация может быть сколько угодно глубокой: результат одной функции можно использовать в другой, а потом ещё в следующей. -Чтобы правильно читать такие конструкции, нужно помнить про порядок вызова: +Чтобы правильно читать такие конструкции, нужно помнить про порядок вызова: 1. Сначала выполняется функция, которая находится «внутри» — в нашем случае это `len(name)`. 2. Затем её результат подставляется на место вызова. 3. После этого выполняется внешняя функция — здесь это `print()`. @@ -71,7 +71,7 @@ print(len(name)) # => 6 ## Использование функций в составе выражений -Функции возвращают значения, а значит их вызовы можно использовать не только как аргументы других функций, но и как часть любых других выражений. +Функции возвращают значения, а значит их вызовы можно использовать не только как аргументы других функций, но и как часть любых других выражений. ```python name = 'python' @@ -87,11 +87,11 @@ double = len(text) * 2 print(double) # => 12 ``` -Здесь вызовы `len(name)` и `len(text)` — это полноценные выражения. Они возвращают значения, которые можно комбинировать с числами, переменными и другими операциями. +Здесь вызовы `len(name)` и `len(text)` — это полноценные выражения. Они возвращают значения, которые можно комбинировать с числами, переменными и другими операциями. ## Совмещение функций и выражений -Мы уже видели, что функции можно использовать как часть выражений и что вызов одной функции можно передавать в другую. Эти идеи легко соединяются. +Мы уже видели, что функции можно использовать как часть выражений и что вызов одной функции можно передавать в другую. Эти идеи легко соединяются. ```python name = 'python' @@ -102,6 +102,6 @@ name = 'python' print(len(name) - 1) # => 5 ``` -Здесь в одном месте соединилось несколько уровней: вызов функции, арифметическая операция и ещё один вызов функции. Именно так в программировании и строятся более сложные конструкции — из комбинаций простых шагов. +Здесь в одном месте соединилось несколько уровней: вызов функции, арифметическая операция и ещё один вызов функции. Именно так в программировании и строятся более сложные конструкции — из комбинаций простых шагов. Эта логика рекурсивна: результат любой операции можно снова использовать как часть нового выражения, и так бесконечно глубоко. Но чем больше вложенных вызовов, тем сложнее читать и понимать код. Поэтому программисты стараются находить баланс между выразительностью и понятностью. diff --git a/modules/35-calling-functions/180-variadic-parameters/ru/README.md b/modules/35-calling-functions/180-variadic-parameters/ru/README.md index 543fcf78..41e435d8 100644 --- a/modules/35-calling-functions/180-variadic-parameters/ru/README.md +++ b/modules/35-calling-functions/180-variadic-parameters/ru/README.md @@ -1,30 +1,30 @@ У некоторых функций есть особенность — они принимают переменное число аргументов. Это не связано со значениями по умолчанию, как в случае с `round()`. Речь идёт о том, что количество передаваемых данных не ограничено фиксированным числом. -Рассмотрим функцию `max()`. Она находит наибольшее значение из переданных данных. +Рассмотрим функцию `max()`. Она находит наибольшее значение из переданных данных. ```python print(max(1, 10, 3)) # => 10 print(max(1, -3, 2, 3, 2)) # => 3 ``` -В документации можно встретить несколько вариантов описания `max()`. Чтобы упростить понимание, сосредоточимся на одном, который нам сейчас нужен: +В документации можно встретить несколько вариантов описания `max()`. Чтобы упростить понимание, сосредоточимся на одном, который нам сейчас нужен: ```python max(arg1, arg2, /, *args, key=None) ``` -Это значит: -- функция требует как минимум два значения (`arg1` и `arg2`); -- дальше можно передавать ещё сколько угодно значений (`*args`); -- функция вернёт наибольшее из переданных. +Это значит: +- функция требует как минимум два значения (`arg1` и `arg2`); +- дальше можно передавать ещё сколько угодно значений (`*args`); +- функция вернёт наибольшее из переданных. -Если среди аргументов есть несколько одинаковых максимальных значений, возвращается первый из них. +Если среди аргументов есть несколько одинаковых максимальных значений, возвращается первый из них. ```python print(max(5, 5, 2)) # => 5 ``` -Аналогично работает функция `min()`, только она ищет наименьшее значение: +Аналогично работает функция `min()`, только она ищет наименьшее значение: ```python print(min(1, 10, 3)) # => 1 diff --git a/modules/35-calling-functions/270-deterministic/ru/README.md b/modules/35-calling-functions/270-deterministic/ru/README.md index 3c9f4ddb..f9f41240 100644 --- a/modules/35-calling-functions/270-deterministic/ru/README.md +++ b/modules/35-calling-functions/270-deterministic/ru/README.md @@ -1,3 +1,5 @@ +![Двое сидят и разговаривают о детерминированной функции](./assets/deterministic.png) + У функций в любом языке программирования есть фундаментальные свойства. Эти свойства помогают понимать, как функция будет вести себя в разных ситуациях, как её тестировать и где применять. Одно из таких свойств — **детерминированность**. **Детерминированная функция** всегда возвращает один и тот же результат при одинаковых входных данных. Например, детерминированной можно назвать функцию, которая считает количество символов: diff --git a/modules/35-calling-functions/270-deterministic/ru/assets/deterministic.png b/modules/35-calling-functions/270-deterministic/ru/assets/deterministic.png new file mode 100644 index 00000000..1a6cf820 Binary files /dev/null and b/modules/35-calling-functions/270-deterministic/ru/assets/deterministic.png differ diff --git a/modules/38-objects/100-objects/ru/README.md b/modules/38-objects/100-objects/ru/README.md index 336f6847..65d3e009 100644 --- a/modules/38-objects/100-objects/ru/README.md +++ b/modules/38-objects/100-objects/ru/README.md @@ -1,10 +1,13 @@ -До этого момента мы работали только с функциями: они получают данные, что-то делают с ними и возвращают результат. Но в Python есть ещё один похожий механизм — **методы**. -Метод — это та же функция, только «привязанная» к конкретному значению определённого типа данных. То есть вместе с самим значением мы получаем набор функций, которые умеют с ним работать. +![Upper](./assets/upper.png) + +До этого момента мы работали только с функциями: они получают данные, что-то делают с ними и возвращают результат. Но в Python есть ещё один похожий механизм — **методы**. + +Метод — это та же функция, только «привязанная» к конкретному значению определённого типа данных. То есть вместе с самим значением мы получаем набор функций, которые умеют с ним работать. ## Методы строк -Например, у строк есть свои методы для преобразования текста. Метод `upper()` переводит все буквы в верхний регистр: +Например, у строк есть свои методы для преобразования текста. Метод `upper()` переводит все буквы в верхний регистр: ```python text = 'hexlet' diff --git a/modules/38-objects/100-objects/ru/assets/upper.png b/modules/38-objects/100-objects/ru/assets/upper.png new file mode 100644 index 00000000..5c810856 Binary files /dev/null and b/modules/38-objects/100-objects/ru/assets/upper.png differ diff --git a/modules/38-objects/200-methods-immutability/ru/README.md b/modules/38-objects/200-methods-immutability/ru/README.md index d8694406..54cada49 100644 --- a/modules/38-objects/200-methods-immutability/ru/README.md +++ b/modules/38-objects/200-methods-immutability/ru/README.md @@ -33,7 +33,7 @@ print(new_text) # => HEXLET text = ' hi ' cleaned = text.strip() print(cleaned) # => hi -print(text) # => hi +print(text) # => hi ``` Метод `strip()` вернул новую строку без пробелов, но сам `text` не изменился. diff --git a/modules/38-objects/500-method-chain/ru/README.md b/modules/38-objects/500-method-chain/ru/README.md index bdc1ae99..78416e0d 100644 --- a/modules/38-objects/500-method-chain/ru/README.md +++ b/modules/38-objects/500-method-chain/ru/README.md @@ -1,3 +1,5 @@ +![Конвейер методов, strip обрезает пробелы, upper - переводит символы в верхний регистр](./assets/methods-chain.png) + Метод — это операция, которая применяется к значению и возвращает новый результат. Если результат снова позволяет вызывать методы, то к нему можно применить ещё один метод. Такой приём называется **цепочка методов (method chaining)**. Вот пример: diff --git a/modules/38-objects/500-method-chain/ru/assets/methods-chain.png b/modules/38-objects/500-method-chain/ru/assets/methods-chain.png new file mode 100644 index 00000000..b2b4c619 Binary files /dev/null and b/modules/38-objects/500-method-chain/ru/assets/methods-chain.png differ diff --git a/modules/40-define-functions/100-define-function/ru/README.md b/modules/40-define-functions/100-define-function/ru/README.md index e1d67306..372ce5f3 100644 --- a/modules/40-define-functions/100-define-function/ru/README.md +++ b/modules/40-define-functions/100-define-function/ru/README.md @@ -1,3 +1,5 @@ +![определение-функции](./assets/define_python.png) + До этого момента мы использовали только уже готовые функции — `print()`, `len()`, `max()` и другие. Но в Python можно создавать свои собственные функции. Это основа программирования: выделение повторяющейся логики в именованные блоки кода. ## Зачем определять функции diff --git a/modules/40-define-functions/100-define-function/ru/assets/define_python.png b/modules/40-define-functions/100-define-function/ru/assets/define_python.png new file mode 100644 index 00000000..e6d38983 Binary files /dev/null and b/modules/40-define-functions/100-define-function/ru/assets/define_python.png differ diff --git a/modules/40-define-functions/200-return/ru/README.md b/modules/40-define-functions/200-return/ru/README.md index dca995cf..8276c659 100644 --- a/modules/40-define-functions/200-return/ru/README.md +++ b/modules/40-define-functions/200-return/ru/README.md @@ -1,3 +1,5 @@ +![Sum-python](./assets/sum-python.jpg) + В этом уроке мы научимся писать функции, которые **возвращают значения**. Такие функции не просто что-то делают, а отвечают на вопрос и отдают результат своей работы — как будто говорят: «Вот, держи, я посчитала». Например, функция может вернуть строку с обработанным текстом или число, вычисленное по формуле. Возвращённое значение можно использовать дальше — сохранить в переменную, передать в другую функцию или вывести на экран. diff --git a/modules/40-define-functions/200-return/ru/assets/sum-python.jpg b/modules/40-define-functions/200-return/ru/assets/sum-python.jpg new file mode 100644 index 00000000..85e8b129 Binary files /dev/null and b/modules/40-define-functions/200-return/ru/assets/sum-python.jpg differ diff --git a/modules/40-define-functions/400-default-parameters/ru/README.md b/modules/40-define-functions/400-default-parameters/ru/README.md index e4f853c0..1b81c498 100644 --- a/modules/40-define-functions/400-default-parameters/ru/README.md +++ b/modules/40-define-functions/400-default-parameters/ru/README.md @@ -1,10 +1,10 @@ -Функции могут принимать параметры. Иногда удобно задать значение сразу в определении функции, чтобы не указывать его при каждом вызове. Такое значение называется **значением по умолчанию**. +Функции могут принимать параметры. Иногда удобно задать значение сразу в определении функции, чтобы не указывать его при каждом вызове. Такое значение называется **значением по умолчанию**. -Если аргумент не передан, используется это значение. Если аргумент указан, то оно заменяет умолчание. +Если аргумент не передан, используется это значение. Если аргумент указан, то оно заменяет умолчание. ## Пример: повторение текста -Сделаем функцию, которая повторяет строку несколько раз. По умолчанию пусть будет один раз, но при желании можно указать другое количество. +Сделаем функцию, которая повторяет строку несколько раз. По умолчанию пусть будет один раз, но при желании можно указать другое количество. ```python def repeat(text, times=1): @@ -14,7 +14,7 @@ print(repeat("Hi")) # => Hi print(repeat("Hi", 3)) # => HiHiHi ``` -В этом примере используется операция умножения строки на число. Она работает так: берётся исходная строка и повторяется указанное количество раз. Например, `"A" * 5` превратится в `"AAAAA"`. Это встроенная возможность Python, которая часто применяется при генерации шаблонов, разделителей и повторяющихся фрагментов текста. +В этом примере используется операция умножения строки на число. Она работает так: берётся исходная строка и повторяется указанное количество раз. Например, `"A" * 5` превратится в `"AAAAA"`. Это встроенная возможность Python, которая часто применяется при генерации шаблонов, разделителей и повторяющихся фрагментов текста. Необязательные параметры всегда указываются в конце списка параметров. Поэтому в примере сначала идёт обязательный параметр `text`, а уже после него — параметр `times` со значением по умолчанию. diff --git a/modules/40-define-functions/500-named-arguments/ru/README.md b/modules/40-define-functions/500-named-arguments/ru/README.md index 50a78ef5..45be8f61 100644 --- a/modules/40-define-functions/500-named-arguments/ru/README.md +++ b/modules/40-define-functions/500-named-arguments/ru/README.md @@ -1,18 +1,18 @@ Функции в Python можно вызывать по`разному. До этого мы передавали значения строго по порядку: первое значение шло в первый параметр, второе — во второй и так далее. Такой способ называется **позиционным вызовом**. -Но в Python есть ещё один вариант — **именованные аргументы**. При вызове функции мы явно указываем имя параметра, которому передаём значение. Он особенно удобен, когда у функции много параметров или не все из них нужно менять — тогда можно указать только нужные по имени, а остальные оставить со значениями по умолчанию. +Но в Python есть ещё один вариант — **именованные аргументы**. При вызове функции мы явно указываем имя параметра, которому передаём значение. Он особенно удобен, когда у функции много параметров или не все из них нужно менять — тогда можно указать только нужные по имени, а остальные оставить со значениями по умолчанию. ```python def repeat(text, times=1): return text * times -repeat("Hi", 3) # позиционный вызов -repeat(text="Hi", times=3) # именованный вызов +repeat("Hi", 3) # позиционный вызов +repeat(text="Hi", times=3) # именованный вызов ``` Оба варианта делают одно и то же. Но во втором случае мы явно написали, что "Hi" — это text, а 3 — это times. С точки зрения определения функции ничего не поменялось, именованные аргументы могут использоваться для любой функции, сама функция об этом ничего не знает. Она получает значения, так как они описаны в определении. -Именованные аргументы можно указывать в любом порядке. Это не меняет результат работы функции, потому что значения связываются именно по имени параметра. +Именованные аргументы можно указывать в любом порядке. Это не меняет результат работы функции, потому что значения связываются именно по имени параметра. ```python repeat(times=3, text="Hi") # => HiHiHi @@ -20,17 +20,17 @@ repeat(times=3, text="Hi") # => HiHiHi ## Когда использовать именованные аргументы -Именованные аргументы полезны, когда у функции есть несколько параметров и не все из них нужно менять. В таких случаях можно указать только те параметры, которые действительно важны в конкретном вызове, а остальные оставить со значениями по умолчанию. +Именованные аргументы полезны, когда у функции есть несколько параметров и не все из них нужно менять. В таких случаях можно указать только те параметры, которые действительно важны в конкретном вызове, а остальные оставить со значениями по умолчанию. ```python def make_line(symbol="-", length=10): return symbol * length -make_line() # все параметры по умолчанию +make_line() # все параметры по умолчанию -make_line(length=5) # меняем только длину +make_line(length=5) # меняем только длину # Без этого пришлось бы писать так make_line("-", 5) ``` -Нам не пришлось указывать явно символ, даже несмотря на то, что он идет в списке параметров раньше длины. Это также делает вызовы функций более понятными для чтения: сразу видно, какое именно значение относится к какому параметру. +Нам не пришлось указывать явно символ, даже несмотря на то, что он идет в списке параметров раньше длины. Это также делает вызовы функций более понятными для чтения: сразу видно, какое именно значение относится к какому параметру. diff --git a/modules/40-define-functions/600-type-annotations/ru/README.md b/modules/40-define-functions/600-type-annotations/ru/README.md index d3bc9135..4f4dc9fa 100644 --- a/modules/40-define-functions/600-type-annotations/ru/README.md +++ b/modules/40-define-functions/600-type-annotations/ru/README.md @@ -1,10 +1,10 @@ -В Python в функцию можно передать любые значения. Иногда это усложняет понимание кода: не всегда ясно, что именно ожидает функция и что она возвращает. +В Python в функцию можно передать любые значения. Иногда это усложняет понимание кода: не всегда ясно, что именно ожидает функция и что она возвращает. -Чтобы сделать код понятнее, в Python есть **аннотации типов**. С их помощью можно явно указать, какие значения принимает функция и какой результат она возвращает. Эти подсказки полезны в редакторах кода: они показывают ожидаемые типы аргументов и помогают быстрее разобраться, как пользоваться функцией. +Чтобы сделать код понятнее, в Python есть **аннотации типов**. С их помощью можно явно указать, какие значения принимает функция и какой результат она возвращает. Эти подсказки полезны в редакторах кода: они показывают ожидаемые типы аргументов и помогают быстрее разобраться, как пользоваться функцией. ## Как указывать типы параметров -Аннотация функции описывает два элемента: +Аннотация функции описывает два элемента: 1. **Типы параметров** — указываются прямо в определении функции после имени каждого параметра через двоеточие. 2. **Тип возвращаемого результата** — указывается после списка параметров с помощью стрелки ``>`. @@ -22,11 +22,11 @@ print(add(2, 3)) # => 5 ## Какие типы используются в аннотациях -На этом этапе достаточно знать аннотации для простых, примитивных типов данных: +На этом этапе достаточно знать аннотации для простых, примитивных типов данных: -* `int` — целые числа -* `float` — числа с плавающей точкой -* `str` — строки +* `int` — целые числа +* `float` — числа с плавающей точкой +* `str` — строки * `bool` — логические значения (True или False) ```python @@ -39,7 +39,7 @@ print(describe("Anna", 25, 1.70)) ## Пример с параметрами по умолчанию -Аннотации работают одинаково как для обязательных параметров, так и для тех, у которых есть значение по умолчанию. Сначала указывается тип, потом через `=` — стандартное значение. +Аннотации работают одинаково как для обязательных параметров, так и для тех, у которых есть значение по умолчанию. Сначала указывается тип, потом через `=` — стандартное значение. ```python def greet(name: str, greeting: str = "Hello") -> str: @@ -49,16 +49,16 @@ print(greet("Anna")) # => Hello, Anna print(greet("Kirill", "Hi")) # => Hi, Kirill ``` -В этом примере `name` — обязательный параметр, а `greeting` имеет значение по умолчанию. Аннотации показывают типы обоих параметров и возвращаемого результата. +В этом примере `name` — обязательный параметр, а `greeting` имеет значение по умолчанию. Аннотации показывают типы обоих параметров и возвращаемого результата. ## Аннотации и проверка кода -Хотя сам Python не проверяет аннотации во время выполнения программы, есть отдельные инструменты, которые умеют это делать. Такой подход называют **статической проверкой кода**. +Хотя сам Python не проверяет аннотации во время выполнения программы, есть отдельные инструменты, которые умеют это делать. Такой подход называют **статической проверкой кода**. -"Статическая" значит, что проверка происходит ещё до запуска программы. Инструмент читает исходный код и сверяет, соответствуют ли переданные значения указанным типам. +"Статическая" значит, что проверка происходит ещё до запуска программы. Инструмент читает исходный код и сверяет, соответствуют ли переданные значения указанным типам. -Например, если функция принимает строку, а вы передадите число, то при статической проверке это будет показано как ошибка. +Например, если функция принимает строку, а вы передадите число, то при статической проверке это будет показано как ошибка. -Особенно удобно, когда такие ошибки подсвечивает редактор прямо во время написания кода. Это позволяет сразу увидеть проблему и исправить её, не дожидаясь запуска программы. Благодаря этому в работающем коде становится меньше неожиданных ошибок — многие из них отлавливаются заранее. +Особенно удобно, когда такие ошибки подсвечивает редактор прямо во время написания кода. Это позволяет сразу увидеть проблему и исправить её, не дожидаясь запуска программы. Благодаря этому в работающем коде становится меньше неожиданных ошибок — многие из них отлавливаются заранее. Аннотации типов не являются обязательными. Функции можно писать и без них — Python всё равно будет работать. Но когда аннотации есть, код становится понятнее для людей и удобнее для редакторов. Нужно ли аннотировать функции в своем коде? Да, это считается хорошей практикой. diff --git a/modules/45-logic/10-bool-type/ru/README.md b/modules/45-logic/10-bool-type/ru/README.md index d27f07ce..c2925fda 100644 --- a/modules/45-logic/10-bool-type/ru/README.md +++ b/modules/45-logic/10-bool-type/ru/README.md @@ -50,7 +50,7 @@ print(is_infant(1)) # => True print(is_infant(0)) # => True ``` -Когда функции возвращают результат сравнения, они обычно отвечают на вопрос «да» или «нет». Такие функции называют **предикатами**. Их легко узнать по тому, что они возвращают логическое значение `True` или `False`. Часто в их названии есть вопрос или утверждение, которое можно проверить (`is', 'has`, `can`). Вот функция, проверяющая, является ли число чётным: +Когда функции возвращают результат сравнения, они обычно отвечают на вопрос «да» или «нет». Такие функции называют **предикатами**. Их легко узнать по тому, что они возвращают логическое значение `True` или `False`. Часто в их названии есть вопрос или утверждение, которое можно проверить (`is', 'has`, `can`). Вот функция, проверяющая, является ли число чётным: ```python def is_negative(number: int) -> bool: diff --git a/modules/45-logic/25-logical-operators/ru/README.md b/modules/45-logic/25-logical-operators/ru/README.md index 16424836..15cacc66 100644 --- a/modules/45-logic/25-logical-operators/ru/README.md +++ b/modules/45-logic/25-logical-operators/ru/README.md @@ -1,3 +1,5 @@ +![even-or-odd](./assets/even-or-odd.jpg) + Мы уже умеем писать функции, которые проверяют одиночные условия. А в этом уроке научимся строить составные условия. Предположим, что сайт при регистрации требует, чтобы пароль был длиннее восьми символов и содержал хотя бы одну заглавную букву. Попробуем написать два отдельных логических выражения и соединим их специальным оператором «И»: diff --git a/modules/45-logic/25-logical-operators/ru/assets/even-or-odd.jpg b/modules/45-logic/25-logical-operators/ru/assets/even-or-odd.jpg new file mode 100644 index 00000000..6c3197c8 Binary files /dev/null and b/modules/45-logic/25-logical-operators/ru/assets/even-or-odd.jpg differ diff --git a/modules/48-conditionals/30-if/ru/README.md b/modules/48-conditionals/30-if/ru/README.md index 63c07689..8af8c57e 100644 --- a/modules/48-conditionals/30-if/ru/README.md +++ b/modules/48-conditionals/30-if/ru/README.md @@ -1,3 +1,5 @@ +![Условная конструкция if](./assets/if-statement.png) + Логические выражения позволяют проверять разные условия. Но сами по себе они ничего не делают — только возвращают `True` или `False`. Чтобы программа могла выполнять разные действия в зависимости от результата, в Python есть специальная конструкция `if`. ```python @@ -19,7 +21,7 @@ if 10 == 10: print("Goodbye!") ``` -Здесь напечатаются `"First"` и `"Second"`, потому что условие выполнилось. А `"Goodbye!"` напечатается в любом случае, так как она уже за пределами блока. +Здесь напечатаются `"First"` и `"Second"`, потому что условие выполнилось. А `"Goodbye!"` напечатается в любом случае, так как она уже за пределами блока. ## Использование if внутри функции @@ -36,14 +38,14 @@ print(get_type_of_sentence('Hodor')) # => normal print(get_type_of_sentence('Hodor?')) # => question ``` -Здесь используется сразу два `return`. Работа функции устроена так: +Здесь используется сразу два `return`. Работа функции устроена так: -* если условие внутри `if` выполняется, срабатывает `return 'question'` и функция завершается; -* если условие не выполняется, управление переходит на следующую строку — `return 'normal'`. +* если условие внутри `if` выполняется, срабатывает `return 'question'` и функция завершается; +* если условие не выполняется, управление переходит на следующую строку — `return 'normal'`. Таким образом, у функции есть несколько возможных точек выхода. Это частая практика: в зависимости от условий функция может завершаться по-разному. -Несмотря на то что функция `get_type_of_sentence` использует `if`, она не является предикатом — она возвращает строки. А вот пример предиката: функция, которая проверяет, достаточно ли денег для покупки. Она возвращает логическое значение в зависимости от условия. +Несмотря на то что функция `get_type_of_sentence` использует `if`, она не является предикатом — она возвращает строки. А вот пример предиката: функция, которая проверяет, достаточно ли денег для покупки. Она возвращает логическое значение в зависимости от условия. ```python def has_enough_money(balance: int, price: int) -> bool: @@ -55,16 +57,15 @@ print(has_enough_money(100, 50)) # => True print(has_enough_money(30, 50)) # => False ``` -Здесь используется `if`, и результатом работы функции всегда будет `True` или `False`. +Здесь используется `if`, и результатом работы функции всегда будет `True` или `False`. ## if и логические выражения -Функцию `has_enough_money` мы написали через `if`. Но в таком виде она могла бы обойтись и без него, потому что результат сравнения сам по себе уже является логическим выражением. +Функцию `has_enough_money` мы написали через `if`. Но в таком виде она могла бы обойтись и без него, потому что результат сравнения сам по себе уже является логическим выражением. ```python def has_enough_money(balance: int, price: int) -> bool: return balance >= price ``` -В простых случаях лучше сразу возвращать такое выражение. `if` нужен там, где внутри блока выполняются дополнительные действия, а не только возврат результата. Чем более сложные программы мы будем писать, тем чаще такие ситуации начнут встречаться. - +В простых случаях лучше сразу возвращать такое выражение. `if` нужен там, где внутри блока выполняются дополнительные действия, а не только возврат результата. Чем более сложные программы мы будем писать, тем чаще такие ситуации начнут встречаться. diff --git a/modules/48-conditionals/30-if/ru/assets/if-statement.png b/modules/48-conditionals/30-if/ru/assets/if-statement.png new file mode 100644 index 00000000..713c6a37 Binary files /dev/null and b/modules/48-conditionals/30-if/ru/assets/if-statement.png differ diff --git a/modules/48-conditionals/30-if/ru/assets/ternary.png b/modules/48-conditionals/30-if/ru/assets/ternary.png new file mode 100644 index 00000000..146d4e31 Binary files /dev/null and b/modules/48-conditionals/30-if/ru/assets/ternary.png differ diff --git a/modules/48-conditionals/40-if-else/ru/README.md b/modules/48-conditionals/40-if-else/ru/README.md index ca13b948..3f5c4086 100644 --- a/modules/48-conditionals/40-if-else/ru/README.md +++ b/modules/48-conditionals/40-if-else/ru/README.md @@ -34,7 +34,7 @@ else: Оформить конструкцию `if-else` можно двумя способами. С помощью отрицания можно изменить порядок блоков: ```python -def get_type_of_sentence(sentence): +def get_type_of_sentence(sentence: str) -> str: last_char = sentence[-1] if last_char != '?': @@ -68,7 +68,7 @@ check_number(3) ```python # Правильно -def check_number(number): +def check_number(number: int) -> None: if number > 0: print("Число положительное") if number > 10: diff --git a/modules/48-conditionals/50-else-if/ru/README.md b/modules/48-conditionals/50-else-if/ru/README.md index c520c125..c20e8353 100644 --- a/modules/48-conditionals/50-else-if/ru/README.md +++ b/modules/48-conditionals/50-else-if/ru/README.md @@ -27,7 +27,7 @@ print(get_type_of_sentence('No!')) # => 'Sentence is exclamation' Чтобы исправить ситуацию, воспользуемся еще одной возможностью условной конструкции: ```python -def get_type_of_sentence(sentence): +def get_type_of_sentence(sentence: str) -> str: last_char = sentence[-1] if last_char == '?': diff --git a/modules/48-conditionals/60-ternary-operator/ru/README.md b/modules/48-conditionals/60-ternary-operator/ru/README.md index ae15c859..18ed13bc 100644 --- a/modules/48-conditionals/60-ternary-operator/ru/README.md +++ b/modules/48-conditionals/60-ternary-operator/ru/README.md @@ -1,7 +1,7 @@ Посмотрите на определение функции, которая возвращает модуль переданного числа: ```python -def abs(number): +def abs(number: int) -> int: if number >= 0: return number return -number @@ -10,18 +10,20 @@ def abs(number): Но можно записать более лаконично. Для этого справа от `return` должно быть выражение, но `if` — это инструкция, а не выражение. В Python есть конструкция, которая работает как `if-else`, но считается выражением. Она называется **тернарный оператор** — единственный оператор в Python, который требует три операнда: ```python -def abs(number): +def abs(number: int) -> int: return number if number >= 0 else -number ``` Общий паттерн выглядит так: ` if else `. +![Тернарный оператор](./assets/ternary.png) + Давайте перепишем начальный вариант `get_type_of_sentence()` аналогично. Было: ```python -def get_type_of_sentence(sentence): +def get_type_of_sentence(sentence: str) -> str: last_char = sentence[-1] if last_char == '?': return 'question' @@ -31,7 +33,7 @@ def get_type_of_sentence(sentence): Стало: ```python -def get_type_of_sentence(sentence): +def get_type_of_sentence(sentence: str) -> str: last_char = sentence[-1] return 'question' if last_char == '?' else 'normal' diff --git a/modules/48-conditionals/60-ternary-operator/ru/assets/if-statement.png b/modules/48-conditionals/60-ternary-operator/ru/assets/if-statement.png new file mode 100644 index 00000000..713c6a37 Binary files /dev/null and b/modules/48-conditionals/60-ternary-operator/ru/assets/if-statement.png differ diff --git a/modules/48-conditionals/60-ternary-operator/ru/assets/ternary.png b/modules/48-conditionals/60-ternary-operator/ru/assets/ternary.png new file mode 100644 index 00000000..146d4e31 Binary files /dev/null and b/modules/48-conditionals/60-ternary-operator/ru/assets/ternary.png differ diff --git a/modules/50-loops/10-while/ru/README.md b/modules/50-loops/10-while/ru/README.md index e9a74f1f..afc369ac 100644 --- a/modules/50-loops/10-while/ru/README.md +++ b/modules/50-loops/10-while/ru/README.md @@ -1,12 +1,14 @@ +![Цикл while](./assets/while.png) + # Циклы в программировании -Во многих задачах нужно выполнять одни и те же действия несколько раз. Например, искать в книге нужную фразу: страницу за страницей, пока не найдём совпадение. Сколько раз придётся повторить поиск, заранее неизвестно, но шаг всегда одинаковый — открыть страницу и проверить её. +Во многих задачах нужно выполнять одни и те же действия несколько раз. Например, искать в книге нужную фразу: страницу за страницей, пока не найдём совпадение. Сколько раз придётся повторить поиск, заранее неизвестно, но шаг всегда одинаковый — открыть страницу и проверить её. В программировании такие повторения описываются с помощью **циклов**. Они позволяют записать один раз действие, которое будет выполняться снова и снова, пока выполняется условие. ## Первый пример -Начнём с самой простой задачи. Пусть нужно несколько раз вывести одну и ту же строку `"Hello!"`. Без цикла это пришлось бы делать вручную, повторяя вызовы `print()`. С циклом это выглядит так: +Начнём с самой простой задачи. Пусть нужно несколько раз вывести одну и ту же строку `"Hello!"`. Без цикла это пришлось бы делать вручную, повторяя вызовы `print()`. С циклом это выглядит так: ```python counter = 0 @@ -18,32 +20,32 @@ while counter < 2: # => Hello! ``` -Конструкция `while` задаёт повторение. Её синтаксис состоит из трёх частей: +Конструкция `while` задаёт повторение. Её синтаксис состоит из трёх частей: -* ключевое слово `while` -* условие (предикат), стоящее после `while` и проверяемое на каждой итерации -* блок кода — тело цикла, которое выполняется, пока условие истинно +* ключевое слово `while` +* условие (предикат), стоящее после `while` и проверяемое на каждой итерации +* блок кода — тело цикла, которое выполняется, пока условие истинно -Условие после `while` проверяется перед каждой итерацией. Если оно истинно (`True`), выполняется тело цикла — все строки кода с отступом. Когда выполнение тела завершается, интерпретатор возвращается обратно к проверке условия. Если условие остаётся истинным, цикл повторяется снова. Как только условие становится ложным (`False`), цикл останавливается, и программа продолжает работу со строк, которые идут дальше за циклом. +Условие после `while` проверяется перед каждой итерацией. Если оно истинно (`True`), выполняется тело цикла — все строки кода с отступом. Когда выполнение тела завершается, интерпретатор возвращается обратно к проверке условия. Если условие остаётся истинным, цикл повторяется снова. Как только условие становится ложным (`False`), цикл останавливается, и программа продолжает работу со строк, которые идут дальше за циклом. -В примере используется переменная `counter`. Она играет роль **счётчика цикла**: +В примере используется переменная `counter`. Она играет роль **счётчика цикла**: -1. сначала ей задаётся начальное значение (`counter = 0`), -2. на каждой итерации значение увеличивается (`counter = counter + 1`), -3. проверка `counter < 2` определяет, нужно ли продолжать цикл. +1. сначала ей задаётся начальное значение (`counter = 0`), +2. на каждой итерации значение увеличивается (`counter = counter + 1`), +3. проверка `counter < 2` определяет, нужно ли продолжать цикл. -Без изменения счётчика условие никогда не станет ложным, и цикл превратится в бесконечный. +Без изменения счётчика условие никогда не станет ложным, и цикл превратится в бесконечный. ## Работа цикла по шагам Старт: `counter = 0` -**Шаг 1.** Проверка условия `counter < 2`: подставляем `0 < 2` → истина. Заходим в тело цикла. -Выполняется `print("Hello!")` → на экран выводится `Hello!`. +**Шаг 1.** Проверка условия `counter < 2`: подставляем `0 < 2` → истина. Заходим в тело цикла. +Выполняется `print("Hello!")` → на экран выводится `Hello!`. `counter = counter + 1` меняет значение: было `0`, стало `1`. -**Шаг 2.** Возврат к проверке условия `counter < 2`: теперь `1 < 2` → истина. Снова тело цикла. -`print("Hello!")` → выводится `Hello!`. +**Шаг 2.** Возврат к проверке условия `counter < 2`: теперь `1 < 2` → истина. Снова тело цикла. +`print("Hello!")` → выводится `Hello!`. `counter = counter + 1`: было `1`, стало `2`. **Шаг 3.** Снова проверка `counter < 2`: теперь `2 < 2` → ложь. Цикл прекращается, управление переходит к следующей инструкции после цикла. @@ -52,8 +54,8 @@ while counter < 2: ## Отступы и продолжение программы -У цикла есть тело — это все строки кода, которые имеют одинаковый отступ после строки с `while`. -Как только отступ заканчивается, значит, закончился и цикл. +У цикла есть тело — это все строки кода, которые имеют одинаковый отступ после строки с `while`. +Как только отступ заканчивается, значит, закончился и цикл. ```python counter = 0 @@ -64,16 +66,16 @@ while counter < 2: print("End of loop") ``` -В этом примере строки с `print("Hello!")` и `counter = counter + 1` относятся к циклу, потому что у них есть отступ. А строка `print("End of loop")` уже без отступа — она выполнится один раз, когда цикл завершится. +В этом примере строки с `print("Hello!")` и `counter = counter + 1` относятся к циклу, потому что у них есть отступ. А строка `print("End of loop")` уже без отступа — она выполнится один раз, когда цикл завершится. -Таким образом, отступы показывают, какие строки относятся к циклу, а какие выполняются потом. +Таким образом, отступы показывают, какие строки относятся к циклу, а какие выполняются потом. ## Цикл внутри функции -Напишем функцию, которая печатает числа от 1 до заданного аргумента: +Напишем функцию, которая печатает числа от 1 до заданного аргумента: ```python -def print_numbers(n): +def print_numbers(n: int) -> None: i = 1 while i <= n: print(i) diff --git a/modules/50-loops/10-while/ru/assets/while.png b/modules/50-loops/10-while/ru/assets/while.png new file mode 100644 index 00000000..0d10f271 Binary files /dev/null and b/modules/50-loops/10-while/ru/assets/while.png differ diff --git a/modules/50-loops/20-aggregation-numbers/ru/README.md b/modules/50-loops/20-aggregation-numbers/ru/README.md index fdad2b1e..f7ffe382 100644 --- a/modules/50-loops/20-aggregation-numbers/ru/README.md +++ b/modules/50-loops/20-aggregation-numbers/ru/README.md @@ -1,3 +1,5 @@ +![Итерации цикла](./assets/iterations.png) + Отдельный класс задач, который не обходится без циклов, называется **агрегированием данных**. К таким задачам относятся: поиск максимального или минимального значения, суммы, среднего арифметического. В их случае результат зависит от всего набора данных. В этом уроке разберем, как агрегация применяется к числам и строкам. Допустим, нам нужно найти сумму набора чисел. Реализуем функцию, которая складывает числа в указанном диапазоне, включая границы. **Диапазон** — ряд чисел от конкретного начала до определенного конца. Например, диапазон [1, 10] включает целые числа от одного до десяти. @@ -17,7 +19,7 @@ sum_numbers_from_range(100, 100) # 100 Чтобы реализовать такой код, понадобится цикл, так как сложение чисел — это итеративный процесс, то есть повторяется для каждого числа. Количество итераций зависит от размера диапазона. Вот код этой функции: ```python -def sum_numbers_from_range(start, finish): +def sum_numbers_from_range(start: int, finish: int) -> int: # Технически можно менять start # Но входные аргументы нужно оставлять в исходном значении # Это сделает код проще для анализа diff --git a/modules/50-loops/20-aggregation-numbers/ru/assets/iterations.png b/modules/50-loops/20-aggregation-numbers/ru/assets/iterations.png new file mode 100644 index 00000000..c768d5a6 Binary files /dev/null and b/modules/50-loops/20-aggregation-numbers/ru/assets/iterations.png differ diff --git a/modules/50-loops/23-aggregation-strings/ru/README.md b/modules/50-loops/23-aggregation-strings/ru/README.md index 107f73d0..33353214 100644 --- a/modules/50-loops/23-aggregation-strings/ru/README.md +++ b/modules/50-loops/23-aggregation-strings/ru/README.md @@ -9,7 +9,7 @@ repeat('hexlet', 3) # 'hexlethexlethexlet' Принцип работы этой функции — в цикле происходит «наращивание» строки указанное количество раз: ```python -def repeat(text, times): +def repeat(text: str, times: int) -> str: # Нейтральный элемент для строк — пустая строка result = '' i = 1 @@ -37,7 +37,7 @@ result = result + 'hexlet' # hexlethexlethexlet Чтобы наращивание работало, нужно стартовое значение. Для строк таким значением является **пустая строка** `''`. -Она называется нейтральным элементом, потому что при конкатенации ничего не меняет: +Она называется нейтральным элементом, потому что при конкатенации ничего не меняет: ```python print('' + 'abc') # => abc diff --git a/modules/50-loops/25-iteration-over-string/ru/README.md b/modules/50-loops/25-iteration-over-string/ru/README.md index 9ef65943..e4d3cff4 100644 --- a/modules/50-loops/25-iteration-over-string/ru/README.md +++ b/modules/50-loops/25-iteration-over-string/ru/README.md @@ -3,7 +3,7 @@ Ниже пример кода, который печатает буквы каждого слова на отдельной строке: ```python -def print_name_by_symbol(name): +def print_name_by_symbol(name: str) -> None: i = 0 # Такая проверка будет выполняться до конца строки, # включая последний символ. Его индекс `length - 1`. @@ -24,10 +24,10 @@ print_name_by_symbol(name) ## Переворот строки -Вместо печати можно собирать новую строку. Например, напишем функцию, которая переворачивает строку: +Вместо печати можно собирать новую строку. Например, напишем функцию, которая переворачивает строку: ```python -def reverse_string(text): +def reverse_string(text: str) -> None: result = '' i = len(text) - 1 while i >= 0: @@ -41,9 +41,9 @@ print(reverse_string('hexlet')) # => telxeh Здесь: -* переменная `result` инициализируется пустой строкой — нейтральным элементом для конкатенации; -* цикл начинается с последнего индекса (`len(text) - 1`) и двигается к нулю; -* на каждом шаге к результату добавляется текущий символ; -* когда индекс становится меньше нуля, цикл завершается. +* переменная `result` инициализируется пустой строкой — нейтральным элементом для конкатенации; +* цикл начинается с последнего индекса (`len(text) - 1`) и двигается к нулю; +* на каждом шаге к результату добавляется текущий символ; +* когда индекс становится меньше нуля, цикл завершается. В итоге строка строится в обратном порядке. diff --git a/modules/50-loops/26-conditions-inside-loops/ru/README.md b/modules/50-loops/26-conditions-inside-loops/ru/README.md index e7eff32e..4690956f 100644 --- a/modules/50-loops/26-conditions-inside-loops/ru/README.md +++ b/modules/50-loops/26-conditions-inside-loops/ru/README.md @@ -1,3 +1,5 @@ +![Условия внутри цикла](./assets/conditions-inside-loops.png) + В теле цикла, как и в теле функции, можно выполнять инструкции. Поэтому внутри цикла можно использовать всё изученное ранее, например — условные конструкции. Представьте функцию, которая считает, сколько раз входит буква в предложение. Пример ее работы: @@ -14,7 +16,7 @@ count_chars('Sansa', 'y') # 0 * Какой будет проверка на вхождение символа? ```python -def count_chars(string, char): +def count_chars(string: str, char: int) -> int: index = 0 count = 0 while index < len(string): diff --git a/modules/50-loops/26-conditions-inside-loops/ru/assets/conditions-inside-loops.png b/modules/50-loops/26-conditions-inside-loops/ru/assets/conditions-inside-loops.png new file mode 100644 index 00000000..e016c272 Binary files /dev/null and b/modules/50-loops/26-conditions-inside-loops/ru/assets/conditions-inside-loops.png differ diff --git a/modules/50-loops/26-conditions-inside-loops/ru/assets/edge-cases.png b/modules/50-loops/26-conditions-inside-loops/ru/assets/edge-cases.png new file mode 100644 index 00000000..107d2713 Binary files /dev/null and b/modules/50-loops/26-conditions-inside-loops/ru/assets/edge-cases.png differ diff --git a/modules/50-loops/30-syntactic-sugar/ru/README.md b/modules/50-loops/30-syntactic-sugar/ru/README.md index 5d0cdaf9..22a2c35c 100644 --- a/modules/50-loops/30-syntactic-sugar/ru/README.md +++ b/modules/50-loops/30-syntactic-sugar/ru/README.md @@ -35,12 +35,12 @@ text += " World" # то же самое, что text = text + " World" Существует сокращённая форма почти для всех операторов: -- `+=` для сложения -- `-=` для вычитания -- `*=` для умножения -- `/=` для деления -- `//=` для целочисленного деления -- `%=` для остатка от деления -- `**=` для возведения в степень +- `+=` для сложения +- `-=` для вычитания +- `*=` для умножения +- `/=` для деления +- `//=` для целочисленного деления +- `%=` для остатка от деления +- `**=` для возведения в степень Все они работают по одному принципу: берут текущее значение переменной, применяют операцию и сохраняют результат в ту же переменную. diff --git a/modules/50-loops/55-return-from-loops/ru/README.md b/modules/50-loops/55-return-from-loops/ru/README.md index dee7934e..02b210e5 100644 --- a/modules/50-loops/55-return-from-loops/ru/README.md +++ b/modules/50-loops/55-return-from-loops/ru/README.md @@ -17,7 +17,7 @@ В этом случае достаточно проверять числа не до `x - 1`, а до половины числа. Например, 11 не делится на 2, 3, 4, 5. Но и дальше не будет делиться на числа больше своей половины. Значит, можно оптимизировать алгоритм и проверять деление только до `x / 2`: ```python -def is_prime(number): +def is_prime(number: int) -> bool: if number < 2: return False