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

Example: Simple Function

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

# No output until the function is called

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.

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

Welcome to Python functions

Calling a Function Multiple Times

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

Hello, user! Hello, user! Hello, user!

Function Naming Rules

• 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()

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)

118.0 295.0 94.4

Using Functions for Reusability

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))

118.0 295.0 94.4

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)

Task completed

Using Returned Values Directly

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

36

Functions Without a Return Statement

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

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

This function has no return 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.

def future_feature(): pass

# No output, but does not raise a SyntaxError

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

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

Hello Aarav Hello Meera Hello Karan

Parameters vs Arguments

• Parameter → The variable listed in the function definition
• Argument → The actual value passed when calling the function

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

Welcome Ananya

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")

Ravi Sharma

Incorrect Usage (Error)

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

TypeError: display_fullname() missing 1 required positional argument: 'last'

Default Parameter Values

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

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

Hello Neha Hello Guest

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

I live in Japan I live in India I live in Canada

Keyword Arguments

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

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

Pet: cat Name: Luna

Positional Arguments

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

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

Pet: dog Name: Rocky

Mixing Positional and Keyword Arguments

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

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

Buddy is a 4 year old dog

Passing Different Data Types as Arguments

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

milk bread eggs

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

Name: Amit City: Pune

Returning Values from Functions

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

20

Returning Different Data Types

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

['red', 'green', 'blue']

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

Width: 1920 Height: 1080

Positional-Only Arguments

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

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

Hello Rahul

Keyword-Only Arguments

To allow only keyword arguments, use * before parameters.

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

Hello Rahul

Combining Positional-Only and Keyword-Only Arguments

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

50

Python *args and **kwargs

Python uses *args for variable positional arguments and **kwargs for variable keyword arguments.

Arbitrary Positional Arguments (*args)

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

All students: ('Arjun', 'Neha', 'Rohan') First student: Arjun

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

Data type: <class 'tuple'> 10 20 30 40

Using *args with Regular Parameters

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

Welcome Aman Welcome Kriti Welcome Sahil

Practical Uses of *args

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))

12 100

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))

19

Arbitrary Keyword Arguments (**kwargs)

When you prefix a parameter with **, the function can accept any number of keyword arguments (stored as a dictionary).

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

Profile data: {'name': 'Riya', 'age': 22, 'city': 'Jaipur'}

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

Type: <class 'dict'> Name: Kunal Country: India

Using **kwargs with Regular Parameters

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")

Username: user_101 Other details: email = user@mail.com status = active

Combining *args and **kwargs

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")

Title: Employee Info Positional data: ('Rahul', 'IT') Keyword data: {'age': 28, 'city': 'Noida'}

Unpacking Arguments

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

24

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

Welcome Amit Verma

Variable Scope in Python

In Python, a variable’s scope determines where that variable can be accessed in a program. Understanding scope helps prevent unexpected errors and makes your code easier to manage.

Local Scope

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

150

Accessing Local Variables in Nested Functions

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

Hello from outer function

Global Scope

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

100 100

Local vs Global Variables with Same Name

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

Inside function: 300 Outside function: 500

The global Keyword

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

Active

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

75

The nonlocal Keyword

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

Admin

The LEGB Rule

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

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

Python Decorators

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

Basic Decorator Concept

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

GOOD MORNING

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())

WELCOME USER SYSTEM READY

Decorating Functions with Arguments

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

HELLO AARAV

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"))

HELLO MEERA

Decorators with Their Own Arguments

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())

hello python

Using Multiple Decorators

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())

HI ROHAN

Preserving Function Metadata

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

wrapper

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__)

greet Returns a greeting message

Lambda Functions in Python

A lambda function is a small, unnamed function created using the lambda keyword.

add_five = lambda x: x + 5 print(add_five(10))

15

multiply = lambda x, y: x * y print(multiply(4, 7)) total = lambda x, y, z: x + y + z print(total(3, 6, 9))

28 18

Returning a Lambda from a Function

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

20 30

Lambda with Built-in Functions

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

[4, 16, 36, 64]

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

[12, 18, 25]

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)

[{'name': 'Ben', 'score': 75}, {'name': 'Alex', 'score': 82}, {'name': 'Chris', 'score': 90}]

words = ["python", "java", "csharp", "go"] sorted_words = sorted(words, key=lambda x: x[-1]) print(sorted_words)

['java', 'python', 'go', 'csharp']

Recursion in Python

Recursion is a programming technique where a function calls itself to solve a problem by breaking it into smaller subproblems.

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

6 5 4 3 2 1 Finished!

Example: Factorial Using Recursion

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

720

Fibonacci Sequence Using Recursion

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))

21

Using Recursion with Lists

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))

20

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))

21

Recursion Depth Limit in Python

import sys print(sys.getrecursionlimit())

1000

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

1500

Generators in Python

Generators are special functions that produce values one at a time and pause their execution between each value.

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

10 20 30

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

5 4 3 2 1

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))

0 1 2

Using next() with Generators

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

Alice Bob Charlie

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

1 2

Generator Expressions

# 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))

[0, 1, 4, 9] <generator object <genexpr> at 0x...> [0, 1, 4, 9]

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

385

Fibonacci Sequence Using a Generator

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))

0 1 1 2 3 5 8 13 21 34

Advanced Generator Methods

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")

Message received: Hi Message received: Python

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

Start Generator has stopped

« Previous Next »

AI Code Explanation Python

Powered by Gocourse AI