⚙️ Functions in Python

A function is a block of code which only runs when it is called.

You can pass data, known as parameters, into a function.

A function can return data as a result.

  def function_name():
      # Code block          
            

⚙️ Creating a Function in Python

In Python a function is defined using the def keyword:

  def my_function():
      print("Hello from a function")
            

⚙️ Calling a Function in Python

To call a function, use the function name followed by parenthesis:

  def my_function():
      print("Hello from a function")

  my_function()
            

⚙️ Types of Functions in Python

Python comes preloaded with many function definitions that you can use or create new functions.

1. Module Functions 2. Built-in Functions 3. User-Defined Functions

⚙️ Module Functions in Python

A module is a Python file with the .py extension that contains a collection of functions, classes, and variables. You can import and use functions from a module.

  import math
  print(math.sqrt(16))  # Output: 4.0
  print(math.factorial(5))  # Output: 120
  print(math.pi)  # Output: 3.141592653589793              
            

⚙️ Built-in Functions in Python

Built-in functions are the functions that are always available in Python — no need to import any module.

  name = input("Enter your name: ")
  print("Hello,", name)
  print("Length of your name:", len(name))
          

⚙️ User-Defined Functions in Python

User-defined functions in Python are functions that are created by the user to perform specific tasks.

  def function_name(parameters): # Function Header
      # Function body
      # Code to execute
      return result
            

⚙️ Function Parameters and Arguments in Python

A parameter is the variable listed inside the parentheses in the function definition.

An argument is the value that is sent to the function when it is called.

  def greet(name):   # 'name' is a parameter
      print("Hello", name)

  greet("Deepak")     # "Deepak" is an argument
            

⚙️ Types of User-Defined Functions in Python

1. Takes Nothing, Returns Nothing Function does not take parameters and does not return a value. Only performs a task.

  def add_numbers():
      a = 5
      b = 3
      print("Sum =", a + b)
          
  add_numbers()          
            

Takes Something, Returns Nothing Function takes parameters but does not return any value. Used for processing input.

  def add_numbers(a, b):
      sum = a + b
      print("Sum =", Sum)
                    
  add_numbers(5, 3)            
            

Takes Nothing, Returns Something Function doesn’t take input, but returns a value. Used when logic is inside function.

  def add_numbers():
      a = 5
      b = 3
      return a + b
                    
  sum = add_numbers()        
  print("Sum =", Sum)
            

Takes Something, Returns Something Function takes input and returns a value. Most common and useful type.

  def add_numbers(a, b):
      return a + b
                    
  sum = add_numbers(5, 3)        
  print("Sum =", Sum)
            

⚙️ Types of Parameters / Arguments in Python

In Python, there are five main types of parameters/arguments used in functions.

1. Required Positional Arguments

2. Keyword Arguments

3. Default Arguments

4. Variable-length Positional Arguments (*args)

5. Variable-length Keyword Arguments (**kwargs)

⚙️ Python Function – Required Positional Arguments

A required positional argument is an argument that must be passed to the function

If any required argument is missing Python will raise an error.

  def display(name, age):
      print("Name:", name)
      print("Age:", age)

  display("Riya", 21)   # ✅ Correct
  display(21, "Riya")   # ⚠️ Wrong Order – Incorrect Output
  display("Amit")       # ❌ Error – Missing Argument
            

⚙️ Python Function – Keyword Arguments

Keyword arguments allow you to pass values to function parameters by name instead of by position.

  def display(name, age):
      print("Name:", name)
      print("Age:", age)
          
  # ✅ Correct: Using keyword arguments in order
  display(name="Riya", age=21)
  
  # ✅ Correct: Order doesn't matter with keyword arguments
  display(age=21, name="Riya")
  
  # ✅ Correct: Positional first, then keyword
  display("Riya", age=21)
  
  # ❌ Error: Keyword cannot come before positional
  display(name="Riya", 21)   # SyntaxError: positional argument follows keyword argument          
            

⚙️ Python Function - Default Arguments

In Python, default arguments allow you to assign a default value to a function parameter that is used if no value is given during the call.

  def display(age=18, name):  # ❌ SyntaxError: non-default argument follows default argument 
      # Function body

  def display(name, age=18):  # Default value for age is 18
      print("Name:", name)
      print("Age:", age)

  # ✅ Both arguments provided
  display("Riya", 21)

  # ✅ Only one argument: 'age' uses default value (18)
  display("Amit")

  # ✅ Keyword argument used for default parameter
  display("Amit", age=25)
            

⚙️ Python Function Variable-length Positional Arguments (*args)

*args allows you to pass a variable number of positional arguments to a function. These arguments are collected into a tuple.

  def add(*args):
      total = 0
      for num in args:
          total += num
      print("Sum:", total)
          
  # ✅ Passing multiple numbers
  add(10, 20, 30)
  
  # ✅ Passing no arguments
  add()
  
  # ✅ Passing any number of values
  add(5, 15, 25, 35, 45)          
            

⚙️ Python Function – Variable-length Keyword Arguments (**kwargs)

**kwargs lets you pass any number of keyword arguments to a function. These are stored as a dictionary.

  def display_details(**kwargs):
      for key, value in kwargs.items():
          print(key + ":", value)

  # ✅ Passing multiple keyword arguments
  display_details(name="John", age=25, course="Python")

  # ✅ Passing no arguments
  display_details()

  # ✅ Passing keyword arguments in any order
  display_details(course="Java", city="Delhi", name="Amit")
            

⚙️ Python Function – return Statement

The return statement return a value back from a function to the place where it was called. It ends the function's execution.

In Python, if a function does not have a return statement, it is considered a void function. By default, such functions return None.

  def add(a, b):
      result = a + b
      return result

  # ✅ Store returned value
  sum = add(10, 20)
  print("Sum:", sum)

  # ✅ Use directly in expression
  print("Double of sum:", add(10, 20) * 2)
            

⚙️ Python anonymous - lambda Functions

A lambda function is a small anonymous function defined using the lambda keyword. It can take any number of arguments but has only one expression.

  # ✅ Lambda function to add two numbers
  add = lambda a, b: a + b
  print("Sum:", add(10, 5)) 

  # ✅ Lambda function to find square
  square = lambda x: x * x
  print("Square:", square(4))

  # ✅ Lambda function inside another function
  def multiply(n):
      return lambda a: a * n

  double = multiply(2)
  print("Double:", double(5))
            

⚙️ Python Function – Local and Global Variables

Local Variable: Defined inside a function and accessible only within that function.

  def show():
      x = 50  # Local variable
      print("Inside function:", x)

  show()
  print("Outside function:", x) # ❌ Not accessible
            

Global Variable: Defined outside the functions and accessible throughout the program.

  x = 100  # Global variable

  def show():
      print("Inside function:", x)

  show()
  print("Outside function:", x) # ✅ Accessible
            

⚙️ Python Function – global Keyword

The global keyword is used to access and modify a global variable from inside a function.

⚠️ Without global Keyword x = x + 10 ❌ UnboundLocalError: local variable 'x' referenced before assignment

  x = 5  # Global variable

  def update():
      global x
      x = x + 10
      print("Inside function:", x)

  update()
  print("Outside function:", x)
            

⚙️ Python – Lifetime and Scope of Variables

Scope: Scope refers to where a variable can be accessed in the program.

Lifetime: Lifetime refers to how long a variable exists in memory during program execution.

  # Variable a is created when the function starts and destroyed when it ends — this is its lifetime.

  def my_function():
      a = 10  # Local variable
      a = a + 1
      print("Inside function:", a)
          
  # Calling the function multiple times
  my_function()
  my_function()
  my_function()
            

⚙️ Python – Recursive Functions

A recursive function is a function that calls itself to solve a smaller instance of the same problem until a base condition is met.

  def factorial(n):
      if n == 0:  # Base case
          return 1
      else:
          return n * factorial(n - 1)  # Recursive call

  # Calling the recursive function
  print(factorial(5)) 
            

⚙️ Python – Library Functions

Library functions are predefined functions provided by Python's standard libraries. You can directly use them without defining them yourself.

⚙️ Python - String Methods

All string methods return new values. They do not change the original string.

⚙️ Python Pattern Matching Using Regular Expressions

Pattern matching in Python is done using the re module, which provides functions to search, match, and manipulate string patterns using regular expressions (regex).

import re

  import re
  
  # Sample text
  text = "Hello World! Welcome to the world of Python. Let's find patterns in this text."
  
  # re.match() - Matches pattern at the beginning of the string
  match = re.match(r"Hello", text)
  if match:
      print("Match found:", match.group())  # Output: Match found: Hello
  else:
      print("No match found with re.match()")
  
  # re.search() - Searches for the pattern anywhere in the string
  search = re.search(r"world", text, re.IGNORECASE)  # Case insensitive search
  if search:
      print("Search found:", search.group())  # Output: Search found: World
  else:
      print("No match found with re.search()")
  
  # re.findall() - Finds all occurrences of the pattern in the string
  findall = re.findall(r"world", text, re.IGNORECASE)
  print("All occurrences found with re.findall():", findall)  # Output: ['World', 'world']
  
  # re.sub() - Replaces occurrences of the pattern with a replacement
  sub = re.sub(r"world", "universe", text, flags=re.IGNORECASE)
  print("Text after re.sub():", sub)  # Output: Hello Universe! Welcome to the universe of Python. Let's find patterns in this text.
  
  # re.split() - Splits the string using the pattern as a delimiter
  split = re.split(r"\s", text)  # Splits by whitespace
  print("Text after re.split():", split)  # Output: ['Hello', 'World!', 'Welcome', 'to', 'the', 'world', 'of', 'Python.', 'Let's', 'find', 'patterns', 'in','th'text.']              
            

⚙️ Python Numeric Functions

Includes built-in and math module functions for working with numbers.

⚙️ Python Random Module Functions

Includes functions for generating random numbers and selections

🧭 Python Date and Time Functions

Includes functions for working with dates and times.

🧭 Python calendar Module Functions