Python Functions

Functions help make your programs more readable, efficient, and easier to maintain. In this lesson, you’ll learn how to define, call, and use functions, as well as pass arguments and return values.

What is a Function?

A function is a block of reusable code that performs a specific task. Functions help to break your program into smaller, manageable parts. Instead of repeating the same code in multiple places, you can define a function once and reuse it whenever needed.

Why Use Functions?

• Code Reusability: You can define a function once and use it many times.
• Organization: Functions make your code more modular and easier to read.
• Maintainability: Changes made in a function are applied wherever the function is used.
• Abstraction: Functions allow you to hide complex details and focus on higher-level logic.

Defining a Function

You define a function using the def keyword, followed by the function name, parentheses (), and a colon :. The code inside the function is indented.

Basic Syntax:

def function_name():
    # Code block (indented)
    print("This is a function.")

Example:

def greet():
    print("Hello, world!")

# Calling the function
greet()  # Output: Hello, world!

In this example, the function greet() is defined and then called using its name followed by parentheses.

Function Parameters

A function can take parameters (or arguments, depending on your point of view) to accept input values. These parameters allow the function to perform operations based on the given input.

Example:

def greet(name):
    print(f"Hello, {name}!")

# Calling the function with an argument
greet("Alice")  # Output: Hello, Alice!

In this case, name is a parameter, and when we call greet("Alice"), the value "Alice" is passed as an argument to the function.

Return Values

A function can return a value using the return statement. Once a function returns a value, the function exits, and the returned value can be assigned to a variable or used in further calculations.

Example:

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

# Calling the function and storing the result
result = add(5, 3)
print(result)  # Output: 8

Here, the function add() returns the sum of a and b. The returned value is then printed.

Positional vs. Keyword Arguments

Positional Arguments:

Arguments passed to a function are positional by default, which means the order matters and must match the order of the parameters in the function definition.

Example:

def describe_pet(animal, name):
    print(f"I have a {animal} named {name}.")

# Positional arguments
describe_pet("dog", "Buddy")  # Output: I have a dog named Buddy.

Keyword Arguments:

You can also pass arguments by explicitly specifying their parameter names, regardless of their order. These are called keyword arguments.

Example:

# Keyword arguments
describe_pet(animal="cat", name="Whiskers")  # Output: I have a cat named Whiskers.

Using keyword arguments makes your code more readable, especially when a function has many parameters.

Default Parameter Values

You can define default values for parameters in a function. If an argument is not provided when calling the function, the default value is used.

Example:

def greet(name="Guest"):
    print(f"Hello, {name}!")

# Using default value
greet()  # Output: Hello, Guest!

# Providing an argument
greet("Alice")  # Output: Hello, Alice!

Here, if no argument is provided when calling greet(), the function uses the default value "Guest".

Variable-Length Arguments

Sometimes you may not know how many arguments will be passed to a function. Python allows you to define variable-length arguments using the *args and **kwargs syntax.

Using *args for Multiple Positional Arguments:

*args allows you to pass a variable number of positional arguments to a function. Inside the function, args is treated as a tuple of all the extra arguments.

Example:

def add(*args):
    return sum(args)

# Calling the function with different numbers of arguments
print(add(1, 2, 3))  # Output: 6
print(add(4, 5))     # Output: 9

Here, the add() function can accept any number of arguments, and the sum() function calculates their total.

Using **kwargs for Multiple Keyword Arguments:

**kwargs allows you to pass a variable number of keyword arguments. Inside the function, kwargs is treated as a dictionary.

Example:

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

# Calling the function with keyword arguments
print_info(name="Alice", age=30, city="New York")
# Output:
# name: Alice
# age: 30
# city: New York

The print_info() function can handle any number of keyword arguments and prints them in a formatted way.

Returning Multiple Values

A function can return multiple values by separating them with commas. These values are returned as a tuple.

Example:

def get_coordinates():
    return 10, 20

# Unpacking the returned tuple
x, y = get_coordinates()
print(x, y)  # Output: 10 20

This feature allows you to return more than one piece of data from a function, making it easy to work with grouped values.

Scope and Lifetime of Variables

Variables inside a function are considered local to that function, meaning they exist only within the function’s scope. Once the function finishes execution, the local variables are destroyed. This is known as variable scope.

Example:

def my_function():
    x = 10  # Local variable
    print(x)

my_function()  # Output: 10
# print(x)  # This would raise an error because x is not defined outside the function

Variables created outside of all functions are global variables and can be accessed inside functions. However, you should avoid modifying global variables inside functions unless necessary.

Docstrings (Documentation Strings)

A docstring is a string that describes what a function does. It is placed immediately after the function definition and is used to document the function’s purpose, parameters, and return value. You can access a function’s docstring using the help() function or the .__doc__ attribute.

Example:

def greet(name):
    """Greet a person by their name."""
    print(f"Hello, {name}!")

# Accessing the docstring
print(greet.__doc__)  # Output: Greet a person by their name.

Using docstrings is important for making your code easier to understand, both for others and for yourself when revisiting code.

Example: Building a Simple Program

Let’s build a simple program that calculates the total cost of items in a shopping cart, where each item has a name and price.

Shopping Cart Program:

def calculate_total(items):
    """Calculate the total cost of items."""
    total = 0
    for item, price in items.items():
        total += price
    return total

# Dictionary of items and their prices
cart = {"apple": 1.2, "banana": 0.5, "cherry": 2.5}

# Calculate and print the total cost
total_cost = calculate_total(cart)
print(f"Total cost: ${total_cost:.2f}")

How it works:

• The function calculate_total() accepts a dictionary of items and prices, and sums up the prices.
• The result is printed in a formatted way to show the total cost.

Key Concepts Recap

• A function is a reusable block of code that can accept arguments and return values.
• Positional and keyword arguments allow you to pass values to functions in different ways.
• You can use default parameter values and variable-length arguments (*args, **kwargs) for more flexible function calls.
• Functions can return multiple values using tuples, and docstrings help document functions.
• Local variables are confined to the function’s scope, while global variables can be accessed throughout the program.

Exercises

1. Write a function that takes two numbers and returns both their sum and their product.
2. Create a function that takes a list of numbers and returns the largest and smallest numbers.
3. Write a function that accepts any number of positional arguments (*args) and returns their average.
4. Create a function with default parameters that calculates the area of a rectangle. If only one side is provided, assume it’s a square.

Next time, we’ll explore modules and libraries in Python, which allow you to organize and reuse code across multiple programs and leverage external functionality.

FAQ

Q1: What’s the difference between parameters and arguments in functions?

A1:
The terms parameters and arguments are often used interchangeably, but they refer to different concepts:

• Parameters are the variables listed in the function definition. They act as placeholders for values.
• Arguments are the actual values passed to the function when it is called.

Example:

def greet(name):  # 'name' is a parameter
    print(f"Hello, {name}!")

greet("Alice")  # 'Alice' is an argument

Q2: Can a function return multiple values?

A2:
Yes, a function can return multiple values by separating them with commas. Python automatically packages these values into a tuple, which can be unpacked later.

Example:

def get_coordinates():
    return 10, 20

x, y = get_coordinates()
print(x, y)  # Output: 10 20

Returning multiple values is useful when a function needs to provide more than one result without creating a custom structure like a list or dictionary.

Q3: What happens if I define a parameter with a default value, but also pass an argument for it?

A3:
If a function parameter has a default value, and you pass an argument for that parameter, the provided argument overrides the default value.

Example:

def greet(name="Guest"):
    print(f"Hello, {name}!")

greet("Alice")  # Output: Hello, Alice! (overrides the default value "Guest")
greet()         # Output: Hello, Guest! (uses the default value)

In this case, if you pass "Alice" as an argument, it replaces the default "Guest" value.

Q4: What is the purpose of *args and **kwargs, and when should I use them?

A4:

• *args: Use *args when you want to pass a variable number of positional arguments to a function. It allows your function to accept more arguments than you initially defined.
  Example:

  def add(*args):
      return sum(args)

  print(add(1, 2, 3))  # Output: 6
  print(add(5, 10))    # Output: 15

• **kwargs: Use **kwargs to pass a variable number of keyword arguments to a function. This allows you to pass named arguments that aren’t predefined in the function signature.
  Example:

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

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

Use *args when you’re not sure how many positional arguments will be passed, and **kwargs when you’re not sure how many named arguments the function will receive.

Q5: Can a function modify a global variable?

A5:
Yes, but you need to explicitly declare it global with the global keyword inside the function – otherwise the function will treat the variable as local, and modifications will not affect the global variable.

Example:

count = 0  # Global variable

def increment():
    global count
    count += 1

increment()
print(count)  # Output: 1

Be cautious when modifying global variables inside functions, as this can lead to unexpected behavior in larger programs. It’s generally better to avoid using global variables when possible.

Q6: What is the difference between positional arguments and keyword arguments?

A6:

• Positional arguments: These are arguments passed in the order that the function parameters are defined. The position matters, and the arguments must match the order of the parameters. Example:

  def describe_pet(animal, name):
      print(f"I have a {animal} named {name}.")

  describe_pet("dog", "Buddy")  # Positional: "dog" for animal, "Buddy" for name

• Keyword arguments: These are arguments passed with the parameter names explicitly stated. The order doesn’t matter because each argument is matched to its corresponding parameter by name. Example:

  describe_pet(animal="cat", name="Whiskers")  # Keyword arguments

Keyword arguments can make your code more readable, especially when a function has many parameters.

Q7: Can I call a function before it’s defined in my script?

A7:
No, Python requires that a function is defined before it is called. If you try to call a function before its definition, Python will raise a NameError.

Example:

greet()  # Error: NameError: name 'greet' is not defined

def greet():
    print("Hello!")

To avoid errors, make sure to define your functions before calling them in your code.

Q8: What’s the difference between return and print in a function?

A8:

• return: The return statement sends a value back to the caller of the function. The returned value can be used in further operations or stored in a variable. Example:

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

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

• print: The print() function displays output to the console but does not return anything. You cannot use print() to capture a value for later use. Example:

  def add(a, b):
      print(a + b)

  result = add(5, 3)  # Output: 8, but result is None

Use return when you need to send a value back from the function and use print for displaying results without storing them.

Q9: Why should I use docstrings in functions?

A9:
Docstrings are used to describe what a function does, making your code more readable and easier to understand. They provide important information about the function’s behavior, parameters, and return values. When you or others revisit the code later, docstrings make it easier to understand the function’s purpose.

Example:

def calculate_area(length, width):
    """Calculate the area of a rectangle."""
    return length * width

You can access the docstring of a function using help() or the .__doc__ attribute:

print(calculate_area.__doc__)  # Output: Calculate the area of a rectangle.

Docstrings are especially important in larger projects where multiple developers are working on the same codebase.

Q10: Can I define a function inside another function?

A10:
Yes, Python allows you to define nested functions, where a function is defined inside another function. This is useful when you want a helper function that’s only needed within the outer function.

Example:

def outer_function(text):
    def inner_function():
        print(text)
    inner_function()

outer_function("Hello, world!")  # Output: Hello, world!

Nested functions are often used when you want to encapsulate functionality that’s only relevant within the context of the outer function.

Q11: What’s the purpose of the pass statement in a function?

A11:
The pass statement is a placeholder that allows you to define a function without providing any code inside it. This is useful when you’re planning the structure of your program but haven’t yet implemented the function’s logic. Without pass, Python would raise a SyntaxError if a function has no content.

Example:

def my_function():
    pass  # Placeholder for future code

Using pass allows your code to run without errors while you continue developing the rest of your program.

Q12: What happens if I don’t include a return statement in a function?

A12:
If a function does not include a return statement, it will return None by default. This means that if you call the function and try to use its return value, you will get None.

Example:

def greet():
    print("Hello!")

result = greet()  # Calls the function but returns None
print(result)  # Output: None

While print() produces output, it does not return a value, so the variable result is assigned None.