Comment puis-je inverser une liste en Python?
Comment puis-je effectuer les opérations suivantes en Python?
array = [0, 10, 20, 40]
for (i = array.length() - 1; i >= 0; i--)
J'ai besoin d'avoir les éléments d'un tableau, mais de la fin au début.
Vous pouvez utiliser la fonction reversed comme ceci:
>>> array=[0,10,20,40]
>>> for i in reversed(array):
... print(i)
Notez que reversed(...) ne renvoie pas de liste. Vous pouvez obtenir une liste inversée en utilisant list(reversed(array)).
>>> L = [0,10,20,40]
>>> L[::-1]
[40, 20, 10, 0]
La syntaxe de tranche étendue est bien expliquée dans le Python Nouvelle entrée pour la version 2.3.5
Par demande spéciale dans un commentaire il s'agit de la documentation de tranche la plus récente .
>>> L = [0,10,20,40]
>>> L.reverse()
>>> L
[40, 20, 10, 0]
Ou
>>> L[::-1]
[40, 20, 10, 0]
Ceci est pour dupliquer la liste:
L = [0,10,20,40]
p = L[::-1] # Here p will be having reversed list
Ceci est pour inverser la liste en place:
L.reverse() # Here L will be reversed in-place (no new list made)
Je pense que le meilleur moyen de renverser une liste dans Python est de faire:
a = [1,2,3,4]
a = a[::-1]
print(a)
>>> [4,3,2,1]
Le travail est terminé et vous avez maintenant une liste inversée.
Pour inverser la même liste, utilisez:
array.reverse()
Pour assigner une liste inversée à une autre liste, utilisez:
newArray = array[::-1]
Utilisation de la découpe, par exemple array = array [:: - 1], est une astuce soignée et très pythonique, mais peut-être un peu obscure pour les débutants. L'utilisation de la méthode reverse () est un bon moyen de coder au jour le jour, car elle est facilement lisible.
Toutefois, si vous devez inverser une liste en place comme dans une question d’entrevue, vous ne pourrez probablement pas utiliser de méthodes intégrées telles que celles-ci. L'intervieweur examinera la façon dont vous abordez le problème plutôt que la profondeur de la connaissancePython, une approche algorithmique est nécessaire. L’exemple suivant, qui utilise un échange classique, pourrait constituer un moyen 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 nuplets ou les séquences de chaînes, car les chaînes et les nuplets sont immuables, c’est-à-dire que vous ne pouvez pas y écrire pour modifier des éléments.
Je trouve (contrairement à d'autres suggestions) que l.reverse() est de loin le moyen le plus rapide d'inverser une longue liste dans Python 3 et 2. J'aimerais savoir si d'autres personnes peuvent les reproduire. les horaires.
l[::-1] est probablement plus lent car il copie la liste avant de l'inverser. Ajouter l'appel list() autour de l'itérateur effectué par reversed(l) doit ajouter une surcharge. Bien sûr, si vous voulez une copie de la liste ou un itérateur, utilisez ces méthodes respectives, mais si vous voulez simplement inverser la liste, alors l.reverse() semble être le moyen le plus rapide.
Les 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
Timings 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
Façons possibles,
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
Utiliser Reverse (array) serait probablement le meilleur itinéraire.
>>> array = [1,2,3,4]
>>> for item in reversed(array):
>>> print item
Si vous avez besoin de comprendre comment implémenter ceci sans utiliser le reversed intégré.
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
Cela devrait prendre O(N) temps.
Si vous souhaitez 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
VALEURS ORGANISATRICES:
En Python, l’ordre des listes peut aussi être manipulé avec sort, en organisant 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 ORGANISER
Peut-être que vous ne voulez pas trier les valeurs, mais seulement les inverser. Ensuite, nous pouvons le faire comme ceci:
print(list(reversed(my_list)))
** Les numéros ont la priorité sur l'alphabet dans l'ordre de la liste. L'organisation Python values est géniale.
Utiliser la compréhension de la liste:
[array[n] for n in range(len(array)-1, -1, -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
Strictement parlant, la question n'est pas de savoir comment renvoyer une liste dans l'ordre inverse, mais plutôt comment inverser une liste avec un exemple de nom de liste array.
Pour inverser une liste nommée "array", utilisez array.reverse().
La méthode slice extrêmement utile décrite peut également être utilisée pour inverser une liste à la place en la définissant comme une modification en tranches de lui-même à l'aide de array = array[::-1].
Vous pouvez également utiliser le complément au niveau du bit de l'index du tableau pour parcourir le tableau en sens inverse:
>>> 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.
La traduction la plus directe de vos besoins en Python est cette instruction for:
for i in xrange(len(array) - 1, -1, -1):
print i, array[i]
C'est plutôt cryptique mais peut être utile.
Utilisation de la logique
Utiliser une certaine logique de la vieille école pour pratiquer pour des entretiens.
Échanger les numéros d'avant en arrière. Utilisation de deux pointeurs
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
Utilisez la fonction inversée comme suit et imprimez-la
>>> for element in reversed(your_array):
... print element
Vous pouvez toujours traiter la liste comme une pile, extrayant les éléments du haut de la pile à partir du fond de la liste. De cette façon, vous tirez parti des caractéristiques de pile d'une pile premier entré dernier sorti. Bien sûr, vous consommez le premier tableau. J'aime cette méthode dans la mesure où elle est assez intuitive en ce sens qu'une liste est consommée depuis le back-end, tandis que l'autre est construite depuis le front-end.
>>> l = [1,2,3,4,5,6]; nl=[]
>>> while l:
nl.append(l.pop())
>>> print nl
[6, 5, 4, 3, 2, 1]
Inverser sur place en inversant les 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]
def reverse(text):
lst=[]
for i in range(0,len(text)):
lst.append(text[(len(text)-1)-i])
return ''.join(lst)
print reverse('reversed')
utilisation
print(reversed(list_name))
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
Avec un minimum de fonctions intégrées, en supposant que ses paramètres d'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)
>>> l = [1, 2, 3, 4, 5]
>>> print(reduce(lambda acc, x: [x] + acc, l, []))
[5, 4, 3, 2, 1]
Peut être fait en utilisant __reverse__, qui retourne un générateur.
>>> 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]