Divisão de dicionário / lista dentro de uma coluna do Pandas em colunas separadas

Tenho dados salvos em um banco de dados postgreSQL. Estou consultando esses dados usando Python2.7 e transformando-os em um DataFrame do Pandas. No entanto, a última coluna desse quadro de dados possui um dicionário (ou lista?) De valores. O DataFrame fica assim:

[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"}

Eu preciso dividir esta coluna em colunas separadas para que o DataFrame fique assim:

[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

O principal problema que estou enfrentando é que as listas não são do mesmo tamanho. Mas todas as listas contêm apenas os mesmos três valores: a, bec. E eles sempre aparecem na mesma ordem (um primeiro, b segundo, c terceiro).

O código a seguir USADO para trabalhar e retornar exatamente o que eu queria (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)

Eu estava executando esse código apenas na semana passada e estava funcionando bem. Mas agora meu código está quebrado e recebo esse erro da linha [4]:

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

Não fiz alterações no código, mas agora estou recebendo o erro. Sinto que isso se deve ao fato de meu método não ser robusto ou adequado.

Qualquer sugestão ou orientação sobre como dividir esta coluna de listas em colunas separadas seria super apreciada!

EDIT: Eu acho que os métodos .tolist () e .apply não estão funcionando no meu código porque é uma string unicode, ou seja:

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

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

Os dados estão sendo importados do banco de dados postgreSQL neste formato. Alguma ajuda ou idéias para esse problema? existe uma maneira de converter o unicode?

Para converter a string em um ditado real, você pode fazer df['Pollutant Levels'].map(eval). Posteriormente, a solução abaixo pode ser usada para converter o ditado em colunas diferentes.

Usando um pequeno exemplo, você pode usar .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

Para combiná-lo com o restante do quadro de dados, você pode concatoutras colunas com o resultado acima:

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 seu código, isso também funciona se eu deixar de fora a 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

Eu sei que a pergunta é bastante antiga, mas cheguei aqui procurando respostas. Atualmente, existe uma maneira melhor (e mais rápida) de fazer isso usando json_normalize:

import pandas as pd

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

Isso evita funções caras de aplicação ...

Tente o seguinte: Os dados retornados do SQL devem ser convertidos em um Dict. ou poderia ser "Pollutant Levels" agoraPollutants'

   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

A resposta de Merlin é melhor e super fácil, mas não precisamos de uma função lambda. A avaliação do dicionário pode ser ignorada com segurança por uma das duas maneiras a seguir, conforme ilustrado abaixo:

Caminho 1: dois passos

# 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

Caminho 2: As duas etapas acima podem ser combinadas de uma só vez:

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

Eu recomendo fortemente que o método extraia a coluna 'Poluentes':

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

é muito mais rápido que

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

quando o tamanho de df é gigante.

Você pode usar joincom pop+ tolist. O desempenho é comparável ao concatcom drop+ tolist, mas alguns podem encontrar este limpador de sintaxe:

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

Benchmarking com outros métodos:

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

Uma solução de linha é a seguinte:

>>> 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'])

.. teria analisado o dict corretamente (colocando cada chave de dict em uma coluna df separada e valores de chave em linhas df), para que os dict não fossem compactados em uma única coluna em primeiro lugar.

Concatenei essas etapas em um método, você deve passar apenas o dataframe e a coluna que contém o comando para expandir:

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)