Functions are reusable blocks of code that perform a specific task. They improve code readability, reduce duplication, and make programs easier to maintain.

Creating a Function

Use the def keyword.

Syntax

def function_name(parameters):
    # code
    return value

Example

def greet():
    print("Hello World")

greet()

Output

Hello World

Calling a Function

A function executes only when it is called.

def welcome():
    print("Welcome!")

welcome()
welcome()

Output

Welcome!
Welcome!

Function Parameters and Arguments

Parameter

Variables defined in the function.

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

name is a parameter.

Argument

Actual value passed to the function.

greet("Alice")

"Alice" is an argument.

Positional Arguments

Arguments are matched by position.

def student(name, age):
    print(name, age)

student("John", 20)

Output

John 20

Keyword Arguments

Arguments are passed using parameter names.

def student(name, age):
    print(name, age)

student(age=20, name="John")

Output

John 20

Default Parameters

A parameter can have a default value.

def greet(name="Guest"):
    print("Hello", name)

greet()
greet("Alice")

Output

Hello Guest
Hello Alice

Multiple Parameters

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

add(10, 20)

Output

Return Statement

Returns a value to the caller.

def square(n):
    return n * n

result = square(5)

print(result)

Output

Returning Multiple Values

def details():
    return "John", 20

name, age = details()

print(name)
print(age)

Output

John
20

print() vs return

print()

Displays output.

def add():
    print(5 + 5)

x = add()

print(x)

Output

10
None

return

Returns a value.

def add():
    return 5 + 5

x = add()

print(x)

Output

Arbitrary Arguments (`*args`)

Accepts any number of positional arguments.

def total(*numbers):
    print(sum(numbers))

total(10, 20, 30, 40)

Output

Arbitrary Keyword Arguments (`**kwargs`)

Accepts any number of keyword arguments.

def person(**info):
    print(info["name"])
    print(info["age"])

person(name="John", age=21)

Output

John
21

Combining Parameters

def demo(a, b=10, *args, **kwargs):
    print(a)
    print(b)
    print(args)
    print(kwargs)

demo(1, 2, 3, 4, city="Chennai")

Output

1
2
(3, 4)
{'city': 'Chennai'}

Variable Scope

Scope determines where a variable can be accessed.

Local Scope

Created inside a function.

def test():
    x = 10
    print(x)

test()

Outside the function:

print(x)

Output

NameError

Global Scope

Created outside every function.

x = 100

def show():
    print(x)

show()

print(x)

Output

100
100

global Keyword

Modify a global variable.

count = 0

def increment():
    global count
    count += 1

increment()

print(count)

Output

Nested Functions

A function inside another function.

def outer():

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

    inner()

outer()

Output

Inner Function

Recursive Function

A function calling itself.

def countdown(n):

    if n == 0:
        return

    print(n)

    countdown(n - 1)

countdown(5)

Output

Lambda Function (Anonymous Function)

Small one-line function.

square = lambda x: x * x

print(square(5))

Output

Multiple parameters

add = lambda a, b: a + b

print(add(10, 20))

Output

Higher-Order Functions

Functions can be passed as arguments.

def greet():
    return "Hello"

def display(func):
    print(func())

display(greet)

Output

Hello

Built-in Functions

Some commonly used Python functions.

Function	Purpose
`print()`	Display output
`input()`	Read user input
`len()`	Length of object
`type()`	Get data type
`sum()`	Sum of numbers
`max()`	Largest value
`min()`	Smallest value
`sorted()`	Sort values
`abs()`	Absolute value
`round()`	Round number

Example

numbers = [5, 2, 8]

print(len(numbers))
print(max(numbers))
print(min(numbers))
print(sum(numbers))

Function Annotations (Type Hints)

Used to specify expected types.

def add(a: int, b: int) -> int:
    return a + b

print(add(5, 10))

Decorators

A decorator is a function that modifies or extends the behavior of another function without changing its original code. Decorators use the @ symbol.

Simple Decorator

def decorator(func):

    def wrapper():
        print("Before function")
        func()
        print("After function")

    return wrapper

@decorator
def hello():
    print("Hello")

hello()

Output

Before function
Hello
After function

Decorator with Arguments

def decorator(func):

    def wrapper(name):
        print("Welcome")
        func(name)

    return wrapper

@decorator
def greet(name):
    print("Hello", name)

greet("Alice")

Output

Welcome
Hello Alice

Multiple Decorators

Decorators are applied from bottom to top.

def deco1(func):
    def wrapper():
        print("Decorator 1")
        func()
    return wrapper

def deco2(func):
    def wrapper():
        print("Decorator 2")
        func()
    return wrapper

@deco1
@deco2
def hello():
    print("Hello")

hello()

Output

Decorator 1
Decorator 2
Hello

Common Built-in Decorators

`@staticmethod`

Does not use self or cls.

class Math:

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

print(Math.add(5, 10))

`@classmethod`

Receives the class (cls) instead of the object.

class Student:

    school = "ABC School"

    @classmethod
    def show_school(cls):
        print(cls.school)

Student.show_school()

`@property`

Allows calling a method like an attribute.

class Person:

    def __init__(self, name):
        self._name = name

    @property
    def name(self):
        return self._name

p = Person("John")

print(p.name)

Quick Revision

def → Create a function
Call function using ()
Parameters → Variables in function definition
Arguments → Values passed to function
return → Returns value
print() → Displays value
Default parameters → Optional values
*args → Multiple positional arguments
**kwargs → Multiple keyword arguments
Local scope → Inside function
Global scope → Outside function
global → Modify global variable
Nested function → Function inside another function
Recursion → Function calls itself
Lambda → Anonymous one-line function
Higher-order function → Takes or returns functions
Type hints → Specify expected parameter/return types
Decorator → Adds functionality without modifying the original function
@staticmethod → No self or cls
@classmethod → Uses class (cls)
@property → Access method like an attribute

Day 1

Day 2

Python Functions

Creating a Function

Syntax

Calling a Function

Function Parameters and Arguments

Parameter

Argument

Positional Arguments

Keyword Arguments

Default Parameters

Multiple Parameters

Return Statement

Returning Multiple Values

print() vs return

print()

return

Arbitrary Arguments (`*args`)

Arbitrary Keyword Arguments (`**kwargs`)

Combining Parameters

Variable Scope

Local Scope

Global Scope

global Keyword

Nested Functions

Recursive Function

Lambda Function (Anonymous Function)

Higher-Order Functions

Built-in Functions

Function Annotations (Type Hints)

Decorators

Simple Decorator

Decorator with Arguments

Multiple Decorators

Common Built-in Decorators

`@staticmethod`

`@classmethod`

`@property`

Quick Revision

​Creating a Function

​Syntax

​Calling a Function

​Function Parameters and Arguments

​Parameter

​Argument

​Positional Arguments

​Keyword Arguments

​Default Parameters

​Multiple Parameters

​Return Statement

​Returning Multiple Values

​print() vs return

​print()

​return

​Arbitrary Arguments (*args)

​Arbitrary Keyword Arguments (**kwargs)

​Combining Parameters

​Variable Scope

​Local Scope

​Global Scope

​global Keyword

​Nested Functions

​Recursive Function

​Lambda Function (Anonymous Function)

​Higher-Order Functions

​Built-in Functions

​Function Annotations (Type Hints)

​Decorators

​Simple Decorator

​Decorator with Arguments

​Multiple Decorators

​Common Built-in Decorators

​@staticmethod

​@classmethod

​@property

​Quick Revision

Creating a Function

Syntax

Calling a Function

Function Parameters and Arguments

Parameter

Argument

Positional Arguments

Keyword Arguments

Default Parameters

Multiple Parameters

Return Statement

Returning Multiple Values

print() vs return

print()

return

Arbitrary Arguments (`*args`)

Arbitrary Keyword Arguments (`**kwargs`)

Combining Parameters

Variable Scope

Local Scope

Global Scope

global Keyword

Nested Functions

Recursive Function

Lambda Function (Anonymous Function)

Higher-Order Functions

Built-in Functions

Function Annotations (Type Hints)

Decorators

Simple Decorator

Decorator with Arguments

Multiple Decorators

Common Built-in Decorators

`@staticmethod`

`@classmethod`

`@property`

Quick Revision