¿Cómo puedo hacer lo siguiente en Python?

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

Necesito tener los elementos de una matriz, pero desde el final hasta el principio.

Puede utilizar la reversedfunción para esto como:

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

Tenga en cuenta que reversed(...)no devuelve una lista. Puede obtener una lista invertida usando list(reversed(array)).

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

La sintaxis extendida de la porción se explica bien en la entrada de Novedades de Python para su lanzamiento2.3.5

Por pedido especial en un comentario, esta es la documentación de corte más actualizada .

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

O

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

Esto es para duplicar la lista:

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

Esto es para revertir la lista en el lugar:

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

Creo que la mejor manera de revertir una lista en Python es hacer:

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

El trabajo está hecho, y ahora tienes una lista invertida.

Para invertir la misma lista use:

array.reverse()

Para asignar una lista invertida a otra lista, use:

newArray = array[::-1] 

El uso de segmentación, por ejemplo, array = array [:: - 1], es un buen truco y muy pitónico, pero quizás un poco oscuro para los novatos. Usar el método reverse () es una buena manera de ir en la codificación del día a día porque es fácil de leer.

Sin embargo, si necesita revertir una lista en el lugar como en una pregunta de entrevista, es probable que no pueda utilizar métodos integrados como estos. El entrevistador observará cómo aborda el problema en lugar de la profundidad del conocimiento de Python, se requiere un enfoque algorítmico. El siguiente ejemplo, utilizando un intercambio clásico, podría ser una forma de hacerlo:

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]

Tenga en cuenta que esto no funcionará en Tuplas o secuencias de cadenas, porque las cadenas y las tuplas son inmutables, es decir, no puede escribir en ellas para cambiar elementos.

Creo que (al contrario de algunas otras sugerencias) l.reverse()es, con mucho, la forma más rápida de revertir una larga lista en Python 3 y 2. Me interesaría saber si otros pueden replicar estos tiempos.

l[::-1]es probablemente más lento porque copia la lista antes de revertirla. Agregar la list()llamada alrededor del iterador realizado por reversed(l)debe agregar algunos gastos generales. Por supuesto, si desea una copia de la lista o un iterador, use esos métodos respectivos, pero si desea simplemente revertir la lista, entonces l.reverse()parece ser la forma más rápida.

Las funciones

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

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

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

Lista

l = list(range(1000000))

Python 3.5 tiempos

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 tiempos

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

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

El uso de invertido (matriz) sería probablemente la mejor ruta.

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

Si necesita comprender cómo podría implementar esto sin utilizar el incorporado 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

Esto debería llevar tiempo O (N).

Resumen de métodos con explicación y resultados de tiempo

Hay varias buenas respuestas, pero dispersas y la mayoría no indican las diferencias fundamentales de cada enfoque.

En general, es mejor usar funciones / métodos integrados para revertir, como con casi cualquier función. En este caso, son aproximadamente de 2 a 8 veces más rápidos en listas cortas (10 elementos) y hasta ~ 300 + veces más rápido en listas largas en comparación con un medio de indexación creado manualmente. Esto tiene sentido ya que tienen expertos que los crean, el escrutinio y la optimización. También son menos propensos a defectos y más propensos a manejar casos de bordes y esquinas.

Considere también si desea:

1. Invertir una lista existente en el lugar
   • La mejor solución es el object.reverse()método.
2. Cree un iterador del reverso de la lista (porque lo va a alimentar a un ciclo for, un generador, etc.)
   • La mejor solución es la reversed(object)que crea el iterador
3. o cree una copia completa que esté en el orden inverso
   • La mejor solución es usar rebanadas con un tamaño de paso de -1: object[::-1]

Script de prueba

Aquí está el comienzo de mi script de prueba para los métodos cubiertos. Ponga todos los fragmentos de código en esta respuesta para crear un script que ejecute todas las diferentes formas de invertir una lista y el tiempo de cada una (el resultado se muestra en la última sección).

from timeit import timeit
from copy import copy

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

Método 1: Invierta en su lugar con obj.reverse ()

Si el objetivo es simplemente invertir el orden de los elementos en una lista existente, sin recorrerlos ni obtener una copia para trabajar, use el <list>.reverse() función Ejecute esto directamente en un objeto de lista, y el orden de todos los elementos se invertirá:

Tenga en cuenta que lo siguiente revertirá la variable original que se proporciona, aunque también devuelve la lista revertida. es decir, puede crear una copia utilizando esta función de salida. Por lo general, no haría una función para esto, pero lo hice para usar el código de sincronización al final.

Probaremos el rendimiento de estas dos formas: primero simplemente invirtiendo una lista en el lugar (cambia la lista original), y luego copiando la lista y luego invirtiéndola.

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

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

Método 2: Invierta una lista usando rebanadas obj[::-1]

El método de división de índice incorporado le permite hacer una copia de parte de cualquier objeto indexado.

• No afecta el objeto original.
• Construye una lista completa, no un iterador

La sintaxis genérica es: <object>[first_index:last_index:step]. Para explotar rebanar para crear una sencilla lista invertida, utilice: <list>[::-1]. Al dejar una opción vacía, los establece en los valores predeterminados del primer y último elemento del objeto (se invierte si el tamaño del paso es negativo).

La indexación permite utilizar números negativos, que cuentan desde el final del índice del objeto hacia atrás (es decir, -2 es el penúltimo elemento). Cuando el tamaño del paso es negativo, comenzará con el último elemento e indexará hacia atrás en esa cantidad. Hay cierta lógica de inicio y fin asociada con esto que se ha optimizado.

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

Método 3: Invierta una lista con la reversed(obj)función iteradora

Hay una reversed(indexed_object)función:

• Esto crea un iterador de índice inverso, no una lista. Excelente si lo está alimentando a un bucle para un mejor rendimiento en listas grandes
• Esto crea una copia y no afecta el objeto original.

Pruebe con un iterador sin formato y creando una lista desde el iterador.

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

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

Método 4: Lista inversa con indexación personalizada / manual

Como mostrará el momento, crear sus propios métodos de indexación es una mala idea. Utilice los métodos integrados a menos que necesite hacer algo realmente personalizado.

Dicho esto, no hay una penalización enorme con tamaños de lista más pequeños, pero cuando se amplía la penalización se vuelve tremenda. Estoy seguro de que mi código a continuación podría optimizarse, pero seguiré con los métodos integrados.

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

Momento de cada método

A continuación se muestra el resto del guión para cronometrar cada método de inversión. Muestra marcha atrás en su lugar obj.reverse()y crea elreversed(obj) iterador son siempre las más rápidas, mientras que el uso de sectores es la forma más rápida de crear una copia.

¡También demuestra que no debe intentar crear una forma de hacerlo por su cuenta a menos que tenga que hacerlo!

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

Resultados de tiempo

Los resultados muestran que el escalado funciona mejor con los métodos integrados más adecuados para una tarea determinada. En otras palabras, a medida que aumenta el recuento de elementos del objeto, los métodos integrados comienzan a tener resultados de rendimiento muy superiores.

También es mejor usar el mejor método incorporado que logra directamente lo que necesita que unir las cosas. es decir, el corte es mejor si necesita una copia de la lista invertida: es más rápido que crear una lista desde la reversed()función, y más rápido que hacer una copia de la lista y luego hacer un in situ obj.reverse(). Pero si alguno de esos métodos es realmente todo lo que necesita, son más rápidos, pero nunca más del doble de la velocidad. Mientras tanto, los métodos manuales personalizados pueden llevar órdenes de magnitud más largas, especialmente con listas muy grandes.

Para el escalado, con una lista de 1000 elementos, la reversed(<list>)llamada a la función tarda ~ 30 ms para configurar el iterador, la inversión en el lugar tarda solo ~ 55 ms, el uso del método de división demora ~ 210 ms para crear una copia de la lista inversa completa, pero ¡El método manual más rápido que hice tomó ~ 8400 ms!

Con 2 artículos en la lista:

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]

Con 10 artículos en la lista:

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]

Y con 1000 artículos en la lista:

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

Si desea almacenar los elementos de la lista invertida en alguna otra variable, puede usar revArray = array[::-1]o revArray = list(reversed(array)).

Pero la primera variante es un poco más rápida:

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

Salida:

Time: 0.00489711761475 s
Time: 0.00609302520752 s

VALORES ORGANIZADORES:

En Python, el orden de las listas también se puede manipular ordenando , organizando sus variables en orden numérico / alfabético:

Temporalmente:

print(sorted(my_list))

Permanente:

my_list.sort(), print(my_list)

Puede ordenar con la bandera "reverse = True" :

print(sorted(my_list, reverse=True))

o

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

SIN ORGANIZAR

Tal vez no desee ordenar los valores, sino que solo invierta los valores. Entonces podemos hacerlo así:

print(list(reversed(my_list)))

** Los números tienen prioridad sobre el alfabeto en el orden de inclusión. La organización de los valores de Python es asombrosa.

Usando algo de lógica

Usando la lógica de la vieja escuela para practicar para entrevistas.

Intercambiando números de adelante hacia atrás. Usando dos punterosindex[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]

También puede usar el complemento bit a bit del índice de matriz para recorrer la matriz a la inversa:

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

Hagas lo que hagas, no lo hagas de esta manera.

Usar la comprensión de la lista:

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

Otra solución sería usar numpy.flip para esto

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

Hablando estrictamente, la pregunta no es cómo devolver una lista en reversa sino cómo revertir una lista con un nombre de lista de ejemplo array.

Para revertir una lista llamada "array"use array.reverse().

El método de corte increíblemente útil como se describe también se puede usar para revertir una lista en su lugar definiendo la lista como una modificación en rodajas de sí misma usando array = array[::-1] .

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

Con una cantidad mínima de funciones incorporadas, suponiendo que sea la configuración de la entrevista

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)

La traducción más directa de su requerimiento a Python es esta fordeclaración:

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

Esto es bastante críptico pero puede ser útil.

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

Siempre puede tratar la lista como una pila simplemente sacando los elementos de la parte superior de la pila desde el final de la lista. De esta forma, aprovecha las características de primero en último lugar de una pila. Por supuesto que estás consumiendo la primera matriz. Me gusta este método porque es bastante intuitivo porque ves que una lista se consume desde el back-end mientras que la otra se construye desde el front-end.

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

utilizar

print(reversed(list_name))

Aquí hay una manera de evaluar perezosamente el reverso usando un generador :

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

Ahora repita de esta manera:

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

Si necesitas una lista:

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

Hay 3 métodos para obtener la lista invertida:

1. Método de corte 1: reversed_array = array[-1::-1]

2. Método de corte 2: reversed_array2 = array[::-1]

3. Usando la función incorporada: reversed_array = array.reverse()

La tercera función realmente invirtió el objeto de la lista en su lugar. Eso significa que no se mantiene una copia de los datos prístinos. Este es un buen enfoque si no desea mantener la versión anterior. Pero no parece ser una solución si quieres la versión original e inversa.

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