遍歷一個列表，並使用以前的元素

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