python全栈开发-Day9 函数对象、函数嵌套、名称空间与作用域

时间：2024-04-11 20:03:35

一 、函数对象

一 、函数是第一类对象，即函数可以当作数据传递

  可以被引用

  可以当作参数传递

  返回值可以是函数

  可以当作容器类型的元素

二、 利用该特性，优雅的取代多分支的if

 def foo():

     print('foo') 

 def bar():

     print('bar')

 dic={

     'foo':foo,                   #foo是内存地址

     'bar':bar,                   #bar是内存地址

 }

 while True:

     choice=input('>>: ').strip()

     if choice in dic:

         dic[choice]()

二 、函数嵌套

一 、函数的嵌套调用

　　在函数内又调用了其他函数

 def max(x,y):

     return x if x > y else y

 def max4(a,b,c,d):

     res1=max(a,b)

     res2=max(res1,c)

     res3=max(res2,d)

     return res3

 print(max4(1,2,3,4))

二 、函数的嵌套定义

　　在函数内又定义其他函数

 def f1():

     def f2():

         def f3():

             print('from f3')

         f3()

     f2()

 f1()

 f3() #报错，外部无法调用，可以考虑如何在外面使用函数里面的功能

三 、名称空间与作用域

一 、什么是名称空间？

名称空间：存放名字的地方，三种名称空间，（之前遗留的问题x=1，1存放于内存中，那名字x存放在哪里呢？名称空间正是存放名字x与1绑定关系的地方）

二、名称空间的分类

#1、内置名称空间：

#存放python解释器自带的名字,在解释器启动时就生效,解释器关闭就失效.

#2、全局名称空间:

#文件级别的名字,在执行文件的时候生效,在文件结束或者文件执行期间被删除则失效

#3、局部名称空间：

#在函数内定义的名字,(函数的参数以及函数内的名字都存放与局部名称空间),在函数调用时临时生效，函数结束则失效

三 、名称空间的加载顺序（内置>全局>局部）

python test.py

#1、python解释器先启动，因而首先加载的是：内置名称空间

#2、执行test.py文件，然后以文件为基础，加载全局名称空间

#3、在执行文件的过程中如果调用函数，则临时产生局部名称空间

四 、名字的查找顺序 （局部>全局>内置）

#局部名称空间--->全局名称空间--->内置名称空间

#需要注意的是：在全局无法查看局部的，在局部可以查看全局的，如下示例

# max=1

def f1():

    # max=2

    def f2():

        # max=3

        print(max)

    f2()

f1()

print(max)

五 、作用域

#1、作用域

        #全局作用域（包含的是内置名称空间与全局名称空间的名字）：

        #特点：

                 #1、在任何位置都能够访问的到

                 #2、该范围内的名字会伴随程序整个生命周期

                 #（全局存活，全局有效）

　     # 局部作用域（局部名称空间的名字）：

        #特点：

                 #1、只能在函数内使用

                 #2、调用函数时生效，调用结束失效

                 #（临时存活，局部有效）

#2、作用域关系是在函数定义阶段就已经固定的，与函数的调用位置无关，如下

x=1

def f1():

    def f2():

        print(x)

    return f2

x=100

def f3(func):

    x=2

    func()

x=10000

f3(f1())

#3、查看作用域：globals(),locals()

LEGB 代表名字查找顺序: locals -> enclosing function -> globals -> __builtins__

locals 是函数内的名字空间，包括局部变量和形参

enclosing 外部嵌套函数的名字空间（闭包中常见）

globals 全局变量，函数定义所在模块的名字空间

builtins 内置模块的名字空间

四、 闭包函数

一、 什么是闭包？

#定义在函数内部的函数,并且该函数包含对外部函数作用域中名字的引用

该函数就是闭包函数

#提示：之前我们都是通过参数将外部的值传给函数，闭包提供了另外一种思路，包起来喽，包起呦，包起来哇

def outter():

    x=2

    def inner():

        # x=1

        print("from inner",x)

    return inner

f =outter()

f()           #x值为2

二 、闭包的意义与应用

#闭包的意义：返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域

#应用领域：“爬虫“（原来我们是传参，现在我们是包起来）

import requests                  

def outter(url): #url='https://www.baidu.com'

    def get():

        response=requests.get(url)

        if response.status_code == 200:

            print(response.text)

    return get

baidu=outter('https://www.baidu.com')

python=outter('https://www.python.org')

baidu()

python()

相关文章