Функции в программировании
Функция в программировании представляет собой обособленный участок кода, который можно вызывать, обратившись к нему по имени, которым он был назван. При вызове происходит выполнение команд тела функции.
Функции можно сравнить с небольшими программками, которые сами по себе, то есть автономно, не исполняются, а встраиваются в обычную программу. Нередко их так и называют – подпрограммы. Других ключевых отличий функций от программ нет. Функции также при необходимости могут получать и возвращать данные. Только обычно они их получают не с ввода (клавиатуры, файла и др.), а из вызывающей программы. Сюда же они возвращают результат своей работы.
Существует множество встроенных в язык программирования функций. С некоторыми такими в Python мы уже сталкивались. Это print() , input() , int() , float() , str() , type() . Код их тела нам не виден, он где-то «спрятан внутри языка». Нам же предоставляется только интерфейс – имя функции.
С другой стороны, программист всегда может определять свои функции. Их называют пользовательскими. В данном случае под «пользователем» понимают программиста, а не того, кто пользует программу. Разберемся, зачем нам эти функции, и как их создавать.
Предположим, надо три раза подряд запрашивать на ввод пару чисел и складывать их. С этой целью можно использовать цикл:
i = 0 while i 3: a = int(input()) b = int(input()) print(a + b) i += 1
Однако, что если перед каждым запросом чисел, надо выводить надпись, зачем они нужны, и каждый раз эта надпись разная. Мы не можем прервать цикл, а затем вернуться к тому же циклу обратно. Придется отказаться от него, и тогда получится длинный код, содержащий в разных местах одинаковые участки:
print("Сколько бананов и ананасов для обезьян?") a = int(input()) b = int(input()) print("Всего", a + b, "шт.") print("Сколько жуков и червей для ежей?") a = int(input()) b = int(input()) print("Всего", a + b, "шт.") print("Сколько рыб и моллюсков для выдр?") a = int(input()) b = int(input()) print("Всего", a + b, "шт.")
Пример исполнения программы:
Сколько бананов и ананасов для обезьян? 15 5 Всего 20 шт. Сколько жуков и червей для ежей? 50 12 Всего 62 шт. Сколько рыб и моллюсков для выдр? 16 8 Всего 24 шт.
Внедрение функций позволяет решить проблему дублирования кода в разных местах программы. Благодаря им можно исполнять один и тот же участок кода не сразу, а только тогда, когда он понадобится.
Определение функции. Оператор def
В языке программирования Python функции определяются с помощью оператора def . Рассмотрим код:
def count_food(): a = int(input()) b = int(input()) print("Всего", a + b, "шт.")
Это пример определения функции. Как и другие сложные инструкции вроде условного оператора и циклов функция состоит из заголовка и тела. Заголовок оканчивается двоеточием и переходом на новую строку. Тело имеет отступ.
Ключевое слово def сообщает интерпретатору, что перед ним определение функции. За def следует имя функции. Оно может быть любым, также как и всякий идентификатор, например, переменная. В программировании весьма желательно давать всему осмысленные имена. Так в данном случае функция названа «посчитать_еду» в переводе на русский.
После имени функции ставятся скобки. В приведенном примере они пустые. Это значит, что функция не принимает никакие данные из вызывающей ее программы. Однако она могла бы их принимать, и тогда в скобках были бы указаны так называемые параметры.
После двоеточия следует тело, содержащее инструкции, которые выполняются при вызове функции. Следует различать определение функции и ее вызов. В программном коде они не рядом и не вместе. Можно определить функцию, но ни разу ее не вызвать. Нельзя вызвать функцию, которая не была определена. Определив функцию, но ни разу не вызвав ее, вы никогда не выполните ее тела.
Вызов функции
Рассмотрим полную версию программы с функцией:
def count_food(): a = int(input()) b = int(input()) print("Всего", a+b, "шт.") print("Сколько бананов и ананасов для обезьян?") count_food() print("Сколько жуков и червей для ежей?") count_food() print("Сколько рыб и моллюсков для выдр?") count_food()
После вывода на экран каждого информационного сообщения осуществляется вызов функции, который выглядит просто как упоминание ее имени со скобками. Поскольку в функцию мы ничего не передаем скобки опять же пустые. В приведенном коде функция вызывается три раза.
Когда функция вызывается, поток выполнения программы переходит к ее определению и начинает исполнять ее тело. После того, как тело функции исполнено, поток выполнения возвращается в основной код в то место, где функция вызывалась. Далее исполняется следующее за вызовом выражение.
В языке Python определение функции должно предшествовать ее вызовам. Это связано с тем, что интерпретатор читает код строка за строкой и о том, что находится ниже по течению, ему еще неизвестно. Поэтому если вызов функции предшествует ее определению, то возникает ошибка (выбрасывается исключение NameError ):
print("Сколько бананов и ананасов для обезьян?") count_food() print("Сколько жуков и червей для ежей?") count_food() print("Сколько рыб и моллюсков для выдр?") count_food() def count_food(): a = int(input()) b = int(input()) print("Всего", a + b, "шт.")
Сколько бананов и ананасов для обезьян? Traceback (most recent call last): File "test.py", line 2, in count_food() NameError: name 'count_food' is not defined
Для многих компилируемых языков это не обязательное условие. Там можно определять и вызывать функцию в произвольных местах программы. Однако для удобочитаемости кода программисты даже в этом случае предпочитают соблюдать определенные правила.
Функции придают программе структуру
Польза функций не только в возможности многократного вызова одного и того же кода из разных мест программы. Не менее важно, что благодаря им программа обретает истинную структуру. Функции как бы разделяют ее на обособленные части, каждая из которых выполняет свою конкретную задачу.
Пусть надо написать программу, вычисляющую площади разных фигур. Пользователь указывает, площадь какой фигуры он хочет вычислить. После этого вводит исходные данные. Например, длину и ширину в случае прямоугольника. Чтобы разделить поток выполнения на несколько ветвей, следует использовать оператор if-elif-else:
figure = input("1-прямоугольник, 2-треугольник, 3-круг: ") if figure == '1': a = float(input("Ширина: ")) b = float(input("Высота: ")) print("Площадь: %.2f" % (a * b)) elif figure == '2': a = float(input("Основание: ")) h = float(input("Высота: ")) print("Площадь: %.2f" % (0.5 * a * h)) elif figure == '3': r = float(input("Радиус: ")) print("Площадь: %.2f" % (3.14 * r ** 2)) else: print("Ошибка ввода")
Здесь нет никаких функций, и все прекрасно. Но напишем вариант с функциями:
def rectangle(): a = float(input("Ширина: ")) b = float(input("Высота: ")) print("Площадь: %.2f" % (a * b)) def triangle(): a = float(input("Основание: ")) h = float(input("Высота: ")) print("Площадь: %.2f" % (0.5 * a * h)) def circle(): r = float(input("Радиус: ")) print("Площадь: %.2f" % (3.14 * r ** 2)) figure = input("1-прямоугольник, 2-треугольник, 3-круг: ") if figure == '1': rectangle() elif figure == '2': triangle() elif figure == '3': circle() else: print("Ошибка ввода")
Он кажется сложнее, а каждая из трех функций вызывается всего один раз. Однако из общей логики программы как бы убраны и обособлены инструкции для нахождения площадей. Программа теперь состоит из отдельных «кирпичиков Лего». В основной ветке мы можем комбинировать их как угодно. Она играет роль управляющего механизма.
Если нам когда-нибудь захочется вычислять площадь треугольника по формуле Герона, а не через высоту, то не придется искать код во всей программе (представьте, что она состоит из тысяч строк кода как реальные программы). Мы пойдем к месту определения функций и изменим тело одной из них.
Если понадобиться использовать эти функции в какой-нибудь другой программе, то мы сможем импортировать их туда, сославшись на данный файл с кодом (как это делается в Python, будет рассмотрено позже).
Практическая работа
В программировании можно из одной функции вызывать другую. Для иллюстрации этой возможности напишите программу по следующему описанию.
Основная ветка программы, не считая заголовков функций, состоит из одной строки кода. Это вызов функции test() . В ней запрашивается на ввод целое число. Если оно положительное, то вызывается функция positive() , тело которой содержит команду вывода на экран слова «Положительное». Если число отрицательное, то вызывается функция negative() , ее тело содержит выражение вывода на экран слова «Отрицательное».
Понятно, что вызов test() должен следовать после определения функций. Однако имеет ли значение порядок определения самих функций? То есть должны ли определения positive() и negative() предшествовать test() или могут следовать после него? Проверьте вашу гипотезу, поменяв объявления функций местами. Попробуйте объяснить результат.
Примеры решения и дополнительные уроки в pdf-версии курса
X Скрыть Наверх
Python. Введение в программирование
Ветвление. Условный оператор
Ход выполнения программы может быть линейным, то есть таким, когда выражения выполняются друг за другом, начиная с первого и заканчивая последним. Ни одна строка кода программы не пропускается.
Однако чаще в программах бывает не так. При выполнении кода, в зависимости от тех или иных условий, некоторые его участки могут быть опущены, в то время как другие – выполнены. Иными словами, в программе может присутствовать ветвление, которое реализуется условным оператором – особой конструкцией языка программирования.
Проведем аналогию с реальностью. Человек живет по расписанию. Можно сказать, расписание – это алгоритм для человека, его программный код, подлежащий выполнению. В расписании на 18.00 стоит поход в бассейн. Однако экземпляр биоробота класса Homo sapiens через свои рецепторы-сенсоры получает информацию, что воду из бассейна слили. Разумно было бы отменить занятие по плаванию, то есть изменить ход выполнения программы-расписания. Одним из условий посещения бассейна должно быть его функционирование, иначе должны выполняться другие действия.
Подобная нелинейность действий может быть реализована в компьютерной программе. Например, часть кода будет выполняться лишь при определенном значении конкретной переменной. В языках программирования используется приблизительно такая конструкция условного оператора:
if логическое_выражение
Перевести на человеческий язык можно так: если логическое выражение возвращает истину, то выполняются выражения внутри фигурных скобок; если логическое выражение возвращает ложь, то код внутри фигурных скобок не выполняется. С английского «if» переводится как «если».
Конструкция if логическое_выражение называется заголовком условного оператора. Выражения внутри фигурных скобок – телом условного оператора. Тело может содержать как множество выражений, так и всего одно.
Пример использования условного оператора в языке программирования Python:
if n 100: a = a + b
В Питоне вместо фигурных скобок используется двоеточие. Обособление вложенного кода, то есть тела оператора, достигается за счет отступов. В программировании принято делать отступ равным четырем пробелам. Можно использовать клавишу табуляции ( Tab ) на клавиатуре.
Большинство сред программирования автоматически создают отступ, как только вы поставите двоеточие и перейдете на новую строку. Однако при работе в интерактивном режиме отступы надо добавлять вручную.
Нахождение в теле условного оператора здесь обозначается тремя точками. При создании файла со скриптом таких точек быть не должно, как и приглашения >>> .
Python считается языком с ясным синтаксисом и легко читаемым кодом. Это достигается сведением к минимуму таких вспомогательных элементов как различные скобки и точка с запятой. Для разделения выражений используется переход на новую строку, а для обозначения вложенных выражений – отступы от начала строки. В других языках данный стиль программирования также используется, но лишь для удобочитаемости кода человеком. В Питоне же такой стиль возведен в ранг синтаксического правила.
Данный пример вырван из контекста и сам по-себе не является рабочим. Полная версия программы могла бы выглядеть так:
a = 50 b = 10 n = 98 if n 100: a = a + b print(a)
Последняя строчка кода print(a) уже не относится к условному оператору, что обозначено отсутствием перед ней отступа. Она не является вложенной в условный оператор, значит, не принадлежит ему.
Поскольку переменная n равна 98, а это меньше 100, то a станет равной 60. Это значение будет выведено на экран. Если переменная n изначально была бы связана, например, со значением 101, то на экран было бы выведено 50. Потому что при n , равной 101, логическое выражение в заголовке условного оператора вернуло бы ложь. Значит, тело не было бы выполнено, и переменная a не изменилась бы.
Структуру программы можно изобразить следующим образом:
Основная ветка программы выполняется всегда, а вложенный код лишь тогда, когда в темно-зеленой строчке, обозначающей заголовок условного оператора, случается истина.
Для небольших программ иногда чертят так называемые блок-схемы, отражающие алгоритм выполнения. В языке блок-схем различные части кода обозначаются своими фигурами. Так блоку последовательно выполняемых действий соответствует прямоугольник, ветвлению – ромб. Для кода выше блок-схема может выглядеть так:
Условный оператор может включать не одну ветку, а две, реализуя тем самым полноценное ветвление.
В случае возврата логическим выражением False поток выполнения программы не возвращается сразу в основную ветку. На случай False существует другой вложенный код, отличный от случая True . Другими словами, встретившись с расширенной версией условного оператора, поток выполнения программы не вернется в основную ветку, не выполнив хоть какой-нибудь вложенный код.
В языках программирования разделение на две ветви достигается с помощью добавления блока else, получается так называемое if–else (если-иначе). Синтаксис выглядит примерно так:
if логическое_выражение < выражение 1; выражение 2; … >else
Если условие при инструкции if оказывается ложным, то выполняется блок кода при инструкции else . Ситуация, при которой бы выполнились обе ветви, невозможна. Либо код, принадлежащий if , либо код, принадлежащий еlse . Никак иначе. В заголовке else никогда не бывает логического выражения.
Пример программы с веткой else на языке Python:
tovar1 = 50 tovar2 = 32 if tovar1 + tovar2 > 99: print("99 рублей недостаточно") else: print("Чек оплачен")
Следует иметь в виду, что логическое выражение при if может выглядеть нестандартно, то есть не так просто, как a > b и тому подобное. Там может стоять просто одна переменная, число, слово True или False , а также сложное логическое выражение, когда два простых соединяются через логически and или or .
a = ? if a: a = 1
Если вместо знака вопроса будет стоять 0, то с логической точки зрения это False , значит выражение в if не будет выполнено. Если a будет связано с любым другим числом, то оно будет расцениваться как True , и тело условного оператора выполнится. Другой пример:
a = 5 > 0 if a: print(a)
Здесь a уже связана с булевым значением. В данном случае это True . Отметим, что в выражении a = 5 > 0 присваивание выполняется после оператора сравнения, так что подвыражение 5 > 0 выполнится первым, после чего его результат будет присвоен переменной a . На будущее, если вы сомневаетесь в последовательности выполнения операторов, используйте скобки, например так: a = (5 > 0) .
if a > 0 and a b: print(b - a)
Тут, чтобы вложенный код выполнился, a должно быть больше нуля и одновременно меньше b . Также в Питоне, в отличие от других языков программирования, позволительна такая сокращенная запись сложного логического выражения:
if 0 a b: print(b - a)
Практическая работа
- Напишите программу, которая просит пользователя что-нибудь ввести с клавиатуры. Если он вводит какие-нибудь данные, то на экране должно выводиться сообщение «ОК». Если он не вводит данные, а просто нажимает Enter , то программа ничего не выводит на экран.
- Напишите программу, которая запрашивает у пользователя число. Если оно больше нуля, то в ответ на экран выводится число 1. Если введенное число не является положительным, то на экран должно выводиться -1.
Примеры решения и дополнительные уроки в pdf-версии курса
X Скрыть Наверх
Python. Введение в программирование
1. Циклы с предусловием и постусловием
В условие описывается логическое выражение, истинность которого обеспечивает дальнейшую работу цикла. С помощью операторов записывается тело цикла.
Цикл выполняется до тех пор, пока выполняется условие, как только условие стало ложным цикл заканчивается.
Напишем программу, которая будет выводить на экран первые \(10\) целых чисел на экран.
Цикл с заданным условием окончания работы (цикл с постусловием) записывается с помощью оператора « repeat ».
Базовый синтаксис языка Python
программирования, работающий на всех распространённых операционных системах.
В настоящее время существует две версии языка Python: более старая и стремительно теряющая популярность версия 2 и современная версия 3. Мы будем использовать версию 3 данного языка. Именно её необходимо установить дома, скачав данную версию с сайта www.python.org.
Запустить интерпретатор python можно из командной строки:
python3
Будьте внимательны: команда python может запустить интерпретатор версии 2, с которым мы работать не будем. В системе Windows можно использовать пункт меню «Python (command line)».
Интерактивный режим
Откройте командную строку и напишите команду python3.
Вы увидите примерно следующее приглашение командной строки:
Python 3.10.6 (main, Aug 2 2022, 00:00:00) [GCC 12.1.1 20220507 (Red Hat 12.1.1-1)] on linux Type "help", "copyright", "credits" or "license" for more information. >>>
Вводите команды и наслаждайтесь результатом. А что можно вводить? Несколько примеров:
>>> 2 + 2 4 >>> 2 ** 100 1267650600228229401496703205376 >>> 'Hello' + 'World' 'HelloWorld' >>> 'ABC' * 10 'ABCABCABCABCABCABCABCABCABCABC'
Первая команда вычисляет сумму двух чисел, вторая команда вычисляет 2 в степени 100, третья команда выполняет операцию конкатенации («склеивания») для строк, а четвертая команда печатает строку ‘ABC’ , повторенную 10 раз.
Хотите закончить работу с питоном? Введите команду exit () (именно так, со скобочками, так как это — функция) или нажмите :python:Ctrl+D.
Программируемый режим
В предыдущей главе мы использовали Python для простых разовых вычислений, используя интерактивный режим. Теперь создадим программу и выполним её целиком.
a = 179 b = 197 c = (a ** 2 + b ** 2) ** 0.5 print (c)
Здесь мы используем переменные — объекты, в которых можно сохранять различные (числовые, строковые и прочие) значения. В первой строке переменной a присваивается значение 179 , затем переменной b присваивается значение 197 , затем переменной c присваивается значение арифметического выражения (a 2 + b 2 ) 1 ⁄ 2 , равного длине гипотенузы. После этого значение переменной c выводится на экран.
Упражнение №1: первая программа
Откройте произвольный текстовый редактор, например, gedit . Скопируйте туда текст программы, написанной выше. Сохраните текст в файле с именем hypot . py .
Запустите терминал, перейдите в каталог, где лежит файл hypot . py и выполните эту программу:
python3 hypot.py
Интерпретатор языка Python вместо интерактивного режима выполнит последовательность команд из файла.
При этом значения вычисленных выражений не выводятся на экран (в отличие от интерактивного режима), поэтому для того, чтобы вывести результат работы программы, то есть значение переменной c , нужна функция print () .
Базовый синтаксис языка Python 3
Типы данных
Итак, мы видим, что Python умеет работать как минимум с двумя видами данных — числами и строками. Числа записываются последовательностью цифр, также перед числом может стоять знак минус, а строки записываются в одинарных кавычках. 2 и ‘2’ — это разные объекты, первый объект — число, а второй — строка. Операция :python:+ для целых чисел и для строк работает по-разному: для чисел это сложение, а для строк — конкатенация.
Кроме целых чисел есть и другой класс чисел: действительные (вещественные числа), представляемые в виде десятичных дробей. Они записываются с использованием десятичной точки, например, 2.0 .
Определить тип объекта можно при помощи функции type :
>>> type(2) >>> type(‘2’) >>> type(2.0)
Обратите внимание: type является функцией, аргументы функции указываются в скобках после ее имени.
Операции с числами
Вот список основных операций для чисел:
- A + B — сумма;
- A — B — разность;
- A * B — произведение;
- A / B — частное;
- A ** B — возведение в степень:
- A // B — целочисленное деление;
- A % B — остаток от деления.
Полезно помнить, что квадратный корень из числа :python:x — это x ** 0.5 , а корень степени :python:n — это x ** ( 1 / n ) .
Есть также унарный вариант операции :python:-, то есть это операция с одним аргументом. Она возвращает число, противоположное данному. Например: — A .
В выражении может встречаться много операций подряд. Как в этом случае определяется порядок действий? Например, чему будет равно 1 + 2 * 3 ** 1 + 1 ? В данном случае ответ будет 8, так как сначала выполняется возведение в степень, затем — умножение, затем — сложение (соответствует математическому 1 + 2⋅3 1 + 1 ).
Более общие правила определения приоритетов операций такие:
- Выполняются возведения в степень справа налево, то есть 3 ** 3 ** 3 это 3 27 .
- Выполняются унарные минусы (отрицания).
- Выполняются умножения и деления слева направо. Операции умножения и деления имеют одинаковый приоритет.
- Выполняются сложения и вычитания слева направо. Операции сложения и вычитания имеют одинаковый приоритет.
Операции над строками
- A + B — конкатенация;
- A * n — повторение n раз, значение n должно быть целого типа.
Ветвление
Ветвление (или условная инструкция) в Python имеет следующий синтаксис:
if Условие: Блок_инструкций_1 else: Блок_инструкций_2
Блок_инструкций_1 будет выполнен, если Условие истинно. Если Условие ложно, будет выполнен Блок_инструкций_2 .
В условной инструкции может отсутствовать слово else и последующий блок. Такая инструкция называется неполным ветвлением. Например, если дано число x и мы хотим заменить его на абсолютную величину x , то это можно сделать следующим образом:
if x 0: x = -x print(x)
В этом примере переменной x будет присвоено значение — x , но только в том случае, когда x < 0 . А вот инструкция print ( x ) будет выполнена всегда, независимо от проверяемого условия.
Для выделения блока инструкций, относящихся к инструкции if или else , в языке Python используются отступы. Все инструкции, которые относятся к одному блоку, должны иметь равную величину отступа, то есть одинаковое число пробелов в начале строки. Рекомендуется использовать отступ в 4 пробела.
Вложенные условные инструкции
Внутри условных инструкций можно использовать любые инструкции языка Python, в том числе и условную инструкцию. Вложенное ветвление — после одной развилки в ходе исполнения программы появляется другая развилка. При этом вложенные блоки имеют больший размер отступа (например, 8 пробелов).
Примере программы, которая по данным ненулевым числам x и y определяет, в какой из четвертей координатной плоскости находится точка (x,y):
x = int(input()) y = int(input()) if x > 0: if y > 0: # x>0, y>0 print("Первая четверть") else: # x>0, y print("Четвертая четверть") else: if y > 0: # x0 print("Вторая четверть") else: # x <0, yprint("Третья четверть")
В этом примере мы использовали комментарии – текст, который интерпретатор игнорирует. Комментариями в Pythonе является символ # и весь текст после этого символа до конца строки. Желательно писать код так, чтобы комментарии были излишними, однако допускается писать их там, где возникают «призраки» (утверждения или теоремы, которые использованы при написании кода, но не следуют из самого кода). Однако код выше является плохим примером документации: комментарии врут, поскольку автором не учтены точки на осях.
Операторы сравнения
Как правило, в качестве проверяемого условия используется результат вычисления одного из следующих операторов сравнения:
| Оператор | Значение |
|---|---|
| Меньше — условие верно, если первый операнд меньше второго. | |
| > | Больше — условие верно, если первый операнд больше второго. |
| Меньше или равно — условие верно, если первый операнд меньше или равен второму. | |
| >= | Больше или равно — условие верно, если первый операнд больше или равен второму. |
| == | Равенство. Условие верно, если два операнда равны. |
Операторы сравнения в можно объединять в цепочки, например, a == b == c или 1
Тип данных bool
Операторы сравнения возвращают значения специального логического типа bool . Значения логического типа могут принимать одно из двух значений: True (истина) или False (ложь). Если преобразовать логическое True к типу int , то получится 1, а преобразование False даст 0. При обратном преобразовании число 0 преобразуется в False , а любое ненулевое число в True . При преобразовании str в bool пустая строка преобразовывается в False , а любая непустая строка в True .
Каскадные условные инструкции
Пример программы, определяющий четверть координатной плоскости, можно переписать, используя «каскадную» последовательность инструкцией if . elif . else :
x = int(input()) y = int(input()) if x > 0 and y > 0: print("Первая четверть") elif x 0 and y > 0: print("Вторая четверть") elif x 0 and y 0: print("Третья четверть") elif x > 0 and y 0: print("Четвертая четверть") else: print("Точка находится на осях или в центре координат.")
В такой конструкции условия if , . elif проверяются по очереди, выполняется блок, соответствующий первому из истинных условий. Если все проверяемые условия ложны, то выполняется блок else , если он присутствует. Обратите внимание, что таким образом мы чётче видим условия наступления случаев (нет «призраков»), а также отлавливаем ситуацию, когда точка не находится ни в одной из четвертей.
Цикл while
Цикл while («пока») позволяет выполнить одну и ту же последовательность действий, пока проверяемое условие истинно. Условие записывается до тела цикла и проверяется до выполнения тела цикла. Как правило, цикл while используется, когда невозможно определить точное значение количества проходов исполнения цикла.
Синтаксис цикла while в простейшем случае выглядит так:
while Условие: Блок_инструкций
При выполнении цикла while сначала проверяется условие. Если оно ложно, то выполнение цикла прекращается и управление передается на следующую инструкцию после тела цикла while . Если условие истинно, то выполняется инструкция, после чего условие проверяется снова и снова выполняется инструкция. Так продолжается до тех пор, пока условие будет истинно. Как только условие станет ложно, работа цикла завершится и управление передастся следующей инструкции после цикла.
Например, следующий фрагмент программы напечатает на экран всех целые числа, не превосходящие n:
a = 1 while a n: print(a) a += 1
Общая схема цикла while в данном случае для перебора всех подходящих значений такая:
a = начальное_значение while а_является_подходящим_числом: обработать_a перейти_к_следующему_a
Выведем все степени двойки, не превосходящие числа n:
a = 1 while a n: print(a) a *= 2
Цикл for
Цикл for может быть использован как более краткая альтернатива циклу while .
Для последовательного перебора целых чисел из диапазона [ 0 ; n ) можно использовать цикл for :
for i in range(10): print(i)
Этот код по выполняемым действиям полностью соответствуют циклу while :
i = 0 while i 10: print(i) i += 1
Можно задавать начальные и конечные значения для переменной цикла, а также шаг:
for i in range(20, 10, -2): print(i)
Аналогичный цикл while
i = 20 while i > 10: print(i) i -= 2
Контест №1
Программированию учатся на практике, поэтому в курсе каждую неделю будет контест. Контест — это набор задач с системой автоматической проверки решения на тестовых наборах данных. Для участия необходима регистрация на контест.
В первый раз вам придётся создать пользователя (логин и пароль обязательно запишите!), а также ввести некоторую регистрационную информацию: фамилию, имя, номер учебной группы. Пожалуйста, вводите реальные данные, иначе преподаватель не сможет учитывать ваши решения.
Попробуйте сдать решение первой задачи:
x, y = input().split() x, y = int(x), int(y) print(x + y)
Сайт построен с использованием Pelican. За основу оформления взята тема от Smashing Magazine. Исходные тексты программ, приведённые на этом сайте, распространяются под лицензией GPLv3, все остальные материалы сайта распространяются под лицензией CC-BY.