User-Defined Function is a function created by the user to perform specific tasks in a program. Unlike built-in functions provided by a programming language, it allow for customization and code reusability, improving program structure and efficiency. For Example:
def fun( x ):
if (x % 2 == 0):
print("even")
else:
print("odd")
fun(2) # function calling
Output
even
Explanation: fun(x) checks if a number is even or odd using x % 2. If divisible by 2, it prints "even", otherwise "odd".
Syntax
def function_name(parameters):
# Function body
return result
Function call:
function_name(arguments)
Types of Users Defined Functions
1. Parameterized Functions
These functions accept parameters (arguments) to process and return results dynamically. Parameters allow for flexibility, enabling the function to handle different inputs each time it is called.
def fun(name):
print("Hello,", name)
fun("shakshi")
Output
Hello, shakshi
Explanation: fun(name) prints a greeting with the provided name. When called with "shakshi", it outputs "Hello, shakshi".
2. Functions with default arguments
A function can have default values assigned to its parameters. If no argument is provided when calling the function, it takes the default value.
def fun(x, y=50):
print("x:", x)
print("y:", y)
fun(10)
Output
x: 10 y: 50
Explanation: fun(x, y=50) takes two parameters, where y has a default value of 50. It prints the values of x and y. When called with fun(10), it uses 10 for x and the default value 50 for y.
3. Keyword argument functions
Function arguments can be passed using keywords to improve code readability. This ensures the correct mapping of values to parameters, regardless of their order.
def fun(name, age):
print(name, "is", age, "years old.")
fun(age=21, name="shakshi")
Output
shakshi is 21 years old.
Explanation: fun(name, age) prints the name and age with the message "is [age] years old." It is called using keyword arguments (age=21, name="shakshi"), which assigns the values explicitly to name and age.
4. Variable length argument functions
When the number of arguments is unknown, a function can accept multiple arguments using *args (for non-keyword arguments) or **kwargs (for keyword arguments).
def fun(*args):
for arg in args:
print(arg)
fun("Python", "Java", "C++")
Output
Python Java C++
Explanation: fun(*args) uses a variable-length argument list, allowing it to accept any number of arguments. It then iterates through each argument and prints it.
5. Functions with Return value
A function can return a value using the return statement. This allows the function to send back a result for further computation.
def fun(num):
return num * num
res = fun(5)
print(res)
Output
25
Explanation: fun(num) takes a number num as input and returns its square (num * num). When called with fun(5), it calculates 5 * 5 and stores the result in res.
6. Lambda functions
A lambda function is an anonymous (nameless) function that is defined in a single line using the lambda keyword. It is used for short, simple operations where defining a full function is unnecessary.
res = lambda x: x * x
print(res(4))
Output
16
Explanation: lambda x: x * x takes one input x and returns its square (x * x). When res(4) is called, it computes 4 * 4, resulting in 16 .
Pass by Reference or Pass by Value
Python does not follow strictly pass by value or pass by reference. Instead, it uses pass by object reference (call by object sharing). This means that references to objects are passed to functions.
- If the object is immutable (e.g., integers, strings, tuples), modifying it inside the function creates a new object, so the original remains unchanged.
- If the object is mutable (e.g., lists, dictionaries), changes made inside the function affect the original object.
Example: Immutable Objects
def fun(x):
print("Value received:", x, "id:", id(x))
x = 12
print("Value passed:", x, "id:", id(x))
fun(x)
Output
Value passed: 12 id: 140027364606256 Value received: 12 id: 140027364606256
Explanation:
- fun(x) prints the value of x and its memory identifier using id() and x is assigned the value 12 and before calling the function, both the value and id of x are printed.
- When the function is called, it prints the same information for x. Since integers are immutable, no modification happens to the original object.
Example: Mutable Objects
def fun(a):
a[0] = 100 # Changing the first element of the list
print("Inside function - lst:", a)
a = [1, 2, 3] # List is mutable
print("Before function call - lst:", a)
fun(a)
# List is modified outside the function
print("After function call - lst:",a)
Output
Before function call - lst: [1, 2, 3] Inside function - lst: [100, 2, 3] After function call - lst: [100, 2, 3]
Explanation: fun(a) modifies the first element of the passed list ([0] = 100). Since lists are mutable in Python, the change is reflected outside the function. Before the call, a is [1, 2, 3], and after the call, it becomes [100, 2, 3].