Как интовое число записать в список python

преобразование числа в список [закрыт]

Закрыт. Этот вопрос необходимо уточнить или дополнить подробностями. Ответы на него в данный момент не принимаются.

Хотите улучшить этот вопрос? Добавьте больше подробностей и уточните проблему, отредактировав это сообщение.

Закрыт 5 лет назад .

b = 456; c = str(b); x = list(c); z = str(x); a = int(z); 

почему невозможно преобразовать int к типу list и обратно в int ? логикеа такая, с int превращает в str, с str в list, а потов в обратном направлении

Отслеживать
задан 24 ноя 2017 в 13:24
117 1 1 золотой знак 1 1 серебряный знак 11 11 бронзовых знаков
а как вы представляете себе преобразование списка в число? Возьмите 0 элемент например.
24 ноя 2017 в 13:27
Думаю для всех очевидно что 0 должен быть пустым списком, а 2 должно быть [1, 0]. 🙂
24 ноя 2017 в 13:28
@Arnial А 3 должно быть [2, 1, 0] или [1, 1]?
24 ноя 2017 в 13:48
что вы ожидаете получить? Приведите явный пример и словами детально опишите
24 ноя 2017 в 13:54

Pero, всё равно непонятно. Вы хотите получить список из цифр числа, записанного в десятичном представлении?

28 ноя 2017 в 8:36

2 ответа 2

Сортировка: Сброс на вариант по умолчанию

z = str(x); 

Стоит заменить на

z = ''.join(x) 

И что мешает самому написать преобразование?

x = 1234 result = [] while x > 0: result.append(x % 10) x //= 10 result.reverse() print(result) # [1, 2, 3, 4] num = 0 for i, v in enumerate(reversed(result)): num += v * 10 ** i print(num) # 1234 

Отслеживать
ответ дан 24 ноя 2017 в 13:51
6,121 3 3 золотых знака 19 19 серебряных знаков 38 38 бронзовых знаков

Вы вероятно хотите, чтобы

list(456) == [4, 5, 6] 

int([4, 5, 6]) == 456 

Но функция list() работает только с объектами, которые имеют интерфейс iterable , например с множествами , строками , итераторами и генераторами — просто со всем, что может использоваться в цикле for перед двоеточием:

for i in range(10): for i in (2, 3, 5): for i in "abcd": 

Теоретически бы могло быть по меньшей мере

list(любый_объект) == [любый_объект] 

но ни это не так, потому что бы могли возникнуть проблемы:

i = 456 list(i) # [456] или [i] ? [456] всегда то самое, но [i] меняется с i 

С другой стороны, функция int() не может работать со списками — что разумное можно ожидать например от

int(["abc", [3.7, i, (5, 2)], True, (max, 1)]) # . 

Целые числа int в Python

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

Целые числа поддерживают следующие операции:

• арифметические операции;
• побитовые операции;
• операции сравнения.

Тип int в языке Python представлен классом int() , он позволяет:

• преобразовать строку в целое число типа int с учетом указанного основания системы счисления (десятичные по основанию 10, шестнадцатеричные по основанию 16, восьмеричные по основанию 8 и двоичные по основанию 2).
• преобразовать вещественные числа типа float в тип int (отбрасывает дробную часть).
• преобразовать восьмеричные, шестнадцатеричные и двоичные литералы целых чисел в тип int

Класс int() не сможет преобразовать к типу int :

• числа типа complex , т.к. нет однозначного способа преобразования данного типа чисел.
• строку с записью числа с плавающей точкой (вещественного числа)

Примеры преобразования объектов к типу int :

# Преобразование строки с записью # целого числа в десятичной форме к типу int >>> int(' -3 ', base=10) # 3 # При преобразовании десятичных литералов, # записанных в строки, основание можно опускать >>> int(' +5 ') # 5 >>> int(' -15_125') # -15125 # Преобразование типа float в тип `int` >>> int(3.23) # 3 >>> int(1.) # 1 >>> int(3.14e-10) # 0 # Восьмеричные литералы и строки с ними - в тип int >>> int(0o177) # 127 >>> int(' 0o177 ', base=8) # 127 # Шестнадцатеричные литералы и строки с ними - в тип int >>> int(0x9ff) # 2559 >>> int(' 0x9ff ', base=16) # 2559 # Двоичные литералы и строки с ними - в тип int >>> int(0b101010) # 42 >>> int('0b101010', base=2) # 42 

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

>>> 100_000, 0x_FF_FF, 0o7_777 # (100000, 65535, 4095) 

Целые числа еще могут записываться как, шестнадцатеричные (по основанию 16), восьмеричные (по основанию 8) и двоичные (по основанию 2).

• Шестнадцатеричные литералы начинаются с комбинации символов 0x или 0X, вслед за которыми следуют шестнадцатеричные цифры (0-9 и A-F). Шестнадцатеричные цифры могут вводиться как в нижнем, так и в верхнем регистре.
• Литералы восьмеричных чисел начинаются с комбинации символов 0o или 0O (ноль и следующий за ним символ «o» в верхнем или нижнем регистре), вслед за которыми следуют восьмеричные цифры (0-7).
• Двоичные литералы начинаются с комбинации символов 0b или 0B, вслед за которыми следуют двоичные цифры (0 – 1)

Все эти литералы создают объекты целых чисел, они являются всего лишь альтернативными формами записи значений. Для преобразования целого числа в строку с представлением в любой из трех систем счисления можно использовать встроенные функции hex() , oct() и bin()

Методы типа int :

int.bit_length() :

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

>>> n = -37 >>> bin(n) # '-0b100101' >>> n.bit_length() # 6 

def bit_length(self): # двоичное представление: bin(-37) => '- 0b100101' s = bin(self) # удалить начальные нули и знак минус s = s.lstrip('-0b') # len('100101') => 6 return len(s) 

int.bit_count() :

Добавлен в Python 3.10. Возвращает количество единиц в двоичном представлении абсолютного значения целого числа.

>>> n = 19 >>> bin(n) '0b10011' >>> n.bit_count() # 3 >>> (-n).bit_count() # 3 

def bit_count(self): return bin(self).count("1") 

Новое в Python 3.10.

int.to_bytes(length, byteorder, *, signed=False) :

Возвращает массив байтов, представляющих целое число. Параметры length , byteorder являются обязательными:
— length задает необходимое количество байтов,
— byteorder определяет в каком порядке возвращать байты и имеют значения ‘big’ — от старшего к младшему, ‘little’ — от младшего к старшему.
— signed позволяет установить использование дополнительного кода для представления целого числа. Если signed=False и задано отрицательное целое число, то бросается OverflowError .

>>> (1024).to_bytes(2, byteorder='big') # b'\x04\x00' >>> (1024).to_bytes(10, byteorder='big') # b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> (-1024).to_bytes(10, byteorder='big', signed=True) # b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little') # b'\xe8\x03' 

Если указанных байтов недостаточно для представления числа, то будет вызвано исключение OverflowError. Что бы узнать порядок байтов который использует платформа используйте sys.byteorder .

int.from_bytes(bytes, byteorder, *, signed=False) :

Возвращает целое число, которое соответствует указанному массиву байтов.
Параметры bytes и byteorder являются обязательными.
— bytes должен быть байто-подобным объектом (строки байтов, массивы байтов, array.array и т.д.)
— byteorder определяет в каком порядке возвращать байты и имеют значения ‘big’ — от старшего к младшему, ‘little’ — от младшего к таршему.
— signed позволяет установить использование дополнительного кода для представления целого числа. Если signed=False и задано отрицательное елое число, то бросается OverflowError .

>>> int.from_bytes(b'\x00\x7f', byteorder = 'big') # 127 >>> int.from_bytes(b'\x00\x7f', byteorder = 'little') # 32512 >>> int.from_bytes(b'\xff\x81', 'big', signed = True) # -127 >>> int.from_bytes([1, 0], 'big') # можно указать "массив" байтов # 256 >>> int.from_bytes([255, 255], 'big') # 65535 

• КРАТКИЙ ОБЗОР МАТЕРИАЛА.
• Утиная типизация ‘Duck Typing’
• Что такое вызываемый объект callable?
• Как проверить тип переменной/объекта
• Логический тип данных bool
• Целые числа int
• Ограничение длины преобразования целочисленной строки
• Вещественные числа float
• Комплексные числа complex
• Типы последовательностей
• Список list
• Кортеж tuple
• Диапазон range
• Текстовые строки str
• Словарь dict
• Множество set и frozenset
• Итератор Iterator, протокол итератора
• Генератор generator и выражение yield
• Контекстный менеджер with
• Байтовые строки bytes
• Байтовый массив bytearray
• Тип memoryview, буфер обмена
• Файловый объект file object
• Универсальный псевдоним GenericAlias
• Объект объединения Union

Функция int

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

Если вызвать функцию int() без аргументов, она вернет 0.

>>> int() 0

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

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

Если передать функции целое число, то она вернет его же. Если передать вещественное число, то оно будет округлено до целого в сторону нуля (т. е. дробная часть будет отброшена).

>>> int(87) 87 >>> int(-103) -103 >>> int(234.879) 234 >>> int(-0.3) 0 >>> int(-0.9) 0

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

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

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

>>> int(float('15.76')) 15

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

>>> int('12', 8) 10 >>> int('13h', 20) 477 >>> int('111001', 2) 57

Основание системы счисления не должно превышать 36.

>>> int('w0y', 36) 41506 >>> int('w0y', 37) Traceback (most recent call last): File "", line 1, in ValueError: int() base must be >= 2 and 

>>> int(0b11) 3 >>> int(0o10) 8 >>> int(0xA5) 165 >>> int('0b11') Traceback (most recent call last): File "", line 1, in int('0b11') ValueError: invalid literal for int() with base 10: '0b11' >>> int('0b11', 2) 3

>>> class A: . a = 'H' . def __int__(self): . return ord(self.a) . >>> obj = A() >>> int(obj) 72 >>> obj.a = '!' >>> int(obj) 33 

int(x) int(x, base=10) 

a = int(3.5) b = int(12.9) c = int('3') d = int(' -3 ') f = int('0b11', 2) y = int('0o12', base=8) z = int('0xa', base=16) print(a, b, c, d, f, y, z) # Вывод 3, 12, 3, -3, 10, 10, 10