Functions

Basic Function Concepts

Functions in Python are blocks of code that can be used repeatedly to perform specific tasks. Imagine a function like an automatic coffee machine where you provide ingredients (input), then the machine processes and produces coffee (output). Every time you want coffee, you don't need to create a new machine, just use the same machine.

In programming, functions help us avoid writing the same code repeatedly. Functions have names, can accept parameters (input data), and can return values.

Function Structure and Syntax

Every function in Python has a basic structure consisting of several important components.

function_structure.py

def function_name(parameter_list):  """Optional docstring to explain the function"""  # Code block to be executed  statement_1  statement_2  return return_value  # Optional

Function components consist of:

function_example.py

# Function definitiondef greet(name):  message = f"Hello, {name}!"  return message# Function callresult = greet("Alice")print(result)  # Output: Hello, Alice!# Direct call in printprint(greet("Bob"))  # Output: Hello, Bob!

function_parameters.py

def introduction(name, age, city="Jakarta"):  return f"My name is {name}, {age} years old, living in {city}"# Using positional parametersprint(introduction("Sari", 25))# Output: My name is Sari, 25 years old, living in Jakarta# Using keyword parametersprint(introduction(age=30, name="Budi", city="Bandung"))# Output: My name is Budi, 30 years old, living in Bandung# Mix of positional and keyword parametersprint(introduction("Andi", age=28, city="Surabaya"))# Output: My name is Andi, 28 years old, living in Surabaya

variable_parameters.py

def calculate_total(*numbers):  """Calculate total from a number of numbers"""  total = 0  for num in numbers:      total += num  return total# Calling with various number of argumentsprint(calculate_total(1, 2, 3))        # Output: 6print(calculate_total(5, 10, 15, 20))  # Output: 50def student_info(name, **details):  """Display student information with additional details"""  print(f"Name: {name}")  for key, value in details.items():      print(f"{key.capitalize()}: {value}")# Calling with keyword argumentsstudent_info("Maya", age=20, major="Informatics", gpa=3.8)# Output:# Name: Maya# Age: 20# Major: Informatics# Gpa: 3.8

return_values.py

def circle_area(radius):  """Calculate circle area"""  import math  return math.pi * radius ** 2def find_min_max(number_list):  """Return minimum and maximum values"""  if not number_list:      return None, None  return min(number_list), max(number_list)def print_message(message):  """Function without explicit return"""  print(f"Message: {message}")  # No return, automatically return None# Usage examplearea = circle_area(5)print(f"Circle area: {area:.2f}")  # Output: Circle area: 78.54min_val, max_val = find_min_max([3, 1, 4, 1, 5, 9])print(f"Min: {min_val}, Max: {max_val}")  # Output: Min: 1, Max: 9result = print_message("Hello World")  # Output: Message: Hello Worldprint(f"print_message function result: {result}")  # Output: print_message function result: None

scope_variables.py

# Global variablecounter = 0def add_counter():  # Local variable with same name  counter = 10  print(f"Local counter: {counter}")def add_global_counter():  global counter  counter += 1  print(f"Global counter: {counter}")# Usage demonstrationprint(f"Initial counter: {counter}")       # Output: Initial counter: 0add_counter()                        # Output: Local counter: 10print(f"Counter after function: {counter}")  # Output: Counter after function: 0add_global_counter()                 # Output: Global counter: 1print(f"Final counter: {counter}")      # Output: Final counter: 1

first_class_functions.py

def multiply_two(x):  return x * 2def multiply_three(x):  return x * 3def apply_operation(function, value):  """Apply function to value"""  return function(value)# Store function in variableoperation = multiply_twoprint(operation(5))  # Output: 10# Store functions in listoperation_list = [multiply_two, multiply_three]for op in operation_list:  print(op(4))  # Output: 8 then 12# Pass function as argumentresult1 = apply_operation(multiply_two, 7)result2 = apply_operation(multiply_three, 7)print(f"Results: {result1}, {result2}")  # Output: Results: 14, 21

docstring_example.py

def calculate_factorial(n):  """  Calculate factorial of a positive integer.  Parameters:      n (int): Positive integer  Returns:      int: Factorial value of n  Raises:      ValueError: If n is negative      TypeError: If n is not an integer  Example:      >>> calculate_factorial(5)      120      >>> calculate_factorial(0)      1  """  if not isinstance(n, int):      raise TypeError("Input must be an integer")  if n < 0:      raise ValueError("Input must be positive or zero")  if n <= 1:      return 1  return n * calculate_factorial(n - 1)# Access docstringprint(calculate_factorial.__doc__)# Use functionprint(calculate_factorial(5))  # Output: 120print(calculate_factorial(0))  # Output: 1

nested_functions.py

def create_multiplier(factor):  """Create multiplier function with specific factor"""  def multiplier(value):      """Inner function that multiplies value by factor"""      return value * factor  return multiplier# Create specific multiplier functionsmultiply_two = create_multiplier(2)multiply_five = create_multiplier(5)print(multiply_two(10))   # Output: 20print(multiply_five(4))   # Output: 20def simple_calculator():  """Calculator with nested functions"""  def add(a, b):      return a + b  def subtract(a, b):      return a - b  def multiply(a, b):      return a * b  # Return dictionary containing functions  return {      'add': add,      'subtract': subtract,      'multiply': multiply  }# Use calculatorcalc = simple_calculator()print(calc['add'](5, 3))  # Output: 8print(calc['subtract'](10, 4)) # Output: 6print(calc['multiply'](6, 7))    # Output: 42

error_handling.py

def safe_divide(numerator, denominator):  """  Perform division with error handling.  Returns:      tuple: (result, error_message)  """  try:      result = numerator / denominator      return result, None  except ZeroDivisionError:      return None, "Error: Cannot divide by zero"  except TypeError:      return None, "Error: Input must be numbers"def convert_to_int(value):  """Convert value to integer with validation"""  try:      return int(value)  except ValueError:      print(f"Warning: '{value}' cannot be converted to integer")      return None  except TypeError:      print("Error: Invalid input for conversion")      return None# Usage exampleresult, error = safe_divide(10, 2)if error:  print(error)else:  print(f"Division result: {result}")  # Output: Division result: 5.0result, error = safe_divide(10, 0)if error:  print(error)  # Output: Error: Cannot divide by zero# Test conversionnumber1 = convert_to_int("123")    # Success, return 123number2 = convert_to_int("abc")    # Output: Warning: 'abc' cannot be converted to integernumber3 = convert_to_int([1, 2])   # Output: Error: Invalid input for conversion

Functions

Basic Function Concepts

Function Structure and Syntax

How Function Calls Work

Parameters and Arguments

Positional and Keyword Parameters

Variable Number of Parameters

Function Return Values

Variable Scope in Functions

Local and Global Variables

Functions as First-Class Objects

Function Documentation with Docstring

Nested Functions and Closure

Error Handling in Functions