Hello, Space Explorer! Today, our focus is on calling functions in Python. By the end of the lesson, you'll understand how to call functions, utilize transitive function calling, employ named parameters, and return multiple values from a function.

Much like how using a remote control can switch on your television, calling a function tells Python to execute a block of code. It's akin to giving directions to your spaceship's computer. Let's use a common scenario in space journeys: greeting a new crew member. Consider this example:

Python
Copy to clipboard
1def greet(name):
2    print("Hello " + name + ", welcome aboard the spacecraft!")
3
4greet("Astro Kid")  # Prints: "Hello Astro Kid, welcome aboard the spacecraft!"

In this instance, we instructed our spaceship's computer to greet the new team member, Astro Kid! Just as in saying "Hello" to a new crew member, calling a function executes the predefined code within that function.

In spaceship jargon, think of transitive function calling as delegating tasks on board your spacecraft. So, in fact, transitive function calling is just when you call one or multiple functions inside another function, delegating execution. Suppose we want to increase the heat in our spaceship's engine — instead of doing it ourselves, we assign the task to another function:

Python
Copy to clipboard
1def power_up_engine(level):
2    print("Powering up the engine to level ", level)
3
4def engine_start():
5    print("The engine has started!")
6
7def launch_spacecraft():
8    print("Prepare for launch. ", end='')
9    power_up_engine(3)
10    engine_start()
11
12# Time to hit the space road!
13launch_spacecraft()
14"""
15Prints:
16
17Prepare for launch. Powering up the engine to level 3
18The engine has started!
19"""

Here, as we prepare to launch the spacecraft, we call another function — power_up_engine(3) — to power up our spacecraft's engine. Afterward, we call another function - engine_start() to delegate the processing of engine post-startup operations. You can see how one function can call another to perform a task.

Parameters are called named when you provide their name in the function call, explicitly mapping the provided value in the call to the function parameter. Let's see it in action:

Python
Copy to clipboard
1# Function definition
2def greet_crew_member(name, message):
3    print("Hello, " + name + ". " + message)
4
5# Greet a new member, calling function **without** named parameters
6greet_crew_member("Astro Kid", "Welcome aboard!")
7"""
8Prints: "Hello, Astro Kid. Welcome aboard!
9"""
10
11# Greet another new member using named parameters
12greet_crew_member(name="Star Ranger", message="You're just in time for the cosmic pizza party!")
13"""
14Prints: "Hello, Star Ranger. You're just in time for the cosmic pizza party!
15"""
16
17# Greet another new member using shuffled named parameters
18greet_crew_member(message="You're just in time for the cosmic pizza party!", name="Star Explorer")
19"""
20Prints: "Hello, Star Explorer. You're just in time for the cosmic pizza party!
21"""

Note how we used named name and message parameters in the second and third greet_crew_member calls - this way, we make sure parameters won't be messed up, and we clearly state what is what. Named parameters can be provided in any order. This is especially helpful when the function takes many arguments of the same data type; this way, you won't accidentally mess up the parameters' order when calling the function, and the function call will also be easier to read.

In Python, your spacecraft's computer, i.e., a function, can perform multiple checks at once and return several results. It's similar to checking the fuel status and oxygen levels before launch. Python's magic (using tuples) makes this possible. Let's see our spaceship's computer in action, returning multiple results:

Python
Copy to clipboard
1def spaceship_status():
2    # Returning multiple values actually returns a tuple of values under the hood
3    return "Fuel: Full", "Oxygen: Normal"
4
5# Dereferencing the tuple, getting the first two elements from it
6fuel_status, oxygen_status = spaceship_status()
7
8print(fuel_status) # Prints: "Fuel: Full"
9print(oxygen_status) # Prints: "Oxygen: Normal"

In this example, the spaceship_status() function runs two checks simultaneously — fuel check and oxygen check — and returns both results.

Great job, future space commander! You've mastered calling functions in Python and transitive function calling and seen the power of named parameters. Plus, you've learned to return multiple values from a function all at once.

Next, it's time for hands-on practice. Prepare to apply what you've learned today to some practice scenarios. Each one is a mission that will test your understanding of Python functions and make you a more proficient space commander! Keep exploring and keep coding!