Python Functions

« Previous Next »

Python Functions

A function is a reusable block of code that performs a specific task. A function runs only when it is called, making programs more organized, readable, and efficient.

Functions help you:

    • Avoid repeating the same code

    • Break large programs into smaller parts

    • Make code easier to maintain and debug

Creating a Function

In Python, functions are created using the def keyword, followed by a function name and parentheses.

Syntax

def function_name(): # function body

Try it Yourself

Example: Simple Function

def show_message(): print("Welcome to Python functions")

Try it Yourself

This defines a function named show_message. The code inside the function is indented to indicate it belongs to the function.

Calling a Function

A function does nothing until it is called. To call a function, write its name followed by parentheses.

Example

def show_message(): print("Welcome to Python functions") show_message()

Try it Yourself

Calling a Function Multiple Times

Once defined, a function can be reused any number of times.

Example

def greet_user(): print("Hello, user!") greet_user() greet_user() greet_user()

Try it Yourself

Each function call executes the same block of code.

Function Naming Rules

Function names follow the same naming rules as variables:

    • Must start with a letter or an underscore (_)

    • Can include letters, numbers, and underscores

    • Are case-sensitive

    • Should be descriptive and meaningful

Examples of Valid Function Names

calculate_total() _display_result() checkStatus1()

Try it Yourself

Why Use Functions?

Without functions, repeating the same logic leads to messy and inefficient code.

Example: Without Using Functions

price1 = 100 total1 = price1 + (price1 * 0.18) print(total1) price2 = 250 total2 = price2 + (price2 * 0.18) print(total2) price3 = 80 total3 = price3 + (price3 * 0.18) print(total3)

Try it Yourself

Using Functions for Reusability

With functions, you write the logic once and reuse it easily.

Example: Using a Function

def calculate_price_with_tax(price): return price + (price * 0.18) print(calculate_price_with_tax(100)) print(calculate_price_with_tax(250)) print(calculate_price_with_tax(80))

Try it Yourself

This approach reduces duplication and improves clarity.

Return Values in Functions

Functions can send data back using the return statement. Once return is executed, the function stops running.

Example: Function Returning a Value

def get_status(): return "Task completed" result = get_status() print(result)

Try it Yourself

Using Returned Values Directly

You can also use the returned value immediately.

Example

def square_number(num): return num * num print(square_number(6))

Try it Yourself

Functions Without a Return Statement

If a function does not explicitly return a value, Python returns None by default.

Example

def print_info(): print("This function has no return") value = print_info() print(value)

Try it Yourself

Output:
None

The pass Statement in Functions

A function definition cannot be empty. If you want to define a function but implement it later, use the pass statement.

Example

def future_feature(): pass

Try it Yourself

Note: The pass keyword acts as a placeholder and avoids syntax errors during development.

Function Arguments in Python

Arguments are values that you pass to a function so it can work with data. They are written inside the parentheses when calling a function.

A function can accept one or more arguments, separated by commas.

Function with a Single Argument

Example

def greet_user(username): print("Hello", username) greet_user("Aarav") greet_user("Meera") greet_user("Karan")

Try it Yourself

Here, username receives the value passed during each function call.

Parameters vs Arguments

Although often used interchangeably, there is a small technical difference:

    • Parameter → The variable listed in the function definition

    • Argument → The actual value passed when calling the function

Example

def welcome(name): # name is a parameter print("Welcome", name) welcome("Ananya") # "Ananya" is an argument

Try it Yourself

Required Number of Arguments

By default, the number of arguments passed must match the number of parameters.

Correct Usage

def display_fullname(first, last): print(first, last) display_fullname("Ravi", "Sharma")

Try it Yourself

Incorrect Usage (Error)

def display_fullname(first, last): print(first, last) display_fullname("Ravi") # Missing one argument

Try it Yourself

Note: This will raise a TypeError.

Default Parameter Values

You can assign default values to parameters. If no argument is provided, the default value is used.

Example

def say_hello(name="Guest"): print("Hello", name) say_hello("Neha") say_hello()

Try it Yourself

Example: Default Country

def introduce(country="India"): print("I live in", country) introduce("Japan") introduce() introduce("Canada")

Try it Yourself

Keyword Arguments

With keyword arguments, you specify the parameter name along with the value. This makes the order irrelevant.

Example

def pet_details(pet, name): print("Pet:", pet) print("Name:", name) pet_details(pet="cat", name="Luna")

Try it Yourself

Positional Arguments

Arguments passed without keywords are called positional arguments. Their order matters.

Example

def pet_details(pet, name): print("Pet:", pet) print("Name:", name) pet_details("dog", "Rocky")

Try it Yourself

Order Change Affects Output

pet_details("Rocky", "dog")

Try it Yourself

Mixing Positional and Keyword Arguments

You can combine both types, but positional arguments must come first.

Example

def animal_info(animal, name, age): print(name, "is a", age, "year old", animal) animal_info("dog", name="Buddy", age=4)

Try it Yourself

Passing Different Data Types as Arguments

Python functions can accept any data type.

Example: Passing a List

def show_items(items): for item in items: print(item) shopping_list = ["milk", "bread", "eggs"] show_items(shopping_list)

Try it Yourself

Example: Passing a Dictionary

def show_profile(profile): print("Name:", profile["name"]) print("City:", profile["city"]) user = {"name": "Amit", "city": "Pune"} show_profile(user)

Try it Yourself

Returning Values from Functions

Functions can send data back using the return statement.

Example

def add_numbers(a, b): return a + b total = add_numbers(8, 12) print(total)

Try it Yourself

Returning Different Data Types

Example: Returning a List

def get_colors(): return ["red", "green", "blue"] colors = get_colors() print(colors)

Try it Yourself

Example: Returning a Tuple

def get_dimensions(): return 1920, 1080 width, height = get_dimensions() print("Width:", width) print("Height:", height)

Try it Yourself

Positional-Only Arguments

You can restrict parameters to accept only positional arguments using /.

Example

def greet(name, /): print("Hello", name) greet("Rahul")

Try it Yourself

Keyword-Only Arguments

To allow only keyword arguments, use * before parameters.

Example

def greet(*, name): print("Hello", name) greet(name="Rahul")

Try it Yourself

Combining Positional-Only and Keyword-Only Arguments

You can use both in the same function.

Example

def calculate(a, b, /, *, x, y): return a + b + x + y result = calculate(5, 10, x=15, y=20) print(result)

Try it Yourself

Python *args and **kwargs

Normally, Python functions must be called with the exact number of arguments defined in the function.

But in real-world programs, you may not always know how many values will be passed.

Python solves this problem using:

    • *args → for variable positional arguments

    • **kwargs → for variable keyword arguments

These make functions flexible and reusable.

Arbitrary Positional Arguments (*args)

When you prefix a parameter with *, the function can accept any number of positional arguments.

All values passed this way are stored as a tuple inside the function.

Example: Using *args

def show_students(*names): print("All students:", names) print("First student:", names[0]) show_students("Arjun", "Neha", "Rohan")

Try it Yourself

Here, names becomes a tuple:

("Arjun", "Neha", "Rohan")

Understanding *args

Inside the function:

args is a tuple. You can loop through it or access elements by index.

Example

def inspect_args(*args): print("Data type:", type(args)) for value in args: print(value) inspect_args(10, 20, 30, 40)

Try it Yourself

Using *args with Regular Parameters

Normal parameters must come before *args.

Example

def greet_users(message, *users): for user in users: print(message, user) greet_users("Welcome", "Aman", "Kriti", "Sahil")

Try it Yourself

message gets "Welcome". Remaining values go into users.

Practical Uses of *args

Example: Adding Multiple Numbers

def total_sum(*values): result = 0 for v in values: result += v return result print(total_sum(2, 4, 6)) print(total_sum(10, 20, 30, 40))

Try it Yourself

Example: Finding the Largest Number

def find_largest(*numbers): if not numbers: return None largest = numbers[0] for n in numbers: if n > largest: largest = n return largest print(find_largest(5, 12, 3, 19, 7))

Try it Yourself

Arbitrary Keyword Arguments (**kwargs)

When you prefix a parameter with **, the function can accept any number of keyword arguments. Inside the function, these values are stored as a dictionary.

Example: Using **kwargs

def show_profile(**info): print("Profile data:", info) show_profile(name="Riya", age=22, city="Jaipur")

Try it Yourself

Here, info becomes: {"name": "Riya", "age": 22, "city": "Jaipur"}

Understanding **kwargs

You can access values using dictionary keys.

Example

def user_details(**data): print("Type:", type(data)) print("Name:", data["name"]) print("Country:", data["country"]) user_details(name="Kunal", country="India", role="Developer")

Try it Yourself

Using **kwargs with Regular Parameters

Normal parameters must appear before **kwargs.

Example

def account_info(username, **details): print("Username:", username) print("Other details:") for key, value in details.items(): print(key, "=", value) account_info("user_101", email="user@mail.com", status="active")

Try it Yourself

Combining *args and **kwargs

You can use both in the same function.

Correct Order:

    1. Regular parameters

    2. *args

    3. **kwargs

Example

def log_data(title, *args, **kwargs): print("Title:", title) print("Positional data:", args) print("Keyword data:", kwargs) log_data("Employee Info", "Rahul", "IT", age=28, city="Noida")

Try it Yourself

Unpacking Arguments

The * and ** symbols can also be used when calling functions to unpack values.

Example: Unpacking a List with *

def multiply(a, b, c): return a * b * c values = [2, 3, 4] print(multiply(*values))

Try it Yourself

This is the same as: multiply(2, 3, 4)

Example: Unpacking a Dictionary with **

def welcome_user(first, last): print("Welcome", first, last) person_data = {"first": "Amit", "last": "Verma"} welcome_user(**person_data)

Try it Yourself

This is the same as: welcome_user(first="Amit", last="Verma")

Variable Scope in Python

In Python, a variable’s scope determines where that variable can be accessed in a program. A variable is only available within the region where it is created. Understanding scope helps prevent unexpected errors and makes your code easier to manage.

Local Scope

A variable created inside a function belongs to the local scope. It can be accessed only within that function.

Example: Local Variable

def calculate(): value = 150 print(value) calculate()

Try it Yourself

Here, value exists only inside the calculate() function.

Accessing Local Variables in Nested Functions

A local variable can be accessed by inner functions defined inside the same outer function.

Example

def outer_function(): message = "Hello from outer function" def inner_function(): print(message) inner_function() outer_function()

Try it Yourself

The variable message is available to inner_function() because it is inside the enclosing scope.

Global Scope

A variable created outside any function belongs to the global scope. Global variables can be accessed from anywhere in the program.

Example: Global Variable

count = 100 def show_count(): print(count) show_count() print(count)

Try it Yourself

Both the function and the main program can access count.

Local vs Global Variables with Same Name

If a variable with the same name exists both inside and outside a function, Python treats them as separate variables.

Example

number = 500 def update_number(): number = 300 print("Inside function:", number) update_number() print("Outside function:", number)

Try it Yourself

    • Inside the function → local variable

    • Outside the function → global variable

They do not affect each other.

The global Keyword

The global keyword allows a function to create or modify a global variable.

Example: Creating a Global Variable Inside a Function

def create_global(): global status status = "Active" create_global() print(status)

Try it Yourself

Example: Modifying a Global Variable

score = 90 def update_score(): global score score = 75 update_score() print(score)

Try it Yourself

Note: Without global, Python would create a new local variable instead of modifying the global one.

The nonlocal Keyword

The nonlocal keyword is used in nested functions to modify a variable from the enclosing (outer) function, but not the global scope.

Example

def profile(): username = "Guest" def update_name(): nonlocal username username = "Admin" update_name() return username print(profile())

Try it Yourself

Here, nonlocal allows update_name() to change the value of username in the outer function.

The LEGB Rule

Python follows the LEGB rule when searching for a variable:

    1. L – Local → Inside the current function

    2. E – Enclosing → Inside outer functions

    3. G – Global → At the top level of the module

    4. B – Built-in → Python’s built-in names

Example: LEGB in Action

value = "Global value" def outer(): value = "Enclosing value" def inner(): value = "Local value" print("Inner:", value) inner() print("Outer:", value) outer() print("Global:", value)

Try it Yourself

Output:
Inner: Local value
Outer: Enclosing value
Global: Global value

Python always picks the closest matching scope.

Python Decorators

A decorator allows you to add extra behavior to a function without modifying the function’s original code.

In simple terms:

    • A decorator is a function

    • It takes another function as input

    • It returns a new enhanced function

Decorators are commonly used for logging, validation, authentication, caching, and formatting output.

Basic Decorator Concept

A decorator wraps a function and adds new behavior before or after calling it.

Example: Simple Decorator

def make_upper(func): def wrapper(): return func().upper() return wrapper @make_upper def greet(): return "good morning" print(greet())

Try it Yourself

How It Works:

    • make_upper is the decorator

    • greet is the function being decorated

    • greet() is replaced with wrapper()

Using the Same Decorator on Multiple Functions

A decorator can be reused for many functions.

Example

def make_upper(func): def wrapper(): return func().upper() return wrapper @make_upper def welcome(): return "welcome user" @make_upper def alert(): return "system ready" print(welcome()) print(alert())

Try it Yourself

Decorating Functions with Arguments

If the original function accepts arguments, the wrapper must accept them too.

Example

def emphasize(func): def wrapper(name): return func(name).upper() return wrapper @emphasize def say_hello(name): return "hello " + name print(say_hello("Aarav"))

Try it Yourself

Using *args and **kwargs in Decorators

To make decorators flexible and compatible with any function signature, use *args and **kwargs.

Example

def emphasize(func): def wrapper(*args, **kwargs): return func(*args, **kwargs).upper() return wrapper @emphasize def greet_user(name): return "hello " + name print(greet_user("Meera"))

Try it Yourself

This allows the decorator to work with any number of arguments.

Decorators with Their Own Arguments

Sometimes, decorators themselves need parameters. This requires an extra level of wrapping.

Example: Decorator Factory

def change_case(style): def decorator(func): def wrapper(): text = func() if style == "lower": return text.lower() return text.upper() return wrapper return decorator @change_case("lower") def message(): return "HELLO PYTHON" print(message())

Try it Yourself

Using Multiple Decorators on a Function

You can stack multiple decorators on a single function. Decorators are applied from bottom to top.

Example

def add_prefix(func): def wrapper(): return "Hi " + func() return wrapper def make_upper(func): def wrapper(): return func().upper() return wrapper @make_upper @add_prefix def username(): return "rohan" print(username())

Try it Yourself

Execution Order:

    • add_prefix runs first

    • make_upper runs second

Preserving Function Metadata

Decorators replace the original function, which causes metadata like __name__ and __doc__ to be lost.

Example: Metadata Loss

def make_upper(func): def wrapper(): return func().upper() return wrapper @make_upper def greet(): """Returns a greeting message""" return "hello" print(greet.__name__) # Output: wrapper

Try it Yourself

Fixing Metadata with functools.wraps

Python provides functools.wraps to preserve original function information.

Example

import functools def make_upper(func): @functools.wraps(func) def wrapper(): return func().upper() return wrapper @make_upper def greet(): """Returns a greeting message""" return "hello" print(greet.__name__) print(greet.__doc__)

Try it Yourself

Now the function keeps its original identity.

Lambda Functions in Python

A lambda function is a small, unnamed function created using the lambda keyword. It is mainly used for short operations where defining a full function would be unnecessary.

Lambda functions can accept any number of arguments, but they must contain only one expression, and that expression is automatically returned.

Syntax

lambda parameters : expression

The expression is evaluated and its result is returned.

Simple Lambda Example

# Add 5 to a number and return the result: add_five = lambda x: x + 5 print(add_five(10))

Try it Yourself

Lambda with Multiple Arguments

Examples

# Multiply two numbers: multiply = lambda x, y: x * y print(multiply(4, 7)) # Add three numbers together: total = lambda x, y, z: x + y + z print(total(3, 6, 9))

Try it Yourself

Why Use Lambda Functions?

Lambda functions are most useful when you need a temporary, small function, especially inside another function. Consider a function that returns another function, where the multiplier is decided later.

Returning a Lambda from a Function

Example

def make_multiplier(n): return lambda x: x * n tripler = make_multiplier(3) print(tripler(8)) quadrupler = make_multiplier(4) print(quadrupler(8)) double = make_multiplier(2) triple = make_multiplier(3) print(double(10)) print(triple(10))

Try it Yourself

When to Use Lambda Functions

Use lambda functions when:

    • The function is simple and short

    • The function is used only once

    • You want cleaner and more readable code

Lambda with Built-in Functions

Lambda functions are often combined with built-in functions such as map(), filter(), and sorted().

Using Lambda with map()

The map() function applies a function to each item in a list.

Example: Square all numbers in a list

numbers = [2, 4, 6, 8] squares = list(map(lambda x: x ** 2, numbers)) print(squares)

Try it Yourself

Using Lambda with filter()

The filter() function selects items that match a condition.

Example: Keep numbers greater than 10

values = [5, 12, 18, 7, 25] greater_than_ten = list(filter(lambda x: x > 10, values)) print(greater_than_ten)

Try it Yourself

Using Lambda with sorted()

The sorted() function can use a lambda to define custom sorting rules.

Example: Sort a list of dictionaries & Words

players = [ {"name": "Alex", "score": 82}, {"name": "Ben", "score": 75}, {"name": "Chris", "score": 90} ] sorted_players = sorted(players, key=lambda x: x["score"]) print(sorted_players) # Sort words by their last character words = ["python", "java", "csharp", "go"] sorted_words = sorted(words, key=lambda x: x[-1]) print(sorted_words)

Try it Yourself

Recursion in Python

Recursion is a programming technique where a function calls itself to solve a problem by breaking it into smaller subproblems. Instead of using loops, recursion repeatedly applies the same logic until a stopping condition is reached.

Note: When used carefully, recursion can make code clean, readable, and mathematically elegant. However, incorrect recursion can lead to infinite function calls or excessive memory usage, so it must always be written with care.

Simple Recursion Example

Below is a recursive function that prints numbers from a given value down to 1.

def print_reverse(num): if num == 0: print("Finished!") return print(num) print_reverse(num - 1) print_reverse(6)

Try it Yourself

Base Case and Recursive Case

Every recursive function must contain two essential parts:

    1. Base Case: A condition that stops the recursion.

    2. Recursive Case: The part where the function calls itself with a modified value.

Without a base case, the function would keep calling itself forever.

Example: Factorial Using Recursion

The factorial of a number is calculated as: n! = n × (n - 1)!

def calculate_factorial(value): # Base case if value <= 1: return 1 # Recursive case return value * calculate_factorial(value - 1) print(calculate_factorial(6))

Try it Yourself

Why the Base Case Matters

The base case ensures that the recursion eventually stops. Always verify that your recursive calls move closer to this condition.

Fibonacci Sequence Using Recursion

The Fibonacci sequence is a well-known series where each number is the sum of the two previous numbers: 0, 1, 1, 2, 3, 5, 8, ...

Recursive Fibonacci Example

Find the 8th Fibonacci number:

def get_fibonacci(position): if position == 0: return 0 if position == 1: return 1 return get_fibonacci(position - 1) + get_fibonacci(position - 2) print(get_fibonacci(8))

Try it Yourself

Using Recursion with Lists

Recursion can also be applied to process collections such as lists by handling one element at a time.

Example: Sum of List Elements

def total_sum(items): if not items: return 0 return items[0] + total_sum(items[1:]) values = [2, 4, 6, 8] print(total_sum(values))

Try it Yourself

Example: Find the Largest Number in a List

def largest_value(data): if len(data) == 1: return data[0] remaining_max = largest_value(data[1:]) return data[0] if data[0] > remaining_max else remaining_max numbers = [5, 12, 3, 21, 7] print(largest_value(numbers))

Try it Yourself

Recursion Depth Limit in Python

Python limits how deep recursion can go to prevent crashes caused by excessive memory usage. By default, this limit is usually around 1000 function calls.

Check the Current Recursion Limit

import sys print(sys.getrecursionlimit())

Try it Yourself

Increase the Recursion Limit (Use with Caution)

import sys sys.setrecursionlimit(1500) print(sys.getrecursionlimit())

Try it Yourself

Generators in Python

Generators are special functions that produce values one at a time and pause their execution between each value. Instead of returning all results at once, they generate values on demand, making them highly memory-efficient.

When a generator function is called, it does not execute immediately. Instead, it returns a generator object, which can be iterated over like an iterator.

Basic Generator Example

A generator uses the yield keyword instead of return.

def number_stream(): yield 10 yield 20 yield 30 for item in number_stream(): print(item)

Try it Yourself

Here, values are produced one by one as the loop iterates.

The yield Keyword

The yield keyword pauses the function, saves its current state, and returns a value. Execution resumes from the same point the next time the generator is accessed.

Example: Generator That Counts Down

def countdown_generator(limit): while limit > 0: yield limit limit -= 1 for value in countdown_generator(5): print(value)

Try it Yourself

Unlike return, yield allows the function to continue execution later.

Why Generators Save Memory

Generators do not store all values in memory. They generate values only when needed, which is ideal for large datasets.

Example: Large Range Generator

def huge_range(max_value): for i in range(max_value): yield i gen = huge_range(1_000_000) print(next(gen)) print(next(gen)) print(next(gen))

Try it Yourself

Even though the range is large, memory usage stays low.

Using next() with Generators

You can manually retrieve values from a generator using next().

def name_generator(): yield "Alice" yield "Bob" yield "Charlie" g = name_generator() print(next(g)) print(next(g)) print(next(g))

Try it Yourself

When no values remain, Python raises a StopIteration exception.

StopIteration Example

def small_gen(): yield 1 yield 2 g = small_gen() print(next(g)) print(next(g)) print(next(g)) # Raises StopIteration

Try it Yourself

Generator Expressions

Generator expressions are similar to list comprehensions, but they use parentheses and do not create a list in memory.

List vs Generator Expression

# List comprehension squares_list = [n ** 2 for n in range(4)] print(squares_list) # Generator expression squares_gen = (n ** 2 for n in range(4)) print(squares_gen) print(list(squares_gen))

Try it Yourself

Generator Expression with sum()

total = sum(n ** 2 for n in range(1, 11)) print(total)

Try it Yourself

This computes the result without creating an intermediate list.

Fibonacci Sequence Using a Generator

Generators are perfect for infinite sequences like Fibonacci numbers.

def fibonacci_generator(): x, y = 0, 1 while True: yield x x, y = y, x + y fib = fibonacci_generator() for _ in range(10): print(next(fib))

Try it Yourself

This can run indefinitely without exhausting memory.

Advanced Generator Methods

Generators support additional methods for more control.

send() Method

The send() method sends a value into the generator.

def message_receiver(): while True: msg = yield print("Message received:", msg) gen = message_receiver() next(gen) # Start the generator gen.send("Hi") gen.send("Python")

Try it Yourself

close() Method

The close() method stops the generator’s execution.

def controlled_gen(): try: yield "Start" yield "Running" finally: print("Generator has stopped") gen = controlled_gen() print(next(gen)) gen.close()

Try it Yourself

« Previous Next »