Convertissez d'abord l'entier en chaîne de caractères, puis utilisez map pour appliquer int sur elle:

>>> num = 132
>>> map(int, str(num))    #note, This will return a map object in python 3.
[1, 3, 2]

ou en utilisant une liste de compréhension:

>>> [int(x) for x in str(num)]
[1, 3, 2]

la voie la plus courte et la meilleure est déjà répondu, mais la première chose à laquelle j'ai pensé était la voie mathématique, donc ici il est:

def intlist(n):
    q = n
    ret = []
    while q != 0:
        q, r = divmod(q, 10) # Divide by 10, see the remainder
        ret.insert(0, r) # The remainder is the first to the right digit
    return ret

print intlist(3)
print '-'
print intlist(10)
print '--'
print intlist(137)

c'est juste une autre approche intéressante, vous ne devez certainement pas utiliser une telle chose dans les cas d'utilisation pratique.

utiliser list sur un nombre converti en chaîne:

In [1]: list(str(123))
Out[2]: ['1', '2', '3']

n = int(raw_input("n= "))

def int_to_list(n):
    l = []
    while n != 0:
        l = [n % 10] + l
        n = n // 10
    return l

print int_to_list(n)

il y a déjà de grandes méthodes déjà mentionnées sur cette page, cependant elle semble un peu obscure quant à laquelle utiliser. J'ai donc ajouté quelques mesures pour que vous puissiez plus facilement décider par vous-même:

---

un grand nombre a été utilisé (pour les frais généraux) 1111111111111122222222222222222333333333333333333333

utilisant map(int, str(num)) :

import timeit

def method():
    num = 1111111111111122222222222222222333333333333333333333
    return map(int, str(num))

print(timeit.timeit("method()", setup="from __main__ import method", number=10000)

sortie: 0.018631496999999997

utilisant la compréhension de liste:

importer timeit

def method():
    num = 1111111111111122222222222222222333333333333333333333
    return [int(x) for x in str(num)]

print(timeit.timeit("method()", setup="from __main__ import method", number=10000))

sortie: 0.28403817900000006

Code tiré de this answer

Les résultats montrent que la première méthode impliquant intégré méthodes est beaucoup plus rapide que la compréhension de liste.

La "méthode mathématique":

import timeit

def method():
    q = 1111111111111122222222222222222333333333333333333333
    ret = []
    while q != 0:
        q, r = divmod(q, 10) # Divide by 10, see the remainder
        ret.insert(0, r) # The remainder is the first to the right digit
    return ret

print(timeit.timeit("method()", setup="from __main__ import method", number=10000))

sortie: 0.38133582499999996

Code tiré de this answer

la méthode list(str(123)) (ne fournit pas la bonne sortie):

import timeit

def method():
    return list(str(1111111111111122222222222222222333333333333333333333))

print(timeit.timeit("method()", setup="from __main__ import method", number=10000))

sortie: 0.028560138000000013

Code tiré de this answer

la réponse de Duberly González Molinari:

import timeit

def method():
    n = 1111111111111122222222222222222333333333333333333333
    l = []
    while n != 0:
        l = [n % 10] + l
        n = n // 10
    return l

print(timeit.timeit("method()", setup="from __main__ import method", number=10000))

sortie: 0.37039988200000007

Code repris de cette réponse

remarques:

dans tous les cas map(int, str(num)) est la méthode la plus rapide (et est donc probablement la meilleure méthode à utiliser). La compréhension de liste est la deuxième plus rapide (mais la méthode utilisant map(int, str(num)) est probablement la plus souhaitable des deux.

ceux qui réinventent la roue sont intéressants mais sont probablement pas si désirable en usage réel.

vous pouvez utiliser:

d'abord convertir la valeur dans une chaîne de caractères pour itérer, eux chaque valeur peut être convertie en un entier value = 12345

l = [ int(item) for item in str(value) ]

num = list(str(100))
index = len(num)
while index > 0:
    index -= 1
    num[index] = int(num[index])
print(num)

il imprime [1, 0, 0] objet.