Functions and Lambda FunctionsIn programming, a function is a block of organized, reusable code that is used to perform a single, related action. Functions provide better modularity for your application and a high degree of code reusing. They allow you to break down a complex problem into smaller, manageable sub-problems, making your code easier to read, understand, and maintain.
Standard Functions (using `def`)
Standard functions in Python are defined using the `def` keyword, followed by the function name, a set of parentheses that may contain parameters, and a colon. The function body is indented below the definition. Functions can take zero or more arguments (inputs) and can return a value using the `return` keyword. If no `return` statement is present, the function implicitly returns `None`.
Key characteristics:
- Defined with the `def` keyword.
- Can contain multiple expressions and statements.
- Can have a docstring.
- Can be named.
- Used for more complex logic and code organization.
Lambda Functions (Anonymous Functions)
Lambda functions are small, anonymous functions defined using the `lambda` keyword. They are also known as anonymous functions because they don't have a name like standard functions. A lambda function can take any number of arguments, but can only have one expression. The result of this expression is the return value of the lambda function.
Key characteristics:
- Defined with the `lambda` keyword.
- Anonymous (no name).
- Can only contain a single expression, not multiple statements.
- Cannot have a docstring.
- Typically used for short, throwaway functions, often as arguments to higher-order functions like `map()`, `filter()`, or `sorted()`.
- Their primary use is to simplify code when a function is needed for a brief period and doesn't require a formal `def` definition.
Differences and Use Cases
- `def` functions are for reusable blocks of code that might perform multiple operations or have complex logic. They promote code organization and reusability.
- `lambda` functions are for concise, single-expression operations. They are often used when you need a simple function as an argument to another function, avoiding the overhead of formally defining a named function that might only be used once. For example, sorting a list of tuples based on a specific element or filtering a list based on a simple condition.
In essence, `def` is for defining full-fledged functions, while `lambda` is for creating small, inline, anonymous functions when brevity and simplicity are desired.
Example Code
import math
--- Standard Functions (using def) ---
Example 1: A function that adds two numbers
def add_numbers(a, b):
"""This function takes two numbers and returns their sum."""
return a + b
print(f"Using def function (add_numbers): {add_numbers(5, 3)}") Output: Using def function (add_numbers): 8
Example 2: A function that squares a number
def square(x):
"""This function takes a number and returns its square."""
return x - x
numbers = [1, 2, 3, 4, 5]
squared_numbers = list(map(square, numbers))
print(f"Using def function with map (square): {squared_numbers}") Output: Using def function with map (square): [1, 4, 9, 16, 25]
Example 3: A function to check if a number is even
def is_even(num):
"""This function checks if a number is even."""
return num % 2 == 0
even_numbers = list(filter(is_even, numbers))
print(f"Using def function with filter (is_even): {even_numbers}") Output: Using def function with filter (is_even): [2, 4]
--- Lambda Functions ---
Example 1: Lambda function to add two numbers
add_lambda = lambda a, b: a + b
print(f"Using lambda function (add_lambda): {add_lambda(10, 7)}") Output: Using lambda function (add_lambda): 17
Example 2: Lambda function to square a number, used with map
Equivalent to the 'square' def function above
squared_numbers_lambda = list(map(lambda x: x - x, numbers))
print(f"Using lambda function with map: {squared_numbers_lambda}") Output: Using lambda function with map: [1, 4, 9, 16, 25]
Example 3: Lambda function to check if a number is even, used with filter
Equivalent to the 'is_even' def function above
even_numbers_lambda = list(filter(lambda num: num % 2 == 0, numbers))
print(f"Using lambda function with filter: {even_numbers_lambda}") Output: Using lambda function with filter: [2, 4]
Example 4: Sorting a list of tuples using a lambda function as a key
We want to sort by the second element of each tuple
students = [('Alice', 90), ('Bob', 75), ('Charlie', 95), ('David', 80)]
Sort by score (second element)
sorted_students_by_score = sorted(students, key=lambda student: student[1])
print(f"Sorted students by score (lambda): {sorted_students_by_score}")
Output: Sorted students by score (lambda): [('Bob', 75), ('David', 80), ('Alice', 90), ('Charlie', 95)]
Example 5: Combining map with a lambda function for more complex operations
Calculate the square root of each number in a list
numbers_float = [1.0, 4.0, 9.0, 16.0]
square_roots = list(map(lambda x: math.sqrt(x), numbers_float))
print(f"Square roots using lambda and map: {square_roots}")
Output: Square roots using lambda and map: [1.0, 2.0, 3.0, 4.0]