Python中的函数

发布时间:2023年12月21日

创建和使用

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

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

?

文章来源:https://blog.csdn.net/qq_40386113/article/details/135133719
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。