Python基础知识入门（三）——函数详解（参数，返回值，嵌套等）的代码实现

电玩女神 2024-04-18 09:06 18阅读 0赞

#example 1
    #字符串逆序
    str=input('请输入一个字符串：')
    print("原串：",str)
    print("逆串：",str[-1::-1])
    
    #以下使用字符串格式化输出
    print("原串：%s"%(str))
    print("逆串：%s"%(str[-1::-1]))
    
    print("今年是%d年%d月%d日，天气%s!"%(2017,1,1,'晴'))  #格式化字符串输出例子
    '''
    运行结果：
    请输入一个字符串：123456
    原串： 123456
    逆串： 654321
    原串：123456
    逆串：654321
    今年是2017年1月1日，天气晴!'''
    
    #example 2
    #统计文中单词出现的次数
    passage='Do not trouble trouble till trouble troubles you.'
    word=input("输入想查找的词：")
    n=passage.count(word)
    print('%s出现的次数为：%s'%(word,n))
    '''
    运行结果：
    输入想查找的词：trouble
    trouble出现的次数为：4'''
    
    #example 3
    #函数的调用——求阶乘问题
    def fun(x):
        n=1
        for i in range(1,x+1):
            n=n*i
        return n
    
    y=int(input('输入一个正整数：'))
    if y<0:
        print("输入错误！")
    else:
        print("%d的阶乘为%d"%(y,fun(y)))
    '''
    输入一个正整数：5
    5的阶乘为120'''
    
    #example 4
    #参数传递方式
    '''传递不可变对象(元组，一般变量)，形参的变化不会影响到实参'''
    def add(x):
        print("形参x的初始值是:",x)        #形参x的初始值是: 4
        x+=1
        print("形参x的最终值是:",x)        #形参x的最终值是: 5
    y=4
    add(y)
    print("实参y的值是：",y)              #实参y的值是： 4
    
    '''传递可变对象(如列表，字典等)，形参的变化会影响到实参'''
    #列表作实参
    def change(v):
        v.append(3)
        print("形参最终值：",v)       #形参最终值： [1, 3]
    list1=[1]
    print("实参初始值：",list1)       #实参初始值： [1]
    change(list1)
    print("实参最终值：",list1)       #实参最终值： [1, 3]
    
    #字典作实参
    def change(v):
        v['姓名']='诸葛亮'
        v['性别']='男'
        v['年龄']=59
    dict1={'姓名':'林黛玉','性别':'女','年龄':20}
    print("初始字典：",dict1)    #初始字典： {'姓名': '林黛玉', '性别': '女', '年龄': 20}
    change(dict1)
    print("最终字典：",dict1)    #最终字典： {'姓名': '诸葛亮', '性别': '男', '年龄': 59}
    
    
    #位置参数和关键字参数
    #调用位置参数时，要求参数的个数，位置和顺序要与定义中的形参一致，--对应
    #关键字参数明确指定参数值传递给哪个形参
    '''比如函数头是这样：def fun(a,b)
    fun(100,200)与fun(200,100)是不同的   --->未知参数
    fun(a=100,b=200)与fun(b=200,a=100)是一样的   --->关键字参数'''
    
    #默认值参数
    #默认值要求定义函数时必须保证必选参数在前，默认值参数在后
    #此外，需要注意的是：默认值参数必须指向不可变对象，避免造成程序错误
    '''比如函数头是这样：def fun(x,y=4,z=5)
    fun(3)与fun(7,8,9)都是可以的，前者使用默认值'''
    
    #可变参数
    #可变参数的产生背景：有时并不能事先确定函数到底需要多少个参数，而可变参数可以接收任意多个参数
    
    #单星号参数——接收元组
    #example 5  
    #求输入实参的平方和
    def fun(*x):
        print(type(x))
        print("可变参数的值为：",x)
        sum=0
        for i in x:
            sum=sum+i*i
        print("平方和为：",sum)
        return sum
    fun(1,2,3)
    fun(1,2,3,4)
    fun()
    '''
    运行结果：
    <class 'tuple'>
    可变参数的值为： (1, 2, 3)
    平方和为： 14
    <class 'tuple'>
    可变参数的值为： (1, 2, 3, 4)
    平方和为： 30
    <class 'tuple'>
    可变参数的值为： ()
    平方和为： 0'''
    
    
    #双星号参数——接收字典
    #example 6
    def fun(x,**y):
        print(type(y))
        print("y:",y)
        print("x",x)
        for i in y:
            print(i+':'+str(y[i]))
    fun("985高校",a="大连理工大学",b="东北大学",c="四川大学")
    '''
    运行结果：
    <class 'dict'>
    y: {'a': '大连理工大学', 'b': '东北大学', 'c': '四川大学'}
    x 985高校
    a:大连理工大学
    b:东北大学
    c:四川大学
    '''
    
    #参数传递时序列解包
    '''对于刚才的求可变参数平方和的那个函数，我们已知它会将输入的序列转换成一个元组
    但是如果被传递的实参是像列表这样的复合数据类型时，直接传递[1,2,3,4]必然会导致错误
    因为会将其转换成([1,2,3,4]),这个表达式是无法求其平方的
    但我们知道，我们想真正求的是列表中各个元素的平方和，其实可以这样暴力实现：
    fun(list[0],list[1],list[2])，这样太繁琐，那么有什么机制可以将这些复合类型拆解成元素，
    答案是有的，序列解包就可以解决这个问题。用法：对于序列型的实参，可以在前面添加一个星号，会将
    实参序列进行解包
    '''
    def fun(*x):
        print(type(x))
        print("可变参数的值为：",x)
        sum=0
        for i in x:
            sum=sum+i*i
        print("平方和为：",sum)
        return sum
    list1=[1,2,3,4]
    fun(list1)   #TypeError: can't multiply sequence by non-int of type 'list'
                 #可变参数的值为： ([1, 2, 3, 4],)
    
    fun(*list1)  #平方和为30
                 #可变参数的值为： (1, 2, 3, 4)
    
    #再举个栗子，更直观说明
    def add_three(x,y,z):
        s=x+y+z
        print(s)
        
    list1=[1,2,3]
    tuple1=(1,2,3)
    dict1={1:'x',2:'y',3:'z'}
    set1={1,2,3}
    '''若实参为复合数据类型，将实参解包后进行参数传递'''
    add_three(*list1)   #6
    add_three(*tuple1)  #6
    add_three(*dict1)   #6
    add_three(*set1)    #6
    
    #example 5
    #函数的返回值:与其他高级变量如c,c++的使用是一样的
    def min(x,y):
        if x<y:
            return x
        else:
            return y
    print(min(1,3))     #打印1
    
    #example 6
    #变量的作用域
    a,b=3,6             #主程序中定义的变量全是全局变量
    def fun():
        global a       #a是全局变量，与主程序中的a为同一变量
        a=10      
        b=20            #b定义在函数体内赋值语句等号左侧，是局部变量，与主程序中的b不一样
        c=a*b           #c是局部变量
        print(a,b,c)    #10 20 200
    fun()
    print(a,b)      #10 6
    
    #example 7
    #函数的嵌套
    def first():
        x1="Dream1"     #first()函数内局部变量x1，可用在first函数内及其嵌套子函数
        print(x1)       #Dream1
        def second():
            x1="second_Dream1"      #此x1是函数second的局部变量，与first的x1不同
            global x2               #x2是全局变量，作用域为整个程序
            x2="Dream2"
            print(x1,x2)            #second_Dream1 Dream2
            def third():
                x2="third_Dream2"   #此x2是third函数内的局部变量，与second内定义的全局变量不同
                x3="Dream3"         #同理，x3是third内的局部变量
                print(x1,x2,x3)     #second_Dream1 third_Dream2 Dream3
            return third()
        second()
        print(x1,x2)                #Dream1 Dream2（注意：全局变量x2没有被改动，third里的x2根本不是全局变量）
    first()
    '''
    运行结果
    Dream1
    second_Dream1 Dream2
    second_Dream1 third_Dream2 Dream3
    Dream1 Dream2'''
    
    #example 8
    #lambda函数和递归(求斐波那契第N项)
    f=lambda x,y=3,z=5:x+y+z    #又称匿名函数，用法：<函数名>=lambda <参数列表>：<表达式>
    print(f(4),f(4,5,6))  #12 
    
    def fib(n):         #斐波那契函数
        if n<2:
            return n    #递归终止条件
        else:
            return fib(n-1)+fib(n-2)    #递归式
    print(fib(5))       #5
    print(fib(8))       #21