Eu tenho 3 arquivos CSV. Cada um tem a primeira coluna como o nome (string) das pessoas, enquanto todas as outras colunas em cada dataframe são atributos dessa pessoa.

Como posso "unir" todos os três documentos CSV para criar um único CSV com cada linha tendo todos os atributos para cada valor exclusivo do nome da string da pessoa?

A join()função no pandas especifica que eu preciso de um índice múltiplo, mas estou confuso sobre o que um esquema de indexação hierárquica tem a ver com a criação de uma junção com base em um único índice.

Importações assumidas:

import pandas as pd

A resposta de John Galt é basicamente uma reduceoperação. Se eu tiver mais do que um punhado de quadros de dados, eu os colocaria em uma lista como esta (gerada através de compreensões ou loops de lista ou outros enfeites):

dfs = [df0, df1, df2, dfN]

Supondo que eles tenham alguma coluna em comum, como nameno seu exemplo, eu faria o seguinte:

df_final = reduce(lambda left,right: pd.merge(left,right,on='name'), dfs)

Dessa forma, seu código deve funcionar com qualquer número de quadros de dados que você deseja mesclar.

Editar 1 de agosto de 2016 : Para aqueles que usam Python 3: reducefoi movido para functools. Portanto, para usar esta função, primeiro você precisará importar esse módulo:

from functools import reduce

Você pode tentar isso se tiver 3 quadros de dados

# Merge multiple dataframes
df1 = pd.DataFrame(np.array([
    ['a', 5, 9],
    ['b', 4, 61],
    ['c', 24, 9]]),
    columns=['name', 'attr11', 'attr12'])
df2 = pd.DataFrame(np.array([
    ['a', 5, 19],
    ['b', 14, 16],
    ['c', 4, 9]]),
    columns=['name', 'attr21', 'attr22'])
df3 = pd.DataFrame(np.array([
    ['a', 15, 49],
    ['b', 4, 36],
    ['c', 14, 9]]),
    columns=['name', 'attr31', 'attr32'])

pd.merge(pd.merge(df1,df2,on='name'),df3,on='name')

alternativamente, como mencionado por cwharland

df1.merge(df2,on='name').merge(df3,on='name')

Esta é uma situação ideal para o join método

o join método é criado exatamente para esses tipos de situações. Você pode associar qualquer número de DataFrames a ele. O DataFrame chamador se junta ao índice da coleção de DataFrames passados. Para trabalhar com vários DataFrames, você deve colocar as colunas de junção no índice.

O código ficaria assim:

filenames = ['fn1', 'fn2', 'fn3', 'fn4',....]
dfs = [pd.read_csv(filename, index_col=index_col) for filename in filenames)]
dfs[0].join(dfs[1:])

Com os dados de @ zero, você pode fazer o seguinte:

df1 = pd.DataFrame(np.array([
    ['a', 5, 9],
    ['b', 4, 61],
    ['c', 24, 9]]),
    columns=['name', 'attr11', 'attr12'])
df2 = pd.DataFrame(np.array([
    ['a', 5, 19],
    ['b', 14, 16],
    ['c', 4, 9]]),
    columns=['name', 'attr21', 'attr22'])
df3 = pd.DataFrame(np.array([
    ['a', 15, 49],
    ['b', 4, 36],
    ['c', 14, 9]]),
    columns=['name', 'attr31', 'attr32'])

dfs = [df1, df2, df3]
dfs = [df.set_index('name') for df in dfs]
dfs[0].join(dfs[1:])

     attr11 attr12 attr21 attr22 attr31 attr32
name                                          
a         5      9      5     19     15     49
b         4     61     14     16      4     36
c        24      9      4      9     14      9

Isso também pode ser feito da seguinte maneira para obter uma lista de quadros de dados df_list:

df = df_list[0]
for df_ in df_list[1:]:
    df = df.merge(df_, on='join_col_name')

ou se os quadros de dados estiverem em um objeto gerador (por exemplo, para reduzir o consumo de memória):

df = next(df_list)
for df_ in df_list:
    df = df.merge(df_, on='join_col_name')

No python3.6.3 com pandas0.22.0, você também pode usar concat, desde que você defina como índice, as colunas que deseja usar para a associação

pd.concat(
    (iDF.set_index('name') for iDF in [df1, df2, df3]),
    axis=1, join='inner'
).reset_index()

onde df1,, df2e df3são definidos como na resposta de John Galt

import pandas as pd
df1 = pd.DataFrame(np.array([
    ['a', 5, 9],
    ['b', 4, 61],
    ['c', 24, 9]]),
    columns=['name', 'attr11', 'attr12']
)
df2 = pd.DataFrame(np.array([
    ['a', 5, 19],
    ['b', 14, 16],
    ['c', 4, 9]]),
    columns=['name', 'attr21', 'attr22']
)
df3 = pd.DataFrame(np.array([
    ['a', 15, 49],
    ['b', 4, 36],
    ['c', 14, 9]]),
    columns=['name', 'attr31', 'attr32']
)

Não é necessário um multi-índice para executar operações de junção . Basta definir corretamente a coluna do índice na qual executar as operações de junção (que comandam df.set_index('Name')por exemplo)

A joinoperação é executada por padrão no índice. No seu caso, você apenas precisa especificar que a Namecoluna corresponde ao seu índice. Abaixo está um exemplo

Um tutorial pode ser útil.

# Simple example where dataframes index are the name on which to perform the join operations
import pandas as pd
import numpy as np
name = ['Sophia' ,'Emma' ,'Isabella' ,'Olivia' ,'Ava' ,'Emily' ,'Abigail' ,'Mia']
df1 = pd.DataFrame(np.random.randn(8, 3), columns=['A','B','C'], index=name)
df2 = pd.DataFrame(np.random.randn(8, 1), columns=['D'],         index=name)
df3 = pd.DataFrame(np.random.randn(8, 2), columns=['E','F'],     index=name)
df = df1.join(df2)
df = df.join(df3)

# If you a 'Name' column that is not the index of your dataframe, one can set this column to be the index
# 1) Create a column 'Name' based on the previous index
df1['Name']=df1.index
# 1) Select the index from column 'Name'
df1=df1.set_index('Name')

# If indexes are different, one may have to play with parameter how
gf1 = pd.DataFrame(np.random.randn(8, 3), columns=['A','B','C'], index=range(8))
gf2 = pd.DataFrame(np.random.randn(8, 1), columns=['D'], index=range(2,10))
gf3 = pd.DataFrame(np.random.randn(8, 2), columns=['E','F'], index=range(4,12))

gf = gf1.join(gf2, how='outer')
gf = gf.join(gf3, how='outer')

Aqui está um método para mesclar um dicionário de quadros de dados enquanto mantém os nomes das colunas sincronizados com o dicionário. Também preenche os valores ausentes, se necessário:

Esta é a função para mesclar um ditado de quadros de dados

def MergeDfDict(dfDict, onCols, how='outer', naFill=None):
  keys = dfDict.keys()
  for i in range(len(keys)):
    key = keys[i]
    df0 = dfDict[key]
    cols = list(df0.columns)
    valueCols = list(filter(lambda x: x not in (onCols), cols))
    df0 = df0[onCols + valueCols]
    df0.columns = onCols + [(s + '_' + key) for s in valueCols] 

    if (i == 0):
      outDf = df0
    else:
      outDf = pd.merge(outDf, df0, how=how, on=onCols)   

  if (naFill != None):
    outDf = outDf.fillna(naFill)

  return(outDf)

OK, vamos gerar dados e testar isso:

def GenDf(size):
  df = pd.DataFrame({'categ1':np.random.choice(a=['a', 'b', 'c', 'd', 'e'], size=size, replace=True),
                      'categ2':np.random.choice(a=['A', 'B'], size=size, replace=True), 
                      'col1':np.random.uniform(low=0.0, high=100.0, size=size), 
                      'col2':np.random.uniform(low=0.0, high=100.0, size=size)
                      })
  df = df.sort_values(['categ2', 'categ1', 'col1', 'col2'])
  return(df)


size = 5
dfDict = {'US':GenDf(size), 'IN':GenDf(size), 'GER':GenDf(size)}   
MergeDfDict(dfDict=dfDict, onCols=['categ1', 'categ2'], how='outer', naFill=0)

Solução Simples:

Se os nomes das colunas forem semelhantes:

 df1.merge(df2,on='col_name').merge(df3,on='col_name')

Se os nomes das colunas forem diferentes:

df1.merge(df2,left_on='col_name1', right_on='col_name2').merge(df3,left_on='col_name1', right_on='col_name3').drop(columns=['col_name2', 'col_name3']).rename(columns={'col_name1':'col_name'})

Existe outra solução na documentação do pandas (que não vejo aqui),

usando o .append

>>> df = pd.DataFrame([[1, 2], [3, 4]], columns=list('AB'))
   A  B
0  1  2
1  3  4
>>> df2 = pd.DataFrame([[5, 6], [7, 8]], columns=list('AB'))
   A  B
0  5  6
1  7  8
>>> df.append(df2, ignore_index=True)
   A  B
0  1  2
1  3  4
2  5  6
3  7  8

o ignore_index=True é usado para ignorar o índice do quadro de dados anexado, substituindo-o pelo próximo índice disponível no de origem.

Se houver nomes de colunas diferentes, Nanserá apresentado.

Os três quadros de dados são

Vamos mesclar esses quadros usando o pd.merge aninhado

Aqui vamos nós, temos nosso dataframe mesclado.

Feliz análise !!!