python函數總結

8.6. Function definitions¶

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

一個函數定義,定義一個用戶自定義的函數對象

funcdef                 ::=  [decorators] "def" funcname "(" [parameter_list] ")" ["->" expression] ":" suite
decorators              ::=  decorator+
decorator               ::=  "@" dotted_name ["(" [argument_list [","]] ")"] NEWLINE
dotted_name             ::=  identifier ("." identifier)*
parameter_list          ::=  defparameter ("," defparameter)* ["," [parameter_list_starargs]]
                             | parameter_list_starargs
parameter_list_starargs ::=  "*" [parameter] ("," defparameter)* ["," ["**" parameter [","]]]
                             | "**" parameter [","]
parameter               ::=  identifier [":" expression]
defparameter            ::=  parameter ["=" expression]
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). 

函數的執行綁定當前命名空間中的函數名和一個函數對象(一個圍繞該函數可執行代碼的包裝器)

----------------------------------上述邏輯行的解釋--------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Logical lines邏輯行

The end of a logical line is represented by the token NEWLINE. 

邏輯行的結束由NEWlINE標記表示

Statements cannot cross logical line boundaries except where NEWLINE is allowed by the syntax (e.g., between statements in compound statements). 

語句不能跨越邏輯行邊界,除非NEWLINE被語法允許(e.g:複合語句中的語句之間)

A logical line is constructed from one or more physical lines by following the explicit or implicit line joining rules.

一個邏輯行,在顯示或隱式的規則約束下,由一個或多個物理行構成

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

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. [3]

函數定義不會執行函數體,只有當函數被調用時纔會執行

A function definition may be wrapped by one or more decorator expressions. 

一個函數定義可能被一個或多個裝飾器表達式包裹

Decorator expressions are evaluated when the function is defined, in the scope that contains the function definition. 

當函數被定義,裝飾器表達式在含有函數定義的範圍內被評估

The result must be a callable, which is invoked with the function object as the only argument. 

評估的結果必須是可以調用的,

The returned value is bound to the function name instead of the function object. 

Multiple decorators are applied in nested fashion. For example, the following code

@f1(arg)
@f2
def func(): pass

is roughly equivalent to

def func(): pass
func = f1(arg)(f2(func))

except that the original function is not temporarily bound to the name func.

When one or more 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 up until the “*” must also have a default value — this is a syntactic restriction that is not expressed by the grammar.

Default parameter values are evaluated from left to right when the function definition is executed. This means that the expression is evaluated once, when the function is defined, and that the 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 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 ordered mapping receiving any excess keyword arguments, defaulting to a new empty mapping of the same type. Parameters after “*” or “*identifier” are keyword-only parameters and may only be passed used keyword arguments.

Parameters may have annotations of the form “: expression” following the parameter name. Any parameter may have an annotation even those of the form *identifier or **identifier. Functions may have “return” annotation of the form “-> expression” after the parameter list. These annotations can be any valid Python expression and are evaluated when the function definition is executed. Annotations may be evaluated in a different order than they appear in the source code. The presence of annotations does not change the semantics of a function. The annotation values are available as values of a dictionary keyed by the parameters’ names in the __annotations__ attribute of the function object.

It is also possible to create anonymous functions (functions not bound to a name), for immediate use in expressions. This uses lambda expressions, described in section Lambdas. Note that the lambda expression 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 expression. The “def” form is actually more powerful since it allows the execution of multiple statements and annotations.

Programmer’s note: Functions are first-class objects. A “def” statement executed inside a function definition defines a local function that can be returned or passed around. Free variables used in the nested function can access the local variables of the function containing the def. See section Naming and binding for details.

有待更新........沒事....看API練習下英語翻譯