Share
Questa è la seconda parte di un tutorial in due parti su Pandas, l'incredibile toolkit di analisi dei dati di Python.
Nella prima parte, abbiamo trattato i tipi di dati di base di Pandas: la serie e il frame dei dati. Abbiamo importato ed esportato dati, sottoinsiemi di dati selezionati, lavorato con metadati e ordinato i dati.
In questa parte, continueremo il nostro viaggio e gestiremo i dati mancanti, la manipolazione dei dati, la fusione dei dati, il raggruppamento dei dati, le serie temporali e il tracciamento.
Uno dei punti di forza dei panda è la gestione dei valori mancanti. Non si bloccherà e non brucerà in presenza di dati mancanti. Quando mancano i dati, i panda lo sostituiscono con numpy's np.nan (non un numero) e non partecipa a nessun calcolo.
Riesaminiamo il nostro frame di dati, aggiungendo più righe e colonne, ma senza nuovi dati. Per renderlo interessante, inseriremo alcuni valori.
>>> df = pd.DataFrame (np.random.randn (5,2), index = index, columns = ['a', 'b']) >>> new_index = df.index.append (pd.Index (['six'])) >>> new_columns = elenco (df.columns) + ['c'] >>> df = df.reindex (index = new_index, columns = new_columns) >>> df.loc [' tre ']. c = 3 >>> df.loc [' four ']. c = 4 >>> df abc one -0.042172 0.374922 NaN due -0.689523 1.411403 NaN tre 0.332707 0.307561 3.0 quattro 0.426519 -0.425181 4.0 cinque -0.161095 - 0.849932 NaN sei NaN NaN NaN
Nota che df.index.append () restituisce a nuovo indicizza e non modifica l'indice esistente. Anche, df.reindex () restituisce a nuovo frame di dati che riassegno al df variabile.
A questo punto, il nostro frame di dati ha sei righe. L'ultima riga è tutti i NaN e tutte le altre righe tranne la terza e la quarta hanno NaN nella colonna "c". Cosa puoi fare con i dati mancanti? Ecco le opzioni:
Conserva i dati mancanti --------------------- >>> df * = 2 >>> df abc one -0.084345 0.749845 NaN due -1.379046 2.822806 NaN tre 0.665414 0.615123 6.0 quattro 0.853037 -0.850362 8.0 cinque -0.322190 -1.699864 NaN sei NaN NaN NaN Drop file con dati mancanti --------------------------- >> > df.dropna () abc three 0.665414 0.615123 6.0 quattro 0.853037 -0.850362 8.0 Sostituisci con valore predefinito -------------------------- >>> df .fillna (5) abc one -0.084345 0.749845 5.0 due -1.379046 2.822806 5.0 tre 0.665414 0.615123 6.0 quattro 0.853037 -0.850362 8.0 cinque -0.322190 -1.699864 5.0 sei 5.000000 5.000000 5.0
Se vuoi solo verificare se hai dati mancanti nel tuo data frame, usa il è zero() metodo. Questo restituisce una maschera booleana del tuo dataframe, che è Vero per valori mancanti e falso altrove.
>>> df.isnull () a b c one False False Vero due Falso Falso Vero tre Falso Falso Falso quattro Falso Falso Falso cinque Falso Falso Vero sei Vero Vero Vero Vero
Quando si dispone di un frame di dati, è spesso necessario eseguire operazioni sui dati. Iniziamo con un nuovo frame di dati che ha quattro righe e tre colonne di numeri interi casuali tra 1 e 9 (inclusi).
>>> df = pd.DataFrame (np.random.randint (1, 10, size = (4, 3)), columns = ['a', 'b', 'c']) >>> df abc 0 1 3 3 1 8 9 2 2 8 1 5 3 4 6 1
Ora puoi iniziare a lavorare sui dati. Riassumiamo tutte le colonne e assegniamo il risultato all'ultima riga, quindi sommiamo tutte le righe (dimensione 1) e assegniamo all'ultima colonna:
>>> df.loc [3] = df.sum () >>> df abc 0 1 3 3 1 8 9 2 2 8 1 5 3 21 19 11 >>> df.c = df.sum (1)> >> df abc 0 1 3 7 1 8 9 19 2 8 1 14 3 21 19 51
È anche possibile eseguire operazioni sull'intero frame di dati. Ecco un esempio di sottrazione di 3 da ciascuna cella:
>>> df - = 3 >>> df a b c 0 -2 0 4 1 5 6 16 2 5 -2 11 3 18 16 48
Per il controllo totale, puoi applicare funzioni arbitrarie:
>>> df.apply (lambda x: x ** 2 + 5 * x - 4) a b c 0 -10 -4 32 1 46 62 332 2 46 -10 172 3 410 332 2540
Un altro scenario comune quando si lavora con i frame di dati è la combinazione e l'unione di frame di dati (e serie) insieme. Panda, come al solito, ti offre diverse opzioni. Creiamo un altro frame di dati ed esploriamo le varie opzioni.
>>> df2 = df // 3 >>> df2 a b c 0 -1 0 1 1 1 2 5 2 1 -1 3 3 6 5 16
Quando si utilizza pd.concat, i panda semplicemente concatenano tutte le righe delle parti fornite in ordine. Non c'è allineamento degli indici. Vedere nel seguente esempio come vengono creati i valori dell'indice duplicati:
>>> pd.concat ([df, df2]) a b c 0 -2 0 4 1 5 6 16 2 5 -2 11 3 18 16 48 0 -1 0 1 1 1 2 5 2 1 -1 3 3 6 5 16
Puoi anche concatenare le colonne usando il asse = 1 discussione:
>>> pd.concat ([df [: 2], df2], asse = 1) abcabc 0 -2.0 0.0 4.0 -1 0 1 1 5.0 6.0 16.0 1 2 5 2 NaN NaN NaN 1 -1 3 3 NaN NaN NaN 6 5 16
Si noti che poiché il primo frame di dati (ho usato solo due righe) non ha avuto tante righe, i valori mancanti sono stati popolati automaticamente con NaNs, che ha cambiato quei tipi di colonna da int a float.
È possibile concatenare un numero qualsiasi di frame di dati in un'unica chiamata.
La funzione di unione si comporta in modo simile a un join SQL. Unisce tutte le colonne da righe che hanno chiavi simili. Si noti che funziona solo su due frame di dati:
>>> df = pd.DataFrame (dict (key = ['start', 'finish'], x = [4, 8])) >>> chiave df x 0 start 4 1 finish 8 >>> df2 = pd .DataFrame (dict (key = ['start', 'finish'], y = [2, 18])) >>> df2 key y 0 start 2 1 finish 18 >>> pd.merge (df, df2, on = "chiave") tasto xy 0 start 4 2 1 finish 8 18
Il frame dei dati aggiungere() il metodo è una piccola scorciatoia. Funziona funzionalmente come concat (), ma salva alcuni tratti chiave.
>>> chiave df x 0 inizio 4 1 fine 8 Aggiunta di una riga usando il metodo append () ----------------------------- -------------- >>> df.append (dict (key = 'middle', x = 9), ignore_index = True) chiave x 0 start 4 1 finish 8 2 medio 9 Appending una riga usando il concat () ------------------------------------------- >>> pd.concat ([df, pd.DataFrame (dict (key = 'middle', x = [9]))], ignore_index = True) chiave x 0 start 4 1 finish 8 2 middle 9
Ecco una cornice di dati che contiene i membri e l'età di due famiglie: gli Smiths e i Jones. Puoi usare il raggruppa per() metodo per raggruppare i dati per cognome e trovare informazioni a livello di famiglia come la somma delle età e l'età media:
Accentsconagua
df = pd.DataFrame (dict (first = 'John Jim Jenny Jill Jack'.split (), last = "Smith Jones Jones Smith Smith" .split (), age = [11, 13, 22, 44, 65]) ) >>> df.groupby ('last'). sum () l'età dell'ultimo Jones 35 Smith 120 >>> df.groupby ('last'). mean () l'età dell'ultimo Jones 17.5 Smith 40.0 Un sacco di dati importanti sono dati di serie temporali. Pandas ha un forte supporto per i dati delle serie temporali a partire dagli intervalli di dati, passando per la localizzazione e la conversione temporale e fino al sofisticato ricampionamento basato sulla frequenza.
Il intervallo di date() la funzione può generare sequenze di data / ora. Ecco un esempio di generazione di un periodo di sei settimane a partire dal 1 ° gennaio 2017 utilizzando il fuso orario UTC.
>>> settimane = pd.date_range (start = '1/1/2017', periodi = 6, freq = "W", tz = "UTC") >>> settimane DatetimeIndex (['2017-01-01', "2017-01-08", "2017-01-15", "2017-01-22", "2017-01-29", "2017-02-05"], dtype = "datetime64 [ns, UTC] ", freq =" W-SUN ")
L'aggiunta di un timestamp ai frame di dati, sia come colonna di dati sia come indice, è ottima per organizzare e raggruppare i dati in base al tempo. Permette anche il ricampionamento. Ecco un esempio di ricampionamento dei dati di ogni minuto come aggregazioni di cinque minuti.
>>> minutes = pd.date_range (start = '1/1/2017', periodi = 10, freq = "1Min", tz = "UTC") >>> ts = pd.Series (np.random.randn ( len (minuti)), minuti) >>> ts 2017-01-01 00: 00: 00 + 00: 00 1.866913 2017-01-01 00: 01: 00 + 00: 00 2.157201 2017-01-01 00:02 : 00 + 00: 00 -0.439932 2017-01-01 00: 03: 00 + 00: 00 0.777944 2017-01-01 00: 04: 00 + 00: 00 0.755624 2017-01-01 00: 05: 00 + 00 : 00 -2.150276 2017-01-01 00: 06: 00 + 00: 00 3.352880 2017-01-01 00: 07: 00 + 00: 00 -1.657432 2017-01-01 00: 08: 00 + 00: 00 - 0.144666 2017-01-01 00: 09: 00 + 00: 00 -0.667059 Freq: T, dtype: float64 >>> ts.resample ('5Min'). Mean () 2017-01-01 00: 00: 00+ 00:00 1.023550 2017-01-01 00: 05: 00 + 00: 00 -0.253311Panda supporta la stampa con Matplotlib. Assicurati che sia installato: pip installa matplotlib. Per generare un grafico, puoi chiamare il tracciare() di una serie o di un frame di dati. Ci sono molte opzioni per controllare la trama, ma le impostazioni predefinite funzionano per scopi di visualizzazione semplici. Ecco come generare un grafico a linee e salvarlo in un file PDF.
ts = pd.Series (np.random.randn (1000), index = pd.date_range ('1/1/2017', periodi = 1000)) ts = ts.cumsum () ax = ts.plot () fig = ax.get_figure () fig.savefig ('plot.pdf')Nota che su macOS, Python deve essere installato come framework per il plottaggio con Pandas.
Pandas è un framework di analisi dei dati molto ampio. Ha un semplice modello a oggetti con i concetti di serie e data frame e una ricchezza di funzionalità integrate. Puoi comporre e combinare funzioni pandas e i tuoi algoritmi.
Inoltre, non esitare a vedere ciò che abbiamo a disposizione per la vendita e per studiare nel mercato, e non esitare a fare domande e fornire il tuo prezioso feedback utilizzando il feed qui sotto.
Anche i dati che importano ed esportano in panda sono molto estesi e assicurano che sia possibile integrarlo facilmente nei sistemi esistenti. Se stai eseguendo qualsiasi elaborazione dati in Python, i panda appartengono alla tua casella degli strumenti.
