- 
                
塑料小白
                
                
                0星
             
            - 
                
一指青铜
                
                
                100星
             
            - 
                
二指白银
                
                
                200星
             
            - 
                
十指黄金
                
                
                300星
             
            - 
                
流云蓝珀
                
                
                400星
             
            - 
                
幻影钻石
                
                
                500星
             
            - 
                
键影星耀
                
                
                800星
             
            - 
                
神速大师
                
                
                1000星
             
            - 
                
键舞王者
                
                
                200CPM
             
            - 
                
星河宗师
                
                
                400CPM
             
        
     
    
  
    
    
        闯关失败!💔
        你打错了太多字,再接再厉吧!
        
            
        
     
   
        
                
            
                        
                
                                        
                        p 
                    
                                        
                        r 
                    
                                        
                        i 
                    
                                        
                        n 
                    
                                        
                        t 
                    
                                        
                        ( 
                    
                                        
                        " 
                    
                                        
                        h 
                    
                                        
                        e 
                    
                                        
                        l 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        " 
                    
                                        
                        ) 
                    
                                     
                
                
                打印字符串,输出文本到控制台
             
                     
                
                
                
            
                        
                
                                        
                        p 
                    
                                        
                        r 
                    
                                        
                        i 
                    
                                        
                        n 
                    
                                        
                        t 
                    
                                        
                        ( 
                    
                                        
                        " 
                    
                                        
                        a 
                    
                                        
                        " 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        b 
                    
                                        
                        " 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        s 
                    
                                        
                        e 
                    
                                        
                        p 
                    
                                        
                        = 
                    
                                        
                        " 
                    
                                        
                        - 
                    
                                        
                        " 
                    
                                        
                        ) 
                    
                                     
                
                
                设置分隔符,用指定字符分隔输出项
             
                     
                
            
                        
                
                                        
                        p 
                    
                                        
                        r 
                    
                                        
                        i 
                    
                                        
                        n 
                    
                                        
                        t 
                    
                                        
                        ( 
                    
                                        
                        " 
                    
                                        
                        h 
                    
                                        
                        e 
                    
                                        
                        l 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        " 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        e 
                    
                                        
                        n 
                    
                                        
                        d 
                    
                                        
                        = 
                    
                                        
                        " 
                    
                                        
                        ! 
                    
                                        
                        " 
                    
                                        
                        ) 
                    
                                     
                
                
                设置结束符,改变输出的结束字符
             
                     
                
                
            
                        
                
                                        
                        n 
                    
                                        
                        a 
                    
                                        
                        m 
                    
                                        
                        e 
                    
                                        
                          
                    
                                        
                        = 
                    
                                        
                          
                    
                                        
                        i 
                    
                                        
                        n 
                    
                                        
                        p 
                    
                                        
                        u 
                    
                                        
                        t 
                    
                                        
                        ( 
                    
                                        
                        " 
                    
                                        
                        e 
                    
                                        
                        n 
                    
                                        
                        t 
                    
                                        
                        e 
                    
                                        
                        r 
                    
                                        
                          
                    
                                        
                        n 
                    
                                        
                        a 
                    
                                        
                        m 
                    
                                        
                        e 
                    
                                        
                        : 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        ) 
                    
                                     
                
                
                带提示输入,显示提示信息后获取输入
             
                     
                
                
                
            
                        
                
                                        
                        l 
                    
                                        
                        e 
                    
                                        
                        n 
                    
                                        
                        ( 
                    
                                        
                        { 
                    
                                        
                        " 
                    
                                        
                        a 
                    
                                        
                        " 
                    
                                        
                        : 
                    
                                        
                        1 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        b 
                    
                                        
                        " 
                    
                                        
                        : 
                    
                                        
                        2 
                    
                                        
                        } 
                    
                                        
                        ) 
                    
                                     
                
                
                字典长度,返回字典的键值对数量
             
                     
                
                
                
            
                        
                
                                        
                        f 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        a 
                    
                                        
                        t 
                    
                                        
                        ( 
                    
                                        
                        " 
                    
                                        
                        3 
                    
                                        
                        . 
                    
                                        
                        1 
                    
                                        
                        4 
                    
                                        
                        " 
                    
                                        
                        ) 
                    
                                     
                
                
                字符串转浮点数,将字符串转为为浮点数
             
                     
                
                
                
                
                
            
                        
                
                                        
                        b 
                    
                                        
                        o 
                    
                                        
                        o 
                    
                                        
                        l 
                    
                                        
                        ( 
                    
                                        
                        " 
                    
                                        
                        h 
                    
                                        
                        e 
                    
                                        
                        l 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        " 
                    
                                        
                        ) 
                    
                                     
                
                
                字符串转布尔值,非空字符串转为True
             
                     
                
                
                
            
                        
                
                                        
                        m 
                    
                                        
                        a 
                    
                                        
                        x 
                    
                                        
                        ( 
                    
                                        
                        [ 
                    
                                        
                        " 
                    
                                        
                        a 
                    
                                        
                        " 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        b 
                    
                                        
                        " 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        c 
                    
                                        
                        " 
                    
                                        
                        ] 
                    
                                        
                        ) 
                    
                                     
                
                
                求字符串最大值,返回字符串列表中的最大值
             
                     
                
                
                
                
            
                        
                
                                        
                        s 
                    
                                        
                        u 
                    
                                        
                        m 
                    
                                        
                        ( 
                    
                                        
                        ( 
                    
                                        
                        1 
                    
                                        
                        0 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        2 
                    
                                        
                        0 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        3 
                    
                                        
                        0 
                    
                                        
                        ) 
                    
                                        
                        ) 
                    
                                     
                
                
                元组求和,计算元组中元素的总和
             
                     
                
                
                
            
                        
                
                                        
                        r 
                    
                                        
                        o 
                    
                                        
                        u 
                    
                                        
                        n 
                    
                                        
                        d 
                    
                                        
                        ( 
                    
                                        
                        3 
                    
                                        
                        . 
                    
                                        
                        1 
                    
                                        
                        4 
                    
                                        
                        1 
                    
                                        
                        5 
                    
                                        
                        ) 
                    
                                     
                
                
                四舍五入,对数值进行四舍五入
             
                     
                
            
                        
                
                                        
                        r 
                    
                                        
                        o 
                    
                                        
                        u 
                    
                                        
                        n 
                    
                                        
                        d 
                    
                                        
                        ( 
                    
                                        
                        3 
                    
                                        
                        . 
                    
                                        
                        1 
                    
                                        
                        4 
                    
                                        
                        1 
                    
                                        
                        5 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        2 
                    
                                        
                        ) 
                    
                                     
                
                
                指定小数位四舍五入,保留指定小数位数
             
                     
                
                
                
            
                        
                
                                        
                        s 
                    
                                        
                        o 
                    
                                        
                        r 
                    
                                        
                        t 
                    
                                        
                        e 
                    
                                        
                        d 
                    
                                        
                        ( 
                    
                                        
                        [ 
                    
                                        
                        3 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        1 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        2 
                    
                                        
                        ] 
                    
                                        
                        ) 
                    
                                     
                
                
                列表排序,返回排序后的新列表
             
                     
                
            
                        
                
                                        
                        s 
                    
                                        
                        o 
                    
                                        
                        r 
                    
                                        
                        t 
                    
                                        
                        e 
                    
                                        
                        d 
                    
                                        
                        ( 
                    
                                        
                        " 
                    
                                        
                        c 
                    
                                        
                        a 
                    
                                        
                        b 
                    
                                        
                        " 
                    
                                        
                        ) 
                    
                                     
                
                
                字符串排序,返回排序后的字符列表
             
                     
                
            
                        
                
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                        v 
                    
                                        
                        e 
                    
                                        
                        r 
                    
                                        
                        s 
                    
                                        
                        e 
                    
                                        
                        d 
                    
                                        
                        ( 
                    
                                        
                        [ 
                    
                                        
                        1 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        2 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        3 
                    
                                        
                        ] 
                    
                                        
                        ) 
                    
                                     
                
                
                反转序列,返回反转后的迭代器
             
                     
                
            
                        
                
                                        
                        l 
                    
                                        
                        i 
                    
                                        
                        s 
                    
                                        
                        t 
                    
                                        
                        ( 
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                        v 
                    
                                        
                        e 
                    
                                        
                        r 
                    
                                        
                        s 
                    
                                        
                        e 
                    
                                        
                        d 
                    
                                        
                        ( 
                    
                                        
                        [ 
                    
                                        
                        1 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        2 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        3 
                    
                                        
                        ] 
                    
                                        
                        ) 
                    
                                        
                        ) 
                    
                                     
                
                
                反转列表,将反转迭代器转为列表
             
                     
                
                
                
            
                        
                
                                        
                        r 
                    
                                        
                        a 
                    
                                        
                        n 
                    
                                        
                        g 
                    
                                        
                        e 
                    
                                        
                        ( 
                    
                                        
                        1 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        1 
                    
                                        
                        0 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        2 
                    
                                        
                        ) 
                    
                                     
                
                
                带步长范围,创建间隔为2的整数范围
             
                     
                
            
                        
                
                                        
                        a 
                    
                                        
                        l 
                    
                                        
                        l 
                    
                                        
                        ( 
                    
                                        
                        [ 
                    
                                        
                        t 
                    
                                        
                        r 
                    
                                        
                        u 
                    
                                        
                        e 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        t 
                    
                                        
                        r 
                    
                                        
                        u 
                    
                                        
                        e 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        f 
                    
                                        
                        a 
                    
                                        
                        l 
                    
                                        
                        s 
                    
                                        
                        e 
                    
                                        
                        ] 
                    
                                        
                        ) 
                    
                                     
                
                
                全为真检查,判断所有元素是否为真
             
                     
                
            
                        
                
                                        
                        a 
                    
                                        
                        n 
                    
                                        
                        y 
                    
                                        
                        ( 
                    
                                        
                        [ 
                    
                                        
                        f 
                    
                                        
                        a 
                    
                                        
                        l 
                    
                                        
                        s 
                    
                                        
                        e 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        t 
                    
                                        
                        r 
                    
                                        
                        u 
                    
                                        
                        e 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        f 
                    
                                        
                        a 
                    
                                        
                        l 
                    
                                        
                        s 
                    
                                        
                        e 
                    
                                        
                        ] 
                    
                                        
                        ) 
                    
                                     
                
                
                存在真检查,判断是否有元素为真
             
                     
                
            
                        
                
                                        
                        e 
                    
                                        
                        n 
                    
                                        
                        u 
                    
                                        
                        m 
                    
                                        
                        e 
                    
                                        
                        r 
                    
                                        
                        a 
                    
                                        
                        t 
                    
                                        
                        e 
                    
                                        
                        ( 
                    
                                        
                        [ 
                    
                                        
                        " 
                    
                                        
                        a 
                    
                                        
                        " 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        b 
                    
                                        
                        " 
                    
                                        
                        ] 
                    
                                        
                        ) 
                    
                                     
                
                
                枚举序列,返回索引和元素的迭代器