PHP程序员小白到大牛集训(12期免息)
Apifox=Postman + Swagger + Mock + JMeter,是接口文档,接口调试,接口 Mock,接口自动化测试一体化协作平台, php中文网推荐使用
广告
作者信息

长期闲置

长风破浪会有时,直挂云帆济沧海。

最近文章
linux文件的大小能限制吗1043
linux的make命令找不到怎么解决323
linux中i节点是什么560
视频教程分类
推荐视频教程
  • php程序员小白到大牛三个月集训php程序员小白到大牛三个月集训
  • Laravel 9 学习正当时—保姆级教程,想学不会都难!Laravel 9 学习正当时—保姆级教程,想学不会都难!
  • 千万级数据并发解决方案(理论+实战)千万级数据并发解决方案(理论+实战)
  • Laravel基础与实战(模块化)Laravel基础与实战(模块化)
  • 首页 >后端开发 >Python教程 > 正文

    归纳总结Python函数进阶的使用方法

    转载2022-06-02 11:57:551167 关注公众号:每天精选资源文章推送
    本篇文章给大家带来了关于python的相关知识,其中主要介绍了关于函数进阶的使用方法,包括了函数的命名和作用域、函数的嵌套和作用域链、函数名的本质等等内容,下面一起来看一下,希望对大家有帮助。

    推荐学习:python视频教程

    一、函数的命名空间和作用域

    1、函数的命名空间

    • 什么是命名空间?

    假如有一串代码,观察其输出结果:

    def f():
        a = 1
        return a
    
    print(a)
    
    输出结果:
    Traceback (most recent call last):
      File "E:/python代码/11/文件一.py", line 4, in <module>
        print(a)
    NameError: name 'a' is not defined

    报错了!错误是“name 'a' is not defined”。变量a没有被定义。。。为啥?我明明定义了a=1呀!

    那我们就要了解一下Python代码运行时遇到函数时怎么做的:

    首先从python解释器开始执行之后,就在内存中开辟了一个空间每当遇到一个变量的时候,就把变量名和值之间的对应关系记录下来。但是当遇到函数定义的时候解释器只是象征性的将函数名读入内存,表示知道这个函数的存在了,至于函数内部的变量和逻辑解释器根本不关心。等执行到函数调用的时候,python解释器会再开辟一块内存来存储这个函数里的内容,这个时候,才关注函数里面有哪些变量,而函数中的变量会存储在新开辟出来的内存中。函数中的变量只能在函数的内部使用,并且会随着函数执行完毕,这块内存中的所有内容也会被清空。

    我们给这个“存放名字与值的关系”的空间起了一个名字——叫做命名空间

    代码在最开始创建的存储“变量名与值的关系”的空间叫做全局命名空间,在函数内部运行中开辟的临时的空间叫做局部命名空间

    • 函数命名空间三大类

    函数命名空间一共分为三大类

    1、内置命名空间 —— python解释器
        # 就是python解释器一启动就可以使用的名字存储在内置命名空间中
        # 内置的名字在启动解释器的时候被加载进内存里
    2、全局命名空间 —— 我们写的代码但不是函数中的代码
        # 是在程序从上到下被执行的过程中依次加载进内存的
        # 放置了我们设置的所有变量名和函数名
    3、局部命名空间 —— 函数
        # 就是函数内部定义的名字
        # 当调用函数的时候 才会产生这个名称空间 随着函数执行的结束 这个命名空间就又消失了
    
    #在局部:可以使用全局、内置命名空间中的名字
    #在全局:可以使用内置命名空间中的名字,但是不能用局部中使用
    #在内置:不能使用局部和全局的名字的

    内置命名空间:内置命名空间中存放了Python解释器为我们提供的名字(函数)我们不需要定义,都是我们熟悉的打开解释器就能够直接使用如:input、print、str、set……

    • 三种命名空间之间的加载与取值顺序

    加载顺序:内置命名空间(程序运行前加载 > 全局命名空间(程序运行中:从上到下加载) > 局部命名空间(程序运行中:调用时才加载)

    在局部调用时:局部命名空间 > 全局命名空间 > 内置命名空间

    在全局调用时:全局命名空间 > 内置命名空间

    例子:

    a = 10
    def f():
        a = 1
        print(a)
    f()
    print(a)
    
    输出结果:
    1
    10

    2、函数的作用域

    作用域就是作用范围,按照生效范围可以分为全局作用域和局部作用域。

    全局作用域:包含内置名称空间、全局名称空间,在整个文件的任意位置都能被引用、全局有效

    局部作用域:局部名称空间,只能在局部范围生效

    • globals和locals方法

    locals(): 函数会以字典类型返回当前位置的全部局部变量
    globals(): 函数会以字典类型返回当前位置的全部全局变量

    def func():
        a = 1
        print(locals())
        print(globals())
        print('========================分割线==========================')
    func()
    print(locals())
    print(globals())

    输出结果:

    • global关键字

    1、global是Python中的全局变量关键字。
    2、变量分为局部变量与全局变量,局部变量又可称之为内部变量。
    3、由某对象或某个函数所创建的变量通常都是局部变量,只能被内部引用,而无法被其它对象或函数引用。
    4、全局变量既可以是某对象函数创建,也可以是在本程序任何地方创建。全局变量是可以被本程序所有对象或函数引用。
    5、global关键字的作用是可以使得一个局部变量为全局变量

    例子:

    在my函数中,在 x 前面加 global,my函数将 x 赋为8,此时全局变量中的 x 值改变。需要注意的是 global 需要在函数内部声明,若在函数外声明,则函数依然无法操作 x 。

    x = 4
     
    def my():
        global x
        x = 8
        print("x = ", x)
     
    print("x = ", x)
    my()
    print("x = ", x)
     
     
    输出结果是:
    x = 4
    x = 8
    x = 8

    二、函数的嵌套和作用域链

    • 函数的嵌套调用

    def max2(x,y):
        m  = x if x>y else y
        return m
    
    def max4(a,b,c,d):
        res1 = max2(a,b)
        res2 = max2(res1,c)
        res3 = max2(res2,d)
        return res3
    
    ret = max4(1,2,4,3)
    print(ret)
    
    输出结果:
    4
    • 函数的嵌套定义

    def f1():
        print("in f1")
        def f2():
            print("in f2")
    
        f2()
    f1()
    
    输出结果:
    in f1
    in f2
    
    def f1():
        def f2():
            def f3():
                print("in f3")
    
            print("in f2")
            f3()
    
        print("in f1")
        f2()
    
    
    f1()
    
    输出结果:
    in f1
    in f2
    in f3
    • 函数的作用域链

    a = 1
    def outer():
        a = 5
        def inner():
            a = 2
            def inner2():
                nonlocal a
                a += 1
                print('inner2',a)
            inner2()
            print('##a##:',a)
        inner()
        print('**a**:',a)
    
    outer()
    
    print('全局:',a)
    
    输出结果:
    inner2 3
    ##a##: 3
    **a**: 5
    全局: 1
    • nonlocal关键字

    #nonlocal 只能用于局部变量,找上层中离当前函数最近一层的局部变量且外部必须有这个变量
    #声明了nonlocal的内部函数的变量修改会影响到离当前函数最近一层的局部变量
    #对全局无效,在内部函数声明nonlocal变量之前不能再出现同名变量
    #对局部也只是对最近一层有影响
    def f1():
        a = 1
        def f2():
            nonlocal a
            a = 2
        f2()
        print('a in f1 : ',a)
    
    f1()
    
    输出结果:
    a in f1 :  2
    • global关键字

    # 对于不可变数据类型 在局部可是查看全局作用域中的变量
    # 但是不能直接修改
    # 如果想要修改,需要在程序的一开始添加global声明
    # 如果在一个局部(函数)内声明了一个global变量,那么这个变量在局部的所有操作将对全局的变量有效

    三、函数名的本质

    1. 函数名就是内存地址

    2. 函数名可以被赋值

    3. 函数名可以作为容器类型的元素

    4. 函数名可以作为函数的返回值

    5. 函数名可以作为函数的参数

    def func():
        print(123)
    func()
    print(func)
    # 函数名就是内存地址
    # 函数名可以被赋值
    func2 = func
    func2()
    
    #函数名可以作为容器类型的元素
    l = [func,func2]
    for i in l:
        i()
    def func():
        print(123)
    
    def wahaha(f):
        f()
        return f            #函数名可以作为函数的返回值
    qqxing = wahaha(func)   #函数名可以作为函数的参数
    qqxing()
    
    输出结果:
    123
    <function func at 0x000001ADF9946280>
    123
    123
    123
    123
    123
    • 思考

    如果我自己定义了一个input函数(作用:调用该函数就打印'在下周周ovo'),会不会与内置的input函数有冲突呢?

    def input(a):
        print('在下周周ovo')

    那么接下来的代码怎么运行呢?

    def input(a):
        print('在下周周ovo')
    
    def func():
        input('请输入')
        print(input)
    
    func()

    答案:


    四、闭包

    • 闭包函数的概念

    内部函数包含对外部作用域而非全剧作用域名字的引用,该内部函数称为闭包函数
    #函数内部定义的函数称为内部函数

    由于有了作用域的关系,我们就不能拿到函数内部的变量和函数了。如果我们就是想拿怎么办呢?返回呀!

    如果函数内的变量我们要想在函数外部用,可以直接返回这个变量,那么如果我们想在函数外部调用函数内部的函数呢?那就直接将函数名字作为返回值就好

    def outer():
        a = 1
        def inner():
            print(a)    #内部函数调用了外部变量a
        return inner
    
    inn = outer()
    inn()
    
    输出结果:
    1
    • 闭包函数的判断方法

    判断闭包函数的方法__closure__

    当运行后,如果有cell的话,就表示是闭包函数。如果没有就不是。

    #输出的__closure__有cell元素 :是闭包函数
    def func():
        name = 'eva'
        def inner():
            print(name)
        print(inner.__closure__)
        return inner
    
    f = func()
    f()
    
    #输出的__closure__为None :不是闭包函数
    name = 'egon'
    def func2():
        def inner():
            print(name)
        print(inner.__closure__)
        return inner
    
    f2 = func2()
    f2()
    
    输出结果:
    (<cell at 0x000001E935CB0FA0: str object at 0x000001E935CC2CB0>,)
    eva
    None
    egon
    • 闭包嵌套

    顾名思义是两个或以上的闭包函数嵌套在一起

    def wrapper():
        money = 10
        def func():
            name = 'zhou'    
            def inner():
                print(name,money)    #引用了func()函数中name变量引用了wrapper()函数中money变量
            return inner
        return func
    
    f = wrapper()
    i = f()
    i()
    
    输出结果:
    zhuo 10

    小结

    #func(一个函数名)  --->>对应函数的内存地址
    #函数名()---函数调用
    #函数的内存地址----()函数的调用
    # 作用域两种
    # 全局作用域 —— 作用在全局 —— 内置和全局名字空间中的名字都属于全局作用域  ——globals()
    # 局部作用域 —— 作用在局部 —— 函数(局部名字空间中的名字属于局部作用域) ——#locals()globals() : 永远打印全局的名字
    #locals()  : 输出什么 根据locals所在位置
    #在代码中要尽量少定义全局变量,多使用返回值和接收返回值
    #函数的嵌套:
            嵌套调用
            嵌套定义:定义在内部的函数无法直接在全局被调用
    #函数名的本质:
            就是一个变量,保存了函数所在的内存地址
    #闭包:
            内部函数包含对外部作用域而非全剧作用域名字的引用,该内部函数称为闭包函数

    推荐学习:python视频教程

    以上就是归纳总结Python函数进阶的使用方法的详细内容,更多请关注php中文网其它相关文章!

    20期PHP线上班

    声明:本文转载于:CSDN,如有侵犯,请联系admin@php.cn删除

  • 相关标签:python
  • 相关文章

    相关视频


    专题推荐