Hoe kan ik een lijst in Python omkeren?

Hoe kan ik het volgende doen in Python?

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

Ik heb de elementen van een array nodig, maar van het einde tot het begin.

Antwoord 1, autoriteit 100%

U kunt gebruik maken van de reversedfunctioneer hiervoor als:

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

Merk op dat reversed(...)geen lijst retourneert. U kunt een omgekeerde lijst krijgen met list(reversed(array)).

Antwoord 2, autoriteit 93%

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

Extended slice-syntaxis wordt goed uitgelegd in de Python What’s new Entry voor release 2.3.5

Op speciaal verzoek in een opmerking dit is de meest actuele slice-documentatie.

Antwoord 3, autoriteit 28%

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

Of

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

Antwoord 4, autoriteit 2%

Snijden gebruiken, b.v. Array = array [:: – 1], is een nette truc en zeer pythonic, maar een beetje obscuur voor nieuwelingen misschien. Met behulp van de methode Reverse () is een goede manier om in dagelijkse codering te gaan omdat het gemakkelijk leesbaar is.

Als u echter een lijst op hun plaats moet omkeren zoals in een interviewvraag, kunt u waarschijnlijk niet gebruiken ingebouwde methoden zoals deze. De interviewer zal kijken naar hoe u het probleem nadert in plaats van de diepte van Python-kennis, een algoritmische benadering is vereist. Het volgende voorbeeld, met behulp van een klassieke swap, is misschien een manier om het te doen: –

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]

Merk op dat dit niet werkt op tuples of stringsequenties, omdat snaren en tuples onveranderlijk zijn, d.w.z. u kunt ze niet instellen om elementen te veranderen.

5, Autoriteit 2%

Voor het omkeren van hetzelfde lijstgebruik:

array.reverse()

Om omgekeerde lijst toe te wijzen aan een ander lijstgebruik:

newArray = array[::-1] 

Antwoord 6

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

Antwoord 7

Met reverseden list:

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

Antwoord 8

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

Antwoord 9

Het gebruik van reversed(array) is waarschijnlijk de beste route.

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

Moet je begrijpen hoe je dit kunt implementeren zonder de ingebouwde reversedte gebruiken.

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

Dit zou O(N) tijd moeten kosten.

Antwoord 10

Als u de elementen van de omgekeerde lijst in een andere variabele wilt opslaan, kunt u revArray = array[::-1]of revArray = list(reversed(array)).

Maar de eerste variant is iets sneller:

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

Uitgang:

Time: 0.00489711761475 s
Time: 0.00609302520752 s

11

Een andere oplossing zou zijn om numpy.flip Hiervoor

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

12

Gebruik wat logica

Gebruik een oude schoollogica om te oefenen voor interviews.

Wisselnummers naar achteren. Met behulp van twee wijzers 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]

13

Gebruik Lijstbegrip:

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

14

Met minimale hoeveelheid ingebouwde functies, aannemende de instellingen van het interview

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)

15

Strikt genomen, de vraag is niet hoe een lijst in omgekeerde volgorde te retourneren, maar eerder hoe u een lijst met een lijst met een voorbeeldlijst wilt omkeren array.

Om een ​​lijst te achterhalen met de naam "array"Gebruik array.reverse().

De ongelooflijk bruikbare segmentmethode zoals beschreven kan ook worden gebruikt om een ​​lijst op zijn plaats te keren door de lijst te definiëren als een gesneden wijziging van zichzelf met array = array[::-1].

16

Waarden organiseren:

in Python, Lijsten ‘Bestelling ook kan worden gemanipuleerd met Sorteer, het organiseren van uw variabelen in numerieke / alfabetische volgorde:
Tijdelijk:

Afdrukken (gesorteerd (my_list))

permanent:

my_list.sort (), print (my_list)

U kunt sorteren met de vlag “Reverse = TRUE”:

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

zonder

te organiseren

Misschien wil u geen waarden sorteren, maar de waarden alleen omkeren. Dan kunnen we het zo doen:

print(list(reversed(my_list)))

**Getallen hebben voorrang op alfabet in volgorde van vermelding. De organisatie van de Python-waarden is geweldig.

Bewerken 1: een verkeerde moderator beweerde dat mijn antwoord een kopie was en heeft mijn oude bericht verwijderd.

Antwoord 17

De meest directe vertaling van uw vereiste in Python is deze for-instructie:

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

Dit is nogal cryptisch, maar kan nuttig zijn.

Antwoord 18

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

Antwoord 19

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

Antwoord 20

Je zou de lijst altijd kunnen behandelen als een stapel die gewoon de elementen van de bovenkant van de stapel van de achterkant van de lijst haalt. Op die manier profiteer je van de first in last out-kenmerken van een stapel. Natuurlijk consumeer je de 1e array. Ik hou van deze methode omdat het vrij intuïtief is omdat je ziet dat de ene lijst wordt gebruikt vanaf de achterkant, terwijl de andere wordt opgebouwd vanaf de voorkant.

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

Antwoord 21

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 

Antwoord 22

gebruik

print(reversed(list_name))

Antwoord 23

Er zijn 3 methoden om de omgekeerde lijst te krijgen:

1. Snijmethode 1: reversed_array = array[-1::-1]

2. Snijmethode 2:
   reversed_array2 = array[::-1]

3. De ingebouwde functie gebruiken: reversed_array = array.reverse()

De derde functie heeft het lijstobject in feite omgekeerd. Dat betekent dat er geen kopie van ongerepte gegevens wordt bijgehouden. Dit is een goede aanpak als u de oude versie niet wilt behouden. Maar lijkt geen oplossing te zijn als je de ongerepte en omgekeerde versie wilt.

Antwoord 24

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

Antwoord 25

Omkering ter plaatse door referenties van tegengestelde indices te wisselen:

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

Antwoord 26

Kan worden gedaan met __reverse__, wat een generator retourneert.

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

Antwoord 27

Omgekeerde gebruikersinvoerwaarden in één regelcode:

for i in input()[::-1]: print(i,end='')