Содержание

Преобразование целого числа в строку в Python

Автор оригинала: Shubham Sayon.

Быстрое исправление: Встроенный Python str (x) Метод преобразует целочисленный объект х на строковый объект, используя X .__ STR __ () метод.

❖ Введение

Проблема разработки: Учитывая строка Объект в Python, каковы способы преобразовать его в Целое число тип?

Пример :

# This is an integer
x = 13
print("x is of type", type(x))
# Converting integer to string
y = str(x)
print("y is of type", type(y))

Выход:

x is of type y is of type

Давайте посмотрим на пример, где преобразование целого числа становится определяющим фактором в вашем коде.

Сценарий: Объединить строку и целое число.

version = 3
lang = 'Python'
print(lang+version)
# Desired Output: Python3

Фактический выход:

Traceback (most recent call last): File "D:/PycharmProjects/PythonErrors/int2string.py", line 3, in print(version+lang) TypeError: unsupported operand type(s) for +: 'int' and 'str'

Объяснение: Использование + Оператор для объединения строки и целочисления не допускаются в Python.

Таким образом, Python бросает TypeError: неподдерживаемый тип операнда (ы) для +: 'int' и 'STR' в этом случае.

Решение этой проблемы состоит в том, чтобы преобразовать целочисленное объект в строковый объект, а затем объединять две строки, как показано в растворе ниже.

Решение:

version = 3 lang = 'Python' print(lang+str(version)) # Output: Python3

Прежде чем перейти к решениям, я настоятельно рекомендую вам пройти методы преобразования типа, объясненные в Это руководство Отказ

Теперь, без дальнейшего ADO, давайте погрузимся в решения для нашего критического вопроса – « Как преобразовать целое число в строку в Python?

🖋️ Метод 1: Использование str () Метод

Встроенный Python str (x) Функция преобразует объект х в строку, используя X . __ STR __ () метод или, если не существуют,

Repra (x) Встроенная функция для получения строкового преобразования.

  • str () Метод возвращает тип строки объекта. Объект может быть символ, целое число и т. Д. Метод str () возвращает тип строки объекта. Объект может быть символ, целое число или строку.

Синтаксис:

str(object)

Пример:

num_int = 2500 num_str = str(num_int) print("num_str: ", num_str) print("Type of num_float: ", type(num_int)) print("Type of num_str: ", type(num_str))

Выход:

num_str: 2500 Type of num_float: Type of num_str:

🖋️ Метод 2: Использование формата () Функция

Мы можем использовать Формат () Способ в Python, для преобразования целых чисел на строки. Этот метод позволяет вам устанавливать заполнители внутри строки, а затем преобразовать любой другой тип данных (Integer, float) в строку и заполнить заполнители. Кудрявые скобки ‘ {}

«Используются для определения заполнителей.

Синтаксис

"{}" .format (int)

Пример:

# This is an integer y = 20 print("The value of y is", y) print("Initially the number is of type", type(y)) # Converting integer to string using format() y = "{}". format(y) print("The number is of type", type(y), "after conversion.")

Выход:

The value of y is 20 Initially the number is of type The number is of type after conversion.

🖋️ Метод 3: Использование строкового преобразования «% S»

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

  • Старый стандартный метод преобразования строки Python использует оператор модуля (знак процента%) в качестве уникального символа для демонстрации различных типов форматов.
  • Спецификаторы преобразования, например,% s и% d отображаются в строке формата как заполнителей.
  • Эти спецификаторы направляют, как операция отформатирует значения.
  • % s используется для конвертации строки Отказ

Пример:

# This is an integer
no = 2
print("Initially the value of the number is", no)
print("The number is of type", type(no))
# Converting integer to string using %s
conv = "% s" % no
print("The number is of type", type(conv), "after conversion.")

Выход:

Initially the value of the number is 2
The number is of type 
The number is of type  after conversion.

🖋️ Метод 4: использование F-струн

F-струны поддерживаются в Python 3.6 или более высоких версиях. Он представлен строковыми литералами, которые имеют F в качестве префикса и фигурных скобок, содержащих выражения. Переменные в выражении заменяются значениями во время оценки во время выполнения.

Синтаксис:

f'{ int }'

Пример:

# This is an integer
x = 50
print("The value of the number is", x)
print("The number is of type", type(x))
# Converting integer to string using f strings
y = f'{x}'
print("The value of the number remains", y)
print("The number is of type", type(y), "after conversion. ")

Выход:

The value of the number is 50
The number is of type 
The value of the number remains 50
The number is of type  after conversion.

🖋️ Метод 5: Использование пользовательского метода

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

Пример:

def convert(x, type_):
    x = type_(x)
    return x
num = 25
print("Initially type of num : ", type(num))
print("Type of num after conversion: ", type(convert(num, str)))

Выход:

Initially type of num :  
Type of num after conversion:  

❖ вывод

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

  • str () Встроенный метод.
  • Формат () Функция.
  • Конверсия строки с использованием «% s».
  • Используя F-струны.
  • Определение пользовательских функция.

Я надеюсь, что эта статья помогла вам. Пожалуйста, Подписаться и Оставайтесь настроиться Для более интересных статей в будущем.

Авторы 🤵 Шубхам Сайон 👩 Раши Агарваль

Рекомендуемый курс:

  • Вы хотите быстро освоить самые популярные Python IDE?
  • Этот курс приведет вас от новичка к эксперту в Пычарме в ~ 90 минут.
  • Для любого разработчика программного обеспечения имеет решающее значение для освоения IDE хорошо, писать, тестировать и отлаживать высококачественный код с небольшим усилием.

Присоединяйтесь к Pycharm MasterClass Сейчас и мастер Pycharm на завтра!

Я профессиональный Python Blogger и Content Creator. Я опубликовал многочисленные статьи и создал курсы в течение определенного периода времени. В настоящее время я работаю полный рабочий день, и у меня есть опыт в областях, таких как Python, AWS, DevOps и Networking.

Вы можете связаться со мной @:

  • Заработка
  • Linkedin.

Оригинал: “https://blog.finxter.com/converting-integer-to-string-in-python/”

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

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

В этой статье объясняется, как преобразовать целое число Python в строку.

Функция Python str()

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

Функция str() возвращает строковую версию данного объекта. Он принимает следующие формы:

  • object — объект, который нужно преобразовать в строку.

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

Преобразование целого числа Python в строку

Чтобы преобразовать целое число 23 в строковую версию, просто передайте это число в функцию str() :

Кавычки около 23 указывают на то, что число не является целым числом, а является объектом строкового типа. Кроме того, функция type() показывает, что объект является строкой.

Объединение строк и целых чисел

Попробуем объединить строки и целые числа с помощью оператора + и распечатать результат:

Python TypeError исключения TypeError потому что он не может объединить строки и целые числа:

Чтобы преобразовать целое число в строку, передайте целое число в функцию str() :

Теперь, когда вы запустите код, он будет успешно выполнен:

Есть и другие способы объединения строк и чисел.

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

В Python 3.6 и новее вы можете использовать f-строки, которые представляют собой буквальные строки с префиксом ‘f’, содержащие выражения в фигурных скобках:

Наконец, вы можете использовать старое% -форматирование:

Выводы

В Python вы можете преобразовать целое число в строку с помощью функции str() .

Если у вас есть какие-либо вопросы или отзывы, не стесняйтесь оставлять комментарии.

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

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

В этой статье вы узнаете, как преобразовать целое число в строку (int to string) с помощью Python.

Функция str () в Python

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

Функция str() возвращает строковую версию заданного объекта.

Он имеет следующий вид:

  • object: объект для преобразования в строку.

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

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

Чтобы преобразовать целое число 23 в строковый формат, просто передайте число в функцию str():

Кавычки вокруг 23 указывают на то, что число является не целым, а строковым объектом.

А функция type() показала, что объект является строкой.

В Python строки объявляются с помощью ‘ ), парных ( ” ) или тройных ( “”” ) кавычек.

Конкатенация строк и целых чисел

Давайте попробуем объединить строки и целые числа с помощью знака + и вывести результат:

Python выдаст ошибку TypeError, потому что не может объединить строки и целые числа:

Чтобы преобразовать целое число в строку, передайте целое число в функцию str():

Теперь, когда вы запустите код, он будет выполняться правильно:

Существуют и другие способы конкатенации строк и чисел.

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

В Python 3.6 и более поздних версиях вы можете использовать f-строки, которые представляют собой литеральные строки с префиксом ‘f’, содержащие выражения в фигурных скобках:

Кроме этого, вы можете использовать старое %-форматирование:

Заключение

В Python целое число можно преобразовать в строку с помощью функции str().

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

  • Автор записи

Вступление

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

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

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

Строки

Строковые литералы в Python объявляются путем окружения символа двойными (“) или одинарными кавычками (‘). Строки в Python на самом деле являются просто массивами с Юникодом для каждого символа в качестве элемента массива, что позволяет использовать индексы для доступа к одному символу из строки.

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

Цифры

Число в Python может быть integer , float или complex .

Целые числа могут быть положительным или отрицательным целым числом. Начиная с Python 3, целые числа неограниченны и могут содержать практически любое число. До Python 3 верхняя граница была 2 31 -1 для 32-битных сред выполнения и 2 63 -1 для 64-битных сред выполнения.

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

Сложные числительные должны иметь мнимую часть, которая обозначается через j :

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

Использование функции int()

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

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

Это же исключение будет вызвано даже при передаче допустимой строки float:

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

То же самое можно сделать и для любой другой базы, например шестнадцатеричной (база 16):

Использование функции float()

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

Обратите внимание, что полученное значение не совсем точно, как и должно быть 0.23 . Это связано с проблемами floating point math , а не с преобразованием строки в число.

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

В отличие от int() , float() не вызывает исключения, когда получает неплавающее числовое значение.

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

В то время как float() does not have the ability to convert non-base 10 numbers like int() does, it does have the ability to convert numbers represented in scientific notation (aka e-notation):

Использование функции complex()

Преобразование строковых литералов в комплексные числа осуществляется с помощью функции complex () . Для этого строка должна следовать определенному форматированию. В частности, он должен быть отформатирован без пробелов вокруг операторов + или — :

Наличие каких – либо дополнительных пробелов между операторами + или — приведет к возникновению исключения:

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

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

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

Использование функции str()

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

Функция str() доступна в Python 3.0+, так как строки в Python 3.0+ по умолчанию являются Unicode. Однако это не относится к версиям Python ниже 3.0 – в которых для достижения той же цели используется функция unicode() :

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

Использование функции format()

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

Чтобы использовать эту функцию, просто напишите строку, за которой следует .format () , и передайте аргументы для заполнителей.

Аргументы в функции .format() также можно ссылаться по отдельности, используя их позиции или имена переменных:

Обратите внимание, что под капотом функция .format() просто использует str() для преобразования аргументов в строки. Таким образом, по сути, это тот же способ преобразования чисел в строки, что и в предыдущем разделе, но .format() действует как удобная функция для форматирования строки.

Вывод

Python позволяет конвертировать строки, целые числа и поплавки взаимозаменяемо несколькими различными способами. Самый простой способ сделать это-использовать базовые функции str() , int () и float () . Кроме того, есть еще несколько способов, таких как функция format () . Просто имейте в виду, что функции int () , float () и complex() имеют свои ограничения и могут вызывать исключения, если входная строка отформатирована не совсем так, как они ожидают.

В этом руководстве мы узнаем, как преобразовать String в int и int в String в python.

Строка Python в Int

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

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

Результатом следующего кода будет:

Преобразование функционала из другой базы

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

Но помните, что выходное целое число всегда находится в базе 10. Еще одна вещь, которую вам нужно запомнить, – это то, что данная база должна находиться в диапазоне от 2 до 36. Смотрите следующий пример, чтобы понять преобразование строки в int с аргументом base.

Результатом следующего кода будет:

Исключение ValueError при преобразовании

При преобразовании строки в int вы можете получить исключение ValueError. Это исключение возникает, если строка, которую вы хотите преобразовать, не представляет никаких чисел.

Предположим, вы хотите преобразовать шестнадцатеричное число в целое. Но вы не передали аргумент base = 16 в функцию int(). Он вызовет исключение ValueError, если есть какая-либо цифра, которая не принадлежит десятичной системе счисления. Следующий пример иллюстрирует это исключение при преобразовании строки в int.

В итоге результатом приведенного выше кода будет:

Как преобразовать int в строку

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

Преобразование и приведение типов в 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: <class 'int'>
Тип данных в num_float: <class 'float'>
Значение num_new: 124. 23
Тип данных в num_new: <class 'float'>

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

  • мы сложили две переменные 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: <class 'int'> 
Тип данных в num_str: <class 'str'>

Traceback (most recent call last):
File "python", line 7, in <module>
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: <class 'int'>
Тип данных в num_str до явного приведения: <class 'str'>

Тип данных в num_str после явного приведения: <class 'int'>

Сумма num_int и num_str: 579
Тип данных полученной суммы: <class 'int’>

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

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

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

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

Преобразование целого числа в строку в Python

Просмотреть обсуждение

Улучшить статью

Сохранить статью

  • Уровень сложности: Базовый
  • Последнее обновление: 18 окт, 2022

  • Читать
  • Обсудить
  • Посмотреть обсуждение

    Улучшить статью

    Сохранить статью

    В Python целое число может быть преобразовано в строку с помощью встроенной функции str() . Функция str() принимает любой тип данных Python и преобразует его в строку. Но использование str() — не единственный способ сделать это. Этот тип преобразования также можно выполнить с помощью ключевого слова «%s» , функции .format или функции f-string .

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

    1. Использование функции STR ()

    Синтаксис: STR (Integer_Value)

    Пример: 9003

    6. Pithon333

    Пример: 9003

    6. Pithon333

    :

    6. Pithon333

    :

    63

    777.

    NUM = 10

    Печать ( "Тип переменной перед конверцией:" , "Тип переменной перед конверцией:" , "Тип. Converted_num = Str (NUM)

    Печать ( "Тип после конвертации:" , тип (Outstited_).0064

    Вывод:

     Тип переменной до преобразования: <класс 'int'>
    Type After conversion :   

    2. Using “%s” keyword

    Syntax: “%s” % integer

    Example:  

    Python3

    число = 10

     

    печать ( «Тип переменной перед преобразованием:« , Тип (NUM))

    Converted_Num = " % S" = " % S" = " % S". ( "Тип после преобразования:" , Тип (Converted_Num))

    Выход:

    Тип после преобразования:  

    3. Using .format() function

    Syntax: '{}'.format(integer)

    Example:  

    Python3

    num = 10

     

    print ( "Type before convertion : " , type (num))

     

    converted_num = "{}" . format (num)

    print ( "Type after convertion :" , type (converted_num))

     

    Output:

     Тип перед преобразованием: <класс 'int'>
    Тип после преобразования:  

    4. Использование f-string

    Синтаксис: f'{integer}’

    Example:  

    Python3

    num = 10

     

    print ( "Type before convertion : " , type (num))

    Converted_Num = F '{NUM}'

    Печать ( ".0064 , тип (converted_num))

    Вывод:

     Тип до преобразования: 
    Тип после преобразования: <класс 'str'> 

    5. Использование __str __ () Метод

    Синтаксис: I Nteger .__ Str __ ()

    Python3

    num = 10

     

    print ( "Type before convertion : " , type (num))

     

    converted_num = NUM .__ str __ ()

    Печать ( "Тип после преобразования:" , Тип (Converted_num) Тип (Converted_num)) Тип (Converted_num)) Тип (Converted_num)) Тип (CONGUNTIDE_NUM))0003

    Вывод:

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

    Python int в двоичную строку?

    Задавать вопрос

    Спросил

    Изменено 1 год, 2 месяца назад

    Просмотрено 1,1 млн раз

    748

    Новинка! Сохраняйте вопросы или ответы и организуйте свой любимый контент.
    Узнать больше.

    Существуют ли какие-либо стандартные методы Python для преобразования Integer (или Long) в двоичную строку в Python?

    В Google есть множество функций dec2bin()... Но я надеялся, что смогу использовать встроенную функцию/библиотеку.

    • python
    • двоичный
    • string.format

    1

    Метод формата строки Python может принимать спецификацию формата.

     >>> "{0:b}".формат(37)
    '100101'
     

    Документация спецификации формата для Python 2

    Документация спецификации формата для Python 3

    6

    Если вы ищете bin() как эквивалент hex() , он был добавлен в python 2.6.

    Пример:

     >>> bin(10)
    '0b1010'
     

    5

    Python на самом деле делает ли что-то уже встроенное для этого, возможность выполнять такие операции, как '{0:b}'. format(42) , что даст вам битовый шаблон (в строке) для 42 или 101010 .


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

     определить intToBinString, получая intVal:
        если intVal равен нулю:
            вернуть "0"
        установить для strVal значение ""
        в то время как intVal больше нуля:
            если intVal нечетное:
                префикс "1" к strVal
            еще:
                префикс "0" к strVal
            разделить intVal на два, округлив в меньшую сторону
        вернуть стрВал
     

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

    Общая идея заключается в использовании кода (в порядке предпочтения):

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

    5

    Если вам нужно текстовое представление без префикса 0b, вы можете использовать это:

     get_bin = lambda x: format(x, 'b')
    печать (get_bin (3))
    >>> '11'
    печать (get_bin (-3))
    >>> '-11'
     

    Если вам нужно n-битное представление:

     get_bin = lambda x, n: format(x, 'b').zfill(n)
    >>> get_bin(12, 32)
    '00000000000000000000000000001100'
    >>> get_bin(-12, 32)
    '-00000000000000000000000000001100'
     

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

     def get_bin(x, n=0):
        """
        Получите двоичное представление x. 
        Параметры
        ----------
        х : интервал
        п : интервал
            Минимальное количество цифр. Если x нужно меньше цифр в двоичном формате, остальные
            заполняется нулями.
        Возвращает
        -------
        ул
        """
        формат возврата (x, 'b').zfill (n)
     

    9

    Я удивлен, что нет упоминания о хорошем способе сделать это с помощью строк форматирования, которые поддерживаются в Python 3.6 и выше. TLDR:

     >>> число = 1
    >>> f'0b{номер:08b}'
    '0b00000001'
     

    Это функция форматирования строк, доступная в Python 3.6:

     >>> x, y, z = 1, 2, 3
    >>> f'{x} {y} {2*z}'
    '1 2 6'
     

    Вы также можете запросить двоичный код:

     >>> f'{z:b}'
    '11'
     

    Укажите ширину:

     >>> f'{z:8b}'
    '11'
     

    Запрос заполнения нулями:

     f'{z:08b}'
    '00000011'
     

    И добавьте общий префикс для обозначения двоичного числа:

     >>> f'0b{z:08b}'
    '0b00000011'
     

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

     >>> f'{z:#010b}'
    '0b00000011'
     

    Дополнительная информация доступна в официальной документации по форматированным строковым литералам и мини-языку спецификации формата.

    4

    В качестве ссылки:

     def toBinary(n):
        return ''.join(str(1 & int(n) >> i) для i в диапазоне (64)[::-1])
     

    Эта функция может преобразовать положительное целое число на 184446744073709551615 , представленная как строка '111111111111111111111111111111111111111н' .

    Его можно изменить, чтобы он обслуживал гораздо большее целое число, хотя он может быть не таким удобным, как "{0:b}".format() или bin() .

    2

    Это для Python 3 и сохраняет начальные нули!

     печать (формат (0, '08b'))
     

    3

    Простой способ сделать это — использовать строковый формат, см. эту страницу.

     >> "{0:b}".формат(10)
    «1010»
     

    И если вы хотите иметь фиксированную длину двоичной строки, вы можете использовать это:

     >> "{0:{fill}8b}". format(10, fill='0')
    '00001010'
     

    Если требуется дополнение до двух, можно использовать следующую строку:

     '{0:{fill}{width}b}'.format((x + 2**n) % 2**n, fill= '0', ширина=n)
     

    , где n — ширина двоичной строки.

    0

    однострочный с лямбда :

     >>> двоичный = лямбда n: '' если n == 0 иначе двоичный (n/2) + str (n% 2)
     

    тест:

     >>> двоичный (5)
    «101»
     

    РЕДАКТИРОВАТЬ :

    но тогда 🙁

     t1 = время()
    для я в диапазоне (1000000):
         двоичный (я)
    t2 = время ()
    печать (t2 - t1)
    # 6.57236599922
     

    по сравнению с

     t1 = время()
    для я в диапазоне (1000000):
        '{0:b}'.format(i)
    t2 = время ()
    печать (t2 - t1)
    # 0.68017411232
     

    2

    Как и в предыдущих ответах, в основном используется формат(), вот реализация f-строки.

     целое число = 7
    бит_счетчик = 5
    печать (f'{целое число:0{bit_count}b}')
     

    Вывод:

    00111

    Для удобства вот ссылка на документы python для форматированных строковых литералов: https://docs. python.org/3/reference/lexical_analysis.html#f-strings.

    Сводка альтернатив:

     n=42
    утверждать "-101010" == формат (-n, 'b')
    утверждать "-101010" == "{0:b}".format(-n)
    утверждать "-101010" == (лямбда x: x >= 0 и str(bin(x))[2:] или "-" + str(bin(x))[3:])(-n)
    утверждать "0b101010" == bin(n)
    assert "101010" == bin(n)[2:] # Но это не работает для отрицательных чисел.
     

    Среди участников Джон Фухи, Тунг Нгуен, mVChr, Мартин Тома. и Мартин Питерс.

    1

     >>> формат(123, 'б')
    '1111011'
     

    0

    Для тех из нас, кому нужно преобразовать целые числа со знаком (диапазон от -2**(цифры-1) до 2**(цифры-1)-1) в двоичные строки с дополнением до 2, это работает:

     def int2bin(integer , цифры):
        если целое >= 0:
            вернуть корзину (целое число) [2:].zfill (цифры)
        еще:
            возвратная корзина (2 ** цифры + целое число) [2:]
     

    Получается:

     >>> int2bin(10, 8)
    '00001010'
    >>> int2bin(-10, 8)
    '11110110'
    >>> int2bin(-128, 8)
    '10000000'
    >>> int2bin(127, 8)
    '01111111'
     

    вы можете сделать так:

     bin(10)[2:]
     

    или :

     f = ул (бин (10))
    с = []
    c. append("".join(карта(int, f[2:])))
    печатать с
     

    1

    Используя numpy pack/unpackbits, они ваши лучшие друзья.

     Примеры
    --------
    >>> a = np.array([[2], [7], [23]], dtype=np.uint8)
    >>> а
    массив([[ 2],
           [7],
           [23]], dtype=uint8)
    >>> b = np.unpackbits(a, ось=1)
    >>> б
    массив([[0, 0, 0, 0, 0, 0, 1, 0],
           [0, 0, 0, 0, 0, 1, 1, 1],
           [0, 0, 0, 1, 0, 1, 1, 1]], dtype=uint8)
     

    2

    Еще одно решение с другим алгоритмом, использующим побитовые операторы.

     по умолчанию int2bin(val):
        разрешение = ''
        пока значение>0:
            рез += ул(значение&1)
            значение=значение>>1 # значение=значение/2
        return res[::-1] # перевернуть строку
     

    Более быстрая версия без обращения строки.

     по умолчанию int2bin(val):
       разрешение = ''
       пока значение>0:
           разрешение = chr((val&1) + 0x30) + разрешение
           значение=значение>>1
       вернуть разрешение
     

    1

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

     >>> bin(37)
    '0b100101'
    >>> 0b100101
    37
     

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

    Python просто добавляет отрицательный знак, поэтому результат для -37 будет таким:

     >>> корзина (-37)
    '-0b100101'
     

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

    Одна запись представляет собой запись величины знака, где первый бит представляет отрицательный знак, а остальные — фактическое значение. В этом случае -37 будет 0b1100101 , а 37 будет 9.0063 0b0100101 . Это похоже на то, что производит python, но просто добавьте 0 или 1 впереди для положительных/отрицательных чисел.

    Более распространена нотация дополнения Two, которая кажется более сложной, а результат сильно отличается от форматирования строки Python. Вы можете прочитать подробности по ссылке, но с 8-битным целым числом со знаком -37 будет 0b11011011 , а 37 будет 0b00100101 .

    У Python нет простого способа создания этих двоичных представлений. Вы можете использовать numpy, чтобы превратить двоичные значения дополнения Two в целые числа python:

     >>> импортировать numpy как np
    >>> np.int8(0b11011011)
    -37
    >>> np.uint8(0b11011011)
    219
    >>> np.uint8(0b00100101)
    37
    >>> np.int8 (0b00100101)
    37
     

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

     >>> из битовой строки импортировать BitArray
    >>> arr = BitArray(int=-37, length=8)
    >>> приб.уинт
    219
    >>> приб.внутр.
    -37
    >>> обр.бин
    '11011011'
    >>> BitArray(bin='11011011').int
    -37
    >>> BitArray(bin='11011011').uint
    219

    В Python 3. 6 добавлен новый подход к форматированию строк, называемый форматированными строковыми литералами или «f-строками». Пример:

     имя = 'Боб'
    число = 42
    f"Здравствуйте, {name}, ваш номер {number:>08b}"
     

    Вывод будет "Привет, Боб, ваш номер 00001010!"

    Обсуждение этого вопроса можно найти здесь - Здесь

    Если я не понимаю, что вы подразумеваете под двоичной строкой, я думаю, что модуль, который вы ищете, - это структура

    . 1

     н=ввод()
    печать (бен (п). заменить ("0b", ""))
     

    0

     по умолчанию двоичный (десятичный):
        другая база = ""
        в то время как десятичный != 0 :
            otherBase = str(десятичный% 2) + otherBase
            десятичный //= 2
        вернуть другую базу
    печатать двоичный файл (10)
     

    вывод:

    1010

    Примеры из ссылки на документацию выше:

     >>> np. binary_repr(3)
    '11'
    >>> np.binary_repr(-3)
    '-11'
    >>> np.binary_repr(3, ширина=4)
    '0011'
     

    Дополнение до двух возвращается, когда входное число отрицательное и указана ширина:

     >>> np.binary_repr(-3, ширина=3)
    «101»
    >>> np.binary_repr(-3, ширина=5)
    «11101»
     

    Вот код, который я только что реализовал. Это не метод , но вы можете использовать его как готовую к использованию функцию !

     по умолчанию inttobinary(число):
      если число == 0:
        вернуть ул (0)
      результат = ""
      пока (число != 0):
          остаток = число%2
          число = число/2
          результат += ул(остаток)
      return result[::-1] # чтобы инвертировать строку
     

    0

    Несколько похожее решение

     def to_bin(dec):
        флаг = Истина
        bin_str = ''
        пока флаг:
            остаток = убыль % 2
            частное = уб/2
            если частное == 0:
                флаг = Ложь
            bin_str += str(остаток)
            dec = частное
        bin_str = bin_str[::-1] # перевернуть строку
        вернуть bin_str
     

    вот простое решение с использованием функции divmod(), которая возвращает напоминание и результат деления без дроби.

     дектобин(номер):
        корзина = ''
        в то время как (число >= 1):
            число, рем = divmod (число, 2)
            корзина = корзина + стр (рем)
        возвратная корзина
     

    1

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

     по умолчанию в корзину (число):
      если число == 0:
        возвращаться ""
      return toBin(num//2) + str(num%2)
    print ([(toBin(i)) для i в диапазоне (10)])
    ['', '1', '10', '11', '100', '101', '110', '111', '1000', '1001']
     

    1

    Калькулятор со всеми необходимыми функциями для DEC,BIN,HEX: (сделано и протестировано с помощью Python 3.5)

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

     # ПРЕОБРАЗОВАТЕЛЬ: DEC / BIN / HEX
    защита dec2bin(d):
        # дек -> бин
        б = бункер (д)
        вернуть б
    защита dec2hex(d):
        # дек -> шестнадцатеричный
        ч = шестнадцатеричный (г)
        вернуть ч
    защита bin2dec(b):
        # бин -> дек
        bin_numb="{0:b}". формат(б)
        d = оценка (bin_numb)
        вернуть d, bin_numb
    защита bin2hex (b):
        # бин -> шестнадцатеричный
        ч = шестнадцатеричный (б)
        вернуть ч
    определение hex2dec (ч):
        # шестнадцатеричный -> десятичный
        д = интервал (ч)
        вернуть д
    определение hex2bin(h):
        # шестнадцатеричный -> бин
        б = бин (ч)
        вернуть б
    ## ПРОВЕРОЧНЫЕ НОМЕРА
    число_дек = 99
    numb_bin = 0b0111
    numb_hex = 0xFF
    ## РАСЧЕТЫ
    res_dec2bin = dec2bin(numb_dec)
    res_dec2hex = dec2hex (numb_dec)
    res_bin2dec,bin_numb = bin2dec(numb_bin)
    res_bin2hex = bin2hex (numb_bin)
    res_hex2dec = hex2dec (numb_hex)
    res_hex2bin = hex2bin(numb_hex)
    ## ПЕЧАТЬ
    print('------- DECIMAL to BIN / HEX -------\n')
    print('десятичный:',numb_dec,'\nbin: ',res_dec2bin,'\nhex: ',res_dec2hex,'\n')
    print('------- BINARY to DEC / HEX -------\n')
    print('binary: ',bin_numb,'\ndec: ',numb_bin,'\nhex: ',res_bin2hex,'\n')
    print('----- HEXADECIMAL to BIN / HEX -----\n')
    print('hexadec:',hex(numb_hex),'\nbin: ',res_hex2bin,'\ndec: ',res_hex2dec,'\n')
     

    Для вычисления двоичных чисел:

     print("Двоичный файл {0:>08b}". format(16))
     

    Чтобы вычислить шестнадцатеричное десятичное число :

     print("Шестнадцатеричный десятичный код равен {0:>0x}".format(15))
     

    Вычислить все бинарники нет до 16 ::

     для i в диапазоне (17):
       print("{0:>2}: двоичный файл {0:>08b}".format(i))
     

    Для вычисления шестнадцатеричного числа нет до 17

     для i в диапазоне (17):
        print("{0:>2}: шестнадцатеричное десятичное число равно {0:>0x}".format(i))
    ##так как 2 цифры достаточно для шестнадцатеричной записи числа
     
     попробуйте:
        пока верно:
            р = ""
            а = ввод ()
            в то время как != 0:
                л = а% 2
                б = а - л
                а = б / 2
                р = ул(л) + р
            печать (р)
    кроме:
        print ("написать 1 число")
     

    1

    Я нашел метод, использующий матричные операции для преобразования десятичного числа в двоичное.

     импортировать numpy как np
    E_mat = np.tile (E, [1, M])
    M_order = pow(2,(M-1-np.array(диапазон(M)))).T
    bindata = np.remainder(np.floor(E_mat/M_order).astype(np.int),2)
     

    E — входные десятичные данные, M — двоичные порядки. bindata — это выходные двоичные данные в формате двоичной матрицы 1 на M.

    python - Как преобразовать целое число в строку по любой базе?

    Приведенный ниже код Python преобразует целое число Python в строку в произвольном основании (от 2 до бесконечности) и работает в обоих направлениях. Таким образом, все созданные строки можно преобразовать обратно в целые числа Python, предоставив строку для N вместо целого числа. Код намеренно работает только с положительными числами (на мой взгляд, есть некоторые проблемы с отрицательными значениями и их битовыми представлениями, в которые я не хочу вникать). Просто выберите из этого кода то, что вам нужно, хотите или нравится, или просто получайте удовольствие, изучая доступные варианты. Многое здесь только для того, чтобы задокументировать все различные доступные подходы (например, Oneliner кажется не быстрым, даже если обещают).

    Мне нравится предложенный Сальвадором Дали формат бесконечно больших оснований. Хорошее предложение, которое оптически хорошо работает даже для простых двоичных битовых представлений. Обратите внимание, что параметр заполнения width=x в случае строки с форматированием InfiniteBase=True применяется к цифрам, а не ко всему числу. Кажется, что код, обрабатывающий формат чисел в формате InfiniteBase, работает даже немного быстрее, чем другие варианты - еще одна причина для его использования?

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

     определение inumToStr( N, основание = 2, ширина = 1, бесконечное основание = False, \
        useNumpy = False, useRecursion = False, useOneliner = False, \
        useGmpy=False, подробный=True):
        ''' Только положительные числа, но работает в ОБОИХ направлениях. 
        Для строк в наборе обозначений InfiniteBase для оснований <= 62
        бесконечная база = Истина. Примеры использования:
        inumToStr( 17, 2, 1, 1) # [1,0,0,0,1]
        inumToStr( 17, 3, 5) # 00122
        inumToStr(245, 16, 4) # 00F5
        inumToStr(245, 36, 4,0,1) # 006T
        inumToStr(245245245245,36,10,0,1) # 0034NWOQBH
        inumToStr(245245245245,62) # 4JhA3Th
            245245245245 == int(gmpy2.mpz('4JhA3Th',62))
        inumToStr(245245245245,99,2) # [25,78, 5,23,70,44]
        -------------------------------------------------- --
        inumToStr('[1,0,0,0,1]',2, InfiniteBase=True) # 17
        inumToStr('[25,78, 5,23,70,44]', 99) # 245245245245
        inumToStr('0034NWOQBH', 36) # 245245245245
        inumToStr('4JhA3Th', 62) # 245245245245
        -------------------------------------------------- --
        --- Тайминги для N = 2**4096, base=36:
                                          стандарт: 0,0023
                                          бесконечный: 0,0017
                                          число: 0,1277
                                          рекурсия; 0,0022
                                          однострочник: 0,0146
                    Для N = 2**8192:
                                          стандарт: 0,0075
                                          бесконечно: 0,0053
                                          число: 0,1369
        Максимум.  превышена глубина рекурсии: recursio/oneliner
        '''
        показать = распечатать
        если type(N) равно str и (infiniteBase равно True или base > 62):
            лстН = оценка (N)
            if verbose: show('преобразование нестандартной строки битов InfiniteBase в целое число Python')
            возвращаемая сумма([ item*base**pow for pow, item in enumerate(lstN[::-1]) ] )
        если тип (N) равен str и base <= 36:
            если подробно: show('base <= 36. Возвращает Python int(N, base)')
            вернуть целое число (N, основание)
        если тип (N) равен str и base <= 62:
            если использоватьGmpy:
                если подробно: show(' base <= 62, useGmpy=True, возвращает int(gmpy2.mpz(N,base))')
                вернуть целое число (gmpy2.mpz (N, база))
            еще:
                если подробно: show(' base <= 62, useGmpy=False, возвращаемое значение автоматически вычисляется)')
                лстстрофдигитс="0123456789"+\
                    "abcdefghijklmnopqrstuvwxyz".upper() + \
                    "АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЫЭЮЯ"
                dictCharToPow = {}
                для индекса, char в перечислении (lstStrOfDigits):
                    dictCharToPow. update({символ: индекс})
                возвращаемая сумма ( dictCharToPow [item] * base ** pow для pow, элемент в перечислении (N [:: - 1])) )
            #:если
        #:если
            
        если использовать Oneliner и базу <= 36:
            если подробно: show(' base <= 36, useOneliner=True, запуск кода Oneliner')
            д = "0123456789АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЫЭЮЯ"
            baseit = lambda a=N, b=base: (не a) и d[0] или \
            baseit(a-a%b,b*base)+d[a%b%(base-1) или (a%b) и (base-1)]
            вернуть baseit () .rjust (ширина, d [0]) [1:]
        если useRecursion и база <= 36:
            если подробно: show(' base <= 36, useRecursion=True, работает алгоритм рекурсии')
            BS="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
            определение_базы (n, b):
                вернуть "0", если не n иначе to_base(n//b, b).lstrip("0") + BS[n%b]
            вернуться к_базе (N, база).rjust (ширина, BS [0])
            
        если база > 62 или бесконечная база:
            если многословно: показать('база > 62 или InfiniteBase=True, возвращает нестандартную строку цифр')
            # Разрешает произвольную большую базу с 'width=. ..'
            # применяется к каждой цифре (полезно также для битов)
            N, цифра = divmod(N, основание)
            strN = str(цифра).rjust(ширина, ' ')+']'
            в то время как Н:
                N, цифра = divmod(N, основание)
                strN = str(цифра).rjust(ширина, ' ') + ',' + strN
            вернуть '[' + строкаN
        #:если
        
        если база == 2:
            если многословно: показать ("база = 2, возвращает Python str(f'{N:0{ширина}b}')")
            вернуть строку (f '{N: 0 {ширина} b}')
        если база == 8:
            если многословно: show(" base = 8, возвращает Python str(f'{N:0{width}o}')")
            вернуть строку (f '{N: 0 {ширина} o}')
        если база == 16:
            если многословно: show(" base = 16, возвращает Python str(f'{N:0{width}X}')")
            вернуть строку (f '{N: 0 {ширина} X}')
        если база <= 36:
            если использоватьNumpy:
                если подробно: показать («база <= 36, useNumpy = True, возвращает np.base_repr (N, база)»)
                импортировать numpy как np
                strN = np.