Типы данных Python: полное руководство

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

В этой главе рассматриваются все встроенные типы данных:

Встроенная функция type() позволяет в любой момент узнать тип значения:

print(type(42))       # <class 'int'>
print(type(3.14))     # <class 'float'>
print(type("hello"))  # <class 'str'>
print(type(True))     # <class 'bool'>
print(type([1, 2]))   # <class 'list'>
print(type((1, 2)))   # <class 'tuple'>
print(type({1, 2}))   # <class 'set'>
print(type({"a": 1})) # <class 'dict'>
print(type(None))     # <class 'NoneType'>

Числовые типы

В Python есть три числовых типа: int, float и complex. Все три поддерживают стандартные арифметические операторы (+, -, *, /, //, %, **).

int

Тип int хранит целое число неограниченного размера — целые числа в Python не ограничены 32 или 64 битами.

Основные операторы

Обратите внимание: / всегда возвращает float, даже если результат является целым числом. Используйте //, когда вам нужно целое частное.

Целочисленный тип данных Python

# Integer addition
print(1 + 2)    # 3

# Integer subtraction
print(3 - 1)    # 2

# Integer multiplication
print(2 * 3)    # 6

# True division always returns float
print(6 / 2)    # 3.0

# Floor division returns int
print(7 // 2)   # 3

# Exponentiation
print(2 ** 10)  # 1024

float

Тип float хранит десятичное число в формате IEEE 754 с двойной точностью. Используйте float везде, где нужны дробные значения.

Нюанс — представление чисел с плавающей точкой: 0.1 + 0.2 не равно точно 0.3 в двоичной арифметике с плавающей точкой. Используйте round() или модуль decimal, когда требуется точная десятичная арифметика (например, для денежных расчётов).

complex

Комплексное число (complex) имеет вещественную и мнимую часть и записывается как a + bj в Python (используется j, а не i). Комплексные числа применяются главным образом в научных вычислениях, обработке сигналов и инженерных расчётах.

str (Строки)

Тип str — это неизменяемая последовательность символов Unicode. Строки могут быть заключены в одинарные, двойные или тройные кавычки (для многострочных строк).

single = 'Hello'
double = "World"
multi  = """This spans
multiple lines."""

Основные операции со строками

Полезные методы строк

s = "  Hello World  "
print(s.strip())          # "Hello World"  — remove whitespace
print(s.strip().lower())  # "hello world"
print(s.strip().upper())  # "HELLO WORLD"
print("Hello World".split())   # ['Hello', 'World']
print(",".join(["a", "b", "c"]))  # a,b,c
print("Hello World".replace("World", "Python"))  # Hello Python
print(len("Hello"))       # 5

f-строки (форматированные строковые литералы)

f-строки (появились в Python 3.6) — предпочтительный способ встраивать значения в строки:

name = "Alice"
age  = 30
print(f"{name} is {age} years old.")   # Alice is 30 years old.
print(f"Next year she will be {age + 1}.")  # Next year she will be 31.

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

bool (Логический тип)

Тип bool имеет ровно два значения: True и False. В Python boolean является подклассом int — True равен 1, а False равен 0.

print(type(True))   # <class 'bool'>
print(True + 1)     # 2  (True is treated as 1)
print(False + 10)   # 10 (False is treated as 0)

Истинные и ложные значения

Любой объект Python можно вычислить в логическом контексте. Следующие значения являются ложными (вычисляются как False); всё остальное — истинное:

• False, None
• Числовой ноль: 0, 0.0, 0j
• Пустые последовательности: "", [], (), set()
• Пустое отображение: {}

print(bool(0))      # False
print(bool(""))     # False
print(bool([]))     # False
print(bool(None))   # False

print(bool(42))     # True
print(bool("hi"))   # True
print(bool([0]))    # True  — list with one item is truthy

Подробнее см. в главе Python Booleans.

list

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

# Creating a list
fruits = ["apple", "banana", "cherry"]

# Modifying an item
fruits[1] = "orange"
print(fruits)  # ['apple', 'orange', 'cherry']

# Adding items
fruits.append("mango")
print(fruits)  # ['apple', 'orange', 'cherry', 'mango']

# Removing an item
fruits.remove("orange")
print(fruits)  # ['apple', 'cherry', 'mango']

# Length
print(len(fruits))  # 3

Когда использовать list: когда нужна упорядоченная коллекция, которая будет изменяться — добавлять элементы, удалять или обновлять значения на месте. Подробно рассмотрено в главе Python Lists.

tuple

Тип tuple — это упорядоченная, неизменяемая последовательность. После создания её элементы нельзя изменить.

# Creating a tuple
coords = (10, 20)
print(coords[0])    # 10
print(len(coords))  # 2

# Tuple unpacking
x, y = coords
print(x, y)  # 10 20

# Single-element tuple needs a trailing comma
single = (42,)
print(type(single))  # <class 'tuple'>

Когда использовать tuple вместо list:

• Данные не должны меняться (например, координаты GPS, значения цвета RGB, строки базы данных).
• Вы хотите использовать значение в качестве ключа словаря (списки не могут быть ключами dict, поскольку они изменяемы; tuple — могут).
• Вы хотите явно выразить намерение: «эта последовательность фиксирована».

Подробнее см. в главе Python Tuples.

set

Тип set — это неупорядоченная коллекция уникальных элементов. Дублирующиеся значения автоматически отбрасываются при создании или добавлении.

# Duplicates are automatically removed
unique = {1, 2, 2, 3, 3, 3}
print(unique)  # {1, 2, 3}

# Adding an item
unique.add(4)
print(unique)  # {1, 2, 3, 4}

# Membership test — O(1) average
print(3 in unique)  # True

# Set operations
a = {1, 2, 3}
b = {2, 3, 4}
print(a | b)  # {1, 2, 3, 4}  union
print(a & b)  # {2, 3}        intersection
print(a - b)  # {1}           difference

Когда использовать set: когда нужна быстрая проверка принадлежности или требуется устранить дубликаты из коллекции. Подробнее см. в главе Python Sets.

dict (Словарь)

Тип dict — это неупорядоченное отображение пар ключ-значение. Начиная с Python 3.7 словари сохраняют порядок вставки. Ключи должны быть уникальными и неизменяемыми (чаще всего используются строки и числа).

person = {"name": "John", "age": 32, "city": "New York"}

# Access by key
print(person["name"])  # John

# Add a key
person["country"] = "United States"
print(person)
# {'name': 'John', 'age': 32, 'city': 'New York', 'country': 'United States'}

# Remove a key
del person["city"]
print(person)
# {'name': 'John', 'age': 32, 'country': 'United States'}

# Safe access with a default value
print(person.get("email", "not provided"))  # not provided

# Iterate over keys and values
for key, value in person.items():
    print(f"{key}: {value}")

Когда использовать dict: когда данные имеют структуру «ключ-значение» и требуется быстрый поиск по имени. Подробнее см. в главе Python Dictionary Methods.

NoneType

None — это null-значение Python, представляющее отсутствие значения. Это единственный экземпляр типа NoneType.

result = None
print(result)         # None
print(type(result))   # <class 'NoneType'>

# Functions that do not explicitly return a value return None
def greet(name):
    print(f"Hello, {name}!")

x = greet("Alice")    # prints: Hello, Alice!
print(x)              # None

Всегда используйте is None (проверка тождественности), а не == None (проверка равенства):

if result is None:
    print("No result yet")

Изменяемость с первого взгляда

Изменяемость определяет, можно ли изменить значение на месте после его создания. Это влияет на корректность кода (случайное алиасирование), производительность (копирование против ссылки) и на то, что можно использовать в качестве ключей dict.

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

Python предоставляет встроенные функции для преобразования между типами. Это называется явным преобразованием типов (или приведением типов).

# To int
print(int("42"))      # 42
print(int(3.9))       # 3  (truncates, does not round)
print(int(True))      # 1

# To float
print(float(7))       # 7.0
print(float("3.14"))  # 3.14

# To str
print(str(3.14))      # '3.14'
print(str(True))      # 'True'

# Between sequences
print(list((1, 2, 3)))   # [1, 2, 3]
print(tuple([1, 2, 3]))  # (1, 2, 3)
print(set([1, 2, 2, 3])) # {1, 2, 3}

int() обрезает дробную часть (не округляет): int(3.9) возвращает 3, а не 4. Используйте round() перед int(), если необходимо округление.

Подробно о правилах приведения типов рассказано в главе Python Casting.

Проверка типа в коде

Используйте isinstance() (предпочтительно) или type() для проверки типов:

x = 42
print(isinstance(x, int))    # True
print(isinstance(x, float))  # False

# isinstance also works with a tuple of types
print(isinstance(x, (int, float)))  # True

Предпочитайте isinstance() вместо type(x) == int, поскольку он учитывает наследование — bool является подклассом int, поэтому isinstance(True, int) возвращает True, что обычно и является ожидаемым поведением.

Краткий справочник

* Порядок вставки сохраняется начиная с Python 3.7+.

Практика