首页 文章

在Python中以相反的顺序遍历列表

提问于
浏览
533

所以我可以从 len(collection) 开始到 collection[0] 结束 .

编辑:对不起,我忘了提到我也希望能够访问循环索引 .

24 回答

  • 1

    在python 3中实现 reverse(enumerate(collection)) 的一种富有表现力的方法:

    zip(reversed(range(len(collection))), reversed(collection))
    

    在python 2中:

    izip(reversed(xrange(len(collection))), reversed(collection))
    

    我不知道为什么我们没有这方面的简写,例如:

    def reversed_enumerate(collection):
        return zip(reversed(range(len(collection))), reversed(collection))
    

    或者为什么我们没有 reversed_range()

  • 1
    input_list = ['foo','bar','baz']
    for i in range(-1,-len(input_list)-1,-1)
        print(input_list[i])
    

    我认为这个也是简单的方法...从末尾读取并继续递减直到列表的长度,因为我们从不执行“结束”索引因此添加-1也

  • 0

    您可以在普通for循环中使用负索引:

    >>> collection = ["ham", "spam", "eggs", "baked beans"]
    >>> for i in range(1, len(collection) + 1):
    ...     print(collection[-i])
    ... 
    baked beans
    eggs
    spam
    ham
    

    要像访问集合的反向副本一样向前访问索引,请使用 i - 1

    >>> for i in range(1, len(collection) + 1):
    ...     print(i-1, collection[-i])
    ... 
    0 baked beans
    1 eggs
    2 spam
    3 ham
    

    要访问原始的未反转索引,请使用 len(collection) - i

    >>> for i in range(1, len(collection) + 1):
    ...     print(len(collection)-i, collection[-i])
    ... 
    3 baked beans
    2 eggs
    1 spam
    0 ham
    
  • 3

    反向功能在这里派上用场:

    myArray = [1,2,3,4]
    myArray.reverse()
    for x in myArray:
        print x
    
  • 0

    要使用负指数:从-1开始,每次迭代后退-1 .

    >>> a = ["foo", "bar", "baz"]
    >>> for i in range(-1, -1*(len(a)+1), -1):
    ...     print i, a[i]
    ... 
    -1 baz
    -2 bar
    -3 foo
    
  • 1

    一个简单的方法:

    n = int(input())
    arr = list(map(int, input().split()))
    
    for i in reversed(range(0, n)):
        print("%d %d" %(i, arr[i]))
    
  • 0

    使用内置的 reversed() 函数:

    >>> a = ["foo", "bar", "baz"]
    >>> for i in reversed(a):
    ...     print (i)
    ... 
    baz
    bar
    foo
    

    要访问原始索引:

    >>> for i, e in reversed(list(enumerate(a))):
    ...     print (i, e)
    ... 
    2 baz
    1 bar
    0 foo
    
  • 889

    你可以做:

    for item in my_list[::-1]:
        print item
    

    (或者你想在for循环中做什么 . )

    [::-1] 切片会反转for循环中的列表(但实际上不会修改列表"permanently") .

  • 1

    如果你需要循环索引,并且不想遍历整个列表两次,或者使用额外的内存,我会写一个生成器 .

    def reverse_enum(L):
       for index in reversed(xrange(len(L))):
          yield index, L[index]
    
    L = ['foo', 'bar', 'bas']
    for index, item in reverse_enum(L):
       print index, item
    
  • 1

    它可以这样做:

    for i in range(len(collection)-1, -1, -1):
        print collection[i]
    
        # print(collection[i]) for python 3. +
    

    所以你的猜测非常接近:)有点尴尬,但它基本上是说:从1开始不到 len(collection) ,继续前进直到-1到-1之前,步长为-1 .

    Fyi, help 函数非常有用,因为它允许您从Python控制台查看某些文档,例如:

    help(range)

  • 2

    reversed 内置函数很方便:

    for item in reversed(sequence):
    

    反向的documentation解释了它的局限性 .

    对于我必须与索引一起反向遍历序列的情况(例如,对于改变序列长度的就地修改),我将此函数定义为我的codeutil模块:

    import itertools
    def reversed_enumerate(sequence):
        return itertools.izip(
            reversed(xrange(len(sequence))),
            reversed(sequence),
        )
    

    这个避免了创建序列的副本 . 显然, reversed 限制仍然适用 .

  • 5
    >>> l = ["a","b","c","d"]
    >>> l.reverse()
    >>> l
    ['d', 'c', 'b', 'a']
    

    要么

    >>> print l[::-1]
    ['d', 'c', 'b', 'a']
    
  • 0

    如果不重新创建新列表,可以通过索引来完成:

    >>> foo = ['1a','2b','3c','4d']
    >>> for i in range(len(foo)):
    ...     print foo[-(i+1)]
    ...
    4d
    3c
    2b
    1a
    >>>
    

    要么

    >>> length = len(foo)
    >>> for i in range(length):
    ...     print foo[length-i-1]
    ...
    4d
    3c
    2b
    1a
    >>>
    
  • 1

    我喜欢单线发电机的方法:

    ((i, sequence[i]) for i in reversed(xrange(len(sequence))))
    
  • 0

    使用 list.reverse() 然后像往常一样迭代 .

    http://docs.python.org/tutorial/datastructures.html

  • 134
    def reverse(spam):
        k = []
        for i in spam:
            k.insert(0,i)
        return "".join(k)
    
  • 0

    其他答案都很好,但如果你想做 List comprehension style

    collection = ['a','b','c']
    [item for item in reversed( collection ) ]
    
  • 0

    对序列对象使用内置函数 reversed() ,此方法具有所有序列的效果

    more detailed reference link

  • 4

    您还可以使用 while 循环:

    i = len(collection)-1
    while i>=0:
        value = collection[i]
        index = i
        i-=1
    
  • 7

    一个简单的方法是:

    for i in range(1,len(arr)+1):
        print(arr[-i])
    
  • 57

    无论如何,你也可以这样做 . 非常简单 .

    a = [1, 2, 3, 4, 5, 6, 7]
    for x in xrange(len(a)):
        x += 1
        print a[-x]
    
  • 0

    如果需要索引,最简单的方法是从 len()-1 中减去 enumerate(reversed()) 返回的索引 . enumerate() 不接受 step 参数 .

    如果你需要多次这样做,你应该使用一个发电机:

    a = ['b', 'd', 'c', 'a']
    
    def enumerate_reversed(lyst):
        for index, value in enumerate(reversed(lyst)):
            index = len(lyst)-1 - index
            yield index, value
    
    for index, value in enumerate_reversed(a):
        do_something(index, value)
    

    或者如果你只需要做一次:

    for index, value in enumerate(reversed(a)):
        index = len(a)-1 - index
    
        do_something(index, value)
    
  • 45

    假设任务是找到满足列表中某些条件的最后一个元素(即首先向后看时),我得到以下数字:

    >>> min(timeit.repeat('for i in xrange(len(xs)-1,-1,-1):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', repeat=8))
    4.6937971115112305
    >>> min(timeit.repeat('for i in reversed(xrange(0, len(xs))):\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', repeat=8))
    4.809093952178955
    >>> min(timeit.repeat('for i, x in enumerate(reversed(xs), 1):\n    if 128 == x: break', setup='xs, n = range(256), 0', repeat=8))
    4.931743860244751
    >>> min(timeit.repeat('for i, x in enumerate(xs[::-1]):\n    if 128 == x: break', setup='xs, n = range(256), 0', repeat=8))
    5.548468112945557
    >>> min(timeit.repeat('for i in xrange(len(xs), 0, -1):\n    if 128 == xs[i - 1]: break', setup='xs, n = range(256), 0', repeat=8))
    6.286104917526245
    >>> min(timeit.repeat('i = len(xs)\nwhile 0 < i:\n    i -= 1\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', repeat=8))
    8.384078979492188
    

    所以,最丑陋的选择 xrange(len(xs)-1,-1,-1) 是最快的 .

  • 19

    此外,您可以使用“范围”或“计数”功能 . 如下:

    a = ["foo", "bar", "baz"]
    for i in range(len(a), 0, -1):
        print(i, a[i-1])
    
    3 baz
    2 bar
    1 foo
    

    您还可以使用itertools中的“count”,如下所示:

    a = ["foo", "bar", "baz"]
    from itertools import count, takewhile
    
    def larger_than_0(x):
        return x > 0
    
    for x in takewhile(larger_than_0, count(3, -1)):
        print(x, a[x-1])
    
    3 baz
    2 bar
    1 foo
    

相关问题