# Πώς να συγχωνεύσετε DataFrames με την εντολή pandas merge()

Με τη συνάρτηση pandas `DataFrame.merge()`, μπορείτε να συνδυάσετε DataFrames χρησιμοποιώντας κλειδιά. Αυτό σας επιτρέπει να συνδυάσετε αποτελεσματικά δεδομένα από διάφορες πηγές, δίνοντάς σας τη δυνατότητα να πραγματοποιήσετε πιο ολοκληρωμένες αναλύσεις.

## Ποια είναι η σύνταξη για το pandas `merge()`;

Η μέθοδος DataFrame `merge()` της Python pandas μπορεί να δεχτεί μια σειρά διαφορετικών παραμέτρων, επιτρέποντας στους προγραμματιστές να καθορίσουν τον τρόπο συνδυασμού των DataFrames. Η γενική σύνταξη της συνάρτησης `merge()` έχει ως εξής:

```python
DataFrame.merge(left, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'), copy=True, indicator=False, validate=None)
```

Note Η συνάρτηση pandas `merge()` είναι παρόμοια με τη λειτουργία JOIN στη γλώσσα SQL. Η εμπειρία με σχεσιακές βάσεις δεδομένων όπως [η SQL](https://www.ionos.com/el-gr/digitalguide/diakomistis/technognosia/ti-einai-to-sql/) μπορεί να διευκολύνει την κατανόηση του τρόπου λειτουργίας της μεθόδου pandas DataFrame `merge()`. Ωστόσο, πρέπει να έχετε υπόψη σας ότι υπάρχουν ορισμένες διαφορές. Στο pandas, εάν και οι δύο στήλες κλειδιών έχουν τιμές που αξιολογούνται ως *null*, αυτές οι τιμές θα συγχωνευθούν επίσης.

### Ποιες παράμετροι μπορούν να χρησιμοποιηθούν με το pandas `merge`;

Οι διάφορες παράμετροι που δέχεται `merge()` σας επιτρέπουν όχι μόνο να καθορίσετε ποια [DataFrames pandas](https://www.ionos.com/el-gr/digitalguide/istoselides/anaptyxi-istoselidon/python-pandas-dataframe/) θα συνδυάσετε, αλλά και τον τύπο σύνδεσης που θα χρησιμοποιήσετε, καθώς και άλλες λεπτομέρειες.

<table>
  <thead>
    <tr>
      <th><strong>Παράμετρος</strong></th>
      <th><strong>Περιγραφή</strong></th>
      <th><strong>Προεπιλεγμένη τιμή</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>αριστερά</td>
      <td>Το πρώτο DataFrame που θα συγχωνευθεί</td>
      <td></td>
    </tr>
    <tr>
      <td>δεξιά</td>
      <td>Το δεύτερο DataFrame που θα συγχωνευθεί</td>
      <td></td>
    </tr>
    <tr>
      <td>πώς</td>
      <td>Ο τύπος της συνένωσης που θα εκτελεστεί (`inner`, `outer`, `left`, `right`)</td>
      <td>`inner`</td>
    </tr>
    <tr>
      <td>σε</td>
      <td>Η στήλη ή οι στήλες ή τα επίπεδα ευρετηρίου που θα χρησιμοποιηθούν ως κλειδιά. Πρέπει να υπάρχουν και στα δύο DataFrames.</td>
      <td></td>
    </tr>
    <tr>
      <td>left\_on</td>
      <td>Η στήλη ή οι στήλες ή τα επίπεδα ευρετηρίου του αριστερού DataFrame που πρέπει να χρησιμοποιηθούν ως κλειδιά</td>
      <td></td>
    </tr>
    <tr>
      <td>right\_on</td>
      <td>Η στήλη ή οι στήλες ή τα επίπεδα ευρετηρίου του δεξιού DataFrame που πρέπει να χρησιμοποιηθούν ως κλειδιά</td>
      <td></td>
    </tr>
    <tr>
      <td>left\_index</td>
      <td>Εάν είναι `True`, ο δείκτης του αριστερού DataFrame χρησιμοποιείται ως κλειδί</td>
      <td>`False`</td>
    </tr>
    <tr>
      <td>right\_index</td>
      <td>Εάν είναι `True`, ο δείκτης του δεξιού DataFrame χρησιμοποιείται ως κλειδί.</td>
      <td>`False`</td>
    </tr>
    <tr>
      <td>sort</td>
      <td>Εάν `True`, τα κλειδιά του DataFrame που προκύπτει ταξινομούνται λεξικογραφικά.</td>
      <td>`False`</td>
    </tr>
    <tr>
      <td>επιθήματα</td>
      <td>Επιθήματα που χρησιμοποιούνται για τη διάκριση στηλών με το ίδιο όνομα.</td>
      <td>`("_x", "_y")`</td>
    </tr>
    <tr>
      <td>αντίγραφο</td>
      <td>Εάν `False`, αποφεύγεται η αντιγραφή</td>
      <td>`True`</td>
    </tr>
  </tbody>
</table>

## Πώς να χρησιμοποιήσετε το pandas `merge()`

Ακολουθούν μερικά παραδείγματα που θα σας βοηθήσουν να κατανοήσετε πώς να χρησιμοποιείτε αποτελεσματικά το pandas `merge()`.

### `INNER JOIN`

Ένα INNER JOIN συνδυάζει δύο DataFrames pandas και **επιστρέφει μόνο τις σειρές όπου τα κλειδιά ταιριάζουν και στα δύο DataFrames**. Για να κατανοήσουμε καλύτερα πώς λειτουργεί αυτό, ας δημιουργήσουμε δύο DataFrames:

```python
import pandas as pd
# Sample DataFrames
df1 = pd.DataFrame({
    'Key': ['A', 'B', 'C'],
    'Value1': [1, 2, 3]
})
df2 = pd.DataFrame({
    'Key': ['B', 'C', 'D'],
    'Value2': [4, 5, 6]
})
print(df1)
print(df2)
```

Τα δύο DataFrames που προκύπτουν έχουν την εξής μορφή:

```none
Key    Value1
0     A            1
1     B            2
2     C            3
    Key    Value2
0     B            4
1     C            5
2     D            6
```

Τώρα, μπορούμε να εκτελέσουμε ένα `INNER JOIN` χρησιμοποιώντας τη συνάρτηση `merge()`:

```python
# INNER JOIN
result = pd.merge(df1, df2, how='inner', on='Key')
print(result)
```

Το αποτέλεσμα δείχνει ότι μόνο οι σειρές που έχουν τα κλειδιά B και C περιλαμβάνονται στο DataFrame. Αυτό συμβαίνει επειδή αυτά τα δύο κλειδιά υπάρχουν **και στα δύο αρχικά DataFrames**.

```none
Key    Value1    Value2
0     B            2            4
1     C            3            5
```

### `OUTER JOIN`

Το `OUTER JOIN` επίσης συγχωνεύει δύο DataFrames, αλλά σε αντίθεση με `INNER JOIN`, επιστρέφει **όλες τις σειρές** και συμπληρώνει **τις ελλείπουσες τιμές με `NaN`**.

```python
# OUTER JOIN
result = pd.merge(df1, df2, how='outer', on='Key')
print(result)
```

Το παρακάτω DataFrame περιλαμβάνει **όλες τις σειρές και από τα δύο DataFrames**. `NaN` χρησιμοποιείται για τις ελλείπουσες τιμές στο κλειδί A, το οποίο υπάρχει μόνο στο `df1`, και στο κλειδί D, το οποίο υπάρχει μόνο στο `df2`.

```none
Key    Value1    Value2
0     A        1.0        NaN
1     B        2.0        4.0
2     C        3.0        5.0
3     D        NaN        6.0
```

Note Οι άλλες τυπικές παραλλαγές του `JOIN` λειτουργούν με παρόμοιο τρόπο.

### Χρήση `left_on` και `right_on`

Μερικές φορές, δύο DataFrames έχουν διαφορετικά ονόματα στηλών για τα κλειδιά τους. Σε αυτή την περίπτωση, μπορείτε να χρησιμοποιήσετε τις παραμέτρους `left_on` και `right_on` για να καθορίσετε ποιες στήλες θα χρησιμοποιηθούν. Αρχικά, ας δημιουργήσουμε δύο νέα DataFrames:

```python
df3 = pd.DataFrame({
    'Key': ['A', 'B', 'C'],
    'Value1': [1, 2, 3]
})
df4 = pd.DataFrame({
    'Key2': ['B', 'C', 'D'],
    'Value2': [4, 5, 6]
})
print(df3)
print(df4)
```

Τα δύο DataFrames έχουν την εξής μορφή:

```none
Key    Value1
0     A            1
1     B            2
2     C            3
    Key2    Value2
0        B            4
1        C            5
2        D            6
```

Μπορούμε να χρησιμοποιήσουμε τις παραμέτρους `left_on` και `right_on` για να εκτελέσουμε τη λειτουργία `JOIN` χρησιμοποιώντας διαφορετικά κλειδιά:

```python
# Join with different key column names
result = pd.merge(df3, df4, how='inner', left_on='Key', right_on='Key2')
print(result)
```

Με τη ρητή χρήση `left_on='Key'` και `right_on='Key2'`, οι αντίστοιχες στήλες κλειδιών χρησιμοποιούνται για τη συγχώνευση.

```none
Key    Value1 Key2    Value2
0     B            2        B            4
1     C            3        C            5
```

### Χρήση δεικτών ως κλειδιών

Μπορείτε επίσης να χρησιμοποιήσετε τους **δείκτες των DataFrames ως κλειδιά**, ορίζοντας τις παραμέτρους `left_index` και `right_index` σε `True`. Αρχικά, ας δημιουργήσουμε δύο νέα DataFrames με δείκτες:

```python
df5 = pd.DataFrame({
    'Value1': [1, 2, 3]
}, index=['A', 'B', 'C'])
df6 = pd.DataFrame({
    'Value2': [4, 5, 6]
}, index=['B', 'C', 'D'])
print(df5)
print(df6)
```

Ακολουθούν τα DataFrames:

```none
Value1
A        1
B        2
C        3
    Value2
B        4
C        5
D        6
```

Τώρα, μπορούμε να εκτελέσουμε μια λειτουργία `JOIN` χρησιμοποιώντας τους δείκτες:

```python
# JOIN with indices
result = pd.merge(df5, df6, how='inner', left_index=True, right_index=True)
print(result)
```

Το αποτέλεσμα είναι ένα `JOIN` που χρησιμοποιεί τους δείκτες από τα DataFrames:

```none
Value1  Value2
B        2        4
C        3        5
```


This is a markdown version of: [https://www.ionos.com/el-gr/digitalguide/istoselides/anaptyxi-istoselidon/python-pandas-sygchoneysi-dataframe/](https://www.ionos.com/el-gr/digitalguide/istoselides/anaptyxi-istoselidon/python-pandas-sygchoneysi-dataframe/) for AI/LLM consumption.