Python 프로그래밍 세계에서 인라인 함수는 정식 함수 정의 없이 작고 단일 표현식 함수를 생성하는 강력하고 간결한 방법을 제공합니다. Python 에서 람다 함수 (lambda functions) 로 알려진 이러한 인라인 함수는 간단한 연산과 함수형 프로그래밍 기법에 특히 유용합니다. 이 튜토리얼은 람다 함수를 생성하고 사용하여 더 우아하고 효율적인 Python 코드를 작성하는 방법을 안내합니다.
Python 에서 람다 함수는 표준 def 문 대신 lambda 키워드를 사용하여 정의된 작고 익명적인 함수입니다. 람다 함수는 전통적인 함수처럼 이름을 필요로 하지 않기 때문에 "익명 (anonymous)"이라고 불립니다.
람다 함수의 기본 구문은 다음과 같습니다.
lambda arguments: expression람다 함수는 단일 표현식으로 제한되며, 해당 표현식의 결과를 자동으로 반환합니다.
몇 가지 간단한 람다 함수를 생성하고 테스트해 보겠습니다.
코드 편집기에서 새 Python 파일을 엽니다. WebIDE 에서 "File" > "New File"을 클릭하고 /home/labex/project 디렉토리에 lambda_basics.py로 저장합니다.
첫 번째 람다 함수를 생성하기 위해 다음 코드를 추가합니다.
## A simple lambda function that squares a number
square = lambda x: x * x
## Testing the lambda function
result = square(5)
print(f"The square of 5 is: {result}")python3 ~/project/lambda_basics.py다음 출력을 볼 수 있습니다.
The square of 5 is: 25람다 함수를 해당 일반 함수와 비교해 보겠습니다.
lambda_basics.py 파일에 다음 코드를 추가합니다.## Regular function that adds two numbers
def add_regular(a, b):
return a + b
## Equivalent lambda function
add_lambda = lambda a, b: a + b
## Testing both functions
print(f"Regular function: 3 + 5 = {add_regular(3, 5)}")
print(f"Lambda function: 3 + 5 = {add_lambda(3, 5)}")python3 ~/project/lambda_basics.py이제 다음을 볼 수 있습니다.
The square of 5 is: 25
Regular function: 3 + 5 = 8
Lambda function: 3 + 5 = 8람다 함수는 다음과 같은 경우에 가장 유용합니다.
매개변수가 여러 개인 예제를 하나 더 만들어 보겠습니다.
lambda_basics.py 파일에 다음 코드를 추가합니다.## Lambda function with multiple parameters
calculate = lambda x, y, z: x * y + z
## Testing with different values
result1 = calculate(2, 3, 4)
result2 = calculate(5, 2, 1)
print(f"2 * 3 + 4 = {result1}")
print(f"5 * 2 + 1 = {result2}")python3 ~/project/lambda_basics.py추가 출력을 볼 수 있습니다.
2 * 3 + 4 = 10
5 * 2 + 1 = 11람다 함수는 간단한 한 줄 함수를 생성하는 데 이상적입니다. 전체 함수 정의가 필요하지 않을 때 코드를 간결하게 작성할 수 있는 방법을 제공합니다. 다음 단계에서는 더 강력한 연산을 위해 Python 의 내장 함수와 함께 람다 함수를 사용하는 방법을 살펴보겠습니다.
람다 함수는 map(), filter(), sorted()와 같은 Python 의 내장 함수와 결합될 때 특히 강력해집니다. 이러한 조합을 통해 데이터 변환 및 조작을 위한 효율적인 코드를 작성할 수 있습니다.
map() 함수와 람다map() 함수는 주어진 함수를 반복 가능한 객체 (예: 리스트) 의 각 항목에 적용하고 결과를 포함하는 맵 객체를 반환합니다.
/home/labex/project 디렉토리에 lambda_builtin.py라는 새 파일을 생성합니다.
map()을 람다와 함께 사용하는 것을 보여주기 위해 다음 코드를 추가합니다.
## Using map() with a lambda function to square each number in a list
numbers = [1, 2, 3, 4, 5]
squared_numbers = list(map(lambda x: x**2, numbers))
print("Original numbers:", numbers)
print("Squared numbers:", squared_numbers)python3 ~/project/lambda_builtin.py다음과 같은 출력을 볼 수 있습니다.
Original numbers: [1, 2, 3, 4, 5]
Squared numbers: [1, 4, 9, 16, 25]filter() 함수와 람다filter() 함수는 조건을 만족하는 요소 (함수가 True 를 반환) 로 새 반복 가능한 객체를 생성합니다.
lambda_builtin.py 파일에 다음 코드를 추가합니다.## Using filter() with a lambda function to find even numbers
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print("All numbers:", numbers)
print("Even numbers:", even_numbers)
## Using filter() to find names that start with 'J'
names = ["Alice", "Bob", "John", "Jane", "Michael", "Jessica"]
j_names = list(filter(lambda name: name.startswith('J'), names))
print("All names:", names)
print("Names starting with J:", j_names)python3 ~/project/lambda_builtin.py추가 출력을 볼 수 있습니다.
All numbers: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Even numbers: [2, 4, 6, 8, 10]
All names: ['Alice', 'Bob', 'John', 'Jane', 'Michael', 'Jessica']
Names starting with J: ['John', 'Jane', 'Jessica']sorted() 함수와 람다sorted() 함수를 사용하면 사용자 지정 키 함수를 사용하여 반복 가능한 객체를 정렬할 수 있으며, 람다 함수가 매우 유용한 곳입니다.
lambda_builtin.py 파일에 다음 코드를 추가합니다.## Using sorted() with lambda to sort by the second element of tuples
pairs = [(1, 5), (3, 2), (5, 7), (2, 9), (4, 1)]
sorted_by_second = sorted(pairs, key=lambda pair: pair[1])
print("Original pairs:", pairs)
print("Sorted by second element:", sorted_by_second)
## Using sorted() with lambda to sort strings by length
words = ["apple", "banana", "cherry", "date", "elderberry", "fig"]
sorted_by_length = sorted(words, key=lambda word: len(word))
print("Original words:", words)
print("Sorted by length:", sorted_by_length)python3 ~/project/lambda_builtin.py추가 출력을 볼 수 있습니다.
Original pairs: [(1, 5), (3, 2), (5, 7), (2, 9), (4, 1)]
Sorted by second element: [(4, 1), (3, 2), (1, 5), (5, 7), (2, 9)]
Original words: ['apple', 'banana', 'cherry', 'date', 'elderberry', 'fig']
Sorted by length: ['fig', 'date', 'apple', 'cherry', 'banana', 'elderberry']람다 함수를 사용하여 여러 연산을 연결하거나 결합할 수도 있습니다.
lambda_builtin.py 파일에 다음 코드를 추가합니다.## Combining map and filter with lambda functions
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
## First square the numbers, then filter for values greater than 20
result = list(filter(lambda x: x > 20, map(lambda x: x**2, numbers)))
print("Original numbers:", numbers)
print("Squared numbers > 20:", result)python3 ~/project/lambda_builtin.py추가 출력을 볼 수 있습니다.
Original numbers: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Squared numbers > 20: [25, 36, 49, 64, 81, 100]map(), filter(), sorted()와 같은 내장 함수와 함께 람다 함수를 사용하면 최소한의 코드로 데이터를 처리하는 강력한 방법을 제공합니다. 다음 단계에서는 람다 함수의 더 실용적인 응용 프로그램을 살펴보겠습니다.
이 단계에서는 조건 논리와 실제 시나리오에서의 사용을 포함하여 람다 함수의 실용적인 응용 사례를 살펴봅니다.
람다 함수는 파이썬의 삼항 연산자 구문 x if 조건 else y를 사용하여 조건식을 포함할 수 있습니다.
/home/labex/project 디렉토리에 lambda_practical.py라는 새 파일을 만듭니다.
조건부 람다 함수를 보여주는 다음 코드를 추가합니다.
## 조건식을 사용한 람다 함수
get_status = lambda score: "Pass" if score >= 60 else "Fail"
## 다양한 점수로 함수를 테스트합니다.
scores = [45, 90, 60, 30, 75]
for score in scores:
status = get_status(score)
print(f"점수: {score}, 상태: {status}")python3 ~/project/lambda_practical.py다음과 같은 결과를 볼 수 있습니다.
점수: 45, 상태: Fail
점수: 90, 상태: Pass
점수: 60, 상태: Pass
점수: 30, 상태: Fail
점수: 75, 상태: Pass람다 함수는 계산기와 같은 간단한 유틸리티 함수를 만드는 데 적합합니다.
lambda_practical.py 파일에 다음 코드를 추가합니다.## 람다 함수를 사용한 계산기 만들기
operations = {
'add': lambda x, y: x + y,
'subtract': lambda x, y: x - y,
'multiply': lambda x, y: x * y,
'divide': lambda x, y: x / y if y != 0 else "0 으로 나눌 수 없습니다"
}
## 계산기를 테스트합니다.
a, b = 10, 2
for operation, func in operations.items():
result = func(a, b)
print(f"{a} {operation} {b} = {result}")
## 0 으로 나누는 경우 테스트
print(f"10 나누기 0 = {operations['divide'](10, 0)}")python3 ~/project/lambda_practical.py추가적인 출력을 볼 수 있습니다.
10 add 2 = 12
10 subtract 2 = 8
10 multiply 2 = 20
10 divide 2 = 5.0
10 divide 0 = 0으로 나눌 수 없습니다람다 함수는 데이터 구조를 변환하는 데 매우 적합합니다.
lambda_practical.py 파일에 다음 코드를 추가합니다.## 람다 함수를 사용한 사전 목록 처리
employees = [
{'name': 'Alice', 'salary': 90000, 'department': 'Engineering'},
{'name': 'Bob', 'salary': 75000, 'department': 'Marketing'},
{'name': 'Charlie', 'salary': 60000, 'department': 'Engineering'},
{'name': 'David', 'salary': 85000, 'department': 'HR'},
{'name': 'Eve', 'salary': 120000, 'department': 'Engineering'}
]
## Engineering 부서 직원을 찾아 급여 기준으로 정렬
engineering_employees = sorted(
filter(lambda emp: emp['department'] == 'Engineering', employees),
key=lambda emp: emp['salary'],
reverse=True
)
print("Engineering 부서 직원 (급여 높은 순):")
for employee in engineering_employees:
print(f" {employee['name']}: ${employee['salary']}")
## 평균 급여 계산
average_salary = sum(map(lambda emp: emp['salary'], employees)) / len(employees)
print(f"\n평균 급여: ${average_salary:.2f}")
## 평균 급여 초과 직원 찾기
above_average = list(filter(lambda emp: emp['salary'] > average_salary, employees))
print(f"\n평균 급여 초과 직원:")
for employee in above_average:
print(f" {employee['name']}: ${employee['salary']} ({employee['department']})")python3 ~/project/lambda_practical.py추가적인 출력을 볼 수 있습니다.
Engineering 부서 직원 (급여 높은 순):
Eve: $120000
Alice: $90000
Charlie: $60000
평균 급여: $86000.00
평균 급여 초과 직원:
Alice: $90000 (Engineering)
Eve: $120000 (Engineering)람다 함수는 GUI 응용 프로그램에서 이벤트 핸들러로 일반적으로 사용됩니다. 이를 보여주기 위해 간단한 Tkinter 응용 프로그램을 만들어 보겠습니다.
/home/labex/project 디렉토리에 lambda_gui.py라는 새 파일을 추가합니다.sudo apt update
sudo apt install python3-tk -y## ... (이전 코드와 동일)python3 ~/project/lambda_gui.py
이제 람다 함수가 간단한 데이터 처리에서 GUI 및 데이터 변환과 같은 더 복잡한 응용 프로그램에 이르기까지 다양한 실용적인 시나리오에 적용될 수 있는 방법을 보았습니다.
이 마지막 단계에서는 중첩된 람다, 클로저 (closure), 고차 함수를 포함하여 람다 함수를 사용하는 몇 가지 고급 기술을 살펴보겠습니다.
람다 함수는 다른 함수에서 생성되어 반환될 수 있으며, 동적 함수 생성을 허용합니다.
/home/labex/project 디렉토리에 lambda_advanced.py라는 새 파일을 생성합니다.
다음 코드를 추가합니다.
## Function that returns a lambda function
def create_multiplier(factor):
"""Returns a function that multiplies its input by the given factor."""
return lambda x: x * factor
## Create specific multiplier functions
double = create_multiplier(2)
triple = create_multiplier(3)
quadruple = create_multiplier(4)
## Test the multiplier functions
number = 10
print(f"Original number: {number}")
print(f"Double: {double(number)}")
print(f"Triple: {triple(number)}")
print(f"Quadruple: {quadruple(number)}")python3 ~/project/lambda_advanced.py다음과 같은 출력을 볼 수 있습니다.
Original number: 10
Double: 20
Triple: 30
Quadruple: 40람다를 사용하여 일련의 연산을 생성하기 위해 함수를 합성할 수 있습니다.
lambda_advanced.py 파일에 다음 코드를 추가합니다.## Function composition using lambda
def compose(f, g):
"""Returns a function that applies f after g."""
return lambda x: f(g(x))
## Create component functions
square = lambda x: x * x
increment = lambda x: x + 1
decrement = lambda x: x - 1
## Create composite functions
square_then_increment = compose(increment, square)
increment_then_square = compose(square, increment)
complex_operation = compose(square, compose(increment, square))
## Test the composite functions
value = 5
print(f"\nOriginal value: {value}")
print(f"square_then_increment: {square_then_increment(value)}") ## (5² = 25) + 1 = 26
print(f"increment_then_square: {increment_then_square(value)}") ## (5 + 1)² = 36
print(f"complex_operation: {complex_operation(value)}") ## ((5² = 25) + 1)² = 676python3 ~/project/lambda_advanced.py추가 출력을 볼 수 있습니다.
Original value: 5
square_then_increment: 26
increment_then_square: 36
complex_operation: 676람다가 정의되는 방식 때문에 Python 에서 진정한 재귀 람다 함수를 만드는 것은 어렵습니다. 그러나 Y combinator를 사용하여 재귀 람다 함수를 만들 수 있습니다.
lambda_advanced.py 파일에 다음 코드를 추가합니다.## Y combinator for creating recursive lambda functions
Y = lambda f: (lambda x: x(x))(lambda y: f(lambda *args: y(y)(*args)))
## Creating a recursive factorial function using lambda and the Y combinator
factorial = Y(lambda f: lambda n: 1 if n <= 0 else n * f(n - 1))
## Test the recursive factorial function
for i in range(6):
print(f"factorial({i}) = {factorial(i)}")
## Creating a recursive Fibonacci function using lambda and the Y combinator
fibonacci = Y(lambda f: lambda n: n if n <= 1 else f(n-1) + f(n-2))
## Test the recursive Fibonacci function
print("\nFibonacci sequence:")
for i in range(10):
print(f"fibonacci({i}) = {fibonacci(i)}")python3 ~/project/lambda_advanced.py추가 출력을 볼 수 있습니다.
factorial(0) = 1
factorial(1) = 1
factorial(2) = 2
factorial(3) = 6
factorial(4) = 24
factorial(5) = 120
Fibonacci sequence:
fibonacci(0) = 0
fibonacci(1) = 1
fibonacci(2) = 1
fibonacci(3) = 2
fibonacci(4) = 3
fibonacci(5) = 5
fibonacci(6) = 8
fibonacci(7) = 13
fibonacci(8) = 21
fibonacci(9) = 34부분 함수 적용을 사용하면 기존 함수의 일부 인수를 미리 채워 새 함수를 만들 수 있습니다.
lambda_advanced.py 파일에 다음 코드를 추가합니다.from functools import partial
## Original function with multiple parameters
def power(base, exponent):
return base ** exponent
## Creating specialized functions using partial and lambda
square = partial(power, exponent=2)
cube = partial(power, exponent=3)
## Alternative approach using lambda
square_lambda = lambda x: power(x, 2)
cube_lambda = lambda x: power(x, 3)
## Test both approaches
number = 4
print(f"\nOriginal number: {number}")
print(f"square (partial): {square(number)}")
print(f"cube (partial): {cube(number)}")
print(f"square (lambda): {square_lambda(number)}")
print(f"cube (lambda): {cube_lambda(number)}")
## Partial application with multiple pre-filled arguments
def format_string(prefix, content, suffix):
return f"{prefix}{content}{suffix}"
## Create specialized formatters
html_paragraph = partial(format_string, "<p>", suffix="</p>")
html_div = partial(format_string, "<div>", suffix="</div>")
## Test specialized formatters
content = "Hello, World!"
print(f"\nOriginal content: {content}")
print(f"HTML paragraph: {html_paragraph(content)}")
print(f"HTML div: {html_div(content)}")python3 ~/project/lambda_advanced.py추가 출력을 볼 수 있습니다.
Original number: 4
square (partial): 16
cube (partial): 64
square (lambda): 16
cube (lambda): 64
Original content: Hello, World!
HTML paragraph: <p>Hello, World!</p>
HTML div: <div>Hello, World!</div>이러한 고급 기술은 Python 에서 람다 함수의 유연성과 강력함을 보여줍니다. 람다 함수를 고차 함수, 함수 합성 및 부분 적용과 결합하여 복잡한 문제에 대한 간결하고 우아한 솔루션을 만들 수 있습니다.
이 랩에서는 Python 에서 인라인 함수 (람다 함수) 를 생성하고 사용하는 방법을 배우고, 기본적인 개념에서 고급 기술까지 익혔습니다.
다음은 여러분이 달성한 내용입니다.
기본 람다 함수 - 람다 함수의 구문과 기본 사용법을 배우고, 일반 함수와 비교했으며, 언제 사용해야 하는지 이해했습니다.
내장 함수와 함께 람다 사용하기 - 강력한 데이터 변환을 효율적으로 수행하기 위해 map(), filter(), sorted()와 같은 Python 의 내장 함수와 람다 함수를 결합하는 방법을 탐구했습니다.
실용적인 람다 응용 - 조건식, 간단한 계산기, 데이터 변환 기술을 포함한 실용적인 예제를 구현하여 데이터 컬렉션을 처리했습니다.
고급 람다 기술 - 고차 함수, 함수 합성, Y combinator 를 사용한 재귀 람다 함수, 부분 함수 적용을 탐구하여 복잡한 문제를 간결하게 해결했습니다.
람다 함수는 Python 프로그래밍에서 강력한 도구로, 간결하고 기능적인 프로그래밍 스타일을 허용합니다. 간단한 연산에 가장 적합하지만, 함수에서 인수로 전달되고 반환될 수 있는 능력은 광범위한 응용 분야에서 매우 다재다능하게 만듭니다.
람다 함수를 마스터함으로써, 더 우아하고 효율적인 코드를 작성하는 데 도움이 되는 중요한 도구를 Python 프로그래밍 도구 상자에 추가했습니다.
