Course: Python Training
Topic: Defining and Calling Functions with def
Course Link: Python Training Course – JustAcademy
Demo Link: Register for a Course Demo
Official Website: JustAcademy
A function is a reusable block of code designed to perform a specific task. Instead of writing the same instructions repeatedly, you can define a function once and call it whenever required. Functions help make Python programs organized, readable, reusable, and easier to test and maintain.
For example, if a program needs to display a welcome message in several places, you can create one function that displays the message and call it whenever needed.
Python provides the def keyword to define a function. A function can accept input values called parameters, perform operations, and optionally return a result to the code that called it.
After completing this topic, you will be able to:
def keyword.The def keyword is used to define a function in Python. When Python encounters a function definition, it creates the function object and binds it to the specified name. The function body runs when the function is called, not merely when it is defined.
Basic syntax:
def function_name():
# Statements to execute
passExplanation of the syntax:
| Component | Description |
|---|---|
def |
Keyword used to define a function. |
function_name |
Name used to refer to and call the function. |
() |
Parentheses that contain optional parameters. |
: |
Colon that marks the beginning of the function body. |
| Indented statements | Instructions executed when the function is called. |
pass |
A placeholder statement that does nothing, useful while developing a function body. |
Consider a function that displays a simple message.
def greet():
print("Hello, welcome to Python!")
greet()Output:
Hello, welcome to Python!Explanation:
def greet(): defines a function named greet.print() statement forms the function body.greet() calls the function.Function definitions and function calls serve different purposes. Defining a function establishes what the function does, while calling it requests that the function execute.
Choose a meaningful name that describes the task. For example, display_message() is more descriptive than abc().
def display_message():
print("Learning Python functions")display_message()def display_message():
print("Learning Python functions")
display_message()
display_message()Output:
Learning Python functions
Learning Python functionsThe same function is called twice, so the same message is displayed twice. This demonstrates code reuse.
A function without parameters does not require input values from the caller. It can still perform tasks such as displaying information, printing a menu, or showing instructions.
def show_menu():
print("1. View Profile")
print("2. Update Profile")
print("3. Exit")
show_menu()Output:
1. View Profile
2. Update Profile
3. ExitUse a function without parameters when the task can be performed without receiving input from the caller.
Parameters are variable names written in a function definition. They allow the function to receive values from the caller and use those values when executing its statements.
Syntax:
def function_name(parameter):
# Use the parameter
passdef greet_user(name):
print("Hello,", name)
greet_user("Amit")
greet_user("Priya")Output:
Hello, Amit
Hello, PriyaHere, name is the parameter. The values "Amit" and "Priya" are arguments supplied in the function calls.
A function can accept multiple parameters separated by commas.
def display_student(name, age, course):
print("Name:", name)
print("Age:", age)
print("Course:", course)
display_student("Neha", 22, "Python")Output:
Name: Neha
Age: 22
Course: PythonWhen positional arguments are supplied, they are assigned to parameters according to their order in the function definition.
| Parameter | Argument |
|---|---|
| A name specified in a function definition. | A value or expression supplied when calling a function. |
| Receives the supplied value during the call. | Provides the input used by the function. |
Example: name in def greet(name): |
Example: "Amit" in greet("Amit") |
A function can calculate a result and send it back to the caller using the return statement. The returned value can be stored in a variable, displayed, passed to another function, or used in an expression.
def add(a, b):
return a + b
result = add(10, 20)
print(result)Output:
30Explanation: The function calculates a + b and returns the result. The call add(10, 20) produces 30, which is stored in result.
def add_and_print(a, b):
print(a + b)
def add_and_return(a, b):
return a + b
first = add_and_print(5, 3)
second = add_and_return(5, 3)
print("First:", first)
print("Second:", second)Output:
8
First: None
Second: 8The first function displays 8 but does not explicitly return a value, so its result is None. The second function returns 8, making the result available for further use.
Python functions can return multiple values separated by commas. Python packages those values into a tuple, which can be unpacked into separate variables.
def calculate(a, b):
total = a + b
difference = a - b
return total, difference
sum_result, difference_result = calculate(15, 5)
print("Sum:", sum_result)
print("Difference:", difference_result)Output:
Sum: 20
Difference: 10The return statement ends the current function call and sends a value back to the caller. Any statements after an executed return in the same execution path are not run.
def check_number(number):
if number > 0:
return "Positive"
elif number < 0:
return "Negative"
return "Zero"
print(check_number(10))
print(check_number(-5))
print(check_number(0))Output:
Positive
Negative
ZeroIf a function reaches the end without executing a return statement with a value, Python returns None.
Default parameters provide a value that Python uses when the caller does not supply an argument for that parameter.
def greet(name="Guest"):
print("Welcome,", name)
greet()
greet("Rahul")Output:
Welcome, Guest
Welcome, RahulParameters with default values must follow parameters without default values in a function definition. Also, avoid using mutable objects such as lists as default values unless shared state is specifically intended.
Keyword arguments specify values by parameter name. They improve readability and allow arguments to be supplied in a different order from the parameter list.
def describe_person(name, age, city):
print(name, age, city)
describe_person(
city="Mumbai",
name="Priya",
age=25
)Output:
Priya 25 MumbaiKeyword argument names must match the function's parameter names. Required parameters must still receive values.
A variable created inside a function is usually local to that function. It can be accessed within the relevant function scope but cannot normally be referenced directly from outside the function.
def calculate_square(number):
result = number ** 2
return result
print(calculate_square(4))
# print(result) # NameError: result is not defined hereOutput:
16The variable result is local to calculate_square(). Its value is made available outside the function through the returned result.
A docstring is a string placed immediately after a function definition. It explains the function's purpose and can describe its inputs and return value.
def calculate_area(length, width):
"""Return the area of a rectangle."""
return length * width
print(calculate_area(5, 4))
print(calculate_area.__doc__)Output:
20
Return the area of a rectangle.Use descriptive names, consistent indentation, and docstrings for functions whose purpose or behavior may not be immediately obvious.
Understanding common function errors helps you identify problems quickly and write reliable Python programs.
def greet():
print("Hello!")
greetExplanation: Writing greet refers to the function object but does not execute it. Use parentheses to call the function.
greet()Output:
Hello!# Incorrect
def greet()
print("Hello!")Problem: A function definition must end with a colon.
# Correct
def greet():
print("Hello!")# Incorrect
def greet():
print("Hello!")Problem: Python uses indentation to identify the function body.
# Correct
def greet():
print("Hello!")def greet(name):
print("Hello,", name)
# greet() # TypeError: required argument is missing
greet("Amit")Output:
Hello, Amitdef multiply(a, b):
print(a * b)
result = multiply(4, 5)
print(result)Output:
20
NoneProblem: The function displays the product but does not return it. Use return a * b if the caller needs the result.
In a normal script, the function definition must have been executed before the function is called. Otherwise, the function name may not yet exist and Python can raise a NameError.
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):
if b == 0:
return "Cannot divide by zero"
return a / b
print("Addition:", add(10, 5))
print("Subtraction:", subtract(10, 5))
print("Multiplication:", multiply(10, 5))
print("Division:", divide(10, 5))
print("Division:", divide(10, 0))Output:
Addition: 15
Subtraction: 5
Multiplication: 50
Division: 2.0
Division: Cannot divide by zerodef calculate_area(length, width):
"""Calculate and return the area of a rectangle."""
return length * width
area = calculate_area(8, 5)
print("Area:", area)Output:
Area: 40def calculate_average(mark1, mark2, mark3):
return (mark1 + mark2 + mark3) / 3
average = calculate_average(80, 90, 85)
print("Average marks:", average)Output:
Average marks: 85.0def is_even(number):
return number % 2 == 0
print(is_even(8))
print(is_even(7))Output:
True
Falsedef calculate_discounted_price(price, discount_percent):
discount = price * discount_percent / 100
return price - discount
final_price = calculate_discounted_price(2000, 15)
print("Final price:", final_price)Output:
Final price: 1700.0calculate_total(), find_average(), and display_menu().return when the caller needs to work with a calculated result.print() when the purpose is to display information, rather than to provide a result for further computation.Define a function named welcome() that prints a welcome message. Call it three times.
Create a function named greet_person(name) that accepts a person's name and displays a personalized greeting.
Define a function named add_numbers(a, b) that returns the sum of two numbers. Store the result in a variable and print it.
Create a function named square(number) that returns the square of a given number.
Write a function named check_age(age) that returns "Eligible" if the age is at least 18 and "Not eligible" otherwise.
Create a function that accepts a product price and quantity, then returns the total bill.
def welcome():
print("Welcome to Python programming!")
welcome()
welcome()
welcome()Output:
Welcome to Python programming!
Welcome to Python programming!
Welcome to Python programming!def greet_person(name):
print(f"Hello, {name}! Welcome to Python.")
greet_person("Amit")Output:
Hello, Amit! Welcome to Python.def add_numbers(a, b):
return a + b
result = add_numbers(25, 15)
print("Sum:", result)Output:
Sum: 40def square(number):
return number ** 2
print(square(6))Output:
36def check_age(age):
if age >= 18:
return "Eligible"
return "Not eligible"
print(check_age(20))
print(check_age(16))Output:
Eligible
Not eligibledef calculate_bill(price, quantity):
return price * quantity
total = calculate_bill(250, 4)
print("Total bill:", total)Output:
Total bill: 1000Answer: A function is a reusable block of code that performs a specific task. It can accept inputs, execute instructions, and optionally return a result.
Answer: Python uses the def keyword to define a function.
Answer: Defining a function establishes its code and behavior. Calling a function executes its body.
Answer: Parameters are names listed in the function definition. Arguments are the values or expressions supplied when calling the function.
Answer: If the function finishes without returning a value explicitly, Python returns None.
Answer: print() displays information, while return sends a value back to the caller so it can be stored or used in another expression.
Answer: Yes. Multiple parameters can be specified in the function definition, separated by commas.
Answer: A default parameter has a predefined value that is used when the caller does not supply an argument for it.
Answer: A local variable is a name assigned within a function's local scope and is normally accessible only within that scope.
Answer: A docstring is a string literal placed at the beginning of a function body to document its purpose and behavior.
Answer: Functions reduce code duplication, improve readability, organize logic, simplify testing, and make programs easier to maintain.
Answer: Python generally raises a TypeError when a function is called without a required argument.
def keyword defines a function.return statement sends a result back to the caller.None.Defining and calling functions with def is a fundamental Python programming skill. Functions help divide a program into manageable tasks, accept different inputs through parameters, and provide results through return values. By practicing function definitions, function calls, scope, default arguments, and error handling, you can develop more reusable, readable, and maintainable Python applications.
Continue learning with these JustAcademy resources:
