- 
                
塑料小白
                
                
                0星
             
            - 
                
一指青铜
                
                
                100星
             
            - 
                
二指白银
                
                
                200星
             
            - 
                
十指黄金
                
                
                300星
             
            - 
                
流云蓝珀
                
                
                400星
             
            - 
                
幻影钻石
                
                
                500星
             
            - 
                
键影星耀
                
                
                800星
             
            - 
                
神速大师
                
                
                1000星
             
            - 
                
键舞王者
                
                
                200CPM
             
            - 
                
星河宗师
                
                
                400CPM
             
        
     
    
  
    
    
        闯关失败!💔
        你打错了太多字,再接再厉吧!
        
            
        
     
   
        
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
                
            
                        
                
                
                [truː ænd fɔːls]
                逻辑与运算,两个条件都为真才返回真
             
                     
                
                
                
                
                
                
                
            
                        
                
                                        
                        x 
                    
                                        
                          
                    
                                        
                        = 
                    
                                        
                          
                    
                                        
                        [ 
                    
                                        
                        1 
                    
                                        
                        ] 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        y 
                    
                                        
                          
                    
                                        
                        = 
                    
                                        
                          
                    
                                        
                        [ 
                    
                                        
                        1 
                    
                                        
                        ] 
                    
                                        
                        ; 
                    
                                        
                          
                    
                                        
                        x 
                    
                                        
                          
                    
                                        
                        i 
                    
                                        
                        s 
                    
                                        
                          
                    
                                        
                        n 
                    
                                        
                        o 
                    
                                        
                        t 
                    
                                        
                          
                    
                                        
                        y 
                    
                                     
                
                
                非身份运算,判断是否不是同一对象
             
                     
                
                
            
                        
                
                                        
                        " 
                    
                                        
                        x 
                    
                                        
                        " 
                    
                                        
                          
                    
                                        
                        n 
                    
                                        
                        o 
                    
                                        
                        t 
                    
                                        
                          
                    
                                        
                        i 
                    
                                        
                        n 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        a 
                    
                                        
                        p 
                    
                                        
                        p 
                    
                                        
                        l 
                    
                                        
                        e 
                    
                                        
                        " 
                    
                                     
                
                
                非成员运算,判断元素是否不在序列中
             
                     
                
                
                
                
                
                
                
                
            
                        
                
                                        
                        1 
                    
                                        
                        0 
                    
                                        
                          
                    
                                        
                        / 
                    
                                        
                          
                    
                                        
                        2 
                    
                                        
                          
                    
                                        
                        = 
                    
                                        
                        = 
                    
                                        
                          
                    
                                        
                        5 
                    
                                        
                          
                    
                                        
                        a 
                    
                                        
                        n 
                    
                                        
                        d 
                    
                                        
                          
                    
                                        
                        3 
                    
                                        
                          
                    
                                        
                        < 
                    
                                        
                          
                    
                                        
                        6 
                    
                                     
                
                
                混合运算,结合比较和逻辑运算符
             
                     
                
            
                        
                
                                        
                        " 
                    
                                        
                        h 
                    
                                        
                        e 
                    
                                        
                        l 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        " 
                    
                                        
                          
                    
                                        
                        + 
                    
                                        
                          
                    
                                        
                        " 
                    
                                        
                        " 
                    
                                        
                          
                    
                                        
                        + 
                    
                                        
                        " 
                    
                                        
                        w 
                    
                                        
                        o 
                    
                                        
                        r 
                    
                                        
                        l 
                    
                                        
                        d 
                    
                                        
                        " 
                    
                                     
                
                
                字符串加法,拼接多个字符串
             
                     
                
                
            
                         3">
                
                                        
                        l 
                    
                                        
                        e 
                    
                                        
                        n 
                    
                                        
                        ( 
                    
                                        
                        " 
                    
                                        
                        h 
                    
                                        
                        e 
                    
                                        
                        l 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        " 
                    
                                        
                        ) 
                    
                                        
                          
                    
                                        
                        > 
                    
                                        
                          
                    
                                        
                        3 
                    
                                     
                
                
                函数结果比较,用函数返回值进行比较
             
                     
                
                
                
                
                
                
            
                        
                
                                        
                        r 
                    
                                        
                        o 
                    
                                        
                        u 
                    
                                        
                        n 
                    
                                        
                        d 
                    
                                        
                        ( 
                    
                                        
                        3 
                    
                                        
                        . 
                    
                                        
                        1 
                    
                                        
                        4 
                    
                                        
                        1 
                    
                                        
                        5 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        2 
                    
                                        
                        ) 
                    
                                     
                
                
                四舍五入函数,保留指定小数位数
             
                     
                
                
            
                        
                
                                        
                        f 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        a 
                    
                                        
                        t 
                    
                                        
                        ( 
                    
                                        
                        " 
                    
                                        
                        3 
                    
                                        
                        . 
                    
                                        
                        1 
                    
                                        
                        4 
                    
                                        
                        " 
                    
                                        
                        ) 
                    
                                     
                
                
                浮点数转换函数,将其他类型转为浮点数
             
                     
                
                
                
            
                        
                
                                        
                        l 
                    
                                        
                        e 
                    
                                        
                        n 
                    
                                        
                        ( 
                    
                                        
                        " 
                    
                                        
                        p 
                    
                                        
                        y 
                    
                                        
                        t 
                    
                                        
                        h 
                    
                                        
                        o 
                    
                                        
                        n 
                    
                                        
                        " 
                    
                                        
                        ) 
                    
                                     
                
                
                长度函数,返回序列的长度
             
                     
                
            
                        
                
                                        
                        s 
                    
                                        
                        o 
                    
                                        
                        r 
                    
                                        
                        t 
                    
                                        
                        e 
                    
                                        
                        d 
                    
                                        
                        ( 
                    
                                        
                        [ 
                    
                                        
                        3 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        1 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        2 
                    
                                        
                        ] 
                    
                                        
                        ) 
                    
                                     
                
                
                排序函数,返回排序后的列表
             
                     
                
            
                        
                
                                        
                        a 
                    
                                        
                        n 
                    
                                        
                        y 
                    
                                        
                        ( 
                    
                                        
                        [ 
                    
                                        
                        f 
                    
                                        
                        a 
                    
                                        
                        l 
                    
                                        
                        s 
                    
                                        
                        e 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        t 
                    
                                        
                        r 
                    
                                        
                        u 
                    
                                        
                        e 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        f 
                    
                                        
                        a 
                    
                                        
                        l 
                    
                                        
                        s 
                    
                                        
                        e 
                    
                                        
                        ] 
                    
                                        
                        ) 
                    
                                     
                
                
                任一函数,判断序列中是否有真值
             
                     
                
            
                        
                
                                        
                        a 
                    
                                        
                        l 
                    
                                        
                        l 
                    
                                        
                        ( 
                    
                                        
                        [ 
                    
                                        
                        t 
                    
                                        
                        r 
                    
                                        
                        u 
                    
                                        
                        e 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        t 
                    
                                        
                        r 
                    
                                        
                        u 
                    
                                        
                        e 
                    
                                        
                        , 
                    
                                        
                          
                    
                                        
                        f 
                    
                                        
                        a 
                    
                                        
                        l 
                    
                                        
                        s 
                    
                                        
                        e 
                    
                                        
                        ] 
                    
                                        
                        ) 
                    
                                     
                
                
                所有函数,判断序列中是否全为真值