Uzupełniający obraz pd.concat([df0, df1], kwargs). Zauważ, że znaczenie kwarg axis=0 lub axis=1 nie jest tak intuicyjne jak df.mean() lub df.apply(func)

W tej odpowiedzi rozważę praktyczne przykłady.

Pierwszy, jest z pandas.concat.

Drugi, scalający ramki danych z indeksu jednego i kolumny drugiego.

1. pandas.concat

Biorąc pod uwagę następujące {[4] } o tych samych nazwach kolumn:

Preco2018 with size (8784, 5)

Preco 2019 z rozmiarem (8760, 5)

Które mają te same nazwy kolumn.

Można je łączyć za pomocą pandas.concat, by simply

import pandas as pd

frames = [Preco2018, Preco2019]

df_merged = pd.concat(frames)

Co daje ramkę danych o następującym rozmiarze (17544, 5)

Jeśli chcesz wizualizować, kończy się to tak

(źródło)

2. Merge by Column and Index

W tej części rozważę przypadek szczególny: jeżeli chcemy połączyć indeks jednej ramki z kolumną innej ramki.

Powiedzmy, że jeden ma ramkę danych Geo z 54 kolumnami, będącą jedną z kolumn daty Data, która jest typu datetime64[ns].

I ramka danych Price, która ma jedną kolumnę z ceną i indeksem odpowiada datom

W tym konkretnym przypadku, aby je połączyć, używa się pd.merge

merged = pd.merge(Price, Geo, left_index=True, right_on='Data')

Co daje następujący dataframe

[[40]}ten post będzie poruszał następujące tematy: [41]}

• łączenie z indeksem w różnych warunkach
  • opcje połączeń opartych na indeksach: merge, join, concat
  • scalanie na indeksach
  • scalanie na indeksie jednej kolumny drugiej
• efektywne wykorzystanie nazwanych indeksów do uproszczenia składni scalania

_{POWRÓT DO GÓRY}

Oparte na indeksie dołącza

TL;DR

Istnieje kilka opcji, niektóre prostsze niż inne w zależności od zastosowania case.

1. DataFrame.merge Z left_index i right_index (lub left_on i right_on za pomocą indeksów nazw)
   • obsługuje wewnętrzne / lewe / prawe / pełne
   Może dołączyć tylko do dwóch na raz.]}
   • obsługuje połączenia column-column, index-column, index-index
2. DataFrame.join (dołącz do indeksu)
   • podpory wewnętrzne / lewe (domyślnie) / right / full
   Może łączyć się z wieloma ramami danych naraz.]}
   • obsługuje połączenia indeks-indeks
3. pd.concat (dołącza do indeksu)
   • obsługuje wewnętrzny / pełny (domyślnie)
   Może łączyć się z wieloma ramami danych naraz.]}
   • obsługuje połączenia indeks-indeks

Indeks do indeksu

Konfiguracja I Podstawy

import pandas as pd
import numpy as np

np.random.seed([3, 14])
left = pd.DataFrame(data={'value': np.random.randn(4)}, 
                    index=['A', 'B', 'C', 'D'])    
right = pd.DataFrame(data={'value': np.random.randn(4)},  
                     index=['B', 'D', 'E', 'F'])
left.index.name = right.index.name = 'idxkey'

left
           value
idxkey          
A      -0.602923
B      -0.402655
C       0.302329
D      -0.524349

right
 
           value
idxkey          
B       0.543843
D       0.013135
E      -0.326498
F       1.385076

Zazwyczaj, wewnętrzne połączenie na indeksie będzie wygląda tak:

left.merge(right, left_index=True, right_index=True)

         value_x   value_y
idxkey                    
B      -0.402655  0.543843
D      -0.524349  0.013135

Inne połączenia mają podobną składnię.

Godne Uwagi Alternatywy

1. DataFrame.join domyślnie dołącza do indeksu. DataFrame.join domyślnie wykonuje lewe złączenie zewnętrzne, więc how='inner' jest tutaj konieczne.

    left.join(right, how='inner', lsuffix='_x', rsuffix='_y')
   
             value_x   value_y
    idxkey                    
    B      -0.402655  0.543843
    D      -0.524349  0.013135
   

   Zauważ, że musiałem podać argumenty lsuffix i rsuffix, ponieważ join w przeciwnym razie popełniłbym błąd:

    left.join(right)
    ValueError: columns overlap but no suffix specified: Index(['value'], dtype='object')
   

   Ponieważ nazwy kolumn są takie same. Nie byłoby to problemem, gdyby byli inaczej nazwane.

    left.rename(columns={'value':'leftvalue'}).join(right, how='inner')
   
            leftvalue     value
    idxkey                     
    B       -0.402655  0.543843
    D       -0.524349  0.013135
   

2. pd.concat dołącza do indeksu i może dołączyć dwa lub więcej ramek danych jednocześnie. Domyślnie wykonuje pełne połączenie zewnętrzne, więc how='inner' jest tutaj wymagane..

    pd.concat([left, right], axis=1, sort=False, join='inner')
   
               value     value
    idxkey                    
    B      -0.402655  0.543843
    D      -0.524349  0.013135
   

   Aby uzyskać więcej informacji na temat concat, Zobacz ten post .

Indeks do kolumn

Aby wykonać połączenie wewnętrzne za pomocą indeksu lewej, kolumny prawej, użyjesz DataFrame.merge kombinacji left_index=True i right_on=....

right2 = right.reset_index().rename({'idxkey' : 'colkey'}, axis=1)
right2
 
  colkey     value
0      B  0.543843
1      D  0.013135
2      E -0.326498
3      F  1.385076

left.merge(right2, left_index=True, right_on='colkey')

    value_x colkey   value_y
0 -0.402655      B  0.543843
1 -0.524349      D  0.013135

Inne połączenia mają podobną strukturę. Zauważ, że tylko merge może wykonywać indeks do łączenia kolumn. Możesz dołączyć do wielu kolumn, pod warunkiem, że liczba poziomów indeksów po lewej jest równa liczbie kolumn po prawej.

join i concat nie są zdolne do mieszania. Będziesz musiał ustawić indeks jako wstępny krok za pomocą DataFrame.set_index.

Efektywnie używając nazwanego indeksu [pandy >= 0.23]

Jeśli indeks jest nazwany, to z pandy > = 0.23, DataFrame.merge pozwala określić nazwę indeksu na on (lub left_on i right_on w razie potrzeby).

left.merge(right, on='idxkey')

         value_x   value_y
idxkey                    
B      -0.402655  0.543843
D      -0.524349  0.013135

W poprzednim przykładzie scalania z indeksem lewej, prawej kolumny, możesz użyć {[15] } z nazwą indeksu lewej:

left.merge(right2, left_on='idxkey', right_on='colkey')

    value_x colkey   value_y
0 -0.402655      B  0.543843
1 -0.524349      D  0.013135

Czytaj Dalej

Przejdź do innych tematów w Pandy 101 aby kontynuować naukę:

• Podstawy łączenia-podstawowe typy złączy

• Oparte na wskaźnikach dołącza^*

• Uogólnienie na wiele ramek danych

• Cross join

_{* jesteś tutaj}

Ten post będzie poruszał następujące tematy:

• Jak poprawnie uogólnić na wiele ramek danych (i dlaczego merge ma tutaj braki)
• scalanie na unikalnych kluczach
• scalanie na nie-unqiue keys

_{POWRÓT DO GÓRY}

Uogólnienie na wiele ramek danych

Często pojawia się sytuacja, gdy wiele ramek danych ma być połączonych ze sobą. Naiwnie, można to zrobić poprzez wywołania łańcucha merge:

df1.merge(df2, ...).merge(df3, ...)

Jednak to szybko wymyka się spod kontroli dla wielu ramek danych. Ponadto konieczne może być uogólnienie dla nieznanej liczby ramek danych.

Tutaj przedstawiam pd.concat dla połączeń wielokierunkowych na klawiszach unique oraz DataFrame.join dla połączeń wielokierunkowych na klawiszach non-unique {46]}. Najpierw konfiguracja.

# Setup.
np.random.seed(0)
A = pd.DataFrame({'key': ['A', 'B', 'C', 'D'], 'valueA': np.random.randn(4)})    
B = pd.DataFrame({'key': ['B', 'D', 'E', 'F'], 'valueB': np.random.randn(4)})
C = pd.DataFrame({'key': ['D', 'E', 'J', 'C'], 'valueC': np.ones(4)})
dfs = [A, B, C] 

# Note, the "key" column values are unique, so the index is unique.
A2 = A.set_index('key')
B2 = B.set_index('key')
C2 = C.set_index('key')

dfs2 = [A2, B2, C2]

Multiway merge on unique keys

Jeśli Twoje klucze (tutaj kluczem może być kolumna lub Indeks) to unique, wtedy możesz użyć pd.concat. Zauważ, że pd.concat dołącza ramki danych do indeksu .

# merge on `key` column, you'll need to set the index before concatenating
pd.concat([
    df.set_index('key') for df in dfs], axis=1, join='inner'
).reset_index()

  key    valueA    valueB  valueC
0   D  2.240893 -0.977278     1.0

# merge on `key` index
pd.concat(dfs2, axis=1, sort=False, join='inner')

       valueA    valueB  valueC
key                            
D    2.240893 -0.977278     1.0

Pomiń join='inner' dla pełnego połączenia zewnętrznego. Zauważ, że nie możesz określić lewego lub prawego złączenia Zewnętrznego (jeśli potrzebujesz, użyj join, opisanego poniżej).

Multiway merge na kluczach z duplikatami

concat jest szybki, ale ma swoje wady. Nie radzi sobie z duplikatami.

A3 = pd.DataFrame({'key': ['A', 'B', 'C', 'D', 'D'], 'valueA': np.random.randn(5)})

pd.concat([df.set_index('key') for df in [A3, B, C]], axis=1, join='inner')
ValueError: Shape of passed values is (3, 4), indices imply (3, 2)

W tej sytuacji możemy użyć join, ponieważ może obsłużyć nie unikalne keys (zauważ, że join dołącza ramki danych do ich indeksu; wywołuje merge pod maską i wykonuje lewe zewnętrzne połączenie, chyba że określono inaczej).

# join on `key` column, set as the index first
# For inner join. For left join, omit the "how" argument.
A.set_index('key').join(
    [df.set_index('key') for df in (B, C)], how='inner').reset_index()

  key    valueA    valueB  valueC
0   D  2.240893 -0.977278     1.0

# join on `key` index
A3.set_index('key').join([B2, C2], how='inner')

       valueA    valueB  valueC
key                            
D    1.454274 -0.977278     1.0
D    0.761038 -0.977278     1.0

Czytaj Dalej

Przejdź do innych tematów w Pandy 101 aby kontynuować naukę:

• Podstawy łączenia-podstawowe rodzaje łączenia

• Połączenia oparte na indeksach

• Generalizowanie do wielu RAM danych ^*

• Cross join

_{* jesteś tutaj}