django 自定义分页类改善，适用于于条件查询等操作，提高灵活性

之前的一篇文章 http://blog.youkuaiyun.com/u011085172/article/details/71405043  里面写到的自定义分页类，因在代码中只能对数据库表进行all()方式的查询操作，

不能满足filter或者其他的条件查询，刚好今天碰到要用，于是改善了下代码：

class Pagination(object):  
    """分页基础类"""  
    """通过给的model和分页参数对相关model进行分页 
        Args:  
            from_name: 导入模块的 from后面的参数 
                from {from_name} import model_name 
            mode_name: 需要导入的模块名 
                from from_name import {model_name} 
            cur_page: 当前显示的是第几页 
            start_page_omit_symbol: 超出的页数使用怎么样的省略号(前) 
                ... 2 3 4 
            end_page_omit_symbol: 超出的页数使用怎么样的省略号(后) 
                1 2 3 4 ... 
            one_page_data_size: 每一页显示几行 
            show_page_item_len: 显示几个能点击的页数 
        Return:  
            pagination: dict 
                    pagination = {  
                        'objs': objs, # 需要显示model数据 
                        'all_obj_counts': all_obj_counts, # 一共多少行数据 
                        'start_pos': start_pos, # 数据分页开始的数据  
                        'end_pos': end_pos, # 数据分页结束的数据  
                        'all_page': all_page, # 一共有多少页 
                        'cur_page': cur_page, # 当前的页码 
                        'pre_page': pre_page, # 上一页的页码 
                        'next_page': next_page, # 下一页的页码 
                        'page_items': page_items, 能点击的页数 
                        'start_page_omit_symbol': start_page_omit_symbol, # 开始的省略号 
                        'end_page_omit_symbol': end_page_omit_symbol, # 结束的省略号 
                    }   
        Raise: None 
        """
    
    def __init__(self,
            from_name='', 
            model_name='',  
            cur_page=1, 
            start_page_omit_symbol = '...',  
            end_page_omit_symbol = '...', 
            one_page_data_size=1,  
            show_page_item_len=9,
            classType = ''):  
        self.from_name = from_name
        self.model_name = model_name
        self.cur_page = cur_page
        self.start_page_omit_symbol = start_page_omit_symbol
        self.end_page_omit_symbol = end_page_omit_symbol
        self.one_page_data_size = one_page_data_size
        self.show_page_item_len = show_page_item_len
        self.start_pos = (self.cur_page - 1) * self.one_page_data_size    
        self.end_pos = self.start_pos + self.one_page_data_size
        self.classType = classType
        # 如果没有输入导入模块需要的相关信息直接退出  
        if not self.from_name or not self.model_name:  
            return None
        import_str = 'from {from_name} import {model_name}'.format(  
                                          from_name = self.from_name,  
                                          model_name = self.model_name)  
        # 导入模块  
        exec import_str
    
    def getObjs(self):
        # 查找需要的model数据  
        find_objs_str = ('{model_name}.objects.all()'  
                         '[{start_pos}:{end_pos}]'.format(  
                                               model_name = self.model_name,  
                                               start_pos = self.start_pos,  
                                               end_pos = self.end_pos))
        return eval(find_objs_str)
    
    def getTotalPage(self):
        # 计算总共的页数  
        find_objs_count_str = '{model_name}.objects.count()'.format(  
                                               model_name = self.model_name)  
        all_obj_counts = eval(find_objs_count_str)
        return all_obj_counts
     
    def create_pagination(self):  
          
          
        objs = self.getObjs()
        all_obj_counts = self.getTotalPage()    
        all_page =  all_obj_counts / self.one_page_data_size 
        remain_obj = all_obj_counts % self.one_page_data_size  
        if remain_obj > 0:  
            all_page += 1  
   
        # 限制当前页不能小于1和并且大于总页数  
        cur_page = 1 if self.cur_page < 1 else self.cur_page  
        cur_page = all_page if self.cur_page > all_page else self.cur_page  
   
        # 获得显示页数的最小页  
        start_page = self.cur_page - self.show_page_item_len / 2  
        if start_page > all_page - self.show_page_item_len:  
            start_page = all_page - self.show_page_item_len + 1  
        start_page = 1 if start_page < 1 else start_page  
   
        # 获得显示页数的最大页  
        end_page = self.cur_page + self.show_page_item_len / 2  
        end_page = all_page if end_page > all_page else end_page  
        if end_page < self.show_page_item_len and all_page > self.show_page_item_len:  
            end_page = self.show_page_item_len  
   
        # 获得上一页  
        pre_page = self.cur_page - 1  
        pre_page = 1 if pre_page < 1 else pre_page  
   
        # 获得下一页  
        next_page = self.cur_page + 1  
        next_page = all_page if next_page > all_page else next_page  
   
        # 处理省略符，是否显示  
        if start_page <= 1:  
            self.start_page_omit_symbol = ''  
           
        if end_page >= all_page:  
            self.end_page_omit_symbol = ''  
   
        # 创建能点击的展示页码  
        page_items = range(start_page, end_page + 1)  
   
        pagination = {  
            'objs': objs,  
            'all_obj_counts': all_obj_counts,  
            'start_pos': self.start_pos,  
            'end_pos': self.end_pos,  
            'all_page': all_page,  
            'cur_page': self.cur_page,  
            'pre_page': pre_page,  
            'next_page': next_page,  
            'page_items': page_items,  
            'start_page_omit_symbol': self.start_page_omit_symbol,  
            'end_page_omit_symbol': self.end_page_omit_symbol,  
        }  
   
        return pagination

这个类作为基础类，在原先的基础上，把设计到数据库操作的代码封装到函数中去，便于子类对这些函数的重写

例如以下代码，示例条件查询的写法：

class AllAbstPagination(Pagination):
    '''获取所有文档摘要的类，从基础类继承
        重写getObjs函数
    '''
    def getObjs(self):
        # 查找需要的model数据  
        find_objs_str = ('{model_name}.objects.all()'  
                         '[{start_pos}:{end_pos}]'.format(  
                                               model_name = self.model_name,  
                                               start_pos = self.start_pos,  
                                               end_pos = self.end_pos))
        objs = []
        for file in eval(find_objs_str):
            objs.append(file.get_abstract())
        return objs

class ClassAbstPagination(Pagination):
    '''获取指定分类下文档摘要的类，从基础类继承
        重写getObjs和getTotalPage函数
    '''
    def getObjs(self):
        find_objs_str = ('{model_name}.objects.all()'.format(model_name = self.model_name))
        objs = []
        for file in eval(find_objs_str).filter(belongClass__in = self.classType)[self.start_pos:self.end_pos]:
            objs.append(file.get_abstract())
        return objs
    def getTotalPage(self):
        # 计算总共的页数  
        find_objs_count_str = '{model_name}.objects.all()'.format(  
                                               model_name = self.model_name)  
        all_obj_counts = eval(find_objs_count_str).filter(belongClass__in = self.classType).count()
        return all_obj_counts

如上，get_abstract()是models.py中自定义的获取表信息的函数，以上两个示例通过重写函数来实现不同的条件需求，灵活许多。