python基础-day12

day11回顾:
    函数变量:
        def 函数变量名:
            语句块:
    def f1():
        pass
    f2=f1  #f2绑定f1绑定的函数
    f2=f1() 调用后返回None
函数可以作为参数传入另一个函数
    def fx(fn):
    ...
    fx(f1) 和 fx(f1())不同
函数可以作为另一个函数的返回值
    def fy():
        return max
    def fz():
        def f2():
            pass
        return f2 

函数的嵌套定义:
python 的四个作用域:
    局部　                       L
    外部嵌套函数作用域             E
    全局(函数所在模块的作用域)      G
    内建函数作用域                B

global 语句　　　　　 (声明变量为全局变量)
nonlocal 语句       (声明变量为外部嵌套函数作用域内的变量)

lambda　表达式
    作用:
        创建匿名函数
    语法:
        lambda 形参列表:表达式
        
eval(字符串,全局变量的字典，局部变量的字典)
    返回表达式执行后的返回的对象
exec(字符串，全局变量的字典，局部变量的字典)
    把字符串当成程序来解释执行

------------------------------------------------------------------
day12:

函数式编程
    函数式编程是指用一系列函数解决问题

    函数是一等公民

    说明:
        用每一个函数完成细小的功能，一系列函数的任何组成可以解决大问题
        函数仅接受输入并产生输出，不包含任何可能影响输出的内部状态

函数的可重入性:
    当一个函数没有访问除局部变量以外的变量，则此函数为可重入函数
    示例:
        def maadd1(x,y):
        return x+y

不可重入函数:
    示例:
        s=0
        def myadd2(x,y):
            global s
            s+=x+y
            return s

高阶函数 High Order Function    
    满足下列条件中一个的函数即为高阶函数
        1.函数接受一个或多个函数作为参数传入
        2.函数返回一个函数值

    python 内建的高阶函数
        map, filter, sorted

        map函数
            map(func,*iterables)
               对可迭代对象，此可迭代对象将用func对可迭代对象iterables中的每个元素作为参数计算后得到结果,
               再返回,当最短的一个可迭代对象不再提供数据时迭代结束
            示例:
                def power2(x):
                    return x**2
                    #生成一个可迭代对象，此可迭代对象可以生成1~9的自然是的平方
                for x in map(power2,range(1,10)):
                    print(x,end=' ')
                print()
                #生成一个可迭代对象，此可迭代对象可以生成
                # 1**4 ,2**3 ,3**2,4**1
                #pow(x,y,z=None)  x**y%z
                for x in map(pow,range(1,5),range(4,0,-1)):
                    print(x,end=' ')
                print()
                for x in map(pow,[1,2,3,4],[4,3,2,1],range(4,0,-1)):
                    print(x,end=' ')
                print()
    练习:
        1**2+2**2+3**2+...+9**2的和
        print(map(power2,range(1,10)))

        1**3+2**3+3**3+...+9**3的和
        print(sum(map(lambda x:x**3,range(1,10))))

        1**9+2**8+3**7+...+9**1的和
        print(sum(map(pow,range(1,10),range(9,0,-1))))

---------------------------------------------------------
filter(筛选过滤) 函数
    filter(func,iterable)返回一个可迭代对象，此可迭代对象将对iterable获取到的数据用函数
    func进行筛选，func将对iterable中的每个元素进行求值，返回False则丢弃,返回True则保留此数据

    示例:

        def isodd(x):
            return x%2==1
        #生成1~100的奇数
        for x in filter(isodd,range(100))
            print(x)
        print()
        #生成１～100的偶数
        even =[x for  x in filter(lambda x:x%2==0,range(1,100)) ]
        print(even)

        ＃生成1~100的素数
        def isprime(x):
            if x <2:
                return False
            for i in range(2,x):
                if x%i==0:
                    return False
                else:
                    return True
        primes=[x for x in filter(isprime,range(100))]
        print(primes)

sorted函数
    作用:
        将可迭代对象的数据进行排序,生成排序后的列表
    格式:
        sorted(iterable,key=None,reverse=False)
    说明:
        iterable是可迭代对象
        key函数是用来提供比较值的函数，这个值将作为排序的依据
        reverse 标志用来设置是否降序排序
    示例:   
        l=[5,-2,-4,0,3,1]
        l2=sorted(l)
        print(l2)  　　　#默认升序[-4, -2, 0, 1, 3, 5]
        l3=sorted(l,reverse=True)　#降序　l3= [5, 3, 1, 0, -2, -4]
        print('l3=',l3)
        l4=sorted(l,key=abs) #按绝对值排序
        print(l4)

    练习:
        names=['Tom','Jerry','Spike','Tyke']
        排序的依据是'moT','yrreJ','ekipS','ekyT'
        结果是:
            ['Spike','Tyke','Tom','Jerry']

        # names=['Tom','Jerry','Spike','Tyke']
        #         排序的依据是'moT','yrreJ','ekipS','ekyT'
        #         结果是:
        #             ['Spike','Tyke','Tom','Jerry']
        names=['Tom','Jerry','Spike','Tyke']
        def fx(x):
            return x[::-1]
        print(sorted(names,key=fx))

递归函数 recursion
    函数直接或间接调用自身
    示例:
    recursion_forever.py
        def say_story():
            print('从前有座山，山里有座庙，庙里有个老和尚讲故事:')
            say_story()
            print('讲故事结束')
        say_story()
        print('程序结束')
    
    示例:
        def f1():
            f1()   #直接调用自己
        f1()
        
        函数间接调用自己
        def fa():
            fb()
        def fb():
            fa()
        fa()
    说明:递归一定要控制递归的层数,当符合一定条件时要终止递归调用
        几乎所有的递归都能用while循环来代替
    优缺点:
        优点是可以把问题简单化，让思路更为清晰，代码更简洁
        缺点是因系统环境影响大，当递归深度太大时，可能会得到不可预知的结果
    递归函数调用分为两个阶段:
    1递推阶段
        从原问题出发，按递归公式递推从未知到已知，最终到达递归终止条件
    2回归阶段
        按递归终止条件求出结果，逆向逐步代入递归公式，回归原问题求解
    示例见:recursion.py
            def fx(n):
                print('递归进入第',n,'层')
                if n==100:
                    return
                fx(n+1)   #进入下一层
                
                print('递归退出第',n,'层')
            fx(1)
            print('程序结束')


    已知有五位朋友一起
    第五位朋友说他比第四位朋友大2岁
    第四位朋友说他比第三位朋友大２岁
    第三位朋友说他比第二位朋友大２岁
    第二位朋友说他比第一位朋友大２岁
    第一位朋友说他10岁

        # 已知有五位朋友一起
        # 第五位朋友说他比第四位朋友大2岁
        # 第四位朋友说他比第三位朋友大２岁
        # 第三位朋友说他比第二位朋友大２岁
        # 第二位朋友说他比第一位朋友大２岁
        # 第一位朋友说他10岁
        def getage(n):
            if n==1:
                return 10
            return getage(n-1)+2
        print(getage(5))
-----------------------------------------
闭包 closure
    什么是闭包
        闭包是引用此函数外部变量的函数
    闭包必须满足三个条件:
        1必须有内嵌函数
        2内嵌函数必须引用外部函数中的变量
        3外部函数返回值必须是内嵌函数
    示例:
        closure.py
    用闭包来创建任意的:
    f(x)=a*x**2+b*x+c的函数
    
        def get_fx(a,b,c):
            def fx(x):
                return a*x**2+b*x+c
            return fx
        f123=get_fx(1,2,3)
        print(f123(20))
        print(f123(5))
练习:
    1编写程序求1~20的阶乘的和
    即: 1!+2!+3!+...+20!

    2.改写之前的学生信息管理系统，要求添加４个功能
        5)按学生成绩高低显示学生信息
        6)按学生成绩低高显示学生信息
        7)按学生年龄高低显示学生信息
        8)按学生年龄低高显示学生信息
    
    3.已知有列表:
    L=[[3,5,8],10,[[13,14],15,18],20]   递归做
    (1)写一个函数print_list(lst),打印出所有的数字,即:
        print_list(L)  #打印3 5 8 10 13...t
    (2)写一个函数sum_list(lst)返回这个列表中所有数字的和
        print(sum_list(L))