Как преобразовать переменную в int python

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

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

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

Читайте также: Типы данных в Python 3

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

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

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

Метод float() преобразовывает целые числа в числа с плавающей точкой. Число указывается в круглых скобках:

Это преобразует число 57 в 57.0.

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

f = 57
print(float(f))
57.0

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

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

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

Число 390.8 преобразуется в 390.

Эта функция также может работать с переменными. Объявите переменные:

b = 125.0
c = 390.8

Затем преобразуйте и отобразите их:

print(int(b))
print(int(c))
125
390

Чтобы получить целое число, функция int() отбрасывает знаки после запятой, не округляя их (потому 390.8 не преобразовывается в 391).

Преобразование чисел с помощью деления

При делении Python 3 может преобразовать целое число в число с плавающей точкой (в Python 2 такой функции нет). К примеру, разделив 5 на 2, вы получите 2.5.

Python не преобразовывает тип данных во время деления; следовательно, деля целое число на целое число, в результате вы получили бы целое число, 2.

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

Строка – это последовательность из одного или больше символов (цифр, букв и других символов). Строки – очень распространённый тип данных в программировании. Существует много способов преобразования строк.

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

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

Попробуйте преобразовать целое число, например:

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

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

Особенно полезно преобразовывать числа в строки, используя переменные. К примеру, можно отследить, сколько строк кода в день пишет тот или иной пользователь. Если пользователь пишет больше 50 строк, программа отправит ему поощрительное сообщение.

user = «Michael»
lines = 50
print(«Congratulations, » + user + «! You just wrote » + lines + » lines of code.»)

Запустив этот код, вы получите ошибку:

TypeError: Can’t convert ‘int’ object to str implicitly

Python не может склеивать строки с числами, потому нужно преобразовать значение lines в строку.

user = «Michael»
lines = 50
print(«Congratulations, » + user + «! You just wrote » + str(lines) + » lines of code.»)

Теперь, запустив код, вы увидите:

Congratulations, Michael! 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(«Michael has » + str(f) + » points.»)
Michael has 5524.53 points.

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

Строки можно преобразовать в числа с помощью методов int() и 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’

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

lines_yesterday = «50»
lines_today = «108»
lines_more = int(lines_today) — int(lines_yesterday)
print(lines_more)
58

Значение переменной lines_more – это число, в данном случае это 58.

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

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

total_points = «5524.53»
new_points = «45.30»
new_total_points = total_points + new_points
print(new_total_points)
5524.5345.30

В данном случае оператор + склеивает две строки, а не складывает числа. Потому в результате получилось довольно странное значение.

Конвертируйте эти строки в числа с плавающей точкой, а затем выполните сложение.

total_points = «5524.53»
new_points = «45.30»
new_total_points = float(total_points) + float(new_points)
print(new_total_points)
5569.83

Как видите, теперь программа возвращает ожидаемый результат.

Если вы попробуете преобразовать строку с десятичными значениями в целое число, вы получите ошибку:

f = «54.23»
print(int(f))
ValueError: invalid literal for int() with base 10: ‘54.23’

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

Чтобы преобразовать данные в кортеж или список, используйте методы tuple() и list() соответственно. В 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(5000))
TypeError: ‘int’ object is not iterable

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

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

Обратите внимание: при этом в методах list() и print() используется две пары круглых скобок. Одни принадлежать собственно методу, а другие – кортежу.

print(list((‘blue coral’, ‘staghorn coral’, ‘pillar coral’)))
[‘blue coral’, ‘staghorn coral’, ‘pillar coral’]

Если данные, которые вывел метод print, заключены в квадратные скобки, значит, кортеж преобразовался в список.

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

coral = (‘blue coral’, ‘staghorn coral’, ‘pillar coral’)
list(coral)

Строки тоже можно преобразовывать в списки:

Заключение

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

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

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

1. Неявное преобразование типов.
2. Явное приведение типов.

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

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

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

# Преобразуем целое число в число с плавающей точкой num_int = 123 num_float = 1.23 num_new = num_int + num_float print("Тип данных в num_int:", type(num_int)) print("Тип данных в num_float:", type(num_float)) print("Значение num_new:", num_new) print("Тип данных в num_new:", type(num_new)) 

Вывод:

Тип данных в num_int:
Тип данных в num_float:
Значение num_new: 124.23
Тип данных в num_new:

В программе выше:

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

Теперь давайте попробуем сложить строку и целое число и посмотрим, как Python с этим справится.

# Складываем строку и целое число num_int = 123 num_str = "456" print("Тип данных в num_int:", type(num_int)) print("Тип данных в num_str:", type(num_str)) print(num_int + num_str) 

Вывод:

Тип данных в num_int: 
Тип данных в num_str:  

Traceback (most recent call last): 
File "python", line 7, in 
TypeError: unsupported operand type(s) for +: 'int' and 'str'

В программе выше:

• мы сложили две переменные num_int и num_str.
• как видно из вывода, мы получили TypeError — Python не может использовать неявное преобразование в таких случаях.

Однако в Python есть решение для таких ситуаций — это явное приведение.

Явное приведение типов

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

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

Синтаксис

(выражение)

Приведение типов можно выполнить, если присвоить выражению значение функции, соответствующее нужному типу данных.

# Складываем строку и целое число с помощью явного преобразования num_int = 123 num_str = "456" print("Тип данных в num_int:", type(num_int)) print("Тип данных в num_str до явного приведения:", type(num_str)) num_str = int(num_str) print("Тип данных в num_str после явного приведения:", type(num_str)) num_sum = num_int + num_str print("Сумма num_int и num_str:", num_sum) print("Тип данных полученной суммы:", type(num_sum)) 

Вывод:

Тип данных в num_int:
Тип данных в num_str до явного приведения:

Тип данных в num_str после явного приведения:

Сумма num_int и num_str: 579
Тип данных полученной суммы:

В программе выше:

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

Что надо запомнить:

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

СodeСhick.io — простой и эффективный способ изучения программирования.

2023 © ООО «Алгоритмы и практика»

Как преобразовать переменную в int python

Здесь Python понимает, что вы хотите сохранить целое число 110 в виде строки или используете целочисленный тип данных:

>>> i = 110 

Важно учитывать, что конкретно подразумевается под «110» и 110 в приведённых выше примерах. Для человека, который использовал десятичную систему счисления всю жизнь очевидно, что речь идёт о числе сто десять. Однако другие системы счисления, такие, как двоичная и шестнадцатеричная, используют иные основания для представления целого числа.

Например, вы представляете число сто десять в двоичном и шестнадцатеричном виде как 1101110 и 6e соответственно.

А также записываете целые числа в других системах счисления в Python с помощью типов данных str и int:

>>> binary = 0b1010 >>> hexadecimal = "0xa" 

Обратите внимание, что binary и hexadecimal используют префиксы для идентификации системы счисления. Все целочисленные префиксы имеют вид 0? , где ? заменяется символом, который относится к системе счисления:

1. b: двоичная (основание 2);
2. o: восьмеричная (основание 8);
3. d: десятичная (основание 10);
4. x: шестнадцатеричная (основание 16).

Техническая подробность: префикс не требуется ни в int , ни в строковом представлении, когда он определён логически.

int предполагает, что целочисленный литерал – десятичный:

>>> decimal = 303 >>> hexadecimal_with_prefix = 0x12F >>> hexadecimal_no_prefix = 12F File "", line 1 hexadecimal_no_prefix = 12F ^ SyntaxError: invalid syntax 

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

>>> decimal = "303" >>> hexadecimal_with_prefix = "0x12F" >>> hexadecimal_no_prefix = "12F" 

Каждая из этих строк представляет одно и то же целое число.

Теперь, когда мы разобрались с базовым представлением целых чисел с помощью str и int , вы узнаете, как преобразовать Python строку в int .

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

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

>>> int("10") 10 >>> type(int("10"))

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

>>> int("0x12F") Traceback (most recent call last): File "", line 1, in ValueError: invalid literal for int() with base 10: '0x12F' 

Сообщение об ошибке говорит, что строка – недопустимое десятичное целое число.

Важно понимать разницу между двумя типами неудачных результатов при передаче строки в int() :

1. Синтаксическая ошибка ValueError возникает, когда int() не знает, как интерпретировать строку с использованием предоставленного основания (10 по умолчанию).
2. Логическая ошибка int() интерпретирует строку, но не так, как то ожидалось.

Вот пример логической ошибки:

>>> binary = "11010010" >>> int(binary) # Using the default base of 10, instead of 2 11010010 

В этом примере вы подразумевали, что результатом будет 210 – десятичное представление двоичной строки. К сожалению, поскольку точное поведение не было указано, int() предположил, что строка – десятичное целое число.

Гарантия нужного поведения – постоянно определять строковые представления с использованием явных оснований:

>>> int("0b11010010") Traceback (most recent call last): File "", line 1, in ValueError: invalid literal for int() with base 10: '0b11010010' 

Здесь получаете ValueError , потому что int() не способен интерпретировать двоичную строку как десятичное целое число.

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

>>> int("0x12F", base=16) 303 

Теперь int() понимает, что вы передаёте шестнадцатеричную строку и ожидаете десятичное целое число.

Техническая подробность: аргумент base не ограничивается 2, 8, 10 и 16:

>>> int("10", base=3) 3 

Отлично! Теперь, когда тонкости преобразования строки Python в int освоены, вы научитесь выполнять обратную операцию.

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

Для преобразования int в строку Python разработчик использует str() :

>>> str(10) '10' >>> type(str(10))

По умолчанию str() ведёт себя, как int() : приводит результат к десятичному представлению:

>>> str(0b11010010) '210' 

В этом примере str() блеснул «умом»: интерпретировал двоичный литерал и преобразовал его в десятичную строку.

Если вы хотите, чтобы строка представляла целое число в другой системе счисления, то используйте форматированную строку (f-строку в Python 3.6+) и параметр, который задаёт основание:

>>> octal = 0o1073 >>> f"" # Decimal '571' >>> f"" # Hexadecimal '23b' >>> f"" # Binary '1000111011' 

str – гибкий способ представления целого числа в различных системах счисления.

Заключение

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

В этом уроке мы изучили:

1. Как использовать str и int для хранения целых чисел.
2. Как указать явную систему счисления для целочисленного представления.
3. Как преобразовать строку Python в int .
4. Как преобразовать Python int в строку.

Теперь, когда вы усвоили материал о str и int , читайте больше о представлении числовых типов с использованием float(), hex(), oct() и bin()!

Как преобразовать переменную в int python

На этом шаге мы рассмотрим преобразование типов данных .

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

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

bool ([< объект >]) — преобразует объект в логический тип данных. Примеры:

>>> bool(0), bool(1), bool(""), bool("Строка"), bool([1, 2]), bool([]) (False, True, False, True, True, False) 

>>> int(7.5), int("71") (7, 71) >>> int("71", 10), int("71", 8), int("0o71", 8), int("A", 16) (71, 57, 57, 10) 

—> Если преобразование невозможно, то генерируется исключение:

>>> int("71s") Traceback (most recent call last): File "#3>", line 1, in int("71s") ValueError: invalid literal for int() with base 10: '71s' 

>>> float(7), float("7.1") (7.0, 7.1) >>> float("Infinity"), float("-inf") (inf, -inf) >>> float("Infinity") + float("-inf") nan 

>>> str(125), str([1, 2, 3]) ('125', '[1, 2, 3]') >>> str((1, 2, 3)), str('x': 5, 'y': 10>) ('(1, 2, 3)', "") >>> str(bytes('строка', 'utf-8')) "b'\\xd1\\x81\\xd1\\x82\\xd1\\x80\\xd0\\xbe\\xd0\\xba\\xd0\\xb0'" >>> str(bytearray('строка', 'utf-8')) "bytearray(b'\\xd1\\x81\\xd1\\x82\\xd1\\x80\\xd0\\xbe\\xd0\\xba\\xd0\\xb0')" 

>>> obj1 = bytes("строка1", "utf-8") >>> obj2 = bytearray("строка2", "utf-8") >>> str(obj1, 'utf-8'), str(obj2, 'utf-8') ('строка1', 'строка2') >>> str(obj1, "ascii", "ignore") '1' >>> str(obj1, "ascii", "strict") Traceback (most recent call last): File "", line 1, in str(obj1, "ascii", "strict") UnicodeDecodeError: 'ascii' codec can't decode byte 0xd1 in position 0: ordinal not in range(128) 

>>> bytes('строка', 'cp1251') b'\xf1\xf2\xf0\xee\xea\xe0' >>> bytes('строка123', 'ascii', 'ignore') b'123' 

>>> b = bytes([225, 226, 224, 174, 170, 160]) >>> b b'\xe1\xe2\xe0\xae\xaa\xa0' >>> str(b, 'cp866') 'строка' 

>>> bytearray('строка', 'cp1251') bytearray(b'\xf1\xf2\xf0\xee\xea\xe0') 

>>> b = bytearray([225, 226, 224, 174, 170, 160]) >>> b bytearray(b'\xe1\xe2\xe0\xae\xaa\xa0') >>> str(b, 'cp866') 'строка' 

>>> list("12345") # Преобразование строки ['1', '2', '3', '4', '5'] >>> list((1, 2, 3, 4, 5)) # Преобразование кортежа [1, 2, 3, 4, 5] 

>>> tuple("123456") # Преобразование строки ('1', '2', '3', '4', '5', '6') >>> tuple([1, 2, 3, 4, 5, 6]) # Преобразование списка (1, 2, 3, 4, 5, 6) 

В качестве примера рассмотрим возможность сложения двух чисел, введенных пользователем. Как вы уже знаете, вводить данные позволяет функция input () . Воспользуемся этой функцией для получения чисел от пользователя (рисунок 1).

# -*- coding: utf-8 -*- x = input("x comm"># Вводим первое значение y = input("у comm"># Вводим второе значение print(x + y) input()

Рис.1. Получение данных от пользователя

Архив с файлом можно взять здесь.

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

Рис.2. Результат выполнения скрипта

Таким образом, следует запомнить, что функция input () возвращает результат в виде строки. Чтобы просуммировать два числа, необходимо преобразовать строку в число (рисунок 3).

# -*- coding: utf-8 -*- x = int(input("x comm"># Вводим первое значение y = int(input("у comm"># Вводим второе значение print(x + y) input()

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

Архив с файлом можно взять здесь.

В этом случае мы получим число 17, как и должно быть (рисунок 4).

Рис.2. Результат выполнения скрипта

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

На следующем шаге мы рассмотрим удаление переменной .