파이썬에서 리버스 순서로 목록을 가로 지르십시오
문제
그래서 시작할 수 있습니다 len(collection)
그리고 끝납니다 collection[0]
.
편집 : 죄송합니다. 루프 색인에 액세스 할 수 있기를 원한다는 것을 잊었습니다.
해결책
내장을 사용하십시오 reversed()
기능:
>>> a = ["foo", "bar", "baz"]
>>> for i in reversed(a):
... print(i)
...
baz
bar
foo
원래 색인에도 액세스하려면 사용하십시오 enumerate()
전달하기 전에 목록에 reversed()
:
>>> for i, e in reversed(list(enumerate(a))):
... print(i, e)
...
2 baz
1 bar
0 foo
부터 enumerate()
생성기를 반환하고 발전기를 되돌릴 수 없습니다. list
첫 번째.
다른 팁
넌 할 수있어:
for item in my_list[::-1]:
print item
(또는 For Loop에서하고 싶은 모든 것.)
그만큼 [::-1]
슬라이스는 For Loop의 목록을 뒤집습니다 (그러나 실제로 목록을 "영구적으로"수정하지는 않습니다).
루프 색인이 필요하고 전체 목록을 두 번 횡단하거나 추가 메모리를 사용하지 않으려면 생성기를 작성합니다.
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
다음과 같이 할 수 있습니다.
for i in range(len(collection)-1, -1, -1): print collection[i] # print(collection[i]) for python 3. +
그래서 당신의 추측은 꽤 가깝습니다 :) 조금 어색하지만 기본적으로 말합니다 : 1로 시작하십시오. len(collection)
, -1의 단계에서 -1의 단계에 도달 할 때까지 계속 가십시오.
참고로 help
기능은 파이썬 콘솔에서 무언가에 대한 문서를 볼 수 있으므로 매우 유용합니다.
help(range)
그만큼 reversed
내장 기능은 편리합니다.
for item in reversed(sequence):
그만큼 선적 서류 비치 반전 된 경우 그 한계를 설명합니다.
인덱스와 함께 시퀀스를 반대로 걸어야하는 경우 (예 : 시퀀스 길이를 변경하는 내내 수정의 경우)이 함수가 내 CodeUtil 모듈을 정의했습니다.
import itertools
def reversed_enumerate(sequence):
return itertools.izip(
reversed(xrange(len(sequence))),
reversed(sequence),
)
이것은 시퀀스의 사본을 만드는 것을 피합니다. 분명히 reversed
제한이 여전히 적용됩니다.
>>> l = ["a","b","c","d"]
>>> l.reverse()
>>> l
['d', 'c', 'b', 'a']
또는
>>> print l[::-1]
['d', 'c', 'b', 'a']
새 목록을 재현하지 않고 색인을 통해 수행 할 수 있습니다.
>>> 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))))
또한 "범위"또는 "카운트"함수를 사용할 수 있습니다. 다음과 같이 :
a = ["foo", "bar", "baz"]
for i in range(len(a)-1, -1, -1):
print(i, a[i])
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
사용 list.reverse()
그리고 평소처럼 반복하십시오.
def reverse(spam):
k = []
for i in spam:
k.insert(0,i)
return "".join(k)
그만한 가치가있는 것은 당신이 이런 식으로 할 수 있습니다. 매우 간단합니다.
a = [1, 2, 3, 4, 5, 6, 7]
for x in xrange(len(a)):
x += 1
print a[-x]
인덱스가 필요하고 목록이 작 으면 가장 읽기 쉬운 방법은해야합니다. reversed(list(enumerate(your_list)))
허용 된 대답처럼. 그러나 이것은 목록의 사본을 생성하므로 목록이 메모리의 상당 부분을 차지하는 경우 반환 된 색인을 빼야합니다. enumerate(reversed())
~에서 len()-1
.
한 번만 해야하는 경우 :
a = ['b', 'd', 'c', 'a']
for index, value in enumerate(reversed(a)):
index = len(a)-1 - index
do_something(index, value)
또는이 작업을 여러 번 수행 해야하는 경우 발전기를 사용해야합니다.
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)
역 함수는 여기에서 편리합니다.
myArray = [1,2,3,4]
myArray.reverse()
for x in myArray:
print x
다른 대답은 좋지만이해 스타일을 나열하십시오
collection = ['a','b','c']
[item for item in reversed( collection ) ]
내장 기능을 사용하십시오 reversed()
시퀀스 객체의 경우이 방법은 모든 시퀀스의 효과가 있습니다.
당신은 또한 a를 사용할 수 있습니다 while
고리:
i = len(collection)-1
while i>=0:
value = collection[i]
index = i
i-=1
루프의 일반적인 음수 지수를 사용할 수 있습니다.
>>> 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
달성하는 표현적인 방법 reverse(enumerate(collection))
파이썬 3에서 :
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()
가져 오기가없는 접근 :
for i in range(1,len(arr)+1):
print(arr[-i])
또는
for i in arr[::-1]:
print(i)
음수 지수를 사용하려면 : -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
간단한 방법 :
n = int(input())
arr = list(map(int, input().split()))
for i in reversed(range(0, n)):
print("%d %d" %(i, arr[i]))
input_list = ['foo','bar','baz']
for i in range(-1,-len(input_list)-1,-1)
print(input_list[i])
나는 이것을 할 수있는 간단한 방법이라고 생각합니다 ... 끝에서 읽고 목록 길이까지 계속 줄어드는데, 우리는 "end"색인을 실행하지 않기 때문에 -1도 추가되었습니다.
작업이 목록에서 일부 조건을 만족시키는 마지막 요소를 찾는 것이라고 가정하면 (즉, 뒤로 볼 때 먼저) 다음 숫자를 받고 있습니다.
>>> 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)
가장 빠릅니다.
색인이 부정적이라고 생각하지 않으면 다음을 수행 할 수 있습니다.
>>> a = ["foo", "bar", "baz"]
>>> for i in range(len(a)):
... print(~i, a[~i]))
-1 baz
-2 bar
-3 foo
가장 우아한 방법은 변화하는 것입니다 enumerate
그리고 reversed
다음 생성기 사용
(-(ri+1), val) for ri, val in enumerate(reversed(foo))
이 반전을 생성합니다 enumerate
반복자
예시:
foo = [1,2,3]
bar = [3,6,9]
[
bar[i] - val
for i, val in ((-(ri+1), val) for ri, val in enumerate(reversed(foo)))
]
결과:
[6, 4, 2]