Python Base.any_2list方法代码示例

# 需要导入模块: from Base import Base [as 别名]
# 或者: from Base.Base import any_2list [as 别名]
class DatabaseProc(object):
    
    def __init__(self):
        self.dbobj=DatabaseInterface()
        self.wp=StockInterfaceWrap()
        self.base=Base()
    
    
    #返回list
    def _get_grp(self,grpnam,grpsubnams):
        db_table=tables.stockgrps_table_struct
        collnam=db_table['collnam']
        filter_dic={ "grpnam":grpnam}   
        sel_fields=self.base.any_2list(grpsubnams)
        return self.dbobj.db_findone(filter_dic,sel_fields,collnam)[0]
    
    
    def get_tickerall(self):
        grpnam='tickers'
        grpsubnams=['tk_all']
        return self._get_grp(grpnam,grpsubnams)
    
    def get_tickerconcept(self,connam):
        grpnam='concepts'
        
        if type(connam)==str:
            connam=unicode(connam,encoding='utf-8')
            
        grpsubnams=[connam]
        return self._get_grp(grpnam,grpsubnams)
    
    #获取当日次新股列表
    def get_tickercxg(self,date):
        collnam='stockinfo'
        year=365
        sel_fields=['ticker','timeToMarket']
        df=self.dbobj.db_find(sel_fields,collnam)
        mask=[self.base.date_minus(date,str(x))<=year if len(x)==10 else False for x in df['timeToMarket']]
        return df.ix[mask]
    
    #获取当日开始打新的冻结资金
    def get_amtdx(self):
        pass
    
    #获取今日上市的新股
    def get_tickerxg(self):
        pass
    
    
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        

# 需要导入模块: from Base import Base [as 别名]
# 或者: from Base.Base import any_2list [as 别名]
class DatabaseUpdate(object):
    
    def __init__(self):
        self.dbobj=DatabaseInterface()
        self.wp=StockInterfaceWrap()
        self.proc=StockDataProc()
        self.db_proc=DatabaseProc()
        self.base=Base()
    
    
    #默认数据库语句的建立方式为pd_df2diclist
    def _update_build_paras(self,df,keyindex=0):
        
        hd_method=self.base.pd_df2diclist
        #将索引值转化格式
        #索引可能是int或是list of int,为了便于处理，把int转为list
        keyindex=self.base.any_2list(keyindex)
        leftindex=self.base.lists_minus(range(len(df.columns)),keyindex)
        
        #建立数据库查询字典列表，由于列表可能很长，改为iter
        filt=iter(hd_method(df[keyindex]))
        #建立数据库更新字典表，由于列表可能很长，改为iter
        update=iter(hd_method(df[leftindex]))
        
        return (filt,update)
    
    def _update_arrayinsert(self,db_table,filter_val,update_key,update_val):
        updatecollnam=db_table['collnam']
        indexnam=db_table['itemnams'][0]
        
        filter_dic={indexnam:filter_val}
        update_dic=self.base.lists_2dict(update_key,update_val)
        
        self.dbobj.db_insertarray_many(filter_dic,update_dic,updatecollnam)
        
    def _update_updateiter(self,db_table,crawl_data):
        
        if crawl_data.empty:
            print 'no data...pass...'
            return -1
        #获取数据库索引项名称，更新时按照此索引更新
        keyindex=db_table['keyindex']
        #获取需要更新的数据库的表名
        updatecollnam=db_table['collnam']
        
        print updatecollnam+':start updating data.....'
        #------数据批量更新------
        #建立批量数据更新语句
        df_proc=crawl_data
        db_filt_list,db_update_list=self._update_build_paras(df_proc,keyindex)
         #批量更新
        self.dbobj.db_updatemultiprocess(db_filt_list,db_update_list,updatecollnam)
        
    def _update_insertarriter(self,db_table,crawl_data):
        if crawl_data.empty:
            print '无数据...跳过...'
            return -1
        #获取数据库索引项名称，更新时按照此索引更新
        keyindex=db_table['keyindex']
        #获取需要更新的数据库的表名
        updatecollnam=db_table['collnam']
        
        print updatecollnam+':StoBas part 开始初次插入数据.....'
        #------数据批量更新------
        #建立批量数据更新语句
        df_proc=crawl_data
        db_filt_list,db_update_list=self._update_build_paras(df_proc,keyindex)
         #批量更新
        print '批量更新数据....'
        self.dbobj.db_updateiter(db_filt_list,db_update_list,updatecollnam,self.dbobj.db_insertarray_one)
        
        
    def _insert_many(self,df,collnam,index_id=0,useiter=False):
         if not df.index.name is None:
                df.reset_index(level=index_id, inplace=True)
                
         insert_data=self.base.pd_df2diclist(df)
         #插入数据
         if useiter:
             self.dbobj.db_insertmultiprocess(insert_data,collnam)
         else:
             self.dbobj.db_insertmany(insert_data,collnam)
         self.dbobj.db_ensure_index(collnam,df.columns[index_id],unique=True)

    
    def _insert_initwithindex(self,tb,index_vals,index_id=0):
         insertcollnam=tb['collnam']
         insertitemnams=tb['itemnams']
         insertitemvals=tb['itemvals']
         #使用insert命令插入若干数据
         #构建insertone语句插入若干文件，格式：[{itemnam1:value1,itemnam2:value2},{itemnam1:value3,itemnam2:value4}]

         index_vals=self.base.any_2list(index_vals)
         
         df=pd.DataFrame(index=index_vals,columns=insertitemnams[1:])
         df.index.name=insertitemnams[index_id]
         
         m=len(index_vals)
         
         for x,y in zip(df.columns,insertitemvals):
#.........这里部分代码省略.........

# 需要导入模块: from Base import Base [as 别名]
# 或者: from Base.Base import any_2list [as 别名]
class DataCapture(object):
    
    def __init__(self,token=settings.token):
        self.token=settings.token
        self.base=Base()
    
    def isEmptydf(self,df):
        return df is None or min(df.shape)==0
    
        #数据抓取,实现网络问题时重新抓取
    #参数说明：
    #request_itf[function]：request的接口函数，如fd.FundDiv
    #*args, **kwargs:request的接口函数参数
    #返回：
    #视接口函数返回而定，tushare和通联的返回pd.dataframe
    #**如果返回值为空，则也返回
    def data_request(self,request_itf,*args, **kwargs):
        
        for i in range(settings.try_times):
            try:
                res=request_itf(*args, **kwargs)
            except KeyboardInterrupt:
                print '连接出错，第'+str(i)+'重试中......'
                time.sleep(settings.sleep_time)
                continue
            break
        if res is None:
            pass#LOG
        return res

    
    #抽取数据中的行、列  考虑使用PandaSQL
    #df--pd.dataframe,带抽取的数据框
    #select_colnams--list of str or str,df的列名
    #select_rows--dict, {'colnam':[rowvalues],'colnam':[rowvalues]...}
    #返回：
    #如果select_xxx是列表，则返回pd.df；如果是str，则返回pd.series
    def data_extract(self,df,select_colnams=defaultna,select_rows=defaultna):
        
        #抽取列
        #列名不存在，返回non
        def data_extractcol(df,select_colnams):
            if select_colnams in emptylist:
                return df
            else:
                try:
                    return df[select_colnams]
                except KeyError:
                    pass#LOG
                    return defaultna
        
        #按照index值抽取行
        def _data_extractrow_byindex(df,index_vals):
            if index_vals in emptylist:
                return df
            try:
                return df.loc[df.index.isin(index_vals)]
            except KeyError:
                pass#LOG
                return defaultna
        
        #按行的值抽取行
        def _data_extractrow_byval(df,col_nam,row_vals):
            if row_vals in emptylist:
                return df
                
            row_vals=self.base.any_2list(row_vals)
            
            try:
                return df.loc[df[col_nam].isin(row_vals)]
            except KeyError:
                pass#LOG
                return defaultna 
        
        #行名不存在返回空df
        def data_extractrow(df,select_rows):
            if select_rows in emptylist:
                return df
            
            indexnam=df.index.name
            
            for colnam,rowval in select_rows.items():
                df=_data_extractrow_byindex(df,rowval) if colnam==indexnam \
                    else _data_extractrow_byval(df,colnam,rowval)
            return df
            
        df_rowextracted=data_extractrow(df,select_rows)
        
        return df_rowextracted if self.isEmptydf(df_rowextracted) \
            else data_extractcol(df_rowextracted,select_colnams)

    
    #所有接口通用的数据抓取流程    
        
    def data_capture_flow(self,request_itf,select_colnams=defaultna,
                      select_rows=defaultna,*args,**kwargs):
                          
        datadf=self.data_request(request_itf,*args, **kwargs)
        datadf_extracted=self.data_extract(datadf,select_colnams,select_rows)
        return datadf_extracted