В этом руководстве мы на примерах разберем явное и неявное преобразование типов данных для примитивных и непримитивных структур данных Python.
Каждое значение в Python имеет тип данных. Типы — это классификация данных, которая указывает компилятору или интерпретатору, как вы хотите использовать эти данные. Тип определяет операции, которые можно выполнять с данными, и структуру, в которой они будут храниться. В науке о данных часто требуется изменить тип данных, чтобы упростить их использование и работу с ними.
В Python есть много типов данных. Вы наверняка уже видели и работали с некоторыми из них. Есть целые числа (int) и числа с плавающей точкой (float) для работы с числовыми значениями, логический тип данных (bool) для работы со значениями истины и лжи и строки (str) для работы с алфавитно-цифровыми символами. Вы можете использовать списки, кортежи, словари и множества — структуры данных, в которых можно хранить коллекции значений.
Содержание
- Проверка типа данных в Python
- Неявное и явное преобразование типов данных в Python
- Примитивные и непримитивные структуры данных в Python
- Преобразования примитивных структур данных
- Преобразования непримитивных структур данных
- Юникод, двоичные, восьмеричные и шестнадцатеричные числа в Python
- Часто задаваемые вопросы
Проверка типа данных в Python
Прежде чем преобразовывать типы данных, полезно их проверить. Для этого Python предоставляет две основные функции:
type(). Эта функция возвращает тип переменной.isinstance(). Эта функция проверяет, принадлежит ли переменная к определенному типу.
a = 5.5 print(type(a)) # Output: <class 'float'> print(isinstance(a, int)) # Output: False print(isinstance(a, float)) # Output: True
Неявное и явное преобразование типов данных в Python
Преобразование данных в Python может происходить двумя способами:
- Вы явно указываете компилятору преобразовать тип данных в какой-то другой тип.
- Компилятор сам понимает необходимость преобразования и делает его за вас.
В первом случае вы выполняете явное преобразование типа данных, а во втором — неявное.
Неявное преобразование типов данных
Неявное или принудительное преобразование — это когда преобразование типа данных происходит либо во время компиляции, либо во время выполнения и делается не вами, а самим Python. Давайте рассмотрим пример:
a_int = 1 b_float = 1.0 c_sum = a_int + b_float print(c_sum) print(type(c_sum))
2.0 <class 'float'>
В примере целочисленное значение a_int было добавлено к значению b_float (тип float). Результат был автоматически преобразован в значение c_sum типа float, и вам не пришлось просить компилятор сделать это. Это и есть неявное преобразование данных.
Почему значение типа float не было преобразовано в целое число?
Это связано с более широкой концепцией продвижения типов в информатике (англ. type promotion). Если говорить по-простому, это защитный механизм компилятора, позволяющий по возможности выполнять операции с данными разных типов, переводя при этом данные в супертип без потери информации.
Из этого следует, что преобразование из float в int не выполняется потому, что тогда компилятору придется удалить дробную часть числа, а это приведет к потере информации.
Явное преобразование типов данных
Явное преобразование типов данных, часто называемое приведением типов, происходит, когда вы намеренно переводите значение из одного типа в другой. Такой подход дает вам прямой контроль над преобразованием, поскольку вы явно указываете целевой тип данных в своем коде. Явное преобразование обычно используется в тех случаях, когда автоматическое (неявное) преобразование, предоставляемое Python, не удовлетворяет каким-то требованиям.
Синтаксис явного преобразования следующий:
целевой_тип_данных(выражение)
Например, если вы хотите преобразовать число с плавающей точкой в целое число, вы напишете:
int(3.14) # Преобразует 3.14 в 3
Примечание. Хотя явные преобразования очень полезны, они могут привести к потере информации. Например, при преобразовании числа с плавающей точкой в целое число его дробная часть будет отброшена. Важно понимать эти последствия, чтобы избежать непредвиденных результатов в ваших программах.
Давайте рассмотрим некоторые часто используемые явные преобразования типов данных.
Примитивные и непримитивные структуры данных в Python
Примитивные структуры данных являются строительными блоками для манипулирования данными и содержат чистые, простые значения данных. В Python есть четыре примитивных типа переменных:
- Целые числа
- Числа с плавающей точкой
- Строки
- Булевы значения
Непримитивные структуры данных хранят не просто значение, а коллекции значений в различных форматах. В Python существуют следующие непримитивные структуры данных:
- Списки
- Кортежи
- Словари
- Множества
Преобразования примитивных структур данных
Целые числа и числа с плавающей точкой
Целые числа (тип int) и числа с плавающей точкой (тип float) — это типы данных для работы с числами.
В Python для преобразования числа типа int в число типа float используется функция float(). Аналогично, для преобразования float в int используется функция int().
a_int = 3 b_int = 2 # Явное преобразование типа из int во float c_float_sum = float(a_int + b_int) print(c_float_sum) # Вывод: # 5.0
a_float = 3.3 b_float = 2.0 # Явное преобразование типа из float в int c_int_sum = int(a_float + b_float) print(c_int_sum) c_float_sum = a_float + b_float print(c_float_sum) # Вывод: # 5 # 5.3
Проблема точности чисел типа float и модуль Decimal
Вычисления с дробными числами в Python могут привести к проблемам с точностью:
print(0.1 + 0.2) # Вывод: 0.30000000000000004
Чтобы избежать этого, используйте модуль Decimal:
from decimal import Decimal
print(Decimal('0.1') + Decimal('0.2'))
# Вывод: 0.3
Преобразование чисел типа float в комплексные числа
Вы можете преобразовать вещественные числа в комплексные с помощью функции complex(real,imag). Она требует два числа (действительное и мнимое) и преобразует вещественные числа в комплексные.
real = 2 imag = 5 print(complex(real, imag)) # Вывод: # (2+5j)
Строки
Строка — это набор из одного или нескольких символов (букв, цифр и других символов). Вам довольно часто может понадобиться преобразовывать строки в числа или числа в строки.
price_cake = 15
price_cookie = 6
total = price_cake + price_cookie
print("The total is: " + total + "$")
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-12-54bd76b9b4bd> in <module>()
2 price_cookie = 6
3 total = price_cake + price_cookie
----> 4 print("The total is: " + total + "$")
TypeError: Can't convert 'int' object to str implicitly
В примере выше выдается ошибка TypeError, сообщающая, что компилятор не может неявно преобразовать целочисленное значение в строку.
То, что должна сделать программа в данном случае, может показаться вам интуитивно понятным. Однако компилятор не всегда может быть уверен в ваших намерениях, поэтому он предоставляет механизм с явным приведением типов, чтобы вы могли четко указать, чего вы хотите. Вот как можно преобразовать целое число в строку в Python с помощью функции str():
price_cake = 15
price_cookie = 6
total = price_cake + price_cookie
print("The total is: " + str(total) + "$")
# Вывод:
# The total is: 21$
Аналогично можно преобразовать в строку число с плавающей точкой.
Python позволяет преобразовывать строки в числа и наоборот, когда это возможно. Давайте посмотрим, что это значит:
price_cake = '15'
price_cookie = '6'
# Конкатенация строк
total = price_cake + price_cookie
print("The total is: " + total + "$")
# Явное приведение типа к целочисленному
total = int(price_cake) + int(price_cookie)
print("The total is: " + str(total) + "$")
# Вывод:
# The total is: 156$
# The total is: 21$
Разберем этот код.
price_cake и price_cookie изначально являются строками. Вам нужно найти общую сумму, а значит, сначала эти строки нужно преобразовать в соответствующие целочисленные значения. Если этого не сделать, компилятор посчитает, что нужна конкатенация строк, а не сложение чисел. Затем вам нужно поместить это значение в конечную строку и, следовательно, преобразовать total в строку, чтобы соединить с остальной частью сообщения.
Хотя это очень маленький пример преобразования типов данных, вы уже можете увидеть, насколько полезным оно может быть.
Вероятно, вы обратили внимание на оговорку “когда это возможно” относительно преобразования строк в целые числа или float. Дело в том, что преобразовать строку в число и применить к ней числовые операции можно не всегда. Компилятор знает об этом и поэтому выдаст ошибку, если вы попытаетесь это сделать. Например:
price_cake = 'fifteen'
price_cookie = 'six'
total = int(price_cake) + int(price_cookie)
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-25-80591b8accda> in <module>()
1 price_cake = 'fifteen'
2 price_cookie = 'six'
----> 3 total = int(price_cake) + int(price_cookie)
ValueError: invalid literal for int() with base 10: 'fifteen'
Итоги: преобразования примитивных типов данных в Python
| Преобразование | Функция | Пример | Вывод |
|---|---|---|---|
| int во float | float() | float(3) | 3.0 |
| float в int | int() | int(3.9) | 3 |
| str в int | int() | int('123') | 123 |
| int в str | str() | str(123) | ‘123’ |
Преобразования непримитивных структур данных
Кортежи и списки
Так же, как int можно преобразовать во float, а float — в int, можно преобразовать кортеж в список и список в кортеж.
Помните, что такое кортежи и списки? Списки и кортежи в Python используются для хранения коллекций элементов. Разница между ними в том, что кортежи неизменяемы, т.е. после их определения вы не сможете удалить, добавить или изменить какие-либо значения внутри них.
Зачем преобразовывать списки в кортежи?
Потому что кортежи являются неизменяемыми типами данных и позволяют существенно оптимизировать создаваемые программы.
А зачем преобразовывать кортежи в списки?
Возможно, вы хотите внести изменения в исходный кортеж. Вы можете преобразовать его в список, внести изменения, а затем снова преобразовать в кортеж.
В Python есть функция tuple(), возвращающая кортежную версию переданного ей значения, и функция list(), возвращающая список:
a_tuple = ('a', 1) ,('f', 2), ('g', 3)
b_list = [1,2,3,4,5]
print(tuple(b_list))
print(list(a_tuple))
# Вывод:
# (1, 2, 3, 4, 5)
# [('a', 1), ('f', 2), ('g', 3)]
Аналогично в список или кортеж можно преобразовать строку:
dessert = 'Cake'
# Преобразовать символы строки в отдельные элементы кортежа
print(tuple(dessert)) # Вывод: ('C', 'a', 'k', 'e')
# Преобразовать строку в список
dessert_list = list(dessert)
dessert_list.append('s')
print(dessert_list) # Вывод: ['C', 'a', 'k', 'e', 's']
Словари и множества
Вы можете использовать функцию dict() для преобразования кортежа в словарь и set() для преобразования списка в множество.
print(dict(a_tuple))
print(set(b_list))
# Вывод:
# {'a': 1, 'f': 2, 'g': 3}
# {1, 2, 3, 4, 5}
Как и с другими функциями преобразования, вам нужно лишь указать имя функции, чтобы преобразовать любой тип данных в словарь или множество.
Использование dataclasses для структурированных данных (Python 3.7+)
Классы данных обеспечивают лучший способ работы со структурированными данными, чем словари или кортежи.
from dataclasses import dataclass
@dataclass
class Product:
name: str
price: float
in_stock: bool
item = Product("Laptop", 799.99, True)
print(item)
# Вывод: Product(name='Laptop', price=799.99, in_stock=True)
Итоги: преобразования непримитивных типов данных в Python
| Преобразование | Функция | Пример | Вывод |
|---|---|---|---|
| Список в кортеж | tuple() | tuple([1, 2, 3]) | (1, 2, 3) |
| Кортеж в список | list() | list(('a', 1)) | [‘a’, 1] |
| Строка в список | list() | list('Cake') | [‘C’, ‘a’, ‘k’, ‘e’] |
| Строка в кортеж | tuple() | tuple('Cake') | (‘C’, ‘a’, ‘k’, ‘e’) |
| Кортеж в словарь | dict() | dict((('a', 1), ('b', 2))) | {‘a’: 1, ‘b’: 2} |
| Список во множество | set() | set([1, 2, 3, 4, 5]) | {1, 2, 3, 4, 5} |
Юникод, двоичные, восьмеричные и шестнадцатеричные целые числа в Python
Система счисления, которой вы пользуетесь повседневно, называется десятичной. В ней используется десять символов: 0, 1, 2, 3, 4, 5, 6, 7, 8 и 9. С их помощью можно представить любое число.
Когда у вас заканчиваются символы, вы переходите к следующему разряду. В десятичной системе для обозначения числа, большего, чем 9, используется 10, что означает один десяток и ноль единиц. Однако в других системах счисления все иначе.
Например, в двоичной системе используется только два символа, 0 и 1. Когда у вас заканчиваются символы, вам так же нужно перейти к следующему разряду. Вот как вы будете считать в двоичной системе: 0, 1, 10, 11, 100, 101 и т. д.
Давайте теперь разберем, как преобразовывать числа в одной системе счисления в числа в другой системе.
Преобразование двоичных чисел в десятичные
Двоичные целые числа — это числа с основанием два. Это означает, что в двоичной системе счисления для представления чисел используются только два символа: 0 и 1. И когда вы считаете от нуля в двоичной системе, доступные символы заканчиваются куда быстрее, чем в десятичной.
Вы не переходите к цифре 2, потому что 2 не существует в двоичной системе счисления. Вместо этого вы используете специальную комбинацию 1 и 0. 1000 в двоичной системе равно 8 в десятичной. В двоичной системе вы используете степени двойки, то есть 8 — это, по сути, (1(2^3)) + (0(2^2)) + (0(2^1)) + (0(2^0))= 8. Позиция 1 и 0 определяет, в какую степень нужно возвести 2.
Для наглядности рассмотрим это на более сложном примере:
Двоичное число = 1001111
Десятичное значение = (1*(2^6)) + (0*(2^5)) + (0*(2^4)) + (1*(2^3)) + (1*(2^2)) + (1*(2^1)) + (1*(2^0))
= 79
В Python для преобразования десятичного значения в соответствующее ему двоичное можно просто использовать функцию bin().
Аналогично, функция int() преобразует двоичное значение в десятичное. Функция int() принимает в качестве второго аргумента основание преобразуемого числа. Если речь идет о двоичной системе, то основание — 2.
a = 79 # Основание 2 (двоичная система) bin_a = bin(a) print(bin_a) print(int(bin_a, 2)) # Основание 2 (двоичная система) # Вывод: # 0b1001111 # 79
Преобразование восьмеричных чисел в десятичные
Восьмеричная система счисления тоже работает с меньшим количеством символов, чем привычная нам десятичная. Она имеет основание восемь, что означает, что для представления всех величин используется восемь символов. Это 0, 1, 2, 3, 4, 5, 6 и 7. После 7 идет 10, так как 8 не существует.
Точно так же, как в двоичной системе для определения значения числа вы использовали степень двойки, в восьмеричной вы будете использовать степень восьмерки.
10 в двоичной системе равно 8 в восьмеричной. Давайте разложим это по полочкам: (1(8^1)) + (0(8^0))= 8.
Более сложный пример:
Восьмеричное число = 117
Десятичное значение = (1*(8^2)) + (1*(8^1)) + (7*(8^0))
= 79
В Python вы можете использовать функцию oct() для преобразования десятичного значения в соответствующее ему восьмеричное. В качестве альтернативы можно также использовать функцию int() и правильное основание, которое для восьмеричной системы счисления равно 8.
a = 79 # Основание 8 (восьмеричная система) oct_a = oct(a) print(oct_a) print(int(oct_a, 8)) # Вывод: # 0o117 # 79
Преобразование шестнадцатеричных чисел в десятичные
Шестнадцатеричная система счисления — это система счисления с основанием 16. В отличие от двоичной и восьмеричной, она использует шесть дополнительных символов, помимо тех, что есть в десятичной.
Но что идет после 9?
Когда требуются дополнительные символы, выходящие за рамки обычных цифр, используются буквы. Так, в шестнадцатеричной системе счисления используется следующий список символов: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E и F.
Используем тот же пример, что и ранее:
Шестнадцатеричное число = 4F
Десятичное значение = (4*(16^1)) + (F*(16^0))
= 79
В Python для преобразования десятичного значения в соответствующее ему шестнадцатеричное можно использовать функцию hex() или функцию int() с основанием 16.
a = 79 # Основание 16 (шестнадцатеричная система) hex_a = hex(a) print(hex_a) print(int(hex_a, 16)) # Вывод: # 0x4f # 79
Преобразование значений Unicode в символы
Функция Python chr() преобразует числа Unicode в строку. Unicode — это общепринятая кодировка символов для отображения текстов на различных языках.
Мы передали функции chr() различные целые числа Unicode, чтобы отобразить «DATACAMP». Вы также можете использовать функцию ord() для преобразования отдельного символа в целое число Unicode.
print(
chr(68),
chr(65),
chr(84),
chr(65),
chr(67),
chr(65),
chr(77),
chr(80),
)
# Вывод:
# D A T A C A M P
Итоги: преобразования чисел в разных системах счисления в Python
| Преобразование | Функция | Пример | Вывод |
|---|---|---|---|
| Десятичное число в двоичное | bin() | bin(79) | 0b1001111 |
| Двоичное число в десятичное | int() | int('1001111', 2) | 79 |
| Десятичное число в восьмеричное | oct() | oct(79) | 0o117 |
| Восьмеричное число в десятичное | int() | int('117', 8) | 79 |
| Десятичное число в шестнадцатеричное | hex() | hex(79) | 0x4f |
| Шестнадцатеричное число в десятичное | int() | int('4F', 16) | 79 |
| Unicode в символ | chr() | chr(68) | ‘D’ |
| Символ в Unicode | ord() | ord('D') | 68 |
Часто задаваемые вопросы
Как в Python преобразовать список целых чисел в одну строку?
Можно использовать метод join() в сочетании с map(), чтобы преобразовать каждое число в строку и соединить полученные строки.
int_list = [1, 2, 3, 4] result = ''.join(map(str, int_list)) print(result) # Вывод: '1234'
Что будет, если попытаться преобразовать нечисловую строку в целое число?
Получите ValueError с сообщением, что строка не является валидным литералом для int().
int('abc')
# ValueError: invalid literal for int() with base 10: 'abc'
Можно ли в Python преобразовать множество в список? Как это сделать?
Да, для этого можно использовать функцию list().
a_set = {1, 2, 3}
a_list = list(a_set)
print(a_list) # Вывод: [1, 2, 3]
Как преобразовать строку из чисел, разделенных пробелами, в список целых чисел?
Используйте метод split() для разделения строки и map() для преобразования каждой части в целое число.
numbers = "1 2 3 4" int_list = list(map(int, numbers.split())) print(int_list) # Вывод: [1, 2, 3, 4]
С помощью какой функции можно проверить тип переменной в Python?
Для этого используется функция type().
x = 5 print(type(x)) # Вывод: <class 'int'>
Вы сделали это!
Поздравляем! Вы узнали о преобразованиях типов данных в Python, в первую очередь с помощью встроенных методов. Это определенно поможет вам работать с различными типами данных, обеспечивая большую гибкость при написании программ.
Перевод статьи “Python Data Type Conversion: A Guide With Examples”.
