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

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

· abs(x) – возвращает абсолютное значение параметра x
(x.__abs__()):

>>> abs (-7)
7,

для комплексных чисел, заданных как a+bj, функция считается по формуле (a**2+b**2)**(1/2):

>>> abs (4+3j)
5.0;

· divmod(x,y) – имеет два параметра: x задает делимое, y – делитель, возвращает кортеж (см. подраздел 2.1 лабораторной работы №2), элементами которого являются соответственно результаты операций // и % над параметрами
x.__divmod__(y):

>>> divmod (17,3)
(5, 2);

· pow(x,y) – возвращает результат возведения первого параметра в степень, заданную вторым параметром (функция аналогична операции **)
(x.__pow__(y) или x.__rpow__(y)):

>>> pow (3,4)
81;
>>> (3).__rpow__(4)
64;

· round(x[, n]) – возвращает число с плавающей точкой, округленное до n цифр после десятичной точки. Если аргумент n опущен или равен 0 – возвращает целое число. Для встроенных типов, поддерживающих функцию round(), значения округляются до числа, ближайшего к 10 в степени минус n. Если два значения одинаково близки, то округление идет в направлении четного числа
(x.__round__(n) или x.__rround__(n)):

>>> round (1.333,2)
1.33
>>> round (2.5)
2
>>> round (3.5)
4.

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

>>> round (2.675, 2)

дает

2.67

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

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

>>> n=2014
>>> n.bit_length()
11.

Оглавление

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

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

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

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

· & – выполняет побитовую операцию И
(a.__and__(b) и b.__rand__(a)):

>>> a&b
12 # 0b00001100;

· | – выполняет побитовую операцию ИЛИ
(a.__or__(b) и b.__ror__(a)):

>>> a|b
61 # 0b00111101;

· ^ – выполняет побитовую операцию ИСКЛЮЧАЮЩЕЕ ИЛИ (XOR)
(a.__xor__(b) и b.__rxor__(a)):

>>> a^b
49 # 0b00110001;

· ~ – выполняет унарную операцию побитового инвертирования
(a.__invert__():

>>> ~a
-61 # 0b110000011;

· >> – выполняет сдвиг левого операнда вправо на число разрядов, заданное правым опрерандом
(a.__rshift__(b) и b.__rrshift__(a)):

>>> a>>2
15 # 0b00001111;

· << – выполняет сдвиг левого операнда влево на число разрядов, заданное правым опрерандом
(a.__lshift__(b) и b.__rlshift__(a)):

>>> a<<2
240 # 0b11110000.

Оглавление

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

Данные логического типа являются подклассом целых чисел 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.

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

>>> 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 имеет следующую форму:

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:

· 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.

 

Оглавление

Оператор pass

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

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

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

KeyboardInterrupt.

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

Оглавление

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

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

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

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

· операнд слева вычисляется раньше операнда справа во всех бинарных операциях, кроме возведения в степень;

· цепочка сравнений вида a < b < c... y < z фактически равносильна: (а < b) and (b < c) and... and (y < z);

· перед фактическим выполнением операции вычисляются нужные для нее операнды. В большинстве бинарных операций предварительно вычисляются оба операнда (сначала левый), но операции or и and, а также цепочки сравнений вычисляют такое количество операндов, которое достаточно для получения результата. В невычисленной части выражения в таком случае могут даже быть неопределенные имена. Это важно учитывать, если используются функции с побочными эффектами;

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

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

Оглавление

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

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

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

Таблица 4 – Встроенные функции языка Python 3.4

Built-in functions