Python学习之路_day_10(函数的嵌套\作用域)

• 函数嵌套

1. 函数的嵌套调用：在函数内又调用了其他函数

def max2(x,y):

    if x > y:

        return x

    else:

        return y

 

def max3(x,y,z):

    res1=max2(x,y)

    res2=max2(res1,z)

    return res2

 

print(max3(11,199,2))

 

1. 函数的嵌套定义：在函数内又定义其他函数

def func1():

    print('from func1')

    def func2(): #func2=内存地址

        print('from func2')

 

    print(func2) #<function func1.<locals>.func2 at 0x0000024907A098C8>

    func2()

 

func1()

 

def f1():

    print('f1')

    def f2():

        print('f2')

        def f3():

            print('f3')

        f3()

    f2()

f1()

 

• 名称空间与作用域

1. 名称空间：存放名字与值绑定关系的地方

 

1. 名称空间分为三类

1. 内置名称空间：存放python解释器自带的名字，在解释器启动时就生效，解释器关闭则实效

2. 全局名称空间：文件级别的名字，在执行文件的时候生效，在文件结束或者文件执行期间被删除则失效（del func）（不是内置，局部名称空间（函数里的））

3. 局部名称空间：存放函数内定义的名字（函数的参数以及函数内的名字都存放与局部名称空间），在函数调用时临时生效，函数结束则实效

 

   加载顺序： 内置名称空间-》全局名称空间-》局部名称空间

   查找名字： 局部名称空间-》全局名称空间-》内置名称空间

 

3. 作用域

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

特点： 在任何位置都能够访问的到；该范围内的名字会伴随程序整个生命周期

 

局部作用域：包含的是局部名称空间的名字

特点：只能在函数内使用；调用函数时生效，调用结束失效

 

• 函数对象

函数在python中是第一类对象

1. 可以被引用

def func():

    print('from func')

f=func

 

1. 可以当作参数传入

def bar(x):

    print(x)

    x()

bar(func)

 

1. 可以当作函数的返回值

def bar(x): # x=func

    return x #return func

res=bar(func) #res=func

# print(res)

res()

 

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

def auth():

    print('登陆。。。。。')

 

def reigster():

    print('注册。。。。。')

 

def search():

    print('查看。。。。')

 

def transfer():

    print('转账。。。。')

 

def pay():

    print('支付。。。。')

 

dic={

    '1':auth,

    '2':reigster,

    '3':search,

    '4':transfer,

    '5':pay

}

 

# print(dic)

# dic['2']()

 

def interactive():

    while True:

        print("""

        1 认证

        2 注册

        3 查看

        4 转账

        5 支付

        """)

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

        if choice in dic:

            dic[choice]()

        else:

            print('非法操作')

 

interactive()

 

• 闭包函数

闭：指的是定义在函数内部的函数

作用域关系：在函数定义阶段就规定死了，与调用位置无关

def outter():

    x=2

    def inner():

        x=1

        print('from inner',x)

    return inner

f=outter() #f=inner

def foo():

    x=1111

    f()

 

foo()

##以上结果返回1；若x=1被注释，返回2；若x=2亦被注释，报错，x=1111不会被引用，因为它在foo的局部里。

 

闭包函数：

定义在函数内部的函数；并且该函数包含对外部函数作用域中名字的引用，该函数就成为闭包函数

def outter():

    name='egon'

    def inner():

        print('my name is %s' %name)

    return inner

f=outter()

 

为函数体传值的方式（了解）

方式一：将值以参数的形式传入

import requests

def get(url):

    response=requests.get(url)

    if response.status_code == 200:

        print(response.text)

get('https://www.baidu.com')

 

方式二：闭包函数

import requests

import time

 

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

 

    # 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()

print('=====================>')

time.sleep(3)

baidu()