Python函数的用法

   #函数
    def hello():                    #定义函数
        print("python 你好!")
    hello()                         #调用函数

    def add(a,b):                   #定义函数
        return a+b                  #返回值
    add(1,2)
    add                             #直接用函数名，可返回函数变量名的内存地址
    x = add                         #将函数名赋值给变量
    x(1,2)                          #通过变量调用函数

    #函数参数的多态性:指同一个函数，传递的参数类型不同时可获得不同的结果，体现了（参数得的）多态性
    print(add(1,2.5))                      #数字加法
    print(add("abc","def"))                #字符串的连接
    print(add((1,2),(3,4)))                #元组的合并
    print(add([1,2],[3,4]))                #执行列表合并

    #参数的赋值传递
    #Python允许以形参赋值的方式，将指定的实参传递给形参：
    def add_2(a,b):return a+b
    add_2(a=‘ab‘,b=‘cd‘)
    add_2(b=‘ab‘,a=‘cd‘)                   #指定接收形参的名称，所以传递参数的先后顺序无关紧要

    #参数的传递与共享引用：
    def f(x):
        x = 100
    a=10
    f(a)
    print(a)                               #非变量，不会改变
    #python的赋值是建立变量到对象的引用。
    #重新赋值时，意味着形参引用了新的对象，原来的引用已经作废

    #可变参数
    def f(a):
        a[0]=‘abc‘                         #修改列表的第一个值
    x=[1,2]
    f(x)                                   #调用函数，传递列表对象的引用
    print(x)                               #变量x引用的列表对象在函数中被修改
    #可变参数在函数中可被修改，
    #如果要避免列表在函数中被修改，可试用列表的拷贝作为实参：
    x=[1,2]
    print("x=",x)
    a=f(x[:])
    print("f(x[:])=",a)              #传递列表的拷贝
    print("x=",x)
    #还可在函数内对列表进行拷贝，实参任使用变量：
    def f_4(a):
        a=a[:]              #拷贝列表
        a[0]=‘abc‘          #修改列表的拷贝
    x_4=[1,2]
    f_4(x_4)
    print(x_4)              #结果显示原列表不变
    #!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    #!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    #函数的拷贝调用不成功！！！！！！！

    #有默认值的函数
    #定义函数时，可以为参数设置一个默认值.
    #调用函数时如果没有提供实参，则使用形参的默认值
    def add_2(a,b=-100):    #参数b的默认值为-100
        return a+b
    print("add_2(1,2)=",add_2(1,2)) #传递指定参数
    print("add(1)=",add_2(1))         #形参b取默认值
    #带默认值的参数在定义函数时，应该放在参数表的末尾

    #传递任意个数的参数
    def add_3(a,*b):
        s=a
        for x in b:         #循环迭代元组b中的对象
            s+=x            #累加
        return s            #返回累加和的结果

    print("add_3(1,2)=",add_3(1,2))
    print("add_3(1,2,3)=",add_3(1,2,3))
    print("add_3(1,2,3,4,5)=",add_3(1,2,3,4,5))     #求5个数的和

    #必须通过赋值传递的参数
    #在定义函数时，带星号参数之后的参数必须通过赋值传递:
    def add_4(a,*b,c):
        s=a+c
        for x in b:
            s+=x
        return s
    print("add_4(1,2,3,4,5,c=6)=",add_4(1,2,3,4,5,c=6))

    #嵌套函数的定义：
    #Python允许在函数内部定义函数，如：
    def add_5(a,b):
        def getsum(x):                  #在函数内部定义的函数，将字符串转换为ASII求和
            s=0
            for n in x:
                s+=ord(n)
            return s
        return getsum(a) + getsum(b)    #调用内部定义函数getsum

    print("add_5(‘12‘,‘34‘)=",add_5(‘12‘,‘34‘))

    #lambda 函数
    #表达式函数 用于定义一个匿名函数，可将该函数赋值给变量
    #通过变量调用
    #lambda 参数表:表达式
    add_6=lambda a,b:a+b
    print("add_6(1,2)=",add_6(1,2))
    print("add_6(‘ab‘,‘fg‘)=",add_6(‘ab‘,‘fg‘))
    #lambda的函数体只能是一个表达式，可以调用其他函数，但不能用Python的其他语句

    #递归函数
    def fac(n):                 #实现阶乘计算
        if n == 0:
            return 1
        else:
            return n*fac(n-1)
    print("阶乘计算fac(6)=",fac(6))

    #函数列表
    #1.Python允许将函数作为列表对象，然后同故宫列表索引来调用函数
    d = [lambda a,b:a+b,lambda a,b:a*b,lambda a,b:a+b*b]
    print("d[0][3,4]=",d[0](3,4))   #调用第一个函数
    print("d[1][3,4]=",d[1](3,4))   #调用第二个函数
    print("d[2][3,4]=",d[2](3,4))   #调用第三个函数
    #2.也可以使用def定义的函数来创建列表，如：
    def qh(a,b):            #定义求和函数
        return a+b
    def jc(n):              #定义阶乘函数
        if n == 1:
            return 1
        else:
            return n*jc(n-1)
    b=[qh,jc]               #建立函数列表
    print("b[0](8,3)=",b[0](8,3))               #调用求和函数
    print("b[1](5)=",b[1](5))                   #调用阶乘函数
    #3.Python还允许使用字典来建立函数映射：
    b={‘求和‘:add,‘求阶乘‘:fac}                   #用函数add和函数fac建立函数映射
print("b[‘求和‘](10,11)=",b[‘求和‘](10,11))   #调用求和函数
print("b[‘求阶乘‘](4)=",b[‘求阶乘‘](4))        #调用阶乘函数
#函数列表的实质就是在元组、列表和字典等序列中建立函数对象的引用，然后通过索引来调用函数