A call is a value once it returns, so a call can sit inside another call or inside an expression. Functions compose the way values do.
About 1 min of reading
Before this new lesson, one small question about the lesson you just finished. Recall it, do not look it up.
Compose calls together.
Define two one-step functions.
Before you run it, say out loud what it will print. Then open the answer.
Nest one inside the other.
Before you run it, say out loud what it will print. Then open the answer.
Add two calls in one expression.
Before you run it, say out loud what it will print. Then open the answer.
Store one result and reuse it.
Before you run it, say out loud what it will print. Then open the answer.
Before you write anything, put these lines back in the right order. Click a line to move it up one step. This support step is easier than writing code from scratch, and it is here to make the last example stick.
Because a call is a value, you can feed one function into another. Small functions that each do one step join into bigger ones.
Deeply nested calls run fine but read badly. Naming each step in its own line costs nothing and helps the next reader.
def double(n):
return n * 2
def add_one(n):
return n + 1
print(add_one(double(3)))The inner call runs first, giving 6, then add_one turns it into 7. Reading inside out is how nested calls work.
def half(n):
return n / 2
print(half(10) + half(4))Each call becomes its value, so the line is really 5.0 + 2.0. Calls are just values in disguise.
def square(n):
return n * n
base = square(4)
print(base + base)Storing the result once and using it twice is clearer than calling twice. Same value, one call.
def a(n):
return n + 1
print(a(a(a(1))))This works but is hard to read. Breaking it into named steps is the fix, and it is what real code does.
Each one is defined here on this site. Open the entry for the full definition and the other words it points at.