Python'da aşağıdakileri nasıl yapabilirim?

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

Ben bir dizi unsurları olması gerekir, ama başından sonuna kadar.

Bunun için reversedişlevi aşağıdaki gibi kullanabilirsiniz:

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

reversed(...)Bir liste döndürmediğini unutmayın . Düğmesini kullanarak ters çevrilmiş bir liste alabilirsiniz list(reversed(array)).

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

Genişletilmiş dilim sözdizimi Python'un Yenilikler için yeni girişi2.3.5

Bir yorumdaki özel istek üzerine , bu en güncel dilim belgeleridir .

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

Veya

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

Bu listeyi çoğaltmak içindir:

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

Bu, listeyi yerinde tersine çevirmek içindir:

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

Python bir liste tersine çevirmek için en iyi yolu yapmak olduğunu düşünüyorum:

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

İş bitti ve şimdi bir ters listeniz var.

Aynı listeyi ters çevirmek için şunu kullanın:

array.reverse()

Ters çevrilmiş listeyi başka bir listeye atamak için şunu kullanın:

newArray = array[::-1] 

Dilimleme kullanmak, örneğin dizi = dizi [:: - 1], düzgün bir hile ve çok Pythonic, ancak yeni başlayanlar için biraz belirsiz. Reverse () yöntemini kullanmak, kolayca okunabildiğinden günlük kodlamaya gitmek için iyi bir yoldur.

Ancak, bir röportaj sorusundaki gibi bir listeyi tersine çevirmeniz gerekirse, büyük olasılıkla bunun gibi yerleşik yöntemleri kullanamayacaksınız. Görüşmeci, Python bilgisinin derinliği yerine soruna nasıl yaklaştığınıza bakacak, algoritmik bir yaklaşım gerekli. Aşağıdaki örnek, klasik bir takas kullanarak, bunu yapmanın bir yolu olabilir: -

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]

Bunun, Tuples veya dize dizileri üzerinde çalışmayacağını unutmayın, çünkü dize ve tupller değiştirilemez, yani öğeleri değiştirmek için bunlara yazamazsınız.

l.reverse()Python 3 ve 2'de uzun bir listeyi tersine çevirmenin en hızlı yolu (diğer bazı önerilerin aksine) buluyorum .

l[::-1]muhtemelen daha yavaştır, çünkü listeyi tersine çevirmeden önce kopyalar. Ekleme list()yapılan yineleyici etrafında çağrıyı reversed(l)bazı yükü eklemelisiniz. Elbette listenin bir kopyasını veya yineleyiciyi istiyorsanız ilgili yöntemleri kullanın, ancak listeyi tersine çevirmek istiyorsanız l.reverse()en hızlı yol gibi görünüyor.

Fonksiyonlar

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

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

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

Liste

l = list(range(1000000))

Python 3.5 zamanlamaları

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

Python 2.7 zamanlamaları

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

İle reversedve 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

Tersine çevrilmiş (dizi) kullanmak olası en iyi yoldur.

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

Yerleşik kullanmadan bunu nasıl uygulayabileceğinizi anlamanız gerekiyorsa 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

Bu O (N) zaman almalıdır.

Açıklama ve Zamanlama Sonuçları ile Yöntemlerin Özeti

Birkaç iyi cevap var, ama yayıldı ve çoğu her yaklaşımın temel farklılıklarını göstermiyor.

Genel olarak, hemen hemen her işlevde olduğu gibi tersine çevirmek için yerleşik işlevleri / yöntemleri kullanmak daha iyidir. Bu durumda, kısa listelerde (10 öğe) kabaca 2 ila 8 kat, manuel olarak oluşturulan bir indeksleme aracına kıyasla uzun listelerde ~ 300 + kat daha hızlıdır. Bu, onları yaratan, inceleyen ve optimizasyon yapan uzmanlara sahip oldukları için mantıklıdır. Ayrıca kusurlara daha az eğilimlidirler ve kenar ve köşe kasalarını ele alma olasılıkları daha yüksektir.

Ayrıca şunları yapmak isteyip istemediğinizi de düşünün:

1. Mevcut bir listeyi yerinde ters çevirme
   • En iyi çözüm object.reverse()yöntemdir
2. Listenin tersinin bir yineleyicisi oluşturun (çünkü for döngüye, jeneratöre vb. Besleyeceksiniz)
   • En iyi çözüm, reversed(object)yineleyici oluşturur
3. veya tam tersi sırada olan tam bir kopyasını oluşturabilirsiniz
   • En iyi çözüm -1 adım büyüklüğünde dilimleri kullanmaktır: object[::-1]

Test Betiği

İşte kapsanan yöntemler için test betiğimin başlangıcı. Bir liste ve zamanı tersine çevirmenin tüm farklı yollarını çalıştıracak bir komut dosyası oluşturmak için tüm kod snippet'lerini bir araya getirin (son bölümde gösterilen çıktı).

from timeit import timeit
from copy import copy

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

Yöntem 1: obj.reverse () ile yerinde tersine çevirme

Hedef, varolan bir listedeki öğelerin sırasını tersine çevirmekse, bunlar üzerinde döngü oluşturmadan veya üzerinde çalışmak için bir kopya almadan, <list>.reverse()işlevi kullanın . Bunu doğrudan bir liste nesnesinde çalıştırın, tüm öğelerin sırası tersine çevrilecektir:

Aşağıdakilerin, ters listeyi geri döndürmesine rağmen verilen orijinal değişkeni tersine çevireceğini unutmayın. yani bu işlev çıktısını kullanarak bir kopya oluşturabilirsiniz. Genellikle, bunun için bir işlev yapmak olmaz, ama sonunda zamanlama kodunu kullanmak için yaptım.

Bu iki yolun performansını test edeceğiz - önce bir listeyi yerinde tersine çevirmek (orijinal listeyi değiştirir) ve ardından listeyi kopyalayıp daha sonra tersine çevirmek.

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

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

Yöntem 2: Dilimleri kullanarak bir listeyi tersine çevirme obj[::-1]

Yerleşik dizin dilimleme yöntemi, dizinlenmiş herhangi bir nesnenin bir bölümünün kopyasını oluşturmanıza olanak tanır.

• Orijinal nesneyi etkilemez
• Yineleyici değil, tam bir liste oluşturur

Jenerik sözdizimi: <object>[first_index:last_index:step]. Basit bir ters listesi kullanımını oluşturmak için dilimleme yararlanabilmesi için: <list>[::-1]. Bir seçeneği boş bırakırken, bunları nesnenin ilk ve son öğesinin varsayılanlarına ayarlar (adım boyutu negatifse tersine çevrilir).

Endeksleme, nesnenin endeksinin sonundan geriye doğru sayılan negatif sayılar kullanmasına izin verir (yani -2, sondan ikinci öğeye kadardır). Adım boyutu negatif olduğunda, son öğeyle başlar ve bu miktarla geriye doğru dizine eklenir. Bununla ilişkili optimize edilmiş bazı başlangıç-bitiş mantığı vardır.

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

Yöntem 3: reversed(obj)Yineleyici işleviyle bir listeyi tersine çevirme

Bir reversed(indexed_object)fonksiyon var:

• Bu bir liste değil, ters bir dizin yineleyici oluşturur. Büyük listelerde daha iyi performans için bir döngüye besliyorsanız harika
• Bu bir kopya oluşturur ve orijinal nesneyi etkilemez

Hem ham yineleyici ile hem de yineleyiciden bir liste oluşturarak test edin.

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

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

Yöntem 4: Özel / Manuel dizinleme ile ters liste

Zamanlamanın göstereceği gibi, kendi indeksleme yöntemlerinizi oluşturmak kötü bir fikirdir. Gerçekten özel bir şey yapmanız gerekmediği sürece yerleşik yöntemleri kullanın.

Bununla birlikte, daha küçük liste boyutlarına sahip büyük bir ceza yoktur, ancak ölçeklendirdiğinizde ceza muazzam hale gelir. Eminim aşağıdaki kodum optimize edilebilir, ama yerleşik yöntemlere sadık kalacağım.

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

Her yöntemin zamanlaması

Her bir tersine çevirme yöntemini zamanlamak için komut dosyasının geri kalanı aşağıdadır. Yerinde tersine çevirme obj.reverse()ve reversed(obj)yineleyici oluşturma her zaman en hızlı olduğunu gösterirken, dilimleri kullanmak bir kopya oluşturmanın en hızlı yoludur.

Ayrıca, gerekmedikçe kendi başınıza yapmanın bir yolunu yaratmamaya da kanıt değildir!

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))

Zamanlama Sonuçları

Sonuçlar, ölçeklendirmenin belirli bir görev için en uygun yerleşik yöntemlerle en iyi sonucu verdiğini göstermektedir. Başka bir deyişle, nesne öğesi sayısı arttıkça, yerleşik yöntemler çok daha üstün performans sonuçları elde etmeye başlar.

Ayrıca, ihtiyacınız olan şeyleri doğrudan bir araya getirmekten daha fazlasını sağlayan en iyi yerleşik yöntemi kullanmaktan daha iyi olursunuz. örn. dilimleme, ters listenin bir kopyasına ihtiyacınız varsa en iyisidir - reversed()işlevden bir liste oluşturmaktan daha hızlı ve listenin bir kopyasını oluşturup daha sonra yerinde yapmaktan daha hızlıdır obj.reverse(). Ancak bu yöntemlerden herhangi biri gerçekten ihtiyacınız olduğunda, daha hızlıdırlar, ancak asla hızın iki katından fazla olamazlar. Bu arada - özel, manuel yöntemler, özellikle çok büyük listelerde büyüklük siparişlerini daha uzun sürebilir.

Ölçekleme için, 1000 öğe listesiyle reversed(<list>)işlev çağrısı yineleyiciyi ayarlamak için ~ 30 ms sürer, yerinde geri döndürme sadece ~ 55 ms sürer, dilim yöntemini kullanarak tam ters çevrilmiş listenin bir kopyasını oluşturmak için ~ 210 ms sürer, ancak yaptığım en hızlı manuel yöntem ~ 8400 ms sürdü !!

Listede 2 öğe ile:

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]

Listede 10 öğe ile:

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]

Ve listedeki 1000 ürünle:

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

Tersine çevrilmiş liste öğelerini başka bir değişkende saklamak istiyorsanız, revArray = array[::-1]veya öğesini kullanabilirsiniz revArray = list(reversed(array)).

Ancak ilk varyant biraz daha hızlı:

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))

Çıktı:

Time: 0.00489711761475 s
Time: 0.00609302520752 s

DÜZENLEME DEĞERLERİ:

Python'da, listelerin sırası da değişkenlerle sayısal / alfabetik sırayla düzenlenerek sıralama ile değiştirilebilir :

Geçici:

print(sorted(my_list))

Kalıcı:

my_list.sort(), print(my_list)

"Reverse = True" bayrağıyla sıralayabilirsiniz :

print(sorted(my_list, reverse=True))

veya

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

ORGANİZASYON OLMADAN

Belki değerleri sıralamak istemezsiniz, sadece değerleri tersine çevirirsiniz. O zaman böyle yapabiliriz:

print(list(reversed(my_list)))

** Sayılar, listeleme sırasında alfabeye göre önceliklidir. Python değerlerinin organizasyonu harika.

Bazı mantık kullanma

Röportaj yapmak için bazı eski okul mantığını kullanmak.

Numaraları önden arkaya değiştirme. İki işaretçi kullanmaindex[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]

Diziyi tersine çevirmek için dizi dizininin bitsel tamamlayıcısını da kullanabilirsiniz :

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

Ne yaparsan yap, böyle yapma.

Liste kavrayışı kullanın:

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

Başka bir çözüm kullanmak olacaktır numpy.flip bunun için

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

Açıkçası, soru bir listenin tersine nasıl döndürüleceği değil, örnek liste adına sahip bir listenin nasıl tersine çevrileceği array.

Use adlı bir listeyi tersine çevirmek "array"için array.reverse().

Açıklandığı gibi inanılmaz derecede faydalı dilim yöntemi, listeyi kullanarak kendi dilimli bir modifikasyonu olarak tanımlayarak yerinde bir listeyi tersine çevirmek için de kullanılabilir array = array[::-1].

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

Minimum miktarda yerleşik işlevle, röportaj ayarlarını varsayarak

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)

İhtiyacınızın Python'a en doğrudan çevirisi şu forifadedir:

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

Bu oldukça şifreli ama faydalı olabilir.

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

Listeye her zaman yığının üstündeki öğeleri listenin arka ucundan atmak gibi bir yığın gibi davranabilirsiniz. Bu şekilde bir yığının ilk giren son çıkan özelliklerinden faydalanırsınız. Tabii ki 1. diziyi tüketiyorsunuz. Bu yöntemi beğendim, çünkü bir listenin arka uçtan tüketildiğini, diğerinin ön uçtan inşa edildiğini görmeniz oldukça sezgisel.

>>> 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 

kullanım

print(reversed(list_name))

İşte bir jeneratör kullanarak tersini tembel olarak değerlendirmenin bir yolu :

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

Şimdi şöyle tekrarlayın:

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

Bir listeye ihtiyacınız varsa:

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

Ters çevrilmiş listeyi almanın 3 yöntemi vardır:

1. Dilimleme Yöntemi 1: reversed_array = array[-1::-1]

2. Dilimleme Yöntemi 2: reversed_array2 = array[::-1]

3. Yerleşik işlevi kullanma: reversed_array = array.reverse()

Üçüncü işlev, aslında liste nesnesini tersine çevirdi. Bu, bozulmamış verilerin hiçbir kopyasının tutulmadığı anlamına gelir. Eski sürümü korumak istemiyorsanız bu iyi bir yaklaşımdır. Eğer bozulmamış ve ters sürümü istiyorsanız Ama bir çözüm gibi görünmüyor.

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