Простой Python полностью

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

>>> int('98.6')

Traceback (most recent call last):

··File "", line 1, in

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

>>> int('1.0e4')

Traceback (most recent call last):

··File "", line 1, in

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

3

>>> False + 5.0

5.0

В Python 2 размер переменной типа int был ограничен 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 бит. Поэтому вы можете выполнить арифметические действия наподобие следующих (10**100 называется гугол (googol), компания Google называлась так до того, как решила сменить свое название на более простое):

>>>

>>> googol = 10**100

>>> googol

100000000000000000000000000000000000000000000000000000000000000000000000000000

00000000000000000000000

>>> googol * googol

100000000000000000000000000000000000000000000000000000000000000000000000000000

000000000000000000000000000000000000000000000000000000000000000000000000000000

000000000000000000000000000000000000000000000

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

Значениями целочисленного типа являются целые числа, но числа с плавающей точкой (в Python они называются float) имеют десятичную запятую. Числа с плавающей точкой обрабатываются так же, как и целые: вы можете использовать операторы +, —, *, /, //, **, % и функцию 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 имеет привычный набор математических функций вроде квадратного корня, косинуса и т. д. Мы рассмотрим их в приложении В, где также обсудим применение Python в науке.

Непрограммисты думают, что программисты хорошо разбираются в математике, потому что работают с числами. На самом деле большинство программистов работают с текстовыми строками гораздо чаще, чем с числами. Логическое (и креативное!) мышление для них зачастую гораздо важнее математических навыков.

Благодаря поддержке стандарта Unicode Python 3 может содержать символы любого языка мира, а также многие другие символы. Необходимость работы с этим стандартом была одной из причин изменения Python 2. Это хорошая причина использовать версию 3. Я буду применять стандарт Unicode лишь иногда, поскольку это может показаться сложным. В следующих примерах я буду использовать строки формата ASCII.

Строки являются первым примером последовательностей в Python. В частности, они представляют собой последовательности символов.