Diviser un entier en Python?

Mon entrée entière est supposée 12345, je veux le diviser et le mettre dans un tableau comme 1, 2, 3, 4, 5. Comment vais-je pouvoir le faire?

>>> [int(i) for i in str(12345)]

[1, 2, 3, 4, 5]

retourne le tableau sous forme de chaîne

>>> list(str(12345))
['1', '2', '3', '4', '5']

retourne le tableau sous forme d'entier

>>> map(int,str(12345))
[1, 2, 3, 4, 5]

[int(i) for i in str(number)]

ou, si vous ne souhaitez pas utiliser de compréhension de liste ou si vous souhaitez utiliser une base différente de 10

from __future__ import division # for compatibility of // between Python 2 and 3
def digits(number, base=10):
    assert number >= 0
    if number == 0:
        return [0]
    l = []
    while number > 0:
        l.append(number % base)
        number = number // base
    return l

Je préfère ne pas transformer un entier en chaîne, alors voici la fonction que j'utilise pour cela:

def digitize(n, base=10):
    if n == 0:
        yield 0
    while n:
        n, d = divmod(n, base)
        yield d

Exemples:

tuple(digitize(123456789)) == (9, 8, 7, 6, 5, 4, 3, 2, 1)
tuple(digitize(0b1101110, 2)) == (0, 1, 1, 1, 0, 1, 1)
tuple(digitize(0x123456789ABCDEF, 16)) == (15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)

Comme vous pouvez le voir, cela donnera des chiffres de droite à gauche. Si vous souhaitez les chiffres de gauche à droite, vous devrez en créer une séquence, puis l'inverser:

reversed(tuple(digitize(x)))

Vous pouvez également utiliser cette fonction pour la conversion de base lorsque vous divisez l'entier. L'exemple suivant divise un nombre hexadécimal en nibbles binaires sous forme de tuples:

import itertools as it
tuple(it.zip_longest(*[digitize(0x123456789ABCDEF, 2)]*4, fillvalue=0)) == ((1, 1, 1, 1), (0, 1, 1, 1), (1, 0, 1, 1), (0, 0, 1, 1), (1, 1, 0, 1), (0, 1, 0, 1), (1, 0, 0, 1), (0, 0, 0, 1), (1, 1, 1, 0), (0, 1, 1, 0), (1, 0, 1, 0), (0, 0, 1, 0), (1, 1, 0, 0), (0, 1, 0, 0), (1, 0, 0, 0))

Notez que cette méthode ne gère pas les décimales, mais pourrait être adaptée à.

comme @nd dit mais en utilisant la fonction intégrée de int pour convertir en une base différente

>>> [ int(i,16) for i in '0123456789ABCDEF' ]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

>>> [int(i,2) for i in "100 010 110 111".split()]
[4, 2, 6, 7]

Je ne sais pas quel est l'objectif final, mais jetez un œil également à l'intérieur du module décimal de python pour faire des choses comme

>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal('5.85987')

Bien que list(map(int, str(x)))l'approche pythonique soit, vous pouvez formuler une logique pour dériver des chiffres sans aucune conversion de type:

from math import log10

def digitize(x):
    n = int(log10(x))
    for i in range(n, -1, -1):
        factor = 10**i
        k = x // factor
        yield k
        x -= k * factor

res = list(digitize(5243))

[5, 2, 4, 3]

L' un des avantages d'un générateur est que vous pouvez alimenter en toute transparence à set, tuple, next, etc, sans aucune logique supplémentaire.

Diviser un seul nombre en ses chiffres (comme répondu par tous)

>>> [int(i) for i in str(12345)]
[1, 2, 3, 4, 5]

Mais, pour obtenir des chiffres à partir d'une liste de nombres:

>>> [int(d) for d in ''.join(str(x) for x in [12, 34, 5])]
[1, 2, 3, 4, 5]

Je voudrais donc savoir, si nous pouvons faire ce qui précède, plus efficacement.

Peut-être join+ split:

>>> a=12345
>>> list(map(int,' '.join(str(a)).split()))
[1, 2, 3, 4, 5]
>>> [int(i) for i in ' '.join(str(a)).split()]
[1, 2, 3, 4, 5]
>>> 

str.join+ str.splitest votre ami, nous utilisons également mapou list comprehensionpour obtenir une liste, (diviser ce que nous rejoignons :-)).

Une autre solution qui n'implique pas la conversion vers / à partir de chaînes:

from math import log10

def decompose(n):
    if n == 0:
        return [0]
    b = int(log10(n)) + 1
    return [(n // (10 ** i)) % 10 for i in reversed(range(b))]

Les chaînes sont tout aussi itérables que les tableaux, alors convertissez-les simplement en chaîne:

str(12345)

selon les réponses précédentes, les chaînes sont itérables, donc si vous avez besoin d'une liste de vos chiffres, vous pouvez l'ajouter un par un en utilisant:

digits = []
digits += str(12345)