Python에서 역순으로 목록 이동
나는 할 수 있다.collection[len(collection)-1]으로 collection[0].
루프 인덱스에 액세스 할 수 있으면 좋겠습니다.
내장된 기능을 사용합니다.
>>> a = ["foo", "bar", "baz"]
>>> for i in reversed(a):
... print(i)
...
baz
bar
foo
원래 인덱스에 액세스하려면 목록을 전달하기 전에 를 사용하십시오.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 루프에서 수행하는 모든 작업).
[::-1]슬라이스는 for 루프의 목록을 반전시킵니다(단, 실제로 목록을 "지속적으로" 수정하지는 않습니다).
다음과 같이 실행할 수 있습니다.
for i in range(len(collection)-1, -1, -1):
print collection[i]
# print(collection[i]) for python 3. +
꽤으로는 '하세요.'라고되어 있습니다len(collection)1의 의 -1의 -1의 -1의 -1의 로 -1의
Fyi, the Fyi, the Fyihelp 함수는 수예를 들어 Python은 Python 콘솔의 를 표시할 수 있습니다.
help(range)
루프 인덱스가 필요하고 전체 목록을 두 번 이동하거나 추가 메모리를 사용하지 않으려면 제너레이터를 작성해야 합니다.
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
reversed빌트인 기능은 편리합니다.
for item in reversed(sequence):
reverse의 설명서는 그 제한에 대해 설명하고 있습니다.
인덱스와 함께 시퀀스를 역방향으로 걸어야 하는 경우(예: 시퀀스 길이를 변경하는 내부 수정의 경우), 이 함수를 my codeutil 모듈로 정의한다.
from six.moves import zip as izip, range as xrange
def reversed_enumerate(sequence):
return izip(
reversed(xrange(len(sequence))),
reversed(sequence),
)
이렇게 하면 시퀀스의 복사본이 생성되지 않습니다. 그 명,는,reversed제한은 여전히 적용됩니다.
Import가 없는 접근법:
for i in range(1,len(arr)+1):
print(arr[-i])
또는 이 접근법은 메모리에 새 목록을 생성하므로 큰 목록을 사용할 때 주의하십시오.
for i in arr[::-1]:
print(i)
또한 "범위" 또는 "카운트" 함수를 사용할 수 있습니다.다음과 같습니다.
a = ["foo", "bar", "baz"]
for i in range(len(a)-1, -1, -1):
print(i, a[i])
3 baz
2 bar
1 foo
다음과 같이 반복 도구의 "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
새 목록을 다시 만들지 않고 인덱싱으로 다음을 수행할 수 있습니다.
>>> 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
>>>
>>> l = ["a","b","c","d"]
>>> l.reverse()
>>> l
['d', 'c', 'b', 'a']
또는
>>> print l[::-1]
['d', 'c', 'b', 'a']
되므로 python 3의 list는 python 3의 list입니다.reversed(list(enumerate(collection))비효율적일 수 있습니다.다른 목록을 생성해도 최적화되지 않습니다.
컬렉션이 확실하게 목록인 경우 반복기 뒤에 있는 복잡성을 숨기는 것이 가장 좋습니다.
def reversed_enumerate(collection: list):
for i in range(len(collection)-1, -1, -1):
yield i, collection[i]
가장 깨끗한 것은 다음과 같습니다.
for i, elem in reversed_enumerate(['foo', 'bar', 'baz']):
print(i, elem)
저는 원라이너 발전기 접근 방식을 좋아합니다.
((i, sequence[i]) for i in reversed(xrange(len(sequence))))
사용하다list.reverse()평소처럼 반복하는 거야
http://docs.python.org/tutorial/datastructures.html
너도 이렇게 할 수 있어매우 단순합니다.
a = [1, 2, 3, 4, 5, 6, 7]
for x in xrange(len(a)):
x += 1
print a[-x]
def reverse(spam):
k = []
for i in spam:
k.insert(0,i)
return "".join(k)
인덱스가 필요하고 목록이 작다면 가장 읽기 쉬운 방법은 다음과 같습니다.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)
태스크가 리스트에서 어떤 조건을 만족시키는 마지막 요소를 찾는 것이라고 가정하면(즉, 뒤를 돌아볼 때 먼저), 다음과 같은 수치를 얻을 수 있습니다.
Python 2:
>>> 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)가장 빠릅니다.
Python 3(다른 기계):
>>> timeit.timeit('for i in range(len(xs)-1,-1,-1):\n if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
4.48873088900001
>>> timeit.timeit('for i in reversed(range(0, len(xs))):\n if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
4.540959084000008
>>> timeit.timeit('for i, x in enumerate(reversed(xs), 1):\n if 128 == x: break', setup='xs, n = range(256), 0', number=400000)
1.9069805409999958
>>> timeit.timeit('for i, x in enumerate(xs[::-1]):\n if 128 == x: break', setup='xs, n = range(256), 0', number=400000)
2.960720073999994
>>> timeit.timeit('for i in range(len(xs), 0, -1):\n if 128 == xs[i - 1]: break', setup='xs, n = range(256), 0', number=400000)
5.316207007999992
>>> timeit.timeit('i = len(xs)\nwhile 0 < i:\n i -= 1\n if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
5.802550058999998
여기서,enumerate(reversed(xs), 1)가장 빠릅니다.
저는 가장 우아한 방법은 변신을 해서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]
역기능은 다음과 같이 편리합니다.
myArray = [1,2,3,4]
myArray.reverse()
for x in myArray:
print x
지수가 음수인 것이 괜찮다면 다음을 수행할 수 있습니다.
>>> a = ["foo", "bar", "baz"]
>>> for i in range(len(a)):
... print(~i, a[~i]))
-1 baz
-2 bar
-3 foo
다른 답변도 좋지만 목록 이해 스타일로 하려면
collection = ['a','b','c']
[item for item in reversed( collection ) ]
음의 지수를 사용하려면 -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
를 사용할 수도 있습니다.while루프:
i = len(collection)-1
while i>=0:
value = collection[i]
index = i
i-=1
일반 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
왜 지금까지 명확한 선택이 나타나지 않았는지 혼란스럽다.
한다면reversed()제너레이터가 있기 때문에 동작하지 않습니다(의 경우와 같습니다).enumerate()), 사용만 하면 됩니다.sorted():
>>> l = list( 'abcdef' )
>>> sorted( enumerate(l), reverse=True )
[(5, 'f'), (4, 'e'), (3, 'd'), (2, 'c'), (1, 'b'), (0, 'a')]
Python의 초보자였던 저는 이 방법이 더 이해하기 쉽다는 것을 알고 목록을 뒤집었습니다.
numlst = [1, 2, 3, 4]라고 말합니다.
범위(len(numlst)-1,-1,-1):
ie., for i in range(3,-1,-1), where 3 is length of list minus 1,
second -1 means list starts from last element and
third -1 signifies it will traverse in reverse order.
print ( numlst [ i ] )
o/p = 4, 3, 2, 1
간단한 방법:
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도 추가되므로 끝에서 읽고 목록 길이까지 계속 감소합니다.
제너레이터를 사용할 수 있습니다.
li = [1,2,3,4,5,6]
len_li = len(li)
gen = (len_li-1-i for i in range(len_li))
마지막으로:
for i in gen:
print(li[i])
이게 도움이 되길 바라.
언급URL : https://stackoverflow.com/questions/529424/traverse-a-list-in-reverse-order-in-python
'source' 카테고리의 다른 글
| http://localhost CORS 오리진이 작동하지 않는 이유는 무엇입니까? (0) | 2023.01.19 |
|---|---|
| 지속성 콘텍스트란? (0) | 2023.01.19 |
| Python의 숨겨진 기능 (0) | 2023.01.19 |
| 쿠키 이름 가져오기 (0) | 2023.01.19 |
| 글로벌 및 로컬에 gulp을 설치해야 하는 이유는 무엇입니까? (0) | 2023.01.19 |