Глава 3. Числа

Поступай так, чтобы принести счастье многим людям.

Фрэнсис Хатчесон

В этой главе мы начнем рассматривать простейшие типы данных, используемые в Python:

•булевы значения (они могут быть равны True или False);

• целые числа (например, 42 или 100000000);

•числа с плавающей точкой (числа с десятичной точкой вроде 3.14159, а иногда и экспоненты вроде 1.0е8, что означает десять в восьмой степени, или 100000000.0).

В каком-то смысле они похожи на атомы. В этой главе мы будем использовать их по отдельности, а впоследствии вы узнаете, как объединить данные простейших типов в более крупные «молекулы», такие как списки и словари.

Для каждого типа определены свои правила использования и обработки компьютером. Я также покажу вам, как использовать литералы (например, 97 или 3.1416) и переменные, которые упоминались в главе 2.

Примеры кода, показанные в этой главе, написаны корректно, но являются всего лишь фрагментами. Мы будем вводить эти фрагменты в интерактивный интерпретатор Python и сразу получать результат. Попробуйте запустить их самостоятельно на своем компьютере (такие примеры вы узнаете по подсказке >>>).

Булевы значения

В Python объекты булева (логического) типа данных могут иметь только два значения — True или False. Иногда вы будете использовать их напрямую, а иногда оценивать «истинность» других типов по их значениям. Специальная функция bool() может преобразовать любой тип данных Python в булев.

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

Для ненулевых чисел эта функция вернет значение True:

>>> bool(True)

True

>>> bool(1)

True

>>> bool(45)

True

>>> bool(-45)

True

Нулевые значения преобразуются в значение False:

>>> bool(False)

False

>>> bool(0)

False

>>> bool(0.0)

False

Чем полезны булевы значения, вы узнаете в главе 4. В последующих главах мы поговорим о том, при каких обстоятельствах списки, словари и другие типы данных могут преобразовываться как True или False.

Целые числа

Целые числа — это целые числа без дробей и десятичной точки, ничего особенного. Кроме, возможно, знака и системы счисления (если вы хотите выразить числа в других системах, а не в десятичной).

Числа-литералы

Любая последовательность цифр в Python представляет собой число-литерал:

>>> 5

Можно использовать и простой ноль (0):

>>> 0

Но не ставьте его перед другими цифрами:

>>> 05

File "<stdin>", line 1

SyntaxError: invalid token

Исключение предупреждает вас о том, что вы ввели код, который нарушает правила Python. Что это значит, я объясню в подразделе «Системы счисления». В книге вы увидите еще много примеров исключений, поскольку они являются основным механизмом обработки ошибок в Python.

Запись целого числа вы можете начать с конструкций 0b, 0o или 0x. См. подраздел «Системы счисления» далее в этой главе.

Последовательность цифр указывает на целое число. Если вы поместите знак + перед цифрами, число останется прежним:

>>> 123

123

>>> +123

123

Чтобы указать на отрицательное число, вставьте перед цифрами знак -:

>>> -123

-123

При записи целого числа нельзя использовать запятые:

>>> 1,000,000

(1, 0, 0)

Вместо числа «миллион» вы получите кортеж с тремя значениями (более подробная информация о кортежах находится в главе 7). Однако в качестве разделителя вы можете использовать символ «нижнее подчеркивание».

>>> million = 1_000_000

>>> million

1000000

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

>>> 1_2_3

123

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

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

Оператор	Описание	Пример	Результат
+	Сложение	5 + 8	13
–	Вычитание	90 – 10	80
*	Умножение	4 * 7	28
/	Деление с плавающей точкой	7 / 2	3.5
//	Целочисленное деление	7 // 2	3
%	Вычисление остатка	7 % 3	1
**	Возведение в степень	3 ** 4	81

Сложение и вычитание будут работать так, как вы и ожидаете:

>>> 5 + 9

>>> 100 - 7

>>> 4 - 10

-6

Вы можете работать с любым количеством чисел и операторов:

>>> 5 + 9 + 3

>>> 4 + 3 — 2 — 1 + 6

Обратите внимание на то, что вставлять пробел между числом и оператором не обязательно:

>>> 5+9 + 3

Такой формат выглядит лучше стилистически и проще читается.

Умножение тоже довольно привычно:

>>> 6 * 7

>>> 7 * 6

>>> 6 * 7 * 2 * 3

252

Операция деления чуть более интересна, поскольку существует два ее вида:

• с помощью оператора / выполняется деление с плавающей точкой (десятичное деление);

• с помощью оператора // выполняется целочисленное деление (деление с остатком).

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

>>> 9 / 5

1.8

Целочисленное деление вернет вам целочисленный ответ и отбросит остаток:

>>> 9 // 5

Вместо того чтобы проделать дыру в пространственно-временном континууме, деление на ноль с помощью любого оператора сгенерирует исключение:

>>> 5 / 0

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

ZeroDivisionError: division by zero

>>> 7 // 0

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

ZeroDivisionError: integer division or modulo by z

Целые числа и переменные

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

>>> a = 95

>>> a

>>> a — 3

Как вы узнали во второй главе, а — это имя, которое указывает на целочисленный объект. Когда мы выполнили операцию a–3, мы не присвоили результат переменной a, поэтому ее значение не изменилось:

>>> a

Если вы хотите изменить значение переменной а, придется сделать следующее:

>>> a = a - 3

>>> a

Опять же эта операция некорректна с точки зрения математики, но именно так вы выполняете повторное присваивание значения переменной в Python. В Python выражение, стоящее справа от знака =, вычисляется первым и только затем присваивается переменной с левой стороны.

Проще думать об этом так.

1. Вычитаем 3 из а.

2. Присваиваем результат этого вычитания временной переменной.

3. Присваиваем а значение временной переменной:

>>> a = 95

>>> temp = a - 3

>>> a = temp

Поэтому, когда вы говорите:

>>> a = a – 3

Python рассчитывает результат операции вычитания с правой стороны от знака =, запоминает результат, а затем присваивает его переменной а, которая находится с левой стороны от знака =. Это гораздо быстрее и лучше на вид, чем использование временной переменной.

Вы можете совместить арифметические операторы с присваиванием, поставив оператор перед знаком =. В этом примере выражение а-=3 аналогично выражению а=а-3:

>>> a = 95

>>> a -= 3

>>> a

А это выражение аналогично выражению а=а+8:

>>> а = 92

>>> a += 8

>>> a

100

Это — выражению а=а*2:

>>> а = 100

>>> a *= 2

>>> a

200

Здесь представлен пример деления с плавающей точкой, а=а/3:

>>> а = 200

>>> a /= 3

>>> a

66.66666666666667

Теперь попробуем использовать сокращенный вариант а=а//4 (целочисленное деление):

>>> a = 13

>>> a //= 4

>>> a

Символ % в Python имеет несколько разных применений. Когда он находится между двух чисел, с его помощью вычисляется остаток от деления первого числа на второе:

>>> 9 % 5

Вот так можно получить частное и остаток одновременно:

>>> divmod(9,5)

(1, 4)

В противном случае вам пришлось бы считать их по отдельности:

>>> 9 // 5

>>> 9 % 5

Только что вы увидели нечто новое — функцию с именем divmod: она получает целые числа 9 и 5, а возвращает двухэлементный кортеж. Как я уже говорил, с кортежами вы познакомитесь в главе 7, а с функциями — в главе 9.

Рассмотрим последнюю математическую функцию, которая также позволяет работать одновременно с целыми числами и с числами с плавающей точкой — возведение в степень с помощью оператора **:

>>> 2**3

>>> 2.0 ** 3

8.0

>>> 2 ** 3.0

8.0

>>> 0 ** 3

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

Рассмотрим, что получится, если ввести следующее:

>>> 2 + 3 * 4

Если выполнить сложение первым, 2+3 равно 5, а 5*4 равно 20. Но если выполнить первым умножение, 3*4 равно 12, а 2+12 равно 14. В Python, как и в большинстве других языков, умножение имеет более высокий приоритет, чем сложение, поэтому вы увидите ответ, совпадающий со второй версией:

>>> 2 + 3 * 4

Как узнать приоритет той или иной операции? В приложении Д есть большая таблица со всеми правилами. Однако на практике я и сам никогда в нее не смотрю, потому что гораздо проще добавить пару скобок, чтобы сгруппировать код и вычисления нужным образом:

>>> 2 + (3 * 4)

Этот пример возведения в степень:

>>> -5 ** 2

-25

аналогичен следующей конструкции:

>>> - (5 ** 2)

-25

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

>>> (-5) ** 2

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

Системы счисления

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

Как правило, у нас десять пальцев на руках и ногах, поэтому мы считаем: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. После этого у нас заканчиваются цифры, и мы переносим единицу на место десятки и ноль — на место единицы: 10 означает «одна десятка и ноль единиц». В отличие от римских цифр в арабских цифрах нет одного символа, который представлял бы собой 10. Далее мы считаем: 11, 12… 19, переносим единицу, чтобы сделать 20 (две десятки и ноль единиц), и т.д.

Система счисления указывает, сколько цифр вы используете до того, как перенесете единицу. В двоичной (бинарной) системе счисления единственными цифрами являются 0 и 1. Такие значения может иметь и знаменитый бит. Двоичные 0 и 1 точно такие же, как и десятичные. Однако, если в этой системе сложить 1 и 1, вы получите 10 (одна десятичная двойка плюс ноль десятичных единиц).

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

• 0b или 0B для двоичной системы (основание 2);

• 0o или 0O для восьмеричной системы (основание 8);

• 0x или 0X для шестнадцатеричной системы (основание 16).

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

Интерпретатор выведет эти числа как десятичные. Попробуем воспользоваться каждой из систем счисления. Первой выберем старое доброе десятичное число 10, которое означает «одна десятка и ноль единиц»:

>>> 10

Теперь возьмем двоичное (основание 2) число 0b10, что означает «одна (десятичная) двойка и ноль единиц»:

>>> 0b10

Восьмеричное (основание 8) число 0o10 означает «одна (десятичная) восьмерка и ноль единиц»:

>>> 0o10

Шестнадцатеричное (основание 16) число 0x10 означает «одно (десятичное) 16 и ноль единиц»:

>>> 0x10

Вы можете пойти и в обратном направлении, преобразовав целое число в строку с любой из этих систем счисления:

>>> value = 65

>>> bin(value)

'0b1000001'

>>> oct(value)

'0o101'

>>> hex(value)

'0x41'

Функция chr() преобразует целое число в его строковый эквивалент, состоящий из одного символа:

>>> chr(65)

'A'

Функция ord() выполняет противоположную задачу:

>>> ord('A')

Если вам интересно, какие «цифры» использует шестнадцатеричная система счисления, то вот они: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e и f. 0ха — это десятичное число 10, а 0xf — десятичное 15. Добавьте 1 к 0xf и получите 0х10 (десятичное 16).

Зачем использовать системы счисления, отличные от десятичной? Они удобны для битовых операций, которые описаны в главе 12. Там же можно найти и детальную информацию о переводе чисел из одной системы счисления в другую.

У котов, как правило, есть по пять пальцев на передних лапах и по четыре на задних — всего 18. Если вы когда-нибудь встретите котов-ученых в лабораторных халатах, они, скорее всего, будут обсуждать арифметику восемнадцатеричной системы счисления. Мой кот Честер, которого вы можете увидеть на рис. 3.1, полидакт — у него целых 22 пальца (или около того — их сложно различить). Если бы он захотел подсчитать все кусочки корма, разбросанные вокруг его миски, он, вполне вероятно, воспользовался бы 22-ричной системой счисления (далее по тексту — честеричной системой счисления), в которой использовались бы цифры от 0 до 9 и символы от a до l.

03_01.tif

Рис. 3.1. Честер — прекрасный пушистый парень, изобретатель честеричной системы счисления

Преобразования типов

Чтобы изменить тип данных на целочисленный, воспользуйтесь функцией int().

Функция int() принимает один входной аргумент и возвращает одно значение — преобразованный в целое число эквивалент входного аргумента. При этом она сохраняет целую часть числа и отбрасывает любой остаток.

Как было сказано в начале главы, простейший тип данных в Python — булев, переменные этого типа могут иметь только значения True и False. После преобразования в целые числа они представляют собой значения 1 и 0:

>>> int(True)

>>> int(False)

В свою очередь, функция bool() возвращает булев эквивалент целого числа:

>>> bool(1)

True

>>> bool(0)

False

При преобразовании числа с плавающей точкой в целое число просто отсекается все, что находится после десятичной точки:

>>> int(98.6)

>>> int(1.0e4)

10000

Преобразование числа с плавающей точкой в булево значение не должно вас удивить:

>>> bool(1.0)

True

>>> bool(0.0)

False

Наконец, рассмотрим пример получения целочисленного значения из текстовой строки (глава 5), которая содержит только цифры и, возможно, разделители _ или знаки + и -:

>>> int('99')

>>> int('-23')

-23

>>> int('+12')

>>> int('1_000_000')

1000000

Если число в строке представлено не в десятичной системе счисления, а в какой-то иной, вы можете включить основание этой системы:

>>> int('10', 2) # двоичная

>>> int('10', 8) # восьмеричная

>>> int('10', 16) # шестнадцатеричная

>>> int('10', 22) # честеричная

Преобразование целого числа в целое число ничего не изменит, но и не навредит:

>>> int(12345)

12345

Если вы попробуете преобразовать что-то непохожее на число, сгенерируется исключение:

>>> int('99 bottles of beer on the wall')

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

ValueError: invalid literal for int() with base 10: '99 bottles of beer on the wall'

>>> int('')

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

ValueError: invalid literal for int() with base 10: ''

Текстовая строка в этом примере начинается с корректных символов-цифр (99), но продолжается символами, которые функция int() обработать не может.

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

>>> int('98.6')

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

ValueError: invalid literal for int() with base 10: '98.6'

>>> int('1.0e4')

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

ValueError: invalid literal for int() with base 10: '1.0e4'

Если вы смешаете численные значения, Python попытается автоматически их преобразовать:

>>> 4 + 7.0

11.0

Булево значение False рассматривается как 0 или 0.0, когда смешивается с целыми числами или числами с плавающей точкой, а True — как 1 или 1.0:

>>> True + 2

>>> False + 5.0

5.0

Насколько объемен тип int

В Python 2 размер переменной типа int имел ограничение в 32 или в 64 бита, в зависимости от вашего процессора. В 32 битах можно было хранить любое целое число в диапазоне от –2 147 483 648 до 2 147 483 647.

Для переменных типа long выделялось 64 бита, что позволяло хранить значения в диапазоне от –9 223 372 036 854 775 808 до 9 223 372 036 854 775 807. В Python 3 тип long отсутствует, а переменная типа int может быть любого размера — даже больше 64 бит. Есть возможность поиграть и с такими большими числами, как гугол (это единица со ста последующими нулями), имя которому придумал девятилетний мальчик в 1920 году ():

>>>

>>>googol = 10**100

>>> googol

10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

>>> googol * googol

100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

Гуголплекс — число, равное 10**googol (если вы хотите записать его самостоятельно, то подскажу, что оно содержит тысячу нулей). Сначала именно так хотела назвать себя компания Google (), но все же остановилась на варианте «гугол». При этом правописание перед регистрацией доменного имени google.com никто не проверил.

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

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

Значениями целочисленного типа являются целые числа, но числа с плавающей точкой (в Python они называются float) имеют десятичную точку:

>>> 5.

5.0

>>> 5.0

5.0

>>> 05.0

5.0

Числа с плавающей точкой могут содержать десятичную целочисленную экспоненту после буквы e:

>>> 5e0

5.0

>>> 5e1

50.0

>>> 5.0e1

50.0

>>> 5.0 * (10 ** 1)

50.0

Для разделения цифр можно использовать символ «нижнее подчеркивание» (_), как и в случае с целыми числами:

>>> million = 1_000_000.0

>>> million

1000000.0

>>> 1.0_0_1

1.001

Числа с плавающей точкой обрабатываются так же, как и целые: вы можете использовать операторы +, −, *, /, //, **, % и функцию divmod().

Для того чтобы преобразовать другие типы в тип float, следует использовать функцию float(). Булевы значения по-прежнему обрабатываются как небольшие числа:

>>> float(True)

1.0

>>> float(False)

0.0

При преобразовании целого числа типа int в число типа float просто добавляется десятичная точка:

>>> float(98)

98.0

>>> float('99')

99.0

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

>>> float('98.6')

98.6

>>> float('-1.5')

-1.5

>>> float('1.0e4')

10000.0

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

>>> 43 + 2.

45.0

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

>>> False + 0

>>> False + 0.

0.0

>>> True + 0

>>> True + 0.

1.0

Математические функции

Python поддерживает комплексные числа и имеет привычный набор математических функций, таких как квадратный корень, косинус и т.д. Их рассмотрение отложим до главы 22, в которой также обсудим применение Python в науке.

Читайте далее

В следующей главе мы наконец попрощаемся с однострочными примерами кода. Вы научитесь принимать решения в коде с помощью утверждения if.

Упражнения

В этой главе мы рассмотрели атомы Python: числа, строки и переменные. Выполним с ними несколько небольших упражнений в интерактивном интерпретаторе.

3.1. Сколько секунд в часе? Используйте интерактивный интерпретатор как калькулятор и умножьте количество секунд в минуте (60) на количество минут в часе (тоже 60).

3.2. Присвойте результат вычисления предыдущего задания (секунды в часе) переменной, которая называется seconds_per_hour.

3.3. Сколько секунд в сутках? Используйте переменную seconds_per_hour.

3.4. Снова посчитайте количество секунд в сутках, но на этот раз сохраните результат в переменной seconds_per_day.

3.5. Разделите значение переменной seconds_per_day на значение переменной seconds_per_hour, используя деление с плавающей точкой (/).

3.6. Разделите значение переменной seconds_per_day на значение переменной seconds_per_hour, используя целочисленное деление (//). Совпадает ли полученный результат с ответом из предыдущего пункта без учета символов .0 в конце?

В версиях Python 3.6 и выше.