Python: ¿Buscando el último índice del elemento min?

Por ejemplo [1,2,3,4,1,2]

tiene el elemento min 1, pero ocurre por última vez en el índice 4.

a = [1,2,3,4,1,2] a.reverse() print len(a) - a.index(min(a)) - 1 

Actualizar después de comentar:

El efecto secundario puede eliminarse revirtiendo nuevamente (pero, por supuesto, eso es bastante ineficiente).

 a.reverse() 
 >>> values = [1,2,3,4,1,2] >>> -min((x, -i) for i, x in enumerate(values))[1] 4 

Ninguna modificación a la lista original, funciona para iterables arbitrarios, y solo requiere una pasada.

Esto crea una iterable cantidad de tuplas, siendo el primer valor el elemento original de la lista y el segundo elemento el índice negado. Al encontrar el mínimo en esta iterable cantidad de tuplas, los valores se compararán primero y luego los índices, por lo que terminará con una tupla de (min_value, lower_negative_index). Al tomar el segundo elemento de esta tupla y negarlo nuevamente, obtendrá el índice más alto del valor mínimo.

Aquí hay una versión alternativa que es muy similar, pero usa una función clave para min() :

 >>> min(range(len(values)), key=lambda i: (values[i], -i)) 4 

Tenga en cuenta que esta versión solo funcionará para secuencias (listas, tuplas, cadenas, etc.).

len(list_) - list_[::-1].index(min(list_)) - 1

Obtenga la longitud de la lista, reste de eso el índice del mínimo de la lista en la lista invertida, y luego reste 1.

No es tan eficiente (soy un principiante en Python), pero también funciona bien. El idx solo mantendrá el último índice del elemento mínimo. Creo que el método M.Keijzers es el mejor.

 array = [1,2,3,4,1,2] min_val = min(array) for i in range(len(array)): if array[i] == min_val: idx = i print idx 
 len(myList)-1 - myList[::-1].index(min(list)) 

Esto usa la list[::-1] notación de list[::-1] para devolver una copia superficial de una lista invertida, para que no cambie su lista original, luego busca el valor mínimo en esa lista

 >>>myList = [1,2,3,4,1,2] >>>len(myList)-1 - myList[::-1].index(min(list)) 4 
 >>> from operator import itemgetter >>> from itertools import izip,count >>> min(izip(count(len(L)-1,-1), reversed(L)), key=itemgetter(1))[0] 4 

Explicación

reversed devuelve el iterador que recorre la lista original sin crear una lista temporal:

 >>> reversed(L)  

izip y count son flojos, y parece que no hay ejecución de código byte, por lo que espero que esta solución sea bastante rápida, y de una sola línea.


Comparaciones de tiempo

http://ideone.com/ZQuge3

Las soluciones que utilizan el index resultaron ser las más rápidas a pesar de que tienen que hacer 2 pases en la lista. Otras soluciones crean tuplas auxiliares dentro de los generadores en cada iteración y creo que es la razón por la que estas soluciones son más lentas. Incluso la solución de akson128 que invoca la ejecución de códigos de bytes es aún más rápida (porque no tiene que crear tuplas).