遍历一个列表，并使用以前的元素

Question

我有一个包含十进制数的清单，但在这个例子中，我使用整数：

my_list = [40, 60, 100, 240, ...] 

我想打印列表中的每个元素以相反的顺序事后我要打印第二行，其中的每一个值除以2，然后在前面的INT由3 devided等第三行...

输出应该是：

240  120  60  36 
120  60  30  18 #previous number divided by 2 
40  20  10  6 #previous number divided by 3 
...  ...  ... ... #previous number divided by 4 ... 

我的解决方案丑陋：我可以创建一个切片并反转该列表，并为循环创建n并将结果附加到新列表中。但是一定有更好的办法。你会怎么做？

Answer 1

我会写一个发电机，产生名单依次为：

def divider(lst,n): 
    lst = [float(x) for x in lst[::-1]] 
    for i in range(1,n+1): 
     lst = [x/i for x in lst] 
     yield lst 

是比较合适的。如果我们想让它会更有效，我们可以分解出的第一次迭代（除以1），并分别获得它：

def divider(lst,n): 
    lst = [float(x) for x in reversed(lst)] 
    yield lst 
    for i in range(2,n+1): 
     lst = [x/i for x in lst] 
     yield lst 

*请注意，在这种情况下没有一大堆之间差异lst[::-1]和reversed(lst)。前者通常要快一点，但后者的内存效率要高一些。根据您的约束选择。

---

演示：

>>> def divider(lst,n): 
...  lst = [float(x) for x in reversed(lst)] 
...  yield lst 
...  for i in range(2,n+1): 
...   lst = [x/i for x in lst] 
...   yield lst 
... 
>>> for lst in divider([40, 60, 100, 240],3): 
...  print lst 
... 
[240.0, 100.0, 60.0, 40.0] 
[120.0, 50.0, 30.0, 20.0] 
[40.0, 16.666666666666668, 10.0, 6.666666666666667] 

Answer 2

my_list = [40, 60, 100, 240] 
def dostuff(l,limit): 
    print('\t'.join(map(str,reversed(l)))) 
    print('\n'.join([ '\t'.join(map(str,[v/float(i) for v in reversed(my_list)])) for i in range(2,limit+1)])) 
dostuff(my_list,20) 

产地：

240 100 60 40 
120.0 50.0 30.0 20.0 
80.0 33.333333333333336 20.0 13.333333333333334 
60.0 25.0 15.0 10.0 
48.0 20.0 12.0 8.0 
40.0 16.666666666666668 10.0 6.666666666666667 
34.285714285714285 14.285714285714286 8.571428571428571 5.714285714285714 
30.0 12.5 7.5 5.0 
26.666666666666668 11.11111111111111 6.666666666666667 4.444444444444445 
24.0 10.0 6.0 4.0 
21.818181818181817 9.090909090909092 5.454545454545454 3.6363636363636362 
20.0 8.333333333333334 5.0 3.3333333333333335 
18.46153846153846 7.6923076923076925 4.615384615384615 3.076923076923077 
17.142857142857142 7.142857142857143 4.285714285714286 2.857142857142857 
16.0 6.666666666666667 4.0 2.6666666666666665 
15.0 6.25 3.75 2.5 
14.117647058823529 5.882352941176471 3.5294117647058822 2.3529411764705883 
13.333333333333334 5.555555555555555 3.3333333333333335 2.2222222222222223 
12.631578947368421 5.2631578947368425 3.1578947368421053 2.1052631578947367 
12.0 5.0 3.0 2.0 

Answer 3

要打印的柱状你想要的输出，使用format strings。您可能需要调整此得到你想要的比对和精确的实际数据：

def print_list(L): 
    print ' '.join('{:>3d}'.format(i) for i in L) 

通常做的，我们可以使用递归函数的划分，但我们也可以使用一个简单的循环，每次迭代产生下次上工作的列表：

my_list = [40, 60, 100, 240, 36, 60, 120, 240] 

maxdiv = 20 
baselist = list(reversed(my_list)) 
for div in range(1, maxdiv+1): 
    baselist = [i/div for i in baselist] 
    print_list(baselist) 

输出：

240 120  60  36 240 100  60  40 
120  60  30  18 120  50  30  20 
40  20  10  6  40  16  10  6 
10  5  2  1  10  4  2  1 
    2  1  0  0  2  0  0  0 
    0  0  0  0  0  0  0  0 
    0  0  0  0  0  0  0  0 
    0  0  0  0  0  0  0  0 
... 

Answer 4

max_n = 3 
vals = [40, 60, 100, 240] 
grid = [list(reversed(vals))] 

for n in xrange(2, max_n + 1): 
    grid.append([v/n for v in grid[-1]]) 

for g in grid: 
    print g 

# Output 
[240, 100, 60, 40] 
[120.0, 50.0, 30.0, 20.0] 
[40.0, 16.666666666666668, 10.0, 6.666666666666667] 

Answer 5

new_list = my_list[::-1] #reverse the list 
print '\t'.join(map(str, new_list)) 
for _counter in range(2, 21): #count from 2 to 20 
    for _index in range(len(new_list)): # iterate the whole list 
     new_list[_index] = new_list[_index]/_counter 
     print '\t'.join(map(str, new_list)) 

这将产生像（我用float代替int）输出：

240.0  100.0   60.0   40.0 
120.0  50.0   30.0   20.0 
40.0  16.6666666667 10.0   6.66666666667 
10.0  4.16666666667 2.5   1.66666666667 
2.0   0.833333333333 0.5   0.333333333333