Scribd
Upload
4 views

Functions

The document provides an overview of functions in Python, detailing their definition, calling, and debugging, along with key concepts such as parameters, return values, and variable scope. It covers various types of parameters, common errors, lambda functions, recursion, and the importance of docstrings. Additionally, it highlights real-world applications of functions and key takeaways for effective function usage.

Uploaded by

Mercy Okanlawon
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
4 views

Functions

The document provides an overview of functions in Python, detailing their definition, calling, and debugging, along with key concepts such as parameters, return values, and variable scope. It covers various types of parameters, common errors, lambda functions, recursion, and the importance of docstrings. Additionally, it highlights real-world applications of functions and key takeaways for effective function usage.

Uploaded by

Mercy Okanlawon
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 6

Functions

Goal: Understand how to define, call, and debug functions in Python,


including parameters, return values, and scope.

1. What Are Functions?

Functions are reusable blocks of code that perform specific tasks. They
help:

 Avoid repetitive code.


 Organize logic into modular units.
 Simplify debugging.

Syntax:

def function_name(parameters):
# Code to execute
return value

Example:

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

greet("Alice") # Output: Hello, Alice!

2. Defining Functions

1. Function Name: Follows variable naming rules (letters,


underscores, no numbers/symbols).
2. Parameters: Variables listed in parentheses (inputs to the
function).
3. Body: Indented code block.
4. Return Statement: Exits the function and sends back a value
(optional).

Example with Return:

def add(a, b):


return a + b

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

Key Notes:

 If no return is specified, the function returns None.


 Functions can return multiple values (as a tuple):
def min_max(numbers):
return min(numbers), max(numbers)

values = [4, 2, 9]
smallest, largest = min_max(values)

3. Parameters vs. Arguments

 Parameters: Variables defined in the function’s declaration.


 Arguments: Actual values passed to the function when calling it.

Example:

def multiply(x, y): # x and y are parameters


return x * y

multiply(2, 4) # 2 and 4 are arguments

Types of Parameters:

1. Positional: Matched by order.


2. Keyword: Explicitly named arguments.
3. Default: Assigned a default value.
4. Arbitrary: *args (tuple) and **kwargs (dict).

Example with Default Values:

def power(base, exponent=2):


return base ** exponent

print(power(3)) # Output: 9 (uses default exponent=2)


print(power(3, 3)) # Output: 27

4. Scope: Local vs. Global Variables

 Local Variables: Defined inside a function. Not accessible outside.


 Global Variables: Defined outside functions. Accessible
everywhere.

Example:

global_var = 10

def my_function():
local_var = 5
print(global_var + local_var) # Output: 15

my_function()
print(local_var) # NameError: 'local_var' is not defined

Modifying Global Variables:


Use the global keyword:

count = 0

def increment():
global count
count += 1

increment()
print(count) # Output: 1
5. Common Function Errors

1. Missing Return Value:


def calculate_area(radius):
area = 3.14 * radius ** 2

print(calculate_area(5)) # Output: None (no return statement)

2. Incorrect Indentation:
def wrong():
print("Hello") # IndentationError

3. Mixing Data Types:


def add(a: int, b: int) -> int:
return a + b

add("3", 5) # TypeError: Can't add str and int

4. Unused Parameters:
def greet(name):
print("Hello!") # 'name' is defined but never used

6. Lambda Functions

 Anonymous, single-expression functions.


 Syntax: lambda arguments: expression

Example:

square = lambda x: x ** 2
print(square(4)) # Output: 16

Use Cases:

 Short operations (e.g., sorting with key=lambda).


 Temporary functions.
7. Recursion

A function that calls itself.

Example (Factorial):

def factorial(n):
if n == 1:
return 1
else:
return n * factorial(n - 1)

print(factorial(5)) # Output: 120

Key Notes:

 Requires a base case to avoid infinite recursion.


 Can be memory-intensive for large inputs.

8. Docstrings

Documentation strings explaining a function’s purpose.

Example:

def divide(a, b):


"""Divides two numbers and returns the result.

Args:
a (float): Numerator
b (float): Denominator

Returns:
float: Result of division, or None if b is 0.
"""
if b == 0:
return None
return a / b

Accessing Docstrings:

print(divide.__doc__)

9. Real-World Applications

1. Data Processing:
def clean_data(data):
# Remove duplicates, handle missing values
return cleaned_data

2. Input Validation:
def validate_age(age):
return age >= 18

3. Modularizing Code:
def send_email(recipient, message):
# Connect to server, send email
print("Email sent!")

10. Key Takeaways

1. Use def to define functions and return to exit with a value.


2. Parameters can have default values (e.g., def func(a=0)).
3. Variables inside functions are local unless declared global.
4. Avoid infinite recursion with a base case.

You might also like