零基础学习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))