Pandas - Como nivelar um índice hierárquico em colunas


325

Eu tenho um quadro de dados com um índice hierárquico no eixo 1 (colunas) (de uma groupby.aggoperação):

     USAF   WBAN  year  month  day  s_PC  s_CL  s_CD  s_CNT  tempf       
                                     sum   sum   sum    sum   amax   amin
0  702730  26451  1993      1    1     1     0    12     13  30.92  24.98
1  702730  26451  1993      1    2     0     0    13     13  32.00  24.98
2  702730  26451  1993      1    3     1    10     2     13  23.00   6.98
3  702730  26451  1993      1    4     1     0    12     13  10.04   3.92
4  702730  26451  1993      1    5     3     0    10     13  19.94  10.94

Quero aplainá-lo, para que fique assim (os nomes não são críticos - eu poderia renomear):

     USAF   WBAN  year  month  day  s_PC  s_CL  s_CD  s_CNT  tempf_amax  tmpf_amin   
0  702730  26451  1993      1    1     1     0    12     13  30.92          24.98
1  702730  26451  1993      1    2     0     0    13     13  32.00          24.98
2  702730  26451  1993      1    3     1    10     2     13  23.00          6.98
3  702730  26451  1993      1    4     1     0    12     13  10.04          3.92
4  702730  26451  1993      1    5     3     0    10     13  19.94          10.94

Como eu faço isso? (Eu tentei muito, sem sucesso.)

Por sugestão, aqui está a cabeça em forma de ditado

{('USAF', ''): {0: '702730',
  1: '702730',
  2: '702730',
  3: '702730',
  4: '702730'},
 ('WBAN', ''): {0: '26451', 1: '26451', 2: '26451', 3: '26451', 4: '26451'},
 ('day', ''): {0: 1, 1: 2, 2: 3, 3: 4, 4: 5},
 ('month', ''): {0: 1, 1: 1, 2: 1, 3: 1, 4: 1},
 ('s_CD', 'sum'): {0: 12.0, 1: 13.0, 2: 2.0, 3: 12.0, 4: 10.0},
 ('s_CL', 'sum'): {0: 0.0, 1: 0.0, 2: 10.0, 3: 0.0, 4: 0.0},
 ('s_CNT', 'sum'): {0: 13.0, 1: 13.0, 2: 13.0, 3: 13.0, 4: 13.0},
 ('s_PC', 'sum'): {0: 1.0, 1: 0.0, 2: 1.0, 3: 1.0, 4: 3.0},
 ('tempf', 'amax'): {0: 30.920000000000002,
  1: 32.0,
  2: 23.0,
  3: 10.039999999999999,
  4: 19.939999999999998},
 ('tempf', 'amin'): {0: 24.98,
  1: 24.98,
  2: 6.9799999999999969,
  3: 3.9199999999999982,
  4: 10.940000000000001},
 ('year', ''): {0: 1993, 1: 1993, 2: 1993, 3: 1993, 4: 1993}}

5
você pode adicionar a saída df[:5].to_dict()como um exemplo para outras pessoas lerem no seu conjunto de dados?
precisa saber é o seguinte

Boa ideia. Fiz isso acima, pois era muito longo para o comentário.
Ross R

Há uma sugestão no pandasrastreador de problemas para implementar um método dedicado para isso.
Joelostblom 10/07/2018

2
@joelostblom e de fato foi implementado (pandas 0.24.0 e acima). Eu postei uma resposta, mas basicamente agora você pode fazer dat.columns = dat.columns.to_flat_index(). Função de pandas incorporada.
onlyphantom

Respostas:


471

Eu acho que a maneira mais fácil de fazer isso seria definir as colunas para o nível superior:

df.columns = df.columns.get_level_values(0)

Nota: se o nível to tiver um nome, você também poderá acessá-lo por este, em vez de 0.

.

Se você deseja combinar / joinseu MultiIndex em um índice (supondo que você tenha apenas entradas de string em suas colunas), você pode:

df.columns = [' '.join(col).strip() for col in df.columns.values]

Nota: precisamos stripo espaço em branco para quando não houver um segundo índice.

In [11]: [' '.join(col).strip() for col in df.columns.values]
Out[11]: 
['USAF',
 'WBAN',
 'day',
 'month',
 's_CD sum',
 's_CL sum',
 's_CNT sum',
 's_PC sum',
 'tempf amax',
 'tempf amin',
 'year']

14
df.reset_index (inplace = True) pode ser uma solução alternativa.
Tobias

8
um comentário secundário ... se você quiser usar _ para os vários níveis da coluna de combinação .. você pode usar isso ... df.columns = ['_'. join (col) .strip () para col em df.columns. valores]
ihightower

30
pequenas modificações para manter o sublinhado apenas de colunas associadas:['_'.join(col).rstrip('_') for col in df.columns.values]
Seiji Armstrong

Isso funcionou muito bem, se você quiser apenas o segundo uso da coluna: df.columns = [col [1] para col no df.columns.values]
user3078500

1
Se você quiser usar em sum s_CDvez de s_CD sum, pode-se fazer df.columns = ['_'.join(col).rstrip('_') for col in [c[::-1] for c in df.columns.values]].
irene

82
pd.DataFrame(df.to_records()) # multiindex become columns and new index is integers only

3
Isso funciona, mas deixa para trás nomes das colunas que são de difícil acesso por meio de programação e não são queriable
DMEU

1
Isso não funcionará com a versão mais recente do pandas. Funciona com 0,18, mas não com 0,20 (mais recente até agora) #
TH22 10/10

1
@dmeu para preservar os nomes das colunas pd.DataFrame(df.to_records(), columns=df.index.names + list(df.columns))
Teoretic

1
Ele está preservando os nomes das colunas como tuplas para mim, e para manter o índice que eu uso:pd.DataFrame(df_volume.to_records(), index=df_volume.index).drop('index', axis=1)
Jayen

54

Todas as respostas atuais neste tópico devem ter sido um pouco datadas. A partir da pandasversão 0.24.0, o .to_flat_index()que você precisa.

Da documentação do panda :

MultiIndex.to_flat_index ()

Converta um MultiIndex em um índice de tuplas que contém os valores de nível.

Um exemplo simples de sua documentação:

import pandas as pd
print(pd.__version__) # '0.23.4'
index = pd.MultiIndex.from_product(
        [['foo', 'bar'], ['baz', 'qux']],
        names=['a', 'b'])

print(index)
# MultiIndex(levels=[['bar', 'foo'], ['baz', 'qux']],
#           codes=[[1, 1, 0, 0], [0, 1, 0, 1]],
#           names=['a', 'b'])

Aplicando to_flat_index():

index.to_flat_index()
# Index([('foo', 'baz'), ('foo', 'qux'), ('bar', 'baz'), ('bar', 'qux')], dtype='object')

Utilizando-o para substituir os existentes pandas coluna

Um exemplo de como você o utilizaria dat, que é um DataFrame com uma MultiIndexcoluna:

dat = df.loc[:,['name','workshop_period','class_size']].groupby(['name','workshop_period']).describe()
print(dat.columns)
# MultiIndex(levels=[['class_size'], ['count', 'mean', 'std', 'min', '25%', '50%', '75%', 'max']],
#            codes=[[0, 0, 0, 0, 0, 0, 0, 0], [0, 1, 2, 3, 4, 5, 6, 7]])

dat.columns = dat.columns.to_flat_index()
print(dat.columns)
# Index([('class_size', 'count'),  ('class_size', 'mean'),
#     ('class_size', 'std'),   ('class_size', 'min'),
#     ('class_size', '25%'),   ('class_size', '50%'),
#     ('class_size', '75%'),   ('class_size', 'max')],
#  dtype='object')

42

A resposta de Andy Hayden é certamente a maneira mais fácil - se você quiser evitar rótulos de coluna duplicados, precisará ajustar um pouco

In [34]: df
Out[34]: 
     USAF   WBAN  day  month  s_CD  s_CL  s_CNT  s_PC  tempf         year
                               sum   sum    sum   sum   amax   amin      
0  702730  26451    1      1    12     0     13     1  30.92  24.98  1993
1  702730  26451    2      1    13     0     13     0  32.00  24.98  1993
2  702730  26451    3      1     2    10     13     1  23.00   6.98  1993
3  702730  26451    4      1    12     0     13     1  10.04   3.92  1993
4  702730  26451    5      1    10     0     13     3  19.94  10.94  1993


In [35]: mi = df.columns

In [36]: mi
Out[36]: 
MultiIndex
[(USAF, ), (WBAN, ), (day, ), (month, ), (s_CD, sum), (s_CL, sum), (s_CNT, sum), (s_PC, sum), (tempf, amax), (tempf, amin), (year, )]


In [37]: mi.tolist()
Out[37]: 
[('USAF', ''),
 ('WBAN', ''),
 ('day', ''),
 ('month', ''),
 ('s_CD', 'sum'),
 ('s_CL', 'sum'),
 ('s_CNT', 'sum'),
 ('s_PC', 'sum'),
 ('tempf', 'amax'),
 ('tempf', 'amin'),
 ('year', '')]

In [38]: ind = pd.Index([e[0] + e[1] for e in mi.tolist()])

In [39]: ind
Out[39]: Index([USAF, WBAN, day, month, s_CDsum, s_CLsum, s_CNTsum, s_PCsum, tempfamax, tempfamin, year], dtype=object)

In [40]: df.columns = ind




In [46]: df
Out[46]: 
     USAF   WBAN  day  month  s_CDsum  s_CLsum  s_CNTsum  s_PCsum  tempfamax  tempfamin  \
0  702730  26451    1      1       12        0        13        1      30.92      24.98   
1  702730  26451    2      1       13        0        13        0      32.00      24.98   
2  702730  26451    3      1        2       10        13        1      23.00       6.98   
3  702730  26451    4      1       12        0        13        1      10.04       3.92   
4  702730  26451    5      1       10        0        13        3      19.94      10.94   




   year  
0  1993  
1  1993  
2  1993  
3  1993  
4  1993

2
obrigado Theodros! Esta é a única solução correta que lida com todos os casos!
CanCeylan

17
df.columns = ['_'.join(tup).rstrip('_') for tup in df.columns.values]

14

E se você deseja reter alguma das informações de agregação do segundo nível do multi-índice, você pode tentar o seguinte:

In [1]: new_cols = [''.join(t) for t in df.columns]
Out[1]:
['USAF',
 'WBAN',
 'day',
 'month',
 's_CDsum',
 's_CLsum',
 's_CNTsum',
 's_PCsum',
 'tempfamax',
 'tempfamin',
 'year']

In [2]: df.columns = new_cols

new_colsnão está definido.
samthebrand

11

A maneira mais pitônica de fazer isso para usar a mapfunção

df.columns = df.columns.map(' '.join).str.strip()

Saída print(df.columns):

Index(['USAF', 'WBAN', 'day', 'month', 's_CD sum', 's_CL sum', 's_CNT sum',
       's_PC sum', 'tempf amax', 'tempf amin', 'year'],
      dtype='object')

Atualize usando Python 3.6+ com a string f:

df.columns = [f'{f} {s}' if s != '' else f'{f}' 
              for f, s in df.columns]

print(df.columns)

Resultado:

Index(['USAF', 'WBAN', 'day', 'month', 's_CD sum', 's_CL sum', 's_CNT sum',
       's_PC sum', 'tempf amax', 'tempf amin', 'year'],
      dtype='object')

9

A solução mais fácil e intuitiva para mim foi combinar os nomes das colunas usando get_level_values . Isso evita nomes de colunas duplicados quando você faz mais de uma agregação na mesma coluna:

level_one = df.columns.get_level_values(0).astype(str)
level_two = df.columns.get_level_values(1).astype(str)
df.columns = level_one + level_two

Se você deseja um separador entre colunas, você pode fazer isso. Isso retornará o mesmo que o comentário de Seiji Armstrong na resposta aceita, que inclui apenas sublinhados para colunas com valores nos dois níveis de índice:

level_one = df.columns.get_level_values(0).astype(str)
level_two = df.columns.get_level_values(1).astype(str)
column_separator = ['_' if x != '' else '' for x in level_two]
df.columns = level_one + column_separator + level_two

Eu sei que isso faz o mesmo que a ótima resposta de Andy Hayden acima, mas acho que é um pouco mais intuitivo e fácil de lembrar (por isso não preciso continuar me referindo a esse tópico), especialmente para usuários iniciantes de pandas .

Esse método também é mais extensível no caso em que você pode ter três níveis de coluna.

level_one = df.columns.get_level_values(0).astype(str)
level_two = df.columns.get_level_values(1).astype(str)
level_three = df.columns.get_level_values(2).astype(str)
df.columns = level_one + level_two + level_three

6

Depois de ler todas as respostas, vim com isso:

def __my_flatten_cols(self, how="_".join, reset_index=True):
    how = (lambda iter: list(iter)[-1]) if how == "last" else how
    self.columns = [how(filter(None, map(str, levels))) for levels in self.columns.values] \
                    if isinstance(self.columns, pd.MultiIndex) else self.columns
    return self.reset_index() if reset_index else self
pd.DataFrame.my_flatten_cols = __my_flatten_cols

Uso:

Dado um quadro de dados:

df = pd.DataFrame({"grouper": ["x","x","y","y"], "val1": [0,2,4,6], 2: [1,3,5,7]}, columns=["grouper", "val1", 2])

  grouper  val1  2
0       x     0  1
1       x     2  3
2       y     4  5
3       y     6  7
  • Método de agregação único : variáveis ​​resultantes nomeadas da mesma forma que fonte :

    df.groupby(by="grouper").agg("min").my_flatten_cols()
    • Igual df.groupby(by="grouper", a_index = False) ou .agg(...).reset_index ()
    • ----- before -----
                 val1  2
        grouper         
      
      ------ after -----
        grouper  val1  2
      0       x     0  1
      1       y     4  5
  • Variável de origem única, várias agregações : variáveis ​​resultantes nomeadas após estatísticas :

    df.groupby(by="grouper").agg({"val1": [min,max]}).my_flatten_cols("last")
    • O mesmo que a = df.groupby(..).agg(..); a.columns = a.columns.droplevel(0); a.reset_index().
    • ----- before -----
                  val1    
                 min max
        grouper         
      
      ------ after -----
        grouper  min  max
      0       x    0    2
      1       y    4    6
  • Várias variáveis, várias agregações : variáveis ​​resultantes nomeadas (varname) _ (statname) :

    df.groupby(by="grouper").agg({"val1": min, 2:[sum, "size"]}).my_flatten_cols()
    # you can combine the names in other ways too, e.g. use a different delimiter:
    #df.groupby(by="grouper").agg({"val1": min, 2:[sum, "size"]}).my_flatten_cols(" ".join)
    • É executado a.columns = ["_".join(filter(None, map(str, levels))) for levels in a.columns.values]sob o capô (já que essa forma de agg()resultado emMultiIndex colunas).
    • Se você não tem o my_flatten_colsajudante, que poderia ser mais fácil de digitar a solução sugerida por @Seigi : a.columns = ["_".join(t).rstrip("_") for t in a.columns.values], que funciona de forma semelhante, neste caso (mas não se você tem rótulos numéricos em colunas)
    • Para manipular os rótulos numéricos nas colunas, você pode usar a solução sugerida por @jxstanford e @Nolan Conaway ( a.columns = ["_".join(tuple(map(str, t))).rstrip("_") for t in a.columns.values]), mas não entendo por que a tuple()chamada é necessária e acredito que rstrip()só será necessária se algumas colunas tiverem um descritor como ("colname", "")( o que pode acontecer se você reset_index()antes de tentar consertar .columns)
    • ----- before -----
                 val1           2     
                 min       sum    size
        grouper              
      
      ------ after -----
        grouper  val1_min  2_sum  2_size
      0       x         0      4       2
      1       y         4     12       2
  • Você deseja nomear as variáveis resultantes manualmente: (isso é obsoleto desde pandas 0.20.0 com qualquer alternativa adequada a partir de 0,23 )

    df.groupby(by="grouper").agg({"val1": {"sum_of_val1": "sum", "count_of_val1": "count"},
                                       2: {"sum_of_2":    "sum", "count_of_2":    "count"}}).my_flatten_cols("last")
    • De outros sugestões incluem : configuração manual das colunas: res.columns = ['A_sum', 'B_sum', 'count']ou .join()ing várias groupbyinstruções.
    • ----- before -----
                         val1                      2         
                count_of_val1 sum_of_val1 count_of_2 sum_of_2
        grouper                                              
      
      ------ after -----
        grouper  count_of_val1  sum_of_val1  count_of_2  sum_of_2
      0       x              2            2           2         4
      1       y              2           10           2        12

Casos tratados pela função auxiliar

  • nomes de nível podem não ser de seqüência de caracteres, por exemplo, Index pandas DataFrame por números de coluna, quando os nomes de coluna são inteiros , portanto, temos que converter commap(str, ..)
  • eles também podem estar vazios, então temos que filter(None, ..)
  • para colunas de nível único (ou seja, qualquer coisa, exceto MultiIndex), columns.valuesretorna os nomes ( stre não as tuplas)
  • dependendo de como você usou, .agg()pode ser necessário manter o rótulo mais baixo de uma coluna ou concatenar vários rótulos
  • (como sou novato em pandas?) com mais frequência, desejo reset_index()poder trabalhar com as colunas agrupar de maneira regular, por isso é o padrão

resposta realmente ótima, você pode explicar o trabalho de '[" " .join (tupla (mapa (str, t))). rstrip (" ") para t em a.columns.values]', obrigado antecipadamente
Vineet 26/07

@Vineet Atualizei minha postagem para indicar que mencionei esse trecho para sugerir que ele tem um efeito semelhante à minha solução. Se você quiser detalhes sobre o motivo, tuple()é necessário comentar a publicação de jxstanford. Caso contrário, ele pode ser útil para inspecionar o .columns.valuesno exemplo fornecido: [('val1', 'min'), (2, 'sum'), (2, 'size')]. 1) for t in a.columns.valuesloops sobre as colunas, para a segunda coluna t == (2, 'sum'); 2) map(str, t)se aplica str()a cada "nível", resultando em ('2', 'sum'); 3) "_".join(('2','sum'))resulta em "2_sum",
Nickolay

5

Uma solução geral que lida com vários níveis e tipos mistos:

df.columns = ['_'.join(tuple(map(str, t))) for t in df.columns.values]

1
Caso também existam colunas não hierárquicas:df.columns = ['_'.join(tuple(map(str, t))).rstrip('_') for t in df.columns.values]
Nolan Conaway

Obrigado. Estava procurando por muito tempo. Desde que meu índice multinível continha valores inteiros. Ele resolveu o meu problema :)
AnksG

4

Um pouco tarde, talvez, mas se você não estiver preocupado com nomes de colunas duplicados:

df.columns = df.columns.tolist()

Para mim, isso altera os nomes das colunas para serem parecidos com tuplas: (year, )e(tempf, amax)
Nickolay 28/05

3

Caso você queira ter um separador no nome entre os níveis, essa função funcionará bem.

def flattenHierarchicalCol(col,sep = '_'):
    if not type(col) is tuple:
        return col
    else:
        new_col = ''
        for leveli,level in enumerate(col):
            if not level == '':
                if not leveli == 0:
                    new_col += sep
                new_col += level
        return new_col

df.columns = df.columns.map(flattenHierarchicalCol)

1
Eu gosto disso. Deixando de fora o caso em que as colunas são não hierárquica isso pode ser muito simplificado:df.columns = ["_".join(filter(None, c)) for c in df.columns]
Gigo

3

Seguindo @jxstanford e @ tvt173, escrevi uma função rápida que deveria resolver o problema, independentemente dos nomes das colunas string / int:

def flatten_cols(df):
    df.columns = [
        '_'.join(tuple(map(str, t))).rstrip('_') 
        for t in df.columns.values
        ]
    return df

1

Você também pode fazer o seguinte. Considere dfser o seu dataframe e assuma um índice de dois níveis (como é o caso no seu exemplo)

df.columns = [(df.columns[i][0])+'_'+(datadf_pos4.columns[i][1]) for i in range(len(df.columns))]

1

Vou compartilhar uma maneira direta que funcionou para mim.

[" ".join([str(elem) for elem in tup]) for tup in df.columns.tolist()]
#df = df.reset_index() if needed

0

Para nivelar um MultiIndex dentro de uma cadeia de outros métodos DataFrame, defina uma função como esta:

def flatten_index(df):
  df_copy = df.copy()
  df_copy.columns = ['_'.join(col).rstrip('_') for col in df_copy.columns.values]
  return df_copy.reset_index()

Em seguida, use o pipemétodo para aplicar esta função na cadeia de métodos DataFrame, antes groupbye depois de aggqualquer outro método na cadeia:

my_df \
  .groupby('group') \
  .agg({'value': ['count']}) \
  .pipe(flatten_index) \
  .sort_values('value_count')

0

Outra rotina simples.

def flatten_columns(df, sep='.'):
    def _remove_empty(column_name):
        return tuple(element for element in column_name if element)
    def _join(column_name):
        return sep.join(column_name)

    new_columns = [_join(_remove_empty(column)) for column in df.columns.values]
    df.columns = new_columns
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.