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

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

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

>>> from M import *

к программе будут подключены все объекты модуля M кроме тех, чьи имена начинаются с одиночного знака подчеркивания (подключение модулей см. в подразделе 1.1 лаб. раб. №2). Другим примером является применение начального знака подчеркивания доя наименования атрибутов, предназначенных для использования внутри описания класса, но разрешенных для даступа из клиентского кода (см. подраздел 2.3 лаб. раб. №11);

· одиночный знак подчеркивания, стоящий в конце имени используется для предотвращения совпадения с ключевым словом. Например, для обозначения переменной, в которой произходит накапливание суммы, вместо имени sum (название встроенной функции) можно использовать имя sum_;

· двойной знак подчеркивания, стоящий в начале имени атрибута, означает его использование только внутри описания класса и запрет доступа из клиентского кода (см. подраздел 2.3 лаб. раб. №11);

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

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

· используются при описании встроенных типов (классов);

· формируют протоколы:

§ контейнера (см. подраздел 1.1 лаб. раб. №3);

§ итератора (см. подраздел 1.2 лаб. раб. №3);

§ последовательностей (см. подраздел 1.4.1 лаб. раб. №3);

· вызываются при выполнении арифметических и побитовых операций (см. подразделы 4.1.4 и 4.1.6);

· вызываются при выполнении встроенных функций для работы с числами (см. подраздел 4.1.5);

· вызываются при выполнении операторов присваивания (см. таблицу 1 в подразделе 6.1);

· вызываются при выполнении операций сравнения (см. подраздел 6.2);

· могут быть также применены при описании пользовательских классов (см. раздел 1 лаб. раб. №11).

Оглавление

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

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

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

Оглавление