Suddivisione del dizionario / elenco all'interno di una colonna Panda in colonne separate

Ho dei dati salvati in un database postgreSQL. Sto interrogando questi dati usando Python2.7 e trasformandoli in un Pandas DataFrame. Tuttavia, l'ultima colonna di questo frame di dati contiene un dizionario (o un elenco?) Di valori al suo interno. DataFrame è simile al seguente:

[1] df
Station ID     Pollutants
8809           {"a": "46", "b": "3", "c": "12"}
8810           {"a": "36", "b": "5", "c": "8"}
8811           {"b": "2", "c": "7"}
8812           {"c": "11"}
8813           {"a": "82", "c": "15"}

Ho bisogno di dividere questa colonna in colonne separate in modo che DataFrame assomigli a questo:

[2] df2
Station ID     a      b       c
8809           46     3       12
8810           36     5       8
8811           NaN    2       7
8812           NaN    NaN     11
8813           82     NaN     15

Il problema principale che sto riscontrando è che le liste non hanno le stesse lunghezze. Ma tutte le liste contengono solo gli stessi 3 valori: a, b e c. E appaiono sempre nello stesso ordine (un primo, b secondo, c terzo).

Il seguente codice USATO per funzionare e restituire esattamente quello che volevo (df2).

[3] df 
[4] objs = [df, pandas.DataFrame(df['Pollutant Levels'].tolist()).iloc[:, :3]]
[5] df2 = pandas.concat(objs, axis=1).drop('Pollutant Levels', axis=1)
[6] print(df2)

Stavo eseguendo questo codice solo la scorsa settimana e funzionava bene. Ma ora il mio codice è rotto e ottengo questo errore dalla riga [4]:

IndexError: out-of-bounds on slice (end) 

Non ho apportato modifiche al codice ma ora ricevo l'errore. Ritengo che ciò sia dovuto al fatto che il mio metodo non è solido o adeguato.

Eventuali suggerimenti o indicazioni su come dividere questa colonna di elenchi in colonne separate sarebbero molto apprezzati!

EDIT: Penso che i metodi .tolist () e .apply non funzionano sul mio codice perché è una stringa unicode, cioè:

#My data format 
u{'a': '1', 'b': '2', 'c': '3'}

#and not
{u'a': '1', u'b': '2', u'c': '3'}

I dati vengono importati dal database postgreSQL in questo formato. Qualche aiuto o idee con questo problema? c'è un modo per convertire l'unicode?

Per convertire la stringa in un dict reale, puoi farlo df['Pollutant Levels'].map(eval). Successivamente, la soluzione seguente può essere utilizzata per convertire il dict in colonne diverse.

Usando un piccolo esempio, puoi usare .apply(pd.Series):

In [2]: df = pd.DataFrame({'a':[1,2,3], 'b':[{'c':1}, {'d':3}, {'c':5, 'd':6}]})

In [3]: df
Out[3]:
   a                   b
0  1           {u'c': 1}
1  2           {u'd': 3}
2  3  {u'c': 5, u'd': 6}

In [4]: df['b'].apply(pd.Series)
Out[4]:
     c    d
0  1.0  NaN
1  NaN  3.0
2  5.0  6.0

Per combinarlo con il resto del frame di dati, puoi concatle altre colonne con il risultato sopra:

In [7]: pd.concat([df.drop(['b'], axis=1), df['b'].apply(pd.Series)], axis=1)
Out[7]:
   a    c    d
0  1  1.0  NaN
1  2  NaN  3.0
2  3  5.0  6.0

Usando il tuo codice, questo funziona anche se lascio fuori la ilocparte:

In [15]: pd.concat([df.drop('b', axis=1), pd.DataFrame(df['b'].tolist())], axis=1)
Out[15]:
   a    c    d
0  1  1.0  NaN
1  2  NaN  3.0
2  3  5.0  6.0

So che la domanda è piuttosto vecchia, ma sono arrivato qui alla ricerca di risposte. Al momento esiste un modo migliore (e più veloce) per farlo usando json_normalize:

import pandas as pd

df2 = pd.json_normalize(df['Pollutant Levels'])

Questo evita costose funzioni di applicazione ...

Prova questo: i dati restituiti da SQL devono essere convertiti in Dict. o potrebbe essere "Pollutant Levels" è oraPollutants'

   StationID                   Pollutants
0       8809  {"a":"46","b":"3","c":"12"}
1       8810   {"a":"36","b":"5","c":"8"}
2       8811            {"b":"2","c":"7"}
3       8812                   {"c":"11"}
4       8813          {"a":"82","c":"15"}


df2["Pollutants"] = df2["Pollutants"].apply(lambda x : dict(eval(x)) )
df3 = df2["Pollutants"].apply(pd.Series )

    a    b   c
0   46    3  12
1   36    5   8
2  NaN    2   7
3  NaN  NaN  11
4   82  NaN  15


result = pd.concat([df, df3], axis=1).drop('Pollutants', axis=1)
result

   StationID    a    b   c
0       8809   46    3  12
1       8810   36    5   8
2       8811  NaN    2   7
3       8812  NaN  NaN  11
4       8813   82  NaN  15

La risposta di Merlin è migliore e super facile, ma non abbiamo bisogno di una funzione lambda. La valutazione del dizionario può essere tranquillamente ignorata in uno dei due modi seguenti, come illustrato di seguito:

Modo 1: due passaggi

# step 1: convert the `Pollutants` column to Pandas dataframe series
df_pol_ps = data_df['Pollutants'].apply(pd.Series)

df_pol_ps:
    a   b   c
0   46  3   12
1   36  5   8
2   NaN 2   7
3   NaN NaN 11
4   82  NaN 15

# step 2: concat columns `a, b, c` and drop/remove the `Pollutants` 
df_final = pd.concat([df, df_pol_ps], axis = 1).drop('Pollutants', axis = 1)

df_final:
    StationID   a   b   c
0   8809    46  3   12
1   8810    36  5   8
2   8811    NaN 2   7
3   8812    NaN NaN 11
4   8813    82  NaN 15

Modo 2: i due passaggi precedenti possono essere combinati in una volta sola:

df_final = pd.concat([df, df['Pollutants'].apply(pd.Series)], axis = 1).drop('Pollutants', axis = 1)

df_final:
    StationID   a   b   c
0   8809    46  3   12
1   8810    36  5   8
2   8811    NaN 2   7
3   8812    NaN NaN 11
4   8813    82  NaN 15

Consiglio vivamente il metodo di estrarre la colonna 'inquinanti':

df_pollutants = pd.DataFrame(df['Pollutants'].values.tolist(), index=df.index)

è molto più veloce di

df_pollutants = df['Pollutants'].apply(pd.Series)

quando la dimensione di df è gigante.

Puoi usare joincon pop+ tolist. Le prestazioni sono paragonabili a concatcon drop+ tolist, ma alcuni possono trovare questo pulitore sintassi:

res = df.join(pd.DataFrame(df.pop('b').tolist()))

Benchmarking con altri metodi:

df = pd.DataFrame({'a':[1,2,3], 'b':[{'c':1}, {'d':3}, {'c':5, 'd':6}]})

def joris1(df):
    return pd.concat([df.drop('b', axis=1), df['b'].apply(pd.Series)], axis=1)

def joris2(df):
    return pd.concat([df.drop('b', axis=1), pd.DataFrame(df['b'].tolist())], axis=1)

def jpp(df):
    return df.join(pd.DataFrame(df.pop('b').tolist()))

df = pd.concat([df]*1000, ignore_index=True)

%timeit joris1(df.copy())  # 1.33 s per loop
%timeit joris2(df.copy())  # 7.42 ms per loop
%timeit jpp(df.copy())     # 7.68 ms per loop

Una soluzione di linea è la seguente:

>>> df = pd.concat([df['Station ID'], df['Pollutants'].apply(pd.Series)], axis=1)
>>> print(df)
   Station ID    a    b   c
0        8809   46    3  12
1        8810   36    5   8
2        8811  NaN    2   7
3        8812  NaN  NaN  11
4        8813   82  NaN  15

my_df = pd.DataFrame.from_dict(my_dict, orient='index', columns=['my_col'])

.. avrebbe analizzato correttamente il dict (inserendo ciascuna chiave dict in una colonna df separata e i valori chiave in righe df), quindi i dadi non verrebbero schiacciati in una singola colonna in primo luogo.

Ho concatenato questi passaggi in un metodo, devi solo passare il frame di dati e la colonna che contiene il dict da espandere:

def expand_dataframe(dw: pd.DataFrame, column_to_expand: str) -> pd.DataFrame:
    """
    dw: DataFrame with some column which contain a dict to expand
        in columns
    column_to_expand: String with column name of dw
    """
    import pandas as pd

    def convert_to_dict(sequence: str) -> Dict:
        import json
        s = sequence
        json_acceptable_string = s.replace("'", "\"")
        d = json.loads(json_acceptable_string)
        return d    

    expanded_dataframe = pd.concat([dw.drop([column_to_expand], axis=1),
                                    dw[column_to_expand]
                                    .apply(convert_to_dict)
                                    .apply(pd.Series)],
                                    axis=1)
    return expanded_dataframe

df = pd.concat([df['a'], df.b.apply(pd.Series)], axis=1)