Parameters

What are parameters?

Parameters let you pass data into functions. Instead of hardcoding values, you make functions flexible to work with different inputs.

# Without parameters (inflexible)
def greet_alice():
    print("Hello, Alice!")

# With parameters (flexible)
def greet(name):
    print(f"Hello, {name}!")

# Now it works for anyone
greet("Alice")
greet("Bob")
greet("Charlie")

Basic parameters

Add parameters inside the parentheses when defining a function:

def introduce(name, age):
    print(f"My name is {name}")
    print(f"I am {age} years old")

# Call with values
introduce("Alice", 25)
introduce("Bob", 30)

The values you pass when calling a function are called “arguments”. The variables in the function definition are “parameters”. Many people use these terms interchangeably.

Positional arguments

By default, Python matches the arguments you pass in a function call to the parameters in the function definition by their position (order).

def describe_pet(animal_type, pet_name):
    print(f"I have a {animal_type} named {pet_name}.")

# Positional arguments: "hamster" maps to animal_type, "Harry" to pet_name
describe_pet("hamster", "Harry")  # I have a hamster named Harry.

# Changing the order changes the meaning!
describe_pet("Harry", "hamster")  # I have a Harry named hamster.

Multiple parameters

Functions can have multiple parameters of any type:

def calculate_total(price, tax_rate, discount):
    tax = price * tax_rate
    final_price = price + tax - discount
    print(f"Total: ${final_price}")

# Order matters when passing them positionally!
calculate_total(100, 0.08, 10)  # $98.0

Default values

Give parameters default values for optional arguments:

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

# Use default
greet("Alice")           # Hello, Alice!

# Override default
greet("Bob", "Hi")       # Hi, Bob!
greet("Charlie", "Hey")  # Hey, Charlie!

Put parameters with defaults at the end. Required parameters come first, optional ones last.

Keyword arguments

Call functions using parameter names for clarity:

def create_profile(name, age, city):
    print(f"{name}, {age}, from {city}")

# Positional arguments (order matters)
create_profile("Alice", 25, "NYC")

# Keyword arguments (order doesn't matter)
create_profile(city="NYC", age=25, name="Alice")
create_profile(name="Bob", city="LA", age=30)

Mixing positional and keyword arguments

You can combine positional and keyword arguments in the same function call. This is useful when you want to provide values for the first few parameters positionally, and use keyword names for the rest.

def book_flight(destination, date, seat="window", class_type="economy"):
    print(f"Flight to {destination} on {date}. Seat: {seat}, Class: {class_type}")

# Mixing positional and keyword arguments
# "Paris" and "Oct 15" are positional; class_type is keyword
book_flight("Paris", "Oct 15", class_type="business")

The Golden Rule: Positional arguments must always come before keyword arguments in a function call.

# ERROR: Positional argument follows keyword argument
book_flight(destination="London", "Oct 20")  # SyntaxError!

Key rules to remember

Here is a quick summary of rules for parameters and arguments:

Order in Function Definition:
- Always place required parameters (without default values) before optional parameters (with default values).
- def greet(name, greeting="Hello") is correct.
- def greet(greeting="Hello", name) is incorrect (will raise a SyntaxError).
Order in Function Calls:
- Positional arguments must always come before keyword arguments.
- greet("Alice", greeting="Hi") is correct.
- greet(name="Alice", "Hi") is incorrect (will raise a SyntaxError).
No Double Assignment:
- You cannot pass multiple values for the same parameter in a single call.
- greet("Alice", name="Bob") is incorrect (will raise a TypeError).
Beware of Mutable Defaults:
- Never use mutable types (like lists [] or dictionaries {}) as default parameters. Use None instead.

Common mistakes

Wrong number of arguments

def greet(name, age):
    print(f"Hi {name}, you're {age}")

# Wrong - too few arguments
greet("Alice")  # TypeError!

# Wrong - too many arguments
greet("Alice", 25, "NYC")  # TypeError!

# Right
greet("Alice", 25)

Default values with mutable objects

# Wrong - don't use lists as defaults
def add_item(item, list=[]):
    list.append(item)
    return list

# Right - use None and create new list
def add_item(item, list=None):
    if list is None:
        list = []
    list.append(item)
    return list

What’s next?

Functions become truly powerful when they can return values. Let’s learn how!

Return values

Get results from functions

Functions

Classes

Error handling

Modules & Packages

Extending Python

What are parameters?

Basic parameters

Positional arguments

Multiple parameters

Default values

Keyword arguments

Mixing positional and keyword arguments

Key rules to remember

Common mistakes

What’s next?

Return values

​What are parameters?

​Basic parameters

​Positional arguments

​Multiple parameters

​Default values

​Keyword arguments

​Mixing positional and keyword arguments

​Key rules to remember

​Common mistakes

​What’s next?

Return values

What are parameters?

Basic parameters

Positional arguments

Multiple parameters

Default values

Keyword arguments

Mixing positional and keyword arguments

Key rules to remember

Common mistakes

What’s next?