Sottoinsiemi di dati in Python

Question

Voglio usare l'equivalente del comando sottoinsieme in R per qualche codice Python che sto scrivendo.

Ecco il mio dati:

col1    col2    col3    col4    col5
100002  2006    1.1 0.01    6352
100002  2006    1.2 0.84    304518
100002  2006    2   1.52    148219
100002  2007    1.1 0.01    6292
10002   2006    1.1 0.01    5968
10002   2006    1.2 0.25    104318
10002   2007    1.1 0.01    6800
10002   2007    4   2.03    25446
10002   2008    1.1 0.01    6408

Voglio sottoinsieme dei dati in base a contenuto di col1 e col2. (I valori unici in col1 sono 100002 e 10002, e in col2 sono 2006,2007 e 2008).

Questo può essere fatto in R con il comando sottoinsieme, c'è qualcosa di simile in Python?

Answer 1

Mentre le risposte degli iteratori-based sono perfettamente bene, se si sta lavorando con gli array NumPy (come si parla che siete) ci sono migliori e più veloci modi per selezionare le cose:

import numpy as np
data = np.array([
        [100002, 2006, 1.1, 0.01, 6352],
        [100002, 2006, 1.2, 0.84, 304518],
        [100002, 2006, 2,   1.52, 148219],
        [100002, 2007, 1.1, 0.01, 6292],
        [10002,  2006, 1.1, 0.01, 5968],
        [10002,  2006, 1.2, 0.25, 104318],
        [10002,  2007, 1.1, 0.01, 6800],
        [10002,  2007, 4,   2.03, 25446],
        [10002,  2008, 1.1, 0.01, 6408]    ])

subset1 = data[data[:,0] == 100002]
subset2 = data[data[:,0] == 10002]

Questo produce

subset1:

array([[  1.00002e+05,   2.006e+03,   1.10e+00, 1.00e-02,   6.352e+03],
       [  1.00002e+05,   2.006e+03,   1.20e+00, 8.40e-01,   3.04518e+05],
       [  1.00002e+05,   2.006e+03,   2.00e+00, 1.52e+00,   1.48219e+05],
       [  1.00002e+05,   2.007e+03,   1.10e+00, 1.00e-02,   6.292e+03]])

subset2:

array([[  1.0002e+04,   2.006e+03,   1.10e+00, 1.00e-02,   5.968e+03],
       [  1.0002e+04,   2.006e+03,   1.20e+00, 2.50e-01,   1.04318e+05],
       [  1.0002e+04,   2.007e+03,   1.10e+00, 1.00e-02,   6.800e+03],
       [  1.0002e+04,   2.007e+03,   4.00e+00, 2.03e+00,   2.5446e+04],
       [  1.0002e+04,   2.008e+03,   1.10e+00, 1.00e-02,   6.408e+03]])

Se non si conoscono i valori unici nella prima colonna in anticipo, è possibile utilizzare numpy.unique1d o la funzione built-set per trovare loro.

Edit: Ho appena realizzato che si voleva selezionare i dati dove si hanno combinazioni uniche di due colonne ... In questo caso, si potrebbe fare qualcosa di simile:

col1 = data[:,0]
col2 = data[:,1]

subsets = {}
for val1, val2 in itertools.product(np.unique(col1), np.unique(col2)):
    subset = data[(col1 == val1) & (col2 == val2)]
    if np.any(subset):
        subsets[(val1, val2)] = subset

(sto memorizzazione dei sottoinsiemi come un dizionario, con la chiave è una tupla della combinazione ... Ci sono certamente altri (e meglio, a seconda di quello che stai facendo) modi per fare questo!)

Answer 2

subset() in R è più o meno analogo a filter() in Python. Mentre le note di riferimento, questo sarà usato implicitamente list comprehension, in modo che il più conciso e chiaro modo di scrivere il codice potrebbe essere

[ item for item in items if item.col2 == 2006 ] 

Se, ad esempio, le righe di dati erano in una chiamata items iterabile.

Answer 3

Dal momento che non sono a conoscenza R né come questo comando sottoinsieme funziona in base alla propria descrizione posso suggerire di dare un'occhiata alle funzionalità di groupby itertools. Se data una funzione che fornisce in uscita un valore, è possibile formare gruppi basati su output della funzione. Tratto da groupby :

groups = []
uniquekeys = []
data = sorted(data, key=keyfunc)
for k, g in groupby(data, keyfunc):
    groups.append(list(g))      # Store group iterator as a list
    uniquekeys.append(k)

e poi hai i tuoi sottoinsiemi. Tuttavia, fare attenzione a come i valori restituiti non sono pieni liste a tutti gli effetti. Sono iteratori.

Io parto dal presupposto che i valori vengono restituiti in base riga per riga.