Python Function Design

Python Data Types, Operators and OOPs concepts

Now Watching

← Previous

Python Data Operators

Lesson Progress

Python Class Introduction

📄 View Reference Document & Notes

📋 Lesson Notes & Resources

🔧 Python Function - Full Concept Explained

📘 1. Description

A Python Function is a block of reusable code that performs a specific task. Functions help you avoid repetition, make code modular, and improve readability.

It is defined using the def keyword followed by a name, parentheses (), and a colon :.

🔍 2. Example


def greet(name):
    print(f"Hello, {name} 👋!")

greet("Sairam")

🎯 3. Why You Should Learn Functions?

🔁 Reuse your code without repeating it.
📦 Keep your program modular and readable.
🧪 Easier to test and debug.
🧠 Build large applications efficiently.

🧰 4. Use Cases (Tabular Format)

Use Case	Description
Math Calculation	Create functions like `add()`, `subtract()` to calculate numbers
API Handling	Group all HTTP requests in functions (e.g., `get_user_data()`)
File Operations	Write functions to read/write files
Data Cleaning	Use reusable functions to clean and format data
Email Notifications	Send emails using a single function call

📦 5. Realtime Scenarios

✅ Automate sending WhatsApp or email messages using a function.
📈 Read S3 files and apply a reusable parsing function to each file.
🔄 Convert Excel to CSV with reusable conversion logic.
🧹 Clean and validate user input using a function before saving to DB.
💬 Generate dynamic messages using template functions.

📝 6. Practice Tests - Improve Your Function Skills

✍️ Write a function to check if a number is prime
🧮 Write a function to calculate the factorial of a number
📄 Create a function that reads a file and returns line count
📊 Write a function that returns summary statistics from a list
🔐 Write a login validation function with username/password check

🧩 Types of Functions in Python

Function Type	Description	Real-Time Use Case Example
1. Built-in Functions	Predefined functions in Python	`print()`, `len()`, `type()`, `range()`
2. User-defined Functions	Functions created by users using `def` keyword	`def calculate_salary():`, `def send_email():`
3. Lambda Functions	Anonymous functions using `lambda` keyword (single-expression)	Sorting a list of tuples, filtering data with conditions
4. Recursive Functions	A function that calls itself to solve smaller sub-problems	Calculating factorial, Fibonacci series
5. Generator Functions	Use `yield` to return one item at a time without storing the entire sequence	Reading large files line-by-line, paginated API requests
6. Higher-Order Functions	Functions that take other functions as arguments or return functions	`map()`, `filter()`, `reduce()`
7. Nested Functions	Functions defined inside other functions (inner functions)	Scope management, closures, decorators
8. Decorator Functions	Functions that modify the behavior of another function	Logging, authorization, timing a function’s execution
9. Callback Functions	Function passed as argument and called later	Used in UI event handling, asynchronous programming
10. Partial Functions	Pre-filling arguments using `functools.partial`	Pre-define behavior like setting currency in conversion APIs
11. Coroutine Functions	Declared with `async def`, used with `await` to handle asynchronous calls	Async I/O operations, web scraping, concurrent API calls
12. Static Methods	Defined in classes using `@staticmethod`, doesn't use class instance	Utility methods inside class that don’t need access to class data
13. Class Methods	Use `@classmethod`, receives `cls` as argument instead of `self`	Factory methods to create class instances from different inputs

🧠 All Python Function Types - Explained with Examples

1️⃣ Built-in Functions 📦

These are pre-defined functions provided by Python.

print("Hello World!")
len([1, 2, 3])

Use Case: Logging, counting, formatting, etc.

2️⃣ User-defined Functions 🧑‍💻

Created using def keyword.

def greet(name):
    print(f"Hello {name}")

Use Case: Custom logic in apps

3️⃣ Lambda Functions ⚡

Anonymous functions with lambda.

square = lambda x: x ** 2
print(square(5))

Use Case: Sorting, filtering

4️⃣ Recursive Functions 🔁

Function calling itself repeatedly.

def factorial(n):
    return 1 if n == 0 else n * factorial(n - 1)

Use Case: Tree traversal, factorial

5️⃣ Generator Functions 🧵

Use yield to return items one by one.

def count_up():
    yield 1
    yield 2

Use Case: Large file reading, streams

6️⃣ Higher-Order Functions 🧠

Accepts/returns other functions.

def apply_twice(func, val):
    return func(func(val))

print(apply_twice(lambda x: x + 1, 3))

Use Case: Functional programming

7️⃣ Nested Functions 🔄

Functions defined inside other functions.

def outer():
    def inner():
        print("Inner")
    inner()

Use Case: Closures, scope control

8️⃣ Decorator Functions 🎯

Wrap another function to modify its behavior.

def logger(func):
    def wrapper():
        print("Logging...")
        return func()
    return wrapper

@logger
def hello():
    print("Hello World!")

Use Case: Authentication, timing

9️⃣ Callback Functions 📞

Passed as argument to be called later.

def process(callback):
    print("Start")
    callback()
    print("End")

process(lambda: print("Running..."))

Use Case: Event handling, async logic

🔟 Partial Functions 🔒

Pre-fill function arguments using functools.partial

from functools import partial

def power(base, exp):
    return base ** exp

square = partial(power, exp=2)

Use Case: Currency conversion, API configuration

1️⃣1️⃣ Coroutine Functions ⚙️

Declared with async def and uses await

import asyncio

async def hello():
    await asyncio.sleep(1)
    print("Async Hello")

Use Case: Web scraping, I/O tasks

1️⃣2️⃣ Static Method 📚

Doesn't need class instance. Defined using @staticmethod.

class Math:
    @staticmethod
    def add(a, b):
        return a + b

Use Case: Utility methods inside classes

1️⃣3️⃣ Class Method 🧰

Uses @classmethod and gets `cls` as argument.

class Person:
    def __init__(self, name):
        self.name = name

    @classmethod
    def create_anonymous(cls):
        return cls("Anonymous")

Use Case: Alternative constructors

✅ Python Function Types - Summary with Emojis

📦Built-in→ Already available

🧑‍💻User-defined→ Your own logic

⚡Lambda→ One-liners

🔁Recursive→ Self-calling

🧵Generator→ Stream data

🧠Higher-Order→ Functions as tools

🧭Nested→ Scoped inside

🎯Decorator→ Add new behaviors

📞Callback→ Event-based

🔒Partial→ Lock in defaults

⚙️Coroutine→ Async programming

📚Static Method→ Class helper (no state)

🧰Class Method→ Acts on class-level data