La forma más fácil de ordenar es con la función order(lista), que toma una lista y muestra una lista nueva con esos elementos en orden. La lista original no se modifica.
a = [5, 1, 4, 3] print(sorted(a)) ## [1, 3, 4, 5] print(a) ## [5, 1, 4, 3]
Es más común pasar una lista a la función managed(), pero, en realidad, puede tomar como entrada cualquier tipo de colección iterable. El método list.sort() anterior es una alternativa que se detalla a continuación. La función ordenada() parece más fácil de usar en comparación con sort(), así que recomiendo usar ordenada().
La funciónsort() se puede personalizar a través de argumentos opcionales. El argumento ordenado opcional inverso=True, p.ej., ordenado(lista, invertido=Verdadero), hace que el orden sea hacia atrás.
strs = ['aa', 'BB', 'zz', 'CC'] print(sorted(strs)) ## ['BB', 'CC', 'aa', 'zz'] (case sensitive) print(sorted(strs, reverse=True)) ## ['zz', 'aa', 'CC', 'BB']
Orden personalizado con key=
Para una ordenación personalizada más compleja, ordenada() toma una "clave=" opcional que especifica una función "clave" que transforma cada elemento antes de la comparación. La función clave toma 1 valor y muestra 1 valor, y el valor “proxy” que se muestra se usa para las comparaciones dentro del ordenamiento.
Por ejemplo, con una lista de cadenas, especifica key=len (la función integrada len()) ordena las cadenas por longitud, del más corto al más largo. El ordenamiento llama a len() para cada cadena a fin de obtener la lista de valores de longitud del proxy y, luego, realiza el ordenamiento con esos valores.
strs = ['ccc', 'aaaa', 'd', 'bb'] print(sorted(strs, key=len)) ## ['d', 'bb', 'ccc', 'aaaa']
Como otro ejemplo, especificar "str.lower" como la función clave es una forma de forzar la ordenación para tratar las mayúsculas y las minúsculas de la misma manera:
## "key" argument specifying str.lower function to use for sorting print(sorted(strs, key=str.lower)) ## ['aa', 'BB', 'CC', 'zz']
También puedes pasar tu propia MyFn como la función clave, de la siguiente manera:
## Say we have a list of strings we want to sort by the last letter of the string.
strs = ['xc', 'zb', 'yd' ,'wa']
## Write a little function that takes a string, and returns its last letter.
## This will be the key function (takes in 1 value, returns 1 value).
def MyFn(s):
return s[-1]
## Now pass key=MyFn to sorted() to sort by the last letter:
print(sorted(strs, key=MyFn)) ## ['wa', 'zb', 'xc', 'yd']
Para ordenar elementos más complejos, como ordenar por apellido y luego por nombre, puedes usar las funciones itemgetter o attrgetter, como las siguientes:
from operator import itemgetter
# (first name, last name, score) tuples
grade = [('Freddy', 'Frank', 3), ('Anil', 'Frank', 100), ('Anil', 'Wang', 24)]
sorted(grade, key=itemgetter(1,0))
# [('Anil', 'Frank', 100), ('Freddy', 'Frank', 3), ('Anil', 'Wang', 24)]
sorted(grade, key=itemgetter(0,-1))
#[('Anil', 'Wang', 24), ('Anil', 'Frank', 100), ('Freddy', 'Frank', 3)]
método sort()
Como alternativa a order(), el método sort() de una lista ordena esa lista en orden ascendente, p.ej., list.sort(). El método sort() cambia la lista subyacente y muestra None, así que utilízalo de la siguiente manera:
alist.sort() ## correct alist = blist.sort() ## Incorrect. sort() returns None
Lo anterior es un malentendido muy común con sort(), ya que *no muestra* la lista ordenada. Se debe llamar al método sort() en una lista; no funciona en ninguna colección que se pueda enumerar (pero la función ordenada() anterior funciona en cualquier cosa). El método sort() es anterior a la función arrange(), por lo que es probable que lo veas en el código anterior. El método sort() no necesita crear una nueva lista, por lo que puede ser un poco más rápido en caso de que los elementos a ordenar ya estén en una lista.
Tuplas
Una tupla es una agrupación de elementos de tamaño fijo, como una coordenada (x, y). Las tuplas son como las listas, excepto que son inmutables y no cambian de tamaño (las tuplas no son estrictamente inmutables, ya que uno de los elementos contenidos podría ser mutable). Las tuplas desempeñan una especie de función de “struct” en Python: una forma conveniente de pasar un pequeño conjunto de valores de tamaño fijo y lógico. Una función que necesita devolver múltiples valores puede simplemente mostrar una tupla de los valores. Por ejemplo, si quisiera tener una lista de coordenadas 3-d, la representación natural de Python sería una lista de tuplas, en la que cada tupla es de tamaño 3 y contiene un grupo (x, y, z).
Para crear una tupla, enumera los valores entre paréntesis separados por comas. La tupla “vacía” es solo un par vacío de paréntesis. Acceder a los elementos de una tupla es igual que a una lista: len(), [ ], for, in, etc. funcionan de la misma manera.
tuple = (1, 2, 'hi') print(len(tuple)) ## 3 print(tuple[2]) ## hi tuple[2] = 'bye' ## NO, tuples cannot be changed tuple = (1, 2, 'bye') ## this works
Para crear una tupla de tamaño 1, el único elemento debe ir seguido de una coma.
tuple = ('hi',) ## size-1 tuple
Es un caso gracioso en la sintaxis, pero la coma es necesaria para distinguir la tupla del caso común de poner una expresión entre paréntesis. En algunos casos, puedes omitir el paréntesis, y Python verá una tupla a partir de las comas.
Cuando se asigna una tupla a una tupla de nombres de variables de igual tamaño, se asignan todos los valores correspondientes. Si las tuplas no tienen el mismo tamaño, se mostrará un error. Esta función también funciona para las listas.
(x, y, z) = (42, 13, "hike") print(z) ## hike (err_string, err_code) = Foo() ## Foo() returns a length-2 tuple
Comprensión de listas (opcional)
La comprensión de listas es una función más avanzada que es útil en algunos casos, pero no es necesaria para los ejercicios y no es algo que debas aprender al principio (es decir, puedes omitir esta sección). Una comprensión de lista es una forma compacta de escribir una expresión que se expande a una lista completa. Supongamos que tenemos una lista nums [1, 2, 3, 4]. Esta es la comprensión de la lista para calcular una lista de sus cuadrados [1, 4, 9, 16]:
nums = [1, 2, 3, 4] squares = [ n * n for n in nums ] ## [1, 4, 9, 16]
La sintaxis es [ expr for var in list ]: for var in list parece un bucle for normal, pero sin los dos puntos (:). La expr a su izquierda se evalúa una vez por cada elemento para dar los valores de la lista nueva. Aquí hay un ejemplo con cadenas, donde cada cadena se cambia a mayúsculas y agrega "!!!":
strs = ['hello', 'and', 'goodbye'] shouting = [ s.upper() + '!!!' for s in strs ] ## ['HELLO!!!', 'AND!!!', 'GOODBYE!!!']
Puedes agregar una prueba "if" a la derecha del bucle for para reducir el resultado. La prueba if se evalúa para cada elemento, incluidos solo aquellos en los que la prueba es verdadera.
## Select values <= 2 nums = [2, 8, 1, 6] small = [ n for n in nums if n <= 2 ] ## [2, 1] ## Select fruits containing 'a', change to upper case fruits = ['apple', 'cherry', 'banana', 'lemon'] afruits = [ s.upper() for s in fruits if 'a' in s ] ## ['APPLE', 'BANANA']
Ejercicio: list1.py
Para practicar el material de esta sección, prueba los problemas posteriores en list1.py que usan ordenación y tuplas (en los Ejercicios básicos).