ЛАБОРАТОРНАЯ РАБОТА №1

Тема: Основы языка Python

Цель: Рассмотрение среды разработки, типов данных, операторов и функций вывода и ввода данных

ОГЛАВЛЕНИЕ

Введение
1 Среда разработки
1.1 Программирование в интерактивном режиме
1.2 Использование встроенной системы помощи
1.3 Программирование в сценарном режиме
1.3.1 Описание панели инструментов
1.3.2 Работа в сценарном режиме
2 Использование специальных методов
3 Понятие объекта
3.1 Идентичность объектов
3.2 Типы объектов
3.3 Значения объектов
4 Встроенные типы данных
4.1 Числа
4.1.1 Целые числа
4.1.2 Числа с плавающей точкой
4.1.3 Комплексные числа
4.1.4 Операции с числами
4.1.5 Функции для работы с числами
4.1.6 Побитовые операции над целыми числами
4.2 Логический тип
4.3 Проверка типа объекта
5 Ввод и вывод данных
5.1 Функция print()
5.2 Функция input()
6 Операторы
6.1 Оператор присваивания
6.2 Условный оператор
6.3 Оператор цикла while
6.4 Оператор pass
7 Приоритет операций
8 Встроенные идентификаторы
8.1 Встроенные функции
8.2 Встроенные константы
Индивидуальные задания

Оглавление

Введение

Python – мощный и простой в использовании язык программирования, разработанный Гвидо ван Россумом (Guido van Rossum) в 1991 году. Название языка произошло не от вида пресмыкающихся. Автор назвал язык в честь популярного британского комедийного телешоу 1970-х годов «Летающий цирк Монти Пайтона». Тем не менее название языка чаще ассоциируют именно со змеей, нежели с фильмом – пиктограммы файлов в Microsoft Windows изображают змеиные головы.
Отличительными особенностями языка Python являются:

Таким образом, Python – это язык программирования, известный своей простотой и элегантностью исходного кода, эффективностью, а также поддержкой выдающегося сообщества программистов. Благодаря наличию невероятного количества качественных библиотек, Python широко используется в разных областях от применения в NASA и CERN, процессинга электронных платежей и до создания популярных онлайн игр.
При изучении языка Python помимо рассмотрения материала, изложенного в данном лабораторном практикуме, а также в других литературных источниках, полезно ознакомится со следующей документацией языка Python версии 3.6.0:

Ссылки на документацию языка Python 3.6.0 можно также получить, находясь в среде разработки IDLE (см. подразделы 1.1 и 1.3), по нажатию клавиши F1.

Оглавление

1 Среда разработки

В комплект поставки Python входит интегрированная среда разработки IDLE (Integrated DeveLopment Environment), в которой редактирование программы выполняется намного удобнее, чем в простом текстовом редакторе или терминале. IDLE также имеет встроенную систему отладки, позволяющую запускать программу построчно, что облегчает процесс поиска ошибок.
IDLE написана на языке Python с использованием GUI-инструментария tkinter, поэтому легко запускается в любой операционной системе, для которой существует реализация Python.
Графический пользовательский интерфейс GUI (Graphical User Interface) – это разновидность пользовательского интерфейса, в котором элементы интерфейса (меню, кнопки, значки, списки и т. п.), представленные пользователю на дисплее, исполнены в виде графических изображений. В отличие от интерфейса командной строки (типа старого DOS системы Windows), в GUI пользователь имеет свободный доступ ко всем элементам интерфейса экрана и может ими управлять с помощью клавиатуры или мыши (см. раздел 1 лаб. раб. №13).
Отличительные черты среды IDLE Python:

Таким образом IDLE Python является интерактивным интерпретатором. Интегрированная среда разработки имеет два основных режима работы:

Оглавление

1.1 Программирование в интерактивном режиме

Для запуска интерактивной сессии необходимо выбрать IDLE (Python GUI) в меню Пуск или на панели задач. На экране появится окно Shell (Python 3.6.0 Shell), содержащее:

Интерактивный режим можно использовать в качестве калькулятора: например, набрав после приглашения 2+3 и нажав Enter, получаем на экране:

>>> 2+3
5

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

>>> # Вывод данных на экран
>>> print "Hello,world!"

Первая сторока начинается с символа # и является комментарием, который не обрабатывается интерпретатором. Комментарий продолжается до конца строки (т.е в языке Python все комментарии являются однострочными, при этом не допускается использование перед символом # кавычек.
Вторая строка осуществляет вывод сообщения в окно среды разработки. После нажатия клавиши Enter программа начнет выполняться. На экран выводится сообщение о найденной синтаксической ошибке:

>>> SyntaxError: Missing parentheses in call to 'print'

Ошибка возникла из-за того, что для вывода на экран сообщения был использован оператор print, который применяется только в версиях языка Python до 3.x. Версии 3.x обратно не совместимы с версиями 2.x. Об отличиях версии 3.0 от 2.x см. http://docs.python.org/3/whatsnew/3.0.html).
Для версий 3.x языка Python вместо оператора print необходиммо использовать встроенную (built-in) функцию print() (описание встроенных функций см. в http://docs.python.org/3/library/functions.html, а также в подразделе 8.1). Описание функции print() приведено в подразделе 5.1. В данном примере функция вызывается с единственным аргументом, который указывает данные, выводимые на экран:

>>> # Вывод данных на экран
>>> print ( "Hello,world!" )

После запуска программы на экране появляется сообщение:

Hello,world!

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

Оглавление

1.2 Использование встроенной системы помощи

Помимо справочной информации о языке Python, которую можно получить из внешних источников (см. Введение), интерпретатор имеет внутреннюю систему оказания помощи, реализованную в виде встроенной функции help([object]), которая используется в интерактивном режиме. Если ни один аргумент функции не задан:

>>> help (),

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

Welcome to Python 3.3! This is the interactive help utility.

. . .

or summary contain a given string such as "spam", type "modules spam".

help>

Приведем сокращенный перевод этого текста.

После приветствия указывается о необходимости изучения документации по языку Python и сообщается как получить помощь. Для этого после выведенного на экран приглашения для ввода (help>) необходимо ввести имя любого модуля (англ. module), ключевого слова (англ. keyword), символа (англ. symbol) или темы (англ. topics). Чтобы получить список доступных модулей, ключевых слов, символов или тем языка Python, необходимо ввести соответственно "modules", "keywords", "symbols" или "topics". Для выхода из интерактивного режима помощи в интерактивный режим интерпретатора неоюбходимо ввести "quit".

Например, для получения полного списка ключевых слов языка необходимо указать "keywords":

help> "keywords"

Here is a list of the Python keywords. Enter any keyword to get more help.

False def if raise
None del import return
True elif in try
and else is while
as except lambda with
assert finally nonlocal yield
break for not
class from or
continue global pass

help>

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

help> quit

После этого следует небольшой текст, сообщающий о том, что осуществлен переход к интерпретатору языка Python.
Если необходимо получить справку о некотором объекте, нужно вызвать функцию help() с указанием имени объекта в качестве ее аргумента. Например, для получения справочной информации о функции print() необходимо вызвать help("print"):

>>> help ( "print" )

На экране появляется информация о назначении функции и ее аргументах:

Help on built-in function print in module builtins:

print(...)
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

Prints the values to a stream, or to sys.stdout by default.
Optional keyword arguments:
file: a file-like object (stream); defaults to the current sys.stdout.
sep: string inserted between values, default a space.
end: string appended after the last value, default a newline.
flush: whether to forcibly flush the stream.

На русском языке эта информация приведена в подразделе 5.1 при описании функции print().
Укажем, что система помощи работает для модулей, классов и функций, только если те были снабжены строками документации (см. объявления функции и класса соответственно в подразделах 1.1 лаб. раб. №6 и 1.1 лаб. раб. №11).
Отметим, что для получения информации о возможностях и режимах работы самой среды IDLE необходимо воспользоваться пунктом "IDLE help" меню "help" панели инструментов (см. подраздел 1.3.1).
Кроме встроенной, для языка Python существуют и улучшенные интерактивные оболочки, напримр, IPython и bpython.

Оглавление

1.3 Программирование в сценарном режиме

При работе в интерактивном режиме система отвечает мгновенно. С одной стороны это хорошо, так как сразу можно видеть результат. Но для создания программ, которые сохранялись бы в памяти и могли быть запущены позднее, этот режим не подходит. Для этой цели в среде разработки предусмотрен сценарный режим (см. подраздел 1.3.2 ). В нем можно создавать, редактировать, загружать и сохранять программу.

Оглавление

1.3.1 Описание панели инструментов

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

Оглавление

1.3.2 Работа в сценарном режиме

В сценарный режим можно перейти из интерактивного, выбрав в меню File пункт New Window (Cntr+N) (см. подраздел 1.3.1). Появляется новое окно "Edit". В нем необходимо создать текст программы, например,

# -*- coding utf-8 -*-
print ( "Hello, world!" )

Затем, выбрав в меню File пункт Save As, задать путь к файлу, который будет содержать программу, указав расширение .py, например, 1.py, и нажать Сохранить.
Если первой строкой кода является строка указанного в примере вида, т.е. начинающаяся с символов # -*- . . . , она указывает кодировку, в которой был создан текст программы – в данном случае в кодировке UTF-8 (от англ. Unicode Transformation Format, 8-bit — «формат преобразования Юникода, 8-битный») — одна из общепринятых и стандартизированных кодировок текста, которая позволяет хранить символы Юникода, используя переменное количество байт (от 1 до 6).
В версиях Python 3.x все символы по умолчанию представляются в кодировке Юникода (см. раздел 2.2.3 лаб. раб. №2), в отличие от версий Python 2.x, в которых такой кодировкой яляляется ASCII. Поэтому требуется преобразовать тексты всех внешних файлов, в том числе и программ, в кодировку UTF-8. Например, если текст программы был создан в кодировке cp-1252 (window-1252), то необходимо в первой строке кода указать:

# -*- coding cp-1252 -*- .

Ддя внешних файлов, созданных текстовыми редакторами в кодировке UTF-8 (в том числе при разработке программ с использованием интегрированной среды разработки IDLE) задание в первой строке кодировки:

# -*- coding utf-8 -*-

не является обязательным (предполагается заданным по умолчанию) и в последующих примерах использоваться не будет.
Отметим, что в тех случаях, когда в программе необходимо указать путь к интерпретатору, например при использовании скриптов на языке Python в качестве серверных приложений, первая строка кода должна указывать путь к интерпретатору (см. подраздел 2.2.3 лаб. раб. №10), а кодировка текста (при необходимости) будет указываться во второй строке.
Для запуска программы с предварительной проверкой нужно выбрать пункт Run Module в меню Run или нажать F5. В окне Shell добавляется строка RESTART и результат работы программы:

>>> ================================ RESTART ================================
Hello,world!

Для последующего запуска этой программы из интерактивного режима необходимо, выбрав в меню File пункт Open, загрузить программу 1.py в окно "Edit" и запустить ее на выполнение, как было указано выше.
Если по результатам выполнения программы необходимо внести в нее изменения, то они вносятся в окне "Edit" и сохраняются в памяти путем выбора в меню File пункта Save.
Однако, если попытаться запустить эту программу не из среды разработки Python, а по двойному щелчку мышки по файлу с расширением .py, то на экране промелькнет консольное окно и исчезнет. Чтобы удержать результат работы программы на экране, необходимо добавить в программу функцию input():

print ( "Hello, world!" )
input ( "Для завершения программы нажмите Enter" )

Описание функции input() приведено в подразделе 5.2.
Отметим, что одновременное использование интерактивного и сценарного режимов при создании и отладке программы создает предпосылки для наиболее эффективной и качественной работы.

Оглавление

2 Использование специальных методов

В языке Python знаки подчеркивания (англ. underscores) помимо обычного использования в идентификаторах подобно другим языкам программирования (см. подраздел 6.1) имеют и специальное назначение:

Специальные методы во многом составляют ядро яз ыка Python, поскольку:

Оглавление

3 Понятие объекта

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

Оглавление

3.1 Идентичность объектов

Идентичность (identity) является неизменяемым свойством объекта в течение времени его существования, задается при его создании и представляет собой уникальное целое число. В реализации CPython указывает на адрес объекта в памяти. Значение идентичности объекта может быть получено с помощью встроенной функции id() (см. описание встроенных функций в подразделе 8.1). Например, объект, представленный числом 25, имеет значение идентичности, равное 505894688:

>>> id (25)
505894688.

Проверить идентичность двух объектов можно с помощью операторов is и is not. Операция is возвращает значение True при их идентичности:

>>> s=5
>>> s is 5
True

и значение False при отсутствии идентичности:

>>> s is '5'
False

Операция is not возвращает противоположное значение:

>>> s is not '5'
True

Оглавление

3.2 Типы объектов

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

Каждый объект языка Python имеет свой тип (type), который является неизменяемым свойством и определяет операции, поддерживаемые объектом, и его возможные значения. Поскольку данные являются объектами, а любой объект принадлежит классу (class), который определяет его свойства, то понятия "класс" и "тип" являются синонимами.
В языке Python все является объектом, в том числе тип объекта и его класс. Для определения типа объекта используется встроенная функция type(), которая, если указан один аргумент (см. описание встроенных функций в подразделе 8.1), возвращает его тип (класс) в форме <class 'тип данных'>, например, целое число

>>> type (-55)
<class 'int'>.

имеет тип int (см. описание целых чисел в подразделе 4.1). Проверим утверждение, что тип объекта сам является объектом:

>>> type ( type (-55))
<class 'type'>.

Определить класс (тип) объекта также можно, используя атрибут __class__:

>>> 2.3e-1.__class__
<class 'float'>

(см. описание чисел с плавающей точкой в подразделе 4.1.2).
При описании языка Python также используется термин "instance", под которым понимается конкретный образец или экземпляр класса, поэтому этот термин является синонимом слова "объект".

Оглавление

3.3 Значения объектов

Объекты, в зависимости от того, могут быть изменены их значения или нет, делятся на изменяемые объекты (mutable objects) и неизменяемые объекты (immutable objects). Для определения, явояется ли данный объект изменяемым или нет, можно использовать функцию hash() (см. подраздел 8.1 данной лаб. раб. и подраздел 1.3 лаб. раб. №3).
Неизменяемые объекты могут создаваться и уничтожаться, но не могут менять число, последовательность и значения своих элементов. Все рассматриваемые в данной лабораторной работе объекты (целые числа, числа с плавающей точкой, комплексные числа и данные логиченского типа) являются неизменяемыми обхектами.
Изменяемые объекты могут изменять значения своих элементов, могут вставлять новые элементы в начале, в середине и в конце последовательности своих элементов. Примером изменяемого типа являются списки (см. раздел 2 лаб. раб. №3).
Для задания значений объектам могут быть использованы как литералы (любые разрешенные для данного типа значения, представленные в синтаксически правильной для языка Python форме), так и конструкторы соответствующено типа (см. разделы 4.1.1, 4.1.2, 4.1.3 и 4.2).
Объекты явно не уничтожаются, но после того, как они становятся недоступными, происходит удаление их из памяти системными средствами сборки мусора.

Оглавление

4 Встроенные типы данных

Python имеет большое количество встроенных типов данных (для версии 3.6.0 они приведены по адресу http://docs.python.org/3/library/stdtypes.html). Наиболее важные из них:

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

Оглавление

4.1 Числа

Числа (англ. numeric types) являются неизменяемыми объектами и подразделяются на:

Оглавление

4.1.1 Целые числа

Целые числа со знаком (англ. integers) принадлежат типу (классу) int. Они имеют формально неограниченный размер (фактически их размер ограничен конечным объемом памяти компьютера). Значения целых чисел, во-первых, могут быть заданы в виде целочисленных литералов:

Во-вторых, целые числа могут быть созданы с помощью конструктора класса – встроенной функции int(x [,base]), которая:

Отметим, что при использовании вместо встроенной функции int() специального метода x.__int__(), x должен быть числом:

>>> 0.026e3.__int__()
26
>>> '3' .__int__(),

иначе выводится сообщение об ошибке:

AttributeError: 'str' object has no attribute '__int__';

Для представления целых чисел в виде строк (см. раздел 2 лаб. раб. №2) можно использовать следующие встроенные функции (см. подраздел 8.1):

Дополнительную информацию о целых числах можно получить, использовав метод int_info модуля sys (см. подраздел 1.3 лаб. раб. №2).

Оглавление

4.1.2 Числа с плавающей точкой

Числа с плавающей точкой (англ. floating point numbers) или вещественные числа имеют тип (класс) float и содержат целую и дробную части, разделенные точкой. Создаваться числа с плавающей точкой могут, во-первых, в виде литерала, который имеет две формы:

При выводе на экран вещественные числа преобразуются в форму десятичной дроби. Задаваться вещественные числа могут только в десятичной системе счисления.
Во-вторых, числа с плавающей точкой могут быть созданы с помощью конструктора класса – втроенной функции float(), которая:

При использовании специального метода x.__float__(), x должен быть числом.
Дополнительную информацию о вещественных числах можно получить, использовав метод float_info модуля sys (см. подраздел 1.3 лаб. раб. №2).

Оглавление

4.1.3 Комплексные числа

Комплексные числа (англ. complex numbers) имеют тип (класс) complex и создаются, во-первых, в виде литерала формы a+bj, где a задает вещественную часть числа, а b – мнимую (a и b могут быть числами любого типа, включая пип complex), например:

>>> comp=2+3j+1.33e-1
>>> comp
(2.133+3j).

Во-вторых, компрлексное число может быть создано с помощью встроенной фукнции – конструктора complex([real[, imag]]), которая создает комплексное число с реальной частью real и мнимой частью imag. Если первый параметр является строкой, он интерпретируется как комплексное число и функция должна вызываться без второго параметра. Второй параметр не должен быть строкой. Каждый аргумент может быть любого числового типа, включая комплексный. Если мнамая часть опущена, ее значение по умолчанию приравнивается нулю и функция выполняется подобно функциям int() и float(). Если опущены оба аргумента, возвращается значение 0j.
Отметим, что когда осуществляется преобразование из строки, строка не должна содержать разделительных символов вокруг внутренних операторов + или -. Например, вызов функции complex('4+3j'):

>>> comp1= complex ( '4+3j' )
>>> comp1
(4+3j)

создает правильное комплексное число, а вызов функции complex('4 + 3j') приведет к возникновению исключения:

>>> comp1= complex ( '4 + 3j' )
ValueError: complex() arg is a malformed string,

т.е.аргументом функции complex() является неправильно сформированая строка.
Класс complex поддерживает свойства:

и метод conjugate(), который возвращает сопряженное комплексное число

>>> comp.conjugate()
(4-3j)

Оглавление

4.1.4 Операции с числами

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

При выполнении каждого оператора вызывается соответствующий ему метод. Это позволяет для одного и того же оператора задавать разные действия в зависимости от типа операндов.
Отметим, что в выражении операции выполняются в порядке их приоритета: наивысший приоритет имеет операция **, затем следуют операции *, /, // и %, еще более низкий приоритет имеют операции сложения и вычитания. При равном приоритете операции выполняются слева направо, например:

>>> 5+6/2*4**2
53.

Однако операции возведения в степень, идущие подряд, выполняются в обратном порядке – справа налево. Поэтому результатом выражения 2**3**2 будет 512, а не 64:

>>> 2**3**2
512.

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

Оглавление

4.1.5 Функции для работы с числами

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

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

>>> round (2.675, 2)

дает

2.67

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

Оглавление

4.1.6 Побитовые операции над целыми числами

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

>>> a=60 # 0b00111100
>>> b=13 # 0b00001101

Для работы с этими операндами могут быть использованы следующие операторы (в скобках указаны соответствующие им специальные методы):

Оглавление

4.2 Логический тип

Данные логического типа являются подклассом целых чисел bool(int) и могут принимать одно из двух значений: истина (англ. true) или ложь (англ. false). Язык Python имеют константы True и False, которые используются для непосредственного присваивания логических значений в виде литералов (все встроенные константы языка Python приведены в подразделе 8.2). Другим вариантом задания логических значений является использование конструктора класса – встроенной фукнкции bool([x]) (см. подраздел 8.1).
Результатом вычисления выражений также может быть логическое значение. В определенных местах программы, например, в операторе if, интерпретатор языка ожидает, что результатом вычисления выражения будет логическое значение. Такие места программы называют логическим контекстом. Практически всякое выражение можно использовать в логическом контексте. Python в любом случае попытается осуществить его проверку на истинность, используя следующие правила:

Логические операции приведены в порядке возрастания приоритета:

>>> True and True or False and False
True
>>> True and (True or False) and False
False
>>> not True or True
True
>>> not (False and False)
False.

Операция not имеет более низкий приоритет, чем любая нелогическая операция, например, not a==b интерпретируется как not (a==b).

Оглавление

4.3 Проверка типа объекта

В подразделе 3.2 приведено описание и использование функции type(), которая выполняет вывод типа (класса) указанного объекта. Иногда возникает необходимость не выводить значение типа объекта, а определить, принадленжит ли данный объект определенному типу. Для этого можно использовать встроенную функцию isinstance() (см. подраздел 8.1 ), которая имеет два аргумента – в первом указывается проверяемый тип (значение), во втором – тип (класс). Функция isinstance() возвращает значение True, если объект имеет указанный тип, и значение False – в противном случае:

>>> isinstance (1.0, int)
False.
>>> isinstance ( int (1.0), int)
True.

Из результатов примера видно, что значение 1.0 не является литералом целого числа, а после произведенного преобразования с помощью конструктора int() – уже имеет целочисленный тип.

Оглавление

5 Ввод и вывод данных

В примерах при описании функционирования среды разработки языка Python были использованы встроенные функции print() и input(). Сейчас приведем их более детальное описание.

Оглавление

5.1 Функция print()

Функция print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False) осуществляет вывод данных objects в потоковый файл. При этом:

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

x=25
y=2.5E-2
print ( 'x' ,x)
print ( 'y' ,y)
>>> ================================ RESTART ================================
x 25
y 0.025
>>>

и с их использованием:

x=25
y=2.5E-2
print ( 'x' ,x,sep= '=' ,end= ' ' )
print ( 'y' ,y,sep= '=' ,end= '' )
>>> ================================ RESTART ================================
x=25 y=0.025

Оглавление

5.2 Функция input()

Функция input([prompt]) – при наличии необязательного аргумента prompt выводит его в стандантный поток вывода (англ. standard output). Затем считывет данные из стандартного устройства ввода (англ. standard intput) и преобразует их в строки, убирая замыкающие символы новой строки (англ. trailing newline).
Отметим, что функция input() объединила в себе две функции, которые используются во второй версии языка Python – собственно функцию input() и функцию raw_input(), которая не поддерживается версиями 3.x языка Python.
В примере показан ввод двоичного целого числа и числа с плавающей точкой:

x= int ( input ( "Введите двоичное число " ),2)
y= float ( input ( "Введите число с плавающей точкой " ))

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

Оглавление

6 Операторы

6.1 Оператор присваивания

Оператор присваивания имеет следующую форму: v=expr, где

Переменные в языке Python не требуют явного объявления и для них не указывается изначально тип данных. Python относится к языкам программирования с динамической типизацией переменных. Переменные появляются, когда им присваивают значение, и автоматически уничтожаются при выходе из области видимости. Поэтому при работе оператора присваивания переменная получает не только значение выражения, но и его тип.
Имена (идентификаторы) (англ. names, identifiers) переменных языка Python (), так же как и во многих других языках программирования (Pascal, C, Java, JavaScript и др.) могут содержать только латинские буквы, цифры и знаки подчеркивания и начинаться или с буквы, или со знака подчеркивания. Отметим, что в качестве идентификаторов не следует использовать зарезервированные (ключевые) слова (англ. keywords) языка Python. Список ключевых слов можно получить, например, с помощью встроенной системы помощи (см. подраздел 1.2). Имена в языке Python зависят от регистра и не имеют ограничений по числу символов.
При выполнении оператора присваивания интерпретатором осуществляются следующие действия:

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

>>> del n
>>> n
NameError: name 'n' is not defined

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

>>> s1= 'some value'
>>> s2=s1
>>> s2
'some value',

и при удалении первой ссылки вторая сохраняет свое значение:

>>> del s1
>>> s1
NameError: name 's1' is not defined
>>> s2
'some value'.

Python допускает множественное присвоение:

>>> s5=s4=s3=s2
>>> s5
'some value'.

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

>>> n=7
>>> id (n)
505894400
>>> n=25
>>> id (n)
505894688.

происходит следующее – прежнее значение не изменится (оно будет в последствии автоматически удалено системой сборки мусора), а новое значение будет занесено в новую область памяти и теперь на него будет указывать ссылка n, что подтверждает встроенная функция id() (см. подраздел 8.1), которая показывает, что значение адреса переменной n стало другим. Т.е. происходит не изменение значения объекта, а создание нового объекта с новыми данными и адресом.
Оператор присваивания имеет несколько расширенных вариантов, приведенных в табл. 1.

Таблица 1 – Расширенные формы оператора присваивания

ОператорПример
использования		Эквивалентная
форма		Соответствующий
метод
+=x+=yx=x+yx.__iadd__(y)
-=x-=yx=x-yx.__isub__(y)
*=x*=yx=x*yx.__imul__(y)
/=x/=yx=x/yx.__itruediv__(y)
//=x//=yx=x//yx.__ifloordiv__(y)
%=x%=yx=x%yx.__imod__(y)
**=x**=yx=x**yx.__ipow__(y)
<<=x<<=yx=x<<yx.__ilshift__(y)
>>=x>>=yx=x>>yx.__irshift__(y)
&=x&=yx=x&yx.__iand__(y)
|=x|=yx=x|yx.__ior__(y)
^=x^=yx=x^yx.__ixor__(y)

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

>>> z1=5; z2=3.7; z3=1.5e-1.

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

>>> x=z1+ \
z2+ \
z3 \
>>> x
8.85.

Оглавление

6.2 Условный оператор

Условный оператор имеет следующую форму:

if <условие> :
<блок>

В условии указывается выражение, имеющее логический тип. Блок представляет собой одну или несколько строк программы (операторов), которые задаются с отступом. Визуальный блок в языке Python является логическим блоком и соответствует конструкции {...} в JavaScript и других C-подобных языках. Если условие имеет значение True, то выполняются строки, входящие в блок. В противном случае блок не выполняется, а управление передается следующей после условного оператора строке.
Операторы сравнения, когорые могут использоваться в условии, приведены в табл. 2.

Таблица 2 – Операторы сравнения
Оператор
сравнения		Выполняемые действияМетод,
соответствующий оператору
x==yесли операнды x и y равны,
условие получает значение True, иначе – False		x.__eq__(y)
x!=yесли операнды x и y не равны,
условие получает значение True, иначе – False		x.__ne__(y)
x>yесли значение x больше значения y,
условие получает значение True, иначе – False		x.__gt__(y)
x>=yесли значение x больше значения y или равно ему,
условие получает значение True, иначе – False		 (x.__ge__(y))
x<yесли значение x меньше значения y,
условие получает значение True, иначе – False		x.__lt__(y)
x<=yесли значение x меньше значения y или равно ему,
условие получает значение True, иначе – False 		x.__le__(y)

Отметим, что в версиях Python 2.x для сравнения использовались: оператор сравнения <> (эвивалентный оператору !=), встроенная функция cmp() и соответствующий ей метод __cmp__(), которые убраны в версиях 3.x.
При использовании оператора сравнения вызывается соответствующий ему метод, определенный для типа (класса) сравнивающихся объектов. Поэтому использование оператора сравнения:

>>> x=7
>>> x==4
False
>>> x==7
True

равноценно вызову требуемого метода:

>>> x.__eq__(4)
False
>>> x.__eq__(7)
True.

Благодаря этому для одного и того же оператора сравнения могут выполняться разные действия в зависимости от типа его операндов.
Пример использования условного оператора:

>>> x= input ( 'Введите число' )
Введите число 12
>>> if int (x)>=0:
print ( 'Число положительное' )

Число положительное.

После ввода первой строки программы и нажатия Enter на экран выводится сообщение: Введите число. После ввода числа (12) и ввода первой строки условного оператора среда разработки делает отступ для ввода блока. Вводится первая строка блока и дважды нажимается Enter (признаком завершения блока является пустая строка). На экране появляется результат работы этого фрагмента программы: Число положительное.
Python поддерживает множественное использование операций сравнения:

>>> a,b,c=2,3,4
>>> if a<b<c: #a<b and b<c
print ( 'OK' )

OK.

В другой форме условного оператора для задания альтернативного варианта добавляется служебное слово else:

if <условие> :
<блок1>
else :
<блок2>.
В зависимости от значения условия будет выполняться или блок1 (True), или блок2 (False). Следующий пример запускается в сценарном режиме:

x= input ( 'Введите число' )
if int (x)>=0:
print ( 'Число положительное' )
else :
print ( 'Число отрицательное' ).

После ввода этого фрагмента программы в окне редактирования выбирается режим Run module и программа запускается на выполнение. Результат работы программы помещается в окно итерактивного режима:

>>> ================================ RESTART ================================
>>>
Введите число -1
Число отрицательное.

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

>>> if X:
A=Y
>>> else :
A=Z
можно применить более короткий вариант, связанный с использованием трехместного выражения if/else:

>>> A=Y if X else Z.

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

if <условие1> :
<блок1>
elif <условие2>:
<блок2>
. . .
elif <условиеN>:
<блокN>
else :
<блокN+1>.
В качестве примера рассмотрим задачу определения оценки по полученным баллам:

points= input ( 'Введите число баллов' )
points= int (points)
if points>80:
mark= 'Відмінно'
elif points>66:
mark= 'Добре'
elif points>50:
mark= 'Задовільно'
else :
mark= 'Незадовільно'
print (mark)
>>> ================================ RESTART ================================
>>>
Введите число баллов 80
Добре.

Оглавление

6.3 Оператор цикла while

Оператор цикла while имеет следующую форму:

while <условие> :
<блок>.

Пока условие имеет логическое значение True, будут циклически выполняться действия, указанные в блоке. Когда условие примет заначение False, управление будет передано оператору, следующему за блоком. Если условие изначально не выполняется, то действия, предусмотренные блоком, не будут выполнены вовсе.
В качестве примера использования оператора цикла while приведем программу нахождения чисел Фибоначчи. Эти числа характеризуются тем, что каждое следующее число Фибоначчи равно сумме двух предыдущих. Программа находит и выводит на экран все числа Фибоначчи, не превышающие 50:

>>> # Определение чисел Фибоначчи
>>> a,b=0,1
>>> while b<=50:
print (b,end= ' ' )
a,b=b,a+b
1 1 2 3 5 8 13 21 34.

В теле оператора while также могут быть использованы операторы break и continue:

>>> с=0
>>> while True :
с+=1
if с>9:
break
if c==3 or c==5:
continue
print (c,end= ' ' )
1 2 4 6 7 8 9.

Оглавление

6.4 Оператор pass

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

>>> while True :
pass # Ожидание прерывания c клавиатуры (Ctrl+C).

После нажатия класиши Ctrl+C режим ожидания заканчивается в выводом:

KeyboardInterrupt.

Этот оператор часто используется для создания минималистичных классов, к примеру исключений (exceptions), или для игнорирования нежелательных исключений.

Оглавление

7 Приоритет операций

В таблице 3 приведены операции в порядке возрастания их приоритета. Для унарных операций x обозначает операнд.

Таблица 3 – Приоритет операций
ОперацияОписание
orлогическое ИЛИ
andлогическое И
not xлогическое НЕ
in, not inпроверка принадлежности
is, is notпроверка идентичности
<,<=,>,>=,
!=,== 		операторы сравнения
|побитовое ИЛИ
^побитовое исключающее ИЛИ
&побитовое И
<<, >>побитовые сдвиги
+, -сложение и вычитание
*, /, //, %*, /, % умножение, деление, целочисленное деление, остаток
+x, -xунарный плюс и смена знака
~xпобитовое НЕ
**возведение в степень
x.атрибутссылка на атрибут
x[индекс] взятие элемента по индексу
x[от:до]выделение среза (от и до)
f(аргумент,...)вызов функции
( ... )скобки или кортеж
[ ... ]список или списковое включение
{кл:зн, ...}словарь пар ключ-значение

Порядок вычислений операндов определяется такими правилами:

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

Оглавление

8 Встроенные идентификаторы

8.1 Встроенные функции

В предыдущих разделах были описаны и использованы некоторые встроенные функции языка Python. Встроенные (buit-in) означает, что их можно непосредственно использовать в программе без подключения дополнительных модулей. В табл. 4 перечислены в алфавитном порядке имена всех встроенных функций языка Python 3.4. Ниже приводится их описание. Встроенные функции, которые были использованы в лабораторных работах, имеют соответствующие ссылки.

Таблица 4 – Встроенные функции языка Python 3.4
Built-in functions
abs() dict() help() min() setattr()
all() dir()hex() next() slice()
any() divmod()id() object() sorted()
ascii() enumerate() input() oct() staticmethod()
bin() eval()int() open() str()
bool() exec()isinstance() ord() sum()
bytearray() filter()issubclass() pow() super()
bytes() float()iter() print() tuple()
callable() format()len() property() type()
chr() frozenset()list() range()vars()
classmethod() getattr()locals() repr() zip()
compile() globals() map() reversed() __import__()
complex() hasattr()max() round()
delattr() hash()memoryview() set()

Оглавление

Оглавление

8.2 Встроенные константы

Python имеет следующие встроенные константы:

Оглавление

Индивидуальные задания

1. Ознакомиться с интерактивным и сценарным режимами работы среды разработки программ на языке Python (IDLE).
2. Разработать программу на языке Python, которая выполняет следующее:

Таблица 5 – Перечень индивидуальных заданий
Номер
п/п		HelpАргумент Основание Операция
арифметическаяпобитовая
11116+&
2228-|
3332*^
44116/~
5528// >>
6632%<<
77116**&
8828+|
9932-^
1010116*~
111128/ >>
121232// <<
1313116%&
141428**|
15132+^
162116-~
17328* >>
18432/<<
195116//&
20628%|

 Оглавление