Из Delphi в Python. Неизменяемые типы данных. Числа

В предыдущей части мы разобрались с тем как установить Python на свой компьютер, рассмотрели устанавливаемые программы и написали небольшой скрипт «Hello, world» и его модификацию с использованием Python 3.7. Сегодня рассмотрим типы данных Python и рассмотрим несколько примеров, касающихся использования этих самых типов данных.

Сразу следует оговориться, что все данные в языке Python — это объекты и каждый объект может иметь свой тип, будь то один из встроенных типов или созданный нами.

Однако, прежде, чем мы приступим к изучению типов данных в Python, необходимо сделать небольшую ремарку и рассказать об именовании переменных в Python.

Именование переменных в Python

В принципе, основные правила именования переменных в Python совпадают с именованием переменных в Delphi, то есть:

1. имя переменной может содержать буквы, цифры и знаки подчеркивания;
2. имя переменной не может начинаться с цифры;
3. в качестве имени переменной нельзя использовать ключевые (зарезервированные) слова.

Думаю, что с этими правилами знакомы все, кто написал хотя бы самую простенькую программку для решения квадратного уравнения или что-то в таком духе. В отличие от Delphi, в Python:

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

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

• не используйте имена переменных, начинающиеся с двух знаков подчеркивания (__), а также имена, включающие в себя два знака подчеркивания в начале и конце имени — такие переменные играют в Python особую роль, о которой, думаю, расскажу чуть позднее.

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

• при именовании переменной следите за регистром;

В Python a и A — это разные переменные.

Таким образом, если в Delphi я мог назвать переменную, например, так:

var __MyInt__: integer;

и это было бы, в принципе, допустимо, то в Python — это категорически не приветствуется.
В Delphi я бы мог (хотя это не желательно) сделать вот так:

var a: integer;
begin
  A:=100;
end

В Python — это приведет к ошибке, так как a и A — это разные переменные.

Разобравшись немного с именованием переменных, перейдем к типам данных.

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

Основные (встроенные) типы данных в Python подразделяются на изменяемые и неизменяемые. Вначале рассмотрим неизменяемые типы данных.

Неизменяемые типы данных Python

К неизменяемым типам данных в Python относятся: числа, строки, кортежи, диапазоны и тип bytes. Смысл неизменяемого типа — создав переменную неизменяемого типа и присвоив ей значение, более мы изменить её значение не можем. Чтобы разобраться с этим, рассмотрим вот такой пример:

>>> a = 1
>>> a
1
>>> a = 2
>>> a
2

Казалось бы — где тут неизменяемое значение? Было 1, а стало 2 и всё в порядке — Python никаких ошибок не выдал. Однако, если рассмотреть весь процесс, описанный в коде выше, по шагам, то получим следующее поведение:

1. a = 1 — создаем числовой объект со значением 1 и присваиваем ссылку на этот объект переменной a.
2. a = 2 — создаем новый числовой объект со значением 2 и присваиваем переменной a ссылку на этот объект
3. старый объект (тот, что со значением 1) автоматически удаляется сборщиком мусора.

Чтобы убедиться в том, что переменная a на каждом шаге в коде выше действительно содержит разные ссылки, воспользуемся функцией id(), которая и будет возвращать нам адрес в памяти где содержится наш объект.

>>> a = 1
>>> id(a)
1529559296
>>> a = 2
>>> id(a)
1529559312

Ну и, раз уж зашла речь про адреса, то сразу рассмотрим и оператор is. Этот оператор вернет True, если слева и справа от него находятся переменные, содержащие одинаковые указатели на объект. Рассмотрим вот такой пример:

>>> a = 2
>>> b = 2
>>> a is b
True

Что здесь не так? По идее, в документации к Python сказано следующее: каждый объект в Python имеет идентификатор, тип и значение. В примере мы создали два объекта с числовым типом данных, соответственно и оператор is должен был выдать False, однако, получили True. Судя по тому, что удалось изучить в Сети и, касающееся такого поведения Python, причина кроется в механизмах кэширования с целью ускорения работы. Более того, всё в той же официальной документации, дословно сказано следующее:

for immutable types, operations that compute new values may actually return a reference to any existing object with the same type and value, while for mutable objects this is not allowed.

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

a and b may or may not refer to the same object with the value one, depending on the implementation

То есть, переменные могут, а может и не могут ссылаться на один и тот же объект — тут как повезет. Исходя из вышесказанного вытекает и небольшая такая заметка на память:

Числа

int — целые числа. При этом размер числа ограничен только объемом памяти. Опять же, пример, показывающий различия в Delphi и Python:

Такой код в Delphi:

var x: integer;
begin
  x:=2147483647;
  x:=x+101;
  ShowMessage(IntToStr(x));
end;

Выдаст результат -2147483548, так как тип integer в Delphi — это от -2147483648 до 2147483647.
Тот же самый код в Python выдаст верное (с математической точки зрения) значение:

>>> z = 2147483647+101
>>> z
2147483748

float — числа с плавающей точкой. Python использует только числа с двойной точностью. Этот тип данных ничем не отличается от Double в Delphi. Этот код выдаст одинаковый результат в обоих языках программирования:

>>> y = 9.9E308
>>> y
inf
>>> y = 1.79E308
>>> y
1.79e+308

complex — комплексные числа. Работать с комплексными числами в Python достаточно просто. Ниже представлен пример записи комплексного числа, а также получение его реально и мнимой части:

>>> f = 2.1+2j #объявили комплексное число
>>> type(f) #проверили тип данных
<class 'complex'>;
>>> f.real #получили реальную часть числа
2.1
>>> f.imag #получили мнимую часть числа
2.0

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

В принципе, примерно то же, что и в Delphi, но в Python добавился оператор возведения в степень (в Delphi для этого используется функция power(x,y)), а также добавилось второе деление (с округлением вниз). Чтобы посмотреть, как работает обычное деление и деление вниз, рассмотрим вот такой пример:

>>> 10/2 #обычное деление двух целых чисел - на выходе имеем вещественный тип
5.0
>>> 10//2 #деление с округлением вниз двух целых чисел. Результат - целое число
5
>>> 10/3 #обычное деление двух целых чисел. Остаток есть
3.3333333333333335
>>> 10//3 #деление с округлением вниз двух целых чисел. Остаток отброшен
3

При выполнении операций над числами разных типов мы получаем на выходе более сложный тип данных, то есть сначала идет целый тип, затем вещественный и затем — комплексный. Вместе с этим, меня, после Delphi немного озадачил пример, приведенный в книге:

>>> 0.3-0.1-0.1-0.1
-2.7755575615628914e-17

Очевидно, что на выходе должен быть ноль, что, в принципе и демонстрирует Delphi, а Python выдал отрицательный результат. Как пишем автор книги, причина кроется в ограничении точности вычислений и рекомендует для операций с фиксированной точностью использовать модуль decimal вот так:

>>> from decimal import Decimal
>>> Decimal("0.3")-Decimal("0.1")-Decimal("0.1")-Decimal("0.1")
Decimal('0.0')

Результат, конечно, оказался равен нулю, но, что-то мне с трудом верится в то, что это единственно верный способ выполнения операций с заданной точностью. Пока оставим этот вопрос на потом, дальше — разберемся.

Числа в Python можно представлять в нескольких формах, в т.ч. в двоичной, восьмеричной и шестнадчатеричной.
Число в двоичной форме в Python начинается с комбинации символов 0b или OB и содержит цифры 0 или 1, например:

>>> 0b111111111, 0B000100010001, 0b1111000
(511, 273, 120)

Восьмеричные числа начинаются с 0o или 0O и содержат цифры от 0 до 7:

>>> 0o01234567, 0O345601, 0o76456
(342391, 117633, 32046)

Шестнадцатеричные числа начинаются с комбинации 0x или 0X и содержат цифры от 0 до 9 и буквы от A до F:

>>> 0x1234567890A, 0Xabcdef
(1250999896330, 11259375)

Соответственно, вне зависимости от того в какой форме представлены числа, над ними также можно выполнять все операции представленные выше, например, складывать:

>>> 0x123ABC+0.1+0o12334+0b110011
1200075.1

Как и в Delphi у Python есть достаточно много встроенных методов работы с числами, например, round, abs, pow, max, min и т.д. Есть также отдельные модули, реализующие более серьезную математику, типа Math и т.д., но о них я расскажу отдельно в следующих частях своего повествования о переходе с Delphi на Python.

Книжная полка

	Автор:Владимир Дронов Название: Python 3. Самое необходимое Описание Описан базовый синтаксис языка Python 3: типы данных, операторы, условия, циклы, регулярные выражения, встроенные функции, классы и объекты, итераторы и перечисления, обработка исключений, часто используемые модули стандартной библиотеки	Купить на ЛитРес
	Автор: Майк МакГрат Название: Python. Программирование для начинающих Описание: Книга «Программирование на Python для начинающих» является исчерпывающим руководством для того, чтобы научиться программировать на языке Python. В этой книге с помощью примеров программ и иллюстраций, показывающих результаты работы кода, разбираются все ключевые аспекты языка. Установив свободно распространяемый интерпретатор Python, вы с первого же дня сможете создавать свои собственные исполняемые программы!	Купить на ЛитРес