Las funciones lambda de Python ofrecen una forma concisa y poderosa de realizar operaciones de ordenamiento personalizadas. En este tutorial, exploraremos cómo usar funciones lambda para ordenar datos en Python, desbloqueando nuevas posibilidades para la manipulación y el análisis de datos. Al final, tendrás una sólida comprensión de cómo aprovechar las funciones lambda para el ordenamiento personalizado y podrás aplicar estas técnicas a tus propios proyectos de Python.
En Python, una función lambda es una función pequeña y anónima definida con la palabra clave lambda. A diferencia de las funciones regulares que usan la palabra clave def, las funciones lambda se pueden crear en línea y no necesitan una definición separada.
Creemos un nuevo archivo Python para explorar las funciones lambda. Abre el WebIDE y crea un nuevo archivo llamado basic_lambda.py en el directorio /home/labex/project/lambda_sorting.
Añade el siguiente código a basic_lambda.py:
## Define a regular function
def square_function(x):
return x * x
## The equivalent lambda function
square_lambda = lambda x: x * x
## Test both functions
number = 5
print(f"Using regular function: {number}² = {square_function(number)}")
print(f"Using lambda function: {number}² = {square_lambda(number)}")
## Lambda with multiple arguments
add = lambda x, y: x + y
print(f"{3} + {4} = {add(3, 4)}")Ahora, ejecutemos este archivo en la terminal:
python3 basic_lambda.pyDeberías ver una salida como esta:
Using regular function: 5² = 25
Using lambda function: 5² = 25
3 + 4 = 7Las funciones lambda son especialmente útiles cuando necesitas una función simple por un corto período, particularmente cuando usas funciones como map(), filter() o sorted(). Creemos otro ejemplo para ver las lambdas en acción con la función map().
Crea un nuevo archivo llamado lambda_with_map.py con el siguiente contenido:
## Using lambda with map() to apply a function to all items in a list
numbers = [1, 2, 3, 4, 5]
## Square all numbers using map with a lambda function
squared_numbers = list(map(lambda x: x * x, numbers))
print(f"Original numbers: {numbers}")
print(f"Squared numbers: {squared_numbers}")
## Double all numbers using map with a lambda function
doubled_numbers = list(map(lambda x: x * 2, numbers))
print(f"Doubled numbers: {doubled_numbers}")Ejecuta este archivo:
python3 lambda_with_map.pyDeberías ver:
Original numbers: [1, 2, 3, 4, 5]
Squared numbers: [1, 4, 9, 16, 25]
Doubled numbers: [2, 4, 6, 8, 10]Comprender las funciones lambda es esencial antes de aplicarlas a la ordenación. En el siguiente paso, exploraremos cómo usar funciones lambda con las funciones de ordenación de Python.
Python proporciona dos formas principales de ordenar colecciones: la función sorted() y el método .sort() para listas. Podemos usar funciones lambda con ambas para crear lógica de ordenamiento personalizada.
Creemos un nuevo archivo llamado basic_sorting.py para explorar el ordenamiento básico con funciones lambda:
## Basic sorting examples
fruits = ["apple", "banana", "cherry", "date", "elderberry", "fig"]
## Sort alphabetically (default behavior)
alphabetical = sorted(fruits)
print(f"Alphabetical order: {alphabetical}")
## Sort by length using a lambda function
by_length = sorted(fruits, key=lambda x: len(x))
print(f"Sorted by length: {by_length}")
## Sort by the last character
by_last_char = sorted(fruits, key=lambda x: x[-1])
print(f"Sorted by last character: {by_last_char}")
## Sort in reverse order (longest to shortest)
longest_first = sorted(fruits, key=lambda x: len(x), reverse=True)
print(f"Longest to shortest: {longest_first}")Ejecuta este archivo:
python3 basic_sorting.pyDeberías ver una salida como:
Alphabetical order: ['apple', 'banana', 'cherry', 'date', 'elderberry', 'fig']
Sorted by length: ['fig', 'date', 'apple', 'cherry', 'banana', 'elderberry']
Sorted by last character: ['banana', 'apple', 'date', 'fig', 'cherry', 'elderberry']
Longest to shortest: ['elderberry', 'banana', 'cherry', 'apple', 'date', 'fig']El parámetro key en sorted() toma una función que transforma cada elemento antes de la comparación. Las funciones lambda proporcionan una forma concisa de crear estas transformaciones.
Ahora, intentemos ordenar con estructuras de datos más complejas. Crea un archivo llamado sorting_tuples.py:
## Sorting lists of tuples
students = [
("Alice", 21, 85),
("Bob", 19, 90),
("Charlie", 22, 78),
("David", 20, 92),
("Eve", 18, 88)
]
print("Original student data:")
for student in students:
print(f" {student[0]}: age {student[1]}, grade {student[2]}")
## Sort by name (first element in tuple)
by_name = sorted(students, key=lambda student: student[0])
print("\nSorted by name:")
for student in by_name:
print(f" {student[0]}: age {student[1]}, grade {student[2]}")
## Sort by age (second element)
by_age = sorted(students, key=lambda student: student[1])
print("\nSorted by age:")
for student in by_age:
print(f" {student[0]}: age {student[1]}, grade {student[2]}")
## Sort by grade (third element)
by_grade = sorted(students, key=lambda student: student[2], reverse=True)
print("\nSorted by grade (highest first):")
for student in by_grade:
print(f" {student[0]}: age {student[1]}, grade {student[2]}")Ejecuta este archivo:
python3 sorting_tuples.pyDeberías ver a los estudiantes ordenados de diferentes maneras:
Original student data:
Alice: age 21, grade 85
Bob: age 19, grade 90
Charlie: age 22, grade 78
David: age 20, grade 92
Eve: age 18, grade 88
Sorted by name:
Alice: age 21, grade 85
Bob: age 19, grade 90
Charlie: age 22, grade 78
David: age 20, grade 92
Eve: age 18, grade 88
Sorted by age:
Eve: age 18, grade 88
Bob: age 19, grade 90
David: age 20, grade 92
Alice: age 21, grade 85
Charlie: age 22, grade 78
Sorted by grade (highest first):
David: age 20, grade 92
Bob: age 19, grade 90
Eve: age 18, grade 88
Alice: age 21, grade 85
Charlie: age 22, grade 78En el siguiente paso, exploraremos técnicas de ordenamiento más avanzadas utilizando funciones lambda.
Ahora que entendemos los conceptos básicos, exploremos técnicas de ordenamiento más avanzadas utilizando funciones lambda.
Los diccionarios son una estructura de datos común en Python, y a menudo necesitamos ordenar listas de diccionarios. Crea un archivo llamado sorting_dictionaries.py:
## Sorting lists of dictionaries
products = [
{"name": "Laptop", "price": 999.99, "stock": 25},
{"name": "Phone", "price": 499.50, "stock": 42},
{"name": "Tablet", "price": 299.75, "stock": 15},
{"name": "Headphones", "price": 149.99, "stock": 34},
{"name": "Mouse", "price": 24.99, "stock": 55}
]
## Print original products
print("Original product list:")
for product in products:
print(f" {product['name']}: ${product['price']}, Stock: {product['stock']}")
## Sort by price (lowest to highest)
by_price = sorted(products, key=lambda product: product["price"])
print("\nSorted by price (lowest to highest):")
for product in by_price:
print(f" {product['name']}: ${product['price']}, Stock: {product['stock']}")
## Sort by stock (highest to lowest)
by_stock = sorted(products, key=lambda product: product["stock"], reverse=True)
print("\nSorted by stock (highest to lowest):")
for product in by_stock:
print(f" {product['name']}: ${product['price']}, Stock: {product['stock']}")
## Sort by name (alphabetically)
by_name = sorted(products, key=lambda product: product["name"])
print("\nSorted by name:")
for product in by_name:
print(f" {product['name']}: ${product['price']}, Stock: {product['stock']}")Ejecuta este archivo:
python3 sorting_dictionaries.pyDeberías ver los productos ordenados de diferentes maneras:
Original product list:
Laptop: $999.99, Stock: 25
Phone: $499.5, Stock: 42
Tablet: $299.75, Stock: 15
Headphones: $149.99, Stock: 34
Mouse: $24.99, Stock: 55
Sorted by price (lowest to highest):
Mouse: $24.99, Stock: 55
Headphones: $149.99, Stock: 34
Tablet: $299.75, Stock: 15
Phone: $499.5, Stock: 42
Laptop: $999.99, Stock: 25
Sorted by stock (highest to lowest):
Mouse: $24.99, Stock: 55
Phone: $499.5, Stock: 42
Headphones: $149.99, Stock: 34
Laptop: $999.99, Stock: 25
Tablet: $299.75, Stock: 15
Sorted by name:
Headphones: $149.99, Stock: 34
Laptop: $999.99, Stock: 25
Mouse: $24.99, Stock: 55
Phone: $499.5, Stock: 42
Tablet: $299.75, Stock: 15A veces necesitamos ordenar elementos utilizando múltiples criterios. Por ejemplo, podríamos querer ordenar estudiantes primero por calificación, y luego por edad para aquellos con la misma calificación.
Crea un archivo llamado multi_level_sorting.py:
## Multi-level sorting example
students = [
{"name": "Alice", "grade": "A", "age": 21},
{"name": "Bob", "grade": "B", "age": 19},
{"name": "Charlie", "grade": "A", "age": 22},
{"name": "David", "grade": "C", "age": 20},
{"name": "Eve", "grade": "B", "age": 18},
{"name": "Frank", "grade": "A", "age": 19}
]
print("Original student list:")
for student in students:
print(f" {student['name']}: Grade {student['grade']}, Age {student['age']}")
## Sort by grade (A to C), then by age (youngest to oldest)
## To sort by grade, we create a dictionary for grade priorities
grade_priority = {"A": 1, "B": 2, "C": 3} ## A is highest priority (lowest number)
by_grade_then_age = sorted(students,
key=lambda student: (grade_priority[student["grade"]], student["age"]))
print("\nSorted by grade (A first), then by age (youngest first):")
for student in by_grade_then_age:
print(f" {student['name']}: Grade {student['grade']}, Age {student['age']}")
## Sort by age (oldest to youngest), then by name (alphabetically)
by_age_then_name = sorted(students,
key=lambda student: (-student["age"], student["name"]))
print("\nSorted by age (oldest first), then by name:")
for student in by_age_then_name:
print(f" {student['name']}: Grade {student['grade']}, Age {student['age']}")Ejecuta este archivo:
python3 multi_level_sorting.pyDeberías ver:
Original student list:
Alice: Grade A, Age 21
Bob: Grade B, Age 19
Charlie: Grade A, Age 22
David: Grade C, Age 20
Eve: Grade B, Age 18
Frank: Grade A, Age 19
Sorted by grade (A first), then by age (youngest first):
Frank: Grade A, Age 19
Alice: Grade A, Age 21
Charlie: Grade A, Age 22
Eve: Grade B, Age 18
Bob: Grade B, Age 19
David: Grade C, Age 20
Sorted by age (oldest first), then by name:
Charlie: Grade A, Age 22
Alice: Grade A, Age 21
David: Grade C, Age 20
Bob: Grade B, Age 19
Frank: Grade A, Age 19
Eve: Grade B, Age 18Observa cómo usamos tuplas dentro de la función lambda para definir múltiples criterios de ordenamiento. El primer elemento en la tupla es la clave de ordenamiento principal, y los elementos subsiguientes se utilizan para desempates.
Usamos un signo negativo -student["age"] para ordenar por edad en orden descendente. Esta técnica es útil cuando quieres ordenar numéricamente en orden inverso.
Creemos un ejemplo final para mostrar cómo ordenar objetos de clase personalizados. Crea un archivo llamado sorting_objects.py:
## Sorting objects of a custom class
class Person:
def __init__(self, name, age, height):
self.name = name
self.age = age
self.height = height ## in cm
def __repr__(self):
return f"Person(name='{self.name}', age={self.age}, height={self.height}cm)"
## Create a list of Person objects
people = [
Person("Alice", 25, 165),
Person("Bob", 30, 180),
Person("Charlie", 22, 175),
Person("David", 35, 170),
Person("Eve", 28, 160)
]
print("Original list of people:")
for person in people:
print(f" {person}")
## Sort by age
by_age = sorted(people, key=lambda person: person.age)
print("\nSorted by age:")
for person in by_age:
print(f" {person}")
## Sort by height
by_height = sorted(people, key=lambda person: person.height)
print("\nSorted by height:")
for person in by_height:
print(f" {person}")
## Sort by name length, then by age
by_name_length_then_age = sorted(people, key=lambda person: (len(person.name), person.age))
print("\nSorted by name length, then by age:")
for person in by_name_length_then_age:
print(f" {person}")Ejecuta este archivo:
python3 sorting_objects.pyDeberías ver:
Original list of people:
Person(name='Alice', age=25, height=165cm)
Person(name='Bob', age=30, height=180cm)
Person(name='Charlie', age=22, height=175cm)
Person(name='David', age=35, height=170cm)
Person(name='Eve', age=28, height=160cm)
Sorted by age:
Person(name='Charlie', age=22, height=175cm)
Person(name='Alice', age=25, height=165cm)
Person(name='Eve', age=28, height=160cm)
Person(name='Bob', age=30, height=180cm)
Person(name='David', age=35, height=170cm)
Sorted by height:
Person(name='Eve', age=28, height=160cm)
Person(name='Alice', age=25, height=165cm)
Person(name='David', age=35, height=170cm)
Person(name='Charlie', age=22, height=175cm)
Person(name='Bob', age=30, height=180cm)
Sorted by name length, then by age:
Person(name='Bob', age=30, height=180cm)
Person(name='Eve', age=28, height=160cm)
Person(name='Alice', age=25, height=165cm)
Person(name='David', age=35, height=170cm)
Person(name='Charlie', age=22, height=175cm)Este ejemplo demuestra cómo las funciones lambda se pueden usar para ordenar objetos personalizados accediendo a sus atributos directamente.
Ahora, apliquemos lo que hemos aprendido a un escenario de análisis de datos más realista. Crearemos un programa que analiza un conjunto de datos de libros y permite ordenar por diferentes criterios.
Crea un archivo llamado book_analyzer.py:
## Book data analysis application
books = [
{
"title": "The Great Gatsby",
"author": "F. Scott Fitzgerald",
"year": 1925,
"pages": 180,
"rating": 4.2,
"genres": ["Classic", "Fiction"]
},
{
"title": "To Kill a Mockingbird",
"author": "Harper Lee",
"year": 1960,
"pages": 281,
"rating": 4.3,
"genres": ["Classic", "Fiction", "Drama"]
},
{
"title": "1984",
"author": "George Orwell",
"year": 1949,
"pages": 328,
"rating": 4.2,
"genres": ["Dystopian", "Fiction", "Political"]
},
{
"title": "The Hobbit",
"author": "J.R.R. Tolkien",
"year": 1937,
"pages": 310,
"rating": 4.4,
"genres": ["Fantasy", "Adventure"]
},
{
"title": "Harry Potter and the Sorcerer's Stone",
"author": "J.K. Rowling",
"year": 1997,
"pages": 309,
"rating": 4.5,
"genres": ["Fantasy", "Adventure", "Young Adult"]
},
{
"title": "The Catcher in the Rye",
"author": "J.D. Salinger",
"year": 1951,
"pages": 214,
"rating": 3.8,
"genres": ["Fiction", "Coming of Age"]
}
]
def print_books(book_list, heading):
"""Helper function to print books in a formatted way"""
print(f"\n{heading}")
print("-" * 80)
for book in book_list:
genres = ", ".join(book["genres"])
print(f"{book['title']} by {book['author']} ({book['year']}) - {book['pages']} pages")
print(f" Rating: {book['rating']}, Genres: {genres}")
print("-" * 80)
## Print the original list
print_books(books, "Original Book List")
## Sort books by different criteria
sort_options = {
"1": ("Title (A-Z)", lambda b: b["title"]),
"2": ("Author (A-Z)", lambda b: b["author"]),
"3": ("Publication Year (Oldest First)", lambda b: b["year"]),
"4": ("Publication Year (Newest First)", lambda b: -b["year"]),
"5": ("Rating (Highest First)", lambda b: -b["rating"]),
"6": ("Number of Pages (Lowest First)", lambda b: b["pages"]),
"7": ("Number of Genres", lambda b: len(b["genres"])),
}
## Show sorting options
print("\nSorting Options:")
for key, (description, _) in sort_options.items():
print(f"{key}. {description}")
## Automatically show all sorting examples for this tutorial
for option, (description, sort_key) in sort_options.items():
sorted_books = sorted(books, key=sort_key)
print_books(sorted_books, f"Books Sorted by {description}")Ejecuta este archivo:
python3 book_analyzer.pyVerás los libros ordenados de múltiples maneras:
Original Book List
--------------------------------------------------------------------------------
The Great Gatsby by F. Scott Fitzgerald (1925) - 180 pages
Rating: 4.2, Genres: Classic, Fiction
To Kill a Mockingbird by Harper Lee (1960) - 281 pages
Rating: 4.3, Genres: Classic, Fiction, Drama
1984 by George Orwell (1949) - 328 pages
Rating: 4.2, Genres: Dystopian, Fiction, Political
The Hobbit by J.R.R. Tolkien (1937) - 310 pages
Rating: 4.4, Genres: Fantasy, Adventure
Harry Potter and the Sorcerer's Stone by J.K. Rowling (1997) - 309 pages
Rating: 4.5, Genres: Fantasy, Adventure, Young Adult
The Catcher in the Rye by J.D. Salinger (1951) - 214 pages
Rating: 3.8, Genres: Fiction, Coming of Age
--------------------------------------------------------------------------------
Sorting Options:
1. Title (A-Z)
2. Author (A-Z)
3. Publication Year (Oldest First)
4. Publication Year (Newest First)
5. Rating (Highest First)
6. Number of Pages (Lowest First)
7. Number of Genres
Books Sorted by Title (A-Z)
...
[Output continues with all the different sorting examples]Este ejemplo demuestra cómo las funciones lambda se pueden usar en una aplicación real para proporcionar capacidades de ordenamiento flexibles. Observa cómo almacenamos las funciones lambda junto con sus descripciones en un diccionario, lo que facilitaría la adición de más opciones de ordenamiento en una aplicación real.
Creemos una versión interactiva donde el usuario puede elegir una opción de ordenamiento. Crea un archivo llamado interactive_book_sorter.py:
## Interactive book sorter application
books = [
{
"title": "The Great Gatsby",
"author": "F. Scott Fitzgerald",
"year": 1925,
"pages": 180,
"rating": 4.2,
"genres": ["Classic", "Fiction"]
},
{
"title": "To Kill a Mockingbird",
"author": "Harper Lee",
"year": 1960,
"pages": 281,
"rating": 4.3,
"genres": ["Classic", "Fiction", "Drama"]
},
{
"title": "1984",
"author": "George Orwell",
"year": 1949,
"pages": 328,
"rating": 4.2,
"genres": ["Dystopian", "Fiction", "Political"]
},
{
"title": "The Hobbit",
"author": "J.R.R. Tolkien",
"year": 1937,
"pages": 310,
"rating": 4.4,
"genres": ["Fantasy", "Adventure"]
},
{
"title": "Harry Potter and the Sorcerer's Stone",
"author": "J.K. Rowling",
"year": 1997,
"pages": 309,
"rating": 4.5,
"genres": ["Fantasy", "Adventure", "Young Adult"]
},
{
"title": "The Catcher in the Rye",
"author": "J.D. Salinger",
"year": 1951,
"pages": 214,
"rating": 3.8,
"genres": ["Fiction", "Coming of Age"]
}
]
def print_books(book_list, heading):
"""Helper function to print books in a formatted way"""
print(f"\n{heading}")
print("-" * 80)
for book in book_list:
genres = ", ".join(book["genres"])
print(f"{book['title']} by {book['author']} ({book['year']}) - {book['pages']} pages")
print(f" Rating: {book['rating']}, Genres: {genres}")
print("-" * 80)
## Define our sorting options
sort_options = {
"1": ("Title (A-Z)", lambda b: b["title"]),
"2": ("Author (A-Z)", lambda b: b["author"]),
"3": ("Publication Year (Oldest First)", lambda b: b["year"]),
"4": ("Publication Year (Newest First)", lambda b: -b["year"]),
"5": ("Rating (Highest First)", lambda b: -b["rating"]),
"6": ("Number of Pages (Lowest First)", lambda b: b["pages"]),
"7": ("Number of Genres", lambda b: len(b["genres"])),
}
## Print the original list
print_books(books, "Book Catalog")
while True:
## Show sorting options
print("\nHow would you like to sort the books?")
for key, (description, _) in sort_options.items():
print(f"{key}. {description}")
print("0. Exit")
choice = input("\nEnter your choice (0-7): ")
if choice == "0":
print("Thank you for using the Book Sorter. Goodbye!")
break
elif choice in sort_options:
description, sort_key = sort_options[choice]
sorted_books = sorted(books, key=sort_key)
print_books(sorted_books, f"Books Sorted by {description}")
else:
print("Invalid choice. Please try again.")Ejecuta esta versión interactiva:
python3 interactive_book_sorter.pyEsto te permitirá seleccionar diferentes opciones de ordenamiento y ver los resultados. Cuando hayas terminado, ingresa "0" para salir del programa.
La aplicación interactiva demuestra cómo las funciones lambda facilitan la implementación de varias opciones de ordenamiento en una aplicación real. Cada opción de ordenamiento es simplemente una función lambda que extrae la información relevante del diccionario del libro.
Felicitaciones por completar este tutorial sobre el uso de funciones lambda para la ordenación personalizada en Python. Has aprendido:
sorted() y .sort()).Estas habilidades serán increíblemente útiles para el procesamiento, análisis y manipulación de datos en tus futuros proyectos de Python. Las funciones lambda proporcionan una forma concisa y poderosa de personalizar el comportamiento de ordenamiento, haciendo que tu código sea más expresivo y fácil de mantener.
A medida que continúes tu viaje en Python, descubrirás que las funciones lambda son útiles no solo para ordenar, sino también para otras funciones de orden superior como map(), filter() y reduce(). Las técnicas que has aprendido en este tutorial servirán como una base sólida para estas aplicaciones más avanzadas.
