Python中的函数

创建和使用

? ? ? ? 创建函数的语法如下：

def 函数名(参数):
    代码块(函数体)

函数的参数

形参：在定义函数的时候传递的参数

实参：在调用函数时传递的参数

无参：没有任何参数

位置参数

? ? ? ? 实参的位置和形参一一对应，不能多也不能少

关键字参数

? ? ? ? 用形参的名字作为关键字来指定具体传递的值，则在函数调用时，前后顺序将不受影响

def fun(a,b,c):
    print(a,b,c)

fun(b=10,a=20,c=5)

输出结果：20 10 5

位置参数和关键字参数混用

? ? ? ? 当位置参数和关键字参数混用时，位置参数在前。也就是说函数调用时，既有位置参数也有关键字参数，则位置参数一定在关键字参数之前，否则函数调用是报错的

def fun(a,b,c):
    print(a,b,c)

fun(10,20,c=30)

可变参数

? ? ? ? 示例一，形参中使用一个星号，代表此参数本质上是封装成了元组

def fun(*a):
    print(a)

fun(10,20,30)

#输出   (10, 20, 30)

? ? ? ? 示例二，形参中使用两个星号，代表此参数本质上是封装成了字典。需要注意的是，在函数调用的时候，要使用关键字参数的传递方式

def fun(**a):
    print(a)

fun(a=10,b=30,c=18)

#输出  {'a': 10, 'b': 30, 'c': 18}

可变参数和位置参数混用

? ? ? ? 可变参数和位置参数混用的时候，可变参数优先，且在调用的时候，应该用关键字指明最后一个参数是位置参数。可变参数优先是定义优先和调用优先

def fun(*a,b):
    print(a,b)

fun(10,20,b=11)

def fun2(b,*a):
    print(b,a)

fun(10,20,b=30)

函数的文档

def fun(*a,b):
    """
    fun是个函数
    :param b:可变参数
    :param a: 位置参数
    :return:
    """
    print(a,b)

fun(12,13,b=10)

# 获取函数的文档内容
print(fun.__doc__)

# 进行函数文档的查看
help(fun)

输出结果如下：

?

函数的返回值

关键字：return

????????返回值谁调用就返回给谁

1. 任何函数都有返回值

2. 如果不写return ，也会默认加一个return None

3. 如果写return ，不写返回值 也会默认加一个None

4. 可以返回任何数据类型

5. return后面的代码不在执行，代表着函数的结束

函数的变量的作用域

局部变量

????????定义在函数内部的变量

????????先赋值在使用

????????从定义开始到包含他的代码结束

????????在外部无法访问

全局变量

????????1. 定义在源文件的开头

????????2. 作用范围：整个文件

????????3. 局部变量和全局变量发生命名冲突时，以局部变量优先

global

? ? ? ? 声明全局变量

def fun():
    global b
    b = 100
    print(b)

fun()
#局部变量b被global声明后在函数外部也能使用
print(b)

nonlocal

? ? ? ? 声明的是局部变量

def fun():
    b = 100
    def fun2():
        nonlocal b  #声明之后b在函数内变成了300
        b = 300
        print(b)
    fun2()
    print(b)  #如果在fun2中没有声明，则这里输出的是100，在fun2中声明了之后，这里输出的就是300

fun()



#输出结果如下
300
300

内嵌函数

? ? ? ? 定义在函数内部的函数叫做内嵌函数，或者叫做内部函数，内嵌函数的作用范围：从定义开始到包含它的代码快结束。在内嵌函数中不能直接进行a+=1,a=a+1这样的操作，如果要进行这样的操作，如上面示例，解决方案是nonlocal和global

闭包

? ? ? ? 闭包是函数式编程的重要语法结构。

? ? ? ? 如果内部函数调用了外部函数的局部变量，并外部函数返回内嵌函数的函数对象，例如：

def fun():
    a = 100
    def fun2():
        print(a)
        return "Hello"
    return fun2()

print(fun())

#输出
100
Hello

? ? ? ? 这就形成了闭包，闭包的作用式可以传递更少的形参，可以传递更多的实参——更加安全，间接性的访问内部函数，例如：

def fun(b):
    a = 100
    print(b)

    def fun2():
        print(a)
        return "Hello"

    return fun2()

print(fun(200))

#输出
200
100
Hello

?