pandas
Scalanie, łączenie i łączenie
Szukaj…
Składnia
Ramka danych. merge ( right, how = 'inner', on = None, left_on = None, right_on = None, left_index = False, right_index = False, sort = False, przyrostki = ('_ x', '_y'), copy = True, wskaźnik = Fałsz )
Scal obiekty DataFrame, wykonując operację łączenia w stylu bazy danych za pomocą kolumn lub indeksów.
W przypadku łączenia kolumn w kolumnach indeksy DataFrame zostaną zignorowane. W przeciwnym razie, jeśli łączymy indeksy z indeksami lub indeksy w kolumnie lub kolumnach, indeks zostanie przekazany.
Parametry
| Parametry | Wyjaśnienie |
|---|---|
| dobrze | Ramka danych |
| w jaki sposób | {„lewy”, „prawy”, „zewnętrzny”, „wewnętrzny”}, domyślny „wewnętrzny” |
| left_on | etykieta lub lista lub tablicowe. Nazwy pól do przyłączenia w lewej ramce danych. Może być wektorem lub listą wektorów o długości DataFrame, aby użyć określonego wektora jako klucza łączenia zamiast kolumn |
| tak jest | etykieta lub lista lub tablicowe. Nazwy pól, do których należy dołączyć w prawej ramce danych lub wektorze / liście wektorów w dokumentach left_on |
| left_index | boolean, domyślnie False. Użyj indeksu z lewej DataFrame jako klucza (kluczy) łączenia. Jeśli jest to MultiIndex, liczba kluczy w drugiej ramce danych (indeks lub liczba kolumn) musi być zgodna z liczbą poziomów |
| prawy_indeks | boolean, domyślnie False. Użyj indeksu z prawej DataFrame jako klucza przyłączenia. Te same zastrzeżenia, co left_index |
| sortować | boolean, domyślny Fals. Posortuj klucze łączenia leksykograficznie w wynikowej ramce danych |
| sufiksy | Sekwencja 2 długości (krotka, lista, ...). Sufiks stosowany do nakładających się nazw kolumn odpowiednio po lewej i prawej stronie |
| Kopiuj | wartość logiczna, domyślnie Prawda. Jeśli Fałsz, nie kopiuj niepotrzebnie danych |
| wskaźnik | boolean lub string, domyślnie False. Jeśli ma wartość True, dodaje kolumnę do wyjścia DataFrame o nazwie „_merge” z informacją o źródle każdego wiersza. Jeśli ciąg, kolumna z informacją o źródle każdego wiersza zostanie dodana do wyjściowej ramki DataFrame, a kolumna otrzyma nazwę wartości ciągu. Kolumna informacyjna ma charakter kategoryczny i przyjmuje wartość „left_only” w przypadku obserwacji, których klucz scalający pojawia się tylko w „lewej” ramce danych, „right_only” w przypadku obserwacji, której klucz scalający występuje tylko w „prawej” ramce danych, i „obie”, jeśli klucz scalający obserwacji znajduje się w obu. |
Łączyć
Na przykład podane są dwie tabele,
T1
id x y
8 42 1.9
9 30 1.9
T2
id signal
8 55
8 56
8 59
9 57
9 58
9 60
Celem jest zdobycie nowej tabeli T3:
id x y s1 s2 s3
8 42 1.9 55 56 58
9 30 1.9 57 58 60
Który ma tworzyć kolumny s1 , s2 i s3 , każda odpowiadająca wierszowi (liczba wierszy na id jest zawsze stała i równa 3)
Przez zastosowanie join (który przyjmuje opcjonalny argument argumentu, który może być nazwą kolumny lub wielu kolumn, co określa, że przekazana DataFrame ma być wyrównana do tej kolumny w DataFrame). Tak więc rozwiązanie może wyglądać tak, jak pokazano poniżej:
df = df1.merge (df2.groupby ('id') ['signal']. Apply (lambda x: x.reset_index (drop = True)). unstack (). reset_index ())
df
Out[63]:
id x y 0 1 2
0 8 42 1.9 55 56 59
1 9 30 1.9 57 58 60
Jeśli je rozdzielę:
df2t = df2.groupby('id')['signal'].apply(lambda x: x.reset_index(drop=True)).unstack().reset_index()
df2t
Out[59]:
id 0 1 2
0 8 55 56 59
1 9 57 58 60
df = df1.merge(df2t)
df
Out[61]:
id x y 0 1 2
0 8 42 1.9 55 56 59
1 9 30 1.9 57 58 60
Scalenie dwóch ramek danych
In [1]: df1 = pd.DataFrame({'x': [1, 2, 3], 'y': ['a', 'b', 'c']})
In [2]: df2 = pd.DataFrame({'y': ['b', 'c', 'd'], 'z': [4, 5, 6]})
In [3]: df1
Out[3]:
x y
0 1 a
1 2 b
2 3 c
In [4]: df2
Out[4]:
y z
0 b 4
1 c 5
2 d 6
Przyłączenie wewnętrzne:
Używa przecięcia kluczy z dwóch ramek danych.
In [5]: df1.merge(df2) # by default, it does an inner join on the common column(s)
Out[5]:
x y z
0 2 b 4
1 3 c 5
Alternatywnie określ przecięcie kluczy z dwóch ramek danych.
In [5]: merged_inner = pd.merge(left=df1, right=df2, left_on='y', right_on='y')
Out[5]:
x y z
0 2 b 4
1 3 c 5
Przyłączenie zewnętrzne:
Wykorzystuje połączenie kluczy z dwóch DataFrames.
In [6]: df1.merge(df2, how='outer')
Out[6]:
x y z
0 1.0 a NaN
1 2.0 b 4.0
2 3.0 c 5.0
3 NaN d 6.0
Lewe dołączenie:
Używa tylko kluczy z lewej DataFrame.
In [7]: df1.merge(df2, how='left')
Out[7]:
x y z
0 1 a NaN
1 2 b 4.0
2 3 c 5.0
Right Join
Używa tylko kluczy z właściwej DataFrame.
In [8]: df1.merge(df2, how='right')
Out[8]:
x y z
0 2.0 b 4
1 3.0 c 5
2 NaN d 6
Scalanie / łączenie / łączenie wielu ramek danych (poziomo i pionowo)
generuj przykładowe ramki danych:
In [57]: df3 = pd.DataFrame({'col1':[211,212,213], 'col2': [221,222,223]})
In [58]: df1 = pd.DataFrame({'col1':[11,12,13], 'col2': [21,22,23]})
In [59]: df2 = pd.DataFrame({'col1':[111,112,113], 'col2': [121,122,123]})
In [60]: df3 = pd.DataFrame({'col1':[211,212,213], 'col2': [221,222,223]})
In [61]: df1
Out[61]:
col1 col2
0 11 21
1 12 22
2 13 23
In [62]: df2
Out[62]:
col1 col2
0 111 121
1 112 122
2 113 123
In [63]: df3
Out[63]:
col1 col2
0 211 221
1 212 222
2 213 223
scal / połącz / konkatenuj ramki danych [df1, df2, df3] pionowo - dodaj wiersze
In [64]: pd.concat([df1,df2,df3], ignore_index=True)
Out[64]:
col1 col2
0 11 21
1 12 22
2 13 23
3 111 121
4 112 122
5 113 123
6 211 221
7 212 222
8 213 223
scal / połącz / konkatenuj ramki danych poziomo (wyrównanie według indeksu):
In [65]: pd.concat([df1,df2,df3], axis=1)
Out[65]:
col1 col2 col1 col2 col1 col2
0 11 21 111 121 211 221
1 12 22 112 122 212 222
2 13 23 113 123 213 223
Scal, dołącz i konkatuj
Scalanie nazw kluczy jest takie samo
pd.merge(df1, df2, on='key')
Scalanie nazw kluczy jest różne
pd.merge(df1, df2, left_on='l_key', right_on='r_key')
Różne rodzaje łączenia
pd.merge(df1, df2, on='key', how='left')
Scalanie na wielu klawiszach
pd.merge(df1, df2, on=['key1', 'key2'])
Leczenie nakładających się kolumn
pd.merge(df1, df2, on='key', suffixes=('_left', '_right'))
Używanie indeksu wierszy zamiast scalania kluczy
pd.merge(df1, df2, right_index=True, left_index=True)
Unikaj stosowania składni .join ponieważ daje to wyjątek dla nakładających się kolumn
Scalanie lewego indeksu ramki danych i prawej kolumny ramki danych
pd.merge(df1, df2, right_index=True, left_on='l_key')
Concate dataframes
Klejone pionowo
pd.concat([df1, df2, df3], axis=0)
Klejone poziomo
pd.concat([df1, df2, df3], axis=1)
Jaka jest różnica między łączeniem a łączeniem
Rozważ ramki danych w left i w right
left = pd.DataFrame([['a', 1], ['b', 2]], list('XY'), list('AB'))
left
A B
X a 1
Y b 2
right = pd.DataFrame([['a', 3], ['b', 4]], list('XY'), list('AC'))
right
A C
X a 3
Y b 4
join
Pomyśl o join jako o połączeniu z ramkami danych na podstawie ich odpowiednich indeksów. Jeśli występują nakładające się kolumny, join będzie wymagać dodania sufiksu do nakładającej się nazwy kolumny z lewej ramki danych. Nasze dwie ramki danych mają nakładającą się nazwę kolumny A
left.join(right, lsuffix='_')
A_ B A C
X a 1 a 3
Y b 2 b 4
Zauważ, że indeks został zachowany i mamy 4 kolumny. 2 kolumny od left i 2 od right .
Jeśli indeksy nie zostały wyrównane
left.join(right.reset_index(), lsuffix='_', how='outer')
A_ B index A C
0 NaN NaN X a 3.0
1 NaN NaN Y b 4.0
X a 1.0 NaN NaN NaN
Y b 2.0 NaN NaN NaN
Użyłem złączenia zewnętrznego, aby lepiej zilustrować tę kwestię. Jeśli indeksy nie zostaną wyrównane, wynikiem będzie suma indeksów.
Możemy powiedzieć join aby użyło określonej kolumny w lewej ramce danych jako klucza łączenia, ale nadal będzie korzystał z indeksu z prawej strony.
left.reset_index().join(right, on='index', lsuffix='_')
index A_ B A C
0 X a 1 a 3
1 Y b 2 b 4
merge
Pomyśl o merge jako o wyrównaniu do kolumn. Domyślnie merge będzie szukać nakładających się kolumn, w których zostaną scalone. merge daje lepszą kontrolę nad kluczami scalania, pozwalając użytkownikowi określić podzbiór nakładających się kolumn do użycia z on parametrem lub osobno pozwolić na określenie, które kolumny po lewej i które kolumny po prawej mają zostać scalone.
merge zwróci połączoną ramkę danych, w której indeks zostanie zniszczony.
W tym prostym przykładzie nakładająca się kolumna ma wartość 'A' i łączy się na jej podstawie.
left.merge(right)
A B C
0 a 1 3
1 b 2 4
Zwróć uwagę, że indeks wynosi [0, 1] i nie jest już ['X', 'Y']
Możesz jawnie określić, że left_index indeks z parametrem left_index lub right_index
left.merge(right, left_index=True, right_index=True, suffixes=['_', ''])
A_ B A C
X a 1 a 3
Y b 2 b 4
I to wygląda dokładnie tak jak powyższy przykład join .
