@freemo Is there a reason why toots using markdown do not appear as raw markdown for those on servers who don’t support markdown and instead appear as plain text with all the markdown ignored?

It makes it tricky to decide whether to use markdown, or to use plain text and put the markdown symbols as plain text so everyone gets the same version

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

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

– 2 –

greet_person("Ishaan", number=3)

In the second call, the first argument, "Ishaan", is a positional argument as in the first example

However, the second argument is a named argument or a keyword argument

The argument is matched to the parameter by naming it. You’re using the parameter name with an equals before the argument in the function call

Therefore, in this second example, you have one positional argument and one keyword (or named) argument

/3

Let’s look at all five function calls in this example:

– 1 –

greet_person("Elizabeth", 5)

This is the most commonly used function call. The arguments are positional arguments

This means that the values "Elizabeth" and 5 are matched to the parameter names person and number depending on the their position in the function call

The first argument is assigned to the first parameter; the second argument to the second parameter…

/2