policy機(jī)制中經(jīng)典的python用法

由于接觸python時(shí)間還不長，屬于邊用邊學(xué)，在看項(xiàng)目代碼的時(shí)候，遇到了很多不太懂的python語法，但是我認(rèn)為這些用法用的實(shí)在是好，希望以后自己在寫程序時(shí)，也能寫出這么經(jīng)典的代碼，在這里記錄下來這些：

1. 將函數(shù)名作為參數(shù)傳遞給另一個(gè)模塊中的函數(shù)使用：
[python] view plaincopy

    def init():  
        ......  
        #read_cached_file做的事是讀取_POLICY_PATH文件中的數(shù)據(jù)，和這個(gè)文件修改的時(shí)間，保存到_POLICY_CACHE字典中，  
        #然后使用_set_rules(data)來解析這些數(shù)據(jù)，最后返回這些數(shù)據(jù)。  
        utils.read_cached_file(_POLICY_PATH, _POLICY_CACHE,  
                               reload_func=_set_rules)  
       
    def _set_rules(data):  
        default_rule = CONF.policy_default_rule  
        policy.set_rules(policy.Rules.load_json(data, default_rule))  


2. 類方法的使用

[python] view plaincopy

    class Rules(dict):  
        @classmethod  
        def load_json(cls, data, default_rule=None):  
       
            rules = dict((k, parse_rule(v)) for k, v in  
                         jsonutils.loads(data).items())  
       
            return cls(rules, default_rule)  

以前一直弄不清楚類方法和靜態(tài)方法的區(qū)別，都是通過類名去調(diào)用，但是現(xiàn)在清楚了，類方法有一個(gè)很好的特性，就是它可以在創(chuàng)建類對(duì)象之前，做一些初始化的工作，這樣創(chuàng)建的對(duì)象，比直接調(diào)用Rules()，更靈活。

這里還想說一下繼承自dict這個(gè)特性，通過覆蓋父類中的方法，__missing__()，__str__()等定制了一個(gè)自己的字典類型，用起來很舒服啊。

3. 解釋器的使用

[python] view plaincopy

    _checks = {}  
       
    def register(name, func=None):  
        def decorator(func):  
            _checks[name] = func  
            return func  
        if func:  
            return decorator(func)  
       
        return decorator  
      
    @register("rule")  
    class RuleCheck(Check):  
        pass  
      
    @register("role")  
    class RoleCheck(Check):  
        pass  

文檔在加載的時(shí)候，每遇到一個(gè)@register()修飾符，就會(huì)將被修飾的類添加到_check變量中，簡潔方便。

4. yield的使用
yield在我看來，是一種能夠間斷的循環(huán)，一直都不太會(huì)用它，policy中在解析復(fù)合rule時(shí)，就用到了yield:

[python] view plaincopy

    state = ParseState()   
        for tok, value in _parse_tokenize(rule):  
            state.shift(tok, value)  
       
    # 這個(gè)函數(shù)主要是將規(guī)則的字符串進(jìn)行了一下預(yù)處理，然后調(diào)用_parse_check()最終將字符串轉(zhuǎn)換成BaseCheck對(duì)象  
    def _parse_tokenize(rule):  
        #這段代碼的意思是將一個(gè)字符串以空格為間隔，重組為一個(gè)字符串的列表，如：  
        # a.split('(is_admin:True or project_id:%(project_id)s)')  
        # ['(is_admin:True', 'or', 'project_id:%(project_id)s)']  
        for tok in _tokenize_re.split(rule):  
            # Skip empty tokens  
            if not tok or tok.isspace():  
                continue  
       
            # Handle leading parens on the token  
            clean = tok.lstrip('(')  
            for i in range(len(tok) - len(clean)):  
                yield '(', '('  
       
            # If it was only parentheses, continue  
            if not clean:  
                continue  
            else:  
                tok = clean  
       
            # Handle trailing parens on the token  
            clean = tok.rstrip(')')  
            trail = len(tok) - len(clean)  
       
            # Yield the cleaned token  
            lowered = clean.lower()  
            if lowered in ('and', 'or', 'not'):  
                # Special tokens  
                yield lowered, clean  
            elif clean:  
                # Not a special token, but not composed solely of ')'  
                if len(tok) >= 2 and ((tok[0], tok[-1]) in  
                                      [('"''"', '"'), ("'""'", "'")]):  
                    # It's a quoted string  
                    yield 'string', tok[1:-1]  
                else:  
                    yield 'check', _parse_check(clean)  
       
            # Yield the trailing parens  
            for i in range(trail):  
                yield ')', ')'  

程序中每遇到一個(gè)yield，就會(huì)中斷當(dāng)前的執(zhí)行，返回值，然后由外部的for循環(huán)進(jìn)行處理，處理完之后，再回到剛才中斷的地方繼續(xù)執(zhí)行。

5. 元類的使用
元類以前從來沒有接觸過，policy里也用到了，還是在解析復(fù)合rule的時(shí)候，用的這個(gè)元類：ParseStateMeta，通過使用元類，可以自定義某些類是如何創(chuàng)建的，從根本上說賦予你如何創(chuàng)建類的控制權(quán)：
[python] view plaincopy

    class ParseStateMeta(type):  
        # name是子類的類名，bases是子類的數(shù)據(jù)，cls_dict是子類中的屬性  
        def __new__(cls, name, bases, cls_dict):  
       
            reducers = []  
       
            # key為屬性名，value為屬性的對(duì)象，如：  
            # shift : <function shift at 0xa27b4fc>  
            # _make_not_expr : <function _make_not_expr at 0xa27b6bc>  
            for key, value in cls_dict.items():  
                if not hasattr(value, 'reducers'):# 如果沒有包含reducers屬性，即那些沒有@reducer修飾的方法  
                    continue  
                for reduction in value.reducers:# 遍歷某個(gè)函數(shù)中的reducers列表，把它添加到元類中的reducers列表中  
                    reducers.append((reduction, key))  
       
            cls_dict['reducers'] = reducers  
            return super(ParseStateMeta, cls).__new__(cls, name, bases, cls_dict)  
       
    # 雖然只是簡單的定義了一個(gè)ParseState對(duì)象，但是卻做了很多的事：  
    # 1.@reducer修飾器給被裝飾的的方法添加了reducers列表，并且將修飾器的參數(shù)建成一個(gè)列表添加到該列表中;  
    #   -->形式如：[['','',''],['','','']],  
    #        再如：[['(', 'or_expr', ')'], ['(', 'and_expr', ')'], ['(', 'check', ')']]  
    # 2.ParseStateMeta元類創(chuàng)建了一個(gè)reducers變量（針對(duì)于ParseState是全局的），也是一個(gè)列表,  
    #   然后遍歷了ParseState的所有屬性，找到有reducers屬性的屬性(即帶有@reducer的方法)，  
    #   然后再遍歷該方法的reducers列表，將列表的每一項(xiàng)和該方法的名字組合成一個(gè)元組，存放在reducers變量中;  
    #   -->形式如：[(['','',''],funcname),(['','',''],funcname),(['','',''],funcname)]  
    #       再如：[(['check', 'or', 'check'], '_make_or_expr'), (['or_expr', 'or', 'check'], '_extend_or_expr')]  
    class ParseState(object):  
        __metaclass__ = ParseStateMeta  
        ......  
6. 遞歸的使用

[python] view plaincopy

    def reduce(self):  
        #a[-3:]表示a這個(gè)列表的最后三個(gè)數(shù)  
        for reduction, methname in self.reducers:  
            # 如果當(dāng)前的tokens的長度大于reduction的長度，并且tokens的最后幾個(gè)和reduction相同  
            # 即模式匹配，則調(diào)用相應(yīng)的方法來進(jìn)行復(fù)合判斷  
            # 什么情況不執(zhí)行這段呢？  
            # 1. 沒有復(fù)合的規(guī)則  
            # 2. 復(fù)合的規(guī)則和reduction不匹配  
            # 這兩種情況下，就不執(zhí)行復(fù)合，直接返回的還是原來的對(duì)象：RuleCheck, RoleCheck, HttpCheck, GenericCheck  
            # 如果復(fù)合的話，返回的是復(fù)合對(duì)象：OrCheck, AndCheck, NotCheck  
            if (len(self.tokens) >= len(reduction) and  
                self.tokens[-len(reduction):] == reduction):  
                    # Get the reduction method  
                    meth = getattr(self, methname)  
      
                    # Reduce the token stream  
                    # 有兩個(gè)GenericCheck對(duì)象和一個(gè)‘or’，傳遞給_make_or_expr()方法，用這兩個(gè)  
                    # 對(duì)象構(gòu)造了一個(gè)OrCheck對(duì)象，該對(duì)象的返回值，是按照這兩個(gè)GenericCheck對(duì)象在的  
                    # target和creds上能否執(zhí)行的真假來進(jìn)行或操作得到的  
                    results = meth(*self.values[-len(reduction):])  
      
                    # Update the tokens and values  
                    self.tokens[-len(reduction):] = [r[0] for r in results]  
                    self.values[-len(reduction):] = [r[1] for r in results]  
      
                    # Check for any more reductions  
                    return self.reduce()