Skip to main content

​
1. What is a Function?

  • A function is a reusable block of code that performs a specific task.
  • Functions help in organizing code, reducing redundancy, and improving readability.
  • In Python, functions are defined using the def keyword.

​
2. Defining a Function

  • Use the def keyword followed by the function name and parentheses ().
  • Parameters (inputs) can be included inside the parentheses.
  • The function body is indented and contains the code to be executed.
  • Use the return statement to send a value back to the caller.
Syntax: 
def function_name(parameters):
    # Function body
    return value  # Optional
Example: 
def greet(name):
    return f"Hello, {name}!"

​
3. Calling a Function

  • To use a function, you need to call it by its name followed by parentheses ().
  • If the function has parameters, pass the required arguments inside the parentheses.
Example: 
message = greet("Raj")
print(message)  # Output: Hello, Raj!

​
4. Function Parameters and Arguments

  • Parameters: Variables listed inside the parentheses in the function definition.
  • Arguments: Values passed to the function when it is called.
Example: 
def add(a, b):  # a and b are parameters
    return a + b

result = add(5, 10)  # 5 and 10 are arguments
print(result)  # Output: 15

​
5. Types of Arguments

  • Positional Arguments: Arguments are passed in the order of parameters. 
    def greet(name, age):
    return f"Hello, {name}! You are {age} years old."

print(greet("Ram", 25))  # Output: Hello, Ram! You are 25 years old.
  • Keyword Arguments: Arguments are passed with the parameter name. 
    print(greet(age=30, name="Anand"))  # Output: Hello, Anand! You are 30 years old.
  • Default Arguments: Parameters have default values if no argument is provided. 
    def greet(name, age=18):  # age has a default value of 18
    return f"Hello, {name}! You are {age} years old."

print(greet("Bala"))  # Output: Hello, Bala! You are 18 years old.
  • Variable-Length Arguments:
    • *args: Accepts any number of positional arguments as a tuple.
    • **kwargs: Accepts any number of keyword arguments as a dictionary.
    Example: 
    def print_names(*args):
    for name in args:
        print(name)

print_names("Karthik", "Kumar", "David")  # Prints all names

def print_details(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_details(name="Kannan", age=28, city="Chennai")

​
6. Return Values

  • The return statement is used to send a value back to the caller.
  • A function can return multiple values as a tuple.
Example: 
def calculate(a, b):
    sum = a + b
    difference = a - b
    return sum, difference

result = calculate(10, 5)
print(result)  # Output: (15, 5)

​
7. Scope of Variables

  • Local Variables: Variables defined inside a function are local to that function.
  • Global Variables: Variables defined outside a function can be accessed globally.
  • Use the global keyword to modify a global variable inside a function.
Example: 
x = 10  # Global variable

def update_x():
    global x
    x = 20  # Modifying the global variable

update_x()
print(x)  # Output: 20

​
8. Lambda Functions (Anonymous Functions)

  • Lambda functions are small, anonymous functions defined using the lambda keyword.
  • They can have any number of arguments but only one expression.
Syntax: 
lambda arguments: expression
Example: 
square = lambda x: x ** 2
print(square(5))  # Output: 25

​
9. Additional Examples

  • Simple Function: 
    def greet_person(name):
    return f"Good morning, {name}!"

print(greet_person("Siva"))  # Output: Good morning, Siva!
  • Function with Default Argument: 
    def greet_person(name, city="Chennai"):
    return f"Hello, {name}! Welcome to {city}."

print(greet_person("Ramesh"))  # Output: Hello, Ramesh! Welcome to Chennai.
print(greet_person("Suresh", "Bangalore"))  # Output: Hello, Suresh! Welcome to Bangalore.
  • Function with Variable-Length Arguments: 
    def print_scores(**kwargs):
    for subject, score in kwargs.items():
        print(f"{subject}: {score}")

print_scores(math=95, science=89, english=92)
# Output:
# math: 95
# science: 89
# english: 92
  • Lambda Function: 
    is_even = lambda x: x % 2 == 0
print(is_even(10))  # Output: True

​
10. Best Practices

  • Use descriptive function names to indicate their purpose.
  • Keep functions small and focused on a single task.
  • Use comments to explain complex logic.
  • Avoid using too many global variables.