python построить словарь {0: [0, 0, 0], 1: [0, 0, 1], 2: [0, 0, 2], 3: [0, 0, 3], ..., 999: [9, 9, 9]}

Question

Я должен построить словарь с использованием переменных base=10 и digits=set(range(10)) и должен написать понимание, которое отображает каждое целое число от 0 до 999 в список из трех цифр, который представляет это целое число в базе 10 То есть значение должно быть

{0: [0, 0, 0], 1: [0, 0, 1], 2: [0, 0, 2], 3: [0, 0, 3], ...,10: [0, 1, 0], 11: [0, 1, 1], 12: [0, 1, 2], ...,999: [9, 9, 9]} 

Я застрял.

Я пытался что-то вроде

{q:[x,y,z] for q in list[range(1000)] for x in digits for y in digits for z in digits} 

, но индекс д должен быть x * base**2 + y * base**1 + z * base**0

это не правильный способ мышления, любая идея?

Answer 1

alphabet = range(10) 
base = 10 
dict((x*base**2+y*base+z,(x,y,z)) for x in alphabet 
            for y in alphabet 
            for z in alphabet) 

является то, что вы хотите ... я думаю

alphabet = range(2) 
base = 2 
dict((x*base**2+y*base+z,(x,y,z)) for x in alphabet 
            for y in alphabet 
            for z in alphabet) 

генерирует

{0: (0, 0, 0), 1: (0, 0, 1), 2: (0, 1, 0), 3: (0, 1, 1), 4: (1, 0, 0), 5: (1, 0, 1), 6: (1, 1, 0), 7: (1, 1, 1)} 

Answer 2

основной алгоритм я бы использовал бы

for(1->1000) 
    { 
    if(x < 10) 
     insert(x,[0,0,x])) 
    else if(x<100) 
     insert(x,[0,x/10,x%10])) 
    else 
     insert(x,[x/100,x/10,x%10])) 
    } 

Answer 3

Вы можете использовать divmod для разложения каждого номера:

d = {} 
for i in xrange(base**3): 
    a,b = divmod(i, base**2) 
    b,c = divmod(b, base) 
    d[i] = [a,b,c] 

В качестве альтернативы, конструктивное решение с использованием редко используемый reduce функции:

from itertools import product 
d = {reduce(lambda x,y: base*x+y, p):list(p) for p in product(xrange(base), repeat=3)} 

Answer 4

f= lambda x : [int(x/100),int(x/10)%10,x%10] 
k={} 
for p in xrange(0,1000): 
    k[p]=f(p) 

или даже:

d = {x: [int(x/100),int(x/10)%10,x%10] for x in xrange(0,1000)} 

Answer 5

Я хотел бы использовать itertools. Например

dict((i, tup) for i, tup in enumerate(itertools.product(range(10), repeat=3))) 

Если вы действительно требуют каждое значение будет список, вы можете добавить (i, list(tup)) выше.

Функция product вычисляет декартово произведение, эквивалентное вложенному циклу, согласно documentation. Например

In [34]: list(itertools.product(range(3), repeat=3)) 
Out[34]: 
[(0, 0, 0), 
(0, 0, 1), 
(0, 0, 2), 
(0, 1, 0), 
(0, 1, 1), 
(0, 1, 2), 
(0, 2, 0), 
(0, 2, 1), 
(0, 2, 2), 
(1, 0, 0), 
(1, 0, 1), 
(1, 0, 2), 
(1, 1, 0), 
(1, 1, 1), 
(1, 1, 2), 
(1, 2, 0), 
(1, 2, 1), 
(1, 2, 2), 
(2, 0, 0), 
(2, 0, 1), 
(2, 0, 2), 
(2, 1, 0), 
(2, 1, 1), 
(2, 1, 2), 
(2, 2, 0), 
(2, 2, 1), 
(2, 2, 2)] 

product(range(3), repeat=3) эквивалентно product(range(3), range(3), range(3)). Функция product принимает *iterables, поэтому приведенный выше синтаксис действителен.

Answer 6

Есть несколько неправильных вещей в вашем коде:

• используется list, который является типом, как массив. Может, вы хотели написать list(range(1000))? Просто используйте диапазон (1000).
• Ваш for q in range(1000) слишком много: у вас есть полный цикл 1000 * 10 * 10 * 10 вместо 10 * 10 * 10.

Без изменения слишком много кода, вот что вы должны написать (с помощью кода для вычислений д):

{(x*base**2 + y*base**1 + z*base**0):[x,y,z] for q in list[range(1000)] for x in digits for y in digits for z in digits} 

Answer 7

Вот хороший один лайнер:

result = dict((n,['0']*(3-len(str(n))) + list(str(n))) for n in xrange(1000)) 

Answer 8

Что об этом:

{x:map(int,str(x).rjust(3,'0')) for x in xrange(1000)} 

Answer 9

Это позволит вам изменить базу :

import numpy as np 
base = 10 
nmax = 10 
fill = len(np.base_repr(nmax, base=base)) 
d = {q:map(int, list(np.base_repr(q, base=base).zfill(fill))) for q in range(nmax+1)} 
print(d) 

str.zfill покидающий крестовину строка результата из numpy.base_repr с обнуляет до заданной длины (заполняется в моем случае).

base=10, nmax=10 (вы бы хотели nmax=999).

{0: [0, 0], 1: [0, 1], 2: [0, 2], 3: [0, 3], 4: [0, 4], 5: [0, 5], 6: [0, 6], 7: [0, 7], 8: [0, 8], 9: [0, 9], 10: [1, 0]} 

для base=2, nmax=10:

{0: [0, 0, 0, 0], 1: [0, 0, 0, 1], 2: [0, 0, 1, 0], 3: [0, 0, 1, 1], 4: [0, 1, 0, 0], 5: [0, 1, 0, 1], 6: [0, 1, 1, 0], 7: [0, 1, 1, 1], 8: [1, 0, 0, 0], 9: [1, 0, 0, 1], 10: [1, 0, 1, 0]} 

Answer 10

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

база = 10

цифры = комплект (диапазон (10))

dict = {(x * base ** 2 + y * base ** 1 + z * base ** 0): [x, y, z] для x в цифрах для y в цифрах для z в цифрах}