python基础-day11

函数变量:
    函数名是一个变量,他在创建时绑定一个函数
    示例:function variable.py
    #此函数示意函数名绑定函数,函数名是变量
        def f1():
            print('hello f1')
        def f2():
            print('hello f2')
        f1,f2=f2,f1
        f1()         #hello f2

一个函数可以作为另一个函数的实参传递
示例:
        def f1():
            print('hello f1')
        def f2():
            print('hello f2')
        def fx(fn):
            print(fn)
            fn()
        fx(f1)
                #<function f1 at 0x7f330344bf28>
                hello f1

观察下面的执行结果是什么:
    def goodbye(l):
        for x in l:
            print('再见:',x)
    def hello(l):
        for x in l:
            print('您好:',x)
    def fx(fn,l):
        fn(l)
    fx(goodbye,['Tom','Jerry','Spike'])
        再见: Tom
        再见: Jerry
        再见: Spike
------------------------------------
    示例:
        def myinput(fn):
            l=[1,3,5,7,9]
            r=fn(l)
            return r
        print(myinput(max))
        print(myinput(min))
        print(myinput(sum))

函数可以作为另一个函数的返回值
    示例:return_function
        def get_function():
            s=input('请输入您要的操作')
            if s =='求最大':
                return max
            if s =='求最小':
                return min :
            if s =="求和":
                return sum
        l=[2,4,6,8,10]
        f=get_function()
        print(f(l))
-----------------------------------
函数的嵌套定义:
    函数嵌套定义是指一个函数里用def语句来创建其他函数的情况
    示例:function_embed.py
            def fn_outter():
                print('fn_outter被调用')
                def fn_inner():
                    print('fn_inner被调用')
                fn_inner() #调用一次
                fn_inner() #调用两次
                print('fn_outter调用结束！')
                return fn_inner
            f=fn_outter()
            fn     #fn_inner被调用

--------------------------------------
python的作用域:
    作用域也叫命名空间,是访问变量时查找变量名的范围空间

python的四个作用域:
    作用域               英文                   英文简写
    局部作用域(函数内)     Local                    L
    外部嵌套函数作用域     Enclosing function local E
    函数定义所在模块作用域     Global                G
    python内建模块的作用域    Builtin               B      

    示例:
                v=100
                def f1():
                    v=200
                    print('f1.v',v)
                    def f2():
                        v=300
                        print('f2.v=',v)
                    f2()
                f1()
                print('全局的v=',v)

变量名的查找规则:
    在访问变量时,先查找本地变量,然后是包裹此函数外部的函数内部的变量，之后是全局变量
    最后是内建变量
    即:L  L--> E --> G----> B
    在默认的情况下，变量名赋值会创建或者改变本地作用域内的变量

Global语句:
    作用:
        告诉解释执行器,Global语句声明的一个或多个变量，这些变量的作用域为模块级作用域(也称全局变量)
        全局声明(Global)将赋值语句的变量映射到模块文件内部的作用域
    语法:
        global 变量1,变量2,...
    示例:global.py
                v=100
                def f1():
                    global v
                    v=200
                f1()
                print('v=',v)
    说明:
        1.全局变量如果要在函数内部被赋值,则必须经过全局声明,否则被认为是局部变量
        2.全局变量在函数内部不经过全局声明就可以访问(取值)
        3.不能先声明局部变量,再用global声明为全局变量,此做法不符合规则
        4.global变量列表里的变量名不能出现在函数的形参列表里
    
    练习:
        写一个函数hello，部分代码如下:
                count=0
                def hello(name):
                    print('您好',name)
                    global count
                    count+=1
                hello('Tom')
                hello('Jerry')
                hello('Jerry')
                print('hello函数被调用%d次' % count)
---------------------------------------------------
nonlocal语句:
    作用:
        告诉解释执行器,nonlocal声明的变量不是局部变量,也不是全局变量,而是外部嵌套函数内的变量
        语法:
            nonlocal 变量名1,变量名2,...
        示例:nonlocal,py 
                var=100
                def f1():
                    var=200
                    print('f1.var=',var)
                    def f2():
                        nonlocal var
                        var=300
                        print('f2.var=',var)
                    f2()
                    print('f1.var=',var)
        说明:
            1.nonlocal 语句只能嵌套函数内部进行使用,对nonlocal变量列表内的变量赋值将对外部嵌套
            2.函数作用域内的变量进行操作
            3.当有两层或两层以上函数嵌套时,访问nonlocal变量只对最近的一层变量进行操作
            4.nonlocal语句变量列表里的变量名，不能出现在此函数的形参列表中
--------------------------------------------------------------------------------------------
lambda 表达式
    作用:
        创建一个匿名函数对象,同def类似,但不提供函数名
    语法:
        lambda[函数形参列表]:表达式
    示例:lambda.py
            myadd=lambda x,y:x+y      
            myadd=lambda *args:sum(args)
    说明:
        lambda 表达式创建的函数只能包含一条表达式且直接返回表达式的值
        lambda比函数简单，且可以随时创建和销毁，有利于减少程序的偶合度

    练习：
        1.写一个lambda表达式:
            fx=lambda n:
            此函数判断n的平方＋１能否被５整除，能，返回True，否则返回False
            fx=lambda n: (n**2+1)%5==0
            print(fx(3))
            print(fx(4))

        2.写一个lambda表达式来创建函数,此函数返回两个形参变量的最大值
            # def mymax(x,y):
            #     return(max(x,y))
            mymax=lambda x,y: max(x,y)
            print(mymax(100,200))
            print(mymax('ABC','123'))
--------------------------------------------------------------
eval()和exec()函数

    eval() 函数
        作用:
            把一个字符串当表达式来执行,返回表达式执行后的结果
        格式:
            eval(source,global=None,local=None)
        示例:
            s="1+2*3"
            v=eval(s)   # v=7
            print(v)
        
        示例:eval.py
            x=100
            y=200
            s="x+y"
            v=eval(s)
            print(v)  #300
            #假设局部作用域内有 x=1;y=2
            v2=eval(s,None,{'x':1,'y':2})
            print(v2) #3
            #设置局部作用域内有y=2,全局作用域:x=1=,y=20
            v3=eval(s,{'x':10,'y':20},{'y':2})
            print('v3=',v3)   #12
        exec 函数
            作用:
                把一个字符串当程序来执行
            格式:
                exec(source,g))
            示例:
                s="x=100\ny=200\nprint('x+y=',x+y)"
                exec(s)


练习:
    1.看懂下面的程序在做什么
    def fx(f,x,y):
        print(f(x,y))
    fx((lambda a,b:a+b),100,200)
    fx((lambda a,b:a**b),3,4)
    
    2.给出一个整数n,写一个函数来计算
    1+2+3+4+...+n的值并返回结果，要求用函数来做
    如：
        def mysum(n):
            ...
        print(mysum(100))  #5050
        print(mysum(10))   #55
    
    3.给出一个整数n，写一个函数来计算n!(n的阶乘)
        n!=1*2*3*4*...*n
        def myfac(n):
        ...
        print(myfac(5))  #120

    4.给一个整数n，写一个函数来计算1+2**2+3**3+...+n**n的和
    　
    5.写程序打印杨辉三角(只打印６层)
            1
           1 1
          1 2 1
         1 3 3 1
        1 4 6 4 1
      1 5 10 10 5 1


    6.实现带界面的学生信息管理系统的项目

    +----------------------------+
    | 1)添加学生信息               |
    | 2)显示学生信息               |
    | 3)删除学生信息               |
    | 4)修改学生成绩               |
    | q)退出                  　  |
    +----------------------------+
    (用函数来实现,每个功能写一个函数写之相对应)