Docs inconsistent with code when it comes to params

The docs say that if you want to include a list in parameters, you have to append `[]` to the key name:

> In order to pass a list of items as a value you must mark the key as referring to a list like string by
> appending [] to the key:
> 
> ```
> >>> payload = {'key1': 'value1', 'key2[]': ['value2', 'value3']}
> >>> r = requests.get("http://httpbin.org/get", params=payload)
> >>> print(r.url)
> http://httpbin.org/get?key1=value1&key2%5B%5D=value2&key2%5B%5D=value3
> ```

but, the code actually seems to support lists transparently, without using the appended brackets. I am so glad it does this, by the way. some REST APIs I make calls to are out of my control, I can't just tell them to include brackets in their keys.

```
 75     def _encode_params(data):
 76         """Encode parameters in a piece of data.
 77
 78         Will successfully encode parameters when passed as a dict or a list of
 79         2-tuples. Order is retained if data is a list of 2-tuples but arbitrary
 80         if parameters are supplied as a dict.
 81         """
 82
 83         if isinstance(data, (str, bytes)):
 84             return data
 85         elif hasattr(data, 'read'):
 86             return data
 87         elif hasattr(data, '__iter__'):
 88             result = []
 89             for k, vs in to_key_val_list(data):
 90                 if isinstance(vs, basestring) or not hasattr(vs, '__iter__'):
 91                     vs = [vs]
 92                 for v in vs:
 93                     if v is not None:
 94                         result.append(
 95                             (k.encode('utf-8') if isinstance(k, str) else k,
 96                              v.encode('utf-8') if isinstance(v, str) else v))
 97             return urlencode(result, doseq=True)
 98         else:
 99             return data
```

To be certain: _Does requests natively support lists, or am I bonkers?_


You need to inspect `to_key_val_list` to get the full description. `to_key_val_list` will take a dictionary like `{'foo': 'bar', 'biz': 'baz'}` and turn it into `[('foo', 'bar'), ('biz', 'baz')]` (although the order may not be preserved. Alternatively, if `data` in this case is already of the latter form, it'll just return it. That's the kind of list that `params` will support. If the documentation of that has disappeared then it should be replaced, but you cannot pass `['foo', 'bar', 'bogus']`. 

A quick test shows that 

``` py
>>> r = requests.get('https://httpbin.org/get', params=[('a', 'b'), ('a', 'c')])
>>> r.request.url
'https://httpbin.org/get?a=b&a=c'
```

Works fine. The above usecase, however, pertains to specific APIs that expect array-like syntax for query parameters.


The docs intimate that you can pass something like `{'a':['b', 'c']}` into params. That is the kind of list I am referring to: one associated with a key in a python dictionary, like so:

```
>>> r = requests.get('https://httpbin.org/get', params={'a': ['b', 'c']})
>>> r.request.url
'https://httpbin.org/get?a=b&a=c'
```

As you can see, it works fine. However, the docs say you have to add a `[]` to get this kind of behavior to the key:

```
>>> r = requests.get('https://httpbin.org/get', params={'a[]': ['b', 'c']})
>>> r.request.url
'https://httpbin.org/get?a%5B%5D=b&a%5B%5D=c'
```

which would be useless, but thankfully the correct behavior is already present. It is just that the docs need to be updated.