Bagaimana saya bisa melakukan hal berikut dengan Python?

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

Saya perlu memiliki elemen array, tetapi dari awal hingga awal.

Anda dapat menggunakan reversedfungsi untuk ini sebagai:

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

Perhatikan bahwa reversed(...)tidak mengembalikan daftar. Anda bisa mendapatkan daftar terbalik menggunakan list(reversed(array)).

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

Sintaks slice yang diperluas dijelaskan dengan baik dalam Python Entri baru untuk rilis2.3.5

Dengan permintaan khusus dalam komentar, ini adalah dokumentasi slice terbaru .

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

Atau

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

Ini untuk menggandakan daftar:

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

Ini untuk membalik daftar di tempat:

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

Saya pikir cara terbaik untuk membalik daftar dengan Python adalah dengan melakukan:

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

Pekerjaan selesai, dan sekarang Anda memiliki daftar terbalik.

Untuk membalikkan daftar yang sama gunakan:

array.reverse()

Untuk menetapkan daftar terbalik ke dalam beberapa daftar lain gunakan:

newArray = array[::-1] 

Menggunakan slicing, misalnya array = array [:: - 1], adalah trik yang rapi dan sangat Pythonic, tetapi mungkin sedikit tidak jelas bagi pemula. Menggunakan metode reverse () adalah cara yang baik untuk melakukan pengkodean sehari-hari karena mudah dibaca.

Namun, jika Anda perlu membalik daftar di tempat seperti dalam pertanyaan wawancara, Anda kemungkinan tidak akan dapat menggunakan metode bawaan seperti ini. Pewawancara akan melihat bagaimana Anda mendekati masalah daripada kedalaman pengetahuan Python, diperlukan pendekatan algoritmik. Contoh berikut, menggunakan swap klasik, mungkin salah satu cara untuk melakukannya: -

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]

Perhatikan bahwa ini tidak akan berfungsi pada Tuple atau urutan string, karena string dan tuple tidak dapat diubah, yaitu, Anda tidak dapat menulis ke dalamnya untuk mengubah elemen.

Saya menemukan (bertentangan dengan beberapa saran lain) yang l.reverse()sejauh ini merupakan cara tercepat untuk membalik daftar panjang dengan Python 3 dan 2. Saya tertarik untuk mengetahui apakah orang lain dapat meniru timing ini.

l[::-1]mungkin lebih lambat karena menyalin daftar sebelum membalikkannya. Menambahkan list()panggilan di sekitar iterator yang dibuat oleh reversed(l)harus menambahkan beberapa overhead. Tentu saja jika Anda ingin salinan daftar atau iterator maka gunakan metode masing-masing, tetapi jika Anda ingin membalikkan daftar itu makal.reverse() tampaknya menjadi cara tercepat.

Fungsi

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

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

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

Daftar

l = list(range(1000000))

Python 3,5 timing

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

Pengaturan waktu Python 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

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

Menggunakan terbalik (array) akan menjadi rute terbaik.

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

Jika Anda perlu memahami bagaimana bisa menerapkan ini tanpa menggunakan bawaan 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

Ini akan membutuhkan waktu O (N).

Ringkasan Metode dengan Penjelasan dan Hasil Pengaturan Waktu

Ada beberapa jawaban yang baik, tetapi tersebar dan sebagian besar tidak menunjukkan perbedaan mendasar dari setiap pendekatan.

Secara keseluruhan, lebih baik menggunakan fungsi / metode bawaan untuk membalikkan, seperti halnya fungsi apa pun. Dalam hal ini, mereka kira-kira 2 sampai 8 kali lebih cepat pada daftar pendek (10 item), dan hingga ~ 300 + kali lebih cepat pada daftar panjang dibandingkan dengan cara pengindeksan yang dibuat secara manual. Ini masuk akal karena mereka memiliki para ahli yang membuat mereka, pengawasan, dan optimasi. Mereka juga kurang rentan terhadap cacat dan lebih cenderung menangani kasus tepi dan sudut.

Pertimbangkan juga apakah Anda ingin:

1. Membalikkan daftar yang ada di tempat
   • Solusi terbaik adalah object.reverse()metode
2. Buat iterator dari kebalikan dari daftar (karena Anda akan memberinya makan untuk for-loop, generator, dll.)
   • Solusi terbaik adalah reversed(object)yang menciptakan iterator
3. atau buat salinan lengkap yang ada dalam urutan terbalik
   • Solusi terbaik adalah menggunakan irisan dengan ukuran langkah -1: object[::-1]

Skrip Tes

Inilah awal skrip pengujian saya untuk metode yang dibahas. Masukkan semua potongan kode dalam jawaban ini bersama-sama untuk membuat skrip yang akan menjalankan semua cara yang berbeda untuk membalik daftar dan waktu masing-masing (output ditunjukkan pada bagian terakhir).

from timeit import timeit
from copy import copy

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

Metode 1: Membalikkan di tempat dengan obj.reverse ()

Jika tujuannya hanya untuk membalik urutan item dalam daftar yang ada, tanpa mengulanginya atau mendapatkan salinan untuk bekerja dengan, gunakan <list>.reverse() fungsi. Jalankan ini langsung pada objek daftar, dan urutan semua item akan dibalik:

Perhatikan bahwa yang berikut ini akan membalikkan variabel asli yang diberikan, meskipun itu juga mengembalikan daftar terbalik. yaitu Anda dapat membuat salinan dengan menggunakan output fungsi ini. Biasanya, Anda tidak akan membuat fungsi untuk ini, tetapi saya melakukannya untuk menggunakan kode waktu di akhir.

Kami akan menguji kinerja dua cara ini - pertama hanya membalikkan daftar di tempat (mengubah daftar asli), dan kemudian menyalin daftar dan membalikkannya sesudahnya.

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

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

Metode 2: Membalik daftar menggunakan irisan obj[::-1]

Metode pengiris indeks bawaan memungkinkan Anda membuat salinan bagian dari objek yang diindeks.

• Itu tidak mempengaruhi objek asli
• Itu membangun daftar lengkap, bukan iterator

Sintaks generik adalah: <object>[first_index:last_index:step]. Untuk mengeksploitasi slicing untuk membuat daftar terbalik sederhana, gunakan:<list>[::-1] . Ketika membiarkan opsi kosong, itu menetapkan mereka ke default dari elemen pertama dan terakhir objek (terbalik jika ukuran langkah negatif).

Pengindeksan memungkinkan seseorang untuk menggunakan angka negatif, yang dihitung dari akhir indeks objek mundur (yaitu -2 adalah item kedua ke terakhir). Ketika ukuran langkah negatif, itu akan mulai dengan item terakhir dan indeks mundur dengan jumlah itu. Ada beberapa logika awal-akhir yang terkait dengan ini yang telah dioptimalkan.

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

Metode 3: Membalik daftar dengan reversed(obj)fungsi iterator

Ada reversed(indexed_object)fungsi:

• Ini menciptakan iterator indeks terbalik, bukan daftar. Sangat bagus jika Anda memasukkannya ke loop untuk kinerja yang lebih baik pada daftar besar
• Ini menciptakan salinan dan tidak mempengaruhi objek asli

Uji dengan kedua iterator mentah, dan buat daftar dari iterator.

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

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

Metode 4: Daftar terbalik dengan pengindeksan Kustom / Manual

Seperti yang ditunjukkan oleh waktu, menciptakan metode pengindeksan Anda sendiri adalah ide yang buruk. Gunakan metode bawaan kecuali Anda perlu melakukan sesuatu yang benar-benar khusus.

Yang mengatakan, tidak ada penalti besar dengan ukuran daftar lebih kecil, tetapi ketika Anda meningkatkan hukuman menjadi luar biasa. Saya yakin kode saya di bawah ini dapat dioptimalkan, tetapi saya akan tetap menggunakan metode bawaan.

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

Pengaturan waktu setiap metode

Berikut ini adalah sisa skrip untuk menentukan waktu setiap metode pembalikan. Ini menunjukkan pembalikan di tempat dengan obj.reverse()dan menciptakan reversed(obj)iterator selalu yang tercepat, sementara menggunakan irisan adalah cara tercepat untuk membuat salinan.

Itu juga terbukti tidak mencoba menciptakan cara melakukannya sendiri kecuali Anda harus!

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

Hasil Pengaturan Waktu

Hasil menunjukkan bahwa penskalaan bekerja paling baik dengan metode bawaan yang paling cocok untuk tugas yang diberikan. Dengan kata lain, dengan meningkatnya jumlah elemen objek, metode bawaan mulai memiliki hasil kinerja yang jauh lebih unggul.

Anda juga lebih baik menggunakan metode bawaan terbaik yang secara langsung mencapai apa yang Anda butuhkan daripada merangkai semuanya. yaitu mengiris adalah yang terbaik jika Anda membutuhkan salinan daftar terbalik - itu lebih cepat daripada membuat daftar dari reversed()fungsi, dan lebih cepat daripada membuat salinan daftar dan kemudian melakukan di tempatobj.reverse() . Tetapi jika salah satu dari metode itu benar-benar yang Anda butuhkan, mereka lebih cepat, tetapi tidak pernah lebih dari dua kali lipat kecepatan. Sementara itu - kustom, metode manual dapat mengambil pesanan lebih besar, terutama dengan daftar yang sangat besar.

Untuk penskalaan, dengan daftar 1000 item, reversed(<list>)pemanggilan fungsi membutuhkan ~ 30 ms untuk mengatur iterator, pembalikan di tempat hanya membutuhkan ~ 55 ms, menggunakan metode slice membutuhkan ~ 210 ms untuk membuat salinan dari daftar yang dibalik sepenuhnya, tetapi metode manual tercepat yang saya buat mengambil ~ 8400 ms !!

Dengan 2 item dalam daftar:

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]

Dengan 10 item dalam daftar:

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]

Dan dengan 1000 item dalam daftar:

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

Jika Anda ingin menyimpan elemen daftar terbalik di beberapa variabel lain, maka Anda bisa menggunakan revArray = array[::-1]atau revArray = list(reversed(array)).

Tetapi varian pertama sedikit lebih cepat:

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

Keluaran:

Time: 0.00489711761475 s
Time: 0.00609302520752 s

NILAI PENGELOLAAN:

Dalam Python, urutan daftar juga dapat dimanipulasi dengan mengurutkan , mengatur variabel Anda dalam urutan numerik / alfabet:

Untuk sementara:

print(sorted(my_list))

Permanen:

my_list.sort(), print(my_list)

Anda dapat mengurutkan dengan flag "reverse = True" :

print(sorted(my_list, reverse=True))

atau

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

TANPA MENGORGANISASI

Mungkin Anda tidak ingin mengurutkan nilai, tetapi hanya membalikkan nilainya. Maka kita bisa melakukannya seperti ini:

print(list(reversed(my_list)))

** Angka memiliki prioritas di atas alfabet dalam urutan listing. Organisasi nilai-nilai Python mengagumkan.

Menggunakan beberapa logika

Menggunakan beberapa logika sekolah lama untuk berlatih wawancara.

Menukar angka dari depan ke belakang. Menggunakan dua petunjukindex[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]

Anda juga dapat menggunakan komplemen bitwise dari indeks array untuk melangkah melalui array secara terbalik:

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

Apa pun yang Anda lakukan, jangan lakukan seperti ini.

Gunakan pemahaman daftar:

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

Solusi lain adalah menggunakan numpy.flip untuk ini

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

Sebenarnya, pertanyaannya bukanlah bagaimana mengembalikan daftar secara terbalik, melainkan bagaimana membalik daftar dengan nama daftar contoh array.

Untuk membalikkan daftar bernama "array"use array.reverse().

Metode irisan yang sangat berguna seperti yang dijelaskan juga dapat digunakan untuk membalik daftar di tempat dengan mendefinisikan daftar sebagai modifikasi irisan itu sendiri menggunakan array = array[::-1].

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

Dengan jumlah minimum fungsi bawaan, dengan asumsi pengaturan wawancara itu

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)

Terjemahan paling langsung dari persyaratan Anda ke Python adalah forpernyataan ini :

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

Ini agak samar tetapi mungkin bermanfaat.

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

Anda selalu dapat memperlakukan daftar seperti tumpukan hanya dengan memunculkan elemen dari atas tumpukan dari bagian belakang daftar. Dengan begitu Anda memanfaatkan karakteristik tumpukan pertama yang terakhir keluar. Tentu saja Anda mengkonsumsi array 1. Saya suka metode ini karena cukup intuitif karena Anda melihat satu daftar dikonsumsi dari ujung belakang sementara yang lain dibangun dari ujung depan.

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

menggunakan

print(reversed(list_name))

Berikut cara untuk mengevaluasi kebalikan dari menggunakan generator :

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

Sekarang beralih melalui seperti ini:

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

Jika Anda membutuhkan daftar:

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

Ada 3 metode untuk mendapatkan daftar terbalik:

1. Metode Mengiris 1: reversed_array = array[-1::-1]

2. Metode Mengiris 2: reversed_array2 = array[::-1]

3. Menggunakan fungsi builtin: reversed_array = array.reverse()

Fungsi ketiga sebenarnya membalikkan objek daftar di tempat. Itu berarti tidak ada salinan data murni dipertahankan. Ini adalah pendekatan yang baik jika Anda tidak ingin mempertahankan versi yang lama. Tetapi sepertinya tidak menjadi solusi jika Anda menginginkan versi yang asli dan terbalik.

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