Parameters

Overview

Parameters are variables used to pass data into functions or procedures, allowing them to work with different values. They are a crucial part of modular programming, as they enable functions and procedures to be more flexible and reusable.

Understanding how to define and use parameters, and the difference between passing by value and passing by reference, is essential for writing effective and efficient code.

What are Parameters?

• Definition: Parameters are variables used in function or procedure definitions to accept input values.
• Purpose: They allow functions and procedures to operate on different data without needing to rewrite the code.

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

Arguments vs. Parameters

• Parameters are placeholders defined in the function or procedure.
• Arguments are the actual values passed to the function or procedure when it is called.

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

greet("Alice")  # "Alice" is the argument

Types of Parameters

Positional Parameters:

Arguments are passed in the same order as the parameters are defined.

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

result = add(5, 3)  # a = 5, b = 3

Default Parameters:

Parameters can have default values if no argument is provided.

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

Keyword Parameters:

Arguments are passed using parameter names, allowing them to be out of order.

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

result = add(b=3, a=5)  # Still valid

Passing Parameters: By Value vs. By Reference

Passing by Value

• Definition: A copy of the argument's value is passed to the function or procedure.
• Effect: Changes made to the parameter inside the function do not affect the original argument.
• Languages: Common in languages like C (for primitive types) and Python (for immutable data types like integers and strings).

def increment(x):
    x = x + 1
    print(f"Inside function: {x}")

num = 5
increment(num)
print(f"Outside function: {num}")
# Output:
# Inside function: 6
# Outside function: 5

Passing by Reference

• Definition: A reference to the original argument is passed to the function or procedure.
• Effect: Changes made to the parameter inside the function affect the original argument.
• Languages: Common in C++ and Python (for mutable data types like lists and dictionaries).

def add_item(my_list):
    my_list.append("New Item")
    print(f"Inside function: {my_list}")

items = ["Item1", "Item2"]
add_item(items)
print(f"Outside function: {items}")
# Output:
# Inside function: ['Item1', 'Item2', 'New Item']
# Outside function: ['Item1', 'Item2', 'New Item']

Benefits and Drawbacks of Passing Methods

Choosing Between By Value and By Reference

1. Use By Value When:

• You want to ensure the original data remains unchanged.
• The function only needs to work with a copy of the data.

2. Use By Reference When:

• You want the function to modify the original data.
• Passing large data structures to avoid memory overhead.

Tracing Code with Parameters

FUNCTION squareValue(x)
    x = x * x
    RETURN x
END FUNCTION

MAIN
    num = 5
    result = squareValue(num)
    PRINT num
    PRINT result
END MAIN

FUNCTION addItem(list)
    APPEND "New Item" TO list
END FUNCTION

MAIN
    myList = ["A", "B"]
    addItem(myList)
    PRINT myList
END MAIN

Writing Functions and Procedures with Parameters

Function with Parameters:

def multiply(a, b):
    return a * b

result = multiply(3, 4)  # Passes values as arguments
print(result)  # Output: 12

Procedure with Parameters:

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

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

Note Summary