Objective

In this unit, we will learn about lambda functions in Python. Lambda functions are small, anonymous functions that are defined with the lambda keyword, rather than the def keyword. By the end of this unit, you will understand how to create and use lambda functions, and you will know the differences between normal functions and lambda functions.

Understanding Lambda Functions

A lambda function is a small anonymous function. It can take any number of arguments, but can only have one expression. The syntax to create a lambda function is:

lambda arguments: expression

The expression is executed and the result is returned when the lambda function is called. Here's an example of a lambda function that adds two numbers:

add = lambda x, y: x + y

You can call this function just like a normal function:

result = add(5, 3)
print(result)  # Outputs: 8

Creating and Using Lambda Functions

Lambda functions are used when you need a small function for a short period of time, and you don't want to define a full function using def. They are often used in conjunction with functions like map(), filter(), and reduce().

Here's an example of using a lambda function with the map() function:

numbers = [1, 2, 3, 4, 5]
squares = map(lambda x: x ** 2, numbers)
print(list(squares))  # Outputs: [1, 4, 9, 16, 25]

In this example, map() applies the lambda function to every item in the numbers list. The lambda function takes one argument x and returns x ** 2, which is the square of x.

Differences Between Normal Functions and Lambda Functions

While lambda functions can be very useful, they have some limitations compared to normal functions:

1. Lambda functions are limited to a single expression and cannot include complex logic.
2. Lambda functions can't include statements like assignment or while.
3. Lambda functions don't have a name and can't be referenced later in your code.

Despite these limitations, lambda functions are a powerful tool when you need to define a quick, small function for tasks such as sorting, filtering, or mapping data.

Project: Using Lambda Functions to Control the Color of Shapes

In this project, you'll use a lambda function to control the color of shapes drawn with the Turtle library. Here's an example:

import turtle

# Create a new turtle screen and set its background color
screen = turtle.Screen()
screen.bgcolor("white")

# Initialize a turtle object
t = turtle.Turtle()

# Function to draw a square
def draw_square(turtle, side_length):
    for _ in range(4):
        turtle.forward(side_length)
        turtle.right(90)

# Lambda function to determine color
get_color = lambda x: "red" if x % 2 == 0 else "blue"

# Draw a pattern of squares with different colors
for i in range(36):
    t.color(get_color(i))
    draw_square(t, 100)
    t.right(10)

# Hide the turtle and wait until the window is closed
t.hideturtle()
turtle.done()

In this program, we define a lambda function get_color that takes one argument x. If x is even, the function returns "red", otherwise it returns "blue". We use this function to set the color of the turtle before drawing each square. As a result, the squares alternate between red and blue.

Try to modify this program to use different colors or shapes!

In the next unit, we'll look at Turtle events and explore how we can make our Turtle graphics interactive.