Function Parameters

Parameters describe a function's input contract

A function definition can name inputs in its parenthesized parameter list. Those names are parameters: placeholders the function can use while it runs. A function call supplies arguments, the concrete objects to bind to those placeholders. For example, in announce("Mina"), name is a parameter if it appears in the definition, and "Mina" is an argument in this particular call. The distinction is small but useful. A parameter describes what a function accepts; an argument describes what a caller provided. This lesson focuses on that input contract, not on how to define an entire function, what it returns, or how names behave outside the call.

A function's parameter list is therefore a small interface. A caller needs to know which inputs are required, which are optional, and which names are meaningful. Good parameter names communicate the role of an input—width is easier to interpret than x when a function calculates an area. Names do not enforce correctness by themselves, but they make a call easier for another person to read and reduce the chance that an ordered value is misunderstood.

For ordinary parameters, Python can bind arguments by position. In greet("Mina", "Welcome"), the first supplied argument goes to the first parameter and the second goes to the second. This is compact, but it depends on remembering the order. If the call names a parameter, Python instead matches the argument by that name: greet(greeting="Welcome", name="Mina"). Keyword calls can make a line more self-explanatory and can state the arguments in a different order. A call may combine styles, but positional arguments must come before keyword arguments. greet("Mina", greeting="Welcome") is valid; placing a positional argument after a keyword argument is not.

Defaults make an input optional, with a caveat

A default value appears after = in a parameter list. In def greet(name, greeting="Hello"), a call that supplies only name uses "Hello" for greeting; a caller can replace it with its own argument. Defaults are appropriate when one choice is conventional but another should remain available. They are not a separate type of parameter, and they do not mean that every input is optional: name remains required in this example.

Python evaluates a default expression once, when the function definition is executed, rather than rebuilding it for every call. That behavior matters for mutable objects such as lists and dictionaries. A default items=[] can retain additions made during an earlier call, which often surprises beginners who expected a new empty list. When a function needs a fresh list if none was supplied, a common pattern is items=None, followed by an initialization inside the function when items is None. The point is not that lists are forbidden as inputs; it is that a shared default object should be intentional.

Collecting a flexible number of arguments

Sometimes a function genuinely accepts an open-ended set of inputs. A parameter written as *args collects extra positional arguments into a tuple. The spelling args is a convention, not a magic word; the leading * creates the collecting behavior. For a call such as label("notebook", "blue", "lined"), a first ordinary parameter can receive "notebook", and the remaining positional values can be collected as ('blue', 'lined'). A tuple preserves the collected sequence and is useful when the function needs to examine any number of similarly ordered values.

Likewise, **kwargs collects extra keyword arguments into a dictionary whose keys are the supplied keyword names. Again, kwargs is conventional; **settings has the same behavior. In label("notebook", urgent=True), a **settings parameter can receive {'urgent': True} after ordinary parameters have been matched. These tools are flexible, but they can make an interface harder to discover if used merely to avoid choosing clear parameters. Prefer explicit named parameters for the important, expected inputs. Use *args or **kwargs when an arbitrary collection is truly part of the function's contract, and document what those collected values mean.