Запишите инструкцию для определения типа переменной a ответ

Структура программы на языке Python. Операции, переменные и литералы. Типы данных

В данный момент вы не можете посмотреть или раздать видеоурок ученикам

Чтобы получить доступ к этому и другим видеоурокам комплекта, вам нужно добавить его в личный кабинет.

Получите невероятные возможности

Конспект урока «Структура программы на языке Python. Операции, переменные и литералы. Типы данных»

· Структура программы на языке Python.

· Операции и переменные.

· Типы данных языка Python.

Итак, рассмотрим, из чего состоят программы на языке Python. Любая программа на языке Python состоит из модулей. Модуль на языке Python представляет собой ряд связанных между собой операций. Модули сохраняются в отдельных файлах с расширением *.py. Сохранённые модули можно использовать в создаваемых программах. Сначала мы будем разрабатывать довольно простые программы, которые практически всегда будут состоять всего из одного модуля.

Модули, в свою очередь, состоят из более простых структурных единиц. В модулях содержится код на языке Python, состоящий из инструкций. Инструкции представляют собой указания компьютеру. Они определяют, какие операции выполнит компьютер с данными. Инструкции в языке Python делятся на простые и составные. Простые инструкции описываются одной строкой кода, составные же – содержат вложенные инструкции.

Инструкции могут содержать выражения. И если инструкции определяют, какие действия будут выполнены над информацией, то выражения в составе инструкций определяют, над какими именно данными будут выполнены действия, описанные в инструкции.

Вместе с языком Python поставляется множество стандартных модулей, которые предоставляют программисту большое количество инструментов и возможностей для написания самых разных программ.

Рассмотрим пример. Находясь в интерактивном режиме среды разработки, создадим новый файл, в котором запишем несколько инструкций. Сохраним его под именем modul_1.py. Запишем в файле инструкцию вывода print (2 * (10 – 4)). Сохраним файл и запустим инструкцию на выполнение. В главном окне среды разработки было выведено значение записанного нами выражения, то есть 12.

В описанном нами примере, файл modul_1.py является модулем, строка, записанная нами в этом файле, является инструкцией, а математическое выражение, записанное в скобках, является выражением.

Рассмотрим, что такое операции. Операциями в языках программирования называются любые действия над операндами. Операндами называются некоторые данные. Для примера рассмотрим операции, используемые в описанном нами математическом выражении. Всего их две: разность и умножение. Операндами для операции разности являются числа: 10 и 4. Операндами для операции умножения являются число 2 и разность чисел 10 и 4. Установив скобки в этом выражении, мы определили порядок выполнения операций. Сначала будет выполнена операция разности, записанная в скобках, после чего её результат будет использован в качестве операнды при выполнении умножения. Приоритет выполнения операций в языке Python соответствует математическому.

Операндами для операций могут быть литералы, выражения и переменные. В описанном нами примере операндами разности являются литералы, то есть числа, которые записаны при написании кода, а для операции умножения – литерал, то есть число 2, а также выражение, то есть разность чисел 10 и 4. Операндами могут быть и переменные. Независимо от языка программирования, переменной называется именованная область оперативной памяти, в которой хранится информация определённого типа. Механизм связи между переменной и данными, которые она содержит, может отличаться в зависимости от языка программирования. Пока просто запомним, что данные, сохранённые в переменной, связаны с некоторым именем и могут быть вызваны по этому имени.

Данные, которые соответствуют переменной в языке Python, могут быть определены с помощью инструкции присваивания. Инструкция присваивания в языке Python записывается с помощью знака равенства, слева от которого находится имя переменной, а справа – её значение. То есть, чтобы переменной а присвоить значение 4, мы должны записать строку кода: а = 4.

Рассмотрим пример. В среде разработки языка Python, в интерактивном режиме, присвоим переменной t значение 15, после чего убедимся, что операция выполнена. Для этого запишем строку кода: t = 15 и нажмём клавишу Enter. Операция присваивания уже была выполнена – убедимся в этом. Для этого запишем инструкцию print (t) для вывода значения переменной t на экран. Таким образом, мы убедились, что переменная t имеет значение 15. Важно запомнить, что переменную стоит называть осмысленно, её имя не должно совпадать со служебными словами языка или содержать служебные символы; имя переменной не может начинаться с цифры.

Рассмотрим, какие типы данных используются в языке программирования Python. Во время написания программ мы будем использовать всего четыре основных типа данных: целые числа – int, вещественные числа – float и символьные строки – str. К целым числам относятся числа без дробной части, например: 0, 7, — 12 и т. д… К вещественным числам относятся числа с дробной частью, например: 3.5, — 6.7 и так далее… К символьным строкам относятся любые последовательности символов. При вводе они заключаются в двойные или одинарные кавычки.

Те из вас, кто до этого использовал другие языки программирования, например Pascal, знают, что прежде чем использовать переменную в программе, её нужно объявить. При этом, за переменной закрепляется ячейка оперативной памяти, а также указывается тип данных, которые будут на ней храниться. Возможно, многие из вас обратили внимание на то, что при написании кода для демонстрации работы оператора присваивания, мы не объявляли переменную Тэ, прежде чем присвоить ей значение. Так происходит потому, что в языке Python переменная объявляется автоматически перед первым использованием. Тогда у многих из вас может возникнуть вопрос: «Как определяется тип переменной? Ведь его мы тоже не указывали». В отличие от всё того же языка Pascal, в языке Python используется динамическая типизация. Что это означает? В языке Python тип переменной определяется автоматически, в зависимости от присвоенного ей значения, а так как значение переменной в ходе исполнения программы может изменяться, то и тип переменной также изменяется вслед за значением.

Как же определить, какой тип имеет переменная на данный момент? Для этого в языке Python есть функция type. Посмотрим, как она работает. В среде разработки языка Python, в интерактивном режиме, сначала присвоим переменной a значение 4, после чего запишем инструкцию type (a). На экран был выведен результат выполнения инструкции. В угловых скобках записано слово type, после которого в одинарных кавычках следует тип переменной – int. Теперь присвоим переменной a значение -5.7. В языке Python дробная часть числа отделяется от целой точкой. Теперь снова запишем инструкцию type (a). Как видим, тип переменной a изменился на float. Теперь присвоим переменной a символьную строку. Для этого, после знака равенства, в двойных или одинарных кавычках запишем любую последовательность символов, например, слово «Привет». Теперь снова запишем инструкцию type (a). Тип переменной a изменился на str. Для того, чтобы задать число с нулевой дробной частью как вещественное, достаточно просто указать его дробную часть равной нулю. Присвоим переменной a значение 4.0, после чего запишем инструкцию type (a). Как видим, тип переменной a стал float. Важно запомнить, что значения строкового типа не могут употребляться в одном выражении со значениями одного из числовых типов, иначе результатом попытки выполнения инструкции будет сообщение об ошибке.

Решим задачу. Написать модуль, в котором переменным a и b присваиваются значения соответственно равные 8.5 и 6, а переменной c – значение суммы a и b. После чего выводятся на экран значения переменной c, разности a и b, их произведения, частного, а также a b .

Создадим файл модуля, после чего сохраним его. Начнём написание инструкций. В начале запишем инструкцию для присваивания переменной a значения 8.5. После этого, запишем инструкцию для присваивания переменной b значения 6, а также инструкцию присваивания переменной c значения суммы a и b. Дальше напишем инструкцию print, после которой будут следовать пустые скобки. Скопируем эту инструкцию четыре раза (по количеству выражений, результаты которых необходимо вывести). В первой инструкции print в скобках запишем c, во второй – a – b, в третьей – a * b, в четвёртой – a / b и в пятой – a ** b.

После того как все инструкции записаны, сохраним модуль и запустим его на выполнение. В главном окне среды разработки в пяти строках было выведено пять чисел – результаты перечисленных операций. Модуль работает правильно. Задача решена.

Обратим внимание на то, как выполняются инструкции присваивания в написанном нами модуле. При выполнении первой инструкции сначала выделяется ячейка оперативной памяти для переменной a, после чего проверяется литерал 8.5. Это вещественное число, поэтому тип переменной становится float. Далее в ячейку оперативной памяти заносится значение литерала 8.5. Вторая инструкция выполняется так же, с той лишь разницей, что литерал 6 является целым числом и тип переменной b будет int. При выполнении третьей инструкции присваивания сначала из оперативной памяти извлекаются значения переменных a и b, после чего вычисляется значение их суммы. Далее для переменной c выделяется ячейка оперативной памяти. Так как результатом операции сложения является вещественное число, тип переменной c становится float. В созданную ячейку оперативной памяти заносится результат суммы, то есть четырнадцать целых пять десятых.

· Программа на языке Python состоит из модулей, которые, в свою очередь, состоят из инструкций, которые могут содержать выражения.

· Операцией называется любое действие над данными.

· Переменной называется именованная область оперативной памяти, содержащая данные определённого типа.

· В языке Python есть три основных типа данных: целые числа – int, вещественные числа – float, а также строки символов – str.

· В языке Python переменные объявляются автоматически при первом использовании.

· Тип данных, хранящихся в переменной, изменяется в ходе исполнения программы в зависимости от того, какое значение присваивается переменной. Этот принцип называется динамической типизацией.

Основы Python

Программа на языке Python состоит из набора инструкций. Каждая инструкция помещается на новую строку. Например:

Большую роль в Python играют отступы. Неправильно поставленный отступ фактически является ошибкой. Например, в следующем случае мы получим ошибку, хотя код будет практически аналогичен приведенному выше:

Поэтому стоит помещать новые инструкции сначала строки. В этом одно из важных отличий пайтона от других языков программирования, как C# или Java.

Однако стоит учитывать, что некоторые конструкции языка могут состоять из нескольких строк. Например, условная конструкция if:

В данном случае если 1 меньше 2, то выводится строка «Hello». И здесь уже должен быть отступ, так как инструкция print(«Hello») используется не сама по себе, а как часть условной конструкции if. Причем отступ, согласно руководству по оформлению кода, желательно делать из такого количество пробелов, которое кратно 4 (то есть 4, 8, 16 и т.д.) Хотя если отступов будет не 4, а 5, то программа также будет работать.

Таких конструкций не так много, поэтому особой путаницы по поводу где надо, а где не надо ставить пробелы, не должно возникнуть.

Python — регистрозависимый язык, поэтому выражения print и Print или PRINT представляют разные выражения. И если вместо метода print для вывода на консоль мы попробуем использовать метод Print:

то у нас ничего не получится.

Для отметки, что делает тот или иной участок кода, применяются комментарии. При трансляции и выполнении программы интерпретатор игнорирует комментарии, поэтому они не оказывают никакого влияния на работу программы.

Комментарии в Python бывают блочные и строчные. Все они предваряются знаком решетки (#).

Блочные комментарии ставятся в начале строки.

Строчные комментарии располагаются на той же строке, что и инструкции языка:

Python предоставляет ряд встроенных функций. Некоторые из них используются очень часто, особенно на начальных этапах изучения языка, поэтому рассмотрим их.

Основной функцией для вывода информации на консоль является функция print(). В качестве аргумента в эту функцию передается строка, которую мы хотим вывести:

Если же нам необходимо вывести несколько значений на консоль, то мы можем передать их в функцию print через запятую:

В итоге все переданные значения склеятся через пробелы в одну строку:

Full name: Tom Smith

Если функция print отвечает за вывод, то функция input отвечает за ввод информации. В качестве необязательного параметра эта функция принимает приглашение к вводу и возвращает введенную строку, которую мы можем сохранить в переменную:

Введите имя: Евгений

Привет Евгений

Переменная хранит определенные данные. Название переменной в Python должно начинаться с алфавитного символа или со знака подчеркивания и может содержать алфавитно-цифровые символы и знак подчеркивания. И кроме того, название переменной не должно совпадать с названием ключевых слов языка Python. Ключевых слов не так много, их легко запомнить: and, as, assert, break, class, continue, def, del, elif, else, except, False, finally, for, from, global, if, import, in, is, lambda, None, nonlocal, not, or, pass, raise, return, True, try, while, with, yield.

Например, создадим переменную:

Здесь определена переменная name, которая хранит строку «Tom».

В пайтоне применяется два типа наименования переменных: camel case и underscore notation.

Camel case подразумевает, что каждое новое подслово в наименовании переменной начинается с большой буквы. Например:

Underscore notation подразумевает, что подслова в наименовании переменной разделяются знаком подчеркивания. Например:

И также надо учитывать регистрозависимость, поэтому переменные name и Name будут представлять разные объекты.

Переменная хранит данные одного из типов данных. В Python существует множество различных типов данных, которые подразделяются на категории: числа, последовательности, словари, наборы:

• boolean — логическое значение True или False
• int — представляет целое число, например, 1, 4, 8, 50.
• float — представляет число с плавающей точкой, например, 1.2 или 34.76
• complex — комплексные числа
• str — строки, например «hello». В Python 3.x строки представляют набор символов в кодировке Unicode
• bytes — последовательность чисел в диапазоне 0-255
• byte array — массив байтов, аналогичен bytes с тем отличием, что может изменяться
• list — список
• tuple — кортеж
• set — неупорядоченная коллекция уникальных объектов
• frozen set — то же самое, что и set, только не может изменяться (immutable)
• dict — словарь, где каждый элемент имеет ключ и значение

Python является языком с динамической типизацией. Он определяет тип данных переменной исходя из значения, которое ей присвоено. Так, при присвоении строки в двойных или одинарных кавычках переменная имеет тип str. При присвоении целого числа Python автоматически определяет тип переменной как int. Чтобы определить переменную как объект float, ей присваивается дробное число, в котором разделителем целой и дробной части является точка. Число с плавающей точкой можно определять в экспоненциальной записи:

Число float может иметь только 18 значимых симолов. Так, в данном случае используются только два символа — 3.9. И если число слишком велико или слишком мало, то мы можем записывать число в подобной нотации, используя экспоненту. Число после экспоненты указывает степень числа 10, на которое надо умножить основное число — 3.9.

При этом в процессе работы программы мы можем изменить тип переменной, присвоив ей значение другого типа:

С помощью функции type() динамически можно узнать текущий тип переменной:

Python поддерживает все распространенные арифметические операции:

Сложение двух чисел:

Вычитание двух чисел:

Умножение двух чисел:

Деление двух чисел:

Целочисленное деление двух чисел:

Данная операция возвращает целочисленный результат деления, отбрасывая дробную часть

Возведение в степень:

Получение остатка от деления:

В данном случае ближайшее число к 7, которое делится на 2 без остатка, это 6. Поэтому остаток от деления равен 7 — 6 = 1

При последовательном использовании нескольких арифметических операций их выполнение производится в соответствии с их приоритетом. В начале выполняются операции с большим приоритетом. Приоритеты операций в порядке убывания приведены в следующей таблице.

Пусть у нас выполняется следующее выражение:

Здесь начале выполняется возведение в степень (5 ** 2) как операция с большим приоритетом, далее результат умножается на 4 (25 * 4), затем происходит сложение (3 + 100) и далее опять идет сложение (103 + 7).

Чтобы переопределить порядок операций, можно использовать скобки:

Следует отметить, что в арифметических операциях могут принимать участие как целые, так и дробные числа. Если в одной операции участвует целое число (int) и число с плавающей точкой (float), то целое число приводится к типу float.

Ряд специальных операций позволяют использовать присвоить результат операции первому операнду:

Присвоение результата сложения

Присвоение результата вычитания

Присвоение результата умножения

Присвоение результата от деления

Присвоение результата целочисленного деления

Присвоение степени числа

Присвоение остатка от деления

Ряд встроенных функций в Python позволяют работать с числами. В частности, функции int() и float() позволяют привести значение к типу int и float соответственно.

Например, пусть у нас будет следующий код:

Мы ожидаем, что «2» + 3 будет равно 5. Однако этот код сгенерирует исключение, так как первое число на самом деле представляет строку. И чтобы все заработало как надо, необходимо привести строку к числу с помощью функции int():

Аналогичным образом действует функция float(), которая преобразует в число с плавающей точкой. Но вообще с дробными числами надо учитывать, что результат операций с ними может быть не совсем точным. Например:

В данном случае мы ожидаем получить число 0.40002, однако в конце через ряд нулей появляется еще какая-то четверка. Или еще одно выражение:

В этот случае для округления результата мы можем использовать функцию round():

Первый параметр функции — округляемое число, а второй — сколько знаков после запятой должно содержать получаемое число.

При обычном определении числовой переменной она получает значение в десятичной системе. Но кроме десятичной в Python мы можем использовать двоичную, восьмеричную и шестнадцатеричную системы.

Для определения числа в двоичной системе перед его значением ставится 0 и префикс b:

Для определения числа в восьмеричной системе перед его значением ставится 0 и префикс o:

Для определения числа в шестнадцатеричной системе перед его значением ставится 0 и префикс x:

И с числами в других системах измерения также можно проводить арифметические операции:

Для вывода числа в различных системах исчисления используются функция format, которая вызывается у строки. В эту строку передаются различные форматы. Для двоичной системы «<0:08b>«, где число 8 указывает, сколько знаков должно быть в записи числа. Если знаков указано больше, чем требуется для числа, то ненужные позиции заполняются нулями. Для шестнадцатеричной системы применяется формат «<0:02x>«. И здесь все аналогично — запись числа состоит из двух знаков, если один знак не нужен, то вместо него вставляется ноль. А для записи в восьмеричной системе испольуется формат «<0:02o>«.

Результат работы скрипта:

15 in binary 00001111 in hex 0f in octal 17

Ряд операций представляют условные выражения. Все эти операции принимают два операнда и возвращают логическое значение, которое в Python представляет тип boolean. Существует только два логических значения — True (выражение истинно) и False (выражение ложно).

Простейшие условные выражения представляют операции сравнения, которые сравнивают два значения. Python поддерживает следующие операции сравнения:

Возвращает True, если оба операнда равны. Иначе возвращает False.

Возвращает True, если оба операнда НЕ равны. Иначе возвращает False.

• > (больше чем)

Возвращает True, если первый операнд больше второго.

• < (меньше чем)

Возвращает True, если первый операнд меньше второго.

• >= (больше и равно)

Возвращает True, если первый операнд больше или равен второму.

• <= (меньше и равно)

Возвращает True, если первый операнд меньше или равен второму.

Примеры операций сравнения:

Операции сравнения могут сравнивать различные объекты — строки, числа, логические значения, однако оба операнда операции должны представлять один и тот же тип.

Для создания составных условных выражений применяются логические операции. В Python имеются следующие логические операторы:

• and (логическое умножение)

Возвращает True, если оба выражения равны True

В данном случае оператор and сравнивает результаты двух выражений: age > 21 weight == 58. И если оба этих выражений возвращают True, то оператор and также возвращает True. Причем в качестве одно из выражений необязательно выступает операция сравнения: это может быть другая логическая операция или просто переменная типа boolean, которая хранит True или False.

• or (логическое сложение)

Возвращает True, если хотя бы одно из выражений равно True

• not (логическое отрицание)

Возвращает True, если выражение равно False

Если один из операндов оператора and возвращает False, то другой операнд уже не оценивается, так как оператор в любом случае возвратит False. Подобное поведение позволяет немного увеличить производительность, так как не приходится тратить ресурсы на оценку второго операнда.

Аналогично если один из операндов оператора or возвращает True, то второй операнд не оценивается, так как оператор в любом случае возвратит True.

Строка представляет последовательность символов в кодировке Unicode, заключенных в кавычки. Причем в Python мы можем использовать как одинарные, так и двойные кавычки:

Одной из самых распространенных операций со строками является их объединение или конкатенация. Для объединения строк применяется знак плюса:

С объединением двух строк все просто, но что, если нам надо сложить строку и число? В этом случае необходимо привести число к строке с помощью функции str():

Кроме стандартных символов строки могут включать управляющие эскейп-последовательности, которые интерпретируются особым образом. Например, последовательность \n представляет перевод строки. Поэтому следующее выражение:

На консоль выведет две строки:

Время пришло в гости отправится

Ждет меня старинный друг

Тоже самое касается и последовательности \t, которая добавляет табляцию.

Кроме того, существуют символы, которые вроде бы сложно использовать в строке. Например, кавычки. И чтобы отобразить кавычки (как двойные, так и одинарные) внутри строки, перед ними ставится слеш:

Особо следует сказать о сравнении строк. При сравнении строк принимается во внимание символы и их регистр. Так, цифровой символ условно меньше, чем любой алфавитный символ. Алфавитный символ в верхнем регистре условно меньше, чем алфавитные символы в нижнем регистре. Например:

Поэтому строка «1a» условно меньше, чем строка «aa». Вначале сравнение идет по первому символу. Если начальные символы обоих строк представляют цифры, то меньшей считается меньшая цифра, например, «1a» меньше, чем «2a».

Если начальные символы представляют алфавитные символы в одном и том же регистре, то смотрят по алфавиту. Так, «aa» меньше, чем «ba», а «ba» меньше, чем «ca».

Если первые символы одинаковые, в расчет берутся вторые символы при их наличии.

Зависимость от регистра не всегда желательна, так как по сути мы имеем дело с одинаковыми строками. В этом случае перед сравнением мы можем привести обе строки к одному из регистров.

Функция lower() приводит строку к нижнему регистру, а функция upper() — к верхнему.

Условные конструкции используют условные выражения и в зависимости от их значения направляют выполнение программы по одному из путей. Одна из таких конструкций — это конструкция if. Она имеет следующее формальное определение:

В самом простом виде после ключевого слова if идет логическое выражение. И если это логическое выражение возвращает True, то выполняется последующий блок инструкций, каждая из которых должна начинаться с новой стоки и должна иметь отступы от начала строки:

Поскольку в данном случае значение переменной age больше 21, то будет выполняться блок if, а консоль выведет следующие строки:

Доступ разрешен

Завершение работы

Отступ желательно делать в 4 пробела или то количество пробелов, которое кратно 4.

Обратите внимание в коде на последнюю стоку, которая выводит сообщение «Завершение работы». Она не имеет отступов от начала строки, поэтому она не принадлежит к блоку if и будет выполняться в любом случае, даже если выражение в конструкции if возвратит False.

Но если бы мы поставили бы отступы, то она также принадлежала бы к конструкции if:

Если вдруг нам надо определить альтернативное решение на тот случай, если условное выражение возвратит False, то мы можем использовать блок else:

Если выражение age > 21 возвращает True, то выполняется блок if, иначе выполняется блок else.

Если необходимо ввести несколько альтернативных условий, то можно использовать дополнительные блоки elif, после которого идет блок инструкций.

Конструкция if в свою очередь сама может иметь вложенные конструкции if:

Стоит учитывать, что вложенные выражения if также должны начинаться с отступов, а инструкции во вложенных конструкциях также должны иметь отступы. Отступы, расставленные не должным образом, могут изменить логику программы. Так, предыдущий пример НЕ аналогичен следующему:

Теперь напишем небольшую программку, которая использует условные конструкции. Данная программка будет представлять собой своего рода обменный пункт:

С помощью функции input() получаем вводимые пользователем данные на консоль. Причем данная функция возвращает данные в виде строки, поэтому нам надо ее еще привести к целому числу с помощью функции int(), чтобы введенные данные можно было использовать в арифметических операциях.

Программа подразумевает, что пользователь вводит количество средств, которые надо обменять, и код валюты, на которую надо произвести обмен. Коды валюты достаточно условны: 400 для долларов и 401 для евро.

С помощью конструкции if проверяем код валюты и делим на соответствующий валютный курс. Так как в процессе деления образуется довольно длинное число с плавающей точкой, которое может содержать множество знаков после запятой, то оно округляется до двух чисел после запятой с помощью функции round().

В завершении на консоль выводится полученное значение. Например, запустим программу и введем какие-нибудь данные:

Введите сумму, которую вы хотите обменять: 20000

Укажите код валюты (доллары — 400, евро — 401): 401

Валюта: евро

К получению: 333.33

Циклы позволяют повторять некоторое действие в зависимости от соблюдения некоторого условия.

Первый цикл, который мы рассмотрим, это цикл while. Он имеет следующее формальное определение:

После ключевого слова while указывается условное выражение, и пока это выражение возвращает значение True, будет выполняться блок инструкций, который идет далее.

Все инструкции, которые относятся к циклу while, располагаются на последующих строках и должны иметь отступ от начала строки.

В данном случае цикл while будет продолжаться, пока переменная choice содержит латинскую букву «Y» или «y».

Сам блок цикла состоит из двух инструкций. Сначала выводится сообщение «Привет», а потом вводится новое значение для переменной choice. И если пользователь нажмет какую-то другую клавишу, отличную от Y, произойдет выход из цикла, так как условие choice.lower() == «y» вернет значение False. Каждый такой проход цикла называется итерацией.

Также обратите внимание, что последняя инструкция print(«Работа программы завешена») не имеет отступов от начала строки, поэтому она не входит в цикл while.

Дугой пример — вычисление факториала:

Здесь вводит с консоли некоторое число, и пока число-счетчик i не будет больше введенного числа, будет выполняться цикл, в котором происходит умножения числа factorial.

Введите число: 6

Факториал числа 6 равен 720

Другой тип циклов представляет конструкция for. Цикл for вызывается для каждого числа в некоторой коллекции чисел. Коллекция чисел создается с помощью функции range(). Формальное определение цикла for:

После ключевого слова for идет переменная int_var, которая хранит целые числа (название переменной может быть любое), затем ключевое слово in, вызов функции range() и двоеточие.

А со следующей строки располагается блок инструкций цикла, которые также должны иметь отступы от начала строки.

При выполнении цикла Python последовательно получает все числа из коллекции, которая создается функцией range, и сохраняет эти числа в переменной int_var. При первом проходе цикл получает первое число из коллекции, при втором — второе число и так далее, пока не переберет все числа. Когда все числа в коллекции будут перебраны, цикл завершает свою работу.

Рассмотрим на примере вычисления факториала:

Вначале вводим с консоли число. В цикле определяем переменную i, в которую сохраняются числа из коллекции, создаваемой функцией range.

Функция range здесь принимает два аргумента — начальное число коллекции (здесь число 1) и число, до которого надо добавлять числа (то есть number +1).

Допустим, с консоли вводится число 6, то вызов функции range приобретает следующую форму:

Эта функция будет создавать коллекцию, которая будет начинаться с 1 и будет последовательно наполняться целыми числами вплоть до 7. То есть это будет коллекция [1, 2, 3, 4, 5, 6].

При выполнении цикла из этой коллекции последовательно будут передаваться числа в переменную i, а в самом цикле будет происходить умножение переменной i на переменную factorial. В итоге мы получим факториал числа.

Консольный вывод программы:

Введите число: 6

Факториал числа 6 равен 720

Функция range имеет следующие формы:

range(stop): возвращает все целые числа от 0 до stop

range(start, stop): возвращает все целые числа в промежутке от start (включая) до stop (не включая). Выше в программе факториала использована именно эта форма.

range(start, stop, step): возвращает целые числа в промежутке от start (включая) до stop (не включая), которые увеличиваются на значение step

Примеры вызовов функции range:

Например, выведем последовательно все числа от 0 до 4:

Одни циклы внутри себя могут содержать другие циклы. Рассмотрим на примере вывода таблицы умножения:

Внешний цикл for i in range(1, 10) срабатывает 9 раз, так как в коллекции, возвращаемой функцией range, 9 чисел. Внутренний цикл for j in range(1, 10) срабатывает 9 раз для одной итерации внешнего цикла, и соответственно 81 раз для всех итераций внешнего цикла.

В каждой итерации внутреннего цикла на консоль будет выводится произведение чисел i и j. В итоге мы получим следующий консольный вывод:

1 2 3 4 5 6 7 8 9

2 4 6 8 10 12 14 16 18

3 6 9 12 15 18 21 24 27

4 8 12 16 20 24 28 32 36

5 10 15 20 25 30 35 40 45

6 12 18 24 30 36 42 48 54

7 14 21 28 35 42 49 56 63

8 16 24 32 40 48 56 64 72

9 18 27 36 45 54 63 72 81

Для управления циклом мы можем использовать специальные операторы break и continue. Оператор break осуществляет выход из цикла. А оператор continue выполняет переход к следующей итерации цикла.

Оператор break может использоваться, если в цикле образуются условия, которые несовместимы с его дальнейшим выполнением. Рассмотрим следующий пример:

Здесь мы имеем дело с бесконечным циклом, так как условие while True всегда истинно и всегда будет выполняться. Это популярный прием для создания программ, которые должны выполняться неопределенно долго.

В самом цикле получаем ввод с консоли. Мы предполагаем, что пользователь будет вводить число — условную сумму денег для обмена. Если пользователь вводит букву «Y» или «y», то с помощью оператора break выходим из цикла и прекращаем работу программы. Иначе делим введенную сумму на обменный курс, с помощью функции round округляем результат и выводим его на консоль. И так до бесконечности, пока пользователь не захочет выйти из программы, нажав на клавишу Y.

Консольный вывод программы:

Для выхода нажмите Y

Введите сумму для обмена: 20000

К выдаче 357.14 долларов

Введите сумму для обмена: Y

Работа обменного пункта завершена

Но что, если пользователь введет отрицательное число? В этом случае программа также выдаст отрицательный результат, что не является корректным поведением. И в этом случае перед вычислением мы можем проверить значение, меньше ли оно нуля, и если меньше, с помощью оператора continue выполнить переход к следующей итерации цикла без его завершения:

Также обращаю внимание, что для определения, относится ли инструкция к блоку while или к вложенной конструкции if, опять же используются отступы.

И в этом случае мы уже не сможем получить результат для отрицательной суммы:

Для выхода нажмите Y

Введите сумму для обмена: -20000

Сумма должна быть положительной!

Введите сумму для обмена: 20000

К выдаче 357.14 долларов

Введите сумму для обмена: y

Работа обменного пункта завершена

Функции представляют блок кода, который выполняет определенную задачу и который можно повторно использовать в других частях программы. Формальное определение функции:

Определение функции начинается с выражения def, которое состоит из имени функции, набора скобок с параметрами и двоеточия. Параметры в скобках необязательны. А со следующей строки идет блок инструкций, которые выполняет функция. Все инструкции функции имеют отступы от начала строки.

Например, определение простейшей функции:

Функция называется say_hello. Она не имеет параметров и содержит одну единственную инструкцию, которая выводит на консоль строку «Hello».

Для вызова функции указывается имя функции, после которого в скобках идет передача значений для всех ее параметров. Например:

Здесь три раза подряд вызывается функция say_hello. В итоге мы получим следующий консольный вывод:

Теперь определим и используем функцию с параметрами:

Функция принимает параметр name, и при вызове функции мы можем передать вместо параметра какой-либо значение:

Hello, Tom

Hello, Bob

Hello, Alice

Некоторые параметры функции мы можем сделать необязательными, указав для них значения по умолчанию при определении функции. Например:

Здесь параметр name является необязательным. И если мы не передаем при вызове функции для него значение, то применяется значение по умолчанию, то есть строка «Tom».

При передаче значений функция сопоставляет их с параметрами в том порядке, в котором они передаются. Например, пусть есть следующая функция:

При вызове функции первое значение «Tom» передается первому параметру — параметру name, второе значение — число 22 передается второму параметру — age. И так далее по порядку. Использование именованных параметров позволяет переопределить порядок передачи:

Именованные параметры предполагают указание имени параметра с присвоением ему значения при вызове функции.

С помощью символа звездочки можно определить неопределенное количество параметров:

В данном случае функция sum принимает один параметр — *params, но звездочка перед названием параметра указывает, что фактически на место этого параметра мы можем передать неопределенное количество значений или набор значений. В самой функции с помощью цикла for можно пройтись по этому набору и произвести с переданными значениями различные действия. Например, в данном случае возвращается сумма чисел.

Функция может возвращать результат. Для этого в функции используется оператор return, после которого указывается возвращаемое значение:

Поскольку функция возвращает значение, то мы можем присвоить это значение какой-либо переменной и затем использовать ее: result2 = exchange(56, 30000).

В Python функция может возвращать сразу несколько значений:

Здесь функция create_default_user возвращает два значения: name и age. При вызове функции эти значения по порядку присваиваются переменным user_name и user_age, и мы их можем использовать.

В программе может быть определено множество функций. И чтобы всех их упорядочить, хорошей практикой считается добавление специальной функции main, в которой потом уже вызываются другие функции:

Область видимости или scope определяет контекст переменной, в рамках которого ее можно использовать. В Python есть два типа контекста: глобальный и локальный.

Глобальный контекст подразумевает, что переменная является глобальной, она определена вне любой из функций и доступна любой функции в программе. Например:

Здесь переменная name является глобальной и имеет глобальную область видимости. И обе определенные здесь функции могут свободно ее использовать.

В отличие от глобальных переменных локальная переменная определяется внутри функции и доступна только из этой функции, то есть имеет локальную область видимости:

В данном случае в каждой из двух функций определяется локальная переменная name. И хотя эти переменные называются одинаково, но тем не менее это дву разных переменных, каждая из которых доступна только в рамках своей функции. Также в функции say_hi определена переменная surname, которая также является локальной, поэтому в функции say_bye мы ее использовать не сможем.

Есть еще один вариант определения переменной, когда локальная переменная скрывают глобальную с тем же именем:

Здесь определена глобальная переменная name. Однако в функции say_bye определена локальная переменная с тем же именем name. И если функция say_hi использует глобальную переменную, то функция say_bye использует локальную переменную, которая скрывает глобальную.

Если же мы хотим изменить в локальной функции глобальную переменную, а не определить локальную, то необходимо использовать ключевое слово global:

В Python, как и во многих других языках программирования, не рекомендуется использовать глобальные переменные. Единственной допустимой практикой является определение небольшого числа глобальных констант, которые не изменяются в процессе работы программы.

В данном случае число 3.14 представлено константой PI. Понятно, что это значение в принципе не изменится, поэтому его можно вынести из функций и определить в виде константы. Как правило, имя константы определяется заглавными буквами.

Модуль в языке Python представляет отдельный файл с кодом, который можно повторно использовать в других программах.

Для создания модуля необходимо создать собственно файл с расширением *.py, который будет представлять модуль. Название файла будет представлять название модуля. Затем в этом файле надо определить одну или несколько функций.

Пусть основной файл программы будет называться hello.py. И мы хотим подключить к нему внешние модули.

Для этого сначала определим новый модуль: создадим новый файл, который назовем account.py, в той же папке, где находится hello.py. Если используется PyCharm или другая IDE, то оба файла просто помещаются в один проект.

Соответственно модуль будет называться account. И определим в нем следующий код:

Здесь определена функция calculate_income, которая в качестве параметров получает процентную ставку вклада, сумму вклада и период, на который делается вклад, и высчитывает сумму, которая получится в конце данного периода.

В файле hello.py используем данный модуль:

Для использования модуля его надо импортировать с помощью оператора import, после которого указывается имя модуля: import account.

Чтобы обращаться к функциональности модуля, нам нужно получить его пространство имен. По умолчанию оно будет совпадать с именем модуля, то есть в нашем случае также будет называться account.

Получив пространство имен модуля, мы сможем обратиться к его функциям по схеме пространство_имен.функция:

account.calculate_income(rate, money, period)

И после этого мы можем запустить главный скрипт hello.py, и он задействует модуль account.py. В частности, консольный вывод мог бы быть следующим:

Введите процентную ставку: 10Введите сумму: 300000Введите период ведения счета в месяцах: 6Параметры счета: Сумма: 300000 Ставка: 10 Период: 6 Сумма на счете в конце периода: 315315.99

По умолчанию при импорте модуля он доступен через одноименное пространство имен. Однако мы можем переопределить это поведение. Так, ключевое слово as позволяет сопоставить модуль с другим пространством имен. Например:

В данном случае пространство имен будет называться acc.

Другой вариант настройки предполагает импорт функциональности модуля в глобальное пространство имен текущего модуля с помощью ключевого слова from:

В данном случае мы импортируем из модуля account в глобальное пространство имен функцию calculate_income. Поэтому мы сможем ее использовать без указания пространства имен модуля как если бы она была определена в этом же файле.

Если бы в модуле account было бы несколько функций, то могли бы их импортировать в глобальное пространство имен одним выражением:

Но стоит отметить, что импорт в глобальное пространство имен чреват коллизиями имен функций. Например, если у нас том же файле определена функция с тем же именем, то при вызове функции мы можем получить ошибку. Поэтому лучше избегать использования импорта в глобальное пространство имен.

В примере выше модуль hello.py, который является главным, использует модуль account.py. При запуске модуля hello.py программа выполнит всю необходимую работу. Однако, если мы запустим отдельно модуль account.py сам по себе, то ничего на консоли не увидим. Ведь модуль просто определяет функцию и невыполняет никаких других действий. Но мы можем сделать так, чтобы модуль account.py мог использоваться как сам по себе, так и подключаться в другие модули.

При выполнении модуля среда определяет его имя и присваивает его глобальной переменной __name__ (с обеих сторон два подчеркивания). Если модуль является запускаемым, то его имя равно __main__ (также по два подчеркивания с каждой стороны). Если модуль используется в другом модуле, то в момент выполнения его имя аналогично названию файла без расширения py. И мы можем это использовать. Так, изменим содержимое файла account.py:

Кроме того, для тестирования функции определена главная функция main. И мы можем сразу запустить файл account.py отдельно от всех и протестировать код.

Следует обратить внимание на вызов функции main:

Переменная __name__ указывает на имя модуля. Для главного модуля, который непосредственно запускается, эта переменная всегда будет иметь значение __main__ вне зависимости от имени файла.

Поэтому, если мы будем запускать скрипт account.py отдельно, сам по себе, то Python присвоит переменной __name__ значение __main__, далее в выражении if вызовет функцию main из этого же файла.

Однако если мы будем запускать другой скрипт, а этот — account.py — будем подключать в качестве вспомогательного, для account.py переменная __name__ будет иметь значение account. И соответственно метод main в файле account.py не будет работать.

Данный подход с проверкой имени модуля является более рекомендуемым подходом, чем просто вызов метода main.

В файле hello.py также можно сделать проверку на то, является ли модуль главным (хотя в прицнипе это необязательно):

При программировании на Python мы можем столкнуться с двумя типами ошибок. Первый тип представляют синтаксические ошибки (syntax error). Они появляются в результате нарушения синтаксиса языка программирования при написании исходного кода. При наличии таких ошибок программа не может быть скомпилирована. При работе в какой-либо среде разработки, например, в PyCharm, IDE сама может отслеживать синтаксические ошибки и каким-либо образом их выделять.

Второй тип ошибок представляют ошибки выполнения (runtime error). Они появляются в уже скомпилированной программе в процессе ее выполнения. Подобные ошибки еще называются исключениями. Например, в прошлых темах мы рассматривали преобразование числа в строку:

Данный скрипт успешно скомпилируется и выполнится, так как строка «5» вполне может быть конвертирована в число. Однако возьмем другой пример:

При выполнении этого скрипта будет выброшено исключение ValueError, так как строку «hello» нельзя преобразовать в число. С одной стороны, здесь очевидно, сто строка не представляет число, но мы можем иметь дело с вводом пользователя, который также может ввести не совсем то, что мы ожидаем:

При возникновении исключения работа программы прерывается, и чтобы избежать подобного поведения и обрабатывать исключения в Python есть конструкция try..except, которая имеет следующее формальное определение:

try:

инструкции

except [Тип_исключения]:

инструкции

Весь основной код, в котором потенциально может возникнуть исключение, помещается после ключевого слова try. Если в этом коде генерируется исключение, то работа кода в блоке try прерывается, и выполнение переходит в блок except.

После ключевого слова except опционально можно указать, какое исключение будет обрабатываться (например, ValueError или KeyError). После слова except на следующей стоке идут инструкции блока except, выполняемые при возникновении исключения.

Рассмотрим обработку исключения на примере преобразовании строки в число:

Введите число: hello

Преобразование прошло неудачно

Завершение программы

Как видно из консольного вывода, при вводе строки вывод числа на консоль не происходит, а выполнение программы переходит к блоку except.

Вводим правильное число:

Введите число: 22

Введенное число: 22

Завершение программы

Теперь все выполняется нормально, исключение не возникает, и соответственно блок except не выполняется.

В примере выше обрабатывались сразу все исключения, которые могут возникнуть в коде. Однако мы можем конкретизировать тип обрабатываемого исключения, указав его после слова except:

Если ситуация такова, что в программе могут быть сгенерированы различные типы исключений, то мы можем их обработать по отдельности, используя дополнительные выражения except:

Если возникнет исключение в результате преобразования строки в число, то оно будет обработано блоком except ValueError. Если же второе число будет равно нулю, то есть будет деление на ноль, тогда возникнет исключение ZeroDivisionError, и оно будет обработано блоком except ZeroDivisionError.

Тип Exception представляет общее исключение, под которое попадают все исключительные ситуации. Поэтому в данном случае любое исключение, которое не представляет тип ValueError или ZeroDivisionError, будет обработано в блоке except Exception:.

При обработке исключений также можно использовать необязательный блок finally. Отличительной особенностью этого блока является то, что он выполняется вне зависимости, было ли сгенерировано исключение:

Как правило, блок finally применяется для освобождения используемых ресурсов, например, для закрытия файлов.

С помощью оператора as мы можем передать всю информацию об исключении в переменную, которую затем можно использовать в блоке except:

Пример некорректного ввода:

Введите число: fdsf

Сведения об исключении invalid literal for int() with base 10: ‘fdsf’

Завершение программы

Иногда возникает необходимость вручную сгенерировать то или иное исключение. Для этого применяется оператор raise.

При вызове исключения мы можем ему передать сообщение, которое затем можно вывести пользователю:

Введите первое число: 1

Введите второе число: 0

Второе число не должно быть равно 0

Завершение программы

Как называется инструкция которая определяет данные соответствующие переменной python

Итак,
рассмотрим, из чего состоят программы на языке Python. Любая программа на языке
Python состоит из модулей. Модуль на языке Python представляет собой ряд
связанных между собой операций. Модули сохраняются в отдельных файлах с
расширением *.py.
Сохранённые модули можно использовать в создаваемых программах. Сначала мы
будем разрабатывать довольно простые программы, которые практически всегда
будут состоять всего из одного модуля.

Модули,
в свою очередь, состоят из более простых структурных единиц. В модулях
содержится код на языке Python, состоящий из инструкций. Инструкции
представляют собой указания компьютеру. Они определяют, какие операции выполнит
компьютер с данными. Инструкции в языке Python делятся на простые и составные.
Простые инструкции описываются одной строкой кода, составные же – содержат вложенные
инструкции.

Инструкции
могут содержать выражения. И если инструкции определяют, какие действия
будут выполнены над информацией, то выражения в составе инструкций определяют,
над какими именно данными будут выполнены действия, описанные в инструкции.

Вместе
с языком Python поставляется множество стандартных модулей, которые
предоставляют программисту большое количество инструментов и возможностей для
написания самых разных программ.

Рассмотрим
пример. Находясь в интерактивном режиме среды разработки, создадим новый файл,
в котором запишем несколько инструкций. Сохраним его под именем modul_1.py.
Запишем в файле инструкцию вывода print
(2 * (10 – 4)). Сохраним файл и запустим инструкцию на
выполнение. В главном окне среды разработки было выведено значение записанного
нами выражения, то есть 12.

В
описанном нами примере, файл modul_1.py
является
модулем, строка, записанная нами в этом файле, является инструкцией, а
математическое выражение, записанное в скобках, является выражением.

Рассмотрим,
что такое операции. Операциями в языках программирования называются
любые действия над операндами. Операндами называются некоторые данные.
Для примера рассмотрим операции, используемые в описанном нами математическом
выражении. Всего их две: разность и умножение. Операндами для операции разности
являются числа: 10 и 4. Операндами для операции умножения
являются число 2 и разность чисел 10 и 4. Установив скобки
в этом выражении, мы определили порядок выполнения операций. Сначала будет
выполнена операция разности, записанная в скобках, после чего её результат
будет использован в качестве операнды при выполнении умножения. Приоритет
выполнения операций в языке Python соответствует математическому.

Операндами
для операций могут быть литералы, выражения и переменные.
В описанном нами примере операндами разности являются литералы, то есть числа,
которые записаны при написании кода, а для операции умножения – литерал, то
есть число 2, а также выражение, то есть разность чисел 10 и 4.
Операндами могут быть и переменные. Независимо от языка программирования,
переменной называется именованная область оперативной памяти, в которой хранится
информация определённого типа. Механизм связи между переменной и данными,
которые она содержит, может отличаться в зависимости от языка программирования.
Пока просто запомним, что данные, сохранённые в переменной, связаны с некоторым
именем и могут быть вызваны по этому имени.

Данные,
которые соответствуют переменной в языке Python, могут быть определены с
помощью инструкции присваивания. Инструкция присваивания в языке Python
записывается с помощью знака равенства, слева от которого находится имя
переменной, а справа – её значение. То есть, чтобы переменной а
присвоить значение 4, мы должны записать строку кода: а = 4.

Рассмотрим
пример. В среде разработки языка Python, в интерактивном режиме, присвоим переменной
t значение 15, после чего убедимся,
что операция выполнена. Для этого запишем строку кода: t = 15
и нажмём клавишу Enter.
Операция присваивания уже была выполнена – убедимся в этом. Для этого запишем
инструкцию print (t) для вывода значения
переменной t на
экран. Таким образом, мы убедились, что переменная t
имеет
значение 15. Важно запомнить, что переменную стоит называть осмысленно, её имя
не должно совпадать со служебными словами языка или содержать служебные
символы; имя переменной не может начинаться с цифры.

Рассмотрим,
какие типы данных используются в языке программирования Python. Во время
написания программ мы будем использовать всего четыре основных типа данных: целые
числа – int, вещественные числа – float
и символьные строки – str.
К целым числам относятся числа без дробной части, например: 0, 7, — 12 и т. д…
К вещественным числам относятся числа с дробной частью, например: 3.5, — 6.7 и
так далее… К символьным строкам относятся любые последовательности символов.
При вводе они заключаются в двойные или одинарные кавычки.

Те
из вас, кто до этого использовал другие языки программирования, например Pascal,
знают, что прежде чем использовать переменную в программе, её нужно объявить.
При этом, за переменной закрепляется ячейка оперативной памяти, а также
указывается тип данных, которые будут на ней храниться. Возможно, многие из вас
обратили внимание на то, что при написании кода для демонстрации работы
оператора присваивания, мы не объявляли переменную Тэ, прежде чем присвоить ей
значение. Так происходит потому, что в языке Python переменная объявляется
автоматически перед первым использованием. Тогда у многих из вас может
возникнуть вопрос: «Как определяется тип переменной? Ведь его мы тоже не
указывали». В отличие от всё того же языка Pascal,
в языке Python используется динамическая типизация. Что это означает? В
языке Python тип переменной определяется автоматически, в зависимости от
присвоенного ей значения, а так как значение переменной в ходе исполнения
программы может изменяться, то и тип переменной также изменяется вслед за
значением.

Как
же определить, какой тип имеет переменная на данный момент? Для этого в языке Python
есть функция type.
Посмотрим, как она работает. В среде разработки языка Python, в интерактивном
режиме, сначала присвоим переменной a
значение 4, после чего запишем инструкцию type
(a).
На экран был выведен результат выполнения инструкции. В угловых скобках
записано слово type,
после которого в одинарных кавычках следует тип переменной – int.
Теперь присвоим переменной a
значение -5.7. В языке Python дробная
часть числа отделяется от целой точкой. Теперь снова запишем инструкцию type
(a).
Как видим, тип переменной a
изменился на float.
Теперь присвоим переменной a
символьную строку. Для этого, после знака равенства, в двойных или одинарных
кавычках запишем любую последовательность символов, например, слово «Привет».
Теперь снова запишем инструкцию type
(a).
Тип переменной a изменился на str.
Для того, чтобы задать число с нулевой дробной частью как вещественное,
достаточно просто указать его дробную часть равной нулю. Присвоим переменной a
значение 4.0, после чего запишем инструкцию type
(a).
Как видим, тип переменной a
стал float. Важно запомнить,
что значения строкового типа не могут употребляться в одном выражении со
значениями одного из числовых типов, иначе результатом попытки выполнения
инструкции будет сообщение об ошибке.

Решим
задачу. Написать модуль, в котором переменным a
и b присваиваются значения
соответственно равные 8.5 и 6, а переменной c
– значение суммы a и b.
После чего выводятся на экран значения переменной c,
разности a и b,
их произведения, частного, а также a b .

Создадим
файл модуля, после чего сохраним его. Начнём написание инструкций. В начале
запишем инструкцию для присваивания переменной a
значения 8.5. После этого, запишем инструкцию для присваивания переменной b
значения 6, а также инструкцию присваивания переменной c
значения суммы a и b.
Дальше напишем инструкцию print,
после которой будут следовать пустые скобки. Скопируем эту инструкцию четыре
раза (по количеству выражений, результаты которых необходимо вывести). В первой
инструкции print в скобках запишем
c, во второй – a
–
b, в третьей – a
*
b, в четвёртой – a
/
b и в пятой – a
**
b.

После
того как все инструкции записаны, сохраним модуль и запустим его на выполнение.
В главном окне среды разработки в пяти строках было выведено пять чисел –
результаты перечисленных операций. Модуль работает правильно. Задача решена.

Обратим
внимание на то, как выполняются инструкции присваивания в написанном нами
модуле. При выполнении первой инструкции сначала выделяется ячейка оперативной
памяти для переменной a,
после чего проверяется литерал 8.5. Это вещественное число, поэтому тип
переменной становится float.
Далее в ячейку оперативной памяти заносится значение литерала 8.5. Вторая
инструкция выполняется так же, с той лишь разницей, что литерал 6 является
целым числом и тип переменной b
будет int. При выполнении третьей
инструкции присваивания сначала из оперативной памяти извлекаются значения
переменных a и b,
после чего вычисляется значение их суммы. Далее для переменной c
выделяется ячейка оперативной памяти. Так как результатом операции сложения
является вещественное число, тип переменной c
становится float. В созданную
ячейку оперативной памяти заносится результат суммы, то есть четырнадцать целых
пять десятых.

· Программа
на языке Python состоит из модулей, которые, в свою
очередь, состоят из инструкций, которые могут содержать выражения.

· Операцией
называется любое действие над данными.

· Переменной
называется именованная область оперативной памяти, содержащая данные
определённого типа.

· В
языке Python есть три основных типа данных: целые числа – int,
вещественные числа – float,
а также строки символов – str.

· В
языке Python переменные объявляются автоматически при первом использовании.

· Тип
данных, хранящихся в переменной, изменяется в ходе исполнения программы в зависимости
от того, какое значение присваивается переменной. Этот принцип называется динамической
типизацией.

Переменные

JavaScript-приложению обычно нужно работать с информацией. Например:

1. Интернет-магазин – информация может включать продаваемые товары и корзину покупок.
2. Чат – информация может включать пользователей, сообщения и многое другое.

Переменные используются для хранения этой информации.

Переменная

Переменная – это «именованное хранилище» для данных. Мы можем использовать переменные для хранения товаров, посетителей и других данных.

Для создания переменной в JavaScript используйте ключевое слово let .

Приведённая ниже инструкция создаёт (другими словами: объявляет или определяет) переменную с именем «message»:

Теперь можно поместить в неё данные, используя оператор присваивания = :

Строка сохраняется в области памяти, связанной с переменной. Мы можем получить к ней доступ, используя имя переменной:

Для краткости можно совместить объявление переменной и запись данных в одну строку:

Мы также можем объявить несколько переменных в одной строке:

Такой способ может показаться короче, но мы не рекомендуем его. Для лучшей читаемости объявляйте каждую переменную на новой строке.

Многострочный вариант немного длиннее, но легче для чтения:

Некоторые люди также определяют несколько переменных в таком вот многострочном стиле:

…Или даже с запятой в начале строки:

В принципе, все эти варианты работают одинаково. Так что это вопрос личного вкуса и эстетики.

В старых скриптах вы также можете найти другое ключевое слово: var вместо let :

Ключевое слово var – почти то же самое, что и let . Оно объявляет переменную, но немного по-другому, «устаревшим» способом.

Есть тонкие различия между let и var , но они пока не имеют для нас значения. Мы подробно рассмотрим их в главе Устаревшее ключевое слово «var».

Аналогия из жизни

Мы легко поймём концепцию «переменной», если представим её в виде «коробки» для данных с уникальным названием на ней.

Например, переменную message можно представить как коробку с названием «message» и значением «Hello!» внутри:

Мы можем положить любое значение в коробку.

Мы также можем изменить его столько раз, сколько захотим:

При изменении значения старые данные удаляются из переменной:

Мы также можем объявить две переменные и скопировать данные из одной в другую.

Переменная может быть объявлена только один раз.

Повторное объявление той же переменной является ошибкой:

Поэтому следует объявлять переменную только один раз и затем использовать её уже без let .

Примечательно, что существуют функциональные языки программирования, такие как Scala или Erlang, которые запрещают изменять значение переменной.

В таких языках однажды сохранённое «в коробку» значение остаётся там навсегда. Если нам нужно сохранить что-то другое, язык заставляет нас создать новую коробку (объявить новую переменную). Мы не можем использовать старую переменную.

Хотя на первый взгляд это может показаться немного странным, эти языки вполне подходят для серьёзной разработки. Более того, есть такая область, как параллельные вычисления, где это ограничение даёт определённые преимущества. Изучение такого языка (даже если вы не планируете использовать его в ближайшее время) рекомендуется для расширения кругозора.

Имена переменных

В JavaScript есть два ограничения, касающиеся имён переменных:

1. Имя переменной должно содержать только буквы, цифры или символы $ и _ .
2. Первый символ не должен быть цифрой.

Примеры допустимых имён:

Если имя содержит несколько слов, обычно используется верблюжья нотация, то есть, слова следуют одно за другим, где каждое следующее слово начинается с заглавной буквы: myVeryLongName .

Самое интересное – знак доллара ‘$’ и подчёркивание ‘_’ также можно использовать в названиях. Это обычные символы, как и буквы, без какого-либо особого значения.

Эти имена являются допустимыми:

Примеры неправильных имён переменных:

Переменные с именами apple и APPLE – это две разные переменные.

Можно использовать любой язык, включая кириллицу или даже иероглифы, например:

Технически здесь нет ошибки, такие имена разрешены, но есть международная традиция использовать английский язык в именах переменных. Даже если мы пишем небольшой скрипт, у него может быть долгая жизнь впереди. Людям из других стран, возможно, придётся прочесть его не один раз.

Существует список зарезервированных слов, которые нельзя использовать в качестве имён переменных, потому что они используются самим языком.

Например: let , class , return и function зарезервированы.

Приведённый ниже код даёт синтаксическую ошибку:

Обычно нам нужно определить переменную перед её использованием. Но в старые времена было технически возможно создать переменную простым присвоением значения без использования let . Это все ещё работает, если мы не включаем use strict в наших файлах, чтобы обеспечить совместимость со старыми скриптами.

Это плохая практика, которая приводит к ошибке в строгом режиме:

Константы

Чтобы объявить константную, то есть, неизменяемую переменную, используйте const вместо let :

Переменные, объявленные с помощью const , называются «константами». Их нельзя изменить. Попытка сделать это приведёт к ошибке:

Если программист уверен, что переменная никогда не будет меняться, он может гарантировать это и наглядно донести до каждого, объявив её через const .

Константы в верхнем регистре

Широко распространена практика использования констант в качестве псевдонимов для трудно запоминаемых значений, которые известны до начала исполнения скрипта.

Названия таких констант пишутся с использованием заглавных букв и подчёркивания.

Например, сделаем константы для различных цветов в «шестнадцатеричном формате»:

• COLOR_ORANGE гораздо легче запомнить, чем «#FF7F00» .
• Гораздо легче допустить ошибку при вводе «#FF7F00» , чем при вводе COLOR_ORANGE .
• При чтении кода COLOR_ORANGE намного понятнее, чем #FF7F00 .

Когда мы должны использовать для констант заглавные буквы, а когда называть их нормально? Давайте разберёмся и с этим.

Название «константа» просто означает, что значение переменной никогда не меняется. Но есть константы, которые известны до выполнения (например, шестнадцатеричное значение для красного цвета), а есть константы, которые вычисляются во время выполнения сценария, но не изменяются после их первоначального назначения.

Значение pageLoadTime неизвестно до загрузки страницы, поэтому её имя записано обычными, а не прописными буквами. Но это всё ещё константа, потому что она не изменяется после назначения.

Другими словами, константы с именами, записанными заглавными буквами, используются только как псевдонимы для «жёстко закодированных» значений.

Придумывайте правильные имена

В разговоре о переменных необходимо упомянуть, что есть ещё одна чрезвычайно важная вещь.

Название переменной должно иметь ясный и понятный смысл, говорить о том, какие данные в ней хранятся.

Именование переменных – это один из самых важных и сложных навыков в программировании. Быстрый взгляд на имена переменных может показать, какой код был написан новичком, а какой – опытным разработчиком.

В реальном проекте большая часть времени тратится на изменение и расширение существующей кодовой базы, а не на написание чего-то совершенно нового с нуля. Когда мы возвращаемся к коду после какого-то промежутка времени, гораздо легче найти информацию, которая хорошо размечена. Или, другими словами, когда переменные имеют хорошие имена.

Пожалуйста, потратьте время на обдумывание правильного имени переменной перед её объявлением. Делайте так, и будете вознаграждены.

Несколько хороших правил:

• Используйте легко читаемые имена, такие как userName или shoppingCart .
• Избегайте использования аббревиатур или коротких имён, таких как a , b , c , за исключением тех случаев, когда вы точно знаете, что так нужно.
• Делайте имена максимально описательными и лаконичными. Примеры плохих имён: data и value . Такие имена ничего не говорят. Их можно использовать только в том случае, если из контекста кода очевидно, какие данные хранит переменная.
• Договоритесь с вашей командой об используемых терминах. Если посетитель сайта называется «user», тогда мы должны называть связанные с ним переменные currentUser или newUser , а не, к примеру, currentVisitor или newManInTown .

Звучит просто? Действительно, это так, но на практике для создания описательных и кратких имён переменных зачастую требуется подумать. Действуйте.

И последняя заметка. Есть ленивые программисты, которые вместо объявления новых переменных повторно используют существующие.

В результате их переменные похожи на коробки, в которые люди бросают разные предметы, не меняя на них этикетки. Что сейчас находится внутри коробки? Кто знает? Нам необходимо подойти поближе и проверить.

Такие программисты немного экономят на объявлении переменных, но теряют в десять раз больше при отладке.

Дополнительная переменная – это добро, а не зло.

Современные JavaScript-минификаторы и браузеры оптимизируют код достаточно хорошо, поэтому он не создаёт проблем с производительностью. Использование разных переменных для разных значений может даже помочь движку оптимизировать ваш код.

Итого

Мы можем объявить переменные для хранения данных с помощью ключевых слов var , let или const .

• let – это современный способ объявления.
• var – это устаревший способ объявления. Обычно мы вообще не используем его, но мы рассмотрим тонкие отличия от let в главе Устаревшее ключевое слово «var» на случай, если это всё-таки вам понадобится.
• const – похоже на let , но значение переменной не может изменяться.

Переменные должны быть названы таким образом, чтобы мы могли легко понять, что у них внутри.

Задачи

Работа с переменными

1. Объявите две переменные: admin и name .
2. Запишите строку «Джон» в переменную name .
3. Скопируйте значение из переменной name в admin .
4. Выведите на экран значение admin , используя функцию alert (должна показать «Джон»).

В коде ниже каждая строка решения соответствует одному элементу в списке задач.