Functions
1. Defining Functions
Defining functions allows you to encapsulate common operations that can be reused throughout your code. Here's an example of how to define a simple function to add two numbers:
def add(a, b):
return a + bUsage Scenarios: This is useful for performing common operations like addition, string manipulation, etc.
Pros: Functions are reusable, modular, and improve code readability.
Cons: Functions can become complex if too many parameters are passed.
2. Return Values
Functions often return a processed value that can be used for further operations. For example, here's a function that squares a number:
def square(x):
return x**2Usage Scenarios: Functions that return a processed value from inputs.
Pros: Enables functions to return results for further use or processing.
Cons: Can lead to unclear code if return values are not documented properly.
3. *args
*args*args allows functions to accept a variable number of positional arguments. For instance:
def foo(*args):
print(args)Usage Scenarios: Useful when you need to handle variable numbers of positional arguments in functions.
Pros: Allows functions to accept flexible numbers of positional arguments.
Cons: Can make debugging harder if not used carefully.
4. **kwargs
**kwargs**kwargs enables a function to accept any number of keyword arguments. Here's an example:
def foo(**kwargs):
print(kwargs)Usage Scenarios: Handling variable numbers of keyword arguments in functions.
Pros: Allows functions to accept flexible numbers of keyword arguments.
Cons: Can make debugging harder if not used carefully.
5. Lambda Functions
Lambda functions provide a concise way to define short-term, anonymous functions. Here's an example that squares a number:
square = lambda x: x**2Usage Scenarios: Useful for one-off operations.
Pros: Concise, useful for short operations, and doesn't require a function name.
Cons: Less readable for complex operations and not reusable.
6. Recursion
Recursion allows a function to call itself in order to solve problems that can be broken down into smaller sub-problems. For example, the factorial function:
def factorial(n):
return n * factorial(n-1) if n > 1 else 1Usage Scenarios: Tasks that require repetitive operations, like calculating factorials or tree traversal.
Pros: Elegant for problems with a recursive structure (e.g., trees or graphs).
Cons: Can lead to a stack overflow if not carefully designed.
7. Default Arguments
Functions can have default argument values, which can simplify function calls. For example:
def greet(name="John"):
return f"Hello, {name}"Usage Scenarios: When parameters have default values.
Pros: Convenient for optional parameters and reduces function overload.
Cons: Default values may conflict with provided arguments.
8. Keyword Arguments
Keyword arguments allow you to pass arguments by name, which prevents confusion. For example:
def greet(name, age=25):
return f"{name} is {age} years old"Usage Scenarios: Passing arguments by name in function calls.
Pros: Clear, prevents errors due to position-based argument confusion.
Cons: Overuse can make function calls verbose and less concise.
9. Function Annotations (Type Hints)
Function annotations provide type hints to improve code clarity and static analysis. Here's an example:
def add(a: int, b: int) -> int:
return a + bUsage Scenarios: Adding type hints for better readability and static type checking.
Pros: Improves code clarity, enables static analysis, and helps with debugging.
Cons: Can increase verbosity and may seem unnecessary for simple cases.
10. Variable Scope
Understanding the scope of variables in functions is essential for avoiding unintended changes. Here's an example:
x = 10
def func():
x = 5
print(x)
func()Usage Scenarios: Understanding local vs global variable scope in functions.
Pros: Helps avoid unintended changes to global variables and aids debugging.
Cons: Can cause confusion if variables have similar names across different scopes.
11. Nonlocal Keyword
The nonlocal keyword allows you to modify variables in an outer scope (but not global). Here's an example:
def outer():
x = 10
def inner():
nonlocal x
x = 20
inner()
print(x)Usage Scenarios: Useful for modifying variables in an outer (non-global) scope within nested functions.
Pros: Allows modification of outer scope variables.
Cons: Overuse can make code harder to follow, especially in deeply nested functions.
12. Closures
A closure is a function that captures variables from its outer function. Here's an example:
def outer(x):
def inner(y):
return x + y
add_five = outer(5)
print(add_five(3))Usage Scenarios: Functions that return other functions, capturing variables from the outer function.
Pros: Enables encapsulation and data hiding, which is powerful in functional programming.
Cons: Can lead to unintended side effects if closures capture mutable states.
13. Higher-Order Functions
Higher-order functions either accept other functions as arguments or return them. Here's an example:
def apply_function(f, x):
return f(x)
apply_function(lambda x: x * 2, 5)Usage Scenarios: Passing functions as arguments to other functions or returning functions from them.
Pros: Flexible, enables functional programming paradigms, and simplifies code.
Cons: May make code less readable if overused and harder to understand.
14. Function Caching (Memoization)
Memoization helps store previously computed results to avoid redundant calculations. Here's an example using lru_cache:
from functools import lru_cache
@lru_cache
def fibonacci(n):
return n if n <= 1 else fibonacci(n-1) + fibonacci(n-2)Usage Scenarios: Storing previously computed results to optimize performance for repeated function calls.
Pros: Increases performance by avoiding redundant calculations.
Cons: Memory overhead and might not be useful for functions with few repeated calls.
15. Function Overloading (Simulated)
Python does not support function overloading directly, but you can simulate it by using default arguments. Here's an example:
def greet(name, age=None):
return f"Hello {name}, you are {age} years old" if age else f"Hello {name}"Usage Scenarios: Handling different numbers or types of arguments in a flexible manner.
Pros: Allows flexibility and reduces duplication in function design.
Cons: Can lead to complex logic and make the code hard to debug and maintain.
16. Function vs Method
A method is a function that is bound to an object, whereas a function is independent. Here's an example:
class Person:
def greet(self):
return f"Hello {self.name}"
person = Person("Alice")
person.greet()Usage Scenarios: Understanding the distinction between standalone functions and methods bound to classes.
Pros: Methods are bound to objects, leading to better-organized code.
Cons: Methods tied to classes may not be as reusable across different objects.
17. Error Handling in Functions
Using error handling inside functions can help prevent crashes. Here's an example of handling division by zero:
def divide(a, b):
try:
return a / b
except ZeroDivisionError:
return "Cannot divide by zero!"Usage Scenarios: Handling errors or exceptions within functions to prevent unexpected program terminations.
Pros: Improves program reliability by handling errors gracefully.
Cons: Can make code harder to follow if not used properly, and overuse may hide bugs.
Last updated