Parameters and Returns | Functions Tutorial

Python Functions: Parameters and Returns

Functions are fundamental building blocks in Python (and most programming languages). They allow you to organize code into reusable blocks, making your programs more modular, readable, and maintainable. A key aspect of functions is how they interact with the rest of your code through parameters (inputs) and returns (outputs).

1. Parameters (Inputs to a Function)

Parameters are variables listed inside the parentheses () in the function definition. They act as placeholders for values that you'll pass into the function when you call it.

Types of Parameters:

Positional Arguments: These are the most common. The order in which you pass the arguments matters.
Keyword Arguments: You explicitly specify which parameter each argument corresponds to using the parameter name. This allows you to pass arguments in any order.
Default Arguments: You can provide default values for parameters. If the caller doesn't provide a value for that parameter, the default value is used.
Variable-Length Arguments: These allow a function to accept an arbitrary number of arguments.

Example:

def greet(name, greeting="Hello"):  # 'name' is a positional argument, 'greeting' has a default value
  """Greets a person with a specified greeting."""
  print(f"{greeting}, {name}!")

# Calling the function with positional arguments
greet("Alice")  # Output: Hello, Alice!

# Calling the function with a keyword argument
greet(greeting="Hi", name="Bob")  # Output: Hi, Bob!

# Calling the function with both positional and keyword arguments
greet("Charlie", greeting="Good morning") # Output: Good morning, Charlie!

Explanation:

def greet(name, greeting="Hello"): defines a function named greet that takes two parameters: name and greeting.
name is a positional argument – you must provide a value for it when calling the function.
greeting has a default value of "Hello". If you don't provide a value for greeting when calling the function, it will default to "Hello".
The docstring """Greets a person with a specified greeting.""" is good practice for documenting your functions.

More on Parameter Types:

*args (Variable-Length Positional Arguments): Allows you to pass a variable number of non-keyword arguments. These arguments are collected into a tuple.

def sum_numbers(*args):
  """Calculates the sum of an arbitrary number of numbers."""
  total = 0
  for num in args:
    total += num
  return total

print(sum_numbers(1, 2, 3))  # Output: 6
print(sum_numbers(10, 20, 30, 40)) # Output: 100

**kwargs (Variable-Length Keyword Arguments): Allows you to pass a variable number of keyword arguments. These arguments are collected into a dictionary.

def print_info(**kwargs):
  """Prints information based on keyword arguments."""
  for key, value in kwargs.items():
    print(f"{key}: {value}")

print_info(name="David", age=30, city="New York")
# Output:
# name: David
# age: 30
# city: New York

2. Return Values (Outputs from a Function)

The return statement is used to send a value back from a function to the caller. A function doesn't have to return a value. If it doesn't have a return statement, or if the return statement doesn't specify a value, it implicitly returns None.

Example:

def add(x, y):
  """Adds two numbers and returns the result."""
  result = x + y
  return result

sum_result = add(5, 3)
print(sum_result)  # Output: 8

def say_hello(name):
  """Prints a greeting but doesn't return a value."""
  print(f"Hello, {name}!")

return_value = say_hello("Eve")
print(return_value)  # Output: None

Explanation:

return result in the add function sends the value of the result variable back to the caller.
The say_hello function prints a message but doesn't have a return statement. Therefore, it implicitly returns None.

Returning Multiple Values:

Python allows you to return multiple values from a function by separating them with commas. These values are returned as a tuple.

def get_name_and_age():
  """Returns a name and age as a tuple."""
  name = "Frank"
  age = 40
  return name, age

name, age = get_name_and_age()
print(f"Name: {name}, Age: {age}")  # Output: Name: Frank, Age: 40

Key Takeaways:

Parameters are inputs to a function.
Return values are outputs from a function.
Functions can have zero or more parameters.
Functions can return zero or one value (or multiple values as a tuple).
Using parameters and return values makes functions reusable and allows them to interact with other parts of your program.
Good documentation (docstrings) is crucial for understanding how to use functions correctly.