概述

指针函数和函数指针是C语言里两个比较绕的概念。但是不仅面试题爱考，实际应用中也比较广泛。很多人因为搞不清这两个概念，干脆就避而远之，我刚接触C语言的时候对这两个概念也比较模糊，特别是当指针函数、函数指针、函数指针变量、函数指针数组放在一块的时候，能把强迫症的人活活逼疯。
其实如果理解了这些概念的本质，是不需要死记硬背的，理解起来也比较容易。

指针函数

指针函数： 顾名思义，它的本质是一个函数，不过它的返回值是一个指针。其声明的形式如下所示：

ret *func(args, ...);

其中，func是一个函数，args是形参列表，ret *作为一个整体，是 func函数的返回值，是一个指针的形式。
下面举一个具体的实例来做说明：

文件：pointer_func.c

# include <stdio.h>
# include <stdlib.h>

int * func_sum(int n)
{
    if (n < 0)
    {
        printf("error:n must be > 0\n");
        exit(-1);
    }
    static int sum = 0;
    int *p = &sum;
    for (int i = 0; i < n; i++)
    {
        sum += i;
    }
    return p;
}

int main(void)
{
    int num = 0;
    printf("please input one number:");
    scanf("%d", &num);
    int *p = func_sum(num); 
    printf("sum:%d\n", *p);
    return 0;
}

上例就是一个指针函数的例子，其中，int * func_sum(int n)就是一个指针函数， 其功能十分简单，是根据传入的参数n，来计算从0到n的所有自然数的和，其结果通过指针的形式返回给调用方。
以上代码的运行结果如下所示：

如果上述代码使用普通的局部变量来实现，也是可以的，如下所示：

文件：pointer_func2.c

# include <stdio.h>
# include <stdlib.h>

int func_sum2(int n)
{   
    if (n < 0)
    {   
        printf("error:n must be > 0\n");
        exit(-1);
    }
    int sum = 0;
    int i = 0;
    for (i = 0; i < n; i++)
    {   
        sum += i;
    }
    return sum;
}

int main(void)
{
    int num = 0;
    printf("please input one number:");
    scanf("%d", &num);
    int ret = func_sum2(num);
    printf("sum2:%d\n", ret);
    return 0;
}

本案例中，func_sum2函数的功能与指针函数所实现的功能完全一样。

不过在使用指针函数时，需要注意一点，相信细心地读者已经发现了，对比func_sum和func_sum2函数，除了返回值不一样之外，还有一个不同的地方在于，在func_sum中，变量sum使用的是静态局部变量，而func_sum2函数中，变量sum使用的则是普通的变量。
如果我们把指针函数的sum定义为普通的局部变量，会是什么结果呢？不妨来试验一下：

文件：pointer_func3.c

# include <stdio.h>
# include <stdlib.h>

int * func_sum(int n)
{
    if (n < 0)
    {
        printf("error:n must be > 0\n");
        exit(-1);
    }
    int sum = 0;
    int *p = &sum;
    for (int i = 0; i < n; i++)
    {
        sum += i;
    }
    return p;
}

int main(void)
{
    int num = 0;
    printf("please input one number:");
    scanf("%d", &num);
    int *p = func_sum(num); 
    printf("sum:%d\n", *p);
    return 0;
}

执行以上程序，发现仍然能得到正确的结果：

可是如果我们把main函数里面稍微改动一下：

int main(void)
{
    int num = 0;
    printf("please input one number:");
    scanf("%d", &num);
    int *p = func_sum(num);
    printf("wait for a while...\n");    //此处加一句打印
    printf("sum:%d\n", *p);
    return 0;
}

我们在输出sum之前打印一句话，这时看到得到的结果完全不是我们预先想象的样子，得到的并不是我们想要的答案。

为什么会出现上面的结果呢？
其实原因在于，一般的局部变量是存放于栈区的，当函数结束，栈区的变量就会释放掉，如果我们在函数内部定义一个变量，在使用一个指针去指向这个变量，当函数调用结束时，这个变量的空间就已经被释放，这时就算返回了该地址的指针，也不一定会得到正确的值。上面的示例中，在返回该指针后，立即访问，的确是得到了正确的结果，但这只是十分巧合的情况，如果我们等待一会儿再去访问该地址，很有可能该地址已经被其他的变量所占用，这时候得到的就不是我们想要的结果。甚至更严重的是，如果因此访问到了不可访问的内容，很有可能造成段错误等程序崩溃的情况。
因此，在使用指针函数的时候，一定要避免出现返回局部变量指针的情况。
那么为什么用了static就可以避免这个问题呢？
原因是一旦使用了static去修饰变量，那么该变量就变成了静态变量。而静态变量是存放在数据段的，它的生命周期存在于整个程序运行期间，只要程序没有结束，该变量就会一直存在，所以该指针就能一直访问到该变量。
因此，还有一种解决方案是使用全局变量，因为全局变量也是放在数据段的，但是并不推荐使用全局变量。

函数指针

与指针函数不同，函数指针 的本质是一个指针，该指针的地址指向了一个函数，所以它是指向函数的指针。
我们知道，函数的定义是存在于代码段，因此，每个函数在代码段中，也有着自己的入口地址，函数指针就是指向代码段中函数入口地址的指针。
其声明形式如下所示：

ret (*p)(args, ...);

其中，ret为返回值，*p作为一个整体，代表的是指向该函数的指针，args为形参列表。其中p被称为函数指针变量 。

关于函数指针的初始化

与数组类似，在数组中，数组名即代表着该数组的首地址，函数也是一样，函数名即是该数组的入口地址，因此，函数名就是该函数的函数指针。
因此，我们可以采用如下的初始化方式：

函数指针变量 =  函数名;

下面还是以一个简单的例子来具体说明一下函数指针的应用：

文件：func_pointer.c

#include <stdio.h>

int max(int a, int b)
{
    return a > b ? a : b;
}

int main(void)
{
    int (*p)(int, int); //函数指针的定义
    //int (*p)();       //函数指针的另一种定义方式，不过不建议使用
    //int (*p)(int a, int b);   //也可以使用这种方式定义函数指针
    
    p = max;    //函数指针初始化

    int ret = p(10, 15);    //函数指针的调用
    //int ret = (*max)(10,15);
    //int ret = (*p)(10,15);
    //以上两种写法与第一种写法是等价的，不过建议使用第一种方式
    printf("max = %d \n", ret);
    return 0;
}

上面这个函数的功能也十分简单，就是求两个数中较大的一个数。值得注意的是通过函数指针调用的方式。
首先代码里提供了3种函数指针定义的方式，这三种方式都是正确的，比较推荐第一种和第三种定义方式。然后对函数指针进行初始化，前面已经提到过了，直接将函数名赋值给函数指针变量名即可。
上述代码运行的结果如下：

调用的时候，既可以直接使用函数指针调用，也可以通过函数指针所指向的值去调用。(*p)所代表的就是函数指针所指向的值，也就是函数本身，这样调用自然不会有问题。有兴趣的同学可以去试一试。

为什么要使用函数指针？

那么，有不少人就觉得，本来很简单的函数调用，搞那么复杂干什么？其实在这样比较简单的代码实现中不容易看出来，当项目比较大，代码变得复杂了以后，函数指针就体现出了其优越性。
举个例子，如果我们要实现数组的排序，我们知道，常用的数组排序方法有很多种，比如快排，插入排序，冒泡排序，选择排序等，如果不管内部实现，你会发现，除了函数名不一样之外，返回值，包括函数入参都是相同的，这时候如果要调用不同的排序方法，就可以使用指针函数来实现，我们只需要修改函数指针初始化的地方，而不需要去修改每个调用的地方（特别是当调用特别频繁的时候）。

回调函数

函数指针的一个非常典型的应用就是回调函数。
什么是回调函数？
回调函数就是一个通过指针函数调用的函数。其将函数指针作为一个参数，传递给另一个函数。
回调函数并不是由实现方直接调用，而是在特定的事件或条件发生时由另外一方来调用的。
同样我们来看一个回调函数的例子：

文件：callback.c

#include<stdio.h>
#include<stdlib.h>

//函数功能：实现累加求和
int func_sum(int n)
{
        int sum = 0;
        if (n < 0)
        {
                printf("n must be > 0\n");
                exit(-1);
        }
        for (int i = 0; i < n; i++)
        {
                sum += i;
        }
        return sum;
}

//这个函数是回调函数，其中第二个参数为一个函数指针，通过该函数指针来调用求和函数，并把结果返回给主调函数
int callback(int n, int (*p)(int))
{
        return p(n);
}

int main(void)
{
        int n = 0;
        printf("please input number:");
        scanf("%d", &n);
        printf("the sum from 0 to %d is %d\n", n, callback(n, func_sum));       //此处直接调用回调函数，而不是直接调用func_sum函数
        return 0;
}

上面这个简单的demo就是一个比较典型的回调函数的例子。在这个程序中，回调函数callback无需关心func_sum是怎么实现的，只需要去调用即可。
这样的好处就是，如果以后对求和函数有优化，比如新写了个func_sum2函数的实现，我们只需要在调用回调函数的地方将函数指针指向func_sum2即可，而无需去修改callback函数内部。
以上代码的输出结果如下：

回调函数广泛用于开发场景中，比如信号函数、线程函数等，都使用到了回调函数的知识。

一、函数简介

• Swift 函数用来完成特定任务的独立的代码块。
• Swift 使用一个统一的语法来表示简单的 C 语言风格的函数到复杂的 Objective-C 语言风格的方法：
• • 函数声明：告诉编译器函数的名字，返回类型及参数。
• • 函数定义：提供了函数的实体。
• Swift 函数包含了参数类型及返回值类型。

二、函数定义

• Swift 定义函数使用关键字 func，定义函数的时候，可以指定一个或多个输入参数和一个返回值类型。
• 每个函数都有一个函数名来描述它的功能，通过函数名以及对应类型的参数值来调用这个函数，函数的参数传递的顺序必须与参数列表相同。
• 函数的实参传递的顺序必须与形参列表相同，-> 后定义函数的返回值类型。

① 一般用法

• 不带参数：

func pi() -> Double {
	return 3.1415
}

pi()

• 带参数：

// 求和
//
// 将两个整数相加
// - Parameters:
//   - v1: v1 第一个整数
//   - v2: v2 第二个整数
// - Returns: 2个整数的和
//
// - Note : 传入2个整数即可
func sum(v1: Int,v2: Int) -> Int {
    v1 + v2
}

sum(v1: 10, v2: 20)

• 说明：
• • 所有的函数前面都用 func 来修饰；
• • 函数名()的()里写的是参数，这里是虚参，也就是参数名称；
• • 函数的参数默认是常量，而且只能是常量；
• • 返回值是写在参数的后面，并且使用 -> 隔开，sum 函数返回的是 Int 类型；
• • 在调用时也需要加上参数名称，这样传值会更准确；
• • 在 sum 函数中我写了文档注释，这样便于后续维护，而且在调用函数时可以更加明确函数的职责；
• • 因为是单一的表达式，所以无需写 return，编译期会自动判断。
• 注意：
• • 若没有返回值有三种写法：返回 Void，Void 其实就是()，Void 是 () 空元祖的别名(注意 Void 的 V 是大写，跟其他语言不一样），返回()，也就是直接返回空元组；
• • 也可以不写返回值就表示没有返回值；
• • 如果整个函数体只是简单的单一表达式，可以不写 return 来返回，编译器会自动增加 return；
• • 形参默认是 let，也只能是 let，所以以后就不要写就行。

② 返回元组

• 如下所示：

func calculate(v1: Int,v2: Int) -> (sum: Int,diffence: Int,average: Int) {
	let sum = v1+v2
	return(sum,v1-v2,sum>>1)
}

let result = calculate(v1: 20, v2: 10)
result.sum
result.diffence
result.average
result.0
result.1
result.2

• 运行结果：

• 说明：
• • 以元组的形式返回就可以一次性得到多个返回值；
• • 函数接收的时候就直接用一个 let 或 var 就行，因为是不确定数据类型的，所以可以接收任意类型；
• • 接收后使用上就和正常的元组一样，可以通过标识符取用，也可以使用下标取用。

三、函数参数

① 参数标签

• Swift 有参数标签这个东西，常见的参数名称是为了在函数内部有更好的语义化，而参数标签是为了再外界调用时有更好的语义化：

// 函数标签的案例
func goToWork(at time: String) {
// 内部语义化：this time is time
	print("this time is \(time)")
}

goToWork(at: "08:00")
// 外部语义化：go to work at 08:00

// 省略参数标签
func sum(_ v1: Int, _ v2: Int) -> Int {
    v1 + v2
}
sum(10, 20)

• 说明：
• • 在函数定义中使用的是 time 时间，这样更易读，this time is 08:00；
• • 在函数调用时用 go to work at 08:00 这样来写更易读；
• • 在定义函数时需要加上 at 这个参数标签；
• • 函数的一个参数既有在函数内部使用的函数名称，也有在函数外使用的函数标签；
• • 函数标签可以省略，使用_就可以省略，此时外部调用时就无需使用参数标签。
• 注意：
• • 加_省略和不写参数标签是不一样的；
• • 这种情况在调用时就可以直接传值，如果是定义时不写参数标签，在外部调用时仍然要写参数名称，而不能直接写参数。

② 默认参数

• 可以在定义函数时添加默认参数时，这样在调用函数时可以不传入这个参数的值：

func check(name: String = "nobody", age: Int,job: String = "none") -> () {
    print("name=\(name),age=\(age),job=\(job)")
}
check(age: 18)
check(name: "wy", age: 18, job: "iOS")
check(age: 18,job: "iOS")

• 执行结果：

ame=nobody,age=18,job=none
name=wy,age=18,job=iOS
name=nobody,age=18,job=iOS

• 说明：
• • 在函数中 name 和 job 参数有自己的默认参数值；
• • 在调用时函数时可以不给 name 和 job 传值，函数内部会使用默认参数值来计算；
• • 但是 age 必须要传值，因为没有默认参数值；
• • 在传值时会使用到参数标签所以不会有歧义，可以任意决定传值的参数，这与 C 语言不同。

③ 可变参数

• 在 Swift 中使用可变参数会很方便，当然了和其他语言一样其实在内部也是编译成一个数组：

func sum(_ numbers: Int...) -> Int {
	var total = 0
	for number in numbers {
        total += number
    }
	return total
}
sum(10,20,30,40)
sum(10, 20)

• 说明：
• • 传入的参数中在数据类型的后面加上…，这样就是可变参数；
• • 在函数内部把这个参数看做数组来处理；
• • 一个函数最多只能有 1 个可变参数；
• • 紧跟在可变参数后面的参数不能省略参数标签/参数名称，否则无法区分这个值是哪个参数的。

四、函数内修改外部变量的值（inout 的使用）

• 函数的参数只能是常量，所以正常情况下无法修改这个参数，如果想要修改参数，就需要使用 inout 来修饰这个参数，这样做并且不仅可以修改参数内部，还可以修改外部的变量。本质是将值传递改为了指针传递。

// inout的使用
func swapValues(_ v1: inout Int, _ v2: inout Int) -> Void {
	let tmp = v1
    v1 = v2
    v2 = tmp
}

var num1 = 10
var num2 = 20
swapValues(&num1, &num2) // 传入地址（其实就是指针，虽然Swift中没有指针变量的概念）

• 说明：
• • 不同于其他语言，Swift 的虚参只能是常量，不能是变量，所以无法修改；
• • 如果是值传递，也无法修改外部变量的值；
• • 可以使用 inout 来修饰，就可以修改外部变量的值；
• • 调用函数时传入的值要传入变量地址，而不是变量本身；
• • 可变参数不可以加 inout；
• • inout 参数不可以有默认值。

五、函数类型

• 函数也有自己的数据类型，数据类型就是参数数据类型+返回值数据类型，这里的函数类型可以视作 OC 中 block，在使用上和 block 基本一样，block 简单说来其实就是可作为变量/参数/返回值的能够捕获变量的匿名函数；
• 如下所示，演示作为变量、参数、返回值的具体使用，可以看到和 block 的使用完全一致：

① 函数类型

• 函数的函数类型就是参数数据类型+返回值数据类型；
• test() 函数的函数类型就是() -> ()；
• test2() 函数的数据类型为：(Int,String) -> (Int,Double)。

// 数据类型为：()->() 或者()->Void
func test(){
	print("lalala")
}
// 数据类型为：(Int,String) -> (Int,Double)
func test2(a: Int,b: String) -> (Int,Double) {
	return(7,7.0)
}

② 作为变量

• 定义一个函数类型的变量，就可以将这个函数赋值给这个变量，之后通过这个变量来调用函数；
• 通过函数变量调用时不需要参数标签和参数名称，直接传值；
• 为更方便的说明，可以把定义变量和赋值参数分开写了，其实也可以写到一起。

//（Int,Int) -> Int
func sum2(a:Int,b:Int) -> Int {
    a+b
}

// 1、通过函数的数据类型定义一个函数变量
var fn: (Int,Int) -> Int;
// 2、赋值一个函数
fn = sum2(a:b:)
// 3、调用
fn(2,3)

③ 作为参数传递

// 加法
func sum3(v1: Int, v2: Int) -> Int {
    v1+v2
}

// 减法
func difference(v1: Int,v2: Int) -> Int {
    v1-v2
}

// 通过传入的函数和对变量进行对应的加减操作
// (Int, Int) -> Int 是mathFn参数的数据类型
func printResult(_ mathFn: (Int, Int) -> Int , _ a: Int, _ b:Int) {
print("Result: \(mathFn(a,b))")
}

printResult(sum, 20, 10)
printResult(difference, 20, 10)

• 在 printResult 函数中第一个参数就是一个函数，这里传递到时候参数的数据类型就是函数类型；
• (Int, Int) -> Int 是 mathFn 参数的数据类型；
• 在 PrintResult 函数中就可以使用传入的函数进行调用了，通过传入的函数和对变量进行对应的加减操作。

④ 作为返回值

// +1
func next(_ input: Int) -> Int {
    input + 1
}

// -1
func previous(_ input: Int) -> Int {
    input - 1
}

// 通过传入的Bool值判断返回哪个函数
// (Int) -> Int是返回值类型，是个函数类型，因此返回函数
// 因为返回的是函数所以只写名称，不需要带参数
func forward(_ forward: Bool) -> (Int) -> Int {
    forward ? next : previous
}
forward(true)(3)  // 4
forward(false)(4) // 2

• forward 函数的返回值类型是 (Int) -> Int，这是一个函数类型；
• 返回的是函数所以只写名称，不需要带参数，如果带参数就是具体的值；
• forward(true) 得到的是函数 next，因此 next(3) 就是 4。

六、函数的嵌套

• 函数嵌套指的是函数内定义一个新的函数，外部的函数可以调用函数内定义的函数。实例如下：

import Cocoa

func calcDecrement(forDecrement total: Int) -> () -> Int {
   var overallDecrement = 0
   func decrementer() -> Int {
      overallDecrement -= total
      return overallDecrement
   }
   return decrementer
}
let decrem = calcDecrement(forDecrement: 30)
print(decrem())

• 执行输出结果为：

-30

目录

函数与函数式编程

函数的定义

函数与过程

返回值与返回值类型

前向引用

内部/内嵌函数

函数装饰器

传递函数

参数的种类

位置参数

参数默认值

命名关键字参数

关键字参数：**others，便于函数功能的扩展

任意的参数列表 *others

解包参数列表  

解包参数列表  

函数与函数式编程

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

函数能提高应用的模块性，和代码的重复利用率。Python提供了许多内建函数，比如print()。我们也可以自己创建函数，这被叫做用户自定义函数。

函数的定义

我们可以定义一个由自己想要功能的函数，以下是简单的规则：

函数代码块以def关键词开头，后接函数标识符名称和圆括号()。

任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。

函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。

函数内容以冒号起始，并且缩进。

return[表达式]结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回None。

以创建一个输出任意范围内 Fibonacci 数列的函数为例:

def fib(n):
    a,b=0,1
    while a<n:
        print(a,end=" ")
        a,b=b,a+b
    print()
fib(2000)

关键字def引入一个函数定义。它必须后跟函数名称和带括号的形式参数列表。构成函数体的语句从下一行开始，并且必须缩进。

函数体的第一个语句可以(可选的)是字符串文字；这个字符串文字是函数的文档字符串或docstring。

函数的执行会引入一个用于函数局部变量的新符号表。更确切地说，函数中所有的变量赋值都将存储在局部符号表中；而变量引用会首先在局部符号表中查找，然后是外层函数的局部符号表，再然后是全局符号表，最后是内置名称的符号表（变量作用域问题，之后会详细介绍）。因此，全局变量和外层函数的变量不能在函数内部直接赋值(除非是在global语句中定义的全局变量，或者是在nonlocal语句中定义的外层函数的变量)，尽管它们可以被引用。

在函数被调用时，实际参数(实参)会被引入被调用函数的本地符号表中；因此，实参是通过按值调用传递的(其中值始终是对象引用而不是对象的值)。当一个函数调用另外一个函数时，将会为该调用创建一个新的本地符号表。

函数定义会把函数名引入当前的符号表中。函数名称的值具有解释器将其识别为用户定义函数的类型。这个值可以分配给另一个名称，该名称也可以作为一个函数使用。这用作一般的重命名机制:

print(fib)
f=fib
f(100)

上面这个函数是无返回值的函数，即没有return语句，默认返回None。一般来说解释器不会打印出单独的返回值None，如果真想看到它，可以使用print()

print(fib(0))

print(fib(1))

写一个返回斐波那契数列的列表(而不是把它打印出来)的函数，非常简单:

def fib2(n):
    result=[]
    a,b=0,1;
    while a<n:
        result.append(a)
        a,b=b,a+b
    return result
f100=fib2(100)
print(f100)

函数与过程

函数与过程都是可以被调用的实体，一般来说，函数有一定的返回值，过程是简单、特殊、没有返回值的函数。

返回值与返回值类型

当没有返回值时，Python的实际返回对象是None。

当返回对象的数目为1时，Python的返回值类型是该对象的类型。

当返回对象的数目大于1时，Python的返回值类型是元组。

def fun1():
    pass
print(fun1())
def fun2():
    return '123'
print(fun2())
def fun_list():
    return ['123','xyz',456]
print(fun_list())
def fun_tuple1():
    return 1,2,3
print(fun_tuple1())
def fun_tuple2():
    return (1,2,3)
print(fun_tuple2())

运行结果：

None

123

['123', 'xyz', 456]

(1, 2, 3)

(1, 2, 3)

fun1()返回None，fun2()的返回值类型是字符串，fun_list()、fun_tuple1()、fun_tuple2()的返回值大于1个，fun_list()返回的是一个列表，fun_tuple1()、fun_tuple2()等价，都是一个元组。

所以在我们看来。返回一个容器对象时，好像是返回了多个对象（元组在语法上不需要带括号），事实上，他们仍返回的是一个，一个容器罢了。

保存元组返回值的三种方法：

def fun_tuple():
    return 'abc',5,['k','p']
aTuple=fun_tuple()
x,y,z=fun_tuple()
(a,b,c)=fun_tuple()
print(aTuple)
print(x,y,z)
print((a,b,c))

运行结果：

('abc', 5, ['k', 'p'])

abc 5 ['k', 'p']

('abc', 5, ['k', 'p'])

在对x、y、z和a、b、c的赋值中，根据返回值的顺序，每个变量会接收到与之对应的返回值。而aTuple直接获得函数隐式返回的整个元组。

前向引用

def foo():
    print('1')
    bar()
def bar():
    print('2')
foo()

运行结果：

1

2

可见上例中foo（）先调用的bar（），然后bar（）才声明，系统不会报错。但是不推荐这么写，从感觉上来说，有悖常识，自己尽量让需要用的放在前面吧。

内部/内嵌函数

在函数体内部创建另外一个函数是完全合法的，这种函数叫内嵌函数。

如：

def foo():
    print('1')
    def bar():
        print('2')
    bar()
foo()

运行结果：

1

2

内部函数的整个函数体都在外部函数的作用域里。如果没有任何对bar（）的外部引用，那么除了在外部函数体foo()内，任何其他地方都不能对其进行调用。

另外一个函数体内创建函数对象的方式是使用lambda语句。这个之后的学习会涉及。

函数装饰器

暂时看不懂，先不写。

传递函数

传递函数的方式大致有三种：

1. 被引用（访问或者以其他变量作为其别名）
2. 作为参数传入函数
3. 作为字典、列表等容器对象的元素

下面详细介绍一下用其他的变量作为函数的别名。

def foo():
    print('1')
bar=foo
bar()

运行结果：

1

当我们把foo赋给bar时，bar和foo引用了同一个函数对象，所以能以调用foo（）相同的方式调用bar()。

故：foo是函数对象的引用；foo()是函数对象的调用。

再如：

def foo():
    print('1')
def bar(argfunc):
    argfunc()
bar(foo)

运行结果：

1

参数的种类

位置参数

位置参数必须以在被调用函数中的定义的准确顺序来传递。若没有任何默认参数的话，传入函数的参数的精确的数目必须和声明中的数字一致。

当然，我们也可以不按位置地将关键字参数传入函数，给出关键字来匹配其在参数列表中的合适位置，但是位置参数的数字一定要对。

def info(name,sex,grades,school='abc'):
    print(name)
    print(sex)
    print(grades)
    print(school)
info('Jennifer','female','3')
print()
info(sex='female',name='Jennifer',school='lalala',grades='1')
print()
info(grades='1',sex='male',name='frank')

运行结果：

Jennifer

female

3

abc

 

Jennifer

female

1

lalala

 

frank

male

1

abc

参数默认值

最有用的形式是对一个或多个参数指定一个默认值。这样创建的函数，可以用比定义时允许的更少的参数调用，设置默认参数，必选参数在前，默认参数在后。比如:

def ask_ok(prompt,retries=4,reminder='Please try again!'):
    while True:
        ok=input(prompt)
        if ok in ('y','ye','yes'):
            return True
        if ok in ('n','no','nop','nope'):
            return False
        retries=retries-1
        if retries<0:
            raise ValueError('invalid user response')
        print(reminder)

这个函数可以通过几种方式调用:

    只给出必需的参数：ask_ok('Do you really want to quit?')

    给出一个可选的参数：ask_ok('OK to overwrite the file?', 2)

或者给出所有的参数：ask_ok('OK to overwrite the file?', 2, 'Come on, only yes or no!')

这个示例还介绍了 in 关键字。它可以测试一个序列是否包含某个值。

默认值是在定义过程中在函数定义处计算的，所以下例会打印5。

i=5
def f(arg=i):
    print(arg)
i=6
f()

重要警告： 默认值只会执行一次。这条规则在默认值为可变对象(列表、字典以及大多数类实例)时很重要。比如，下面的函数会存储在后续调用中传递给它的参数:

def f(a,L=[]):
    L.append(a)
    return L
print(f(1))
print(f(2))
print(f(3))

打印结果如下：

如果你不想要在后续调用之间共享默认值，你可以这样写这个函数:

def f(a,L=None):
    if L is None:
        L=[]
    L.append(a)
    return L
print(f(1))
print(f(2))
print(f(3))

命名关键字参数

函数调用时，指定参数名称，称为关键字参数（别和默认参数混淆，这里是函数调用）

def temp(a,b,c):

    print(a)

    print(b)

    print(c)

temp(1,3,c=99)

temp(a=1,b=2,c=3)

temp(1,b=2,c=100)

顺序要求：函数调用时，关键字参数必须在普通参数（位置参数）的后面

temp(100,b=200,c=300)

temp(a=100,32,100) #错误语法，关键字参数不能在普通参数的前面

使用字典解包方式传入关键字参数（后面小节中会详细讲到）

hi = {"a":100,"b":99,"c":1000}

temp(**hi) #等同于下面#

temp(a=100,b=99,c=1000)

函数调用时，当剩余的参数全部为关键字参数时，可随意定义顺序

当全部为关键字参数时，调用函数时的参数顺序可随意书写，因为你指定了参数名，但是参数的数量不能少于函数定义时要求的位置参数的数量

temp(c=100,b=38,a=10)

也可以使用形如kwarg=value的关键字参数来调用函数。例如下面的函数:

def parrot(voltage,state='a stiff',action='voom',type='Norwegian Blue'):
    print("--This parrot wouldn't",action,end=' ')
    print("if you put",voltage,"volts though it.")
    print("-- Lovely plumage, the", type)
    print("-- It's", state, "!")

接受一个必需的参数(voltage)和三个可选的参数(state, action，和 type)。这个函数可以通过下面的任何一种方式调用:

• 一个位置参数：parrot(1000)
• 一个关键字参数：parrot(voltage=1000)
• 两个关键字参数;parrot(voltage=1000000, action='VOOOOOM')
• 两个关键字参数;parrot(action='VOOOOOM', voltage=1000000)
• 三个位置参数：parrot('a million', 'bereft of life', 'jump')
• 一个位置参数，一个关键字参数：parrot('a thousand', state='pushing up the daisies')

但下面的函数调用都是无效的:

• 丢失必要参数：parrot()
• 在关键字参数之后的非关键字参数 ：parrot(voltage=5.0, 'dead')
• 同一参数的重复值 ：parrot(110, voltage=220)
• 未知的关键字参数：parrot(actor='John Cleese')

在函数调用中，关键字参数必须跟随在位置参数的后面。传递的所有关键字参数必须与函数接受的其中一个参数匹配(比如 actor 不是函数 parrot 的有效参数)，它们的顺序并不重要。这也包括非可选参数，(比如 parrot(voltage=1000) 也是有效的)。不能对同一个参数多次赋值。下面是一个因为此限制而失败的例子:

def function(a):
    pass
function(0,a=0)

关键字参数：**others，便于函数功能的扩展

当存在一个形式为**name的最后一个形参时，它会接收一个字典，其中包含除了与已有形参相对应的关键字参数以外的所有关键字参数。这可以与一个形式为*name，接收一个包含除了已有形参列表以外的位置参数的元组的形参组合使用(*name必须出现在**name之前，下一小节会讲到)。例如，如果我们这样定义一个函数:

def cheeseshop(kind, *arguments, **keywords):
    print("-- Do you have any", kind, "?")
    print("-- I'm sorry, we're all out of", kind)
    for arg in arguments:
        print(arg)
    print("-" * 40)
    for kw in keywords:
        print(kw, ":", keywords[kw])

它可以像这样调用:

cheeseshop("Limburger", "It's very runny, sir.",
           "It's really very, VERY runny, sir.",
           shopkeeper="Michael Palin",
           client="John Cleese",
           sketch="Cheese Shop Sketch")

注意打印时关键字参数的顺序保证与调用函数时提供它们的顺序是相匹配的。

任意的参数列表 *others

最后，最不常用的选项是可以使用任意数量的参数调用函数。这些参数会被包含在一个元组里。在可变数量的参数之前，可能会出现零个或多个普通参数。:

def write_multiple_items(file, separator, *args):
    file.write(separator.join(args))

一般来说，这些可变参数将在形式参数列表的末尾，因为它们收集传递给函数的所有剩余输入参数。出现在*args参数之后的任何形式参数都是‘仅关键字参数’，也就是说它们只能作为关键字参数而不能是位置参数。

def concat(*args, sep="/"):
    return sep.join(args)
print(concat("earth", "mars", "venus"))
print(concat("earth", "mars", "venus", sep="."))

解包参数列表  

当参数已经在列表或元组中但需要为需要单独位置参数的函数调用解包时，会发生相反的情况。例如，内置的 range() 函数需要单独的 start 和 stop 参数。如果它们不能单独使用，请使用 * 运算符编写函数调用以从列表或元组中解包参数，*args输出结果是3 6:

list(range(3,6))
print(list(range(3,6)))
args=[3,6]
print(list(range(*args)))

以同样的方式，字典可以使用 ** 运算符来提供关键字参数:

def parrot(voltage, state='a stiff', action='voom'):
    print("-- This parrot wouldn't", action, end=' ')
    print("if you put", voltage, "volts through it.", end=' ')
    print("E's", state, "!")
d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
parrot(**d)

更多Python框架梳理，请参考： 【Python学习】Python最全总结

 有问题请下方评论，转载请注明出处，并附有原文链接，谢谢！如有侵权，请及时联系。