Python学习日记day10------函数的命名空间、作用域与闭合函数

1,参数陷阱

如果默认参数的只是一个可变数据类型，那么每一次调用的时候，如果不传值就共用这个数据类型的资源。

2,三元运算

c=a if a>b else b#如果a》b返回a，否则，返回b

变量 =条件返回True的结果 if 条件 else 条件返回False的结果

必须要有结果

必须要有if和else

只能是简单的情况

def func(a,b):

a if a>b else b

print(func(5,1))

3,命名空间与作用域

3.1命名空间的种类

命名空间有三种

内置、全局与局部

3.1.1#内置命名空间-----python解释器

#就是python解释器一启动就可以使用的名字存储在内置命名空间中

#内置的名字在启动解释器的时候被加载进内存里

3.1.2#全局命名空间----我们写的代码但不是函数中的代码

#是在程序从上到下被执行的过程中一次被执行进内存的

#放置了我们设置的所有变量名和函数名

3.1.3#局部命名空间----函数

#就是函数内部定义的名字（定义在函数里的名字）

#当调用函数的时候在会产生这个名称空间，随着函数执行的结束，这个命名空间就又消失了。

　#在局部：可以使用全局、也可以使用内置命名空间中的名字

　 #在全局：可以使用内置命名空间中的名字，但不能使用局部命名空间中的名字

　 #在内置：不能使用局部和全局的名字的

　3.1.4内置命名空间、全局命名空间与局部命名空间的关系：

依赖倒置原则：上层模块应该依赖下层模块，不能反向依赖

在正常情况下，直接使用内置的名字。

当我们在全局定义了和内置名字空间中同名的名字时，会使用全局的名字。

当只有的时候，就不会找上一级要

如果自己没有就找上一级要

如果上一级没有，就再向上一级要

多个函数拥有多个独立的局部明明空间，不互相共享

def input():

    print('in input now')

def func():

    input()

func()

4,作用域有两种

　　全局作用域与局部作用域

　　#全局作用域--->作用在全局----内置和全局名字空间中的名字都属于全局作用域--globals()

#局部作用域--->作用在局部----函数（局部名字空间中的名字属于局部作用域-----locals()

a =1

def func():

    global a

    a+=1

func()

print(a)

#对于不可变数据类型在局部可以查看全局作用域中的变量，但是不能直接修改

#如果想要修改需要在程序的一开始添加global声明

#如果在一个局部内（函数）内声明了一个global变量，这个变量在局部的所有操作将对全局变量有效

# a = 1

# b = 2

# def func():

#     x = 'aaa'

#     y = 'bbb'

#     print(locals())

#     print(globals())

#

# func()

# print(globals())

# print(locals())  #本地的--->在函数体的外部使用locals，作用与globals是相同的

#globals 永远打印全局的名字

#locals输出什么根据locals所以在的位置

a =1

b =2

print(globals())

print(locals())

5，函数的嵌套调用

def max(a,b)

    return a if a>b else b

def the_max(x,y,z):

    c =max(x,y)

    return max(c,z)

print(the_max(1,2,3))

在一个函数的函数体内调用另一个函数叫做函数的嵌套调用

6，函数的嵌套定义

内部函数可以使用外部函数的变量叫做函数的嵌套

def outer():

    def inner():

        print('inner')

        def inner2():

            a+=1 #不可变数据类型的修改

            print(a,b)

            print('inner2')

        inner2()

    inner()

outer()

def outer():

    a =1

    def inner():

        b =2

        print(a)

        print('inner')

        def inner2():

            a+=1

            print('inner2')

        inner2()

    inner()

    print('**a**:',a)

outer()

6.1nonlocal a #声明了一个上面第一层局部变量

a =1

def outer():

    a=1

    def inner():

        b=2

        print(a)

        print('inner')

        def inner2():

            nonlocal a

            a+=1

        inner2()

    inner()

    print('**a**:',a)

outer()

print('全局：'，a)

#nonlocal 只能用于局部变量，找上层中离当前函数最近一层的局部变量

#声明了nonlocal的内部函数的变量修改会影响到离当前函数最近一层的局部变量

对全局无效

对局部也只对最近的一层有影响

7,作用域链

在内部函数适用变量的时候，是从小局部到大局部到全局到内置名字的过程，一级一级往上找，找到最近的一个就使用一一作用域链

a =0

def outer():

    def inner():

        def inner2():

            print(a)

        inner2()

    inner()

outer()

函数名的本质--------第一类对象

7.1函数名可以赋值

def func():

　　print(123)

func2 =func

func2()

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

def func():

    print(123)

func()  #函数名就是内存地址

func2 = func  #函数名可以赋值

func2()

l = [func,func2] #函数名可以作为容器类型的元素

print(l)

for i in l:

     i()

7.3函数名可以作为函数的参数和返回值：

def func():

    print(123)

def wahaha(f)

    f()

wahaha(func)

7.4函数名可以作为函数的返回值

def func():

    print(123)

def wahaha(f)

    f()

    return f

qqxing =wahaha(func)

qqxing()

8,闭包：嵌套函数，且内部函数要调用外部函数的变量

def outer():

    a =1

    def inner():#--->inner是一个闭包

        print(a)

    print(inner._closure_)

outer

常见的闭包函数形式

def outer():

    a =1

    def inner():#--->inner是一个闭包

        print(a)

    return inner

outer

inn =outer()

inn()

在一个函数的外部调用内部的函数

闭包函数应用：

def get_url():

   urlopen('http://www.xiaohua100.cn/index.html').read()

   def inner():

        ret = urlopen(url)

        print(ret)

    return inner

get_func =get_url()

get_func()

巴特西