Cara menggunakan REVERSE pada Python

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 akhir hingga awal.

Anda dapat menggunakan fungsi reversed 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.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 pengiris, mis. 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 mungkin 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) bahwa 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 ia menyalin daftar sebelum membalikkannya. Menambahkan panggilan list() 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 hanya ingin membalikkan daftar maka l.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 reversed dan list :

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

Cara yang mungkin,

list1 = [3,4,3,545,6,4,34,243]

list1.reverse()

list1[::-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 menerapkan ini tanpa menggunakan reversed bawaan.

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 membutuhkan waktu O(N) waktu.

Jika Anda ingin menyimpan elemen daftar terbalik di beberapa variabel lain, maka Anda dapat 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

Gunakan pemahaman daftar:

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

NILAI PENGELOLAAN:

Dengan Python, urutan daftar juga dapat dimanipulasi dengan sort , 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 Python mengagumkan.

Anda dapat menggunakan reversed()

array=[0,10,20,40]

for e in reversed(array):
  print e

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

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

Untuk membalik daftar bernama "array" gunakan array.reverse().

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

Anda juga dapat menggunakan bitwise melengkapi 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.

Terjemahan paling langsung dari persyaratan Anda ke Python adalah pernyataan for ini:

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

Ini agak samar tetapi mungkin bermanfaat.

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

print reverse('reversed')

Gunakan fungsi terbalik sebagai ikuti dan cetak

>>> for element in reversed(your_array):
...     print element

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 

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

Menggunakan beberapa logika

Menggunakan beberapa logika sekolah lama untuk berlatih wawancara.

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

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

Membalikkan di tempat dengan mengalihkan referensi dari indeks yang berlawanan:

>>> l = [1,2,3,4,5,6,7]    
>>> for i in range(len(l)//2):
...     l[i], l[-1-i] = l[-1-i], l[i]
...
>>> l
[7, 6, 5, 4, 3, 2, 1]

Dapat dilakukan menggunakan __reverse__, yang mengembalikan generator.

>>> l = [1,2,3,4,5]
>>> for i in l.__reversed__():
...   print i
... 
5
4
3
2
1
>>>

>>> L = [1, 2, 3, 4]
>>> L = [L[-i] for i in range(1, len(L) + 1)]
>>> L
[4, 3, 2, 1]

Apakah kegunaan dari fungsi reverse?

Apa itu append pada python?

Apa itu array di Python?