Преобразование типов данных в Python: руководство с примерами

В примере к целочисленному значению a_int было прибавлено значение с плавающей запятой b_float, и результат автоматически преобразовался в число с плавающей запятой c_sum без явной инструкции компилятору. Это и есть неявное преобразование типов.

Почему вместо этого значение с плавающей запятой не было преобразовано в целое?

Причина — более общий принцип повышения типа (type promotion) в информатике. Проще говоря, это защитный механизм компилятора, позволяющий выполнять операции, когда это возможно, преобразуя данные в более общий супертип без потери информации.

Это означает, что преобразование из float в int не выполняется, потому что тогда компилятору пришлось бы отбросить дробную часть, что привело бы к потере информации.

Явное преобразование типов данных в Python

Явное преобразование типов, часто называемое приведением типа (type casting), происходит, когда вы намеренно преобразуете значение из одного типа данных в другой. Такой подход даёт вам прямой контроль над преобразованием, поскольку вы явно указываете целевой тип данных в коде. Его обычно используют, когда автоматического (неявного) преобразования, предоставляемого Python, недостаточно для ваших задач.

Синтаксис явного преобразования:

target_data_type(expression)

Например, чтобы преобразовать число с плавающей запятой в целое, напишите:

int(3.14)  # Converts 3.14 to 3

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

Давайте рассмотрим некоторые распространённые явные преобразования типов данных.

Примитивные и непримитивные структуры данных в Python

Примитивные структуры данных — это строительные блоки для работы с данными, они содержат «чистые», простые значения. В Python есть четыре примитивных типа переменных:

• Целые числа
• Числа с плавающей запятой
• Строки
• Логический тип

Непримитивные структуры данных хранят не одно значение, а коллекцию значений в разных форматах. В Python к ним относятся:

• Списки
• Кортежи
• Словари
• Множества

Больше о них — в руководстве DataCamp Data Structures in Python Tutorial.

Преобразования примитивных структур данных

Преобразование между целыми и числами с плавающей запятой в Python

Целые и числа с плавающей запятой — это типы данных для работы с числами.

Чтобы преобразовать целое число в число с плавающей запятой, используйте функцию float() в Python. Аналогично, чтобы преобразовать 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)  # Output: 0.30000000000000004

Чтобы этого избежать, используйте модуль Decimal:

from decimal import Decimal

print(Decimal('0.1') + Decimal('0.2'))  # Output: 0.3

Преобразование из действительного в комплексное число в Python

Можно преобразовать целые числа в комплексные с помощью complex(real,imag). Она принимает два числа (вещественную и мнимую части) и формирует комплексное число.

real = 2
imag = 5
print(complex(real, imag))

(2+5j)

Преобразование типов данных со строками в Python

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

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$

Аналогично работает преобразование float в строку.

В 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 изначально являются строками. Затем нужно найти сумму, то есть сначала преобразовать их в соответствующие целые числа. Иначе компилятор решит, что требуется конкатенация строк, а не численное сложение. Потом это значение нужно подставить в итоговую строку вывода — следовательно, сумму снова нужно преобразовать в строку, чтобы объединить её с остальной частью сообщения.

Надеемся, этот пример показывает важность преобразований типов данных. Пусть это и очень простой пример, но уже видно, насколько это может быть полезно.

Примечание: вы заметили фразу «когда это возможно» при преобразовании строки в целое или число с плавающей запятой? Это потому, что не всегда можно преобразовать строки в числа и применять к ним числовые операции. Компилятор об этом знает и выдаст ошибку при такой попытке. Смотрите пример ниже:

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

Преобразования непримитивных структур данных

Преобразование типов в кортежи и списки в Python

Как и с числами, вы можете преобразовывать списки в кортежи и кортежи в списки.

Помните, что такое кортежи и списки? Списки и кортежи в 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)]

Аналогично можно преобразовать строку в список или кортеж в Python:

dessert = 'Cake'

# Преобразовать символы строки в отдельные элементы кортежа
print(tuple(dessert))

# Преобразовать строку в список
dessert_list = list(dessert)
dessert_list.append('s')
print(dessert_list)

('C', 'a', 'k', 'e')
['C', 'a', 'k', 'e', 's']

Преобразование типов в словари и множества в Python

Можно использовать функцию 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+)

Вместо словарей или кортежей dataclasses предоставляют более удобный способ работы со структурированными данными.

from dataclasses import dataclass

@dataclass
class Product:
    name: str
    price: float
    in_stock: bool

item = Product("Laptop", 799.99, True)
print(item)  # Output: Product(name='Laptop', price=799.99, in_stock=True)

Итоги: преобразования непримитивных структур данных в Python

Юникод, двоичные, восьмеричные и шестнадцатеричные целые числа в Python

Системы счисления — это наборы символов или знаков для представления числовых значений. Привычная вам система — десятичная. В десятичной системе используются десять символов: 0, 1, 2, 3, 4, 5, 6, 7, 8 и 9. С их помощью можно представить любое количество. Unicode, двоичная, шестнадцатеричная и восьмеричная — это разные системы счисления.

Когда символов не хватает, вы переходите к следующему разряду. В десятичной системе для представления числа на единицу больше 9 используется 10 — одна «десятка» и ноль «единиц». В других системах по‑другому. Например, в двоичной системе, где есть только 0 и 1, при исчерпании символов переходят к следующему разряду. Счёт в двоичной системе выглядит так: 0, 1, 10, 11, 100, 101 и т. д.

Далее мы подробнее рассмотрим некоторые системы счисления.

Преобразование двоичного числа в десятичное в Python

Двоичные числа — это числа в системе с основанием два. В ней используются только два символа: 0 и 1. Считая от нуля, вы быстро исчерпываете символы: 0, 1, ???

Дальше символов нет. К цифре 2 вы не переходите, потому что 2 в двоичной системе не существует. Вместо этого используются особые комбинации из 1 и 0. В двоичной системе 1000 равно 8 в десятичной. В двоичной системе используются степени двойки, то есть 8 — это: (1(2^3)) + (0(2^2)) + (0(2^1)) + (0(2^0)) = 8. Положение 1 и 0 определяет степень двойки.

Рассмотрим более сложный пример для наглядности:

Binary Number = 1001111
Decimal value = (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)) #Base 2(binary)

0b1001111
79

Преобразование восьмеричного числа в десятичное в Python

Восьмеричная система — это ещё одна система счисления с меньшим числом символов, чем десятичная. Её основание — восемь, то есть используются восемь символов: 0, 1, 2, 3, 4, 5, 6 и 7. После 7 идёт 10, потому что 8 не существует.

Как и в двоичной системе вы использовали степени двойки, здесь вы будете использовать степени восьми, поскольку основание — 8.

В двоичной системе 10 равно 8 в восьмеричной. Разберём: (1(8^1)) + (0(8^0)) = 8.

Более сложный пример:

Octal Number = 117
Decimal value = (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

Преобразование шестнадцатеричного числа в десятичное в Python

Шестнадцатеричная система — это система с основанием 16. В отличие от двоичной и восьмеричной, она использует шесть дополнительных символов помимо цифр, присутствующих в десятичной системе.

Что идёт после 9?

Когда требуются дополнительные символы сверх обычных цифр, используются буквы. Поэтому в шестнадцатеричной системе полный набор символов: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E и F.

Используя тот же пример:

Hexadecimal Number = 4F
Decimal value = (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

Преобразование Юникода в символ

Функция Python chr() преобразует целые числа Юникода в строку. Unicode — это общепринятая кодировка символов для отображения письменных текстов на разных языках.

Мы передали различные целые Юникода функции chr(), чтобы вывести «DATACAMP». Вы также можете использовать ord(), чтобы преобразовать отдельный символ в целое число Юникода. 

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

Отличная работа!

Поздравляем! Вы узнали о преобразованиях типов данных в Python, прежде всего с использованием встроенных методов. Это определённо поможет вам гибче работать с различными типами данных при написании программ.

У нас есть отличный курс Intermediate Python for Data Science, где вы научитесь визуализировать данные с помощью matplotlib и работать со словарями и знаменитым DataFrame библиотеки pandas. Вы также увидите, как управлять ходом выполнения программы с помощью циклов. В конце курса — кейс, в котором вы примените всё изученное на практике!