Variable-length arguments (*args) in Python - Step-by-Step Execution

Concept Flow - Variable-length arguments (*args)

Function called with arguments

↓

*args collects all extra positional arguments

↓

Inside function, args is a tuple of those arguments

↓

Function uses args as needed

↓

Function returns or ends

When a function is called with extra positional arguments, *args collects them into a tuple inside the function for flexible use.

Execution Sample

Python

def greet(*args):
    for name in args:
        print(f"Hello, {name}!")

greet('Alice', 'Bob', 'Charlie')

This function greets any number of people by printing a hello message for each name passed.

Execution Table

Step	Action	args value	Loop variable 'name'	Output
1	Function greet called with ('Alice', 'Bob', 'Charlie')	('Alice', 'Bob', 'Charlie')
2	Start loop over args	('Alice', 'Bob', 'Charlie')
3	First iteration: name = 'Alice'	('Alice', 'Bob', 'Charlie')	Alice	Hello, Alice!
4	Second iteration: name = 'Bob'	('Alice', 'Bob', 'Charlie')	Bob	Hello, Bob!
5	Third iteration: name = 'Charlie'	('Alice', 'Bob', 'Charlie')	Charlie	Hello, Charlie!
6	Loop ends, function ends	('Alice', 'Bob', 'Charlie')

💡 All names in args processed, loop ends, function returns None

Variable Tracker

Variable	Start	After 1	After 2	After 3	Final
args	()	('Alice', 'Bob', 'Charlie')	('Alice', 'Bob', 'Charlie')	('Alice', 'Bob', 'Charlie')	('Alice', 'Bob', 'Charlie')
name		Alice	Bob	Charlie

Key Moments - 3 Insights

Why is args a tuple and not a list?

In the execution_table rows 1-5, args is shown as a tuple because *args always collects extra positional arguments into a tuple, which is immutable and fixed in size.

What happens if no arguments are passed to greet()?

If no arguments are passed, args is an empty tuple, so the loop in rows 2-5 does not run, and the function ends immediately as shown in exit_note.

Can we access args like a normal variable inside the function?

Yes, as shown in rows 3-5, args behaves like a tuple variable holding all extra arguments, so we can loop over it or index it.

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what is the value of 'name'?

A Charlie

B Bob

C Alice

D args tuple

💡 Hint

Check the 'Loop variable name' column at step 3 in execution_table

At which step does the function finish processing all names?

A Step 6

B Step 4

C Step 5

D Step 2

💡 Hint

Look at the exit_note and the last step in execution_table

If greet() is called with no arguments, what will args be?

A An empty list []

B An empty tuple ()

C None

D A string ''

💡 Hint

Refer to key_moments explanation about args when no arguments are passed

Concept Snapshot

def function_name(*args):
    # args is a tuple of all extra positional arguments
    for item in args:
        # use item

*args lets you pass any number of positional arguments to a function.
Inside, args is a tuple holding them all.

Full Transcript

This visual trace shows how Python functions use *args to accept any number of extra positional arguments. When the function greet is called with three names, these names are collected into the tuple args. The function then loops over args, assigning each name to the variable 'name' in turn, and prints a greeting. The variable tracker shows args stays the same tuple throughout, while 'name' changes each loop. Key moments clarify that args is always a tuple, even if empty, and can be used like any tuple inside the function. The quiz tests understanding of variable values at each step and what happens with no arguments.