Creating a Function
Creating a function in Python is a fundamental concept that helps in structuring your code into reusable blocks. Functions allow you to encapsulate code into a single unit that can be executed whenever needed. Here’s a comprehensive guide to creating functions in Python.
Basic Syntax
To define a function in Python, you use the def keyword, followed by the function name, a pair of parentheses (which may include parameters), and a colon. The body of the function is indented.
Syntax:
Example:
def say_hello():
print("Hello!")
Naming a Function
Function names should be:
- Descriptive: Choose names that clearly indicate what the function does.
- Lowercase: By convention, function names are written in lowercase, with words separated by underscores if needed (function_name).
- Valid: Must start with a letter or underscore, followed by letters, digits, or underscores. They cannot be reserved words.
Examples:
def calculate_sum(a, b): return a + b def display_message(message): print(message)
Function Parameters
Parameters are variables specified in the function definition that allow the function to accept input values.
Example:
def multiply(x, y): return x * y # Calling the function with arguments result = multiply(4, 5) print(result) # Output: 20
Function Body
The body of a function contains the code that runs when the function is called. It must be properly indented. In Python, the standard indentation is 4 spaces or one tab.
Example:
def greet(name):
message = f"Hello, {name}!"
print(message)
Function with No Instructions
A function can be defined with no instructions. This can be useful for creating placeholders in your code.
Example:
def placeholder_function(): pass # The pass statement is a placeholder
Function with Default Parameters
Parameters can have default values, making them optional when calling the function.
Example:
def greet(name="stranger"):
print(f"Hello, {name}!")
greet() # Output: Hello, stranger!
greet("Alice") # Output: Hello, Alice!
Returning a Value
Functions can return a value using the return keyword. When return is executed, the function terminates immediately, and any code after the return statement is not executed.
Example:
def square(x): return x * x result = square(5) print(result) # Output: 25
Using Docstrings for Documentation
Docstrings are documentation strings that immediately follow the function definition and are enclosed in triple quotes. They describe what the function does, its parameters, and its return value.
Example:
def addition(a, b): """ Computes the sum of two numbers. :param a: First number :param b: Second number :return: The sum of a and b """ return a + b
You can access this documentation using .__doc__ or the help() function.
Example:
print(addition.__doc__) # Or help(addition)
Functions with Side Effects
Functions can also have side effects, such as modifying global variables, writing to files, or interacting with the user.
Example:
message = "Hello"
def change_message(new_message):
global message
message = new_message
change_message("Hello, world!")
print(message) # Output: Hello, world!
Anonymous Functions (Lambda)
Python also allows you to define anonymous functions using the lambda keyword. These are typically used for simple operations and are often passed as arguments to other functions.
Syntax:
lambda arguments : expression
Example:
square = lambda x: x * x print(square(5)) # Output: 25
Lambda functions are commonly used with functions like map(), filter(), or sorted().
Example with map():
numbers = [1, 2, 3, 4] squares = map(lambda x: x * x, numbers) print(list(squares)) # Output: [1, 4, 9, 16]
Summary
Creating a function in Python involves:
- Defining the function using def.
- Giving it a meaningful name.
- Specifying parameters (if needed).
- Writing the function body with proper indentation.
- Using return to provide a result (if needed).
- Documenting the function with docstrings for better clarity.