Как преобразовать тип переменной в python

Приведение типов в Python

• Понятие приведения типов в Python
• Приведение к типу bool
• Приведение к типу int
• Приведение к типу float
• Приведение к типу complex
• Приведение к типу str
• Приведение к типу tuple
• Приведение к типу list
• Приведение к типу set
• Приведение к типу dict
• Краткие итоги параграфа
• Вопросы и задания для самоконтроля

Понятие приведения типов в Python

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

Да, в операциях с различными типами чисел или же в условных инструкциях и выражениях интерпретатор неявно (автоматически) преобразует объекты к общему типу. Однако в большинстве случаев это не так, поэтому следует внимательно следить за текущим типом переменной и при необходимости самостоятельно осуществлять явное приведение к нужному типу.

называется процесс преобразования значения одного типа данных в значение другого типа.

Как уже упоминалось ранее, для преобразования различных типов данных между собой в Python доступен целый ряд встроенных функций (конструкторов типов):

• bool() – приведение к логическому типу,
• int() – приведение к целочисленному типу,
• float() – приведение к вещественному типу,
• complex() – приведение к комплексному числу,
• str() – приведение к строковому типу,
• tuple() – приведение к кортежу,
• list() – приведение к списку,
• dict() – приведение к словарю,
• set() – приведение к множеству.

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

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

Приведение к типу bool

Во время преобразования к типу bool (логический тип данных) следующие значения рассматриваются как False :

• само значение False ,
• значение None ,
• нулевые числовые значения 0 , 0.0 и 0+0j ,
• пустая строка «» ,
• пустые объекты: [] , tuple() , <> , dict() .

Все остальные значения преобразуются в значение True , включая число -1 , поскольку оно представляет собой обычное отрицательное число, отличное от нуля (см. пример №1 ). Тоже самое касается коллекций с одним нулевым значением, например, [0] , , (0,) , а также непустых строк, например, ‘0’ или ‘0.0’ .

Код Результат pythonCodes

# False. print('bool(None):', bool(None)) # False. print('bool(0):', bool(0)) # False. print('bool(0.0):', bool(0.0)) # False. print('bool(0+0j):', bool(0+0j)) # False. print('bool(""):', bool('')) # False. print('bool([]):', bool([])) # False. print('bool(<>):', bool(<>)) # False. print('bool(tuple()):', bool(tuple())) # False. print('bool(dict()):', bool(dict())) print() # True. print('bool("0"):', bool('0')) # True. print('bool(-1):', bool(-1)) # True. print('bool([False]):', bool([False])) # True. print('bool():', bool()) # True. print('bool((0,)):', bool((0,)))

bool(None): False bool(0): False bool(0.0): False bool(0+0j): False bool(""): False bool([]): False bool(<>): False bool(tuple()): False bool(dict()): False bool("0"): True bool(-1): True bool([False]): True bool(): True bool((0,)): True 

Пример №1. Приведение к типу bool.

Приведение к типу int

В случае приведения к типу int (целые числа):

• Логическое значение True преобразуется в 1 , False – в 0 .
• Вещественные числа просто усекаются до целой части. Например, в случае приведения вещественного числа -37.9 к целочисленному типу оно будет преобразовано в число -37 .
• Если строка содержит верную запись целого числа в десятичной системе счисления, то интерпретатор в процессе приведения строки к целочисленному типу вернет это число.
• Если строка num_str содержит верное представление целого числа в системе счисления с указанным основанием base , то преобразовать ее можно в целое число при помощи конструктора типа с двумя аргументами int(num_str, base=10) (подробнее здесь).

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

Код Результат pythonCodes

# 1. print('int(True): ', int(True)) # 0. print('int(False): ', int(False)) # 53. print('int("+53"): ', int('+53')) # -7. print('int(-7.33): ', int(-7.33)) # 0. print('int(.33): ', int(.33)) # int() argument must be a . # print('int(5.2+1.3j): ', int(5.2+1.3j)) # int() argument must be a . # print('int(None): ', int(None)) # invalid literal for . # print('int(""): ', int('')) # invalid literal for . # print('int("3.7"): ', int('3.7')) # int() argument must be a . # print('int([5]): ', int([5]))

int(True): 1 int(False): 0 int("-53"): -53 int(-7.33): -7 int(.33): 0 

Пример №2. Приведение к типу int.

Приведение к типу float

В случае приведения к типу float (вещественные числа):

• Логическое значение True преобразуется в 1.0 , False – в 0.0 .
• Целые числа преобразуются в вещественные простым добавлением нулевой дробной части. Например, целое отрицательное число -37 будет преобразовано в число -37.0 .
• Если строка содержит верное представление целого числа в десятичной системе счисления, то интерпретатор в процессе приведения строки к вещественному типу вернет это число, добавив к нему нулевую дробную часть. При этом допускаются начальные и конечные пробельные символы, а также знаки плюса и минуса. Например, строка, содержащая запись целого отрицательного числа с пробелами ‘ -105 ‘ будет преобразовано в число -105.0 .
• Если строка содержит верное представление вещественного в десятичной системе счисления, то интерпретатор в процессе приведения строки к вещественному типу вернет это число. При этом допускаются начальные и конечные пробельные символы, а также знаки плюса и минуса. Например, строка, содержащая запись вещественного отрицательного числа с пробелами ‘ -1.5 ‘ будет преобразовано в число -1.5 .
• Также строка может представлять значения ‘NaN’ , ‘Infinity’ или ‘-Infinity’ .

Для других типов данных приведение к вещественному типу не определено, поэтому попытка такого преобразования приведет к ошибке (см. пример №3 ).

Код Результат pythonCodes

# 1.0. print('float(True): ', float(True)) # 0.0. print('float(False): ', float(False)) # 53.0. print('float(" +53"): ', float(' +53')) # -7.33. print('float("-7.33"): ', float('-7.33')) # 0.013. print('float("1.3e-2 "): ', float('1.3e-2 ')) # nan. print('float("NaN"): ', float('NaN')) # -inf. print('float(" -Infinity "): ', float(' -Infinity ')) # float() argument must be a string. # print('float(5.2+1.3j): ', float(5.2+1.3j)) # float() argument must be a string. # print('float(None): ', float(None)) # could not convert string to float. # print('float(""): ', float('')) # float() argument must be a string. # print('float([5]): ', float([5]))

float(True): 1.0 float(False): 0.0 float(" +53"): 53.0 float("-7.33"): -7.33 float("1.3e-2 "): 0.013 float("NaN"): nan float(" -Infinity "): -inf 

Пример №3. Приведение к типу float.

Приведение к типу complex

В случае приведения к типу complex (комплексные числа):

• Логическое значение True преобразуется в (1+0j) , False – в 0j .
• Целые и вещественные числа преобразуются в комплексные простым добавлением нулевой мнимой части +0j . Например, отрицательное вещественное число -3.7 будет преобразовано в комплексное число (-3.7+0j) .
• Если строка содержит верное представление комплексного числа, то интерпретатор в процессе приведения строки к комплексному типу вернет это число. При этом допускаются начальные и конечные пробельные символы, а также знаки плюса и минуса как перед действительной, так и мнимой частью. Однако пробелов между действительной и мнимой частями быть не должно! Например, строка, содержащая запись комплексного числа с пробелами ‘ -5.5+0.2j ‘ будет преобразовано в число (-5.5+0.2j) .

Для других типов данных приведение к комплексному типу не определено, поэтому попытка такого преобразования приведет к ошибке (см. пример №4 ).

Код Результат pythonCodes

# (1+0j). print('complex(True):', complex(True)) # 0j. print('complex(False):', complex(False)) # (5.9-3.2j). print('complex(" +5.9-3.2j"):', complex(' +5.9-3.2j')) # (53+0j). print('complex(" 53"):', complex(' 53')) # (-7.33+0j). print('complex(" -7.33 "):', complex(' -7.33 ')) # (0.013+0j). print('complex("1.3e-2 "):', complex('1.3e-2 ')) # (nan+0j). print('complex("NaN"):', complex('NaN')) # (-inf+0j). print('complex(" -Infinity "):', complex(' -Infinity ')) # complex() arg is a malformed string. # print('complex("5.2 + 1.3j"):', complex('5.2 + 1.3j')) # complex() first argument must be. # print('complex(None):', complex(None)) # complex() arg is a malformed string. # print('complex(""):', complex('')) # complex() first argument must be. # print('complex([5]):', complex([5]))

complex(True): (1+0j) complex(False): 0j complex(" +5.9-3.2j"): (5.9-3.2j) complex(" 53"): (53+0j) complex(" -7.33 "): (-7.33+0j) complex("1.3e-2 "): (0.013+0j) complex("NaN"): (nan+0j) complex(" -Infinity "): (-inf+0j) 

Пример №4. Приведение к типу complex.

Приведение к типу str

В случае приведения к типу str (строки) интерпретатор просто вернет строковое представление объекта, которое представлено методом приводимого объекта object.__str__() (см. пример №5 ).

Код Результат pythonCodes

# True. print('str(True):', str(True)) # False. print('str(False):', str(False)) # (5.9-3.2j). print('str+5.9-3.2j:', str(+5.9-3.2j)) # 53. print('str(53):', str(+53)) # -7.33. print('str(-7.33):', str(-7.33)) # 0.013. print('str(1.3e-2):', str(1.3e-2)) # None. print('str(None):', str(None)) # [0.5, 1,5]. print('str([0.5, 1,5]):', str([0.5, 1,5])) # . print("str():", str()) # (2, '3'). print("str((2, '3')):", str((2, '3'))) # . print('str():', str())

str(True): True str(False): False str+5.9-3.2j: (5.9-3.2j) str(53): 53 str(-7.33): -7.33 str(1.3e-2): 0.013 str(None): None str([0.5, 1,5]): [0.5, 1, 5] str(): str((2, '3')): (2, '3') str():

Пример №5. Приведение к типу str.

Приведение к типу tuple

К типу tuple (кортежи) могут быть преобразованы только итерируемые объекты. При этом словари преобразуются в кортежи с ключами, теряя свои значения (см. пример №6 ).

Код Результат pythonCodes

# ('a', 'b', 'c'). print("tuple('abc'):", tuple('abc')) # (1, 2, 3). print('tuple([1, 2, 3]):', tuple([1, 2, 3])) # ('one', 'two'). print("tuple():", tuple()) # (1, 2). print("tuple():", tuple()) # ('one', 'two'). print("tuple():", tuple()) # (1, 2, 3). print("tuple(range(1, 4)):", tuple(range(1, 4))) # bool object is not iterable. # print('tuple(True): ', tuple(True)) # int object is not iterable. # print('tuple(53): ', tuple(53)) # NoneType object is not iterable. # print('tuple(None): ', tuple(None))

tuple('abc'): ('a', 'b', 'c') tuple([1, 2, 3]): (1, 2, 3) tuple(): ('one', 'two') tuple(): (1, 2) tuple(): ('one', 'two') tuple(range(1, 4)): (1, 2, 3) 

Пример №6. Приведение к типу tuple.

Приведение к типу list

К типу list (списки) могут быть преобразованы только итерируемые объекты. При этом словари преобразуются в списки с ключами, теряя свои значения (см. пример №7 ).

Код Результат pythonCodes

# ['a', 'b', 'c']. print("list('abc'):", list('abc')) # [1, 2, 3]. print('list((1, 2, 3)):', list((1, 2, 3))) # ['one', 'two']. print("list():", list()) # [1, 2]. print("list():", list()) # ['one', 'two']. print("list():", list()) # [1, 2, 3]. print("list(range(1, 4)):", list(range(1, 4))) # bool object is not iterable. # print('list(True): ', list(True)) # int object is not iterable. # print('list(53): ', list(53)) # NoneType object is not iterable. # print('list(None): ', list(None))

list('abc'): ['a', 'b', 'c'] list((1, 2, 3)): [1, 2, 3] list(): ['one', 'two'] list(): [1, 2] list(): ['one', 'two'] list(range(1, 4)): [1, 2, 3] 

Пример №7. Приведение к типу list.

Приведение к типу set

К типу set (множества) могут быть преобразованы только итерируемые объекты. При этом словари преобразуются в множества с ключами, теряя свои значения (см. пример №8 ).

Код Результат pythonCodes

# . print("set('abc'):", set('abc')) # . print('set((1, 2, 3)):', set((1, 2, 3))) # . print("set():", set()) # . print("set():", set()) # . print("set(range(1, 4)):", set(range(1, 4))) # bool object is not iterable. # print('set(True): ', set(True)) # int object is not iterable. # print('set(53): ', set(53)) # NoneType object is not iterable. # print('set(None): ', set(None))

set('abc'): set((1, 2, 3)): set(): set(): set(range(1, 4)):

Пример №8. Приведение к типу set.

Приведение к типу dict

К типу dict (словари) напрямую могут быть преобразованы только итерируемые объекты, содержащие пары значений, в которых первые элементы становятся ключами словаря, а вторые – его значениями. Например, это могут быть списки, кортежи или множества, содержащие в качестве своих элементов другие списки, кортежи или множества из двух элементов (см. пример №9 ). При этом следует помнить, что только хешируемые (неизменяемые) объекты могут быть ключами словаря или элементами множества.

Код Результат pythonCodes

# . print("dict([[1, 'a'], (2, 'b')]):", dict([[1, 'a'], (2, 'b')])) # . print("dict([(1, 'a'), ]):", dict([(1, 'a'), ])) # . print("dict(((1, 'a'), )):", dict(((1, 'a'), ))) # . print("dict((, [2, 'b'])):", dict((, [2, 'b']))) # . print("dict(<(1, 'a'), (2, 'b')>):", dict(<(1, 'a'), (2, 'b')>)) # unhashable type: list (списки не могут быть ключами). # print("dict([[[1], 'a'], (2, 'b')]):", dict([[[1], 'a'], (2, 'b')])) # unhashable type: list (список - недопустимый эл-т мн-ва). # print("dict(<[1, 'a'], (2, 'b')>):", dict(<[1, 'a'], (2, 'b')>)) # dictionary update sequence element #0 has length 3; 2 is required. # print("dict([(1, 'a'), ]):", dict([(1, 'a', 3), ])) # bool object is not iterable. # print('dict(True): ', dict(True))

dict([[1, 'a'], (2, 'b')]): dict([(1, 'a'), ]): dict(((1, 'a'), )): dict((, [2, 'b'])): dict(<(1, 'a'), (2, 'b')>):

Пример №9. Приведение к типу dict.

Краткие итоги параграфа

• Для преобразования различных типов данных между собой в Python доступен целый ряд встроенных функций (конструкторов типов): bool() – приведение к логическому типу, int() – приведение к целочисленному типу, float() – приведение к вещественному типу, complex() – приведение к комплексному числу, str() – приведение к строковому типу, tuple() – приведение к кортежу, list() – приведение к списку, dict() – приведение к словарю, set() – приведение к множеству.
• В операциях, например, с различными типами чисел или же в условных инструкциях и выражениях интерпретатор неявно (автоматически) преобразует объекты к общему типу. Однако в большинстве случаев это не так, поэтому следует внимательно следить за текущим типом переменной и при необходимости самостоятельно осуществлять явное приведение к нужному типу.

Помогите проекту, подпишитесь!

Подписка на учебные материалы сайта оформляется сроком на один год и стоит около 15 у.е. 5 у.е. После подписки вам станут доступны следующие возможности.

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

На страницу подписки

Вопросы и задания для самоконтроля

1. Каким будет результат сложения двух переменных a = 5 и b = ‘7’ ? А если их перемножить? Показать решение.

Ответ. В первом случае мы получим ошибку, т.к. оператор сложения подразумевает наличие операндов одного типа, но интерпретатор в общем случае не занимается автоматическим приведением типов, оставляя эту обязанность программистам. А вот умножение строки на число предусмотрено заранее, поэтому на выходе мы получим строку ‘77777’ .

2. Приведите пример ситуации, в которой интерпретатор осуществляет неявное приведение к нужному типу. Показать решение.

Ответ. Примерами могут служить: преобразование к вещественному типу при сложении целого и вещественного числа ( 5 + 0.3 ) или же преобразование объектов к логическому типу в условных инструкциях и выражениях ( 1 if ‘ok’ else 0 ).

3. Какой важной особенностью должны обладать объекты, которые явно преобразуются в кортежи, списки или множества? Показать решение.

Ответ. В кортежи, списки или множества при явном приведении типа могут быть преобразованы только итерируемые объекты. Преобразовать, например, число в список не получится.

4. В каких случаях интерпретатор возбудит ошибки? Показать решение.

Условие pythonCodes

print(bool([False])) print(int('7.5')) print(float(None)) print(float('0.55')) print(str(None)) print(list(range(1, 5))) print(dict([[[5], 'пять']])) print(dict([[5, 'пять']]))

Решение Результат pythonCodes

# True. print('bool([False]):', bool([False])) # invalid literal for . # print('int("7.5"): ', int('7.5')) # float() argument must be a string. # print('float(None): ', float(None)) # 0.55. print('float("0.55"): ', float('0.55')) # None. print('str(None):', str(None)) # [1, 2, 3, 4]. print("list(range(1, 5)):", list(range(1, 5))) # unhashable type: list (списки не могут быть ключами). # print("dict([[[5], 'пять']]):", dict([[[5], 'пять']])) # . print("dict([[5, 'пять']]):", dict([[5, 'пять']]))

bool([False]): True float("0.55"): 0.55 str(None): None list(range(1, 5)): [1, 2, 3, 4] dict([[5, 'пять']]):

5. Дополнительные тесты по теме расположены в разделе «Приведение типов» нашего сборника тестов.

Быстрый переход к другим страницам

• Типы bool и NoneType в Python
• Приведение типов в Python
• Инструкции, выражения и операторы в Python
• Вернуться к оглавлению учебника

okpython.net Copyright © 2022-2023.

Как преобразовать тип переменной в python

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

16 марта 2023
Оценки статьи
Еще никто не оценил статью

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

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

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

Преобразование в строку может происходить явно или неявно. Явное преобразование в строку осуществляется с помощью функции str() .

num = 42 str = str(num) # '42' 

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

num = 42 str = 'The answer is ' + str(num) # 'The answer is 42' 

Преобразование в целое число в Python

Преобразование в целое число также может происходить явно или неявно. Явное преобразование в целое число осуществляется с помощью функции int() .

str = '42' num = int(str) # 42 

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

num1 = 42 num2 = '7' sum = num1 + int(num2) # 49 (строка '7' преобразуется в целое число) 

Преобразование в число с плавающей точкой в Python

Преобразование в число с плавающей точкой может также происходить явно или неявно. Явное преобразование в число с плавающей точкой осуществляется с помощью функции float() .

str = '3.14' num = float(str) # 3.14 

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

num1 = 42 num2 = '3.14' sum = num1 + float(num2) # 45.14 (строка '3.14' преобразуется в число с плавающей точкой) 

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

В Python есть операторы, которые могут приводить к неожиданному преобразованию типов данных при их использовании. Например, оператор + может приводить к неявному преобразованию типов данных:

num1 = 42 str1 = 'The answer is ' str2 = num1 + str1 # Ошибка: нельзя складывать число и строку 

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

num1 = 42 str1 = 'The answer is ' str2 = str(num1) + str1 # '42The answer is ' 

Преобразование с помощью методов в Python

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

str = '3.14, 42, True' lst = str.split(', ') num1 = float(lst[0]) num2 = int(lst[1]) bool1 = bool(lst[2])  print(type(num1)) # print(type(num2)) # print(type(bool1)) # 

Здесь мы разделили строку str на список строк lst с помощью метода split() . Затем мы явно преобразовали первый элемент списка в число с плавающей точкой float() , второй элемент — в целое число int() , а третий элемент — в булево значение bool() .

Вывод

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

Меню категорий

Загрузка категорий.

Преобразование (приведение) типов данных в Python

Преобразование (приведение) типов в программировании — это процесс конвертации данных из одного типа в другой (например, преобразование переменной из типа int в тип float).

В Python есть два способа преобразования типов:

Неявное преобразование — автоматическая конвертация типов данных интерпретатором Python.

Явное преобразование — ручная конвертация типов данных программистом с помощью определенных функций в Python.

Неявное преобразование типов в Python

В определенных ситуациях Python автоматически преобразует один тип данных в другой — это известно как неявное преобразование типов.

Давайте рассмотрим пример, в котором Python выполняет конвертацию меньшего типа (int) в больший тип (float), чтобы избежать потери данных.

integer_number = 144
float_number = 1.44
sum = integer_number + float _ number
# Выводим новое значение и его тип данных
print ( «Value:» , sum )
print ( «Data Type:» , type ( sum ) )

Value: 145.44
Data Type:

Здесь мы создали две переменные: integer_number типа int и float_number типа float. Затем мы добавили эти две переменные и сохранили результат в переменной sum . Как вы можете видеть, sum имеет значение 124.23 и тип данных float.

Python всегда преобразует меньшие типы данных в большие типы данных, чтобы избежать потери данных.

Примечание: Мы получим ошибку TypeError , если попытаемся добавить значения типов str и int, например, ’12’ + 23 . Python не может использовать неявное преобразование в подобных ситуациях. Для этого существует явное преобразование.

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

При явном преобразовании типов программисты конвертируют данные из одного типа данных в другой (требуемый) тип данных вручную. Для выполнения явного преобразования типов используются такие встроенные функции, как int() , float() , str() и др.

Этот тип преобразования также называется приведением типов, поскольку пользователь приводит (изменяет) тип данных объектов.

Рассмотрим пример добавление строки и целого числа с использованием явного преобразования:

num_string = ’14’
num_integer = 25
print ( «Data type of num_string before Type Casting:» , type ( num_string ) )
# Явное преобразование типов
num_string = int ( num_string )
print ( «Data type of num_string after Type Casting:» , type ( num_string ) )
num_sum = num_integer + num_string
print ( «Sum:» , num_sum )
print ( «Data type of num_sum:» , type ( num_sum ) )

Data type of num_string before Type Casting:
Data type of num_string after Type Casting:
Sum: 39
Data type of num_sum:

Здесь мы создали две переменные: num_string типа str и num_integer типа int. Обратите внимание на следующую строку кода:

num_string = int ( num_string )

Здесь мы использовали функцию int() для выполнения явного преобразования переменной num_string в целочисленный тип int. После этого Python может добавить эти две переменные — мы получили значение 35 и поместили его в переменную num_sum типа int, которую затем вывели на экран.

Ключевые моменты, которые следует запомнить

Преобразование типов — это конвертация объекта из одного типа данных в другой тип данных.

Неявное преобразование типов автоматически выполняется интерпретатором Python.

Python позволяет избежать потери данных при неявном преобразовании типов.

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

При явном преобразовании типов возможна потеря данных, поскольку мы «привязываем» объект к определенному типу данных.

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

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

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

Преобразование числовых типов

Бывает, вы работаете над чужим кодом и вам нужно преобразовать целое число в число с плавающей запятой (и наоборот). Или вы можете обнаружить, что использовали целое число, хотя на самом деле вам нужно число с плавающей запятой. Python имеет встроенные методы, позволяющие легко выполнить все эти преобразования.

Преобразование целых чисел в числа с плавающей запятой

Метод Python float() преобразует целые числа в числа с плавающей запятой. Чтобы использовать эту функцию, добавьте в скобки целое число:

float(57)

В этом случае 57 будет преобразовано в 57.0.

Этот метод можно использовать и с переменной. Объявим f равным 57, а затем выведем новое значение с плавающей запятой:

f = 57 print(float(f))

Используя функцию float() , мы можем преобразовывать целые числа в числа с плавающей запятой.

Преобразование чисел с плавающей запятой в ​​целые числа

Python также имеет встроенную функцию для преобразования чисел с плавающей запятой в целые числа: int() .

Функция int() работает аналогично функции float() . Чтобы преобразовать десятичную дробь в целое число, вы можете добавить его внутрь скобок:

int(390.8)

В этом случае 390.8 будет преобразовано в 390.

Эту функцию можно использовать и с переменными. Давайте объявим b равным 125.0, а c — равным 390.8, а затем применим к переменным функцию int() :

b = 125.0 c = 390.8 print(int(b)) print(int(c))

125 390

При преобразовании чисел с плавающей запятой в целые числа с помощью функции int() Python отсекает все, что идет после запятой. Мы можем ожидать, что 390,8 округлится до 391, но с применением только лишь функции int() этого не произойдет.

Преобразование чисел путем деления

В Python 3 при делении одного целого числа на другое целое число результат преобразуется в число с плавающей запятой. То есть, если разделить 5 на 2, в Python 3 вы получите число с плавающей запятой:

a = 5 / 2 print(a)

В Python 2, так как вы имели дело с двумя целыми числами, вы получите ответ в виде целого числа: 5 / 2 = 2. Прочтите «Python 2 vs Python 3: Практические соображения» для получения дополнительной информации о различиях между Python 2 и Python 3.

Преобразования со строками

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

Преобразование чисел в строки

Числа в строки можно преобразовать с помощью метода str() . Мы передаем число или переменную в скобки метода, а на выходе получаем строковое значение.

Давайте сначала рассмотрим преобразование целых чисел. Чтобы преобразовать целое число 12 в строку, передадим его в метод str() :

str(12)

При запуске str(12) в интерактивной оболочке Python (чтобы войти в оболочку, введите python в окне терминала) вы получите следующий вывод:

Кавычки вокруг числа 12 означают, что оно теперь является строковым значением, а не целым числом.

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

user = "Sammy" lines = 50 print("Congratulations, " + user + "! You just wrote " + lines + " lines of code.")

Когда мы запускаем этот код, мы получаем следующую ошибку:

TypeError: Can't convert 'int' object to str implicitly

Мы не можем объединять строки и целые числа в Python, поэтому нам придется преобразовать переменную lines в строковое значение:

user = "Sammy" lines = 50 print("Congratulations, " + user + "! You just wrote " + str(lines) + " lines of code.")

Теперь при запуске кода мы получим следующий вывод, поздравляющий нашего пользователя с прогрессом:

Congratulations, Sammy! You just wrote 50 lines of code.

Если мы хотим преобразовать в строку не целое число, а число с плавающей запятой, порядок действий остается прежним. Мы передаем в метод str() число с плавающей запятой, а возвращено будет строковое значение. Передавать в метод можно как само число, так и переменную:

print(str(421.034)) f = 5524.53 print(str(f))

'421.034' '5524.53'

Чтобы убедиться, что все правильно, мы можем объединить в выводе преобразованное число и строковые значения:

f = 5524.53 print("Sammy has " + str(f) + " points.")

Sammy has 5524.53 points.

Мы можем быть уверены, что наш float был правильно преобразован в строку, потому что конкатенация была выполнена без ошибок.

Преобразование строк в числа

Если в вашей строке нет десятичных знаков, вы, скорее всего, захотите преобразовать ее в целое число с помощью метода int() .

Давайте возьмем пример пользователя Сэмми, отслеживающего количество написанных строк кода. Чтобы предоставить пользователю более интересную обратную связь, мы можем проводить с полученными значениями какие-то математические действия. Но в настоящее время эти значения хранятся в строках:

lines_yesterday = "50" lines_today = "108" lines_more = lines_today - lines_yesterday print(lines_more)

TypeError: unsupported operand type(s) for -: 'str' and 'str'

Поскольку два числовых значения хранились в строках, мы получили ошибку. Операнд «-» для вычитания не является допустимым операндом для двух строковых значений.

Давайте изменим код, чтобы включить в него метод int() . Он преобразует строки в целые числа и позволит нам выполнять математические действия со значениями, которые изначально были строками.

lines_yesterday = "50" lines_today = "108" lines_more = int(lines_today) - int(lines_yesterday) print(lines_more)

Переменная lines_more автоматически является целым числом, и в этом примере она равна числовому значению 58.

В приведенном выше примере мы также можем преобразовать строчные значения в числа с плавающей запятой, используя метод float() вместо метода int() . В этом случае вместо 58 мы получим число с плавающей запятой — 58.0. Пользователь Сэмми зарабатывает очки в дробных числах:

total_points = "5524.53" new_points = "45.30" new_total_points = total_points + new_points print(new_total_points)

5524.5345.30

В этом случае использование операнда «+» с двумя строками является допустимой операцией. Но эта операция объединяет две строки, а не складывает два числовых значения вместе. В результате наш output выглядит необычно, поскольку это просто два значения рядом друг с другом.

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

total_points = "5524.53" new_points = "45.30" new_total_points = float(total_points) + float(new_points) print(new_total_points)

5569.83

Теперь, когда мы преобразовали две строки в числа с плавающей запятой, мы получаем ожидаемый результат: сумму чисел 45.30 и 5524.53.

Если мы попытаемся при помощи метода int() конвертировать строку, представляющую собой десятичную дробь, в целое число, мы получим ошибку:

f = "54.23" print(int(f))

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

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

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

Вы можете использовать методы list() и tuple() для преобразования переданных им значений в тип данных списка и кортежа соответственно. В Python:

• список является изменяемой упорядоченной последовательностью элементов, заключенных в квадратные скобки [ ] .
• кортеж является неизменяемой упорядоченной последовательностью элементов, заключенных в круглые скобки ( ) .

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

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

print(tuple(['pull request', 'open source', 'repository', 'branch']))

('pull request', 'open source', 'repository', 'branch')

Мы видим, что в результате выводится кортеж, поскольку элементы теперь заключены в круглые, а не в квадратные скобки.

Давайте используем tuple() с переменной, представляющей список:

sea_creatures = ['shark', 'cuttlefish', 'squid', 'mantis shrimp'] print(tuple(sea_creatures))

('shark', 'cuttlefish', 'squid', 'mantis shrimp')

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

Мы можем преобразовать в кортеж не только список, но и любой итерируемый тип, включая строки:

print(tuple('Sammy'))

('S', 'a', 'm', 'm', 'y')

Строки можно преобразовывать в кортежи с помощью метода tuple() , потому что они итерируемые (их можно перебирать). Но с типами данных, которые не являются итерируемыми (пример — целые числа и числа с плавающей запятой), мы получим ошибку:

print(tuple(5000))

TypeError: 'int' object is not iterable

Можно преобразовать целое число в строку, а затем в кортеж: tuple(str(5000)) . Но лучше выбрать читаемый код, а не сложные преобразования.

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

Преобразование значений, особенно кортежей, в списки может быть полезно, когда вам нужно иметь изменяемую версию этого значения. Для преобразования в список используется метод list() .

Давайте преобразуем кортеж в список. Будьте внимательны со скобками: одна пара для кортежа, вторая — для метода list() , а третья — для метода print() :

print(list(('blue coral', 'staghorn coral', 'pillar coral')))

['blue coral', 'staghorn coral', 'pillar coral']

Квадратные скобки сигнализируют о том, что кортеж, переданный в метод list() , преобразован в список.

Чтобы сделать код более читабельным, мы можем ввести переменную и удалить одну из пар круглых скобок:

coral = ('blue coral', 'staghorn coral', 'pillar coral') list(coral)

Если мы выведем list(coral) , мы получим тот же результат, что и выше.

В список можно преобразовать не только кортеж, но и строку:

print(list('shark'))

['s', 'h', 'a', 'r', 'k']

Заключение

В этой статье мы рассмотрели, как можно преобразовать одни типы данных в другие (в основном, с помощью встроенных методов). Возможность конвертировать типы данных в Python дает вам дополнительную гибкость при написании программ.