Categorías
Python

Arcade: Una cartilla en el marco del juego Python

 

Tabla de Contenidos

  • Valores de pedido Con ordenados () número de orden NumbersSorting Cuerdas
  • Clasificación
  • Ordenación de Cuerdas
  • limitaciones y trampas con Python SortingLists con tipos de datos no comparables, no se pueden ordenar () cuando estás Clasificación cuerdas, Caso Matters Listas
  • con tipos de datos no comparables, no se pueden ordenar ()
  • cuando estás Clasificación cuerdas, la caja asuntos
  • Usando ordenados () con un argumento inverso
  • ordenadas () con un argumento clave Los valores de pedido
  • con .Sort ()
  • cuándo utilizar ordenadas () y cuándo usar .Sort ()
  • Cómo ordenar en Python: Listas Conclusión
  • Ordenación de números
  • Clasificación Cuerdas
  • con no comparables tipos de datos no se pueden ordenar ()
  • cuando estás Clasificación Cuerdas, Caso Matters

Mira ahora Este tutorial tiene un vídeo relacionado curso creado por el real equipo de Python. Mira que junto con el tutorial escrito para profundizar su comprensión: ordenar datos con Python

Todos los programadores tendrán que escribir el código para ordenar los elementos o datos en algún momento. La clasificación puede ser fundamental para la experiencia del usuario en su aplicación, si se trata de ordenar la actividad más reciente de un usuario por fecha y hora, o poner una lista de destinatarios de correo electrónico en orden alfabético por apellido. Pitón de clasificación ofrece una funcionalidad de características robustas de hacer la clasificación básica o pedido modifique para requisitos particulares a nivel granular.

En esta guía, que va a aprender a clasificar los distintos tipos de datos en diferentes estructuras de datos, personalizar el orden, y el trabajo con dos métodos diferentes de clasificación en Python.

Al final de este tutorial, usted sabrá cómo:

  • Implementar Python básica de clasificación y ordenamiento de estructuras de datos
  • Diferenciar entre ordenados () y .Sort ()
  • Personalizar un orden complejo en el su código basado en los requerimientos únicos

Para este tutorial, necesitará una comprensión básica de las listas y tuplas, así como conjuntos. Esas estructuras de datos serán utilizados en este tutorial, y algunas operaciones básicas se llevarán a cabo en ellos. Además, este tutorial usa Python 3, por lo que una salida de ejemplo en este tutorial podría variar ligeramente si está utilizando Python 2. Bono

gratuito: Haga clic aquí para obtener acceso a un capítulo de trucos Python: El libro que le muestra Python las mejores prácticas con ejemplos simples que usted puede aplicar inmediatamente a escribir código más bonito + Pythonic. Los valores de pedido

Con ordenados ()

para empezar con Python clasificación, donde primero para ver cómo ordenar datos tanto de datos y cadena numérica. Números

Clasificación

Puede utilizar Python para ordenar una lista utilizando ordenados (). En este ejemplo, se define una lista de números enteros, y luego ordenadas () se llama con la variable de los números como el argumento:

>>> numbers = [6, 9, 3, 1]
>>> sorted(numbers)
[1, 3, 6, 9]
>>> numbers
[6, 9, 3, 1]

La salida de este código es una nueva, lista ordenada. Cuando se imprime la variable original, los valores iniciales son sin cambios.

Este ejemplo muestra cuatro características importantes de ordenados ():

Este último medio de puntos que ordenan () se pueden utilizar en una lista, y la salida inmediatamente se pueden asignar a una variable:

>>> numbers = [6, 9, 3, 1]
>>> numbers_sorted = sorted(numbers)
>>> numbers_sorted
[1, 3, 6, 9]
>>> numbers
[6, 9, 3, 1]

En este ejemplo, hay ahora una nueva variable numbers_sorted que almacena la salida ordenada ().

Puede confirmar todas estas observaciones ayuda llamando al () en la ordenada (). Los argumentos opcionales y clave inversa se tratan más adelante en el tutorial: Detalle

>>> # Python 3
>>> help(sorted)
Help on built-in function sorted in module builtins:

sorted(iterable, /, *, key=None, reverse=False)
Return a new list containing all items from the iterable in ascending order.

A custom key function can be supplied to customize the sort order, and the
reverse flag can be set to request the result in descending order.

técnico: Si realiza la transición desde Python 2 y están familiarizados con su función del mismo nombre, se debe tener en cuenta un par de cambios importantes en Python 3:

Si usted necesita para convertir una función cmp Python 2 a una función clave, entonces echa un vistazo a functools.cmp_to_key (). Este tutorial no cubrirá ningún ejemplo usando Python 2.

ordenadas () se puede utilizar en tuplas y conjuntos muy parecida:

>>> numbers_tuple = (6, 9, 3, 1)
>>> numbers_set = {5, 5, 10, 1, 0}
>>> numbers_tuple_sorted = sorted(numbers_tuple)
>>> numbers_set_sorted = sorted(numbers_set)
>>> numbers_tuple_sorted
[1, 3, 6, 9]
>>> numbers_set_sorted
[0, 1, 5, 10]

Aviso cómo a pesar de la entrada era un juego y una tupla, la salida es una lista porque ordenados ( ) devuelve una nueva lista por definición. El objeto devuelto se puede convertir a un nuevo tipo si es necesario para que coincida con el tipo de entrada. Tenga cuidado si intento de conversión de la parte posterior lista resultante de un conjunto, como un conjunto, por definición, es desordenada:

>>> numbers_tuple = (6, 9, 3, 1)
>>> numbers_set = {5, 5, 10, 1, 0}
>>> numbers_tuple_sorted = sorted(numbers_tuple)
>>> numbers_set_sorted = sorted(numbers_set)
>>> numbers_tuple_sorted
[1, 3, 6, 9]
>>> numbers_set_sorted
[0, 1, 5, 10]
>>> tuple(numbers_tuple_sorted)
(1, 3, 6, 9)
>>> set(numbers_set_sorted)
{0, 1, 10, 5}

El valor numbers_set_sorted cuando se lanza a un conjunto no se ordena, como se esperaba. La otra variable, numbers_tuple_sorted, retuvo el orden clasificado.

Clasificación Cuerdas

tipos str especie de manera similar a otros iterables, como lista y tupla. El siguiente ejemplo muestra cómo se ordenan () itera a través de cada carácter en el valor que se le pasa y les ordena en la salida:

>>> string_number_value = '34521'
>>> string_value = 'I like to sort'
>>> sorted_string_number = sorted(string_number_value)
>>> sorted_string = sorted(string_value)
>>> sorted_string_number
['1', '2', '3', '4', '5']
>>> sorted_string
[' ', ' ', ' ', 'I', 'e', 'i', 'k', 'l', 'o', 'o', 'r', 's', 't', 't']

ordenadas () va a tratar una str como una lista y iterar a través de cada elemento. En un str, cada elemento significa que cada carácter en el str. Ordenado () no tratará una frase diferente, y va a ordenar cada carácter, incluyendo espacios.

.split () puede cambiar este comportamiento y limpiar la salida, y .join () puede poner todo de nuevo juntos. Vamos a cubrir la orden específica de la salida y por qué es de esa manera breve:

>>> string_value = 'I like to sort'
>>> sorted_string = sorted(string_value.split())
>>> sorted_string
['I', 'like', 'sort', 'to']
>>> ' '.join(sorted_string)
'I like sort to'

La frase original en este ejemplo se convierte en una lista de palabras en lugar de dejarlo como un str. Dicha lista se ordena y se combinan para formar un str nuevo en lugar de una lista.

limitaciones y problemas comunes con Python Clasificación

Vale la pena señalar algunas limitaciones y comportamientos extraños que pueden surgir cuando se está utilizando Python para ordenar los valores, además de números enteros. Listas

con tipos de datos no comparables, no se pueden ordenar ()

hay tipos de datos que no se pueden comparar entre sí utilizando sólo ordenados () porque son demasiado diferentes. Python devolverá un error si se intenta utilizar ordenados () en una lista que contiene datos que no son comparables. En este ejemplo, una Ninguno y un int en la misma lista no se pueden clasificar debido a su incompatibilidad: error espectáculos

>>> mixed_types = [None, 0]
>>> sorted(mixed_types)
Traceback (most recent call last):
File "", line 1, in
TypeError: '<' not supported between instances of 'int' and 'NoneType'

Es por esto que Python no se puede ordenar los valores que se le da. Está tratando de poner los valores en orden mediante el uso de la menos de operador (<) para determinar qué valor es más baja en orden de clasificación. Puede reproducir este error de forma manual mediante la comparación de los dos valores:

>>> None < 0 Traceback (most recent call last): File "", line 1, in
TypeError: '<' not supported between instances of 'NoneType' and 'int'

La misma TypeError cuando intenta comparar dos valores no comparables sin utilizar ordenados ().

Si los valores dentro de la lista se pueden comparar y no lanzar una TypeError, a continuación, la lista se puede ordenar. Esto evita que la clasificación iterables con los valores intrínsecamente unorderable y salida de la producción que puede no tener sentido.

Por ejemplo, si el número 1 llegado antes de la palabra manzana? Sin embargo, si un iterable contiene una combinación de números enteros y cadenas que son todos los números, que pueden ser emitidos a tipos de datos comparables mediante el uso de una lista por comprensión:

>>> mixed_numbers = [5, "1", 100, "34"]
>>> sorted(mixed_numbers)
Traceback (most recent call last):
File "", line 1, in
TypeError: '<' not supported between instances of 'str' and 'int' >>> # List comprehension to convert all values to integers
>>> [int(x) for x in mixed_numbers]
[5, 1, 100, 34]
>>> sorted([int(x) for x in mixed_numbers])
[1, 5, 34, 100]

Cada elemento de mixed_numbers ha int () llamada en él para convertir cualquier valor str a int valores. Ordenado (), entonces se llama y se puede comparar con éxito cada elemento y proporcionar una salida ordenada.

Python también puede convertir implícitamente un valor a otro tipo. En el siguiente ejemplo, la evaluación de 1 <= 0 es una afirmación falsa, lo que la salida de la evaluación será falsa. El número 1 se puede convertir en True como un tipo bool, mientras que 0 convertidos en Falso.

A pesar de que los elementos de la lista de diferente aspecto, todos ellos pueden ser convertidos a valores booleanos (verdadero o falso) y se compara entre sí usando ordenados ():

>>> similar_values = [False, 0, 1, 'A' == 'B', 1 <= 0] >>> sorted(similar_values)
[False, 0, False, False, 1]

'A' == 'B' y 1 <= 0 son convertidas a Falso y devuelto en la salida ordenada.

Este ejemplo ilustra un aspecto importante de clasificar: estabilidad tipo . En Python, cuando se ordena iguales a los valores, conservarán su orden original en la salida. A pesar de que el 1 movido, todos los otros valores son iguales, por lo que conservan su orden original con relación al otro. En el siguiente ejemplo, todos los valores se consideran iguales y conservarán sus posiciones originales:

>>> false_values = [False, 0, 0, 1 == 2, 0, False, False]
>>> sorted(false_values)
[False, 0, 0, False, 0, False, False]

Si inspecciona el orden original y la salida ordenada, se verá que 1 == 2 se convierte en falso, y toda la salida ordenada se en el orden original.

cuando estás Clasificación Cuerdas, Caso Matters

ordenadas () puede ser utilizado en una lista de cadenas para ordenar los valores en orden ascendente, lo que parece ser alfabéticamente por defecto:

>>> names = ['Harry', 'Suzy', 'Al', 'Mark']
>>> sorted(names)
['Al', 'Harry', 'Mark', 'Suzy']

Sin embargo, Python utiliza el Unicode Punto de código de la primera letra de cada cadena para determinar un orden ascendente. Esto significa que ordenan () no van a tratar los nombres de AL y el mismo. Este ejemplo utiliza ord () para devolver el código de punto Unicode de la primera letra de cada cadena: nombre

>>> names_with_case = ['harry', 'Suzy', 'al', 'Mark']
>>> sorted(names_with_case)
['Mark', 'Suzy', 'al', 'harry']
>>> # List comprehension for Unicode Code Point of first letter in each word
>>> [(ord(name[0]), name[0]) for name in sorted(names_with_case)]
[(77, 'M'), (83, 'S'), (97, 'a'), (104, 'h')]

[0] está regresando el primer carácter de cada elemento de ordenados (names_with_case), y ord () se proporciona el código Unicode Punto. A pesar de que viene antes de una M en el alfabeto, el punto de código para M viene antes de una, por lo que la salida ordenada tiene M en primer lugar.

Si la primera letra es la misma, a continuación, ordenados () utilizará el segundo carácter para determinar el orden, y el tercero, si eso es lo mismo, y así sucesivamente, hasta llegar a la final de la cadena:

>>> very_similar_strs = ['hhhhhd', 'hhhhha', 'hhhhhc','hhhhhb']
>>> sorted(very_similar_strs)
['hhhhha', 'hhhhhb', 'hhhhhc', 'hhhhhd']

cada valor de very_similar_strs es idéntica a excepción del último carácter. Ordenado () comparará las cuerdas, y porque los primeros cinco caracteres son los mismos, la salida será basado en el sexto carácter.

cadenas que contienen valores idénticos terminarán ordenados corto al más largo debido a las cadenas más cortas no tienen elementos para comparar a las cadenas más largas:

>>> different_lengths = ['hhhh', 'hh', 'hhhhh','h']
>>> sorted(different_lengths)
['h', 'hh', 'hhhh', 'hhhhh']

La más corta cadena, h, se ordena en primer lugar con la más larga, hhhhh, ordenó el pasado .

Uso de ordenadas () con un argumento inverso

Como se muestra en la documentación de ayuda () para ordenados (), hay un argumento de palabra clave opcional llamado inversa, que va a cambiar el comportamiento de ordenación basado en el operador booleano asignado. Si se asigna inversa True, la clasificación será en orden descendente:

>>> names = ['Harry', 'Suzy', 'Al', 'Mark']
>>> sorted(names)
['Al', 'Harry', 'Mark', 'Suzy']
>>> sorted(names, reverse=True)
['Suzy', 'Mark', 'Harry', 'Al']

La lógica de clasificación sigue siendo el mismo, lo que significa que los nombres están siendo ordenados por su primera letra. Pero la salida se ha invertido con el conjunto de palabras clave inversa en True.

Cuando se asigna False, el pedido se mantendrá ascendente. Cualquiera de los ejemplos anteriores se puede utilizar para ver el comportamiento de marcha atrás utilizando tanto Verdadero o Falso:

>>> names_with_case = ['harry', 'Suzy', 'al', 'Mark']
>>> sorted(names_with_case, reverse=True)
['harry', 'al', 'Suzy', 'Mark']
>>> similar_values = [False, 1, 'A' == 'B', 1 <= 0] >>> sorted(similar_values, reverse=True)
[1, False, False, False]
>>> numbers = [6, 9, 3, 1]
>>> sorted(numbers, reverse=False)
[1, 3, 6, 9]

ordenadas () con un argumento clave

Uno de los componentes más potentes de ordenados () es el argumento de palabra clave denominada clave. Este argumento espera una función que se pasa a ella, y que la función se puede utilizar en cada valor de la lista que se está ordenada para determinar el orden resultante.

Para demostrar un ejemplo básico, vamos a suponer la necesidad de ordenar una lista específica es la longitud de las cuerdas en la lista, corto al más largo. La función para devolver la longitud de una cadena, len (), será utilizada con el argumento clave:

>>> word = 'paper'
>>> len(word)
5
>>> words = ['banana', 'pie', 'Washington', 'book']
>>> sorted(words, key=len)
['pie', 'book', 'banana', 'Washington']

el orden resultante es una lista con un orden de las cuerdas de corto al más largo. La longitud de cada elemento de la lista se determina por Len () y luego devuelto en orden ascendente. El regreso de

Vamos al ejemplo anterior de la clasificación por primera letra cuando el caso es diferente. clave se puede utilizar para resolver ese problema mediante la conversión de toda la cadena a minúsculas:

>>> names_with_case = ['harry', 'Suzy', 'al', 'Mark']
>>> sorted(names_with_case)
['Mark', 'Suzy', 'al', 'harry']
>>> sorted(names_with_case, key=str.lower)
['al', 'harry', 'Mark', 'Suzy']

Los valores de salida no han sido convertidos a minúsculas porque la clave de no manipula los datos en la lista original. Durante la clasificación, la función pasa a la clave está siendo llamado en cada elemento para determinar un orden de publicación, pero los valores originales estará en la salida.

Hay dos limitaciones principales cuando se está utilizando funciones con el argumento clave.

En primer lugar, el número de argumentos necesarios en la función pasa a la clave debe ser uno.

El siguiente ejemplo muestra la definición de una función de adición que toma dos argumentos. Cuando esta función se utiliza en clave de una lista de números, se produce un error porque falta un segundo argumento. Cada complemento de tiempo () se llama durante la ordenación, que está recibiendo solamente un elemento de la lista a la vez:

>>> def add(x, y):
... return x + y
...
>>> values_to_add = [1, 2, 3]
>>> sorted(values_to_add, key=add)
Traceback (most recent call last):
File "", line 1, in
TypeError: add() missing 1 required positional argument: 'y'

La segunda limitación es que la función utilizada con clave debe ser capaz de manejar todos los valores en el iterable. Por ejemplo, usted tiene una lista de números representados como cadenas para ser utilizado en ordenados (), y la clave va a tratar de convertirlos en números utilizando int. Si un valor en el iterable no se puede convertir a un entero, entonces la función fallará:

>>> values_to_cast = ['1', '2', '3', 'four']
>>> sorted(values_to_cast, key=int)
Traceback (most recent call last):
File "", line 1, in
ValueError: invalid literal for int() with base 10: 'four'

Cada valor numérico como un str se puede convertir a int, pero cuatro no puede. Esto provoca una ValueError a ser elevado y explicar que cuatro no se puede convertir a int, ya que no es válido.

La funcionalidad clave es muy potente debido a que casi cualquier función, incorporada o definida por el usuario, se puede utilizar para manipular el orden de salida.

Si el requisito de pedido es para pedir un iterable por la última letra de cada cuerda (y si la letra es la misma, a continuación, utilizar la siguiente letra), entonces una función se puede definir y luego se usa en la clasificación. El ejemplo siguiente define una función que invierte la cadena que se pasa a la misma, y ​​después de que la función se utiliza como el argumento de la clave:

>>> def reverse_word(word):
... return word[::-1]
...
>>> words = ['banana', 'pie', 'Washington', 'book']
>>> sorted(words, key=reverse_word)
['banana', 'pie', 'book', 'Washington']

La palabra [:: - 1] sintaxis rebanada se utiliza para invertir una cadena. Cada elemento tendrá reverse_word () aplicada a ella, y el orden de clasificación se basará en los caracteres de la palabra hacia atrás.

En lugar de escribir una función independiente, se puede utilizar una función lambda se define en el argumento clave.

A lambda es una función anónima que:

En el siguiente ejemplo, la clave se define como una lambda sin nombre, el argumento tomada por el lambda es x, y x [:: - 1] es la operación que voluntad llevarse a cabo en el argumento:

>>> words = ['banana', 'pie', 'Washington', 'book']
>>> sorted(words, key=lambda x: x[::-1])
['banana', 'pie', 'book', 'Washington']

x [:: - 1] que se llama en cada elemento e invierte la palabra. Que la salida invertida se utiliza para clasificar, pero las palabras originales todavía se devuelven.

Si los cambios en los requisitos y el orden deben ser invertidas así, entonces la palabra clave inversa se puede utilizar junto con el argumento clave: funciones lambda

>>> words = ['banana', 'pie', 'Washington', 'book']
>>> sorted(words, key=lambda x: x[::-1], reverse=True)
['Washington', 'book', 'pie', 'banana']

también son útiles cuando se necesita para clasificar objetos de clases basado en una propiedad. Si usted tiene un grupo de estudiantes y necesidad de clasificarlos por su calificación final, mayor a menor, a continuación, un lambda se puede utilizar para obtener la propiedad del grado de la clase:

>>> from collections import namedtuple

>>> StudentFinal = namedtuple('StudentFinal', 'name grade')
>>> bill = StudentFinal('Bill', 90)
>>> patty = StudentFinal('Patty', 94)
>>> bart = StudentFinal('Bart', 89)
>>> students = [bill, patty, bart]
>>> sorted(students, key=lambda x: getattr(x, 'grade'), reverse=True)
[StudentFinal(name='Patty', grade=94), StudentFinal(name='Bill', grade=90), StudentFinal(name='Bart', grade=89)]

este ejemplo se utiliza namedtuple para producir clases con nombre y grado atributos. Las llamadas lambda GetAttr () en cada elemento y devuelve el valor de grado.

inversa se establece en True para que la salida ascendente volteado ser descendiente de manera que los grados más altos se ordenan en primer lugar.

Las posibilidades son infinitas para la forma de pedido se puede hacer cuando a aprovechar tanto la clave y revertir los argumentos de palabras clave en ordenados (). El código puede mantenerse limpio y seco cuando se utiliza un lambda básico para una pequeña función, o se puede escribir una función completamente nueva, importarlos, y utilizarlo en el argumento clave. Los valores de pedido

Con .Sort ()

La manera muy similar nombrados .Sort () difiere bastante de la ordenados () incorporados. Logran más o menos lo mismo, pero la ayuda () documentación para list.sort () destaca dos de los más diferencias críticas entre .Sort () y ordenados ():

>>> # Python2
Help on method_descriptor:

sort(...)
L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
cmp(x, y) -> -1, 0, 1

>>> # Python3
>>> help(list.sort)
Help on method_descriptor:

sort(...)
L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*

En primer lugar, una especie es un método de la lista clase y sólo se puede utilizar con las listas. No es un built-in con un iterable se le ha pasado.

En segundo lugar, .Sort () devuelve None y modifica los valores en su lugar. Vamos a echar un vistazo a los impactos de estas dos diferencias de código:

>>> values_to_sort = [5, 2, 6, 1]
>>> # Try to call .sort() like sorted()
>>> sort(values_to_sort)
Traceback (most recent call last):
File "", line 1, in
NameError: name 'sort' is not defined

>>> # Try to use .sort() on a tuple
>>> tuple_val = (5, 1, 3, 5)
>>> tuple_val.sort()
Traceback (most recent call last):
File "", line 1, in
AttributeError: 'tuple' object has no attribute 'sort'

>>> # Sort the list and assign to new variable
>>> sorted_values = values_to_sort.sort()
>>> print(sorted_values)
None

>>> # Print original variable
>>> print(values_to_sort)
[1, 2, 5, 6]

Existen algunas diferencias bastante dramáticos en la forma .Sort () opera en comparación con los ordenados () en este ejemplo de código:

Estas diferencias en el comportamiento de maquillaje .Sort () y ordenados () absolutamente no son intercambiables en el código, y pueden producir resultados inesperados violentamente si se utiliza de manera incorrecta.

.Sort () tiene la misma clave y revertir los argumentos de palabras clave opcionales que producen la misma funcionalidad robusta como ordenados (). A continuación, puede ordenar una lista de frases por la segunda letra de la tercera palabra y devolver la lista en orden inverso:

>>> phrases = ['when in rome',
... 'what goes around comes around',
... 'all is fair in love and war'
... ]
>>> phrases.sort(key=lambda x: x.split()[2][1], reverse=True)
>>> phrases
['what goes around comes around', 'when in rome', 'all is fair in love and war']

En esta muestra, un lambda se utiliza para hacer lo siguiente:

cuándo utilizar ordenadas () y Cuando para utilizar .Sort ()

usted ha visto las diferencias entre ordenados () y .Sort (), pero no cuando se utiliza la cual? digamos de

Let hay una carrera 5k apareciendo: El primer pitón Anual de 5k. Los datos de las necesidades de carrera a ser capturados y ordenados. Los datos que debe obtenerse es el número de dorsal del corredor y el número de segundos que se tardó en terminar la carrera:

>>> from collections import namedtuple

>>> Runner = namedtuple('Runner', 'bibnumber duration')

Como los corredores cruzan la línea de meta, cada corredor se añadirán a una lista llamada corredores. En carreras de 5 km, no todos los corredores cruzan la línea que empieza al mismo tiempo, por lo que la primera persona en cruzar la línea de meta podría no ser en realidad la persona más rápida:

>>> runners = []
>>> runners.append(Runner('2528567', 1500))
>>> runners.append(Runner('7575234', 1420))
>>> runners.append(Runner('2666234', 1600))
>>> runners.append(Runner('2425234', 1490))
>>> runners.append(Runner('1235234', 1620))
>>> # Thousands and Thousands of entries later...
>>> runners.append(Runner('2526674', 1906))

Cada vez que un corredor cruza la línea de meta, su número de dorsal y su duración total en segundos se añade a los corredores.

Ahora, el programador consciente de sus deberes a cargo del manejo de los datos de resultado ve esta lista, sabe que los 5 primeros participantes más rápidos son los ganadores que consiguen premios, y los corredores restantes van a ser ordenados por el tiempo más rápido.

No hay requisitos para múltiples tipos de clasificación por diversos atributos. La lista es de un tamaño razonable. No hay ninguna mención de almacenar la lista en algún lugar. Sólo una especie de duración y agarrar los cinco participantes con la duración más bajo:

>>> runners.sort(key=lambda x: getattr(x, 'duration'))
>>> top_five_runners = runners[:5]

que escoge el programador utilizar una lambda en el argumento clave para obtener el atributo de duración de cada corredor y ordenar los corredores en su lugar usando .Sort (). Después de corredores se ordenan, los primeros 5 elementos se almacenan en top_five_runners.

Misión

cumpla! El director de la carrera se acerca y le informa al programador que, dado que la versión actual de Python es 3.7, que han decidido que cada persona trigésimo séptimo que cruzó la línea de meta se va a poner una bolsa de deporte libre.

En este punto, el programador comienza a sudar porque la lista de corredores se ha cambiado de manera irreversible. No hay manera de recuperar la lista original de corredores en el orden en que terminaron y encontrar cada persona trigésimo séptimo.

Si se trabaja con datos importantes, e incluso hay una posibilidad remota de que tendrán que ser recuperados, a continuación, .Sort los datos originales () no es la mejor opción. Si los datos son una copia, de si se trata de datos de trabajo, sin importancia, de si nadie le importará perderlo, ya que puede ser recuperada, a continuación, .Sort () puede ser una buena opción.

Alternativamente, los corredores podría haber sido solucionado utilizando ordenados () y utilizando el mismo lambda:

>>> runners_by_duration = sorted(runners, key=lambda x: getattr(x, 'duration'))
>>> top_five_runners = runners_by_duration[:5]

En este escenario con ordenados (), la lista original de los corredores está intacta y no ha sido sobrescrito. El requisito improvisada de encontrar cada persona trigésimo séptimo a cruzar la línea de meta se puede lograr mediante la interacción con los valores originales: every_thirtyseventh_runners

>>> every_thirtyseventh_runners = runners[::37]

se crea mediante el uso de un paso en la sintaxis rebanada lista de corredores, que todavía contiene el orden original en el cual los corredores cruzaron la línea de meta.

Cómo ordenar en Python: Conclusión

.Sort () y ordenadas () puede proporcionar exactamente el orden de clasificación que necesita si se utilizan correctamente tanto con los argumentos de palabra clave opcionales y retroceso.

Ambos tienen características muy diferentes cuando se trata de la producción y en el lugar modificaciones, así que asegúrese de pensar a través de cualquier funcionalidad de la aplicación o programa que va a utilizar .Sort (), ya que puede sobreescritura de datos de manera irrevocable.

Para los Pythonistas ávidos en busca de un desafío con la clasificación, trate de usar tipos de datos más complejos en la clasificación: iterables anidados. Además, no dude a sumergirse en las implementaciones de código abierto de código Python para los muebles empotrados y leer sobre el algoritmo de ordenación utilizado en Python llamado Timsort.

Mira ahora Este tutorial tiene un vídeo relacionado curso creado por el equipo del Real Python. Mira que junto con el tutorial escrito para profundizar su comprensión: ordenar datos con Python

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *