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.
В комплект поставки Python входит интегрированная среда разработки IDLE (Integrated DeveLopment
Environment), в которой редактирование программы выполняется намного удобнее, чем в простом
текстовом редакторе или терминале. IDLE также имеет встроенную систему отладки, позволяющую
запускать программу построчно, что облегчает процесс поиска ошибок.
IDLE написана на языке Python с использованием GUI-инструментария
tkinter, поэтому легко запускается в любой операционной системе, для которой существует реализация
Python.
Графический пользовательский интерфейс GUI (Graphical User Interface)
– это разновидность пользовательского интерфейса, в котором элементы интерфейса (меню, кнопки,
значки, списки и т. п.), представленные пользователю на дисплее, исполнены в виде графических
изображений. В отличие от интерфейса командной строки (типа старого DOS системы Windows),
в GUI пользователь имеет свободный доступ ко всем элементам интерфейса экрана и может ими управлять
с помощью клавиатуры или мыши (см. раздел 1
лаб. раб. №13).
Отличительные черты среды IDLE Python:
Таким образом IDLE Python является интерактивным интерпретатором. Интегрированная среда разработки имеет два основных режима работы:
Для запуска интерактивной сессии необходимо выбрать 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 для разделения операторов использует не точку с запятой, а перевод
строки.
Помимо справочной информации о языке 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 |
При работе в интерактивном режиме система отвечает мгновенно. С одной стороны это хорошо, так как сразу можно видеть результат. Но для создания программ, которые сохранялись бы в памяти и могли быть запущены позднее, этот режим не подходит. Для этой цели в среде разработки предусмотрен сценарный режим (см. подраздел 1.3.2 ). В нем можно создавать, редактировать, загружать и сохранять программу.
Панель инструментов имеет следующие меню, предназначенные для задания различных режимов работы среды разработки IDLE:
В сценарный режим можно перейти из интерактивного, выбрав в меню 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.
Отметим, что одновременное использование интерактивного и
сценарного режимов при создании и отладке программы создает предпосылки для наиболее эффективной
и качественной работы.
В языке Python знаки подчеркивания (англ. underscores) помимо обычного использования в идентификаторах подобно другим языкам программирования (см. подраздел 6.1) имеют и специальное назначение:
Специальные методы во многом составляют ядро яз ыка Python, поскольку:
Все данные, которые использованы в программах на языке Python, а также отношения между данными, являются объектами. Поэтому понятия "объект" и "данные" являются синонимами. Каждый объект имеет следующие свойства:
Идентичность (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
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", под
которым понимается конкретный образец или экземпляр класса, поэтому этот термин является синонимом
слова "объект".
Объекты, в зависимости от того, могут быть изменены их значения или нет, делятся на изменяемые
объекты (mutable objects) и неизменяемые объекты (immutable objects). Для определения, явояется
ли данный объект изменяемым или нет, можно использовать функцию hash()
(см. подраздел 8.1 данной лаб. раб. и
подраздел 1.3 лаб. раб. №3).
Неизменяемые объекты могут создаваться и уничтожаться, но не могут
менять число, последовательность и значения своих элементов. Все рассматриваемые в данной
лабораторной работе объекты (целые числа, числа с плавающей точкой, комплексные числа
и данные логиченского типа) являются неизменяемыми обхектами.
Изменяемые объекты могут изменять значения своих элементов, могут
вставлять новые элементы в начале, в середине и в конце последовательности своих элементов.
Примером изменяемого типа являются списки
(см. раздел 2 лаб. раб. №3).
Для задания значений объектам могут быть использованы как литералы
(любые разрешенные для данного типа значения, представленные в синтаксически правильной для языка
Python форме), так и конструкторы соответствующено типа (см. разделы 4.1.1,
4.1.2, 4.1.3 и 4.2).
Объекты явно не уничтожаются, но после того, как они становятся
недоступными, происходит удаление их из памяти системными средствами сборки мусора.
Python имеет большое количество встроенных типов данных (для версии 3.6.0 они приведены по адресу http://docs.python.org/3/library/stdtypes.html). Наиболее важные из них:
Кроме них существуют и многие другие типы данных. В языке Python все является объектом, поэтому в нем имеются также и такие типы, как модуль, функция, класс, метод и даже скомпилированный код.
Числа (англ. numeric types) являются неизменяемыми объектами и подразделяются на:
Целые числа со знаком (англ. 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).
Числа с плавающей точкой (англ. floating point numbers) или вещественные числа имеют тип (класс) float и содержат целую и дробную части, разделенные точкой. Создаваться числа с плавающей точкой могут, во-первых, в виде литерала, который имеет две формы:
При выводе на экран вещественные числа преобразуются в форму десятичной дроби. Задаваться
вещественные числа могут только в десятичной системе счисления.
Во-вторых, числа с плавающей точкой могут быть созданы с помощью
конструктора класса – втроенной функции float(), которая:
При использовании специального метода x.__float__(),
x должен быть числом.
Дополнительную информацию о вещественных числах можно получить,
использовав метод float_info модуля sys
(см. подраздел 1.3 лаб. раб. №2).
Комплексные числа (англ. 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)
Все числа (за исключением комплексных чисел) поддерживают следующие операции (в скобках указаны соответствующие им специальные методы, если операция имеет два операнда, то приводится также метод с обратным использованием операндов:
При выполнении каждого оператора вызывается соответствующий ему метод. Это позволяет для одного
и того же оператора задавать разные действия в зависимости от типа операндов.
Отметим, что в выражении операции выполняются в порядке их приоритета:
наивысший приоритет имеет операция **, затем следуют операции
*, /, // и
%, еще более низкий приоритет имеют операции сложения и вычитания. При
равном приоритете операции выполняются слева направо, например:
>>>
5+6/2*4**2
53.
Однако операции возведения в степень, идущие подряд, выполняются в
обратном порядке – справа налево. Поэтому результатом выражения
2**3**2 будет 512, а не 64:
>>>
2**3**2
512.
Для изменения порядка выполнения операций в выражении необходимо
использовать скобки.
При работе с числами могут быть использованы также следующие встроенные функции (см. подраздел 8.1. В скобках указан соответствующий им специальный метод:
Отметим, что поведение функции round() для чисел с плавающей точкой
может вызвать удивление: например:
>>>
round
(2.675, 2)
дает
2.67
вместо ожидаемых 2.68. Это связано с тем обстоятельством, что большинство десятичных дробей не
может быть точно представлено в форме числа с плавающей точкой.
Помимо встроенных функций при работе с целыми числами можно
воспользоваться текже следующими методами класса int:
Python поддерживает также побитовые операции над целыми числами. Пусть операнды a и b имеют
следующие значения:
>>>
a=60
# 0b00111100
>>>
b=13
# 0b00001101
Для работы с этими операндами могут быть использованы следующие
операторы (в скобках указаны соответствующие им специальные методы):
Данные логического типа являются подклассом целых чисел 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).
В подразделе 3.2 приведено описание и использование функции
type(), которая выполняет вывод типа (класса) указанного объекта. Иногда
возникает необходимость не выводить значение типа объекта, а определить, принадленжит ли данный
объект определенному типу. Для этого можно использовать встроенную функцию
isinstance() (см. подраздел 8.1 ), которая
имеет два аргумента – в первом указывается проверяемый тип (значение), во втором – тип
(класс). Функция isinstance() возвращает значение True, если объект
имеет указанный тип, и значение False – в противном случае:
>>>
isinstance
(1.0, int)
False.
>>>
isinstance
(
int
(1.0), int)
True.
Из результатов примера видно, что значение 1.0 не является литералом целого числа, а после
произведенного преобразования с помощью конструктора int() – уже
имеет целочисленный тип.
В примерах при описании функционирования среды разработки языка Python были использованы встроенные функции print() и input(). Сейчас приведем их более детальное описание.
Функция 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
Функция input([prompt]) – при наличии необязательного аргумента prompt
выводит его в стандантный поток вывода (англ. standard output). Затем считывет данные из
стандартного устройства ввода (англ. standard intput) и преобразует их в строки, убирая замыкающие
символы новой строки (англ. trailing newline).
Отметим, что функция input() объединила в
себе две функции, которые используются во второй версии языка Python – собственно функцию
input() и функцию raw_input(), которая не
поддерживается версиями 3.x языка Python.
В примере показан ввод двоичного целого числа и числа с плавающей точкой:
x=
int
(
input
(
"Введите двоичное число "
),2)
y=
float
(
input
(
"Введите число с плавающей точкой "
))
Кроме того, осуществлено преобразование введенных значений с помощью соответствующих конструкторов
в целый тип и тип с плавающей точкой. Это необходимо делать в случаях, когда введенные значения
будут использоваться для выполнения операций с числами, поскольку при вводе все значения
преобразуются в строки.
Оператор присваивания имеет следующую форму: 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.
| Оператор | Пример использования | Эквивалентная форма | Соответствующий метод |
|---|---|---|---|
| += | x+=y | x=x+y | x.__iadd__(y) |
| -= | x-=y | x=x-y | x.__isub__(y) |
| *= | x*=y | x=x*y | x.__imul__(y) |
| /= | x/=y | x=x/y | x.__itruediv__(y) |
| //= | x//=y | x=x//y | x.__ifloordiv__(y) |
| %= | x%=y | x=x%y | x.__imod__(y) |
| **= | x**=y | x=x**y | x.__ipow__(y) |
| <<= | x<<=y | x=x<<y | x.__ilshift__(y) |
| >>= | x>>=y | x=x>>y | x.__irshift__(y) |
| &= | x&=y | x=x&y | x.__iand__(y) |
| |= | x|=y | x=x|y | x.__ior__(y) |
| ^= | x^=y | x=x^y | x.__ixor__(y) |
В языке Python операторы обычно отделяются друг от друга символами перевода на новую строку,
т.е. каждый оператор занимает одну строку программы. Мы этого до сих пор придерживались и будет
поступать так в дальнейшем. Но синтаксисом языка также разрешается помещать несколько операторов
на строке, разделяя их точкой с запятой:
>>>
z1=5; z2=3.7; z3=1.5e-1.
Также разрешается располагать оператор на нескольких строках, разделяя отдельные части оператора
символами обратного слэша:
>>>
x=z1+ \
z2+ \
z3 \
>>>
x
8.85.
Условный оператор имеет следующую форму:
if <условие> :
<блок>
В условии указывается выражение, имеющее логический тип. Блок представляет собой одну или
несколько строк программы (операторов), которые задаются с отступом. Визуальный блок в языке Python
является логическим блоком и соответствует конструкции {...} в JavaScript и других C-подобных
языках. Если условие имеет значение True, то выполняются строки, входящие в блок. В противном
случае блок не выполняется, а управление передается следующей после условного оператора строке. Таблица 2 – Операторы сравнения Отметим, что в версиях Python 2.x для сравнения использовались: оператор сравнения <>
(эвивалентный оператору !=), встроенная функция cmp() и соответствующий
ей метод __cmp__(), которые убраны в версиях 3.x.
Операторы сравнения, когорые могут использоваться в условии, приведены в
табл. 2.
Оператор
сравненияВыполняемые действия Метод,
соответствующий оператору
x==y если операнды x и y равны,
условие получает значение True, иначе – Falsex.__eq__(y)
x!=y если операнды x и y не равны,
условие получает значение True, иначе – Falsex.__ne__(y)
x>y если значение x больше значения y,
условие получает значение True, иначе – Falsex.__gt__(y)
x>=y если значение x больше значения y или равно ему,
условие получает значение True, иначе – False (x.__ge__(y))
x<y если значение x меньше значения y,
условие получает значение True, иначе – Falsex.__lt__(y)
x<=y если значение x меньше значения y или равно ему,
условие получает значение True, иначе – False x.__le__(y)
При использовании оператора сравнения вызывается соответствующий ему
метод, определенный для типа (класса) сравнивающихся объектов. Поэтому использование оператора
сравнения:
>>>
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
Добре.
Оператор цикла 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:
Оператор pass не делает ничего. Он может использоваться, когда
синтаксически требуется присутствие оператора, но от программы не требуется действий. Например:
>>>
while True
:
pass
# Ожидание прерывания c клавиатуры (Ctrl+C).
После нажатия класиши Ctrl+C режим ожидания заканчивается в выводом:
KeyboardInterrupt.
Этот оператор часто используется для создания минималистичных классов,
к примеру исключений (exceptions), или для игнорирования нежелательных исключений.
В таблице 3 приведены операции в порядке возрастания их приоритета. Для унарных операций x обозначает операнд.
| Операция | Описание |
|---|---|
| or | логическое ИЛИ |
| and | логическое И |
| not x | логическое НЕ |
| in, not in | проверка принадлежности |
| is, is not | проверка идентичности |
| <,<=,>,>=, !=,== | операторы сравнения |
| | | побитовое ИЛИ |
| ^ | побитовое исключающее ИЛИ |
| & | побитовое И |
| <<, >> | побитовые сдвиги |
| +, - | сложение и вычитание |
| *, /, //, % | *, /, % умножение, деление, целочисленное деление, остаток |
| +x, -x | унарный плюс и смена знака |
| ~x | побитовое НЕ |
| ** | возведение в степень |
| x.атрибут | ссылка на атрибут |
| x[индекс] | взятие элемента по индексу |
| x[от:до] | выделение среза (от и до) |
| f(аргумент,...) | вызов функции |
| ( ... ) | скобки или кортеж |
| [ ... ] | список или списковое включение |
| {кл:зн, ...} | словарь пар ключ-значение |
Порядок вычислений операндов определяется такими правилами:
В случае неясности приоритетов желательно применять скобки. Несмотря на то, что одни и те же символы могут использоваться для разных операций, приоритеты операций не меняются.
В предыдущих разделах были описаны и использованы некоторые встроенные функции языка Python. Встроенные (buit-in) означает, что их можно непосредственно использовать в программе без подключения дополнительных модулей. В табл. 4 перечислены в алфавитном порядке имена всех встроенных функций языка Python 3.4. Ниже приводится их описание. Встроенные функции, которые были использованы в лабораторных работах, имеют соответствующие ссылки.
Оглавление
Оглавление
Оглавление
Оглавление
Оглавление
Оглавление
Оглавление
Оглавление
dict(iterable, **kwarg) – создаeт
новый словарь (см. подраздел 2.1 лаб. раб. №5);
>>>
seasons=[
'зима'
,
'весна'
,
'лето'
,
'осень'
,
]
>>>
list
(
enumerate
(seasons, start=1))
[(1, 'зима'), (2, 'весна'), (3, 'лето'), (4, 'осень')];
int(x, base=10) – преобразует x в
целое число или возвращает 0, если аргумент не был задан
(см. подраздел 4.1.1 лаб. раб. №1);
Без второго аргумента объект может быть или объектом-контейнером с
поддержкой протокола итерации (метода __iter__()), или он должен поддерживать протокол
последовательности (метод __getitem__() с целочисленным аргументом, начинающимся с 0. Если он не
поддерживает ни один из этих протоколов, возникает ошибка типа (TypeError).
Если второй аргумент sentinel, задающий граничное значение, указан,
тогда объект должен быть вызываемым объектом (англ. callable object). Итератор, созданный в этом
случае будет вызывать объект без аргументов для каждого вызова своего метода __next__(). Если
возвращаемое значение равно значению аргумента sentinel, будет вызвано исключение StopIteration.
В остальных случаях будет возвращено значение
(см. подраздел 1.2 лаб. раб. №3);
max(arg1, arg2, *args[, key]) – возвращает самый большой элемент итерабельного типа
или наибольший из двух или более аргументов. Если используется один позиционный оргумент, он должен
быть инерабельным объектом. Возвращается его наибольший элемент
(см. подраздел 2.5 лаб. раб. №2, подразделы
1.4.2 и 2.2 лаб. раб. №3,
раздел 2 и подразделы 1.1,
3.1 и 3.2 лаб. раб. №4),
множество (см. подраздел 1.1 лаб. раб. №5) и словарь
(см. подраздел 2.1 лаб. раб. №5). Если указываются два или
больше позиционных аргументов, возвращается наибольший из них. Функция может иметь два
необязательных именных аргумента. Аргумент key указывает функцию упорядочевания с одним аргументом,
подобную тем, которые используются для метода list.sort()
(см. подраздел 1.4 лаб. раб. №6). Аргумент по умолчанию
– объект, который будет возвращен, если итерабельный объект будет пустым. Если итерабельный
объект будет пустым и аргумент по умолчанию не будет указан, возникнет исключение ValueError. Если
окажется несколько максимальных значений, функция возвратит, первое встретившееся. Эти правила
распространяются и на другие программные средства сортировки, такие как
sorted(iterable, key=keyfunc, reverse=True)[0] и heapq.nlargest(1, iterable, key=keyfunc).
Новое в версии 3.4 – именованный аргумент, задающий значение по умолчанию;
min(arg1, arg2, *args[, key]) – возвращает самый маленький элемент итерабельного типа
или наименьший из двух или более аргументов. Если используется один позиционный оргумент, оy должен
быть инерабельным объектом. Возвращается его наименьший элемент
(см. подраздел 2.5 лаб. раб. №2, подразделы
1.4.2 и 2.2 лаб. раб. №3,
раздел 2 и подразделы 1.1,
3.1 и 3.2 лаб. раб. №4),
множество (см. подраздел 1.1 лаб. раб. №5) и словарь
(см. подраздел 2.1 лаб. раб. №5). Если указываются два или
больше позиционных аргументов, возвращается наименьший из них. Функция может иметь два
необязательных именных аргумента. Аргумент key указывает функцию упорядочевания с одним аргументом,
подобную тем, которые используются для метода list.sort()
(см. подраздел 1.4 лаб. раб. №6). Аргумент по умолчанию
– объект, который будет возвращен, если итерабельный объект будет пустым. Если итерабельный
объект будет пустым и аргумент по умолчанию не будет указан, возникнет исключение ValueError. Если
окажется несколько миниимальных значений, функция возвратит, первое встретившееся.
Эти правила распространяются и на другие программные средства сортировки, такие как
sorted(iterable, key=keyfunc, reverse=True)[0] и heapq.nlargest(1, iterable, key=keyfunc). Новое в
версии 3.4 – именованный аргумент, задающий значение по умолчанию;
slice(start, stop[, step]) –
возвращает объект типа slice, представленный индексами, указанными диапазоном range(start, stop,
step). Аргументы start и step по умолчанию имеют значение None. slice-объекты имеют данные только
для чтения, атрибуты start, stop и step просто вовзращают значения (или значения по умолчанию). Эти
объекты не имеют явной функциональности. Но могут быть использованы в Numerical Python и других
расширениях;
>>>
class
C
:
@
staticmethod
def
f
(arg1, arg2, ...)
str(object[, encoding[, errors]]) –
возвращает представление заданного объекта в виде строки
(см. подраздел 2.5 лаб. раб. №2);
>>>
sum
((2.5, 4,1.25e1))
19.0
Для некоторых классов есть неплохие альтернативы функции sum(): для
конкатенации строк можно использовать join(sequence), для сложения чисел с плавающей точкой
повышенной точности – math.fsum(), для конкатенации нескольких итерабельных объектов –
itertools.chain();
type(name, bases, dict) –
при задании одного аргумента object функция возвращает наименование типа объекта (см. подразделы
3.2 , 2.1 лаб. раб. №3,
2.1 и
3.1 лаб. раб. №5,
4.1 лаб. раб. №6,
1.1 лаб. раб. №11. Для проверки типа объекта
рекомендуется использовать встроенную функцию isinstance().
При задании трех аргументах функция type(name, bases, dict)
возвращает новый класс. Это существенно для динамической формы оператора класса. Строка name
указывает имя класса и становится атрибутом __name__, кортеж bases перечисляет базовые классы и
становится атрибутом __bases__ и словарь dict задает адресное пространство атрибутов класса и
становится атрибутом __dict__
(см. подраздел 1.1 лаб. раб. №11);
Функция __import__() загружает (импортирует) модуль с именем name, при этом необязательные
аргументы globals и locals определяют, как интерпретировать имя name в контексте пакета
(англ. package). Аргумент fromlist укахывает имена объектов или подмодулей, которые должны быть
импортированы из модуля name. Стандартное применение не использует аргумент locals вообще, а
globals только для определения пакета в контексте оператора import. Аргумент level указывает,
нужно ли использовать абсолютное или относительное импортирование. Значение 0 (задается по
умолчанию) означает выполнение только абсолютного импортирования. Положительное значение этого
аргумента показывает число родительских каталогов для поиска относительно каталога модуля,
вызывающего __import__(). Пример использования:
>>>
temp=__import__(
"collections"
, fromlist=[
"Iterable"
,
"Sequence"
])
>>>
isinstance
(
"WWW"
, temp.Sequence)
True
>>>
isinstance
(2,temp.Iterable)
False
Python имеет следующие встроенные константы:
1. Ознакомиться с интерактивным и сценарным режимами работы среды разработки программ на языке
Python (IDLE).
2. Разработать программу на языке Python, которая выполняет следующее:
| Номер п/п | Help | Аргумент | Основание | Операция | |
|---|---|---|---|---|---|
| арифметическая | побитовая | ||||
| 1 | 1 | 1 | 16 | + | & |
| 2 | 2 | 2 | 8 | - | | |
| 3 | 3 | 3 | 2 | * | ^ |
| 4 | 4 | 1 | 16 | / | ~ |
| 5 | 5 | 2 | 8 | // | >> |
| 6 | 6 | 3 | 2 | % | << |
| 7 | 7 | 1 | 16 | ** | & |
| 8 | 8 | 2 | 8 | + | | |
| 9 | 9 | 3 | 2 | - | ^ |
| 10 | 10 | 1 | 16 | * | ~ |
| 11 | 11 | 2 | 8 | / | >> |
| 12 | 12 | 3 | 2 | // | << |
| 13 | 13 | 1 | 16 | % | & |
| 14 | 14 | 2 | 8 | ** | | |
| 15 | 1 | 3 | 2 | + | ^ |
| 16 | 2 | 1 | 16 | - | ~ |
| 17 | 3 | 2 | 8 | * | >> |
| 18 | 4 | 3 | 2 | / | << |
| 19 | 5 | 1 | 16 | // | & |
| 20 | 6 | 2 | 8 | % | | |