Allow overriding/disabling an entire default kwarg (as well as individual keys)

It would be good if it was possible to completely disable/override a default kwarg, in addition to the current ability to disable individual keys by setting them to `None`.

Maybe this could be done by passing the function an empty object for the kwarg as supposed to `None`.


`kwarg = False` makes sense to me.


Another possibility, for which I can't really think of an elegant solution, would be the ability to replace a default kwarg with another set of key/values, as supposed to explicitly specifying that each key that is present in the default should be disabled.

So basically the ability above, plus specifying a new set of key/vals for the request.


@johtso 
As I don't get the above description, could you please write a short example showing what you have in mind ?


@piotr-dobrogost
So, currently "Any dictionaries that you pass to a request method will be merged with the session-level values that are set". If you wanted to send a request with none of the default params defined for the session, you would have to do something like this:

Setup:

``` python
default_params = dict(a=1, b=2, c=3, d=4)
s = requests.session(params=default_params)
```

The request:

``` python
r = s.get(url, params=dict(a=None, b=None, c=None, d=None))
```

A possible solution would be to allow something like this:

``` python
r = s.get(url, params=False)
```

I was then contemplating the possibility of someone wanting to send a request with none of the default values for a parameter, and also with some new values, which would currently be achieved like so:

``` python
r = s.get(url, params=dict(a=None, b=None, c=None, d=None, foo='bar'))
```

This might not be a use case worth worrying about, it certainly makes things trickier as the nice concise `=False` solution wouldn't do the job. Just throwing it out there.


Thanks for writing examples. I think it would be nice to support different kinds of merging request specific `params` dict with the session's `params` dict. Suppressing session values with `false` is tempting but feels like too big a shortcut. Clear and extensible solution would be to introduce additional argument to `reqest()` specifying how merging should be done. Something like `params_combine_mode='update'|'overwrite'|'supplement'` with the default being `update` I guess.


Hmm, I do like the extensibility of that solution, but it would mean having a "combine_mode" option for each of [the parameters that get merged](https://github.com/kennethreitz/requests/blob/develop/requests/sessions.py#L53).. that seems really verbose.

Maybe there could be a single parameter `merge_modes` that takes a list of `attrs` and `mode` pairs.

Or, how about making `Request()` take either just a dict that gets merged, or a tuple of `(dict, merge_mode)`. That could be pretty nice and concise.


> Maybe there could be a single parameter `merge_modes` that takes a list of `attrs` and `mode` pairs.

When order doesn't matter I always prefer dict to list. With this reservation the idea is ok.

The second idea with tuples of `(dict, merge_mode)` is even better.


Oops, right, of course a dict would be the way to go :)

I'm trying to think of what an example might look like if you just wanted to, say, not send any parameters when default params have been defined for the session. I suppose something like:

``` python
session.get(url, params=({}, 'overwrite'))
```

I suppose that's not too bad..


@kennethreitz 

How do you like this?


@kennethreitz 

Why did you close this?