day10 python学习 函数的嵌套命名空间作用域 三元运算 位置参数 默认参数 动态参数

1、三元运算

#1.三元运算
利用已下方法就可以实现一步运算返回a b中大的值
def my_max(a,b):
    c=0
    a=int(input('请输入'))
    b=int(input('请输入'))
        # if a>b:
        #     c=a
        # else:
        #     c=b
    #或者这样
    c = a if a > b else b
    return c
ret=my_max(1,3)
print(ret)

2.补充上节差的知识点

形参：

#位置参数

#默认参数（关键字参数）

#动态参数

     *args:接收说有按照位置传递的参数，接收到的是参数是组成的元祖

     *kwargs:接收所有按关键字传递的参数，接收到的是参数组成的字典

这次讲的是动态参数

参数的排序    如果各种参数都在函数中使用，就要以以下的形式排序

def func3(a,b,c,*args,key='key',**kwargs):

#2.动态参数
def func(a,b,c,*args,key="key"):  #在参数前面加一个* 这个参数就变成了动态参数
    print(a,b,c)                   #默认参数放在动态参数后边
    print(key)               #参数
    print(args)
set=func(1,2,3,'sd',11,22,33,key='aaa')
以下是返回值
# 1 2 3   #前边这三个必须有，少一个都不能
# aaa   #返回的就是此次的正常结果
# ('sd', 11, 22, 33)  使用的时候，所有传入的值都被组织成元祖的形式

#动态参数2  **kwargs的用法
def func3(a,b,c,*args,key='key',**kwargs):
    print(a,b,c,)
    print(key)
    print(args)
    print(kwargs)
set=func3(1,2,3,'sdash',key='www',x=3,y='alex') #这里最后的kwargs要注意不要写成与
以下是返回值                                     #前边的形参的关键字参数有重复                     
                                                #如不能在后写成a="alex"会报错
# 1 2 3
# www
# ('sdash',)
# {'x': 3, 'y': 'alex'}    #kwargs这个传入的值都会组织成字典的形式

#4魔性用法
def func4(*args):
    print(args)
li=[1,2,3,4,5]
# func4(li) #  得到以下结果
#([1, 2, 3, 4, 5],)  直接将列表传递到函数的话，他会直接弄成一个大的元祖
func4(*li)  #结果如下  在列表名前加一个*就是打散的意思，这样可以一一是放在元祖中去
#(1, 2, 3, 4, 5)       也有**dic的用法  

关键字参数

关键字参数有什么用？在程序比较繁琐的时候，参数顺序是很难能记住的，为了让程序简单不出错，会为参数起一个名字，这就是关键字参数的作用。好比下面这个函数：
>>>def x(name,Profession):
>>>    return '%s is %s' %(name,Profession)
>>>print x(name='Amy',Profession='Student')
Amy is Student

>>>print x(Profession='Student',name='Amy')
Amy is Student
第二次调用x函数时，虽然传参数时把参数位置调换了，但结果还是没有变。这是因为把参数名与值绑定在一起，使用参数名提供的参数叫做关键字参数。
关键字参数还有一个特殊的作用，就是可以在定义函数时设置关键字参数默认值：
>>>def info(name='Amy',Profession='Student'):
>>>    return '%s is %s' %(name,Profession)
>>>print info()
Amy is Student
在函数设置了参数默认值是，调用的时候可以不传入参数了。当然你也可在传入一个或是所有的新参数：
>>>print info('lili')
lili is Student

>>>print info('lili','Teacher')
lili is Teacher

3.命名空间

在这里我们首先回忆一下python代码运行的时候遇到函数是怎么做的。

从python解释器开始执行之后，就在内存中开辟了一个空间

每当遇到一个变量的时候，就把变量名和值之间的对应关系记录下来。

但是当遇到函数定义的时候解释器只是象征性的将函数名读入内存，表示知道这个函数的存在了，至于函数内部的变量和逻辑解释器根本不关心。

等执行到函数调用的时候，python解释器会再开辟一块内存来存储这个函数里的内容，这个时候，才关注函数里面有哪些变量，而函数中的变量会存储在新开辟出来的内存中。函数中的变量只能在函数的内部使用，并且会随着函数执行完毕，这块内存中的所有内容也会被清空。

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

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

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

命名空间和作用域

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

命名空间一共分为三种：

　　全局命名空间    写在函数外的变量名

　　局部命名空间  每个函数都有自己的命名空间

　　内置命名空间  Python解释器启动之后就可以使用的名字

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

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

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

取值：

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

4.作用域

 全局作用域

局部作用域

 

 

 

nonlocal的用法，和他的作用
n=2
def func():
    n=4
    def func2():
        nonlocal n #想要引用上一层的并改变他得值就得用nonlocal这个，如果只是引用不用nonlocal n
        n +=1
    func2()
    print(n)     #运行程序打印的是5  说明上一层的n=1在最下层被修改成功了
func()

内层函数想要改变全局变量中的n的值的话就要用global 来引入全局变量
n=2
def func():
    n=4
    def func2():
        global n#想要引用全局变量的并改变他得值就得用这个，如果只是引用不用nonlocal n
        n +=1
    func2()
    print(n)     #运行程序打印的是4  说明上一层的n=4没有被改变
func()
print(n)       #运行结果还是3  说明只是改变了全局变量n=2的值

 

 

 

函数的嵌套

 

输出的结果

 

 输出结果是  我是qqxing

 

 

本章小结

命名空间：

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

作用域（包括函数的作用域链）：

小范围的可以用大范围的
但是大范围的不能用小范围的
范围从大到小（图）

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

函数的嵌套：

　　嵌套调用

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

函数名的本质：

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

闭包：

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