GNU Info

(python2.1-ref.info)Function definitions

---

Next: Class definitions Prev: try statement Up: Compound statements

---

Enter node , (file) or (file)node

Function definitions
====================

A function definition defines a user-defined function object (see
section Note: standard type hierarchy):

     funcdef:        "def" funcname "(" [parameter_list] ")" ":" suite
     parameter_list: (defparameter ",")* ("*" identifier [, "**" identifier]
                                         | "**" identifier
                                         | defparameter [","])
     defparameter:   parameter ["=" expression]
     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 namespace to a function object
(a wrapper around the executable code for the function).  This function
object contains a reference to the current global namespace as the
global namespace 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 `='
EXPRESSION, the function is said to have "default parameter values."
For a parameter with a default value, the corresponding 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.

*Default parameter values are evaluated when the function definition is
executed.*  This means that the expression is evaluated once, when the
function is defined, and that that same "pre-computed" value is used
for each call.  This is especially important to understand when a
default parameter is a mutable object, such as a list or a dictionary:
if the function modifies the object (e.g. by appending an item to a
list), the default value is in effect modified.  This is generally not
what was intended.  A way around this is to use `None' as the default,
and explicitly test for it in the body of the function, e.g.:

     def whats_on_the_telly(penguin=None):
         if penguin is None:
             penguin = []
         penguin.append("property of the zoo")
         return penguin

Function call semantics are described in more detail in section Note:
Calls.  A function call always assigns values to all parameters
mentioned in the parameter list, either from position arguments, from
keyword arguments, or from default values.  If the form "`*identifier'"
is present, it is initialized to a tuple receiving any excess
positional parameters, defaulting to the empty tuple.  If the form
"`**identifier'" is present, it is initialized to a new dictionary
receiving any excess keyword arguments, defaulting to a new empty
dictionary.

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 Note: Boolean operations.  Note that the lambda
form is merely a shorthand for a simplified function definition; a
function defined in a "`def'" statement can be passed around or
assigned to another name just like a function defined by a lambda form.
The "`def'" form is actually more powerful since it allows the
execution of multiple statements.

*Programmer's note:* a "`def'" form executed inside a function
definition defines a local function that can be returned or passed
around.  The semantics of name resolution in the nested function will
change in Python 2.2.  See the appendix for a description of the new
semantics.