Python中的函数提供了有组织的，可重用的代码来执行一组操作。函数简化了编码过程，防止冗余逻辑，并使代码更容易遵循。

定义和调用简单函数

使用def语句来定义Python中的函数最常见的方式。这种说法是所谓的单条复合语句的语法如下：

def function_name(parameters):
    statement(s)

function_name 被称为标识符的功能。由于函数定义是一个可执行语句其执行绑定功能名称可以在以后使用的标识符被称为函数对象。

parameters 是一个可选的标识符列表，绑定到调用函数时作为参数提供的值。函数可以具有任意数量的参数，这些参数由逗号分隔。

statement(s)-也被称为函数体 -是每个函数被调用时执行的语句的一个非空序列。这意味着一个函数体不能为空。

这里有一个简单的函数定义，目的是打印的一个例子Hello每次被称为时间：

def greet():
    print("Hello")

现在，让我们把定义的greet()函数：

greet()
# Out: Hello

这是一个函数定义的另一个例子，它接受一个参数，并在每次调用函数时显示传入的值：

def greet_two(greeting):
    print(greeting)

在此之后，greet_two()功能必须与参数调用：

greet_two("Howdy")
# Out: Howdy

也可以给该函数参数一个默认值：

def greet_two(greeting="Howdy"):
    print(greeting)

现在可以调用该函数而不给出值：

greet_two()
# Out: Howdy

您会注意到，与许多其他语言不同，您不需要显式声明函数的返回类型。Python函数可以通过返回任何类型的值return关键字。一个函数可以返回任意数量的不同类型！

def many_types(x):
    if x < 0:
        return "Hello!"
    else:
        return 0

print many_types(1)
print many_types(-1)

# Output:
0
Hello!

只要调用者正确地处理它，这是完全有效的Python代码。

到达执行结束没有return语句的函数总是返回None：

def do_nothing():
    pass

print(do_nothing())
# Out: None

如前所述，函数定义必须有一个函数体，一个非空的语句序列。因此，pass语句作为函数体，这是一个空操作-当执行它，什么都不会发生。当语句需要语句时，它作为占位符是有用的，但是不需要执行代码。

用任意数量的参数定义函数

位置参数的任意数量：

定义一个能够获取任意数量的参数的函数可以通过在参数前面加上一个参数来完成 *

def func(*args):
    # args will be a tuple containing all values that are passed in
    for i in args:
        print(i)

func(1, 2, 3)  # Calling it with 3 arguments
# Out: 1
#      2
#      3

list_of_arg_values = [1, 2, 3]
func(*list_of_arg_values)  # Calling it with list of values, * expands the list
# Out: 1
#      2
#      3 

func()  # Calling it without arguments
# No Output 

你不能提供一个默认的args，例如func(*args=[1, 2, 3])将引发一个语法错误（甚至不会编译）。

你不能调用函数时，例如通过名称提供这些func(*args=[1, 2, 3])会提高一个TypeError。

但是，如果你已经有了你的论点在数组（或其他Iterable），你可以调用你的功能如下：func(*my_stuff)。

这些参数（*args）可以通过索引访问，例如args[0]将返回第一个参数

关键字参数的任意数目

您可以通过定义在定义的参数取一个名字参数任意数量2 *在它的面前：

def func(**kwargs):
    # kwargs will be a dictionary containing the names as keys and the values as values
    for name, value in kwargs.items():
        print(name, value)

func(value1=1, value2=2, value3=3)   # Calling it with 3 arguments
# Out: value2 2
#      value1 1
#      value3 3

func()                               # Calling it without arguments
# No Out put

my_dict = {‘foo‘: 1, ‘bar‘: 2}
func(**my_dict)                      # Calling it with a dictionary
# Out: foo 1
#      bar 2

你不能提供这些没有名字，例如func(1, 2, 3)将引发一个TypeError。

kwargs是一个普通的本地python字典。例如，args[‘value1‘]将给予参数的值value1。请务必先确认是否有这样的说法或KeyError将提高。

警告

您可以将这些与其他可选和必需的参数混合，但在定义内的顺序很重要。

该位置/关键字参数放在第一位。（必需参数）。
然后是任意 *arg参数。（可选的）。
那么只有关键字的论据来下一个。（需要）。
最后，任意关键字 **kwargs来了。（可选的）。

#       |-positional-|-optional-|---keyword-only--|-optional-|
def func(arg1, arg2=10 , *args, kwarg1, kwarg2=2, **kwargs):
     pass

• arg1必须给予，否则一个TypeError上升。它可以给出作为位置（func(10)）或关键字参数（func(arg1=10)）。
• kwarg1也必须给予，但它只能作为关键字参数来提供：func(kwarg1=10)。
• arg2和kwarg2是可选的。如果该值要更改的相同的规则arg1（无论是位置还是关键字）和kwarg1（仅限于关键字）适用。
• *args捕获额外的位置参数。但是注意，arg1并arg2必须作为位置参数传递参数提供*args：func(1, 1, 1, 1)。
• **kwargs捕捉所有其他关键字参数。在这种情况下，即没有任何参数arg1，arg2，kwarg1或kwarg2。例如：func(kwarg3=10)。
• 在Python 3，你可以使用*单独指示所有后续参数必须指定为关键字。比如math.isclose在Python 3.5的功能和更高的使用规定def math.isclose (a, b, *, rel_tol=1e-09, abs_tol=0.0)，这意味着前两个参数可以在位置上提供，但可选的第三个和第四个参数只能作为关键字参数提供。

Python 2.x不支持仅关键字的参数。这种行为可以被效仿kwargs：

def func(arg1, arg2=10, **kwargs):
    try:
        kwarg1 = kwargs.pop("kwarg1")
    except KeyError:
        raise TypeError("missing required keyword-only argument: ‘kwarg1‘")

    kwarg2 = kwargs.pop("kwarg2", 2)
    # function body ...

有关命名的注意事项

命名可选位置参数的约定args和可选关键字参数kwargs只是你一个约定可以使用任何你喜欢的名字，但它是遵循惯例有用的，让其他人知道你在做什么，甚至自己以后所以请不要。

注意唯一性

任何功能可以与被定义没有或者一个 *args和无或一种 **kwargs，但不与每一个以上。还*args 必须是最后一个位置参数，并**kwargs必须是最后一个参数。试图使用的任一个以上的将导致一个语法错误异常。

有关可选参数的嵌套函数的注意事项

这是可以嵌套这样的功能和一般的惯例是删除代码已处理的项目，但如果你是传承的参数需要传递一个可选的位置ARGS *前缀和可选关键字ARGS一个**前缀，否则ARGS可以作为列表或元组传递，并将kwargs作为单个字典传递。例如：

def fn(**kwargs):
    print (kwargs)
    f1(**kwargs)

def f1(**kwargs):
    print(len(kwargs))

fn(a=1, b=2)
# Out:
# {‘a‘: 1, ‘b‘: 2}
# 2