Ho 3 file CSV. Ognuno ha la prima colonna come nome (stringa) di persone, mentre tutte le altre colonne in ciascun frame di dati sono attributi di quella persona.

Come posso "unire" tutti e tre i documenti CSV per creare un singolo CSV con ogni riga con tutti gli attributi per ciascun valore univoco del nome della stringa della persona?

La join()funzione in Panda specifica che ho bisogno di un multiindice, ma sono confuso su ciò che uno schema di indicizzazione gerarchico ha a che fare con un join basato su un singolo indice.

Importazioni presunte:

import pandas as pd

La risposta di John Galt è sostanzialmente reduceun'operazione. Se avessi più di una manciata di frame di dati, li metterei in un elenco come questo (generato tramite comprensione dell'elenco o loop o quant'altro):

dfs = [df0, df1, df2, dfN]

Supponendo che abbiano una colonna comune, come namenel tuo esempio, farei quanto segue:

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

In questo modo, il codice dovrebbe funzionare con qualsiasi numero di frame di dati che desideri unire.

Modifica 1 agosto 2016 : per coloro che usano Python 3: reduceè stato spostato in functools. Quindi per usare questa funzione, devi prima importare quel modulo:

from functools import reduce

Puoi provare questo se hai 3 frame di dati

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

in alternativa, come indicato da Cwharland

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

Questa è una situazione ideale per il joinmetodo

Il joinmetodo è costruito esattamente per questo tipo di situazioni. Puoi unire qualsiasi numero di DataFrames insieme ad esso. Il DataFrame chiamante si unisce all'indice della raccolta di DataFrame passati. Per lavorare con più DataFrame, è necessario inserire le colonne di unione nell'indice.

Il codice sarebbe simile al seguente:

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

Con i dati di @ zero, puoi fare questo:

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

Questo può essere fatto anche come segue per un elenco di frame di dati df_list:

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

o se i frame di dati si trovano in un oggetto generatore (ad es. per ridurre il consumo di memoria):

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

In python3.6.3 con pandas0.22.0 puoi anche usare concatfintanto che imposti come indice le colonne che vuoi usare per l'unione

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

dove df1, df2e df3sono definiti come nella risposta di 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']
)

Non è necessario un multiindex per eseguire le operazioni di join . È sufficiente impostare correttamente la colonna dell'indice su cui eseguire le operazioni di join (quale comando df.set_index('Name')ad esempio)

L' joinoperazione viene eseguita per impostazione predefinita sull'indice. Nel tuo caso, devi solo specificare che la Namecolonna corrisponde al tuo indice. Di seguito è riportato un esempio

Un tutorial può essere utile.

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

Ecco un metodo per unire un dizionario di frame di dati mantenendo sincronizzati i nomi delle colonne con il dizionario. Inoltre, riempie i valori mancanti, se necessario:

Questa è la funzione per unire una serie di frame di dati

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, consente di generare dati e testarlo:

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)

Soluzione semplice:

Se i nomi delle colonne sono simili:

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

Se i nomi delle colonne sono diversi:

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

C'è un'altra soluzione dalla documentazione di Panda (che non vedo qui),

usando il .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

La ignore_index=Trueviene utilizzato per ignorare l'indice del dataframe allegata, sostituendolo con l'indice successivo disponibile in quella sorgente.

Se ci sono nomi di colonne diversi, Nanverrà introdotto.

I tre frame di dati sono

Uniamo questi frame usando pd.merge nidificato

Eccoci, abbiamo il nostro dataframe unito.

Buona analisi !!!