Scribd
Upload
7 views7 pages

Untitled Document (15)

Uploaded by

kylemessi001
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
7 views7 pages

Untitled Document (15)

Uploaded by

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

Content on Functions

1. What Are Functions?

Functions are reusable blocks of code designed to perform a specific task.


They help make programs:

● Reusable: Write a piece of code once and call it multiple times.


● Maintainable: Modify a single function to update all calls to it.
● Organized: Divide complex programs into smaller, logical units.

Key Features of Functions:

1. Encapsulation: Functions bundle related logic together.


2. Abstraction: Users of a function don’t need to know its internal
workings; they just call it.
3. DRY Principle: Avoid code repetition with functions (Don't Repeat
Yourself).

2. Defining and Calling Functions

A function must be defined before it can be called.

2.1 Defining a Function

Syntax:

def function_name(parameters):

# Function body
return value # Optional

Example:

def greet_user(name):

print(f"Hello, {name}!")

● def: Defines a function.


● function_name: Name of the function (should describe what it
does).
● parameters: Inputs to the function (optional).
● Function body: Indented code block containing the logic.

2.2 Calling a Function

To execute a function, call it using its name and provide arguments if


required.

Example:

greet_user("Alice")

Output:
Hello, Alice!

3. Parameters and Arguments

Parameters: Variables defined in the function definition to accept inputs.


Example:
python
Copy code
def add(a, b): # a and b are parameters

return a + b

Arguments: Values provided to the function when calling it.


Example:

print(add(3, 5)) # 3 and 5 are arguments

Default Parameters: Provide default values if no argument is passed.

def greet(name="Guest"):

print(f"Hello, {name}!")

greet() # Output: Hello, Guest!

4. Fruitful Functions (Returning Values)


Functions can return values using the return statement.

Example:

def square(number):

return number * number

result = square(4)

print(f"The square is {result}.")

Output:

The square is 16.

5. Types of Functions

1. Built-In Functions: Provided by Python, e.g., print(), len(),


range().
2. User-Defined Functions: Created by the programmer for specific
needs.

Comparison:

Feature Built-In User-Defined


Functions Functions
Purpos General-purpose Specific to the
e tasks program

Exampl sum(), calculate_total(


es input() ), greet()

6. Advanced Features of Functions

Positional and Keyword Arguments:

def describe_pet(animal, name):

print(f"{name} is a {animal}.")

describe_pet("dog", "Buddy") # Positional


arguments

describe_pet(animal="cat", name="Kitty") # Keyword


arguments

1.

Arbitrary Arguments: Use *args for variable-length arguments.

def add_numbers(*args):

return sum(args)
print(add_numbers(1, 2, 3, 4)) # Output: 10

Arbitrary Keyword Arguments: Use **kwargs for variable-length


keyword arguments.

def print_user_details(**kwargs):

for key, value in kwargs.items():

print(f"{key}: {value}")

print_user_details(name="Alice", age=25, city="Paris")

7. Best Practices

Use Meaningful Names: Function names should clearly indicate


their purpose.

○ Good: calculate_area(), send_email()


○ Bad: func1(), do_stuff()

Keep Functions Small: Each function should perform one specific


task.

Document Functions: Use comments or docstrings to explain what the


function does.

def calculate_area(radius):
"""Calculates the area of a circle given its
radius."""

return 3.14 * radius ** 2

Avoid Global Variables: Pass required data as parameters instead


of relying on global variables.

Thinking Points

1. Why is it better to use functions instead of repeating code?


2. What happens if you call a function without providing required
arguments?
3. How can you improve the readability of complex functions?

You might also like