Python Functions

​

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.

def function_name(parameters):
    # Function body
    return value  # Optional

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.

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.

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.

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.

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.

lambda arguments: expression

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.