# 26. Parameters And Arguments

By Bernd Klein. Last modified: 10 Nov 2023.

## Introduction

At first the definition and usage of Python parameters and arguments seems to be simple, but there exists a multitude of intricate details that can be perplexing. So that you don't get lost in the "parameter wood", we provide this introduction.

Let's start with a simple question: If you look at the following code, is everything clear to you? If so, you don't have to continue reading this chapter of our Python tutorial. If not, you should definitely continue reading.

def all_together_now(a, /, b, c=11, d=12, *args, kw_only1=42, kw_only2=84, **kwargs):
return f'{a=}, {b=}, {c=}, {d=}, {args=}, {kw_only1=}, {kw_only2=}, {kwargs=}'



Live Python training

Enjoying this page? We offer live Python training courses covering the content of this site.

Enrol here

## Required Parameters

Let's look first at a function with one parameter which can or better has be called with a positional or keyword argument:

def positional_example(x):
return x + 42


We can call this function with a numerical value like this:

positional_example(1)


### OUTPUT:

43


We can also call it with a keyword argument, i.e. by assigning the object explicitly to the parameter name:

positional_example(x=1)


### OUTPUT:

43


## Positional Only Parameters

Positional-only parameters have no externally-usable name. This implies that you cannot assign an object to the parameter's name when making a function call. When a function accepting positional-only parameters is called, positional arguments are mapped to these parameters based solely on their order.

Positional-only Parameters are a way to prevent using arguments as keyword arguments. We demonstrate this in the following example. All the parameters (in our example only the parameter x) before the '/' are defined as positional only arguments. The parameters following the '/' can be used both positionally and as keyword arguments:

def positional_only_example(x, /, y, z):
return x + 42

positional_only_example(1, 4, 6)


### OUTPUT:

43


As we mentioned before, we can use y and z keyword arguments:

positional_only_example(1, z=6, y=4)


### OUTPUT:

43


If you try to use x as a keyword argument

positional_only_example(x=1, z=6, y=4)


m you will get the exception

TypeError: positional_only_example() got some positional-only arguments passed as keyword arguments: 'x'


Live Python training

Enjoying this page? We offer live Python training courses covering the content of this site.

Upcoming online Courses

Enrol here

## Optional Positional Only Parameters

This is the same as before, but the function can also be called without giving an argument:

def optional_positional_only_example(x=42, /):
return x + 42

print(optional_positional_only_example(1))
# or without an argument:
print(optional_positional_only_example())


### OUTPUT:

43
84


## Keyword-only Parameter

So, we have seen parameters which can only be used in a call as positional but not as keyword parameters. What about parameters that must be utilized as keyword arguments and cannot be employed as positional arguments?

def keyword_only_parameters(*, key):
return key

keyword_only_parameters(key=99)


### OUTPUT:

99


But you cannot call keyword_only_parameters' in a positional way. If you call it with keyword_only_parameters(42) you will get the following exception: TypeError: keyword_only_parameters() takes 0 positional arguments but 1 was given

Live Python training

Enjoying this page? We offer live Python training courses covering the content of this site.

Enrol here

## Optional Keyword-only Parameter

Like before, but if the keyword is not given in the function call the default value will be uses:

def keyword_only_parameters(*, key=42):
return key

print(keyword_only_parameters(key=99))
print(keyword_only_parameters())


### OUTPUT:

99
42


## Keyword-only Parameters after *args

It's easy to imagine a function that accepts a variable number of arguments along with one or more 'options' provided as keyword arguments. There is a way to add these options after the arbitrary list of optional positional parameters.

def keyword_only_args(x, *args, a, b):
return x, args, a, b

print(keyword_only_args("pos", "arg1", "arg2", "arg3", a=3, b=4))


### OUTPUT:

('pos', ('arg1', 'arg2', 'arg3'), 3, 4)


Live Python training

Enjoying this page? We offer live Python training courses covering the content of this site.

Enrol here

## All Together Now

def all_together_now(a, /, b, c=11, d=12, *args, kw_only1=42, kw_only2=84, **kwargs):
return f'{a=}, {b=}, {c=}, {d=}, {args=}, {kw_only1=}, {kw_only2=}, {kwargs=}'

all_together_now(2, 4)


### OUTPUT:

'a=2, b=4, c=11, d=12, args=(), kw_only1=42, kw_only2=84, kwargs={}'

all_together_now(2, name='Guido', age=42, kw_only1=99, b=1001)


### OUTPUT:

"a=2, b=1001, c=11, d=12, args=(), kw_only1=99, kw_only2=84, kwargs={'name': 'Guido', 'age': 42}"


## Keyword Arguments vs. Optional Parameters

"Keyword argument" is like the term "argument" implies related to a function call and not in the function definition. Quite often people confuse optional parameters in a function definition with keyword parameters.

def foobar1(optional_parameter1=42, optional_parameter2=22):
return optional_parameter1 + optional_parameter2

def foobar2(positional_parameter1, positional_parameter2):
return positional_parameter1 + positional_parameter2


Both functions can be called with positional or keyword parameters, as you can see in the following Python function calls:

print(foobar1(1, 99))
print(foobar1(1, optional_parameter2=99))
print(foobar1(optional_parameter1=1, optional_parameter2=99))


### OUTPUT:

100
100
100


Now, the same way of calling with foobar2:

print(foobar2(1, 99))
print(foobar2(1, positional_parameter2=99))
print(foobar2(positional_parameter1=1, positional_parameter2=99))


### OUTPUT:

100
100
100


The distinction between these two functions is rooted in the flexibility of their argument handling. foobar1 can be invoked with no arguments, a single argument, or both arguments. This flexibility arises from the default values provided in the function definition, which can be utilized if a parameter is absent. In contrast, when using foobar2, it is mandatory to provide values for both arguments every time it's called, without any option to rely on defaults.

print(foobar1())
print(foobar1(1))
print(foobar1(optional_parameter2=6))
print(foobar1(1, 99))


### OUTPUT:

64
23
48
100
`

Live Python training

Enjoying this page? We offer live Python training courses covering the content of this site.

Upcoming online Courses

Enrol here