Арифметические действия в Python.
Складывание и вычитание
Выполним несколько упражнений с операциями складывания и вычитания.
Запустите интерпретатор Pythonwin, и выполните команду
>>> 1 + 1
Если после нажатия клавиши <Enter> Python не даст ответ вам результатом 2, значит, у вас большие проблемы!
Теперь попробуйте выполнить более сложные задания, например сложите нескольких чисел, а потом сложите положительные и отрицательные числа за своим выбором, или воспользуйтесь данными из следующего рисунка:
Рис.1. 1 + 1
Давайте теперь попробуем складывать и вычитать действительно большие числа. Выполнение этого задания с помощью карандаша и бумаги, безусловно, не вызовет у вас никаких проблем. Но если вы привыкли пользоваться современным калькулятором, то проблема может возникнуть из-за того, что ваши числа превысят максимально допустимую разрядность вашего электронного устройства.
Несложно определить максимально допустимое число для калькулятора. Просто перечислите число значимых позиций на табло. При использовании компьютера точность вычислений не такая очевидна. Дело в том, что между внутренним представлением чисел, как его видит компьютер, и тем форматом, в котором число отображается на экране, существуют большие отличия.
Для внутреннего представления чисел большинство компьютеров используют 32 бита, причем один из этих битов обычно используется для представления знака числа, которое указывает, есть ли это число положительном или відємним. Поэтому для числового значения остается 31 бит ( максимальное число 2**30-1). Чтобы увидеть это число, наберите выражение (2**30) - 1 и нажмите ENTER
>>> (2**30)-1
2147483647L
Здесь операция ** означает возведения в степень.
Операцию поднесения к степени числа 2 можно заменить операцией сдвига влево (<<). Например
2**2 = 1<<2
Чтобы убедиться в этом - наберите выражение 2**2 == 1<<2 и нажмите ENTER. Получите
>>> 2**2 == 1<<2
True
Здесь знак (==) означает сравнение двух выражений. Если они совпадают, то возвращается значение True, иначе результат сравнения будет False.Проверьте это на примере (3==5).
Следовательно, выражение 1<<31помістить 1 в 32-й бит, а все младшие биты будут иметь значение 0. Чтобы получить максимальное число со знаком + достаточно высчитать из полученного числа единицу. При этом 32-й бит примет значение 0, а все последние биты - значение 1. Это и будет максимальное число со знаком, которое можно представить 32-ма битами, то есть число 2 147 483 647 (два миллиарда с пустяком).
Это число можно увидеть как в десятичной форме (это мы уже сделали), так и в двоичной и 16-ковій форме:
>>> a=(1<<31) - 1
>>> bin(a)
'0'0b1111111111111111111111111111111'
>>> hex(a)
'0'0x7fffffffL'
>>>
Остается объяснить смысл буквы L в конце числа. Справа вот в чем. Все языки, за исключением Пайтона, используют для представления целых чисел только 32 биты (4 байта) памяті. В Пайтоні же для представления целых чисел используется столько байт, сколько нужно для числа. Однако, как только мы с вами превышаем в вычислениях норму в 32 биты, Пайтон добавляет до 32 бітного слова дополнительные байты и помечает получаемый результат буквой L (long) в конце числа.
Почему же тогда результат следующих действий
>>> (1<<31)-1
2147483647L
обозначается буквой L, если данное число вмівщується в 32-х битах?
Тем более, если другие операции возвращают правильный пезультат:
>>> a=(1<<31) - 1
>>> print (a)
2147483647
Ответ обоснуйте.
Следовательно, добавление символу L после любого числа сообщает Python, что вычисления целых выражений велись из пекревищенням нормы в 32 биты.
В Пайтоні число разрядов для представления целых чисел ограничивается только обємом доступной оперативной памяті.
Теперь давайте поработаем с действительно большими числами. Введите единицу, а за ней 100 нулей) :
1000000000000000000000000000000000000000
00000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000L
Число, которое состоит из единицы с сотней нулей, называется гугол (googol). Это название было введено в обиход американским математиком Эдвардом Каснфом (Edward Kasner), a придумал его название девятилетний племянник, Милтоном Сироттой (Milton Sirotta).
Добавляйте после этого числа знак "плюс" (+), а потом опять вставьте такое же число и нажмите клавишу <Enter>. Результат показан на рис. 3.5.
Рис. 3.5. Складывание двух длинных чисел
Вы можете складывать обычные целые числа и длинные целые числа без каких бы то ни было проблем. Правилами Python устанавливается, что всякий раз, когда вы выполняете арифметические функции с любыми двумя операндами, меньший операнд приводится к типа больше. Таким образом, если вы подытоживаете 1 + 100000000000000000000000L, Python автоматически превратит 1 в 1L.
Вам придется также столкнуться еще с третьим типом чисел - числа с плавающей запятой. Это числа, в которых есть десятичная запятая, например 1,1 и 3,14159265359. (В англоязычных странах для представления десятичных чисел вместо плавающей запятой используется точка. Обратите на это внимание и не удивляйтесь, что когда в тексте мы говорим о плавающей кому, а в примерах ставим точку.
Примечание: использование запятой в коде программы Python вызовет ошибку.
Иногда в результате складывания и вычитания таких чисел выводится результат, который вы даже и не допускали получить. Да, например, на рис. 3.6 показано выражение, результатом которого вы, скорее всего, ожидали бы увидеть 0,00001.
Рис. 3.6. Вычитание чисел с плавающей запятой
В целом, вы такой результат и получили. Не удивляйтесь, просто число представлено в экспоненциальном формате, о котором мы уже говорили и поговорим об этом еще раз позже. А пока перейдем к следующей теме.
Умножение, отношение и деление по модулю
В предыдущем разделе вы узнали о складывании и вычитании обычных целых чисел, длинных целых чисел и чисел с плавающей запятой. В этом разделе вы познакомитесь с умножением, делением и с кое-чем таким, о чем вы могли еще не слышали, - делением по модулю. При этом будут использоваться те же типы чисел.
И опять позволю себе повториться - правила выполнения этих операций в Python не очень отличаются от тех, которые вам знакомые из школы. Единственный нюанс, который необходимо всегда учитывать, заключается в том, что тип операнда в значительной степени определяет то, как Python будет обрабатывать числа. Например, деление числа 10 на 4,0, как показано на рис. 3.7, дает ожидаемый результат - 2,5.
Рис. 3.7. Деление чисел
Но в случае, показанном на рис. 3.8, мы получаем абсолютно другой ответ.
Рис. 3.8. Еще один пример деления
Неспівпадання ответов объясняется тем, что в первом случае, указав десятичную кому (точку) в операнде 4.0, мы сообщили Python, что нам небезразличная информация об остатке деления после десятичной запятой. Во втором случае, опустив десятичную кому, мы явно указали Python, что нас интересует только целая часть числа. И Python любезно отбросил дробную часть числа (.5).
Таким образом, как и в случае с операциями складывания и вычитания, Python определяет формат результата по форматам переданных ему операндов. Поэтому следует внимательно относиться к типам операндов. Очень просто потерять десятичную кому там, где в действительности вы ожидаете ее увидеть. Такая потеря в дальнейшем может привести к неправильной работе программы.
Но легкость, с которой при делении можно получить неожиданный или даже неправильный результат, была и остается темой жарких дебатов, которые ведутся и до этого дня среди участников телеконференций по тематике программирования на Python. Некоторые респонденты доводят необходимость применения специального оператора, отличающегося от обычного оператора деления (/), какой бы указывал Python, что требуется выполнить целочисленное деление (как показано на рис. 3.8), или наоборот, что устанавливает для результата формат числа с плавающей запятой (рис. 3.7). Так, как специальные операторы деления предлагалось использовать сочетание символов /. для деления только с плавающей запятой и сочетания // - только для целочисленного деления. Но эти предложения не нашли поддержки у автора языка, хотя он обещал подумать над этим вопросом и внести некоторые изменения в будущие версии Python.
Как и в случаях со складыванием и с вычитанием, длинные целые числа можно использовать в выражениях умножения и деления (рис. 3.9).
Рис. 3.9. Деление и умножение длинных чисел
Обратите внимание, что в третьем примере, показанном на рис. 3.9, используется новый оператор, обозначенный символом %, - деление по модулю. В отличие от операции целочисленного деления, которое возвращает целую часть от деления, эта операция возвращает остаток от целочисленного деления.
С помощью этого оператора можно осуществлять деление обычных или длинных целых чисел, причем от полученного результата отбрасывается целая часть числа (часть), а остаток возвращается. Например, выражение 136656000L % 13 повернет нуль, потому что число 136 656 000 делящееся на 13 без остатка.
Существует специальная функция, которую можно использовать для возвращения части и остатка от деления заодно. Функция divmod(x, y) возвращает результаты выполнения двух действий : х / в и х % у. Вы можете проверить это, введя команду
>>> print divmod (53,13)
(4, 1)
>>>
Полученный результат свидетельствуют о том, что Пайтон имеет групповой тип данных, который называется кортежем (tuple), о чем речь будет идти позже.