Remove redundant __init__ for BaseAdapter

`BaseAdapter.__init__()` overrides the default `__init__` method in an unnecessary way. Pylint classifies this code with `useless-super-delegation`.

> `useless-super-delegation` [is] used whenever we can detect that an
> overridden method is useless, relying on `super()` delegation to do the
> same thing as another method from the MRO.
> 
> 
>     class Impl(Base):
>         def __init__(self, param1, param2):
>             super(Impl, self).__init__(param1, param2)
>
> <sup>[What's New In Pylint 1.7](http://pylint.pycqa.org/en/latest/whatsnew/1.7.html)</sup>

Personal testing shows this change improves performance when initializing `BaseAdapter`.

# [Codecov](https://codecov.io/gh/requests/requests/pull/4697?src=pr&el=h1) Report
> Merging [#4697](https://codecov.io/gh/requests/requests/pull/4697?src=pr&el=desc) into [master](https://codecov.io/gh/requests/requests/commit/883caaf145fbe93bd0d208a6b864de9146087312?src=pr&el=desc) will **increase** coverage by `0.02%`.
> The diff coverage is `n/a`.

[![Impacted file tree graph](https://codecov.io/gh/requests/requests/pull/4697/graphs/tree.svg?width=650&height=150&src=pr&token=mZGswIiXLa)](https://codecov.io/gh/requests/requests/pull/4697?src=pr&el=tree)

```diff
@@            Coverage Diff             @@
##           master    #4697      +/-   ##
==========================================
+ Coverage   66.79%   66.81%   +0.02%     
==========================================
  Files          15       15              
  Lines        1563     1561       -2     
==========================================
- Hits         1044     1043       -1     
+ Misses        519      518       -1
```


| [Impacted Files](https://codecov.io/gh/requests/requests/pull/4697?src=pr&el=tree) | Coverage Δ | |
|---|---|---|
| [requests/adapters.py](https://codecov.io/gh/requests/requests/pull/4697/diff?src=pr&el=tree#diff-cmVxdWVzdHMvYWRhcHRlcnMucHk=) | `70.37% <ø> (+0.18%)` | :arrow_up: |

------

[Continue to review full report at Codecov](https://codecov.io/gh/requests/requests/pull/4697?src=pr&el=continue).
> **Legend** - [Click here to learn more](https://docs.codecov.io/docs/codecov-delta)
> `Δ = absolute <relative> (impact)`, `ø = not affected`, `? = missing data`
> Powered by [Codecov](https://codecov.io/gh/requests/requests/pull/4697?src=pr&el=footer). Last update [883caaf...663796a](https://codecov.io/gh/requests/requests/pull/4697?src=pr&el=lastupdated). Read the [comment docs](https://docs.codecov.io/docs/pull-request-comments).


@Steviosiak, I don’t know if I understand why you feel this is redundant. This is the base class that can be used for creating custom adapters.

We usually avoid making changes in the code unless they solve a specific problem and make the user experience better.

I don’t think we’re likely to accept this at this time.

@nateprewitt I was under the impression that `BaseAdapter` was initializing an instance of itself, which is something objects do by default.

I'm not sure what purpose `__init__` is serving in this case.

@nateprewitt 


To illustrate, each of the following examples would be functionally identical.


```Python
class BaseAdapter(object):
    def __init__(self):
        super(BaseAdapter, self).__init__()
```
```Python
class BaseAdapter(object):
    def __init__(self):
        object.__init__(self)
```
```Python
class BaseAdapter(object):
    def __init__(self):
        pass
```

Pylint warns about the first example with [`useless-super-delegation`](https://github.com/PyCQA/pylint/issues/1567)

It seems my [previous subclass assumptions](https://github.com/requests/requests/pull/4697#issuecomment-398533573) were incorrect.

The examples I provided will behave differently if a subclass inherits from more than one parent class.

```Python
class BaseAdapter(object):
    def __init__(self):
        super(BaseAdapter, self).__init__()

class BaseAdapter2(object):
    def __init__(self):
        object.__init__(self)

class BaseAdapter3(object):
    def __init__(self):
        pass

class Second:
    def __init__(self):
        print("second")
        super().__init__()

class Other1(BaseAdapter, Second):
    def __init__(self):
        print("other1 init")
        super().__init__()

class Other2(BaseAdapter2, Second):
    def __init__(self):
        print("other2 init")
        super().__init__()

class Other3(BaseAdapter3, Second):
    def __init__(self):
        print("other3 init")
        super().__init__()

Other1()
Other2()
Other3()
```

Output:

```
other1 init
second
other2 init
other3 init
```

However, removing `__init__` does seem to have the same output.

```Python
class BaseAdapter(object):
    def __init__(self):
        super(BaseAdapter, self).__init__()

class BaseAdapter4(object):
    pass

class Second:
    def __init__(self):
        print("second")
        super().__init__()

class Other1(BaseAdapter, Second):
    def __init__(self):
        print("other1 init")
        super().__init__()

class Other4(BaseAdapter4, Second):
    def __init__(self):
        print("other4 init")
        super().__init__()

Other1()
Other4()
```

Output:

```
other1 init
second
other4 init
second
```

Related: 

- [Stack Overflow: How does Python's super() work with multiple inheritance?](https://stackoverflow.com/q/3277367/3357935)
- [Stack Overflow: Calling parent class \_\_init__ with multiple inheritance, what's the right way?](https://stackoverflow.com/a/9575426/3357935)
- [Scott Lobdell: Multiple Inheritance in Python](http://scottlobdell.me/2015/06/multiple-inheritance-python/)

Personal testing indicates this change would improve performance when initializing BaseAdapter. (0.57 seconds vs 0.11 seconds)

```Python
import timeit

setup = """
class BaseAdapter(object):
    def __init__(self):
        super(BaseAdapter, self).__init__()
"""
print(timeit.timeit('BaseAdapter()', setup=setup))

setup = """
class BaseAdapter(object):
    pass
"""
print(timeit.timeit('BaseAdapter()', setup=setup))
```

Output

```
0.5758354471040419
0.10679823940642941
```


@Stevoisiak I believe the benchmark you’re providing is showing the total run time of 1,000,000 runs. That means we’re measuring an initialization variation of .4 microseconds which is an incredibly small amount of time for what is likely a one time operation in someone’s code.

As was stated earlier in the PR, we usually don’t remove code unless there’s a compelling reason to do so. I’m not convinced we need this init but it’s nearly impossible to know how people are using this BaseAdapter and I’d rather not risk breaking things.

@nateprewitt Ah, the timings did seem a bit large. Thank you for taking the time to explain.