Comment puis-je inverser une liste en Python?

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

la syntaxe étendue de slice est bien expliquée dans le Python Quoi de neuf pour la version 2.3.5

demande spéciale, dans un commentaire c'est le plus de la tranche actuelle de la documentation .

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

ou

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

pour dupliquer la liste:

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

ceci est d'inverser la liste en place:

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

je pense que la meilleure façon d'inverser une liste en Python est à faire:

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

Le travail est fait, et maintenant vous avez une liste inversée.

pour inverser la même Liste, utiliser:

array.reverse()

pour attribuer la liste inversée dans une autre liste utilisation:

newArray = array[::-1] 

utilisant le tranchage, p.ex. array = array [: -1], est un truc soigné et très pythonique, mais un peu obscur pour les débutants peut-être. L'utilisation de la méthode reverse () est une bonne façon d'aller dans le codage de jour en jour parce qu'il est facilement lisible.

Toutefois, si vous avez besoin d'inverser une liste en place comme dans une question d'entrevue, vous aurez probablement pas être capable d'utiliser des méthodes intégrées comme celles-ci. L'intervieweur examinera comment vous abordez le problème plutôt que la profondeur de Python connaissance, une approche algorithmique est nécessaire. L'exemple suivant, utilisant un swap classique, pourrait être une façon de le faire: -

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]

notez que cela ne fonctionnera pas sur les Tuples ou les séquences de cordes, parce que les cordes et les tuples sont immuables, c'est-à-dire que vous ne pouvez pas y écrire pour changer des éléments.

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

je trouve (contrairement à d'autres suggestions) que l.reverse() est de loin le moyen le plus rapide pour inverser une longue liste en Python 3 et 2. Je serais curieux de savoir si d'autres peuvent reproduire ces timings.

l[::-1] est probablement plus lent car il copie la liste avant de l'inverser. L'ajout de l'appel list() autour de l'itérateur fait par reversed(l) doit ajouter un peu de overhead. Bien sûr, si vous voulez une copie de la liste ou un itérateur ensuite utiliser ces méthodes, mais si vous voulez simplement inverser la liste alors l.reverse() semble être la voie la plus rapide.

fonctions

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 timings

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 timings

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

avec reversed et list :

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

voies possibles", 151920920"

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

en utilisant inversé(array) serait la meilleure route probable.

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

si vous avez besoin de comprendre comment pourrait mettre en œuvre ceci sans utiliser le construit dans 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

Ce qui devrait prendre en O(N) fois.

Si vous voulez stocker les éléments de la liste inversée dans une autre variable, vous pouvez utiliser revArray = array[::-1] ou revArray = list(reversed(array)) .

Mais la première variante est légèrement plus rapide:

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

sortie:

Time: 0.00489711761475 s
Time: 0.00609302520752 s

à proprement parler, la question n'est pas de savoir comment retourner une liste à l'envers, mais plutôt comment inverser une liste avec un exemple de nom de liste array .

pour inverser une liste appelée "array" utilisez array.reverse() .

la méthode incroyablement utile slice comme décrit peut également être utilisée pour inverser une liste en place en définissant la liste comme une modification découpée de lui-même en utilisant array = array[::-1] .

vous pouvez utiliser 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

use list understanding:

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

la traduction la plus directe de votre exigence en Python est cette "déclaration 151910920":

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

c'est assez énigmatique mais peut être utile.

utilisez la fonction inversé comme suit et l'imprimer

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

vous pouvez toujours traiter la liste comme une pile qui détache les éléments du haut de la pile à la fin de la liste. De cette façon, vous profitez de la première dans les dernières caractéristiques de sortie d'une pile. Bien sûr, vous consommez le 1er tableau. J'aime cette méthode en ce qu'elle est assez intuitive en ce qu'on voit une Liste être consommée à l'arrière tandis que l'autre est construite à l'avant.

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

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

print reverse('reversed')

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 

vous pouvez également utiliser le complément bitwise de l'index du tableau pour passer à travers le tableau à l'envers:

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

quoi que vous fassiez, ne le faites pas de cette façon.

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]
>>> print(reduce(lambda acc, x: [x] + acc, l, []))
[5, 4, 3, 2, 1]

VALEURS ORGANISATRICES:

en Python, l'ordre des listes aussi peut être manipulé avec trier , l'organisation de vos variables dans l'ordre numérique/alphabétique:

Temporairement:

print(sorted(my_list))

Permanent:

my_list.sort(), print(my_list)

vous pouvez trier avec le drapeau "reverse=True" :

print(sorted(my_list, reverse=True))

ou

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

SANS ORGANISATION

peut-être que vous ne voulez pas trier les valeurs, mais seulement inverser les valeurs. Alors nous pouvons le faire comme ceci:

print(list(reversed(my_list)))

** les Chiffres ont la priorité sur l'alphabet dans l'ordre. L'organisation des valeurs de Python est géniale.

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

inversion en place par commutation des références des indices opposés:

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

peut être fait en utilisant __reverse__ , qui renvoie un générateur.

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