파이썬에서 다음을 어떻게 할 수 있습니까?

array = [0, 10, 20, 40]
for (i = array.length() - 1; i >= 0; i--)

배열의 요소가 필요하지만 처음부터 끝까지 필요합니다.

reversed이 기능을 다음과 같이 사용할 수 있습니다 .

>>> array=[0,10,20,40]
>>> for i in reversed(array):
...     print(i)

참고 reversed(...)목록을 반환하지 않습니다. 을 사용하여 반전 된 목록을 얻을 수 있습니다 list(reversed(array)).

>>> L = [0,10,20,40]
>>> L[::-1]
[40, 20, 10, 0]

확장 슬라이스 구문은 Python 의 새로운 기능 릴리스에 잘 설명되어 있습니다.2.3.5

의견의 특별한 요청에 의해 이것은 최신 슬라이스 문서 입니다.

>>> L = [0,10,20,40]
>>> L.reverse()
>>> L
[40, 20, 10, 0]

또는

>>> L[::-1]
[40, 20, 10, 0]

이것은 목록을 복제하는 것입니다.

L = [0,10,20,40]
p = L[::-1]  #  Here p will be having reversed list

이것은 목록을 그 자리에서 뒤집는 것입니다.

L.reverse() # Here L will be reversed in-place (no new list made)

파이썬에서 목록을 뒤집는 가장 좋은 방법은 다음과 같습니다.

a = [1,2,3,4]
a = a[::-1]
print(a)
>>> [4,3,2,1]

작업이 완료되었으며 이제 목록이 반전되었습니다.

동일한 목록을 되돌리려면 다음을 사용하십시오.

array.reverse()

다른 목록에 역순으로 목록을 할당하려면 다음을 사용하십시오.

newArray = array[::-1] 

예를 들어, array = array [::-1]과 같은 슬라이싱을 사용하는 것은 깔끔한 트릭이자 매우 Pythonic이지만 초보자에게는 약간 모호합니다. reverse () 메소드를 사용하면 쉽게 읽을 수 있기 때문에 매일 코딩하는 것이 좋습니다.

그러나 인터뷰 질문에서와 같이 목록을 뒤집어 야하는 경우에는 이와 같은 내장 방법을 사용하지 못할 수 있습니다. 면접관은 파이썬 지식의 깊이보다는 문제에 어떻게 접근하는지 살펴보고 알고리즘 접근법이 필요합니다. 클래식 스왑을 사용하는 다음 예제는이를 수행하는 한 가지 방법 일 수 있습니다.

def reverse_in_place(lst):      # Declare a function
    size = len(lst)             # Get the length of the sequence
    hiindex = size - 1
    its = size/2                # Number of iterations required
    for i in xrange(0, its):    # i is the low index pointer
        temp = lst[hiindex]     # Perform a classic swap
        lst[hiindex] = lst[i]
        lst[i] = temp
        hiindex -= 1            # Decrement the high index pointer
    print "Done!"

# Now test it!!
array = [2, 5, 8, 9, 12, 19, 25, 27, 32, 60, 65, 1, 7, 24, 124, 654]

print array                    # Print the original sequence
reverse_in_place(array)        # Call the function passing the list
print array                    # Print reversed list


**The result:**
[2, 5, 8, 9, 12, 19, 25, 27, 32, 60, 65, 1, 7, 24, 124, 654]
Done!
[654, 124, 24, 7, 1, 65, 60, 32, 27, 25, 19, 12, 9, 8, 5, 2]

문자열과 튜플은 변경할 수 없기 때문에 튜플이나 문자열 시퀀스에서는 작동하지 않습니다. 즉, 요소를 변경하기 위해 쓸 수 없습니다.

l.reverse()파이썬 3과 2에서 긴 목록을 되 돌리는 가장 빠른 방법 인 다른 제안과는 달리 나는 다른 사람들이 이러한 타이밍을 복제 할 수 있는지 알고 싶습니다.

l[::-1]목록을 뒤집기 전에 복사하기 때문에 속도가 느려질 수 있습니다. list()반복자 주위 에 호출을 reversed(l)추가하면 약간의 오버 헤드가 추가되어야합니다. 물론리스트 또는 이터레이터의 사본을 원한다면 각각의 방법을 사용하지만리스트를 반대로 바꾸려면l.reverse() 려면 가장 빠른 방법 인 것 같습니다.

기능

def rev_list1(l):
    return l[::-1]

def rev_list2(l):
    return list(reversed(l))

def rev_list3(l):
    l.reverse()
    return l

명부

l = list(range(1000000))

파이썬 3.5 타이밍

timeit(lambda: rev_list1(l), number=1000)
# 6.48
timeit(lambda: rev_list2(l), number=1000)
# 7.13
timeit(lambda: rev_list3(l), number=1000)
# 0.44

파이썬 2.7 타이밍

timeit(lambda: rev_list1(l), number=1000)
# 6.76
timeit(lambda: rev_list2(l), number=1000)
# 9.18
timeit(lambda: rev_list3(l), number=1000)
# 0.46

for x in array[::-1]:
    do stuff

로 reversed와 list:

>>> list1 = [1,2,3]
>>> reversed_list = list(reversed(list1))
>>> reversed_list
>>> [3, 2, 1]

array=[0,10,20,40]
for e in reversed(array):
  print e

reverse (array)를 사용하는 것이 가장 좋은 경로 일 것입니다.

>>> array = [1,2,3,4]
>>> for item in reversed(array):
>>>     print item

내장을 사용하지 않고 어떻게 구현할 수 있는지 이해해야합니다 reversed.

def reverse(a):
    midpoint = len(a)/2
    for item in a[:midpoint]:
        otherside = (len(a) - a.index(item)) - 1
        temp = a[otherside]
        a[otherside] = a[a.index(item)]
        a[a.index(item)] = temp
    return a

O (N) 시간이 걸립니다.

다른 변수에 반전 목록의 요소를 저장하려면 revArray = array[::-1]또는revArray = list(reversed(array)) .

그러나 첫 번째 변형은 약간 더 빠릅니다.

z = range(1000000)
startTimeTic = time.time()
y = z[::-1]
print("Time: %s s" % (time.time() - startTimeTic))

f = range(1000000)
startTimeTic = time.time()
g = list(reversed(f))
print("Time: %s s" % (time.time() - startTimeTic))

산출:

Time: 0.00489711761475 s
Time: 0.00609302520752 s

조직 가치 :

파이썬에서리스트의 순서도 정렬 로 조작 할 수 있습니다 하여 변수를 숫자 / 알파벳 순서로 구성 .

일시적으로 :

print(sorted(my_list))

영구적 인:

my_list.sort(), print(my_list)

"reverse = True" 플래그로 정렬 할 수 있습니다 .

print(sorted(my_list, reverse=True))

또는

my_list.sort(reverse=True), print(my_list)

조직없이

값을 정렬하지 않고 값을 반대로 만 할 수도 있습니다. 그러면 다음과 같이 할 수 있습니다 :

print(list(reversed(my_list)))

** 번호는 알파벳 순서보다 우선 순위가 높습니다. 파이썬 가치의 조직은 훌륭합니다.

설명 및 타이밍 결과가있는 방법 요약

몇 가지 좋은 답변이 있지만 널리 퍼져 있으며 각 접근법의 근본적인 차이점을 나타내지는 않습니다.

전반적으로 내장 함수 / 메소드를 사용하여 거의 모든 함수와 마찬가지로 반전하는 것이 좋습니다. 이 경우 수동으로 생성 된 인덱싱 방법에 비해 짧은 목록 (10 개 항목)에서는 약 2 ~ 8 배 더 빠르며 긴 목록에서는 최대 300 배 이상 빠릅니다. 전문가가 전문가를 만들고, 조사하고, 최적화하는 데 도움이됩니다. 또한 결함이 적고 모서리와 모서리를 처리 할 가능성이 높습니다.

또한 다음을 원할지 여부를 고려하십시오.

1. 기존 목록을 제자리로 뒤집기
   • 가장 좋은 해결책은`object.reverse () '방법입니다
2. for 루프, 생성기 등에 피드를 제공하기 때문에 목록의 반대 반복자를 작성하십시오.
   • 최고의 솔루션은 반복자를 만드는 '역 (객체)'입니다.
3. 또는 역순으로 완전한 사본을 작성하십시오
   • 최상의 솔루션은 -1 단계 크기의 슬라이스를 사용하는 것입니다. object[::-1]

테스트 스크립트

다음은 다루는 방법에 대한 테스트 스크립트의 시작입니다. 이 답변에 모든 코드 스 니펫을 함께 넣어 목록과 시간을 역전시키는 다른 모든 방법을 실행하는 스크립트를 만듭니다 (마지막 섹션에 표시된 출력).

from timeit import timeit
from copy import copy

def time_str_ms(t):
    return '{0:8.2f} ms'.format(t * 1000)

방법 1 : obj.reverse ()를 사용하여 반전

목표가 기존 목록의 항목 순서를 반대로 바꾸거나 반복하지 않고 사본을 얻지 않으면 <list>.reverse() 기능을 . 이것을 목록 객체에서 직접 실행하면 모든 항목의 순서가 반대로됩니다.

다음은 역순으로 목록을 다시 반환하더라도 주어진 원래 변수를 반대로합니다. 즉,이 기능 출력을 사용하여 사본을 만들 수 있습니다. 일반적 으로이 기능을 수행하지는 않지만 끝에 타이밍 코드를 사용했습니다.

이 두 가지 방법의 성능을 테스트합니다. 먼저 목록을 원래 위치로 되돌리고 (원래 목록을 변경 한 후) 목록을 복사하고 나중에 되돌립니다.

def rev_in_place(mylist):
    mylist.reverse()
    return mylist

def rev_copy_reverse(mylist):
    a = copy(mylist)
    a.reverse()
    return a

방법 2 : 슬라이스를 사용하여 목록 반전 obj[::-1]

내장 된 인덱스 슬라이싱 방법을 사용하면 인덱스 된 개체의 일부를 복사 할 수 있습니다.

• 원본 객체에는 영향을 미치지 않습니다
• 반복자가 아닌 전체 목록을 작성합니다.

일반적인 구문은 다음과 같습니다 <object>[first_index:last_index:step]. 슬라이싱을 이용하여 간단한 역순 목록을 만들려면 다음을 사용하십시오.<list>[::-1] .. 옵션을 비워두면 오브젝트의 첫 번째 및 마지막 요소의 기본값으로 설정됩니다 (단계 크기가 음수 인 경우 역순).

색인을 생성하면 음수를 사용할 수 있습니다. 음수는 객체 색인의 끝에서부터 거꾸로 계산됩니다 (즉, -2는 두 번째에서 마지막 항목입니다). 단계 크기가 음수이면 마지막 항목부터 시작하여 해당 양만큼 뒤로 색인합니다. 이와 관련하여 최적화 된 일부 시작-엔드 로직이 있습니다.

def rev_slice(mylist):
    a = mylist[::-1]
    return a

방법 3 : reversed(obj)반복자 함수를 사용하여 목록 반전

이 reversed(indexed_object)기능은 :

• 이것은리스트가 아닌 리버스 인덱스 반복자를 만듭니다. 큰 목록에서 더 나은 성능을 위해 루프에 공급하면 좋습니다.
• 이것은 사본을 생성하고 원본 객체에 영향을 미치지 않습니다

원시 이터레이터로 테스트하고 이터레이터에서 목록을 작성하십시오.

def reversed_iterator(mylist):
    a = reversed(mylist)
    return a

def reversed_with_list(mylist):
    a = list(reversed(mylist))
    return a

방법 4 : 사용자 지정 / 수동 인덱싱을 사용하여 역방향 목록

타이밍이 보여 주듯이, 자신 만의 인덱싱 방법을 만드는 것은 나쁜 생각입니다. 실제로 사용자 정의 작업을 수행해야하는 경우가 아니면 내장 방법을 사용하십시오.

즉, 목록 크기가 작 으면 큰 패널티가 없지만 스케일을 올리면 패널티가 엄청납니다. 아래 코드를 최적화 할 수 있다고 확신하지만 기본 제공 방법을 사용합니다.

def rev_manual_pos_gen(mylist):
    max_index = len(mylist) - 1
    return [ mylist[max_index - index] for index in range(len(mylist)) ]

def rev_manual_neg_gen(mylist):
    ## index is 0 to 9, but we need -1 to -10
    return [ mylist[-index-1] for index in range(len(mylist)) ]

def rev_manual_index_loop(mylist):
    a = []
    reverse_index = len(mylist) - 1
    for index in range(len(mylist)):
        a.append(mylist[reverse_index - index])
    return a

def rev_manual_loop(mylist):
    a = []
    reverse_index = len(mylist)
    for index, _ in enumerate(mylist):
        reverse_index -= 1
        a.append(mylist[reverse_index])
    return a

각 방법 타이밍

다음은 각 반전 방법에 대한 시간을 정하는 나머지 스크립트입니다. 슬라이스를 사용하는 것이 사본을 생성하는 가장 빠른 방법 인 반면, 반복자를 사용하여 뒤집어 obj.reverse()놓은 상태 에서 반전을 만드는 reversed(obj)것이 항상 가장 빠릅니다.

또한 필요한 경우가 아니면 직접 작성하는 방법을 만들려고하지 않습니다.

loops_to_test = 100000
number_of_items = 10
list_to_reverse = list(range(number_of_items))
if number_of_items < 15:
    print("a: {}".format(list_to_reverse))
print('Loops: {:,}'.format(loops_to_test))
# List of the functions we want to test with the timer, in print order
fcns = [rev_in_place, reversed_iterator, rev_slice, rev_copy_reverse,
        reversed_with_list, rev_manual_pos_gen, rev_manual_neg_gen,
        rev_manual_index_loop, rev_manual_loop]
max_name_string = max([ len(fcn.__name__) for fcn in fcns ])
for fcn in fcns:
    a = copy(list_to_reverse) # copy to start fresh each loop
    out_str = ' | out = {}'.format(fcn(a)) if number_of_items < 15 else ''
    # Time in ms for the given # of loops on this fcn
    time_str = time_str_ms(timeit(lambda: fcn(a), number=loops_to_test))
    # Get the output string for this function
    fcn_str = '{}(a):'.format(fcn.__name__)
    # Add the correct string length to accommodate the maximum fcn name
    format_str = '{{fx:{}s}} {{time}}{{rev}}'.format(max_name_string + 4)
    print(format_str.format(fx=fcn_str, time=time_str, rev=out_str))

타이밍 결과

결과는 스케일링이 주어진 작업에 가장 적합한 내장 방법으로 가장 잘 작동 함을 보여줍니다. 다시 말해서, 오브젝트 요소 수가 증가함에 따라 내장 메소드는 훨씬 우수한 성능 결과를 갖기 시작합니다.

함께 묶는 것보다 필요한 것을 직접 달성하는 최상의 내장 방법을 사용하는 것이 좋습니다. 예를 들어, 반전 된 목록의 사본이 필요한 경우 슬라이싱이 가장 좋습니다. reversed()함수 에서 목록을 작성하는 것보다 빠르며, 목록 의 사본을 작성한 후 제자리에서 수행하는 것보다 빠릅니다 obj.reverse(). 그러나 이러한 방법 중 하나가 실제로 필요한 모든 것이라면 더 빠르지 만 두 배 이상의 속도는 결코 아닙니다. 한편, 사용자 지정 수동 방법은 특히 매우 큰 목록의 경우 더 오랜 시간이 걸릴 수 있습니다.

1000 개 항목 목록을 사용하여 크기를 조정하려면 reversed(<list>) 함수 호출은 반복자를 설정하는 데 ~ 30ms가 소요되며, 전체 반전 목록의 사본을 작성하는 데 슬라이스 방법을 사용하면 ~ 210ms가 소요되지만 내부 위치를 역전하는 데는 ~ 55ms가 소요됩니다. 내가 만든 가장 빠른 수동 방법은 ~ 8400 ms 걸렸습니다!

목록에 2 개의 항목이있는 경우 :

a: [0, 1]
Loops: 100,000
rev_in_place(a):             24.70 ms | out = [1, 0]
reversed_iterator(a):        30.48 ms | out = <list_reverseiterator object at 0x0000020242580408>
rev_slice(a):                31.65 ms | out = [1, 0]
rev_copy_reverse(a):         63.42 ms | out = [1, 0]
reversed_with_list(a):       48.65 ms | out = [1, 0]
rev_manual_pos_gen(a):       98.94 ms | out = [1, 0]
rev_manual_neg_gen(a):       88.11 ms | out = [1, 0]
rev_manual_index_loop(a):    87.23 ms | out = [1, 0]
rev_manual_loop(a):          79.24 ms | out = [1, 0]

목록에 10 개의 항목이 있습니다.

rev_in_place(a):             23.39 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
reversed_iterator(a):        30.23 ms | out = <list_reverseiterator object at 0x00000290A3CB0388>
rev_slice(a):                36.01 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
rev_copy_reverse(a):         64.67 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
reversed_with_list(a):       50.77 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
rev_manual_pos_gen(a):      162.83 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
rev_manual_neg_gen(a):      167.43 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
rev_manual_index_loop(a):   152.04 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
rev_manual_loop(a):         183.01 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

목록에 1000 개의 항목이 있습니다.

rev_in_place(a):             56.37 ms
reversed_iterator(a):        30.47 ms
rev_slice(a):               211.42 ms
rev_copy_reverse(a):        295.74 ms
reversed_with_list(a):      418.45 ms
rev_manual_pos_gen(a):     8410.01 ms
rev_manual_neg_gen(a):    11054.84 ms
rev_manual_index_loop(a): 10543.11 ms
rev_manual_loop(a):       15472.66 ms

일부 논리 사용

구식 논리를 사용하여 인터뷰 연습.

앞뒤로 숫자를 바꿉니다. 두 개의 포인터 사용index[0] and index[last]

def reverse(array):
    n = array
    first = 0
    last = len(array) - 1
    while first < last:
      holder = n[first]
      n[first] = n[last]
      n[last] = holder
      first += 1
      last -= 1
    return n

input -> [-1 ,1, 2, 3, 4, 5, 6]
output -> [6, 1, 2, 3, 4, 5, -1]

배열 색인 의 비트 단위 보완 을 사용 하여 배열을 역순으로 단계별로 수행 할 수도 있습니다 .

>>> array = [0, 10, 20, 40]
>>> [array[~i] for i, _ in enumerate(array)]
[40, 20, 10, 0]

무엇을 하든지 이렇게하지 마십시오.

사용 목록 이해 :

[array[n] for n in range(len(array)-1, -1, -1)]

또 다른 해결책은 이것을 위해 numpy.flip 을 사용하는 것 입니다.

import numpy as np
array = [0, 10, 20, 40]
list(np.flip(array))
[40, 20, 10, 0]

엄밀히 말하면 문제는 목록을 반대로 반환하는 방법이 아니라 예제 list name으로 목록을 뒤집는 방법 array입니다.

라는 이름의 목록을 역으로 "array"사용 array.reverse().

설명 된 매우 유용한 슬라이스 방법을 사용하여을 사용하여 목록 자체를 슬라이스 수정으로 정의하여 목록을 반전시킬 수도 있습니다 array = array[::-1].

def reverse(text):
    output = []
    for i in range(len(text)-1, -1, -1):
        output.append(text[i])
    return output

인터뷰 설정을 가정 할 때 최소한의 내장 기능을 사용합니다.

array = [1, 2, 3, 4, 5, 6,7, 8]
inverse = [] #create container for inverse array
length = len(array)  #to iterate later, returns 8 
counter = length - 1  #because the 8th element is on position 7 (as python starts from 0)

for i in range(length): 
   inverse.append(array[counter])
   counter -= 1
print(inverse)

파이썬으로 요구 사항을 가장 직접적으로 번역하는 것은 다음 for과 같습니다.

for i in xrange(len(array) - 1, -1, -1):
   print i, array[i]

이것은 다소 비밀 스럽지만 유용 할 수 있습니다.

def reverse(my_list):
  L = len(my_list)
  for i in range(L/2):
    my_list[i], my_list[L-i - 1] = my_list[L-i-1], my_list[i]
  return my_list

리스트의 끝에서 스택 맨 위의 요소를 튀기기 만하면리스트를 스택처럼 취급 할 수 있습니다. 이렇게하면 스택의 최후의 특성을 활용할 수 있습니다. 물론 첫 번째 배열을 소비하고 있습니다. 이 방법은 하나의 목록이 백엔드에서 소비되고 다른 하나는 프론트 엔드에서 작성되는 것을 볼 수 있다는 점에서 매우 직관적입니다.

>>> l = [1,2,3,4,5,6]; nl=[]
>>> while l:
        nl.append(l.pop())  
>>> print nl
[6, 5, 4, 3, 2, 1]

list_data = [1,2,3,4,5]
l = len(list_data)
i=l+1
rev_data = []
while l>0:
  j=i-l
  l-=1
  rev_data.append(list_data[-j])
print "After Rev:- %s" %rev_data 

사용하다

print(reversed(list_name))

여기에 게으르게 사용하여 역 평가하는 방법 발전기를 :

def reverse(seq):
    for x in range(len(seq), -1, -1): #Iterate through a sequence starting from -1 and increasing by -1.
        yield seq[x] #Yield a value to the generator

이제 다음과 같이 반복하십시오.

for x in reverse([1, 2, 3]):
    print(x)

목록이 필요한 경우 :

l = list(reverse([1, 2, 3]))

반대 목록을 얻는 방법은 3 가지가 있습니다.

1. 슬라이싱 방법 1 : reversed_array = array[-1::-1]

2. 슬라이싱 방법 2 : reversed_array2 = array[::-1]

3. 내장 함수 사용 : reversed_array = array.reverse()

세 번째 함수는 실제로 목록 객체를 뒤집 었습니다. 즉, 원시 데이터의 사본이 유지되지 않습니다. 이전 버전을 유지하지 않으려는 경우이 방법이 좋습니다. 그러나 깨끗하고 역전 된 버전을 원한다면 해결책이 아닌 것 같습니다.

>>> l = [1, 2, 3, 4, 5]
>>> print(reduce(lambda acc, x: [x] + acc, l, []))
[5, 4, 3, 2, 1]