Из этого руководства вы узнаете о базовых встроенных типах данных Python: числовых, строковых и логических (булевых).
Целые числа
В Python 3 фактически нет предела длины целочисленного значения. Конечно, оно ограничено объемом доступной в системе памяти (как и любые другие типы данных), но в остальном — может быть таким длинным, как нужно:
>>> print(123123123123123123123123123123123123123123123123 + 1)
123123123123123123123123123123123123123123123124
Python интерпретирует последовательность десятичных цифр без префикса как десятичное число:
>>> print(10)
10
Следующие строки могут быть добавлены к значению числа, чтобы обозначить основание отличное от 10:
| Префикс | Интерпретация | Основание |
|---|---|---|
| 0b (ноль + «b» в нижнем регистре) 0B (ноль + «b» в верхнем регистре) | Двоичное | 2 |
| 0o (ноль + «o» в нижнем регистре) 0O (ноль + «O» в верхнем регистре) | Восьмеричное | 8 |
| 0x (ноль + «x» в нижнем регистре) 0X (ноль + «X» в верхнем регистре) | Шестнадцатеричное | 16 |
Например:
>>> print(0o10)
8
>>> print(0x10)
16
>>> print(0b10)
2
Чтобы больше узнать о значениях целых чисел с основанием не равным 10, обратитесь к следующим статьям в Википедии: двоичная, восьмеричная, шестнадцатеричная.
Базовый тип целого числа в Python, вне зависимости от используемого основания, называется int:
>>> type(10)
<class 'int'>
>>> type(0o10)
<class 'int'>
>>> type(0x10)
<class 'int'>
Примечание: отличный момент, чтобы напомнить, что функцию print() не нужно использовать при работе в командной строке. Просто вводите значения после
>>>и нажимайте Enter для отображения:>>> 10 10 >>> 0x10 16 >>> 0b10 2Многие примеры будут использовать эту особенность интерпретатора.
Но это не работает с файлами скриптов. Значение в строке файла со скриптом не делает ничего само по себе.
Числа с плавающей точкой
Тип float в Python означает число с плавающей точкой. Значения float определяются с десятичной точкой. По желанию можно добавить символ e или E после целого числа, чтобы обозначить, что это экспоненциальная запись.
>>> 4.2
4.2
>>> type(4.2)
<class 'float'>
>>> 4.
4.0
>>> .2
0.2
>>> .4e7
4000000.0
>>> type(.4e7)
<class 'float'>
>>> 4.2e-4
0.00042
Подробнее: представление float
Далее следует более подробная информация о том, как Python изнутри представляет числа с плавающей точкой. Вы без проблем можете пользоваться этим типом данных, не понимая этот уровень, так что не волнуйтесь, если описанное здесь покажется чересчур сложным. Информация представлена для особо любопытных.
Почти все платформы представляют числа с плавающей точкой Python как 64-битные значения двойной точности в соответствии со стандартом IEEE 754. В таком случае максимальное значение числа с плавающей точкой — это приблизительно 1.8 х 10308. Числа больше Python будет помечать в виде строки inf:
>>> 1.79e308
1.79e+308
>>> 1.8e308
inf
Ближайшее к нулю ненулевое значение — это приблизительно 5.0*10**-342. Все что ближе — это уже фактически ноль:
>>> 5e-324
5e-324
>>> 1e-325
0.0
Числа с плавающей точкой представлены в виде двоичных (с основанием 2) фракций. Большая часть десятичных фракций не может быть представлена в виде двоичных, поэтому в большинстве случаев внутреннее представление — это приближенное к реальному значение. На практике отличия представленного и реального значения настолько малы, что это не должно создавать проблем.
Дальнейшее чтение: для получения дополнительной информации о числах с плавающей точкой в Python и возможных проблемах, связанных с этим типом данных, читайте официальную документацию Python.
Комплексные числа
Сложные числа определяются следующим образом: <вещественное число>+<мнимая часть>j. Например:
>>> 2+3j
(2+3j)
>>> type(2+3j)
<class 'complex'>
Строки
Строки — это последовательности символов. Строковый тип данных в Python называется str.
Строковые литералы могут выделяться одинарными или двойными кавычками. Все символы между открывающей и закрывающей кавычкой являются частью строки:
>>> print("Я строка.")
Я строка.
>>> type("Я строка.")
<class 'str'>
>>> print('Я тоже.')
Я тоже.
>>> type('Я тоже.')
<class 'str'>
Строка может включать сколько угодно символов. Единственное ограничение — ресурсы памяти устройства. Строка может быть и пустой.
А что, если нужно использовать символ кавычки в строке? Первой идеей может быть нечто подобное:
>>> ''
''
Но, как видите, такой подход не работает. Строка в этом примере открывается одинарной кавычкой, поэтому Python предполагает, что следующая закрывает ее, хотя она задумывалась как часть строки. Закрывающая кавычка в конце вносит неразбериху и приводит к синтаксической ошибке.
Если нужно включить кавычки одного типа в строку, то стоит выделить ее целиком кавычками другого типа. Если строка содержит одинарную кавычку, просто используйте в начале и конце двойные или наоборот:
>>> print('Эта строка содержит одну кавычку (').')
SyntaxError: invalid syntax
Как видите, это не так хорошо работает. Строка в этом примере открывается одиночной кавычкой, поэтому Python предполагает, что следующая одинарная кавычка, та, которая в скобках является закрывающим разделителем. Окончательная одинарная кавычка тогда лишняя и вызывает показанную синтаксическую ошибку.
Если вы хотите включить любой тип символа кавычки в строку, самый простой способ — разделить строку с другим типом. Если строка должна содержать одну кавычку, разделите ее двойными кавычками и наоборот:
>>> print("Эта строка содержит одну кавычку (').")
Эта строка содержит одну кавычку (').
>>> print('Эта строка содержит одну кавычку (").')
Эта строка содержит одну кавычку (").
Управляющие последовательности (исключенные последовательности)
Иногда нужно, чтобы Python по-другому интерпретирован символ или последовательность нескольких символов в строке. Этого можно добиться двумя способами:
- Можно «подавить» специальное значение конкретных символов в этой строке;
- Можно создать специальную интерпретацию для символов в строке, которые обычно воспринимаются буквально;
Для этого используется обратный слэш (\). Обратный слэш в строке указывает, что один или несколько последующих символов нужно интерпретировать особым образом. (Это называется исключенной последовательностью, потому что обратный слэш заставляет последовательность символов «исключаться» из своего привычного значения).
Посмотрим, как это работает.
Подавление значения специальных символов
Вы видели, к каким проблемам приводит использовать кавычек в строке. Если она определена одиночными кавычками, просто так взять и использовать такую же кавычку как часть текста, нельзя, потому что она имеет особенное значение — завершает строку:
>>> print('Эта строка содержит одну кавычку (').')
SyntaxError: invalid syntax
Обратный слэш перед одинарной кавычкой «освобождает» ее от специального значения и заставляет Python воспринимать буквальное значение:
>>> print('Эта строка содержит символ одинарной кавычки (\').')
Эта строка содержит символ одинарной кавычки (').
То же работает и со строками, определенными двойными кавычками:
>>> print("Эта строка содержит символ одинарной кавычки (\").")
Эта строка содержит символ одинарной кавычки (").
Следующая таблица управляющих последовательностей описывает символы, которые заставляют Python воспринимать отдельные символы буквально:
| Управляющий символ | Стандартная интерпретация | Исключенная интерпретация |
|---|---|---|
| \’ | Завершает строку, открытую одинарной кавычкой | Символ одинарной кавычки |
| \» | Завершает строку, открытую двойными кавычками | Символ двойных кавычек |
| \newline | Завершает строку ввода | Новая строка игнорируется |
| \\ | Показывает исключенную последовательность | Символ обратного слэша |
Обычно символ новой строки (newline) заменяет enter. Поэтому он в середине строки заставит Python думать, что она неполная:
>>> print('a
SyntaxError: EOL while scanning string literal
Чтобы разбить строку на несколько строк кода, добавьте обратный слэш перед переходом на новую строку и newline будет игнорироваться:
>>> print('a\
... b\
... c')
abc
Для включения буквального значения обратного слэша, исключите его с помощью еще одного:
>>> print('foo\\bar')
foo\bar
Добавление специального значения символам
Предположим, что необходимо создать строку, которая будет содержать символ табуляции. Некоторые текстовые редакторы вставляют его прямо в код. Но многие программисты считают, что это не правильный подход по нескольким причинам:
- Компьютер видит разницу между символом табуляции и последовательностью пробелов, но программист — нет. Человек, читающий код, не способен отличить пробелы от символа табуляции.
- Некоторые текстовые редакторы настроены так, чтобы автоматически удалять символы табуляции и заменять их на соответствующее количество пробелов.
- Некоторые REPL-среды Python не будут вставлять символы табуляции в код.
В Python (и большинстве других распространенных языков) символ табуляции определяется управляющей последовательностью \t:
>>> print('foo\tbar')
foo bar
Она заставляет символ \t терять свое привычное значение и интерпретируется как символ табуляции.
Вот список экранированных последовательностей, которые заставляют Python использовать специальное значение вместе буквальной интерпретации:
| Управляющая последовательность | «Исключенная» интерпретация |
|---|---|
| \a | ASCII: символ Bell (BEL) |
| \b | ASCII: символ возврата на одну позицию (BS) |
| \f | ASCII: символ разрыва страница (FF) |
| \n | ASCII: символ перевода строки (LF) |
\N{<name>} | Символ из базы Unicode с именем <name> |
| \r | ASCII: символ возврата каретки (CR) |
| \t | ASCII: символ горизонтальной табуляции (TAB) |
| \uxxxx | Символ Unicode с 16-битным шестнадцатеричным значением |
| \Uxxxxxxxx | Символ Unicode с 32-битным шестнадцатеричным значением |
| \v | ASCII: символ вертикальной табуляции (VT) |
| \ooo | Символ с восьмеричным значением ooo |
| \xhh | Символ с шестнадцатеричными значением hh |
Примеры:
>>> print("a\tb")
a b
>>> print("a\141\x61")
aaa
>>> print("a\nb")
a
b
>>> print('\u2192 \N{rightwards arrow}')
→ →
Такой тип исключенной последовательности обычно используется для вставки символов, которые не легко ввести с клавиатуры или вывести.
«Сырые» строки
Литералу «сырой» строки предшествует r или R, которая подавляет экранирование, так что обратный слэш выводится как есть:
>>> print('foo\nbar')
foo
bar
>>> print(r'foo\nbar')
foo\nbar
>>> print('foo\\bar')
foo\bar
>>> print(R'foo\\bar')
foo\\bar
Строки в тройных кавычка
Есть и другой способ объявления строк в Python. Строки в тройных кавычках определяют группами из трех одинарных или двойных кавычек. Исключенные последовательности в них все еще работают, но одинарные и двойные кавычки, а также новые строки могут использоваться без управляющих символов. Это удобный способ создавать строки, включающие символы одинарных и двойных кавычек:
>>> print('''Эта строка содержит одинарные (') и двойные (") кавычки.''')
Эта строка содержит одинарные (') и двойные (") кавычки.
Таким же образом удобно создавать строки, разбитые на несколько строк кода:
>>> print("""Это cтрока,
которая растянута
на несколько строк""")
Это cтрока,
которая растянута
на несколько строк
Наконец, этот способ используется для создания комментариев кода Python.
Булев тип, Булев контекст и «истинность»
В Python 3 три типа Булевых данных. Объекты булевого типа принимают одно из двух значений, True или False:
>>> type(True)
<class 'bool'>
>>> type(False)
<class 'bool'>
Многие выражения в Python оцениваются в булевом контексте. Это значит, что они интерпретируются как истинные или ложные.
«Истинность» объекта типа Boolean самоочевидна: объекты равные True являются истинными, а те, что равны False — ложными. Но не-Булевы объекты также могут быть оценены в Булевом контексте.
