Function definitions

A function definition defines a user-defined function object (see section ):      

funcdef:        "def" funcname "(" [parameter_list] ")" ":" suite
parameter_list: (defparameter ",")* ("*" identifier | defparameter [","])
defparameter:   parameter ["=" condition]
sublist:        parameter ("," parameter)* [","]
parameter:      identifier | "(" sublist ")"
funcname:       identifier

A function definition is an executable statement. Its execution binds the function name in the current local name space to a function object (a wrapper around the executable code for the function). This function object contains a reference to the current global name space as the global name space to be used when the function is called.      

The function definition does not execute the function body; this gets executed only when the function is called.

When one or more top-level parameters have the form parameter = condition, the function is said to have ``default parameter values''. Default parameter values are evaluated when the function definition is executed. For a parameter with a default value, the correponding argument may be omitted from a call, in which case the parameter's default value is substituted. If a parameter has a default value, all following parameters must also have a default value --- this is a syntactic restriction that is not expressed by the grammar.    

Function call semantics are described in section . When a user-defined function is called, first missing arguments for which a default value exists are supplied; then the arguments (a.k.a. actual parameters) are bound to the (formal) parameters, as follows:                 

• If there are no formal parameters, there must be no arguments.

• If the formal parameter list does not end in a star followed by an identifier, there must be exactly as many arguments as there are parameters in the formal parameter list (at the top level); the arguments are assigned to the formal parameters one by one. Note that the presence or absence of a trailing comma at the top level in either the formal or the actual parameter list makes no difference. The assignment to a formal parameter is performed as if the parameter occurs on the left hand side of an assignment statement whose right hand side's value is that of the argument.

• If the formal parameter list ends in a star followed by an identifier, preceded by zero or more comma-followed parameters, there must be at least as many arguments as there are parameters preceding the star. Call this number N. The first N arguments are assigned to the corresponding formal parameters in the way descibed above. A tuple containing the remaining arguments, if any, is then assigned to the identifier following the star. This variable will always be a tuple: if there are no extra arguments, its value is (), if there is just one extra argument, it is a singleton tuple.   

Note that the `variable length parameter list' feature only works at the top level of the parameter list; individual parameters use a model corresponding more closely to that of ordinary assignment. While the latter model is generally preferable, because of the greater type safety it offers (wrong-sized tuples aren't silently mistreated), variable length parameter lists are a sufficiently accepted practice in most programming languages that a compromise has been worked out. (And anyway, assignment has no equivalent for empty argument lists.)

It is also possible to create anonymous functions (functions not bound to a name), for immediate use in expressions. This uses lambda forms, described in section .