函数基础知识（python）

函数：如果在开发程序时，需要某块代码多次，但是为了提高编写的效率以及代码的重用，所以把具有独立功能的代码块组织为一个小模块
这就是函数

函数定义和调用

<1>定义函数
    定义函数的格式如下：

        def 函数名():
            代码
<2>调用函数

    定义了函数之后，就相当于有了一个具有某些功能的代码，想要让这些代码能够执行，需要调用它

    调用函数很简单的，通过 函数名() 即可完成调用


函数参数(一)

    为了让一个函数更通用，即想让它计算哪两个数的和，就让它计算哪两个数的和，在定义函数的时候可以让函数接收数据，
    就解决了这个问题，这就是 函数的参数

    <1> 定义带有参数的函数

    示例如下：

        def add2num(a, b):
            c = a+b
            print c

    <2> 调用带有参数的函数

    以调用上面的add2num(a, b)函数为例:


        def add2num(a, b):
            c = a+b
            print c

        add2num(11, 22) #调用带有参数的函数时，需要在小括号中，传递数据
    <4> 小总结

        定义时小括号中的参数，用来接收参数用的，称为 “形参”

        调用时小括号中的参数，用来传递给函数用的，称为 “实参”

函数返回值(一)

    <1>“返回值”介绍

    所谓“返回值”，就是程序中函数完成一件事情后，最后给调用者的结果

    <2>带有返回值的函数

    想要在函数中把结果返回给调用者，需要在函数中使用return

    如下示例:

        def add2num(a, b):
            c = a+b
            return c

    或者

        def add2num(a, b):
            return a+b

    <3>保存函数的返回值

    在本小节刚开始的时候，说过的“买烟”的例子中，最后儿子给你烟时，你一定是从儿子手中接过来 对么，程序也是如此，如果一个函数返回了一个数据，那么想要用这个数据，那么就需要保存

    保存函数的返回值示例如下:

        #定义函数
        def add2num(a, b):
            return a+b

        #调用函数，顺便保存函数的返回值
        result = add2num(100,98)

        #因为result已经保存了add2num的返回值，所以接下来就可以使用了
        print result

    结果:

        198



函数返回值(二)
    在python中我们可不可以返回多个值？

    >>> def divid(a, b):
    ...     shang = a//b
    ...     yushu = a%b
    ...     return shang, yushu
    ...
    >>> sh, yu = divid(5, 2)
    >>> sh
    5
    >>> yu
    1

    本质是利用了元组



4种函数的类型

    函数根据有没有参数，有没有返回值，可以相互组合，一共有4种

        无参数，无返回值
        无参数，又返回
        有参数，无返回值
        有参数，有返回值

    <1>无参数，无返回值的函数

        此类函数，不能接收参数，也没有返回值，一般情况下，打印提示灯类似的功能，使用这类的函数

    <2>无参数，有返回值的函数

        此类函数，不能接收参数，但是可以返回某个数据，一般情况下，像采集数据，用此类函数


            # 获取温度
            def getTemperature():

                #这里是获取温度的一些处理过程

                #为了简单起见，先模拟返回一个数据
                return 24

            temperature = getTemperature()
            print('当前的温度为:%d'%temperature)

        结果:

            当前的温度为: 24

       <3>有参数，无返回值的函数

        此类函数，能接收参数，但不可以返回数据，一般情况下，对某些变量设置数据而不需结果时，用此类函数

        <4>有参数，有返回值的函数

        此类函数，不仅能接收参数，还可以返回某个数据，一般情况下，像数据处理并需要结果的应用，用此类函数


            # 计算1~num的累积和
            def calculateNum(num):

                result = 0
                i = 1
                while i<=num:

                    result = result + i

                    i+=1

                return result

            result = calculateNum(100)
            print('1~100的累积和为:%d'%result)

        结果:

            1~100的累积和为: 5050

        函数参数(二)
            1. 缺省参数

                调用函数时，缺省参数的值如果没有传入，则被认为是默认值。下例会打印默认的age，如果age没有被传入：

                def printinfo( name, age = 35 ):
                   # 打印任何传入的字符串
                   print "Name: ", name
                   print "Age ", age

                # 调用printinfo函数
                printinfo(name="miki" )
                printinfo( age=9,name="miki" )

                以上实例输出结果：

                Name:  miki
                Age  35
                Name:  miki
                Age  9

                注意：带有默认值的参数一定要位于参数列表的最后面。

                >>> def printinfo(name, age=35, sex):
                ...     print name
                ...
                  File "<stdin>", line 1
                SyntaxError: non-default argument follows default argument

            2.不定长参数

                有时可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，声明时不会命名。

                基本语法如下：

                    def functionname([formal_args,] *args, **kwargs):
                       "函数_文档字符串"
                       function_suite
                       return [expression]

                加了星号（*）的变量args会存放所有未命名的变量参数，args为元组；而加**的变量kwargs会存放命名参数，
                即形如key=value的参数， kwargs为字典。

                >>> def fun(a, b, *args, **kwargs):
                ...     """可变参数演示示例"""
                ...     print "a =", a
                ...     print "b =", b
                ...     print "args =", args
                ...     print "kwargs: "
                ...     for key, value in kwargs.items():
                ...         print key, "=", value
                ...
                >>> fun(1, 2, 3, 4, 5, m=6, n=7, p=8)  # 注意传递的参数对应
                a = 1
                b = 2
                args = (3, 4, 5)
                kwargs:
                p = 8
                m = 6
                n = 7
                >>>
                >>>
                >>>
                >>> c = (3, 4, 5)
                >>> d = {"m":6, "n":7, "p":8}
                >>> fun(1, 2, *c, **d)    # 注意元组与字典的传参方式
                a = 1
                b = 2
                args = (3, 4, 5)
                kwargs:
                p = 8
                m = 6
                n = 7
                >>>
                >>>
                >>>
                >>> fun(1, 2, c, d) # 注意不加星号与上面的区别
                a = 1
                b = 2
                args = ((3, 4, 5), {'p': 8, 'm': 6, 'n': 7})
                kwargs:
                >>>
                >>>

            3. 引用传参

                    可变类型与不可变类型的变量分别作为函数参数时，会有什么不同吗？
                    Python有没有类似C语言中的指针传参呢？

                >>> def selfAdd(a):
                ...     """自增"""
                ...     a += a
                ...
                >>> a_int = 1
                >>> a_int
                1
                >>> selfAdd(a_int)
                >>> a_int
                1
                >>> a_list = [1, 2]
                >>> a_list
                [1, 2]
                >>> selfAdd(a_list)
                >>> a_list
                [1, 2, 1, 2]

                Python中函数参数是引用传递（注意不是值传递）。对于不可变类型，因变量不能修改，所以运算不会影响到变量自身
                ；而对于可变类型来说，函数体中的运算有可能会更改传入的参数变量。


函数的嵌套调用

    def testB():
        print('---- testB start----')
        print('这里是testB函数执行的代码')
        print('---- testB end----')


    def testA():

        print('---- testA start----')

        testB()

        print('---- testA end----')

    testA()

    结果：

        ---- testA start----
        ---- testB start----
        这里是testB函数执行的代码
        ---- testB end----
        ---- testA end----



        思考&实现1

        写一个函数打印一条横线
        打印自定义行数的横线

        参考代码1


        # 打印一条横线
        def printOneLine():
            print("-"*30)

        # 打印多条横线
        def printNumLine(num):
            i=0

            # 因为printOneLine函数已经完成了打印横线的功能，
            # 只需要多次调用此函数即可
            while i<num:
                printOneLine()
                i+=1

        printNumLine(3)

        思考&实现2

            写一个函数求三个数的和
            写一个函数求三个数的平均值

        参考代码2


        # 求3个数的和
        def sum3Number(a,b,c):
            return a+b+c # return 的后面可以是数值，也可是一个表达式

        # 完成对3个数求平均值
        def average3Number(a,b,c):

            # 因为sum3Number函数已经完成了3个数的就和，所以只需调用即可
            # 即把接收到的3个数，当做实参传递即可
            sumResult = sum3Number(a,b,c)
            aveResult = sumResult/3.0
            return aveResult

        # 调用函数，完成对3个数求平均值
        result = average3Number(11,2,55)
        print("average is %d"%result)

局部变量
    
    局部变量，就是在函数内部定义的变量
    不同的函数，可以定义相同的名字的局部变量，但是各用个的不会产生影响
    局部变量的作用，为了临时保存数据需要在函数中定义变量来进行存储，这就是它的作用

全局变量
    如果一个变量，既能在一个函数中使用，也能在其他的函数中使用，这样的变量就是全局变量

    demo如下:

        # 定义全局变量
        a = 100

        def test1():
            print(a)

        def test2():
            print(a)

        # 调用函数
        test1()
        test2()

    
    在函数外边定义的变量叫做全局变量
    全局变量能够在所有的函数中进行访问
    如果在函数中修改全局变量，那么就需要使用global进行声明，否则出错
    如果全局变量的名字和局部变量的名字相同，那么使用的是局部变量的，小技巧强龙不压地头蛇


递归函数
    如果一个函数在内部不调用其它的函数，而是自己本身的话，这个函数就是递归函数。
    举个例子，我们来计算阶乘 n! = 1 * 2 * 3 * ... * n
    def calNum(num):
        i = 1
        return = 1

        while i<=num:
            return *= i
            i+=1

        return result

    ret = calNum(3)
    print(ret)


匿名函数

    用lambda关键词能创建小型匿名函数。这种函数得名于省略了用def声明函数的标准步骤。

    lambda函数的语法只包含一个语句，如下：

        lambda [arg1 [,arg2,.....argn]]:expression

    如下实例：

        sum = lambda arg1, arg2: arg1 + arg2

        #调用sum函数
        print "Value of total : ", sum( 10, 20 )
        print "Value of total : ", sum( 20, 20 )

    以上实例输出结果：

        Value of total :  30
        Value of total :  40

    Lambda函数能接收任何数量的参数但只能返回一个表达式的值

    匿名函数不能直接调用print，因为lambda需要一个表达式
    应用场合
    函数作为参数传递

        自己定义函数

        >>> def fun(a, b, opt):
        ...     print "a =", a
        ...     print "b =", b
        ...     print "result =", opt(a, b)
        ...
        >>> fun(1, 2, lambda x,y:x+y)
        a = 1
        b = 2
        result = 3

        作为内置函数的参数

    想一想，下面的数据如何指定按age或name排序？

    stus = [
        {"name":"zhangsan", "age":18},
        {"name":"lisi", "age":19},
        {"name":"wangwu", "age":17}
    ]

    按name排序：

    >>> stus.sort(key = lambda x:x['name'])
    >>> stus
    [{'age': 19, 'name': 'lisi'}, {'age': 17, 'name': 'wangwu'}, {'age': 18, 'name': 'zhangsan'}]

    按age排序：

    >>> stus.sort(key = lambda x:x['age'])
    >>> stus
    [{'age': 17, 'name': 'wangwu'}, {'age': 18, 'name': 'zhangsan'}, {'age': 19, 'name': 'lisi'}]

函数使用注意事项

    1. 自定义函数

        <1>无参数、无返回值

            def 函数名():
                语句

        <2>无参数、有返回值

            def 函数名():
                语句
                return 需要返回的数值

        注意:

            一个函数到底有没有返回值，就看有没有return，因为只有return才可以返回数据
            在开发中往往根据需求来设计函数需不需要返回值
            函数中，可以有多个return语句，但是只要执行到一个return语句，那么就意味着这个函数的调用完成

        <3>有参数、无返回值

            def 函数名(形参列表):
                语句

        注意：

            在调用函数时，如果需要把一些数据一起传递过去，被调用函数就需要用参数来接收
            参数列表中变量的个数根据实际传递的数据的多少来确定

        <4>有参数、有返回值

            def 函数名(形参列表):
                语句
                return 需要返回的数值

        <5>函数名不能重复

    2. 调用函数

        <1>调用的方式为：

            函数名([实参列表])

        <2>调用时，到底写不写 实参

            如果调用的函数 在定义时有形参，那么在调用的时候就应该传递参数

        <3>调用时，实参的个数和先后顺序应该和定义函数中要求的一致
        
        <4>如果调用的函数有返回值，那么就可以用一个变量来进行保存这个值

    3. 作用域

        <1>在一个函数中定义的变量，只能在本函数中用(局部变量)

        <2>在函数外定义的变量，可以在所有的函数中使用(全局变量)