API tools faq
paste
Advertisement
UgoDonini

TSS_FUNZIONI

UgoDonini
Apr 21st, 2023
522
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Python 21.96 KB | None | 0 0
raw download clone embed print report
  1. import pandas as pd
  2. import os
  3. S=os.system
  4. S('cls')
  5. print('ATTENZIONE: NON AGGIORNARE PANDAS : QUESTA VERSIONE 1.0.5 HA L\'OPZIONE decimal IN pd.read_excel CHE MANCA NELLE VERSIONI PIU NUOVE')
  6. print('SENZA OPZIONE decimal TUTTO IL PROGRAMMA VA IN CRISI')
  7. print(f'Versione in uso di pandas={pd.__version__}')
  8. input('Un tasto per continuare')
  9. """
  10. Created on Fri May 31 09:24:19 2019
  11.  
  12.  
  13. @author: ugo.donini
  14. #da riesaminare e semplificare per ridurre il numero di righe di codice
  15. #30/08/2019: MODIFICATO IL BLOCCO PER KT/V PER EVITARE ASSENZA DI DATI CHE METTE IN CRASH IL SISTEMA
  16. """
  17. #!http://localhost:8888/tree?token=38abbcc08e2b9d1dd6908bf6c55c0b9bccf617ef613ea9c4/usr/bin/env python3.7
  18.  
  19. ####vedi anche studio in PC studio salvato nella cartella python 3.7
  20.  
  21. # ultimo aggiornamento: 30/07/2019
  22. # !!!! AGGIUNTO OPZIONE IN DF_GRAFICO: OPZIONE DI CONSIDERARE SOLO LA DIALISI NELLO STESSO GIORNO DELLA SETTIMANA DELLA DIALISI ATTUALE
  23.  
  24. # ! pip install screeninfo # dimensioni dello screen attuale
  25. #! pip install pyperclip
  26. #%config IPCompleter.greedy=True # ABILITO AUTOCOMPLETION PER TASTO TAB
  27. #oppure in alternativa:
  28.  
  29. #get_ipython().run_line_magic('config', 'IPCompleter.greedy=True # autocomplete con TAB')
  30.  
  31. """
  32. ATTENZIONE: VALORI nan POSSONO METTERE IN CRISI ESECUZIONE DI GRAFICI
  33.  
  34. VEDI QUESTE MODIFICHE
  35.            # tolgo doppioni da df_pz_in_dialisi_oggi_storico e ordino secondo DATA.  !!! INDIASPENSABILE PER OTTENERE DEI GRAFICI CORRETTI !!!
  36.            # PREFERISCO METTERE QUESTO TRATTAMENTO DEL DF SOLO QUI PERCHè CAMBIA IL DF E L'INDICE DIVENTA LA DATA
  37.            df_tmp=df_tmp.groupby(['DATA']).first()# tolgo i doppioni
  38.            # in questo modo 'DATA' diventa index
  39.            df_tmp.RIC.fillna(0,inplace=True) # sostituisco le cellule NaN con 0 che é compatibile coi grafici
  40.            df_tmp.AumentoPeso.fillna(0,inplace=True) # sostituisco le cellule NaN con 0 che é compatibile coi grafici
  41.            df_tmp['DHB/UFTOT'].fillna(0,inplace=True) # sostituisco le cellule NaN con 0 che é compatibile coi grafici
  42.            df_tmp.UF_TOT_LT.fillna(0,inplace=True) # sostituisco le cellule NaN con 0 che é compatibile coi grafici
  43.            df_tmp.P_PRE.fillna(0,inplace=True) # sostituisco le cellule NaN con 0 che é compatibile coi grafici
  44.            df_tmp.HB_INI.fillna(0,inplace=True) # sostituisco le cellule NaN con 0 che é compatibile coi grafici          
  45.            #**************************** modificato 29/01/2021
  46. """
  47.  
  48. import re
  49. import pandas as pd
  50. import matplotlib.pyplot as plt
  51. import numpy as np
  52. import datetime
  53. import pprint
  54. import openpyxl
  55. import sys
  56. import shutil
  57. import pyperclip as clip
  58. import pickle as pik
  59. import os
  60. import seaborn as sns
  61. from matplotlib.dates import date2num
  62. import matplotlib.gridspec as gridspec
  63. import SeabornFig2Grid as sfg
  64. from screeninfo import get_monitors
  65. from os import name # nome del sistema operativo
  66. from os import system
  67. import pyperclip as clip
  68. from pandas.plotting import  register_matplotlib_converters
  69. register_matplotlib_converters()
  70.  
  71. cl_s=os.system('cls')
  72. cl_s
  73. os.system('cls')
  74. cl_s=print('\033[H\033[J') # sistema per fare cls dello schermo con caratteri speciali
  75. #os.system('cls') QUANDO QUESTO COMANDO NON FUNZIONA
  76. #ATTENZIONE: ... SeabornFig2Grid è UN MODULO INSERITO A MANO NELLA LIBRERIA CHE SI TROVA IN :
  77. # c:\Users\ugo.donini\AppData\Local\Continuum\anaconda3\Lib\site-packages\
  78.  
  79. p,pp,DF,DT,S,J=print,pprint.pprint,pd.DataFrame,pd.to_datetime,os.system,os.path.join
  80.  
  81.  
  82. def date_trattamenti(df,cog,no):# DATAFRAME,COGNOME, NOME
  83.     cog=cog.upper()
  84.     no=no.upper()
  85.     mask1=df['Cognome']== cog
  86.     mask2=df['Nome']== no
  87.     ris=list(df[mask1 & mask2].date_eu.str[0:10]) #seleziono solo la data senza l'ora
  88.    
  89.     clip.copy(', '.join(ris))
  90.     cl_s
  91.     p('Ho salvato la lista delle date anche in APPUNTI')
  92.     return ris
  93.  
  94. def sele_elab(df): #seleziono i dati con un filtro tempo da a
  95.     cl_s
  96.     data_sele=[input('anno: ...'),input('mese: ... '), input('giorno: ... ')]
  97.     ora_sele_da=[input('ora da (inizio periodo): ...')]
  98.     ora_sele_a=[input('ora a (fine periodo): ... ')]
  99.     sele_data_ini=data_sele+ora_sele_da
  100.     sele_data_fin=data_sele+ora_sele_a
  101.     data_sele_ini=pd.to_datetime(' '.join(sele_data_ini))
  102.     data_sele_fin=pd.to_datetime(' '.join(sele_data_fin))
  103.     df_tmp=(df[df.DATA<data_sele_fin])
  104.     df_tmp2=df_tmp[df_tmp.DATA>data_sele_ini]
  105.     lista_pz_sele=list(df_tmp2.Cognome_Nome)
  106.     df_elab=df.loc[lista_pz_sele] #in df_elab i dati  di df solo dei pazienti selezionati
  107.     return df_elab,data_sele_ini,data_sele_fin
  108.  
  109. def plotta(x,y,valore='Valore',titolo='Titolo',PAT2='C:\\TMP'): #prova di plot dei valori dove x deve essere la DATA e y il valore da controllare
  110.    
  111.     try:
  112.             fl=os.path.join(PAT2,f'{titolo}_test.png')# DA MODIFICARE IN MODO UNIVERSALE
  113.             fig, ax = plt.subplots()
  114.             ax.plot(x, y)
  115.             plt.gcf().autofmt_xdate()
  116.             ax.set(xlabel='DATA', ylabel=valore,title=f'{titolo}\nVariazione di {valore} nel tempo',ylim=(0, 1.8))
  117.             ax.grid()
  118.             p(fl)
  119.             fig.savefig(fl)
  120.             plt.show()
  121.     except:
  122.             p(titolo,': errore: ',valore.max())
  123.  
  124.  
  125. def str_data_2_data(df):
  126.     #p(df.head(1))
  127.     #creo il diz mesi che mi serve per correggere la DATA in stringa della tabella
  128.     mesi=['gen','feb','mar','apr','mag','giu','lug','ago','sett','ott','nov','dic']
  129.     mesi=dict(enumerate(mesi))
  130.     dict_mesi={v:k for k,v in mesi.items()}
  131.     #trasformo la stringa DATA in datetime - valore DATA perfetto
  132.     df=df.str.replace('.',':') # correggo la separazione ore minuti
  133.     df=df.apply(dt_trsf)
  134.     return df  
  135. def dt_trsf(d0):
  136.     try:
  137.         mesi=['gen','feb','mar','apr','mag','giu','lug','ago','set','ott','nov','dic']
  138.         mesi=dict(enumerate(mesi,1))
  139.         dict_mesi={v:k for k,v in mesi.items()}    
  140.         d1=d0.split(' ')
  141.         d1[1]=str(dict_mesi[d1[1]])
  142.         d1=' '.join(d1)
  143.         d1=(pd.to_datetime(d1,dayfirst=True,infer_datetime_format=True))
  144.         return d1
  145.     except:
  146.         return d0        
  147.  
  148. def t_float(ddf):
  149.     ddf=float(ddf)
  150.     return ddf
  151. def t_int(ddf):
  152.     ddf=int(ddf)
  153.     return ddf
  154. def t_dtt(ddf):# da controllare e migliorare
  155.     ddf=pd.to_datetime(ddf)
  156.     return ddf
  157.  
  158. def set_tipi(df,sele_int=[],sele_float=[]):
  159.     if len(sele_int):
  160.         df[sele_int]=df[sele_int].astype('int')
  161.         #p(df[sele_int].head())
  162.     if len(sele_float):
  163.         df[sele_float]=df[sele_float].astype('float')
  164.         #p(df[sele_float].head())
  165.        
  166.     return df
  167.    
  168. def df_tipi_dataset(fl='C:\\tmp\\TSS_tipi_elab.CSV'):
  169.     df_type=pd.read_csv(fl,sep=';',decimal=',')
  170.     df_type.columns=['Indice','COLONNA','TIPO']
  171.     p(df_type.head())
  172.     df_tipi=df_type[['COLONNA','TIPO']]
  173.     #p(df_tipi.head())
  174.     dd=pd.Series(df.dtypes.index, name='didas')
  175.     dtmp=DF(dd)
  176.     return df_tipi,dtmp
  177.     #dtmp.to_csv('C:\\tmp\\TSS_tipi.CSV',sep=';',decimal=',')
  178. def crea_dict_tipi(df_tipi): # metodo forse obsoleto prodotto dall disperazione prima di capire bene
  179.     # con questo metodo voglio ottenere un dizionario dei tipi
  180.     ris_1=[]
  181.     for i in range(len(df_tipi)):
  182.         rx=tuple(df_tipi.iloc[i,:].values)
  183.         ris_1+=[rx]
  184.     ris_1=dict(ris_1)
  185.     return ris_1
  186. def info_df(df):
  187.     return df.info()
  188.  
  189. def crea_dict_tipi(l1,tipi_mask={0:'None',1:'int',2:'float',3:'datetime',4:'str'},): #dict constructor per i tipi
  190.     tipi=tipi_mask
  191.     dida=str(tipi).replace('}',')')
  192.     dida=dida.replace('{','(')
  193.     dida=dida.replace(" '","")
  194.     dida=dida.replace("',",",")
  195.     dida=dida.replace(':',"=")
  196.     sele_tipo=[]
  197.     cl_s
  198.     for i in l1:
  199.         tipo=int(input(f'{i} - scegli tipo: {dida}: ... ' ))
  200.         sele_tipo+=[(i,tipi[tipo])]
  201.     sele_tipo_dict=dict(sele_tipo)
  202.     return sele_tipo_dict
  203.  
  204. def collima_2_liste(l1,l2):
  205.     z1=zip(l1,l2)
  206.     for i in z1:
  207.         p(i)
  208.     return dict(z1)
  209.  
  210. def l1(df):
  211.     return df.head(1)
  212.  
  213. def seab_fig_1(df1,pz,pat_ris):
  214.     fig=plt.figure()
  215.     fig.suptitle(pz+': DP='+str(df1.iloc[-1,6]))
  216.     fig.add_subplot(221)
  217.     #etichette=['AumentoPeso','Delta_HB','UF_TOT_LT']
  218.     g1=sns.regplot(x='DataNum', y='AumentoPeso',  data=df1)
  219.     plt.gcf().autofmt_xdate() #posiziono le didascalie nella x in obliquo
  220.     fig.add_subplot(222)
  221.     g2=sns.regplot(x='DataNum', y='Delta_HB',  data=df1)
  222.     plt.gcf().autofmt_xdate() #posiziono le didascalie nella x in obliquo
  223.     fig.add_subplot(223)
  224.     g3=sns.regplot(x='DataNum', y='UF_TOT_LT',  data=df1)
  225.     plt.gcf().autofmt_xdate() #posiziono le didascalie nella x in obliquo
  226.  
  227.     fig.add_subplot(224)
  228.     g4=sns.regplot(x='DataNum', y='PAS_FIN',  data=df1)
  229.     plt.gcf().autofmt_xdate() #posiziono le didascalie nella x in obliquo
  230.     fig.savefig(pat_ris+pz+'fig1.png')
  231.     plt.show
  232.  
  233. def seab_fig_2(df1,pz,pat_ris):
  234.     fig=plt.figure()
  235.     g1=sns.lmplot(x='DataNum',y='Delta_HB',data=df1)
  236.     plt.title(pz+': DP='+str(df1.iloc[-1,6]))
  237.     g2=sns.lmplot(x='DataNum',y='UF_TOT_LT',data=df1)
  238.     plt.title(pz+': DP='+str(df1.iloc[-1,6]))
  239.     fig1 = g1
  240.     fig2=g2
  241.     fig1.savefig(pat_ris+pz+'fig1.png')
  242.     fig2.savefig(pat_ris+pz+'fig2.png')
  243.     plt.show()  
  244. def seab_fig_3(df1,pz,pat_ris): # da studiare
  245.     fig=plt.figure()
  246.     g1=sns.scatterplot(x='DataNum',y='Delta_HB',data=df1)
  247.     plt.title(pz+': DP='+str(df1.iloc[-1,6]))
  248.     g2=sns.scatterplot(x='DataNum',y='UF_TOT_LT',data=df1)
  249.     plt.title(pz+': DP='+str(df1.iloc[-1,6]))
  250.     fig1 = g1
  251.     fig2=g2
  252.     #fig1.savefig(pat_ris+pz+'fig1.png') # da studiare
  253.     #fig2.savefig(pat_ris+pz+'fig2.png')
  254.     plt.show()
  255.    
  256. #!!!! IMPORTANTISSIMO !!!! INDISPENSABILE PERCONVERTIRE LASTRINGA IN DATA: dayfirst=Tru
  257. def str_2_tm(expr):
  258.     return pd.to_datetime(expr,dayfirst=True)
  259. #!!! IMPORTANTISSIMO PER RINOMINARE LA TESTATA IN MODO SICURO !!!
  260. def tst_rnm(df,new): #new)lista della nuova testata
  261.     cl_s
  262.     tst_orig=df.columns
  263.     col_rst=dict(zip(tst_orig,new))
  264.     df.rename(columns=col_rst,inplace=True)
  265.     p('ORA MOSTRO IL RISULTATO: SE TUTTO OK INVIO ALTRIMENTI UN TASTO QUALSIASI')
  266.     pp(col_rst)
  267.     pp(df.dtypes)
  268.     p('\n\n')
  269.     r=input('Tutto OK ? (invio se tutto OK)' )
  270.     p('\033[H\033[J') # sistema per fare cls dello schermo con caratteri speciali
  271.     cl_s
  272.     if not r:
  273.         return df
  274. def plt_sintesi_1(dfx,s1=[3,5,6,17,20,21,30,22]):
  275.     #da modificare tenendo presente la coonna 'DATA'
  276.     #va tolta dalle opzioni e gestita in modo separato
  277.     #median() è un artifizio per ottenere la lista
  278.     dfx=DF(dfx)
  279.     pz_lst=list(dfx.groupby(dfx.index).median().index)
  280.                  
  281.     #p(pz_lst)
  282.    
  283.     clm=dfx.columns
  284.     sele=list(clm[s1])+['DATA']
  285.     #p(sele)
  286.     for pz in pz_lst:
  287.         ris_tmp=DF(dfx.loc[pz,sele])
  288.  
  289.         #ris_tmp.rename(index=ris_tmp.DATA,inplace=True)
  290.         ######fig=plt.figure()
  291.         ris_tmp=DF(D1.loc[pz,sele])
  292.         ris_tmp.index=ris_tmp.DATA
  293.         ris_tmp.drop(['DATA'], axis=1,inplace=True)
  294.         p(pz)
  295.         p(sele)
  296.         p(ris_tmp.tail())
  297.        
  298.         #fig.suptitle(pz+': DP='+str(ris_tmp.loc[pz,-1]))
  299.         sele1=[]
  300.         for j in sele:
  301.             if not j=='DATA':
  302.                 sele1+=[j]
  303.         ris_tmp.index.name=''
  304.     # trovare metodo più elegante per sottarre un elemento dalla lista
  305.     for i in sele1:
  306.         fig=plt.figure()
  307.        
  308.         fig.suptitle(pz+': DP='+str(ris_tmp.loc[pz,'D_P']))
  309.         plt.plot(ris_tmp[i])
  310.         #plt.plot(ris_tmp[i])
  311.         plt.legend(sele,loc='upper left')
  312.         plt.gcf().autofmt_xdate()
  313.         plt.show
  314. #!!! NON FUNZIONA QUESTO METODO NON CONSENTE DI MODIFICARE I VALORI IN D1
  315. def P_PRE_update(D1,D2,data=str(pd.to_datetime(datetime.datetime.today(),dayfirst=True))[:10]):
  316.     mask_data=D1.DATA>=pd.to_datetime(data,dayfirst=True)
  317.     p(mask_data)
  318.     D1.P_PRE[mask_data].loc[:]=D2.P_PRE.loc[:]
  319.     p(D1.P_PRE)
  320.     return D1
  321. def tsf_PESI(D1,D2):
  322.     df_tot=pd.concat([D1,D2],axis=0, sort=True)
  323.     mask=df_tot.P_PRE!=0.0
  324.     df_tot1=df_tot[mask]
  325.    
  326.     df_tot1['D_P']=df_tot1.PS-df_tot1.P_PRE
  327.     return df_tot1
  328.  
  329. def scatter_tot_1(dfx,lst_par,titolo,PAT,trasparenza=0.2):
  330.     cl=['r','b','g','y','c','v']
  331.     fig=plt.figure()
  332.     fig.suptitle(titolo)
  333.     etichette=lst_par
  334.     #lst_hb=['HB_INI','HB_FIN','D_HB']
  335.     n=0
  336.     for p1 in lst_par:
  337.         ris_1=dfx[p1]
  338.         plt.scatter(dfx.index,ris_1, s=100, color=cl[n],alpha=trasparenza)
  339.         #plt.scatter(dfx.index,ris_1, s=100, alpha=.5)
  340.         #plt.legend(etichette,loc='upper left')
  341.         plt.gcf().autofmt_xdate()
  342.         n+=1
  343.     plt.legend(etichette,loc='lower left')
  344.     fig.savefig(PAT)
  345.  
  346. def plt_sintesi_2(dfx,s1=[3,5,6,17,20,21,30,22]):
  347.     #median() è un artifizio per ottenere la lista
  348.     pz_lst=list(dfx.groupby(dfx.index).median().index)
  349.                  
  350.     p(pz_lst)
  351.    
  352.     clm=dfx.columns
  353.     sele=list(clm[s1])
  354.     p(sele)
  355.     for pz in pz_lst:
  356.         ris_tmp=dfx.loc[pz,sele]
  357.  
  358.         #ris_tmp.rename(index=ris_tmp.DATA,inplace=True)
  359.         fig=plt.figure()
  360.         #fig.suptitle(pz+': DP='+str(ris_tmp.loc[pz,-1]))
  361.         ris_tmp.index=ris_tmp.DATA
  362.         for i in sele:
  363.             plt.plot(ris_tmp[i])
  364.         plt.legend(sele,loc='upper left')
  365.         plt.gcf().autofmt_xdate()
  366.         plt.show
  367. def testate(df):
  368.     # da elaborare CONSIDERARE LA CONVENIENZA DI TRASFORMARE I DIZIONARI IN DATAFRAME
  369.         #Testata originale di '0_import.xls' ottenuto con macro vecchio programma per ACCESS
  370.     # viene tolto la colonna 'ID': così restano 28 elementi ... forse colonna ID E' da rimettere per utilizzare programma ACCESS
  371.  
  372.     tipi_orig={'Nome risorsa': 'str',
  373.      'Numero di serie': 'str',
  374.      'Nome del filtro': 'str',
  375.      'Peso secco\nKg': 'float',
  376.      'Pressione media TMP\nmmHg': 'float',
  377.      'Peso predialisi\nKg': 'float',
  378.      'Aumento di peso\nKg': 'float',
  379.      'Peso da perdere\nKg': 'float',
  380.      'Ora di inizio trattamento': 'datetime',
  381.      'Ora di fine trattamento': 'datetime',
  382.      'Totale UF\nml': 'int',
  383.      'Tempo effettivo': 'datetime',
  384.      'Sistolica predialisi\nmmHg': 'int',
  385.      'Diastolica predialisi\nmmHg': 'int',
  386.      'Codice fiscale': 'str',
  387.      'Cognome': 'str',
  388.      'Nome': 'str',
  389.      'Data del trattamento': 'datetime',
  390.      'Peso post dialisi\nKg': 'float',
  391.      'Ricircolo\n%': 'float',
  392.      'Emoglobina iniziale\ng/dl': 'float',
  393.      'Emoglobina finale\ng/dl': 'float',
  394.      'OCM Kt/V': 'float',
  395.      'Ora di fine sessione': 'datetime',
  396.      'Frequenza cardiaca post-dialisi\nbpm': 'int',
  397.      'Pressione sistolica post-dialisi\nmmHg': 'int',
  398.      'Pressione diastolica post-dialisi\nmmHg': 'int',
  399.      'Flusso ematico effettivo\nml/min': 'int'}
  400.     tipi_orig_int_float={'Peso secco\nKg': 'float',
  401.      'Pressione media TMP\nmmHg': 'float',
  402.      'Peso predialisi\nKg': 'float',
  403.      'Aumento di peso\nKg': 'float',
  404.      'Peso da perdere\nKg': 'float',
  405.      'Totale UF\nml': 'int',
  406.      'Sistolica predialisi\nmmHg': 'int',
  407.      'Diastolica predialisi\nmmHg': 'int',
  408.      'Peso post dialisi\nKg': 'float',
  409.      'Ricircolo\n%': 'float',
  410.      'Emoglobina iniziale\ng/dl': 'float',
  411.      'Emoglobina finale\ng/dl': 'float',
  412.      'Frequenza cardiaca post-dialisi\nbpm': 'int',
  413.      'Pressione sistolica post-dialisi\nmmHg': 'int',
  414.      'Pressione diastolica post-dialisi\nmmHg': 'int',
  415.      'Flusso ematico effettivo\nml/min': 'int',
  416.       }
  417.     tst_import=df.columns #RICAVATE DIRETTAMENTE DOPO IMPORTAZIONE DATI EXCEL
  418.     #CONTROLLO TESTATA ORIGINALE CON DICT TIPI
  419.     no_in_tst=[k for k in tst_import if not k in tipi_orig ]
  420.  
  421.     p("COLONNA ASSENTE IN DICT 'tipi_orig'\n",no_in_tst)
  422.     #Testata schema ridottissimo
  423.     tst_rid=['ID_PAZ', 'STATUS', 'Cognome', 'Nome', 'FILTRO', 'DATA', 'PS', 'D_P',
  424.            'P_PRE', 'P_RESIDUO', 'UF_TOT', 'RIC', 'HB_INI', 'HB_FIN', 'D_HB',
  425.            'TMP', 'Kt/V', 'QB_EFFETT', 'PAS_FIN', 'PAD_FIN', 'FC_FIN', 'T_DIAL']
  426.  
  427.     #testata nuova per la tabella elaborata
  428.     tst_mod=['Risorsa', 'NS', 'FILTRO', 'PS','TMP', 'P_PRE','AumentoPeso', 'PesoDaPerdere','OraInizio', 'OraFine','UF_TOT',
  429.            'T_DIAL', 'SisPredial','DiasPredial', 'CF', 'Cognome', 'Nome',
  430.            'DATA', 'P_POST', 'RIC','HB_INI','HB_FIN', 'Kt/V','OraFineSess', 'FC_FIN',
  431.            'PAS_FIN','PAD_FIN','QB_EFFETT','RBV_min']
  432.     tst_da_aggiungere=['Delta_tempo']
  433.     df_tipi={'AumentoPeso': 'float',
  434.      'CF': 'str',
  435.      'Cognome': 'str',
  436.      'DATA': 'datetime',
  437.      'DiasPredial': 'int',
  438.      'FC_FIN': 'int',
  439.      'FILTRO': 'str',
  440.      'HB_FIN': 'float',
  441.      'HB_INI': 'float',
  442.      'Kt/V': 'float',
  443.      'NS': 'str',
  444.      'Nome': 'str',
  445.      'OraFine': 'datetime_verificare',
  446.      'OraInizio': 'datetime_verificare',
  447.      'PAD_FIN': 'int',
  448.      'PAS_FIN': 'int',
  449.      'PS': 'float',
  450.      'P_POST': 'float',
  451.      'P_PRE': 'float',
  452.      'PesoDaPerdere': 'float',
  453.      'QB_EFFETT': 'float',
  454.      'RIC': 'float',
  455.      'Risorsa': 'str',
  456.      'SisPredial': 'int',
  457.      'TMP': 'float',
  458.      'T_DIAL': 'datetime_verificare',
  459.      'UF_TOT': 'float',
  460.      'date_eu': 'str',
  461.      'date_eu_convertita_in_tipo_data': 'datetime'}
  462.     tipi_mod_int_float={
  463.      'AumentoPeso': 'float',
  464.      'DiasPredial': 'int',
  465.      'FC_FIN': 'int',
  466.      'HB_FIN': 'float',
  467.      'HB_INI': 'float',
  468.      'Kt/V': 'float',
  469.      'PAD_FIN': 'int',
  470.      'PAS_FIN': 'int',
  471.      'PS': 'float',
  472.      'P_POST': 'float',
  473.      'P_PRE': 'float',
  474.      'PesoDaPerdere': 'float',
  475.      'QB_EFFETT': 'float',
  476.      'RIC': 'float',
  477.      'SisPredial': 'int',
  478.      'TMP': 'float',
  479.      'UF_TOT': 'float',
  480.       }
  481.     tipi_orig_datetime={
  482.      'Ora di inizio trattamento': 'datetime',
  483.      'Ora di fine trattamento': 'datetime',
  484.      'Data del trattamento': 'datetime',
  485.      'Ora di fine sessione':'datetime'
  486.      }
  487.  
  488.     DIDA=dict(enumerate(tst_mod))
  489.     #pp(DIDA)
  490.     #datetime_verificare: formato data strano e diverso studiare per conversione
  491.     tempo_dialisi={'Tempo effettivo': 'datetime','Delta_tempo':'datetime'}
  492.     sele_float=[k for k,v in df_tipi.items() if v=='float']
  493.     sele_int=[k for k,v in df_tipi.items() if v=='int']
  494.     sele_time=[k for k,v in df_tipi.items() if v=='datetime']
  495.  
  496.  
  497.  
  498.  
  499.     return [tipi_orig,tipi_orig_int_float,tst_import,no_in_tst,tst_rid,tst_mod,tst_da_aggiungere,
  500.             df_tipi,tipi_mod_int_float,tipi_orig_datetime,DIDA,tempo_dialisi,sele_float,sele_int,sele_time
  501.            ]
  502.     os.makedirs(pat_tmp,exist_ok=True)
  503.     # In[100]:
  504.     #SELEZIONO LA DATA PER FILTRARE I DATI DEI PAZIENTI
  505.     cl_s
  506.     fl_date_f=os.path.join(pat_tmp,fl_st)
  507.     rsp=''
  508.     try:
  509.         d_f=pd.read_csv(fl_date_f,sep=';')
  510.         data_sele_ini,data_sele_fin=d_f.iloc[0,0],d_f.iloc[1,0]
  511.         rsp= input(f'Vuoi utilizzare le date filtro già impostate ({data_sele_ini, data_sele_fin} )(s/n): ... ').upper()
  512.     except:
  513.         rsp='N'
  514.     if 'N' in rsp:
  515.         data_sele_ini=input('Set di filtro_data (ini-fin)\nData inzio(gg/mm/aaaa hh:mm): ... ')
  516.         data_sele_fin=input('Set di filtro_data (ini-fin)\nData fine(gg/mm/aaaa hh:mm): ... ')
  517.         data_sele_ini=str_2_tm(data_sele_ini)
  518.         data_sele_fin=str_2_tm(data_sele_fin)
  519.         d_f=pd.DataFrame([data_sele_ini,data_sele_fin])
  520.         d_f.to_csv(fl_date_f,sep=';',index=False)
  521.     else:
  522.         pass
  523.     rs=''
  524.     return data_sele_ini, data_sele_fin
  525.     #date_filtro=pd.Series([data_sele_ini,data_sele_fin]) #problemi conpd.Series: mmette una data come head
  526. def estrai_stat(df,idx,par,stat='mean'):
  527.     df_tot.groupby(df_tot.index).describe().loc[idx][par].loc[stat].round(1)
  528.  
  529. # modulo per salvare codice in unico DF di eleenti di codice da ricordare
  530. def df_input(df1): #aggiunge una riga al df df1 partendo dall'ultima: richiede un index numerico
  531.     cl_s
  532.     ix=max(df1.index)
  533.     if df1.iloc[0,0]=='':# controllo se ho un record vuoto; si può migliorare il metodo del contollo con row ...
  534.         ix-=ix
  535.     cols=(dict(enumerate(df1.columns,1)))
  536.     pp(cols)
  537.     r1=input('Numero corrispondente della colonna che vuoi aggiornare da Appunti(solo invio se non vuoi Appunti): ... ')
  538.     if r1:
  539.         r1=int(r1)            
  540.         p('hai scelto: ... ',cols[r1])
  541.         entry_clip=cols[r1]
  542.     else:
  543.         entry_clip=''
  544.  
  545.     for i in df1.columns:
  546.         df1.loc[ix+1,'Data']=pd.to_datetime(datetime.datetime.now()) # inserisco la data del momento              
  547.         if not i=='Data':
  548.             if entry_clip==i:
  549.                 p(f'Inserisco {i} da clip')
  550.                 input('Un tasto quando sei pronto')
  551.                 entry=clip.paste()
  552.             else:
  553.                 entry=input(i+': ...')
  554.             df1.loc[ix+1,i]=entry
  555.            
  556.     return df1
  557.        
  558. def crea_df(new_dict): #crea df da dizionario
  559.     df=DF(new_dict, index=range(1,2))# crea la prima riga vuota
  560.     return df
  561.    
  562. def DATA(dt=datetime.datetime.now()): #SE SI OMETTE L'ARGOMENTO dt si ottiene la data pandas del momento
  563.     D= pd.to_datetime(dt)
  564.     p(D)
  565.     return (D)
  566. def pik_save(obj,fl1):
  567.     filehandler = open(fl1,"wb")
  568.     pickle.dump(obj,filehandler)
  569. def pik_load(fl1):
  570.     file = open(fl1,'rb')
  571.     return pickle.load(file)
  572. #def my_code(op=0,PAT_CODE='c:\\Users\\ugodo\\MEMORIA\\code\\'):
  573. def my_code(op=0,PAT_CODE='c:\\Users\\ugo.donini\\MEMORIA\\code\\'): #opzione Domus Nova
  574.     pat_memo_code=PAT_CODE
  575.     os.makedirs(pat_memo_code,exist_ok=True)
  576.     os.chdir(pat_memo_code)
  577.     #memo_code_fl='MEMO_CODE.PK'
  578.     memo_code_fl='MEMO_CODE.PK'
  579.     if os.path.exists(memo_code_fl):
  580.         mc_df=pik_load(memo_code_fl)
  581.     else:
  582.         nuovo={'Data':'','Linguaggio':'','Scopo':'','Codice':'','Grading':'','Note':''}
  583.         mc_df=crea_df(nuovo)
  584.     if op:
  585.         df_input(mc_df) # il df mc_df viene modificato in place e se la prima riga é vuota viene aggiornata la prima riga
  586.         pik_save(mc_df,memo_code_fl)
  587.     else:
  588.         p(f'Metti il primo parametro di my_code()=1 per registrare nuovo codice: my_code(1)\n')
  589.         p(f'Nel secondo parametro pat di default {PAT_CODE}')
  590.         p('\nOra la tua opzione è di sola consultazione\npuoi analizzare il DF ottenuto coi metodi che vuoi')
  591.        
  592.     return mc_df
  593.  
  594.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!