Как преобразовать число в строку и обратно в Python

Чтобы преобразовать число в строку в Python, используйте str(): str(42) вернёт '42', а str(3.14) — '3.14'. Если нужен формат (два знака после точки, ведущие нули), берите f-строку: f"{price:.2f}". Обратное преобразование делают int("42") и float("3.14"); если строка не похожа на число, они выбрасывают ValueError.

Ниже — все способы перевести число в строку и строку в число, форматирование, двоичная и шестнадцатеричная запись, списки чисел, обработка некорректного ввода и типичные ошибки. Примеры проверены на Python 3.12.

Число в строку: str()

Функция str() принимает любое число — int, float, bool, Decimal — и возвращает его текстовое представление:

n = 42
s = str(n)
print(s, type(s))         # → 42 <class 'str'>
print(repr(str(3.14)))    # → '3.14'
print(repr(str(-7)))      # → '-7'
print(repr(str(True)))    # → 'True'
print(repr(str(10**20)))  # → '100000000000000000000'

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

print(repr(str(0.1 + 0.2)))  # → '0.30000000000000004'
print(repr(str(1/3)))        # → '0.3333333333333333'
print(repr(str(1e16)))       # → '1e+16'

Если такой вид не подходит, отформатируйте число явно — об этом следующий раздел. О самих типах int и float подробнее рассказано в статье о числах в Python.

Число в строку с форматированием

f-строки и функция format() превращают число в строку сразу в нужном виде:

price = 1234.5
print(f"{price:.2f}")        # → 1234.50   (2 знака после точки)
print(f"{0.1 + 0.2:.2f}")    # → 0.30
print(f"{1e16:.0f}")         # → 10000000000000000 (без экспоненты)
print(f"{7:03d}")            # → 007       (ведущие нули)
print(str(7).zfill(3))       # → 007
print(format(price, ".1f"))  # → 1234.5

Задача	Код	Результат
просто в строку	str(42)	'42'
2 знака после точки	f"{3.14159:.2f}"	'3.14'
ведущие нули до 3 цифр	f"{7:03d}" или str(7).zfill(3)	'007'
разделитель тысяч	f"{1234567:,}"	'1,234,567'
процент	f"{0.256:.1%}"	'25.6%'
двоичная запись	bin(10) / format(10, "b")	'0b1010' / '1010'
шестнадцатеричная запись	hex(255) / format(255, "x")	'0xff' / 'ff'

Все спецификаторы формата с примерами собраны в статье об f-строках.

Число в строку для склейки текста

Самая частая причина преобразования — нужно вставить число в текст. Оператор + не смешивает строки и числа:

age = 30
msg = "Возраст: " + age        # → TypeError: can only concatenate str (not "int") to str
print("Возраст: " + str(age))  # → Возраст: 30
print(f"Возраст: {age}")       # → Возраст: 30

f-строка короче и сама вызывает преобразование. А print() с несколькими аргументами превращает числа в строки автоматически: print("Возраст:", age).

Двоичная, восьмеричная и шестнадцатеричная запись

print(bin(10), oct(10), hex(255))                          # → 0b1010 0o12 0xff
print(format(10, "b"), format(255, "x"), format(255, "08b"))  # → 1010 ff 11111111

bin(), oct() и hex() добавляют префикс системы счисления, format() — нет. Обратно в число такую строку переводит int() с основанием:

print(int("1010", 2), int("ff", 16), int("0xff", 16), int("0xff", 0))  # → 10 255 255 255

С основанием 0 Python сам определяет систему по префиксу 0b, 0o или 0x.

Строка в число: int() и float()

int() превращает строку в целое число, float() — в дробное. Пробелы и перевод строки по краям допускаются, знак + или - тоже:

print(int("42") + 1)       # → 43
print(float("3.14") * 2)   # → 6.28
print(int(" 42 \n"))       # → 42
print(int("-17"), int("+5"))  # → -17 5
print(int("1_000"))        # → 1000
print(float("1e3"), float("inf"), float(" -2.5 "))  # → 1000.0 inf -2.5

Типичный случай — ввод с клавиатуры. input() всегда возвращает строку, поэтому число нужно преобразовать явно:

age = int(input("Возраст: "))
print(age + 1)

Если чисел несколько в одной строке, разбейте её и преобразуйте каждую часть: a, b = map(int, input().split()). Подробно этот приём разобран в статье о методе split.

Дробная строка в int

int() не принимает строку с точкой. Сначала преобразуйте её во float, затем в int:

int("3.14")                # → ValueError: invalid literal for int() with base 10: '3.14'
print(int(float("3.14")))  # → 3
print(int(float("3.99")))  # → 3   (дробная часть отбрасывается)
print(round(float("3.99")))  # → 4  (округление)

Запятая вместо точки и пробелы в числе

float() понимает только точку как десятичный разделитель, а int() не допускает пробелов внутри числа. Почистите строку методом replace():

print(float("3,14".replace(",", ".")))  # → 3.14
print(int("1 000".replace(" ", "")))    # → 1000

Как проверить, что строка — число

Метод isdigit() проверяет, что все символы — цифры. Для целых неотрицательных чисел этого хватает, но минус, точка и пробелы дают False:

for v in ["42", "-42", "3.14", "abc", " 7 "]:
    print(repr(v), v.isdigit())

'42' True
'-42' False
'3.14' False
'abc' False
' 7 ' False

Надёжнее просто попробовать преобразовать строку и перехватить ValueError — подробнее о конструкции в статье о try/except:

def to_int(text, default=None):
    try:
        return int(text)
    except ValueError:
        return default

print(to_int("42"), to_int("abc"), to_int("abc", 0))  # → 42 None 0

Списки чисел и строк

join() соединяет только строки, поэтому список чисел сначала преобразуют через map(str, ...). Обратная задача — map(int, ...):

nums = [1, 2, 3]
", ".join(nums)                     # → TypeError: sequence item 0: expected str instance, int found
print(", ".join(map(str, nums)))    # → 1, 2, 3
print(list(map(int, "10 20 30".split())))  # → [10, 20, 30]
print([int(x) for x in ["1", "2", "3"]])   # → [1, 2, 3]

Подробнее — в статьях о методе join и о функции map.

Цифры числа

Строковое представление удобно, чтобы работать с отдельными цифрами:

n = 12345
print([int(d) for d in str(n)])     # → [1, 2, 3, 4, 5]
print(sum(int(d) for d in str(n)))  # → 15  (сумма цифр)
print(len(str(n)))                  # → 5   (количество цифр)
print(int(str(n)[::-1]))            # → 54321 (число задом наперёд)
print(int("".join(["1", "2", "3"])))  # → 123

Такие задачи часто встречаются в учебных упражнениях.

Деньги и точные дроби: Decimal

Если строка содержит денежную сумму, преобразуйте её в Decimal, а не во float — так не будет ошибок округления. Создавайте Decimal из строки, а не из float:

from decimal import Decimal

print(Decimal("0.1") + Decimal("0.2"))  # → 0.3
print(Decimal(0.1))  # → 0.1000000000000000055511151231257827021181583404541015625
print(str(Decimal("19.90")))  # → 19.90

str() у Decimal сохраняет заданное число знаков, в том числе нули в конце.

Частые ошибки

ValueError: invalid literal for int() with base 10

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

ValueError: invalid literal for int() with base 10: '3.14'
ValueError: invalid literal for int() with base 10: ''
ValueError: invalid literal for int() with base 10: '12abc'

Для дробных строк используйте float(), пустые строки проверяйте заранее, лишние символы убирайте через strip() и replace().

ValueError: could not convert string to float

Чаще всего виновата десятичная запятая: float("3,14") не работает. Замените запятую на точку.

TypeError: ‘str’ object is not callable

Вы назвали переменную str и перекрыли встроенную функцию:

str = "текст"
str(5)  # → TypeError: 'str' object is not callable

Переименуйте переменную (text, s) — то же касается имён int, list и input.

Сложение строк вместо чисел

"5" + "5" даёт '55', а не 10. Если значения пришли из input(), файла или JSON, преобразуйте их через int() или float() до вычислений.

Слишком длинное число

С Python 3.11, а также в выпусках безопасности 3.10.7, 3.9.14, 3.8.14 и 3.7.14 преобразование между int и десятичной строкой ограничено 4300 цифрами. Лимит защищает от DoS-атак (CVE-2020-10735): перевод огромного числа в десятичную строку и обратно занимает много времени. Если цифр больше, int(), str() и f-строки выбрасывают ValueError: Exceeds the limit (4300 digits) for integer string conversion. На hex(), oct(), bin() и int() с основанием 2, 8 или 16 лимит не действует. Изменить его можно через sys.set_int_max_str_digits() (значение 0 снимает ограничение), переменную окружения PYTHONINTMAXSTRDIGITS или ключ -X int_max_str_digits. В обычных задачах вы с этим лимитом не столкнётесь.

Частые вопросы

Чем отличаются isdigit(), isdecimal() и isnumeric()?

Все три проверяют символы Unicode, но с разной широтой. isdecimal() пропускает только десятичные цифры, которые понимает int(). isdigit() принимает ещё надстрочные цифры вроде ², а isnumeric() — и дроби вроде ½. Для проверки перед int() безопаснее isdecimal():

for s in ["42", "²", "½"]:
    print(repr(s), s.isdecimal(), s.isdigit(), s.isnumeric())

'42' True True True
'²' False True True
'½' False False True

При этом int("²") выбросит ValueError, хотя "²".isdigit() вернул True.

Как превратить строку “False” в False?

bool() для строки проверяет только, пустая ли она: bool("False") вернёт True. Сравнивайте текст с набором допустимых значений:

def to_bool(text):
    return text.strip().lower() in {"1", "true", "yes", "да", "on"}


print(bool("False"))                   # → True
print(to_bool("True"), to_bool("no"))  # → True False

Как преобразовать строку “1/3” в число?

float() и int() дробную запись не понимают. Модуль fractions создаёт точную дробь из такой строки, а float() превратит её в десятичное число:

from fractions import Fraction

x = Fraction("1/3")
print(x, x * 3, float(x))  # → 1/3 1 0.3333333333333333

Как вывести маленькое число без экспоненты?

str(0.00001) даёт '1e-05'. Задайте количество знаков в f-строке или, если оно заранее неизвестно, отформатируйте через Decimal с форматом f:

from decimal import Decimal

print(str(0.00001))                        # → 1e-05
print(f"{0.00001:.5f}")                    # → 0.00001
print(format(Decimal(str(0.00001)), "f"))  # → 0.00001

Итог

Число в строку переводит str(), а форматированную строку — f-строка вроде f"{x:.2f}". Строку в число превращают int() и float(); перед этим уберите пробелы и замените запятую на точку, а некорректный ввод перехватывайте через try/except ValueError. Другие операции с текстом собраны в статье о строках в Python, а остальной синтаксис — в шпаргалке по Python.