Python Programming

Python Lambda Functions, List Comprehensions, and Modules

Introduction

As Python programs become larger, we need:

Short functions for simple tasks
Faster ways to create lists
Better code organization
Reusable code across multiple files

Python provides:

Lambda Functions
List Comprehensions
Modules
Import Statements

These concepts are heavily used in:

Automation
Django
Flask
Data Science
Machine Learning
Real-world Applications

Anonymous (Lambda) Function

What is a Lambda Function?

A lambda function is a small anonymous function.

Anonymous means:

Function without a name

Normal functions use:

def

Lambda functions use:

lambda

Why Use Lambda?

Useful when:

Function is very small
Used only once
Passed to another function
Sorting data
Filtering data
Data processing

Syntax

lambda parameters: expression

Structure:

lambda
   ↓
parameters
   ↓
expression

Normal Function Example

def square(n):
    return n * n

print(square(5))

Output:

Lambda Version

square = lambda n: n * n

print(square(5))

Output:

Multiple Parameters

add = lambda a, b: a + b

print(add(10, 20))

Output:

Three Parameters

total = lambda a, b, c: a + b + c

print(total(10, 20, 30))

Output:

Lambda Returning Boolean

is_even = lambda n: n % 2 == 0

print(is_even(10))

Output:

True

Lambda with String

greet = lambda name: "Hello " + name

print(greet("Rahul"))

Output:

Hello Rahul

Lambda vs Normal Function

Normal Function	Lambda Function
Uses def	Uses lambda
Can contain many statements	Only one expression
Can have multiple lines	Single line
Easier for complex logic	Best for simple logic

Limitations of Lambda

Lambda can contain only:

One Expression

Invalid Lambda

❌ Wrong

lambda x:

    y = x + 1

    return y

Correct

lambda x: x + 1

Common Lambda Mistakes

Mistake 1

Using Lambda for Large Logic

❌ Bad

lambda x: complicated_program

Use normal functions instead.

Mistake 2

Trying to Use Multiple Statements

❌ Wrong

lambda x:

    print(x)

    return x

Mistake 3

Forgetting Assignment

❌ Wrong

lambda x: x * x

Function created but not stored.

✅ Correct

square = lambda x: x * x

List Comprehension

What is List Comprehension?

List comprehension provides a shorter way to create lists.

Without list comprehension:

numbers = []

for i in range(5):
    numbers.append(i)

print(numbers)

Output:

[0, 1, 2, 3, 4]

List Comprehension Version

numbers = [i for i in range(5)]

print(numbers)

Output:

[0, 1, 2, 3, 4]

Syntax

[expression for item in iterable]

Visual Representation

Expression
     ↓

for item in iterable

     ↓

Create List

Example 1

numbers = [x for x in range(1, 6)]

print(numbers)

Output:

[1, 2, 3, 4, 5]

Example 2: Squares

Without comprehension:

result = []

for i in range(1, 6):
    result.append(i * i)

Using comprehension:

result = [i * i for i in range(1, 6)]

print(result)

Output:

[1, 4, 9, 16, 25]

Example 3: Cubes

cubes = [i ** 3 for i in range(1, 6)]

print(cubes)

Output:

[1, 8, 27, 64, 125]

Conditional List Comprehension

Syntax:

[expression for item in iterable if condition]

Example: Even Numbers

evens = [i for i in range(10) if i % 2 == 0]

print(evens)

Output:

[0, 2, 4, 6, 8]

Example: Odd Numbers

odds = [i for i in range(10) if i % 2 != 0]

print(odds)

Output:

[1, 3, 5, 7, 9]

Example: Uppercase Strings

names = ["john", "alice", "bob"]

result = [name.upper() for name in names]

print(result)

Output:

['JOHN', 'ALICE', 'BOB']

Nested List Comprehension

pairs = [(x, y)
         for x in range(3)
         for y in range(3)]

print(pairs)

Output:

[(0,0), (0,1), (0,2),
 (1,0), (1,1), (1,2),
 (2,0), (2,1), (2,2)]

Common List Comprehension Mistakes

Mistake 1

Using Parentheses Instead of Brackets

❌ Wrong

numbers = (x for x in range(5))

Creates generator, not list.

Mistake 2

Wrong Order

❌ Wrong

[i if i % 2 == 0 for i in range(10)]

✅ Correct

[i for i in range(10) if i % 2 == 0]

Mistake 3

Making Comprehensions Too Complex

Avoid very long comprehensions.

Use loops when readability suffers.

What is a Module?

A module is a Python file containing code.

Example:

calculator.py

Anything saved inside:

calculator.py

becomes a module.

Why Use Modules?

Benefits:

Code Reusability
Better Organization
Easier Maintenance
Less Duplication
Cleaner Projects

Defining a Module

A module is simply:

A Python file (.py)

Example:

math_tools.py

Create Your First Module

Create file:

calculator.py

Content:

def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

Save the file.

You have created a module.

Project Structure

project/

│
├── calculator.py
└── main.py

Importing Module

Import Entire Module

main.py

import calculator

print(calculator.add(10, 20))

print(calculator.subtract(30, 5))

Output:

30
25

How It Works

main.py
     ↓
imports
     ↓
calculator.py
     ↓
uses functions

Example with More Functions

calculator.py

def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

def multiply(a, b):
    return a * b

def divide(a, b):
    return a / b

main.py

import calculator

print(calculator.add(10, 5))

print(calculator.multiply(10, 5))

print(calculator.divide(20, 4))

Output:

15
50
5.0

Import Specific Function

Instead of importing everything:

from calculator import add

Example:

from calculator import add

print(add(10, 20))

Output:

Import Multiple Functions

from calculator import add, subtract

Example:

print(add(10, 20))

print(subtract(20, 10))

Import All Functions

from calculator import *

Example:

print(add(5, 5))

print(subtract(10, 3))

⚠ Generally not recommended.

Reason:

Namespace pollution

Import with Alias

import calculator as calc

Example:

print(calc.add(10, 20))

Output:

Function Call from Imported Module

Example:

calculator.py

def square(n):
    return n * n

main.py

import calculator

print(calculator.square(5))

Output:

Built-in Modules

Python already provides many modules.

Examples:

Module	Purpose
math	Mathematical operations
random	Random numbers
datetime	Date and time
os	Operating system
sys	System information

Example: math Module

import math

print(math.sqrt(25))

Output:

5.0

Example: random Module

import random

print(random.randint(1, 10))

Possible Output:

Common Module Mistakes

Mistake 1

Wrong File Name

❌

Calculator.py

Importing:

import calculator

May fail depending on OS.

Mistake 2

Misspelling Function Name

calculator.ad()

Output:

AttributeError

Mistake 3

Forgetting Module Prefix

import calculator

add(10, 20)

Output:

NameError

✅ Correct

calculator.add(10, 20)

Mistake 4

Circular Imports

Avoid:

A imports B

B imports A

Homework 1

Create a lambda function that doubles a number.

Solution

double = lambda x: x * 2

print(double(10))

Output:

Homework 2

Create a lambda function to find the larger number.

Solution

largest = lambda a, b: a if a > b else b

print(largest(10, 20))

Output:

Homework 3

Create a list of squares from 1 to 10 using list comprehension.

Solution

squares = [i * i for i in range(1, 11)]

print(squares)

Homework 4

Create a list of even numbers from 1 to 50.

Solution

evens = [i for i in range(1, 51)
         if i % 2 == 0]

print(evens)

Homework 5

Create a module named calculator.py with:

add
subtract

functions.

Use them in main.py.

Solution

calculator.py

def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

main.py

import calculator

print(calculator.add(10, 20))

print(calculator.subtract(20, 5))

Output:

30
15

Homework 6

Import add() only from calculator.py.

Solution

from calculator import add

print(add(10, 20))

Output:

Homework 7

Import calculator module using alias.

Solution

import calculator as calc

print(calc.add(5, 5))

Output:

Quick Revision

Topic	Description
Lambda Function	Anonymous function
lambda	Creates anonymous function
List Comprehension	Short way to create lists
Module	Python file
import	Imports module
from module import	Imports specific item
Alias	Alternate module name
Built-in Module	Module provided by Python

Summary

Concept	Key Point
Lambda Function	Small one-line function
List Comprehension	Compact list creation
Module	Reusable Python file
Import	Access code from another file
Alias	Short module name
Built-in Modules	math, random, os, datetime
User Module	Created by programmer
Reusability	Major benefit of modules

Before moving to the next chapter, make sure you can:

✅ Write lambda functions

✅ Convert loops into list comprehensions

✅ Create your own module

✅ Import modules correctly

✅ Use aliases

✅ Create multi-function modules

✅ Build a calculator module and use it from another file

Introduction

Anonymous (Lambda) Function

What is a Lambda Function?

Why Use Lambda?

Syntax

Normal Function Example

Lambda Version

Multiple Parameters

Three Parameters

Lambda Returning Boolean

Lambda with String

Lambda vs Normal Function

Limitations of Lambda

Invalid Lambda

Correct

Common Lambda Mistakes

Mistake 1

Mistake 2

Mistake 3

List Comprehension

What is List Comprehension?

List Comprehension Version

Syntax

Visual Representation

Example 1

Example 2: Squares

Example 3: Cubes

Conditional List Comprehension

Example: Even Numbers

Example: Odd Numbers

Example: Uppercase Strings

Nested List Comprehension

Common List Comprehension Mistakes

Mistake 1

Mistake 2

Mistake 3

What is a Module?

Why Use Modules?

Defining a Module

Create Your First Module

Project Structure

Importing Module

Import Entire Module

How It Works

Example with More Functions

Import Specific Function

Import Multiple Functions

Import All Functions

Import with Alias

Function Call from Imported Module

Built-in Modules

Example: math Module

Example: random Module

Common Module Mistakes

Mistake 1

Mistake 2

Mistake 3

Mistake 4

Homework 1

Solution

Homework 2

Solution

Homework 3

Solution

Homework 4

Solution

Homework 5

Solution

Homework 6

Solution

Homework 7

Solution

Quick Revision

Summary

Python Programming

Filters