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

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

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

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

Введение

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

· простота использования – с точки зрения профессионального программиста легкость языка Python обеспечивает высокую производительность труда: программы на Python простые и требуют меньше времени на разработку и отладку;

· Python – объектно-ориентированный язык, имеющий преимущество перед C# и Java в том, что для этих языков ООП-подход выполняется неукоснительно. Это делает короткие программы избыточно сложными. В Python заложена другая модель – решение о том, использовать или нет ООП-приемы принимает программист в зависимости от типа и сложности программ. Python совмещает функциональность и гибкость;

· легкость интеграции с другими языками программирования, например, C, C++ или Java – программа на Python может использовать сильные стороны этих языков (скажем, быстродействие C, C++) не поступаясь простотой разработки;

· кроссплатформенность – Python может работать на всех платформах: от миниатюрного Palm до суперкомпьютера Cray. На ПК Python поддерживают операционные системы Windows, Linux, Macintosh и др.;

· Python – это бесплатная система с открытым исходным кодом: можно, например делать копии Python, в том числе и модифицированные, можно даже их продавать.

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

· https://docs.python.org/3/>Python 3.6 – содержит полную информацию, включая установку интерпретатора, описание языка, изменения, произошедшие в новой версии, и др.;

· http://docs.python.org/3.6/tutorial/ – содержит полное описание языка;

· http://docs.python.org/3/library/stdtypes.html) – содержит описание всех встроенных типов;

· http://docs.python.org/3/library/functions.html – содержит описание всех встроенных функций;

· http://docs.python.org/3/whatsnew/3.0.html – содержит перечень изменений в версии 3.0 языка Python по сравнению с версиями 2.x.

Ссылки на документацию языка 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:

· запрограммирована на коде Python с использованием GUI-инструментария tkinter;

· кроссплатформенна: работает на Windows и Unix;

· имеет многооконный текстовый редактор с функцией многократной отмены, подсветкой синтаксиса Python и многими другими свойствами;

· использует отладчик с возможностью задавать точки прерывания, осуществлять просмотр и пошаговое выполнение кода.

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

· интерактивный (см. подраздел 1.2);

· сценарный (см. подраздел 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.
Отметим, что одновременное использование интерактивного и сценарного режимов при создании и отладке программы создает предпосылки для наиболее эффективной и качественной работы.

Оглавление

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

Все данные, которые использованы в программах на языке 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). Наиболее важные из них:

· числа (см. подраздел 4.1);

· логический тип (см. подраздел 4.2);

· текстовые последовательности (строки) (см. раздел 2 лаб. раб. №2);

· списки (см. раздел 2 лаб. раб. №3);

· кортежи (см. раздел 1 лаб. раб. №4);

· диапазоны (см. раздел 2 лаб. раб. №4);

· двоичные последовательности (см. раздел 3 лаб. раб. №4);

· множества (см. раздел 1 лаб. раб. №5);

· словари (см. раздел 2 лаб. раб. №5);

· генераторы (см. подраздел 3 лаб. раб. №5);

· файловые типы (см. раздел 1 лаб. раб. №8);

· объект, не имеющий значение (Null object) – возращается функциями, которые не имеют явно заданного оператором return значения. Не поддерживает никаких операций. Имеется только один такой объект, он именуется встроенной константой None (см. подраздел 8.2). В логическом контексте имеет значение False;

· объект NotImplemented – возвращается при выполнении операций, когда в них указываются типы данных, которые эти операции не поддерживают (см. использование метода __add__() в подразделе 4.1.4). Имеется только один такой объект, он именуется встроенной константой NotImplemented (см. подраздел 8.2). В логическом контексте NotImplemented имеет значение True.

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

Оглавление

Числа

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

· целые числа (см. подраздел 4.1.1);

· числа с плавающей точкой (см. подраздел 4.1.2);

· комплексные числа (см. подраздел 4.1.3).

Оглавление

Целые числа

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

· в десятичной форме:
>>> -125;
-125

· в десятичной форме с использованием знака подчеркивания:
>>> 1_000_000; # Эта форма введена в версии 3.6.0 для улучшения читаемости
1000000

· в двоичной форме (имеют префикс 0b/0B):
>>> 0b110011
51;

· в восмеричной форме (имеют префикс 0o/0O):
>>> 0o25
21;

· в 16-ричной форме (имеют префикс 0x/0X):
>>> 0Xa5
165.

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

· если аргумент не задан – возращает значение 0;

· если аргумент задан в виде целого числа – возращает его значение (в этом случае проще использовать литерал);

· если аргументом является число с плавающей точкой – оно преобразуется в целое путем отбрасывания дробной части, например:

>>> int (1.9)
1
>>> int (-1.1)
-1;

· если аргументом является строковый литерал, он должен содержать только цифры и буквы, соответствующие заданной системе счисления. По умолчанию задана десятичная система. С помощью второго необязательного аргумента base можно задать систему счисления по основанию от 2 до 36. При этом строка может содержать цифры от 0 до 9 и латинские буквы от a/A до z/Z:

>>> int ('z',36)
35.

Можно также использовать литералы по основанию 2, 8 и 16, указывая их с префиксами 0b/0B, 0o/0O или 0x/0X, так же как числовые литералы задаются в коде программы. В этом случае значение base должно быть 0:

>>> int ('0x10',0)
16;

· если аргумент имеет логический тип (см. подраздел 4.2) – возвращает 1 для значения True и 0 для значения False.

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

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

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

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

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

· bin() – возвращает целочисленный аргумент в двоичной форме:

>>> bin (25)
'0b11001';

· oct() – возвращает целочисленный аргумент в 8-ричной форме:

>>> oct (25)
'0o31';

· hex() – возвращает целочисленный аргумент в 16-ричной форме:

>>> hex (25)
'0x19'.

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

Оглавление

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

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

· в виде десятичной дроби:

>>> 1.2
1.2

Точка ставится даже в тех случаях, когда дробной части нет.

>>> 1.
1.0

· в виде экспоненты {мантисса}e/E{порядок}:

>>> 1.2e-2
0.012

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

· если аргумент не задан, возращает значение 0.0;

· если аргумент задан в виде числа с плавающей точкой, возвращает значение аргумента;

· если аргументом является строка, она преобразуется в число с плавающей точкой:

>>> float ('1.25E2')
125.0.

При использовании специального метода 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 поддерживает свойства:

· real – указывает вещественную часть числа

>>> comp1.real
4.0;

· imag – указывает мнимую часть числа

>>> comp1.imag
3.0

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

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

 

Оглавление

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

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

· x+y – выполняется сложение чисел x и y, если одно из чисел имеет тип float, то тип результата также будет float
(x.__add__(y) и y.__radd__(x)):

>>> 2+3.0e-1
2.3;

Отметим, что при использовании специальных методов для целых чисел форма:

>>> 2.__add__(2+3.0e-1)

дает синтаксическую ошибку:

SyntaxError: invalid syntax,

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

>>> (2).__add__(3.0e-1)
NotImplemented;

В этом случае уже не появляется сообщение об синтаксической ошибке. Однако вместо результата выполненной операции сложения на экран выводится значение объекта NotImplemented. Это говорит о том, что для указанных типов операндов метод.__add__() не применим, поскольку требует, в отличие от операции сложения, чтобы оба операнда были целыми числами:

>>> (2).__add__(3)
5;

· x-y – выполняется вычитание чисел x и y, если одно из чисел имеет тип float, то тип результата также будет float
(x.__sub__(y) и y.__rsub__(x)):

>>> 5-12.75
-7.75;

· x*y – выполняется умножение чисел x и y, если одно из чисел имеет тип float, то тип результата также будет float
(x.__mul__(y) и y.__rmul__(x)):

>>> 0.77e1*3.456
26.6112;

· x/y – выполняется деление чисел x и y, возвращается значение с типом float, даже если и делимое, и делитель имеют тип int
(x.__truediv__(y) и y.__rtruediv__(x)):

>>> 2/3
0.6666666666666666,

как это видно из результата, точность чисел с плавающей точкой равна 15 десятичным знакам в дробной части;

>>> 12/3
4.0;

· x//y – выполняется целочисленное деление x на y, результат – целое число (округление до ближайшего целого и для положительных, и для отрицательных чисел происходит в сторону минус бесконечности
(x.__floordiv__(y) и y.__rfloordiv__(x)):

>>> 17//4
4;
>>> -17//4
-5;

· x%y – выполняется деление x на y по модулю (определяется остаток от целочисленного деления)
(x.__mod__(y) и y.__rmod__(x)):

>>> 17%4
1;

· x**y – выполняется операция возведения x в степень y (результатом операции 0**0 будет 1, как это принято в языках программирования)
(x.__pow__(y) и y.__rpow__(x)):

>>> 2**10
1024;
>>> 2**(0.5)
1.4142135623730951;

· -x – указывается отрицательное значение x
(x.__neg__();

· +x – x не меняется
(x.__pos__()).

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

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

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

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

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

Оглавление

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

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

· любое число, не равное 0, непустая строка, непустой объект и NotImplemented – принимают значение True;

· числа, равные 0 (0 и 0.0), пустая строка, пустые объекты и значение None – принимают значение False;

· операции сравнения применяются к структурам данных рекурсивно;

· операции сравнения возвращают True или False;

· логические операторы and и or возвращают истинный или ложный объект-операнд:

§ x or y – если x имеет значение False, тогда y, иначе x (в этом случае y не вычисляется);

§ x and y – если x имеет значение False, тогда x (y не вычисляется), иначе y;

§ not x – если x имеет значение False, тогда True, иначе False.

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

>>> 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()

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

· все неименованные аргументы value,... преобразуются в строки;

· между ними вставляются строки-разделители, заданные именованым аргументом sep (по умолчанию – пробелы, т.е. sep=' ');

· в конце вывода добавляется строка завершения, заданная именованым аргументом end, (по умолчанию – символ новой строки, т.е. end='\n');

· файл вывода задается с помощью именованого аргумента file (по умолчанию file='sys.stdout'). Он должен иметь метод write(string);

· необходимость буферизации обычно определяется файлом, но если именованый аргумент flush (введенный в версии Python 3.3), равен True, то принудительно выполняется потоковый режим (по умолчанию flush=False).

Все именованные аргументы должны быть строками. Если именнованный аргумент не задан или имеет значение 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()

Функция 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, где

· v – имя переменной;

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

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

· вычисляется значение выражения, указанного справа от знака равенства, и определяется тип выражения;

· полученное значение заносится в свободные ячейки памяти;

· создается переменная, указанная слева от знака равенства, которая, являясь ссылкой на данные (объект), занесенные в память, получает значение и тип этих данных, например:

>>> n=7
>>> n
7
>>> type (n)
<class 'int'>.

При выполнении оператора 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+=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.

Таблица 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.

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