- 
                
塑料小白
                
                
                0星
             
            - 
                
一指青铜
                
                
                100星
             
            - 
                
二指白银
                
                
                200星
             
            - 
                
十指黄金
                
                
                300星
             
            - 
                
流云蓝珀
                
                
                400星
             
            - 
                
幻影钻石
                
                
                500星
             
            - 
                
键影星耀
                
                
                800星
             
            - 
                
神速大师
                
                
                1000星
             
            - 
                
键舞王者
                
                
                200CPM
             
            - 
                
星河宗师
                
                
                400CPM
             
        
     
    
  
    
    
        闯关失败!💔
        你打错了太多字,再接再厉吧!
        
            
        
     
   
        
                
            
                        
                
                                        
                        d 
                    
                                        
                        e 
                    
                                        
                        f 
                    
                                        
                          
                    
                                        
                        g 
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                        e 
                    
                                        
                        t 
                    
                                        
                        ( 
                    
                                        
                        ) 
                    
                                        
                        : 
                    
                                        
                          
                    
                                        
                        p 
                    
                                        
                        r 
                    
                                        
                        i 
                    
                                        
                        n 
                    
                                        
                        t 
                    
                                        
                        ( 
                    
                                        
                        " 
                    
                                        
                        h 
                    
                                        
                        e 
                    
                                        
                        l 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        " 
                    
                                        
                        ) 
                    
                                     
                
                
                简单函数定义,无参数无返回值的函数
             
                     
                
            
                        
                
                                        
                        d 
                    
                                        
                        e 
                    
                                        
                        f 
                    
                                        
                          
                    
                                        
                        g 
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                        e 
                    
                                        
                        t 
                    
                                        
                        ( 
                    
                                        
                        ) 
                    
                                        
                        : 
                    
                                        
                          
                    
                                        
                        p 
                    
                                        
                        r 
                    
                                        
                        i 
                    
                                        
                        n 
                    
                                        
                        t 
                    
                                        
                        ( 
                    
                                        
                        " 
                    
                                        
                        h 
                    
                                        
                        e 
                    
                                        
                        l 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        " 
                    
                                        
                        ) 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        g 
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                        e 
                    
                                        
                        t 
                    
                                        
                        ( 
                    
                                        
                        ) 
                    
                                     
                
                
                函数调用,执行已定义的函数
             
                     
                
            
                        
                
                                        
                        d 
                    
                                        
                        e 
                    
                                        
                        f 
                    
                                        
                          
                    
                                        
                        a 
                    
                                        
                        d 
                    
                                        
                        d 
                    
                                        
                        ( 
                    
                                        
                        a 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        b 
                    
                                        
                        ) 
                    
                                        
                        : 
                    
                                        
                          
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                        t 
                    
                                        
                        u 
                    
                                        
                        r 
                    
                                        
                        n 
                    
                                        
                          
                    
                                        
                        a 
                    
                                        
                          
                    
                                        
                        + 
                    
                                        
                          
                    
                                        
                        b 
                    
                                     
                
                
                带参数函数,接收两个参数并返回和
             
                     
                
            
                        
                
                                        
                        d 
                    
                                        
                        e 
                    
                                        
                        f 
                    
                                        
                          
                    
                                        
                        a 
                    
                                        
                        d 
                    
                                        
                        d 
                    
                                        
                        ( 
                    
                                        
                        a 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        b 
                    
                                        
                        ) 
                    
                                        
                        : 
                    
                                        
                          
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                        t 
                    
                                        
                        u 
                    
                                        
                        r 
                    
                                        
                        n 
                    
                                        
                          
                    
                                        
                        a 
                    
                                        
                          
                    
                                        
                        + 
                    
                                        
                          
                    
                                        
                        b 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        a 
                    
                                        
                        d 
                    
                                        
                        d 
                    
                                        
                        ( 
                    
                                        
                        3 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        5 
                    
                                        
                        ) 
                    
                                     
                
                
                位置参数调用,按顺序传递参数
             
                     
                
            
                        
                
                                        
                        d 
                    
                                        
                        e 
                    
                                        
                        f 
                    
                                        
                          
                    
                                        
                        i 
                    
                                        
                        n 
                    
                                        
                        f 
                    
                                        
                        o 
                    
                                        
                        ( 
                    
                                        
                        n 
                    
                                        
                        a 
                    
                                        
                        m 
                    
                                        
                        e 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        a 
                    
                                        
                        g 
                    
                                        
                        e 
                    
                                        
                        ) 
                    
                                        
                        : 
                    
                                        
                          
                    
                                        
                        p 
                    
                                        
                        r 
                    
                                        
                        i 
                    
                                        
                        n 
                    
                                        
                        t 
                    
                                        
                        ( 
                    
                                        
                        n 
                    
                                        
                        a 
                    
                                        
                        m 
                    
                                        
                        e 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        a 
                    
                                        
                        g 
                    
                                        
                        e 
                    
                                        
                        ) 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        i 
                    
                                        
                        n 
                    
                                        
                        f 
                    
                                        
                        o 
                    
                                        
                        ( 
                    
                                        
                        a 
                    
                                        
                        g 
                    
                                        
                        e 
                    
                                        
                        = 
                    
                                        
                        2 
                    
                                        
                        0 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        n 
                    
                                        
                        a 
                    
                                        
                        m 
                    
                                        
                        e 
                    
                                        
                        = 
                    
                                        
                        " 
                    
                                        
                        a 
                    
                                        
                        l 
                    
                                        
                        i 
                    
                                        
                        c 
                    
                                        
                        e 
                    
                                        
                        " 
                    
                                        
                        ) 
                    
                                     
                
                
                关键字参数调用,指定参数名传递
             
                     
                
            
                        
                
                                        
                        d 
                    
                                        
                        e 
                    
                                        
                        f 
                    
                                        
                          
                    
                                        
                        g 
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                        e 
                    
                                        
                        t 
                    
                                        
                        ( 
                    
                                        
                        n 
                    
                                        
                        a 
                    
                                        
                        m 
                    
                                        
                        e 
                    
                                        
                        = 
                    
                                        
                        " 
                    
                                        
                        g 
                    
                                        
                        u 
                    
                                        
                        e 
                    
                                        
                        s 
                    
                                        
                        t 
                    
                                        
                        " 
                    
                                        
                        ) 
                    
                                        
                        : 
                    
                                        
                          
                    
                                        
                        p 
                    
                                        
                        r 
                    
                                        
                        i 
                    
                                        
                        n 
                    
                                        
                        t 
                    
                                        
                        ( 
                    
                                        
                        f 
                    
                                        
                        " 
                    
                                        
                        h 
                    
                                        
                        e 
                    
                                        
                        l 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                          
                    
                                        
                        { 
                    
                                        
                        n 
                    
                                        
                        a 
                    
                                        
                        m 
                    
                                        
                        e 
                    
                                        
                        } 
                    
                                        
                        " 
                    
                                        
                        ) 
                    
                                     
                
                
                默认参数,参数有默认值的函数
             
                     
                
            
                        
                
                                        
                        d 
                    
                                        
                        e 
                    
                                        
                        f 
                    
                                        
                          
                    
                                        
                        m 
                    
                                        
                        u 
                    
                                        
                        l 
                    
                                        
                        t 
                    
                                        
                        i 
                    
                                        
                        p 
                    
                                        
                        l 
                    
                                        
                        y 
                    
                                        
                        ( 
                    
                                        
                        a 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        b 
                    
                                        
                        = 
                    
                                        
                        2 
                    
                                        
                        ) 
                    
                                        
                        : 
                    
                                        
                          
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                        t 
                    
                                        
                        u 
                    
                                        
                        r 
                    
                                        
                        n 
                    
                                        
                          
                    
                                        
                        a 
                    
                                        
                          
                    
                                        
                        * 
                    
                                        
                          
                    
                                        
                        b 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        m 
                    
                                        
                        u 
                    
                                        
                        l 
                    
                                        
                        t 
                    
                                        
                        i 
                    
                                        
                        p 
                    
                                        
                        l 
                    
                                        
                        y 
                    
                                        
                        ( 
                    
                                        
                        3 
                    
                                        
                        ) 
                    
                                     
                
                
                调用带默认参数的函数,省略默认参数
             
                     
                
            
                        
                
                                        
                        d 
                    
                                        
                        e 
                    
                                        
                        f 
                    
                                        
                          
                    
                                        
                        s 
                    
                                        
                        u 
                    
                                        
                        m 
                    
                                        
                        _ 
                    
                                        
                        n 
                    
                                        
                        u 
                    
                                        
                        m 
                    
                                        
                        b 
                    
                                        
                        e 
                    
                                        
                        r 
                    
                                        
                        s 
                    
                                        
                        ( 
                    
                                        
                        * 
                    
                                        
                        n 
                    
                                        
                        u 
                    
                                        
                        m 
                    
                                        
                        s 
                    
                                        
                        ) 
                    
                                        
                        : 
                    
                                        
                          
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                        t 
                    
                                        
                        u 
                    
                                        
                        r 
                    
                                        
                        n 
                    
                                        
                          
                    
                                        
                        s 
                    
                                        
                        u 
                    
                                        
                        m 
                    
                                        
                        ( 
                    
                                        
                        n 
                    
                                        
                        u 
                    
                                        
                        m 
                    
                                        
                        s 
                    
                                        
                        ) 
                    
                                     
                
                
                可变位置参数,接收任意数量的位置参数
             
                     
                
            
                        
                
                                        
                        d 
                    
                                        
                        e 
                    
                                        
                        f 
                    
                                        
                          
                    
                                        
                        p 
                    
                                        
                        r 
                    
                                        
                        i 
                    
                                        
                        n 
                    
                                        
                        t 
                    
                                        
                        _ 
                    
                                        
                        i 
                    
                                        
                        n 
                    
                                        
                        f 
                    
                                        
                        o 
                    
                                        
                        ( 
                    
                                        
                        * 
                    
                                        
                        * 
                    
                                        
                        k 
                    
                                        
                        w 
                    
                                        
                        a 
                    
                                        
                        r 
                    
                                        
                        g 
                    
                                        
                        s 
                    
                                        
                        ) 
                    
                                        
                        : 
                    
                                        
                          
                    
                                        
                        p 
                    
                                        
                        r 
                    
                                        
                        i 
                    
                                        
                        n 
                    
                                        
                        t 
                    
                                        
                        ( 
                    
                                        
                        k 
                    
                                        
                        w 
                    
                                        
                        a 
                    
                                        
                        r 
                    
                                        
                        g 
                    
                                        
                        s 
                    
                                        
                        ) 
                    
                                     
                
                
                可变关键字参数,接收任意数量的关键字参数
             
                     
                
            
                        
                
                                        
                        d 
                    
                                        
                        e 
                    
                                        
                        f 
                    
                                        
                          
                    
                                        
                        f 
                    
                                        
                        u 
                    
                                        
                        n 
                    
                                        
                        c 
                    
                                        
                        ( 
                    
                                        
                        a 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        b 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        * 
                    
                                        
                        a 
                    
                                        
                        r 
                    
                                        
                        g 
                    
                                        
                        s 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        k 
                    
                                        
                        w 
                    
                                        
                        a 
                    
                                        
                        r 
                    
                                        
                        g 
                    
                                        
                        s 
                    
                                        
                        ) 
                    
                                        
                        : 
                    
                                        
                          
                    
                                        
                        p 
                    
                                        
                        a 
                    
                                        
                        s 
                    
                                        
                        s 
                    
                                     
                
                
                混合参数,同时包含多种类型参数
             
                     
                
            
                        
                
                                        
                        d 
                    
                                        
                        e 
                    
                                        
                        f 
                    
                                        
                          
                    
                                        
                        a 
                    
                                        
                        d 
                    
                                        
                        d 
                    
                                        
                        ( 
                    
                                        
                        a 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        b 
                    
                                        
                        ) 
                    
                                        
                        : 
                    
                                        
                          
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                        t 
                    
                                        
                        u 
                    
                                        
                        r 
                    
                                        
                        n 
                    
                                        
                          
                    
                                        
                        a 
                    
                                        
                          
                    
                                        
                        + 
                    
                                        
                          
                    
                                        
                        b 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                        s 
                    
                                        
                        u 
                    
                                        
                        l 
                    
                                        
                        t 
                    
                                        
                          
                    
                                        
                        = 
                    
                                        
                          
                    
                                        
                        a 
                    
                                        
                        d 
                    
                                        
                        d 
                    
                                        
                        ( 
                    
                                        
                        2 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        3 
                    
                                        
                        ) 
                    
                                     
                
                
                函数返回值,接收函数的返回结果
             
                     
                
            
                        
                
                                        
                        d 
                    
                                        
                        e 
                    
                                        
                        f 
                    
                                        
                          
                    
                                        
                        f 
                    
                                        
                        u 
                    
                                        
                        n 
                    
                                        
                        c 
                    
                                        
                        ( 
                    
                                        
                        ) 
                    
                                        
                        : 
                    
                                        
                          
                    
                                        
                        p 
                    
                                        
                        a 
                    
                                        
                        s 
                    
                                        
                        s 
                    
                                     
                
                
                空函数,用 pass 作为占位符的函数
             
                     
                
            
                        
                
                                        
                        x 
                    
                                        
                          
                    
                                        
                        = 
                    
                                        
                          
                    
                                        
                        1 
                    
                                        
                        0 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        d 
                    
                                        
                        e 
                    
                                        
                        f 
                    
                                        
                          
                    
                                        
                        f 
                    
                                        
                        u 
                    
                                        
                        n 
                    
                                        
                        c 
                    
                                        
                        ( 
                    
                                        
                        ) 
                    
                                        
                        : 
                    
                                        
                          
                    
                                        
                        p 
                    
                                        
                        r 
                    
                                        
                        i 
                    
                                        
                        n 
                    
                                        
                        t 
                    
                                        
                        ( 
                    
                                        
                        x 
                    
                                        
                        ) 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        f 
                    
                                        
                        u 
                    
                                        
                        n 
                    
                                        
                        c 
                    
                                        
                        ( 
                    
                                        
                        ) 
                    
                                     
                
                
                访问全局变量,函数内部使用外部变量
             
                     
                
            
                        
                
                                        
                        d 
                    
                                        
                        e 
                    
                                        
                        f 
                    
                                        
                          
                    
                                        
                        a 
                    
                                        
                        d 
                    
                                        
                        d 
                    
                                        
                        ( 
                    
                                        
                        a 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        b 
                    
                                        
                        ) 
                    
                                        
                        : 
                    
                                        
                          
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                        t 
                    
                                        
                        u 
                    
                                        
                        r 
                    
                                        
                        n 
                    
                                        
                          
                    
                                        
                        a 
                    
                                        
                          
                    
                                        
                        + 
                    
                                        
                          
                    
                                        
                        b 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        a 
                    
                                        
                        d 
                    
                                        
                        d 
                    
                                        
                        ( 
                    
                                        
                        2 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        3 
                    
                                        
                        ) 
                    
                                     
                
                
                整数参数函数,传递整数参数
             
                     
                
            
                        
                
                                        
                        d 
                    
                                        
                        e 
                    
                                        
                        f 
                    
                                        
                          
                    
                                        
                        c 
                    
                                        
                        o 
                    
                                        
                        n 
                    
                                        
                        c 
                    
                                        
                        a 
                    
                                        
                        t 
                    
                                        
                        e 
                    
                                        
                        n 
                    
                                        
                        a 
                    
                                        
                        t 
                    
                                        
                        e 
                    
                                        
                        ( 
                    
                                        
                        s 
                    
                                        
                        1 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        s 
                    
                                        
                        2 
                    
                                        
                        ) 
                    
                                        
                        : 
                    
                                        
                          
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                        t 
                    
                                        
                        u 
                    
                                        
                        r 
                    
                                        
                        n 
                    
                                        
                          
                    
                                        
                        s 
                    
                                        
                        1 
                    
                                        
                          
                    
                                        
                        + 
                    
                                        
                          
                    
                                        
                        s 
                    
                                        
                        2 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        c 
                    
                                        
                        o 
                    
                                        
                        n 
                    
                                        
                        c 
                    
                                        
                        a 
                    
                                        
                        t 
                    
                                        
                        e 
                    
                                        
                        n 
                    
                                        
                        a 
                    
                                        
                        t 
                    
                                        
                        e 
                    
                                        
                        ( 
                    
                                        
                        " 
                    
                                        
                        a 
                    
                                        
                        " 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        b 
                    
                                        
                        " 
                    
                                        
                        ) 
                    
                                     
                
                
                字符串参数函数,传递字符串参数
             
                     
                
            
                        
                
                                        
                        d 
                    
                                        
                        e 
                    
                                        
                        f 
                    
                                        
                          
                    
                                        
                        g 
                    
                                        
                        e 
                    
                                        
                        t 
                    
                                        
                        _ 
                    
                                        
                        f 
                    
                                        
                        i 
                    
                                        
                        r 
                    
                                        
                        s 
                    
                                        
                        t 
                    
                                        
                        ( 
                    
                                        
                        l 
                    
                                        
                        s 
                    
                                        
                        t 
                    
                                        
                        ) 
                    
                                        
                        : 
                    
                                        
                          
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                        t 
                    
                                        
                        u 
                    
                                        
                        r 
                    
                                        
                        n 
                    
                                        
                          
                    
                                        
                        l 
                    
                                        
                        s 
                    
                                        
                        t 
                    
                                        
                          
                    
                                        
                        [ 
                    
                                        
                        0 
                    
                                        
                        ] 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        g 
                    
                                        
                        e 
                    
                                        
                        t 
                    
                                        
                        _ 
                    
                                        
                        f 
                    
                                        
                        i 
                    
                                        
                        r 
                    
                                        
                        s 
                    
                                        
                        t 
                    
                                        
                        ( 
                    
                                        
                        [ 
                    
                                        
                        1 
                    
                                        
                        , 
                    
                                        
                        2 
                    
                                        
                        , 
                    
                                        
                        3 
                    
                                        
                        ] 
                    
                                        
                        ) 
                    
                                     
                
                
                列表参数函数,传递列表参数
             
                     
                
            
                        
                
                                        
                        d 
                    
                                        
                        e 
                    
                                        
                        f 
                    
                                        
                          
                    
                                        
                        f 
                    
                                        
                        u 
                    
                                        
                        n 
                    
                                        
                        c 
                    
                                        
                        ( 
                    
                                        
                        a 
                    
                                        
                        ) 
                    
                                        
                        : 
                    
                                        
                          
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                        t 
                    
                                        
                        u 
                    
                                        
                        r 
                    
                                        
                        n 
                    
                                        
                          
                    
                                        
                        a 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        f 
                    
                                        
                        u 
                    
                                        
                        n 
                    
                                        
                        c 
                    
                                        
                        ( 
                    
                                        
                        t 
                    
                                        
                        r 
                    
                                        
                        u 
                    
                                        
                        e 
                    
                                        
                        ) 
                    
                                     
                
                
                布尔参数函数,传递布尔值参数
             
                     
                
            
                        
                
                                        
                        d 
                    
                                        
                        e 
                    
                                        
                        f 
                    
                                        
                          
                    
                                        
                        a 
                    
                                        
                        p 
                    
                                        
                        p 
                    
                                        
                        l 
                    
                                        
                        y 
                    
                                        
                        _ 
                    
                                        
                        f 
                    
                                        
                        u 
                    
                                        
                        n 
                    
                                        
                        c 
                    
                                        
                        ( 
                    
                                        
                        f 
                    
                                        
                        u 
                    
                                        
                        n 
                    
                                        
                        c 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        x 
                    
                                        
                        ) 
                    
                                        
                        : 
                    
                                        
                          
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                        t 
                    
                                        
                        u 
                    
                                        
                        r 
                    
                                        
                        n 
                    
                                        
                          
                    
                                        
                        f 
                    
                                        
                        u 
                    
                                        
                        n 
                    
                                        
                        c 
                    
                                        
                        ( 
                    
                                        
                        x 
                    
                                        
                        ) 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        a 
                    
                                        
                        p 
                    
                                        
                        p 
                    
                                        
                        l 
                    
                                        
                        y 
                    
                                        
                        _ 
                    
                                        
                        f 
                    
                                        
                        u 
                    
                                        
                        n 
                    
                                        
                        c 
                    
                                        
                        ( 
                    
                                        
                        l 
                    
                                        
                        e 
                    
                                        
                        n 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        h 
                    
                                        
                        e 
                    
                                        
                        l 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        " 
                    
                                        
                        ) 
                    
                                     
                
                
                函数作为参数,传递函数作为参数
             
                     
                
                
            
                        
                
                                        
                        n 
                    
                                        
                        u 
                    
                                        
                        m 
                    
                                        
                        s 
                    
                                        
                          
                    
                                        
                        = 
                    
                                        
                          
                    
                                        
                        [ 
                    
                                        
                        1 
                    
                                        
                        , 
                    
                                        
                        2 
                    
                                        
                        , 
                    
                                        
                        3 
                    
                                        
                        ] 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        l 
                    
                                        
                        i 
                    
                                        
                        s 
                    
                                        
                        t 
                    
                                        
                        ( 
                    
                                        
                        m 
                    
                                        
                        a 
                    
                                        
                        p 
                    
                                        
                        ( 
                    
                                        
                        l 
                    
                                        
                        a 
                    
                                        
                        m 
                    
                                        
                        b 
                    
                                        
                        d 
                    
                                        
                        a 
                    
                                        
                          
                    
                                        
                        x 
                    
                                        
                        : 
                    
                                        
                          
                    
                                        
                        x 
                    
                                        
                        2 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        n 
                    
                                        
                        u 
                    
                                        
                        m 
                    
                                        
                        s 
                    
                                        
                        ) 
                    
                                        
                        ) 
                    
                                     
                
                
                使用匿名函数,lambda 作为参数
             
                     
                
            
                        
                
                                        
                        d 
                    
                                        
                        e 
                    
                                        
                        f 
                    
                                        
                          
                    
                                        
                        f 
                    
                                        
                        u 
                    
                                        
                        n 
                    
                                        
                        c 
                    
                                        
                        ( 
                    
                                        
                        a 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        b 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        c 
                    
                                        
                        = 
                    
                                        
                        0 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        d 
                    
                                        
                        = 
                    
                                        
                        0 
                    
                                        
                        ) 
                    
                                        
                        : 
                    
                                        
                          
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                        t 
                    
                                        
                        u 
                    
                                        
                        r 
                    
                                        
                        n 
                    
                                        
                          
                    
                                        
                        a 
                    
                                        
                          
                    
                                        
                        + 
                    
                                        
                          
                    
                                        
                        b 
                    
                                        
                          
                    
                                        
                        + 
                    
                                        
                          
                    
                                        
                        c 
                    
                                        
                          
                    
                                        
                        + 
                    
                                        
                          
                    
                                        
                        d 
                    
                                     
                
                
                多默认参数,多个参数有默认值
             
                     
                
            
                        
                
                                        
                        d 
                    
                                        
                        e 
                    
                                        
                        f 
                    
                                        
                          
                    
                                        
                        s 
                    
                                        
                        u 
                    
                                        
                        m 
                    
                                        
                        _ 
                    
                                        
                        a 
                    
                                        
                        n 
                    
                                        
                        d 
                    
                                        
                        _ 
                    
                                        
                        p 
                    
                                        
                        r 
                    
                                        
                        o 
                    
                                        
                        d 
                    
                                        
                        u 
                    
                                        
                        c 
                    
                                        
                        t 
                    
                                        
                        ( 
                    
                                        
                        a 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        b 
                    
                                        
                        ) 
                    
                                        
                        : 
                    
                                        
                          
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                        t 
                    
                                        
                        u 
                    
                                        
                        r 
                    
                                        
                        n 
                    
                                        
                        ( 
                    
                                        
                        a 
                    
                                        
                          
                    
                                        
                        + 
                    
                                        
                          
                    
                                        
                        b 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        a 
                    
                                        
                          
                    
                                        
                        * 
                    
                                        
                          
                    
                                        
                        b 
                    
                                        
                        ) 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        s 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        p 
                    
                                        
                          
                    
                                        
                        = 
                    
                                        
                          
                    
                                        
                        s 
                    
                                        
                        u 
                    
                                        
                        m 
                    
                                        
                        _ 
                    
                                        
                        a 
                    
                                        
                        n 
                    
                                        
                        d 
                    
                                        
                        _ 
                    
                                        
                        p 
                    
                                        
                        r 
                    
                                        
                        o 
                    
                                        
                        d 
                    
                                        
                        u 
                    
                                        
                        c 
                    
                                        
                        t 
                    
                                        
                        ( 
                    
                                        
                        2 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        3 
                    
                                        
                        ) 
                    
                                     
                
                
                多返回值,函数返回元组实现多返回值