zoukankan      html  css  js  c++  java
  • Python之函数进阶

    一、三元表达式:

    a = 20

    b = 10

    c = a if a>b else 10

    #三元运算
    # a = 20
    # b = 10
    # if a > b:
    #     c = a
    # else:
    #     c = 10
    
    #if条件成立的结果 if 条件 else else条件成立的结果
    # a = 20
    # b = 10
    # c = a if a>b else 10
    # print(c)

    二、命名空间:

        命名空间分为:

        全局命名空间

        局部命名空间

        内置命名空间

    命名空间的加载顺序:(硬盘加载到内存)

        先内置命名空间 --> 再全局命名空间(从上到下顺序加载) --> 再局部命名空间(再被调用的时候加载)

    *内置命名空间中存放了python解释器为我们提供的名字:input,print,str,list,tuple...它们都是我们熟悉的,拿过来就可以用的方法。

    取值:

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

    在局部使用变量取值情况
    x = 1 def f(x): print(x) print(10)

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

    在全局引用变量x
    x = 1 def f(x): print(x) f(10) print(x)
    在全局引用内置max
    print
    (max)

     假如有一个函数,实现返回两个数中的较大值:

    def my_max(x,y):
        m = x if x>y else y
        return m
    bigger = my_max(10,20)
    print(bigger)

    之前是不是我告诉你们要把结果return回来你们就照做了?可是你们有没有想过,我们为什么要把结果返回?如果我们不返回m,直接在程序中打印,行不行?

    >>> def my_max(x,y):
    ...     m = x if x>y else y
    ... 
    >>> my_max(10,20)
    >>> print(m)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    NameError: name 'm' is not defined

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

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

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

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

     注意:局部可以使用全局的,但是全局不能使用局部的。

    三、作用域和函数的嵌套 

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

    命名空间和作用域是分不开的。

    命名空间是一个虚构的东西。

    命名空间是因为作用域的划分,才产生的。

    命名空间的本质:存放名字与值的绑定关系

    作用域只分为两种:

        全局作用域:全局命名空间、内置命名空间

        局部作用域:局部命名空间

    在全局看:有变量用全局的,没有就用内置的。包含内置名称空间、全局名称空间,在整个文件的任意位置都能被引用、全局有效

    在局部看:局部名称空间,只能在局部范围生效

    为什么要有作用域的概念:

      为了函数内的变量不会影响到全局的变量。

    globals和locals方法:

    在全局调用globals和locals
    print(globals())
    print(locals())
    在局部调用globals和locals
    def func():
        a = 12
        b = 20
        print(locals())
        print(globals())
    
    func()

    global关键字

    a = 10
    def func():
        global a
        a = 20
    
    print(a)
    func()
    print(a)

     函数的嵌套调用和作用域链: 

    def f1():
        print('f1')
    
    def f2():
       a = 10 f1()

    函数f2可以调用f1的函数。但是f2里的变量a,在f1里是不可以用的。

    函数的嵌套:

    tiger是内部函数

    为了保护内部函数,确定内部函数只能在外部函数中被调用。

    def animal():          #1
        def tiger():       #3
            print("bark")  #6
        print("eat")       #4
        tiger()            #5
    animal()               #2
     1 def max2(x,y):
     2     m  = x if x>y else y
     3     return m
     4 
     5 def max4(a,b,c,d):
     6     res1 = max2(a,b)
     7     res2 = max2(res1,c)
     8     res3 = max2(res2,d)
     9     return res3
    10 
    11 # max4(23,-7,31,11)
    函数的嵌套调用

    函数的嵌套定义

    1 def f1():
    2     print("in f1")
    3     def f2():
    4         print("in f2")
    5 
    6     f2()
    7 f1()
    函数的嵌套定义(一)
     1 def f1():
     2     def f2():
     3         def f3():
     4             print("in f3")
     5         print("in f2")
     6         f3()
     7     print("in f1")
     8     f2()
     9     
    10 f1()
    函数的嵌套定义(二)

    函数的作用域链

    1 def f1():
    2     a = 1
    3     def f2():
    4         print(a)
    5     f2()
    6 
    7 f1()
    作用域链(一)
    1 def f1():
    2     a = 1
    3     def f2():
    4         def f3():
    5             print(a)
    6         f3()
    7     f2()
    8 
    9 f1()
    作用域链(二)
    1 def f1():
    2     a = 1
    3     def f2():
    4         a = 2
    5     f2()
    6     print('a in f1 : ',a)
    7 
    8 f1()
    作用域链(三)

    nonlocal关键字

    # 1.外部必须有这个变量
    # 2.在内部函数声明nonlocal变量之前不能再出现同名变量
    # 3.内部修改这个变量如果想在外部有这个变量的第一层函数中生效

    1 def f1():
    2     a = 1
    3     def f2():
    4         nonlocal a
    5         a = 2
    6     f2()
    7     print('a in f1 : ',a)
    8 
    9 f1()
    nonlocal关键字

     nonlocal  外部必须有这个变量。

         内部修改这个变量如果想在外部有这个变量的第一层函数中生效。

         在函数内部声明nonlocal变量之前,不能再出现同名变量。

    四、函数名的本质:

      就是一个变量,指向一个内存地址。

    1.可以被引用

    1 #函数被引用
    2 def func():
    3     print('in func')
    4 
    5 f = func
    6 print(f)

    2.可以被当作容器类型的元素

     1 #函数被当作容易类型的元素
     2 def f1():
     3     print('f1')
     4 
     5 
     6 def f2():
     7     print('f2')
     8 
     9 
    10 def f3():
    11     print('f3')
    12 
    13 l = [f1,f2,f3]
    14 d = {'f1':f1,'f2':f2,'f3':f3}
    15 #调用
    16 l[0]()
    17 d['f2']()

    3.可以当作函数的参数和返回值

    *不明白?那就记住一句话,就当普通变量用

    1 #第一类对象的概念
    2 第一类对象(first-class object)指
    3 1.可在运行期创建
    4 2.可用作函数参数或返回值
    5 3.可存入变量的实体。

    可用作函数的参数

    def func():
        print("func")
    def func2(f):
        print(f)
        print("func2")
    
    func2(func)

    可用作函数的返回值

    func2()里的实参是func,形参是f。当想调用func()或fu时,可以fu()或func1()。

    def func():
        print("func")
    def func2(f):
        print("func2")
        return f
    
    func2(func)      #将func函数作为参数,传给func2函数的f。在返回f,这个f就是func的print。
    fu = func2(func)
    print(fu)
    fu() #=====>func()
    def func():
        def func2():
            print("hello")
        return func2
    
    func2 = func()
    func2()
    #定义一个函数func,在函数func里嵌套func2,执行func函数,并赋予新的变量func2。
    #执行func函数,就是定义函数func2,在返回func2。
    #所以变量func2等于函数func2()
    #在执行func2(),就可以调用到func2函数。

    如果在全局使用内部函数的函数,该如何实现。

     作用域:

      小范围可以用大范围的

      但是,大范围的不能用小范围的。

      如果在小范围内,要用的变量在小范围内自己有,就用自己的,要是没有,就用上一级范围的。

      如果都没有,就报错吧~~~~~~~!

    五、闭包

    闭包函数:内部函数,包含了对外部作用域中变量的引用。

    def func():
        x = “闭包”       
        def inner():
            print(x)
    
    函数inner就是闭包

    闭包:

      闭:白话就是不是开放的内部函数。

      包:包含外部函数的变量,不用自己函数的变量。

    简单说:函数inner里如果有一个变量x = 1,那么print(x)的结果就不是闭包俩字,而是数字1。

    那么既然函数inner自己有变量,而不需去外部函数中获取变量,那么这个inner函数就不是闭包了。

    闭包函数:

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

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

    我们都知道函数内的变量我们要想在函数外部用,可以直接返回这个变量,那么如果我们想在函数外部调用函数内部的函数呢?

    是不是直接就把这个函数的名字返回就好了?

    这才是闭包函数最常用的用法

    闭包的简单理解,就是封闭的一个包。

    闭包的常用形式: 

    def haha():
        x= '闭包'
        def inner():
            print(x)
        return inner
    i = haha()
    i()

    函数haha执行,调用haha(),拿到一个返回值inner,返回值inner是函数inner的内部内存地址。

    在调用i()就是执行inner函数。

    这么做是因为,在内存中,我们创建一个函数,就会在内存中开辟一个内存空间,放这个函数的值,在这个函数执行完,这个内存空间就会被释放。当在想去调用这个函数里的值得时候。就会出现找不到值得情况。

    而闭包,在inner函数中的print(x)在用着外层函数的x = ‘闭包’。这样的话,变量x就能被暂时保存住,不会被释放。

    i()就相当于一个全局的了。致使inner函数从一个局部函数,变为了一个全局的函数。

    判断闭包函数的方法__closure__

    #输出的__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()
    def wrapper():
        money = 1000
        def func():
            name = 'eva'
            def inner():
                print(name,money)
            return inner
        return func
    
    f = wrapper()
    i = f()
    i()
    
    闭包嵌套
    from urllib.request import urlopen
    
    def index():
        url = "http://www.xiaohua100.cn/index.html"
        def get():
            return urlopen(url).read()
        return get
    
    xiaohua = index()
    content = xiaohua()
    print(content)
    
    闭包函数获取网络应用

     本章小结

    命名空间:

      一共有三种命名空间从大范围到小范围的顺序:内置命名空间、全局命名空间、局部命名空间

    作用域(包括函数的作用域链):

    小范围的可以用大范围的
    但是大范围的不能用小范围的
    范围从大到小(图)

    在小范围内,如果要用一个变量,是当前这个小范围有的,就用自己的
    如果在小范围内没有,就用上一级的,上一级没有就用上上一级的,以此类推。
    如果都没有,报错

    函数的嵌套:

      嵌套调用

      嵌套定义:定义在内部的函数无法直接在全局被调用

    函数名的本质:

      就是一个变量,保存了函数所在的内存地址

    闭包:

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

  • 相关阅读:
    JeePlus:代码生成器
    JeePlus:API工具
    Java实现 洛谷 P1023 税收与补贴问题
    Java实现 洛谷 P1023 税收与补贴问题
    Java实现 洛谷 P1023 税收与补贴问题
    Java实现 洛谷 P1328 生活大爆炸版石头剪刀布
    Java实现 洛谷 P1328 生活大爆炸版石头剪刀布
    Java实现 洛谷 P1328 生活大爆炸版石头剪刀布
    Java实现 洛谷 P1328 生活大爆炸版石头剪刀布
    Java实现 洛谷 P1328 生活大爆炸版石头剪刀布
  • 原文地址:https://www.cnblogs.com/george92/p/8580305.html
Copyright © 2011-2022 走看看