Python学习笔记——函数

函数（function）
1.1
    def MyFirstFunstion():
        print('这是我的第一次编写函数')
    
    MyFirstFunstion()
1.2    参数
    def MySecondFunstion(name):
        print(name + 'I Love You')
    
    MySecondFunstion('凯')
    
    凯I Love You
1.3    返回值
    def add(num1,num2):
        return (num1 + num2)

    print(add(1,2))

    3
2.1    形式参数和实际参数
     def MyFirstFunstion(name):
        '函数定义过程中的name是叫形参'
        #因为Ta只是一个形式，表示占据一个参数位置
        print('传递进来的' + name + '叫做实参，因为Ta是具体的参数值！')

    MyFirstFunstion('凯')
    
    传递进来的凯叫做实参，因为Ta是具体的参数值！
2.2    函数wendang
    MyFirstFunstion.__doc__
    help(MyFirstFunstion)
2.3    关键字参数：关键字用于过多函数时顺序错误时，print()不受顺序影响
    def SaySome(name,words):
        print(name + '-->' + words)
    
    SaySome('凯','或')
        
    凯-->或
2.4    默认参数：当没有输入参数时采用默认参数，不会报错
    def SaySome(name='凯',words='或'):
        print(name + '-->' + words)
    
    SaySome()
        
    凯-->或
    
    SaySome('和')

    和-->或
2.5    收集参数
    def test(*params):
        print('参数的长度是：',len(params));
        print('第二个参数是：',params[1]);

    test(1,'开开',4,7,10)
    
    参数的长度是： 5
    第二个参数是： 开开
2.6    变量的可见性
    局部变量（Local Variable）与全局变量(Global Variable)
    在函数内部可以肆无忌惮的去访问一个全局变量，但修改全局变量的话可能会奇怪的事发生
    #在这里，函数里边的所有变量称为局部变量，函数以外的变量称为全局变量。
    #不要在函数里边去修改全局变量的值。在函数里给全局变量赋值，相当于是创建了一个与全局变量
    #  一样的局部变量的变量名，不会影响全局变量的赋值。
    def discounts(price,rate):
        final_price = price * rate
        #print('这里试图打印全局变量的值old_price:',old_price)
        old_price = 50
        print('修改后的全局变量值1：',old_price)
        return final_price

    old_price = float(input('请输入原价：'))
    rate = float(input('请输入折扣率:'))
    new_price = discounts(old_price,rate)
    print('修改后的全局变量值2：',old_price)
    print('打折后的价格是：',new_price)
2.7    如果必须在函数里修改全局变量，使用关键字——global
    def Myfirst():
        global conut
        conut = 10
        print(conut)
    #global关键字后加上需要修改的全局变量，就可以生效
3    内嵌函数和闭包
    3.1    内嵌函数：允许在函数内部创建函数，进行嵌套函数
                内部函数作用率都在外部函数之内
            def fun1():
                print('fun1()正在调用...')
                def fun2():
                    print('fun2()正在调用...')
                fun2()

                
            >>> fun1()
            fun1()正在调用...
            fun2()正在调用...
    3.2    闭包：如果在一个内部函数里对外部作用率（但不是在全局作用率)的变量进行引用
            那么内部函数就会被认为闭包（closure）
            def fun1(x):
                def fun2(y):
                    return x *  y
                return fun2

            >>> fun1(2)(4)
            8
            >>> i = fun1(2)
            >>> type(i)
            <class 'function'>
            >>> i(4)
            8
    
        通过容器屏蔽掉局部变量，例如列表（Python2没有直接的解决的办法）
             def fun3():
                x = [5]
                def fun4():
                    x[0] *= x[0]
                    return x[0]
                return fun4()

            >>> fun3()
            25
    
        Python3通过nonlocal解决fun4中x没有定义之前进行引用
                            因为fun4相对于fun3来说，fun3中x相当于是一个全局变量
                            （非全局变量的外部变量）不能被修改，会被自动屏蔽掉。
                            所以引出nonlocal，用法和gloabl一样
            def fun3():
                x = 5
                def fun4():
                    nonlocal x
                    x *= x
                    return x
                return fun4()

            >>> fun3()
            25
4.    lambda表达式
    4.1    使用lambda创建匿名函数
        def ds(x,y):
            return y * x + 1

        >>> ds(5,2)
        11
        >>> lambda x : y * x + 1#冒号左边为参数，右边为表达式
        <function <lambda> at 0x0000000002FE37B8>
        >>> g = lambda x,y : y * x + 1
        >>> g(5,2)
        11
    4.2    重要作用
            Python写一些执行脚本时，使用lambda可以省下定义函数过程
            使用lambda不需要考虑命名的问题
            简化代码的可读性
    4.3    BIF
        4.3.1    过滤器filter()
            list(filter(None,[1,0,False,True]))删选结果为True的元素
            [1, True]
            
             def odd(x):
                return x % 2

            >>> temp = range(10)
            >>> show = filter(odd,temp)
            >>> list(show)
            [1, 3, 5, 7, 9]
            
            list(filter(lambda x : x % 2,range(10)))
            [1, 3, 5, 7, 9]
            
        4.3.1    映射map()
            map()将range（）的值带入到lambda中的元素，形成一个序列
            list(map(lambda x : x + 2,range(10)))
            [2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
5.    递归（有调用函数自身的行为，有一个正确的返回条件）
    设置递归的深度        
        >>> import sys
        >>> sys.setrecursionlimit(10000)
    求阶乘的函数(普通函数)
        def factorial(n):
            result = n
            for i in range(1,n):
                result *= i
                
            return result

        number = int(input('请输入一个正整数：'))
        result = factorial(number)
        print('%d的阶乘是：%d'%(number,result))
    求阶乘的函数(递归函数)
        def factorial(n):
            if n == 1:
                return 1
            else:
                return n * factorial(n-1)

        number = int(input('请输入一个正整数：'))
        result = factorial(number)
        print('%d的阶乘是：%d'%(number,result))