소개
Python 의 람다 함수는 사용자 정의 정렬 작업을 수행하는 간결하고 강력한 방법을 제공합니다. 이 튜토리얼에서는 람다 함수를 사용하여 Python 에서 데이터를 정렬하는 방법을 살펴보고, 데이터 조작 및 분석을 위한 새로운 가능성을 열어보겠습니다. 이 튜토리얼을 마치면 사용자 정의 정렬을 위해 람다 함수를 활용하는 데 대한 확실한 이해를 갖게 되며, 이러한 기술을 자신의 Python 프로젝트에 적용할 수 있게 될 것입니다.
람다 함수 이해하기
Python 에서 람다 함수는 lambda 키워드로 정의된 작고 익명적인 함수입니다. def 키워드를 사용하는 일반 함수와 달리, 람다 함수는 인라인으로 생성될 수 있으며 별도의 정의가 필요하지 않습니다.
람다 함수를 탐구하기 위해 새로운 Python 파일을 만들어 보겠습니다. WebIDE 를 열고 /home/labex/project/lambda_sorting 디렉토리에 basic_lambda.py라는 새 파일을 만듭니다.
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)}")이제 터미널에서 이 파일을 실행해 보겠습니다.
python3 basic_lambda.py다음과 같은 출력을 볼 수 있습니다.
Using regular function: 5² = 25
Using lambda function: 5² = 25
3 + 4 = 7람다 함수는 특히 map(), filter(), 또는 sorted()와 같은 함수를 사용할 때, 짧은 기간 동안 간단한 함수가 필요할 때 유용합니다. map() 함수와 함께 람다를 사용하는 또 다른 예제를 만들어 보겠습니다.
다음 내용으로 lambda_with_map.py라는 새 파일을 만듭니다.
## 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}")이 파일을 실행합니다.
python3 lambda_with_map.py다음과 같은 출력을 볼 수 있습니다.
Original numbers: [1, 2, 3, 4, 5]
Squared numbers: [1, 4, 9, 16, 25]
Doubled numbers: [2, 4, 6, 8, 10]람다 함수를 정렬에 적용하기 전에 람다 함수를 이해하는 것이 필수적입니다. 다음 단계에서는 Python 의 정렬 함수와 함께 람다 함수를 사용하는 방법을 살펴보겠습니다.
람다 함수를 사용한 기본 정렬
Python 은 컬렉션을 정렬하는 두 가지 주요 방법을 제공합니다: sorted() 함수와 리스트의 .sort() 메서드입니다. 사용자 정의 정렬 로직을 만들기 위해 둘 다 람다 함수와 함께 사용할 수 있습니다.
람다 함수를 사용한 기본 정렬을 탐구하기 위해 basic_sorting.py라는 새 파일을 만들어 보겠습니다.
## 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}")이 파일을 실행합니다.
python3 basic_sorting.py다음과 같은 출력을 볼 수 있습니다.
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']sorted()의 key 매개변수는 비교 전에 각 항목을 변환하는 함수를 사용합니다. 람다 함수는 이러한 변환을 생성하는 간결한 방법을 제공합니다.
이제 더 복잡한 데이터 구조로 정렬해 보겠습니다. 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]}")이 파일을 실행합니다.
python3 sorting_tuples.py다양한 방식으로 정렬된 학생들을 볼 수 있습니다.
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 78다음 단계에서는 람다 함수를 사용한 더 고급 정렬 기술을 살펴보겠습니다.
고급 정렬 기술
이제 기본 사항을 이해했으므로 람다 함수를 사용한 더 고급 정렬 기술을 살펴보겠습니다.
딕셔너리 정렬
딕셔너리는 Python 에서 흔히 사용되는 데이터 구조이며, 딕셔너리 목록을 정렬해야 하는 경우가 많습니다. 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']}")이 파일을 실행합니다.
python3 sorting_dictionaries.py다양한 방식으로 정렬된 제품을 볼 수 있습니다.
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: 15다단계 정렬
때로는 여러 기준을 사용하여 항목을 정렬해야 합니다. 예를 들어, 학생들을 먼저 학년별로 정렬하고, 같은 학년의 학생들을 나이별로 정렬할 수 있습니다.
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']}")이 파일을 실행합니다.
python3 multi_level_sorting.py다음과 같은 출력을 볼 수 있습니다.
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 18람다 함수 내에서 튜플을 사용하여 여러 정렬 기준을 정의하는 방법을 확인하십시오. 튜플의 첫 번째 요소는 기본 정렬 키이고, 후속 요소는 동점 처리에 사용됩니다.
음수 기호 -student["age"]를 사용하여 나이를 내림차순으로 정렬했습니다. 이 기술은 숫자를 역순으로 정렬하려는 경우에 유용합니다.
사용자 정의 객체 정렬
마지막 예제를 만들어 사용자 정의 클래스 객체를 정렬하는 방법을 보여 드리겠습니다. 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}")이 파일을 실행합니다.
python3 sorting_objects.py다음과 같은 출력을 볼 수 있습니다.
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)이 예제는 람다 함수를 사용하여 속성에 직접 액세스하여 사용자 정의 객체를 정렬하는 방법을 보여줍니다.
실제 사용 사례 정렬
이제 배운 내용을 좀 더 현실적인 데이터 분석 시나리오에 적용해 보겠습니다. 책 데이터 세트를 분석하고 다양한 기준에 따라 정렬할 수 있는 프로그램을 만들 것입니다.
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}")이 파일을 실행합니다.
python3 book_analyzer.py다양한 방식으로 정렬된 책을 볼 수 있습니다.
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]이 예제는 람다 함수를 실제 응용 프로그램에서 사용하여 유연한 정렬 기능을 제공하는 방법을 보여줍니다. 람다 함수와 해당 설명을 딕셔너리에 저장하여 실제 응용 프로그램에서 더 많은 정렬 옵션을 쉽게 추가할 수 있습니다.
사용자가 정렬 옵션을 선택할 수 있는 대화형 버전을 만들어 보겠습니다. 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.")이 대화형 버전을 실행합니다.
python3 interactive_book_sorter.py이렇게 하면 다양한 정렬 옵션을 선택하고 결과를 볼 수 있습니다. 완료되면 "0"을 입력하여 프로그램을 종료합니다.
대화형 응용 프로그램은 람다 함수가 실제 응용 프로그램에서 다양한 정렬 옵션을 쉽게 구현할 수 있도록 하는 방법을 보여줍니다. 각 정렬 옵션은 책 딕셔너리에서 관련 정보를 추출하는 람다 함수일 뿐입니다.
요약
Python 에서 사용자 정의 정렬을 위해 람다 함수를 사용하는 이 튜토리얼을 완료하신 것을 축하드립니다. 다음을 배웠습니다.
- 람다 함수의 기본 사항과 일반 함수와의 차이점
- Python 의 정렬 함수 (
sorted()및.sort()) 와 함께 람다 함수를 사용하는 방법 - 다양한 데이터 구조를 정렬하는 기술:
- 단순 값 목록
- 튜플 목록
- 딕셔너리 목록
- 사용자 정의 객체
- 람다 함수에서 튜플을 사용한 다단계 정렬
- 실제 데이터 분석 응용 프로그램에서 람다 함수를 적용하는 방법
이러한 기술은 향후 Python 프로젝트에서 데이터 처리, 분석 및 조작에 매우 유용할 것입니다. 람다 함수는 정렬 동작을 사용자 정의하는 간결하고 강력한 방법을 제공하여 코드를 더 표현력 있게 만들고 유지 관리를 용이하게 합니다.
Python 여정을 계속 진행하면서 람다 함수가 정렬뿐만 아니라 map(), filter(), reduce()와 같은 다른 고차 함수에도 유용하다는 것을 알게 될 것입니다. 이 튜토리얼에서 배운 기술은 이러한 더 고급 응용 프로그램의 견고한 기반이 될 것입니다.
