Урок №15. Язык программирования. Основные конструкции языка программирования. Типы данных.
Переменная — это величина, значение которой можно изменять во время работы алгоритма.
Переменная имеет имя (идентификатор), тип и значение. Для изменения значения переменной используется оператор присваивания.
Напишем программу, которая выполняет сложение двух чисел:
1) запрашивает у пользователя два целых числа;
2) складывает их;
3) выводит результат сложения.
Числа, введённые пользователем, нужно записать в переменные. В языке Python (в отличие от многих других языков) переменные не нужно заранее объявлять. Они создаются в памяти при первом использовании, точнее, при первом присваивании им значения. Например, при выполнении оператора присваивания
а = 4в памяти создаётся новая переменная (объект типа «целое число»), и она связывается с именем а.
В именах переменных можно использовать латинские буквы(строчные и прописные буквы различаются), цифры (но имя не может начинаться с цифры, иначе транслятору будет сложно различить, где начинается имя, а где — число) и знак подчёркивания «_».
Желательно давать переменным «говорящие» имена, чтобы можно было сразу понять, зачем нужна та или иная переменная.
Тип переменной в Python определяется автоматически. Программа
а = 4
print(type(а))
выдаёт на экран тип (англ, type) переменной а:
<class 'int'>В данном случае а — это переменная целого типа, на это указывает слово int (сокращение от англ, integer — целый). Говорят, что переменная а относится к классу int.
Тип переменной нужен для того, чтобы:
• определить область допустимых значений переменной;
• определить допустимые операции с переменной;
• определить, какой объём памяти нужно выделить переменной и в каком формате будут храниться данные (вспомните, что целые и вещественные числа хранятся по-разному).
В языке Python используется динамическая типизация, это значит, что тип переменной определяется по значению, которое ей присваивается (а не при объявлении переменной, как во многих языках). Таким образом, в разных частях программы одна и та же переменная может хранить значения разных типов.
Обсудите в классе, какие преимущества и недостатки имеет этот подход.
Вспомним, что нам нужно решить три подзадачи:
• ввести два числа с клавиатуры и записать их в переменные (назовём их а и b);
• сложить эти два числа и записать результат в третью переменную с;
• вывести значение переменной с на экран.
Для ввода используется функция input, результат работы которой можно записать в переменную, например так:
а = input ()При выполнении этой строки система будет ожидать ввода с клавиатуры и, когда пользователь введёт число и нажмёт клавишу Enter, система запишет введённое значение в переменную а. При вызове функции input в скобках можно записать сообщение-подсказку:
а = input("Введите целое число: ")Сложить два значения и записать результат в переменную с очень просто:
с = а + bСимвол « = » — это оператор присваивания, с его помощью изменяют значение переменной. Он выполняется следующим образом: вычисляется выражение справа от символа « = », а затем результат записывается в переменную, записанную слева. Поэтому, например, оператор
i = i + 1увеличивает значение переменной i на 1.
Выведём значение переменной с на экран с помощью уже знакомой функции print:
print (с)Казалось бы, теперь легко собрать всю программу:
а = input()
b = input()
с = а + b
print(с)
Однако после того, как мы запустим её и введём какие-то числа, допустим 21 и 33, мы увидим странный ответ: 2133. Вспомните, что при нажатии клавиши на клавиатуре в компьютер поступает её код, т. е. код соответствующего символа. И входные данные воспринимаются функцией input именно как поток символов. Поэтому в той программе, которая приведена выше, переменные а и b — это цепочки символов, при сложении этих цепочек (с помощью оператора « + ») программа просто объединяет их — приписывает вторую цепочку в конец первой.
Чтобы исправить эту ошибку, нужно преобразовать символьную строку, которая получена при вводе, в целое число. Это делается с помощью функции int (от англ, integer — целый):
а = int (input())
b = int (input())
Итак, после того как мы преобразовали введённые значения в формат целых чисел, программа работает правильно — складывает два числа, введённые с клавиатуры. Однако у неё есть два недостатка:
1) перед вводом данных пользователь не знает, что от него требуется (сколько чисел нужно вводить и каких);
2) результат выдаётся в виде числа, которое означает неизвестно что.
Хотелось бы, чтобы диалог программы с пользователем выглядел так:
Введите два целых числа:
2
3
2+3=5
Подсказку для ввода вы можете сделать самостоятельно. При выводе результата ситуация несколько усложняется, потому что нужно вывести значения трёх переменных и два символа: « + » и « = ». Для этого строится список вывода, элементы в котором разделены запятыми:
print (а, " + Ь, " = с)Мы почти получили нужный результат, но почему-то знаки « + » и « = » отделены лишними пробелами, который мы «не заказывали»:
2 + 3 = 5Действительно, функция print вставляет между выводимыми значениями так называемый разделитель (сепаратор, англ, separator). По умолчанию разделитель — это пробел, но мы можем его изменить, указав новый разделитель после слова sep:
print (а, " + ", b, " = с, sep = "")Здесь мы установили пустой разделитель (пустую строку). Теперь все работает как надо, лишних пробелов нет.
В принципе можно было бы обойтись и без переменной с, потому что элементом списка вывода может быть арифметическое выражение, которое сразу вычисляется и на экран выводится его результат:
print (а, " + ", b, " = ", a+b, sep = "")Для того чтобы после выполнения функции print программа не переходила на новую строку, можно задать пустую строку в дополнительном параметре end:
print ("Привет, ", end = "")
print("Вася!")
Перечислим основные простые типы данных в языке Python:
• int — целые значения;
• float — вещественные значения (могут быть с дробной частью);
• bool — логические значения, True (истина, «да») или False (ложь, «нет»);
• str — символ или символьная строка, т. е. цепочка символов.
Тип переменной определяется в тот момент, когда ей присваивается новое значение. Мы уже видели, что для определения типа переменной можно использовать стандартную функцию type. Например, программа
а = 5
print(type(а))
а = 4.5
print(type(а))
а = True
print(type(а))
а = "Вася"
print(type(а))
выдаст на экран такой результат:
<class 'int'>
<class 'float'>
<class 'bool'>
<class 'str'>
Сначала в переменной а хранится целое значение 5, и её тип — целый (int). Затем мы записываем в неё вещественное значение 4,5, переменная будет вещественного типа (float, от англ, floating point — с плавающей точкой). Третье присваивание записывает в переменную а логическое значение (bool, от англ. boolean — булевская величина, в честь Дж. Буля). Последнее значение — символьная строка (str, от англ, string — строка), которая записывается в апострофах или в кавычках.
Целые переменные в Python могут быть сколь угодно большими (или, наоборот, маленькими, если речь идёт об отрицательных числах). Транслятор автоматически выделяет область памяти такого размера, который необходим для сохранения результата вычислений, единственное ограничение связано с объёмом доступной памяти. Поэтому в Python легко (в отличие от других языков программирования) точно выполнять вычисления с «длинными» целыми числами, которые содержат много значащих цифр.
Вещественные переменные, как правило, занимают 8 байт, что обеспечивает точность 15 значащих десятичных цифр. Большинство вещественных чисел хранится в памяти неточно, и в результате операций с ними накапливается вычислительная ошибка.
Условный оператор предназначен для выбора из двух вариантов действий. После служебного слова if (если) записывается некоторое условие; если оно истинно, то выполняется блок операторов, расположенный далее. Вторая (необязательная) часть условного оператора начинается словом else (иначе), сразу после него записывается блок операторов, которые выполняются, если условие после слова if ложно.
Возможности, описанные в предыдущих параграфах, позволяют писать линейные программы, в которых операторы выполняются последовательно друг за другом, и порядок их выполнения не зависит от входных данных.
В большинстве реальных задач порядок действий может изменяться в зависимости от того, какие данные поступили. Например, программа для системы пожарной сигнализации должна выдавать сигнал тревоги, если данные с датчиков показывают повышение температуры или задымлённость.
Для этой цели в языках программирования предусмотрены условные операторы. Например, для того чтобы записать в переменную М максимальное из значений переменных а и b, можно использовать оператор:
if а > b:
М = а
else:
М = b
Если истинно (верно) условие, записанное после ключевого слова if, то затем выполняются все команды (блок команд), которые расположены до слова else. Если же условие после if ложно (неверно), выполняются команды, стоящие после else.
Обратите внимание, что после условия и после слова else ставятся двоеточия.
В Python, в отличие от других языков, важную роль играют сдвиги операторов относительно левой границы (отступы). Слова if и else начинаются на одном уровне, а все команды внутренних блоков сдвинуты относительно этого уровня вправо на одно и то же расстояние. Это позволяет не использовать особые ограничители блоков (слова begin и end в языке Паскаль, фигурные скобки в С-подобных языках). Для сдвига используют символы табуляции (которые вставляются при нажатии на клавишу Tab) или пробелы.
Если в блоке всего один оператор, иногда бывает удобно записать его в той же строке, что и ключевое слово if (else):
if а > b: М = а
else: М = b
В приведённых примерах условный оператор записан в полной форме: в обоих случаях (истинно условие или ложно) нужно выполнить некоторые действия. Программа выбора максимального значения может быть написана иначе:
М = а
if b > а:
М = b
Здесь использован условный оператор в неполной форме, потому что в случае, когда условие ложно, ничего делать не требуется (нет слова else и блока операторов после него).
Поскольку операция выбора максимального из двух значений нужна очень часто, в Python есть встроенная функция max, которая вызывается так:
М = mах(а, b)Если выбирается максимальное из двух чисел, можно использовать особую форму условного оператора в Python:
М = a if а > b else bкоторая работает так же, как и приведённый выше условный оператор в полной форме: записывает в переменную М значение а, если выполняется условие а > b, и значение b, если это условие ложно.
Часто при каком-то условии нужно выполнить сразу несколько действий. Например, в задаче сортировки значений переменных а и b по возрастанию нужно поменять местами значения этих переменных, если а > b:
if а > b:
с = а
а = b
b = с
Все операторы, входящие в блок, сдвинуты на одинаковое расстояние от левого края. Заметим, что в Python, в отличие от многих других языков программирования, есть множественное присваивание, которое позволяет выполнить эту операцию значительно проще:
а, b = b, аКроме знаков < и > в условиях можно использовать другие знаки отношений: <= (меньше или равно), >= (больше или равно), == (равно — два знака «=» без пробела, чтобы отличить от операции присваивания) и != (не равно).
Внутри условного оператора могут находиться любые операторы, в том числе и другие условные операторы. Например, пусть возраст Андрея записан в переменной а, а возраст Бориса — в переменной b. Нужно определить, кто из них старше. Одним условным оператором тут не обойтись, потому что есть три возможных результата: старше Андрей, старше Борис и оба одного возраста. Решение задачи можно записать так:
if а > b:
print("Андрей старше")
else:
if а == b:
print("Одного возраста")
else:
print("Борис старше")
Условный оператор, проверяющий равенство, находится внутри блока «иначе» (else), поэтому он называется вложенным условным оператором. Как видно из этого примера, использование вложенных условных операторов позволяет выбрать один из нескольких (а не только из двух) вариантов. Если после else сразу следует ещё один оператор if, можно использовать так называемое «каскадное» ветвление с ключевыми словами elif (сокращение от else if): если очередное условие ложно, выполняется проверка следующего условия и т. д.
if а > b:
print("Андрей старше")
elif а == b:
print("Одного возраста")
else:
print("Борис старше")
Обратите внимание на отступы: слова if, elif и else находятся на одном уровне!
Если в цепочке if-elif-elif-… выполняется несколько условий, то срабатывает первое из них. Например, программа
if cost < 1000:
print("Скидок нет.")
elif cost < 2000:
print("Скидка 2%.")
elif cost < 5000:
print ("Скидка 5%.")
else:
print("Скидка 10%.")
при cost = 1500 выдаёт Скидка 2%., хотя условие cost < 5000 тоже выполняется.
Рассмотрим следующую задачу: определить количество цифр в десятичной записи целого положительного числа. Будем предполагать, что исходное число записано в переменной п целого типа.
Сначала нужно разработать алгоритм решения задачи. Для подсчёта количества цифр нужно как-то отсекать эти цифры по одной, с начала или с конца, каждый раз увеличивая счётчик. Начальное значение счётчика должно быть равно нулю, так как до выполнения алгоритма ещё не найдено ни одной цифры.
Для отсечения первой слева цифры необходимо заранее знать, сколько цифр в десятичной записи числа, т. е. нужно заранее решить ту задачу, которую мы решаем. Следовательно, этот метод не подходит.
Отсечь последнюю цифру проще — достаточно разделить число нацело на 10 (поскольку речь идёт о десятичной системе). Операции отсечения и увеличения счётчика нужно выполнять столько раз, сколько цифр в числе. Как же «поймать» момент, когда цифры кончатся? Несложно понять, что в этом случае результат очередного деления на 10 будет равен нулю, это и говорит о том, что отброшена последняя оставшаяся цифра. Изменение переменной п и счётчика для начального значения 1234 можно записать в виде таблицы:
Запишем алгоритм на псевдокоде:
счётчик = О
пока n > О
отсечь последнюю цифру числа n
увеличить счётчик на 1
Соответствующая программа на Python выглядит так:
count = 0
while n > 0:
n = n //10
count += 1
Слово while переводится как «пока», т. е. цикл выполняется, пока n > 0. После условия, как и в конце заголовка условного оператора if, ставится двоеточие. Переменная-счётчик имеет имя count.
Обратите внимание, что проверка условия выполняется в начале очередного шага цикла. Такой цикл называется циклом с предусловием (т. е. с предварительной проверкой условия) или циклом «пока». Если в начальный момент значение переменной n будет нулевое или отрицательное, цикл не выполнится ни одного раза.
В данном случае количество шагов цикла «пока» неизвестно, оно равно количеству цифр введённого числа, т. е. зависит от исходных данных. Кроме того, этот же цикл может быть использован и в том случае, когда число шагов известно заранее или может быть вычислено:
к = 0
while к < 10:
print("Привет")
к += 1
Если условие в заголовке цикла никогда не нарушится, цикл будет работать бесконечно долго. В этом случае говорят, что «программа зациклилась». Например, если забыть увеличить переменную к в предыдущем цикле, программа зациклится:
к = 0
while к < 10:
print("Привет")
Вернёмся снова к задаче, которую мы обсуждали в предыдущем параграфе, — вывести на экран 10 раз слово «Привет!». Фактически нам нужно организовать цикл, в котором блок операторов выполнится заданное число раз (в некоторых языках такой цикл есть, например, в школьном алгоритмическом языке он называется «цикл N раз»). На языке Python подобный цикл записывается так:
for i in range(10):
print("Привет!")
Здесь слово for означает «для», переменная i (её называют переменной цикла) изменяется в диапазоне (in range) от 0 до 10, не включая 10 (т. е. от 0 до 9 включительно). Таким образом, цикл выполняется ровно 10 раз. Заметьте, что в конце заголовка цикла ставится двоеточие.
В информатике важную роль играют степени числа 2 (2, 4, 8, 16 и т. д.) Чтобы вывести все степени двойки от 21 до 210, мы уже можем написать такую программу с циклом «пока»:
k = 1
while к <= 10 :
print(2**к)
к += 1
Вы наверняка заметили, что переменная к используется трижды (см. выделенные блоки): в операторе присваивания начального значения, в условии цикла и в теле цикла (увеличение на 1). Цикл с переменной «собирает» все действия с ней в один оператор:
for k in range(1,11):
print(2**к)
Здесь диапазон (range) задаётся двумя числами — начальным и конечным значениями, причём указанное конечное значение не входит в диапазон. Такова особенность функции range в Python.
Шаг изменения переменной цикла по умолчанию равен 1. Если его нужно изменить, указывают третье (необязательное) число в скобках после слова range — нужный шаг. Например, такой цикл выведет только нечётные степени числа 2 (21, 23 и т. д.):
for k in range (1,11,2) :
print (2**к)
С каждым шагом цикла переменная цикла может не только увеличиваться, но и уменьшаться. Для этого начальное значение должно быть больше конечного, а шаг — отрицательный. Следующая программа выводит квадраты натуральных чисел от 10 до 1 в порядке убывания:
for k in range (10,0,-1) :
print(к**2)