def load(self): self.parentregion = self.getParentRegion() self.sourceofdata = self.getSourceOfData() self.loadRegionalData() summarydf = pd.DataFrame(columns=self.columns) # Initalize variables tabledata = [] rwdata = [] # Derive values location = self.parentregion confirmed = self.dfRegion[ColoumnName.Totalconfirmed.value].sum() dead = self.dfRegion[ColoumnName.Death.value].sum() recovered = self.dfRegion[ ColoumnName.Cured_Discharged_Migrated.value].sum() confirmed_internal = self.dfRegion[ ColoumnName.TotalConfirmedcases_IndianNational.value].sum() confirmed_external = self.dfRegion[ ColoumnName.TotalConfirmedcases_ForeignNational.value].sum() motalityrate = dead / confirmed # Add it to the list rwdata.append(self.dtestr) rwdata.append(location) rwdata.append(confirmed) rwdata.append(dead) rwdata.append(recovered) rwdata.append(confirmed_internal) rwdata.append(confirmed_external) rwdata.append(motalityrate) # Add to master List tabledata.append(rwdata) # Assign it master dataframe self.dfSummary = pd.DataFrame(data=tabledata, columns=self.columns)
def parse_recommendations(raw_datas, recommendations_dict): columns = ['date_str', 'recommendation', 'ticker'] df = pd.DataFrame(columns=columns) ticker = '' for raw_data in raw_datas['data']: data = raw_data.replace('\t', ' ') if ' ' in data: data_splitted = data.split(' ') date_str = parse_date(data_splitted[0]) if(ticker == ''): raise SyntaxError( f'Ticker must be defined before recommendation row, line "{data}"".') recommendation = parse_recommendation_text( data_splitted[1], recommendations_dict) row = pd.DataFrame( np.array([[date_str, recommendation, ticker]]), columns=columns) if len(df) == 0: df = df.append(row) else: last_row = df.tail(1).iloc[0] if last_row['ticker'] == ticker and last_row['date_str'] >= date_str: raise ValueError( f'Ticker {ticker} has suspicious order of dates, line "{data}", previous date {last_row["date_str"]}') if last_row['ticker'] != ticker or last_row['recommendation'] != recommendation: df = df.append(row) else: if ' ' in data or ',' in data: raise ValueError( f'Ticker {ticker} has erroneous line "{data}"') if data == '-END-': return df if data != '': ticker = data return df
def _plot_flux_variability_analysis(self, index, variables=None, title=None, width=None, height=None, palette=None, grid=None): if variables is None: variables = self.reference_fva.index[0:10] title = "Compare WT solution %i" % index if title is None else title wt_fva_res = self.reference_fva.loc[variables] strain_fva_res = self.nth_panel(index).loc[variables] dataframe = pandas.DataFrame(columns=["lb", "ub", "strain", "reaction"]) for reaction_id, row in wt_fva_res.iterrows(): _df = pandas.DataFrame([[row['lower_bound'], row['upper_bound'], "WT", reaction_id]], columns=dataframe.columns) dataframe = dataframe.append(_df) for reaction_id, row in strain_fva_res.iterrows(): _df = pandas.DataFrame([[row['lower_bound'], row['upper_bound'], "Strain %i" % index, reaction_id]], columns=dataframe.columns) dataframe = dataframe.append(_df) plot = plotter.flux_variability_analysis(dataframe, grid=grid, width=width, height=height, title=title, x_axis_label="Reactions", y_axis_label="Flux limits", palette=palette) plotter.display(plot)
def save_matrices_to_csv(self, step=None): print("Saving matrix to CSV") basepath = 'matrices/' filepath = basepath + 'odm-{}' if step is not None: filepath = filepath + '-step{}'.format(step) filepath = filepath + '.csv' matrix_size = len(self.matrices['ESC1']) aggregate_matrix = np.zeros(shape=(matrix_size, matrix_size), dtype=int) labels = self.zones + ['Total'] for matrix_type in self.matrices: filename = filepath.format(matrix_type) aggregate_matrix = np.add(aggregate_matrix, self.matrices[matrix_type], dtype=int) pandas.DataFrame(self.matrices[matrix_type], index=labels, columns=labels).to_csv(filename) self.matrices['AGG'] = aggregate_matrix filename = filepath.format('aggregate') pandas.DataFrame(aggregate_matrix, index=labels, columns=labels).to_csv(filename)
def create_confusion_matrix(self, test, prediction, columns): matrix = confusion_matrix(test, prediction) if columns is not None: self.confusion_matrix = pd.DataFrame(matrix, index = columns, columns = columns) else: self.confusion_matrix = pd.DataFrame(matrix) self.indexes = IndexesCalculator(self.confusion_matrix)
def util_create_scenery(df, historic_count,drop_columns): final = df for x in range(0,100): # df['cnv_date'].size): final_data = util_scenario(df.iloc[x],df, x, historic_count,drop_columns) if x == 1: final = pandas.DataFrame(data=final_data) final = final.T else: final_tmp = pandas.DataFrame(data=final_data) final_tmp = final_tmp.T final = final.append(final_tmp) return final
def ReadStructureFile(self, fpath): fname = None if self.usePoscars == True: fname = 'POSCAR' else: fname = 'CONTCAR' f = open(fpath + '\\' + fname, "r") lines = f.readlines() atomdict = dict(zip(lines[5].split(), list(map(int, lines[6].split())))) atomorder = lines[5].split() dim = self.maxMoleculeSize + (self.numberOfMetalAtomsInEachLayer*2) struct = pd.DataFrame(index=range(0, dim), columns=['atom','x','y','z']) cho_order = [] currline = 2 mat = np.zeros((3,3)) for i in range(3): mat[i,:] = list(map(float, lines[currline].split())) currline = currline + 1 currline = 9 i = 0 for atom in atomorder: linesToRead = atomdict[atom] if atom == 'C' or atom == 'H' or atom == 'O': cho_order.append(atom) for line in range(linesToRead): words = lines[currline].split() v = np.array([float(k) for k in words[:3]]) w = np.dot(mat,v) struct.iloc[i, 0:4] = atom, w[0], w[1], w[2] i = i + 1 currline = currline + 1 elif self.excludeMetal == True: currline = currline + linesToRead elif self.excludeMetal == False: cho_order.append(atom) metalCoords = pd.DataFrame(index=range(0, self.atomMaxDict['M']), columns=range(0,4)) for line in range(linesToRead): words = lines[currline].split() v = np.array([float(k) for k in words[:3]]) w = np.dot(mat,v) metalCoords.iloc[line, 0:4] = atom, w[0], w[1], w[2] currline = currline + 1 p = metalCoords.sort_values(by=[3], ascending=False) for j in range(self.numberOfMetalAtomsInEachLayer*2): struct.iloc[i, 0:4] = atom, p.iloc[j,1], p.iloc[j,2], p.iloc[j,3] i = i + 1 while i < dim: struct.iloc[i, :] = 'X', 0.0, 0.0, 0.0 i = i + 1 return struct, cho_order, atomdict
def fill_workers_surveys(self): print("Generating workers surveys") row_list = [] workers_columns = self.columns + ['WORK-TYPE'] for place in self.surveys_to_generate: origin = place['from'] prim_number = place['Setor primário'] sec_number = place['Secundário'] tert_number = place['Terciário'] workplaces = self.generate_zone_workplaces(prim_number, sec_number, tert_number) for workplace in workplaces: d = dict.fromkeys(self.columns, '') d['ORG-LUG'] = origin d['DEST-LUG'] = workplace['zone'] d['WORK-TYPE'] = workplace['type'] row_list.append(d) random.shuffle(row_list) df = pandas.DataFrame(row_list, columns=workers_columns) with ExcelWriter(self.workers_filepath) as writer: df.to_excel(writer)
def __init__(self, master=None, **kwargs): tk.Frame.__init__(self, master, **kwargs) self.pack() master.title('WordCounter v0.1') master.geometry("1000x600") self.request(contents) self.filter_it(titles) df_words = pd.DataFrame(l, columns=['Word']) plt.style.use('seaborn') figure = plt.Figure(figsize=(10, 5), dpi=100) ax = figure.add_subplot(111) canvas = FigureCanvasTkAgg(figure, self) canvas.get_tk_widget().pack(side=tk.BOTTOM, fill=tk.BOTH, expand=True) df = df_words['Word'].value_counts( ascending=False)[:10].rename_axis('Word').reset_index( name='Counts') graph = df.plot.barh(x='Word', y='Counts', rot=0, color='#f23d3d', ax=ax) ax.set_xlabel("Word Count", weight='bold') ax.set_ylabel("Word", weight='bold') ax.set_title("Wordcounter", weight='bold') graph.invert_yaxis() plt.tight_layout() self.text1 = tk.Text(self, height=20, width=50) self.scroll = tk.Scrollbar(self, command=self.text1.yview) self.text1.configure(yscrollcommand=self.scroll.set) self.text1.insert(tk.END, titles, 'color') self.text1.pack(side=tk.LEFT, fill=tk.BOTH, expand=True) self.scroll.pack(side=tk.LEFT, fill=tk.Y)
def generate_metadata(local_path, local_project, local_filename): url = local_path + local_project + local_filename df = pd.read_excel(url) feature = [] feature_description = [] feature_group = [] for column_indexer in range(0, len(df.columns)): feature.append(df.columns[column_indexer]) feature_description.append(df.iloc[0, column_indexer]) feature_group.append('-') #print( feature ) #print( feature_description ) df_metadata = pd.DataFrame( list(zip(feature, feature_description, feature_group)), columns=['Feature Name', 'Feature Description', 'Feature Group']) url = local_path + local_project + '_metadata.xlsx' print(f'url (save excel): {url}') #df_metadata.to_excel(local_path + local_project + '_metadata.xlsx') print(df_metadata)
def predict_nums(df, band): data = df[df.band == band] X = data['total'] size = int(len(X) * 0.85) train, test = X[0:size], X[size:len(X)] test = np.append(test, 135) # predict를 위한 추가 기준값 # non- stationary history = [float(x) for x in train] predictions = list() diff = list() for t in range(len(test)): model = ARIMA(history, order=(5,1,0)) model_fit = model.fit(disp=0) output = model_fit.forecast(alpha=1) yhat = output[0] predictions.append(yhat) obs = test[t] history.append(obs) diff.append(yhat - obs) df = pd.DataFrame(diff) diff = df.describe() return (int(predictions[-1]), int(diff[0].loc['25%']), int(diff[0].loc['75%']))
def EncodeUsingCM(self, structFile, outFileName, r_power = 1, useCutoff = False, cutoff_dist_angstrom = 4.0, setValForMetalAtomicNumType = None): f = open(structFile, 'rb') allStructs = pickle.load(f) f.close() if setValForMetalAtomicNumType is not None: self.metalAtomicNumType = setValForMetalAtomicNumType structs = allStructs['structs'] metals = allStructs['metal'] species = allStructs['species'] metalDescs = allStructs['metalDescs'] dim = self.maxMoleculeSize + (self.numberOfMetalAtomsInEachLayer*2) df = pd.DataFrame(index=range(0, len(structs)), columns=range(0, dim + 2 + metalDescs.shape[1])) df_row = 0 for struct in structs: cmvec = self.BuildCoulombMatrixFromStruct(struct, r_power, useCutoff, cutoff_dist_angstrom) df.iloc[df_row, 0] = metals[df_row] df.iloc[df_row, 1] = species[df_row] for i in range(metalDescs.shape[1]): df.iloc[df_row, i+2] = metalDescs[df_row, i] l = 2 + metalDescs.shape[1] for k in range(dim-1, -1, -1): df.iloc[df_row, l] = cmvec[k] l += 1 df_row += 1 if df_row % 100 == 0 and self.isVerbose == True: print(df_row) df.to_csv(outFileName)
def GetBoBStruct(self, struct, cho_order, atomdict): structbob = pd.DataFrame(index=range(0, struct.shape[0]), columns=range(0,6)) if 'C' not in atomdict: cho_order.append('C') atomdict['C'] = 0 if 'H' not in atomdict: cho_order.append('H') atomdict['H'] = 0 if 'O' not in atomdict: cho_order.append('O') atomdict['O'] = 0 row = 0 j = 0 for cho in cho_order: if cho == 'C' or cho == 'H' or cho == 'O': for i in range(atomdict[cho]): structbob.iloc[row, :] = struct.iloc[j, 0], struct.iloc[j, 1], struct.iloc[j, 2], struct.iloc[j, 3], \ 'reg', struct.iloc[j, 0] row = row + 1 j = j + 1 for i in range(self.atomMaxDict[cho] - atomdict[cho]): structbob.iloc[row, :] = cho, 0.0, 0.0, 0.0, 'pad', cho row = row + 1 elif self.excludeMetal == False: for i in range(self.numberOfMetalAtomsInEachLayer*2): structbob.iloc[row, :] = 'W', struct.iloc[j, 1], struct.iloc[j, 2], struct.iloc[j, 3], 'reg', \ struct.iloc[j, 0] row = row + 1 j = j + 1 structbob_sorted = structbob.sort_values(by=[0,4], ascending=[True,False]) return structbob_sorted
def compile_data(): with open("sp500tickers.pickle", "rb") as f: tickers = pickle.load(f) main_df = pd.DataFrame() for count, ticker in enumerate(tickers): df = pd.read_csv('stock_dfs/{}.csv'.format(ticker)) df.reset_index(inplace=True) df.set_index('Date', inplace=True) df.rename(columns={'Adj Close': ticker}, inplace=True) df.drop(['Open', 'High', 'Low', 'Close', 'Volume'], 1, inplace=True) if main_df.empty: main_df = df else: main_df = main_df.merge(df, how='outer') gc.collect() if count % 10 == 0: print(count) main_df.head() main_df.to_csv('sp500_joined_closes.csv')
def generate_metadata( local_group, local_project ): LOCAL_PATH = f'./data/{local_group}/{local_project}/' LOCAL_ORIGINAL_DATA = '_0_cat.xlsx' url = LOCAL_PATH + local_project + LOCAL_ORIGINAL_DATA print(f'url (original) : {url}') df = pd.read_excel( url ) df = df_initial.drop(columns=['IPAddress', 'RecipientLastName', 'RecipientFirstName', 'RecipientEmail','ExternalReference', 'UserLanguage']) feature = [] feature_description = [] feature_group = [] for column_indexer in range(0 , len(df.columns)): feature.append( df. columns[column_indexer] ) feature_description.append( df.iloc[0,column_indexer]) feature_group.append('-') #print( feature ) #print( feature_description ) df_metadata = pd.DataFrame(list(zip(feature, feature_description, feature_group)), columns =['Feature Name', 'Feature Description', 'Feature Group']) url = LOCAL_PATH + local_project + '_metadata.xlsx' print(f'url (save excel): {url}') df_metadata.to_excel( url ) print( df_metadata )
def Download_finviz(self): a = finvizObj() t0 = time() k = 0 self.finviz_result = [] for symb1 in self.symb: try: tmp = a.get_keys(symb1) tmp1 = pd.DataFrame([tmp], columns=tmp.keys()) tmp1['symb'] = symb1 tmp1['status'] = 1 self.finviz_result.append(tmp1) print('TK' + str(k) + ' :: ' + symb1 + ' key matrix from Finviz is loaded sucessfully') except: #tmp1['status']=0 #tmp1['symb']=symb1 #self.finviz_result.append(tmp1) print('TK' + str(k) + ' :: ' + symb1 + ' Load error in finviz parser, Check symbol please') continue k = k + 1 print( '_____________Key ratios from Finviz Download______________________' ) print('All done Total time ' + str(int(time() - t0)) + ' Seconds')
def generate_metadata(local_group, local_project): LOCAL_PATH = f'./data/{local_group}/{local_project}/' LOCAL_ORIGINAL_DATA = '_0_cat.xlsx' url = LOCAL_PATH + local_project + LOCAL_ORIGINAL_DATA df = pd.read_excel(url) feature = [] feature_description = [] feature_group = [] for column_indexer in range(0, len(df.columns)): feature.append(df.columns[column_indexer]) feature_description.append(df.iloc[0, column_indexer]) feature_group.append('-') #print( feature ) #print( feature_description ) df_metadata = pd.DataFrame( list(zip(feature, feature_description, feature_group)), columns=['Feature Name', 'Feature Description', 'Feature Group']) url = local_path + local_project + '_metadata.xlsx' print(f'url (save excel): {url}') #df_metadata.to_excel(local_path + local_project + '_metadata.xlsx') print(df_metadata)
def readFileSlot(self): self.message.setText("") global messageType self.path = QListWidgetItem(self.lstbox.currentItem()).text() self.showProgress = PopUpProgressBar() if self.path != '': self.showProgress.show() index = linkNames.index(self.path) self.parseData = Parser(str(links[index])) pickleName = self.parseData.parse(self.showProgress) self.testing = Testing(pickleName) self.results = self.testing.analyse(self.showProgress) self.outputResult = list() for result in self.results: self.outputResult.append(result[:-1]) self.dataFrame = pd.DataFrame( self.outputResult, columns=['File', 'Confidence', 'Motion']) print(self.dataFrame) self.text = "" for result in self.results: self.text = result[0] + " is " + result[1] + "% " + result[2] self.textbox.addItem(self.text) self.showProgress.close() if self.text == "": messageType = 1 self.systemMessage = PopUpMessageBox() else: self.hasOutput = True else: messageType = 2 self.systemMessage = PopUpMessageBox()
def fill_students_surveys(self): print("Generating students surveys") row_list = [] students_columns = self.columns + ['SCHOOL-TYPE'] for place in self.surveys_to_generate: origin = place['from'] number = place['Estudantes'] schools = self.generate_zone_schools() for _ in range(number): d = dict.fromkeys(self.columns, '') d['ORG-LUG'] = origin school = schools[random.randint(0, len(schools) - 1)] d['DEST-LUG'] = school['zone'] d['SCHOOL-TYPE'] = school['type'] row_list.append(d) random.shuffle(row_list) df = pandas.DataFrame(row_list, columns=students_columns) with ExcelWriter(self.students_filepath) as writer: df.to_excel(writer)
def save_metadata_alternative( project_relative_root_path, local_project ): url = project_relative_root_path + local_project + DATA_SOURCE_SUFFIX print(f'url (original) : {url}') df = pd.read_excel( url ) df = df.drop( columns = [ 'StartDate' , 'EndDate' , 'Status' , 'IPAddress' , 'RecipientLastName' , 'RecipientFirstName' , 'RecipientEmail' , 'ExternalReference' , 'LocationLatitude' , 'LocationLongitude' , 'DistributionChannel' , 'UserLanguage' , 'RecordedDate' , 'ResponseId' ], axis = 1 ) # rename - Duration (in seconds) df.rename(columns = {'Duration (in seconds)':'Duration'}, inplace = True) feature = [] feature_label = [] feature_description = [] feature_group = [] drop_down = [] data_types = [] for column_indexer in range(0 , len(df.columns)): name = df.columns[column_indexer] description = df.iloc[0,column_indexer] data_types.append( df[name].dtypes.name ) feature.append( name ) feature_description.append( description ) label = '' group = '' label, group, alias = get_label_group( name, description ) feature_label.append( label ) feature_group.append( group ) drop_down.append( alias ) chart_type.appen ( 'Single' ) # SAVE df_metadata = pd.DataFrame(list(zip(feature, feature_label, feature_group, feature_description, drop_down)), columns =['FeatureName', 'FeatureLabel', 'FeatureGroup', 'FeatureDescription', 'DropDown']) url = project_relative_root_path + local_project + METADATA_SUFFIX print(f'url (save {METADATA_SUFFIX}): {url}') print(df_metadata.shape) df_metadata.to_excel( url , index = False, encoding = 'utf-8') return df
def DCACodePicker(data, Keyword): #check whether data is a dataframe if (type(data) == pd.core.frame.DataFrame): #checks whether 'DCA_CODE' is a column heading if 'DCA_CODE' in data: #checks whether user input a keyword if (Keyword): #makes sure data is formatted data = data[[col for col in data]] #create a new dataframe to return RelevantData = pd.DataFrame({'': []}) #this iterates through the data row by row for index, row in data.iterrows(): currkeywords = row['DCA_CODE'] #if a user key word is in the row's DCA CODE then, that row of data gets added to the df if (Keyword in currkeywords): RelevantData = data.append(row, ignore_index=True) return RelevantData else: return 'No Search Term Supplied' else: return 'Incorrect Data' elif (data == 'Invalid Date'): return 'Invalid Date' else: return 'Unknown Error'
def countTfbsInTissues(df): for tissueName in tissueNames: tfsInTissue[tissueName] = dict() df.apply(lambda row: addTfbsToTfCounts(row), axis=1) print("Creating dataframe") cols = ['tfName'] for tissueName in tissueNames: cols.append(tissueName) cols.append('totalBS') rows = [] for tfName in tfs: row = dict() row['tfName'] = tfName totalBS = 0 for tissueName in tissueNames: amount = 0 if tfName in tfsInTissue[tissueName]: amount = tfsInTissue[tissueName][tfName] row[tissueName] = amount totalBS += amount row['totalBS'] = totalBS rows.append(row) tfDf = pd.DataFrame(rows, columns=cols) tfDf['median'] = tfDf[np.array(list(tissueNames))].median(axis=1) tfDf['mean'] = tfDf[np.array(list(tissueNames))].mean(axis=1) #tfDf['mostUsedInTissue'] = tfDf.apply(lambda row: mostUsedInTissue(row), axis=1) #tfDf['diffFactor'] = tfDf.apply(lambda row: calcDiffFactor(row), axis=1) #tfDf.sort(['diffFactor'], inplace=True, ascending=False) return tfDf
def logData(self, i, x, candidate, meanVal, mse, secmeanVal, secmse, accratio, isaccepted): if self.df is None: self.collist = [ 'pred1_mean_cand', 'pred1_mean_x', 'pred1_mse_cand', 'pred1_mse_x', 'pred1_mse_cov', 'pred2_mean_cand', 'pred2_mean_x', 'pred2_mse_cand', 'pred2_mse_x', 'pred2_mse_cov', 'accratio', 'isaccepted', 'evaluationSoFar' ] self.df = pd.DataFrame(index=range(self.n), columns=self.collist + ['x' + str(i) for i in range(self.dim)] + ['cand' + str(i) for i in range(self.dim)]) self.df.iloc[i, :5] = meanVal[0, 0], meanVal[1, 0], mse[0, 0], mse[1, 1], mse[0, 1] self.df.iloc[i, 5:10] = secmeanVal[0, 0], secmeanVal[1, 0], secmse[ 0, 0], secmse[1, 1], secmse[0, 1] self.df.iloc[i, 10] = accratio self.df.iloc[i, 11] = isaccepted self.df.iloc[i, 12] = self.numberOfFuncEvals self.df.iloc[i, len(self.collist):len(self.collist) + self.dim] = x self.df.iloc[i, len(self.collist) + self.dim:] = candidate
def main(): print('carga de archivo') print('................') print('\n') dirname = os.path.dirname(__file__) filename = os.path.join(dirname, '../data/FormatoDeAlmacenamiento1.csv') df = pd.read_csv(filename, sep=';', header=None, na_values=" NaN") #print (df) hora = df[0].str.extract('((?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d)') #print (hora) #remplazo los na por cero df2 = pd.DataFrame() df2 = df2.fillna(0) df2[0] = df[0].str.extract('((?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d)') df2[1] = df[1] #print(df2) print("se agrupa por minutos") df2[0] = pd.DatetimeIndex(df2[0]) df2.set_index(keys=0, inplace=True) ini = datetime.time(00, 18, 0) fin = datetime.time(23, 59, 0) df3 = df2[[1]].between_time(ini, fin) df3 = df3.groupby([1])[[1]].count() print(df3)
def calcExpressionForEachTissue(tFactorDF): newDFRows = [] tFactorDF.apply(lambda row: getUniquenessPerTF(row, newDFRows), axis=1) diffFactorDF = pd.DataFrame(newDFRows, columns=['tfName', 'tissue', 'diffFactor']) diffFactorDF.sort(['diffFactor'], inplace=True, ascending=False) return diffFactorDF
def parsed_to_panel_dataframe(self, parsed): """ Recibe una lista de diccionarios a partir de la cual crea el dataframe del panel. Devuelve una lista de diccionarios con los datos del panel a partir de lo que recibe. Parameters ---------- parsed_by_currency: lista de diccionarios por día de una moneda. """ def create_multi_index_column(field_title): """Crea multi index desarmando el título de un campo.""" tc, ars, coin, entity, channel, flow, hour = field_title.split("_") return (coin, entity, channel, flow, hour) df = pd.DataFrame(parsed.values()).set_index("indice_tiempo") df.sort_index(inplace=True) df.columns = pd.MultiIndex.from_tuples( [create_multi_index_column(col) for col in df.columns]) df_panel = df.stack([-5, -4, -3, -2, -1], dropna=False).reset_index() df_panel.columns = [ "indice_tiempo", "coin", "entity", "channel", "flow", "hour", "value" ] df_panel.columns = [ "indice_tiempo", "moneda", "entidad_bancaria", "canal", "flujo", "hora", "valor" ] df_panel["indice_tiempo"] = df_panel["indice_tiempo"].apply( lambda x: x) df_panel["valor"] = df_panel["valor"].apply(lambda x: x if x and x > 0 else None) panel_data = df_panel.to_dict(orient="records") return panel_data
def main(self): try: self.goto_room() finally_data = pd.DataFrame(columns=['期数', '金额', '收益']) for i in range(20): print(finally_data) print( '-----------------------------------------round:{}---------------------------------------' .format(i + 1)) self.send_email(text=''' 上一轮收益为:{}\n 即将进行的是round:{}\n '''.format(finally_data['收益'].sum(), i + 1)) data = self.plan_process() finally_data = finally_data.append(data) print(finally_data) except TimeoutException: print('TimeoutException错误,修正后再出发。。。') self.send_email(text='TimeoutException错误,修正后再出发。。') except WebDriverException: print('WebDriverException错误,修正后再出发。。。') self.send_email(text='WebDriverException错误,修正后再出发。。') finally: print('矿机已停止运转,欢迎下次使用。。。')
def _clear_vrf_tab(self, vrf_dictionary): """Builds and writes the "Clear VRF's" worksheet.""" clear_vrf_df = pd.DataFrame( self._check_vrf_against_entire_db(vrf_dictionary)) clear_vrf_df.to_excel( self.writer, sheet_name='Clear-VRF', index=False, header=["Clear VRF's"])
def save_metadata(project_relative_root_path, local_project): url = project_relative_root_path + local_project + DATA_SOURCE_SUFFIX print(f'url (original) : {url}') df = pd.read_excel(url) df = df.drop(columns=[ 'StartDate', 'EndDate', 'Status', 'IPAddress', 'RecipientLastName', 'RecipientFirstName', 'RecipientEmail', 'ExternalReference', 'LocationLatitude', 'LocationLongitude', 'DistributionChannel', 'UserLanguage', 'RecordedDate', 'ResponseId' ], axis=1) # rename - Duration (in seconds) df.rename(columns={'Duration (in seconds)': 'Duration'}, inplace=True) feature = [] feature_label = [] feature_description = [] feature_group = [] for column_indexer in range(0, len(df.columns)): name = df.columns[column_indexer] description = df.iloc[0, column_indexer] feature.append(name) feature_description.append(description) if name == 'Progress' or name == 'Duration' or name == 'Finished': feature_group.append('Response') feature_label.append(name) elif match(r'Q\d+_', name): split_pattern = '\? - ' if search(split_pattern, description): elements = name.split(split_pattern) feature_group.append(elements[0]) feature_label.append(elements[0]) else: feature_group.append('NA') feature_label.append(name) else: feature_group.append('NA') feature_label.append(name) #print( feature ) #print( feature_description ) df_metadata = pd.DataFrame( list(zip(feature, feature_label, feature_group, feature_description)), columns=['Feature Name', 'Feature Description', 'Feature Group']) url = project_relative_root_path + local_project + METADATA_SUFFIX print(f'url (save {METADATA_SUFFIX}): {url}') df_metadata.to_excel(url, index=False, encoding='utf-8') return df
def plan_process(self): # 进入房间静默等待本期结束,准备开始 global money self.check_next_issue() # 是否中奖指针设置为未中奖 isprize = False # 金额进度指针设置为0 i = 0 # 初始化数据统计三个变量 issue_list = [] money_list = [] income_list = [] # 开始循环,推出条件为True while isprize == False: # 设置三等报警条件 if i == 3: self.alarm_1() if i == 4: self.alarm_2() if i == 5: self.alarm_3() i = 0 # 设置收入为0,为数据统计准备 income = 0 # 10-60秒,进入先投钱,然后再初始化金钱,点击,投钱,确认 money, shade = self.my_plan(indicator=i) print('这是第{}次投注'.format(i + 1)) # 金钱指针前移一位 i += 1 # 数据统计三个列表添加数据 issue_list.append(self.check_issue()) money_list.append(money) income_list.append(0) # 等待本局截至,静默20秒,等待开奖 self.check_next_issue() time.sleep(20) # 开奖,若中为True,不中为False isprize = self.check_num(shade) # 中奖后跳出循环,开始统计本剧收益 statements = money * 1.93 #单局中赔率为1.93 # 统计每局收入状况 for j in range(len(money_list)): income_list[j] = 0 - money_list[j] income_list[-1] = statements - money_list[-1] # 构建pandas数据体 data = pd.DataFrame( { '期数': issue_list, '金额': money_list, '收益': income_list, }, columns=['期数', '金额', '收益']) time.sleep(5) return data