PERF/QST:  Pandas merge is an order of magnitude slower than map for joining a Series to a DataFrame on a column
Summary of situation:

We have some large ```DataFrame``` and a ```Series``` with some additional data corresponding to particular groups in the ```DataFrame``` (for example, from some supplementary data source, the result of a ```groupby``` or just from some other computation regarding the groups). To make a toy example, here we have 5000 different groups and 1e6 rows:

```
df = pd.DataFrame({"group": [i for i in range(5000)]*200, "value": np.random.random(int(1e6))})
grp_data = pd.DataFrame({"group":[i for i in range(5000)], "grp_value":np.random.random(5000)})
```
```
df
        group     value
0           0  0.760855
1           1  0.811482
2           2  0.115438
3           3  0.766736
4           4  0.651614
...       ...       ...
999995   4995  0.679567
999996   4996  0.016641
999997   4997  0.159281
999998   4998  0.762351
999999   4999  0.352805

[1000000 rows x 2 columns]
```
```
grp_data
      group  grp_value
0         0   0.628370
1         1   0.457861
2         2   0.954026
3         3   0.509669
4         4   0.297275
...     ...        ...
4995   4995   0.415900
4996   4996   0.511556
4997   4997   0.698350
4998   4998   0.905850
4999   4999   0.197737

[5000 rows x 2 columns]
```

Here are two methods for joining on the extra group data, one using ```merge``` and the other using ```map```.

```
tic = time.perf_counter()
merge_df = df.merge(grp_data, on="group", how="left")
print(str((time.perf_counter() - tic)*1000) + " milliseconds")
```
```
96.42482600065705 milliseconds
```

```
tic = time.perf_counter()
map_df = df.copy()
map_df["grp_value"] = map_df.group.map(grp_data.set_index("group").grp_value)
print(str((time.perf_counter() - tic)*1000) + " milliseconds")
```
```
16.401605999988078 milliseconds
```

Each produce the same DataFrame as desired with the ```grp_value```'s paired with their corresponding ```group``` for each row:

```
        group     value  grp_value
0           0  0.760855   0.628370
1           1  0.811482   0.457861
2           2  0.115438   0.954026
3           3  0.766736   0.509669
4           4  0.651614   0.297275
...       ...       ...        ...
999995   4995  0.679567   0.415900
999996   4996  0.016641   0.511556
999997   4997  0.159281   0.698350
999998   4998  0.762351   0.905850
999999   4999  0.352805   0.197737

[1000000 rows x 3 columns]
```
But map is an order of magnitude faster for the same operation.


With the actual DataFrame that I found this difference (which has more columns and is longer), the performance difference was even worse at 15x slower. From what I've read online, I only ever see merge suggested for this kind of thing and I find myself doing this kind of operation a lot. My question is twofold:

1) What is the natural way to combine data in the way described above using pandas?

2) Why is merge so much slower than map in this case?


#### Output of ``pd.show_versions()``

<details>

INSTALLED VERSIONS
------------------
commit           : db08276bc116c438d3fdee492026f8223584c477
python           : 3.7.6.final.0
python-bits      : 64
OS               : Linux
OS-release       : 5.4.49+
Version          : #1 SMP Mon Nov 30 19:42:49 PST 2020
machine          : x86_64
processor        : x86_64
byteorder        : little
LC_ALL           : C.UTF-8
LANG             : C.UTF-8
LOCALE           : en_US.UTF-8

pandas           : 1.1.3
numpy            : 1.18.5
pytz             : 2019.3
dateutil         : 2.8.1
pip              : 20.2.4
setuptools       : 46.1.3.post20200325
Cython           : 0.29.21
pytest           : 5.4.1
hypothesis       : 5.10.0
sphinx           : 3.0.2
blosc            : None
feather          : 0.4.1
xlsxwriter       : 1.2.8
lxml.etree       : 4.5.0
html5lib         : 1.0.1
pymysql          : None
psycopg2         : None
jinja2           : 2.11.2
IPython          : 7.13.0
pandas_datareader: 0.9.0
bs4              : 4.9.0
bottleneck       : 1.3.2
fsspec           : 0.8.4
fastparquet      : None
gcsfs            : 0.6.1
matplotlib       : 3.2.1
numexpr          : 2.7.1
odfpy            : None
openpyxl         : 3.0.3
pandas_gbq       : None
pyarrow          : 0.16.0
pytables         : None
pyxlsb           : None
s3fs             : 0.5.1
scipy            : 1.4.1
sqlalchemy       : 1.3.16
tables           : 3.6.1
tabulate         : 0.8.7
xarray           : 0.16.1
xlrd             : 1.2.0
xlwt             : 1.3.0
numba            : 0.48.0

</details>
