Stephen Gruppetta @s_gruppetta@qoto.org

However, if the function call was just:

`do_something_clever(5, 8)`

then Monty doesn't know what to do with the data he's holding. So he'll throw it away in the garbage bin so he can carry on with his work.

What if you write:

`print(do_something_clever(5, 8))`

Monty will go to the `do_something_clever` Function Room, do what he needs to do, and return to the Main Room holding the integer `13`…

/5

However, he won't go empty handed. He'll take some data with him—the arguments you use when you call the function.

In the example in the previous tweet, Monty will take the integers `5` and `8` when he goes from the Main Room to the Function Room.

As Monty enters the Function Room, he'll find two empty boxes at the entrance labelled `first` and `second` — these are the parameters from the function definition.

He'll place the integer `5` inside the box labelled `first` and the integer `8` in the box labelled `second`. He will then place these boxes on the Function Room shelves.

Monty will then do whatever he needs to do in the Function Room.

When he's done, he'll return to the Main Room.

But once again, he won't return empty-handed. He'll take the contents of the box labelled `output` with him since this is what you wrote in the `return` statement.

Note that Monty does \_not\_ take the whole box labelled `output` with him but only its contents. In the example above, this is the integer `13`

What will Monty do with this integer as he returns to the Main Room and shuts the Function Room door behind him?

If the function was called like this:

`result = do_something_clever(5, 8)`

then he'll bring another empty cardboard box, place the integer `13` inside it, and label the box `result`. He places this box on the shelves in the Main Room.

/4

Anyway, let's get to defining a function:

`def do_something_clever(first, second):`
`"""do some stuff"""`
`output = first + second`
`return output`

A function is a mini-program within a program.

So, in my mental image of how computer programming works, a function is another room…

When you define a function, you're creating a new Function Room that's adjacent to the Main Room.

There's a door connecting the Main Room to the Function Room.

The label on the door says `do_something_clever`, the name of the function.

So, when you use the name `do_something_clever`, Monty will look around the Main Room and see the name as a label on a door leading to another room.

If you've called the function by adding parentheses, `do_something_clever(5, 8)`, Monty will open the Function Room door and go through it.

/3

At the start of the program, if you use a word that's in the red booklet, Monty will know what to do.

keywords like `while`, built-in functions like `print`, these are the things in this booklet.

When you create a variable, such as:

`day = "Monday"`

Monty gets an empty cardboard box, puts the string `"Monday"` inside the box and puts a label on the outside of the box which says `day`

Monty puts this box on a shelf in the Main Room

From now on, if you write `day` in your program, when Monty looks around the room he'll find a box labelled `day` and he'll get its contents—the string `"Monday"`

/2

@kaievans I don’t think it will take long, especially since one server at least has it already!

@kaievans here’s screeenshot of one of my toots as seen by others on my server, but it’s a bit pointless if no one else sees the markdown

In case you want to go back to Day 1 of this series on Intermediate Python functions, here's the link: https://qoto.org/@s_gruppetta/109301873510386964

– 5 –

`greet_person(number=10, person="Stephen”)`

Since you're using these arguments as named arguments, you no longer need to stick to the order in which they're defined in the function signature

Python no longer uses position to assign the arguments to the parameter names. This is particularly useful in functions which can take many parameters

In this example, the programmer calling the `greet_person()` function has a choice on whether to use positional arguments, named arguments, or a mixture of both (as long as the positional arguments come before the named ones)

There are ways in which the programmer who defines the function can force the user to use positional-only or keyword-only arguments

But we'll leave that discussion for another day…

/6

– 4 –

`greet_person(person="Stephen", number=10)`

In this case, you've used both arguments as named or keyword arguments. You're no longer relying on the position of the arguments. What matters now is the keyword you use when calling the function.

This leads us nicely to number 5…

/5

– 3 –

`greet_person(person="Stephen", 10)`

This seems identical to the case in the second example, but we come across one of the rules when using positional and keyword parameters

See the description of the `SyntaxError`. It says `positional argument follows keyword argument`

When using a mixture of positional and keyword arguments, the positional arguments must come first

And this makes perfect sense, since Python is relying on the position of these arguments within the function call to know which parameter name to assign them to

/4