ENH: Allow for `loc` to specify numeric and/or name slicing
#### Is your feature request related to a problem?

Yes. The problem is that many use cases require specifying a numeric row range (say, the 10th - 20th rows) and a name-based column range (columns "timestamp" and "value").

As of now, the most consistent way to solve it is:

```python
df.loc[df.index[start_val:(end_val + 1)],cols_of_interest]
```

This is not ideal because

1. It is long and ugly to need to use `df.index` at all.
1. Notice the `(end_val + 1)`:  While most of Python uses exclusive ranges (eg, `range(1,3)` does not include `3`), `pandas`' `loc` is inclusive.  So, developers get used to `df.loc[1:3,'a']` giving all three rows.

#### Describe the solution you'd like

[this should provide a description of the feature request, e.g. "`DataFrame.foo` should get a new parameter `bar` that [...]", try to write a docstring for the desired feature]

`DataFrame.loc` should have a new argument `num_idxs` which is a boolean list of 2 values, specifying whether the row or column indices should be numeric or names.  Eg, `[True, False]` means that the rows should be treated as numeric and the columns as names.

This argument should have a default value of `None`, since default lists are dangerous in Python, but that `None` should resolve to `[True, False]`, since this is the most common situation that most of us want (I think).

The behavior of numeric should be exactly identical to the current implementation of `iloc`.  The behavior of names should be identical to `loc`, currently.


#### API breaking implications

[this should provide a description of how this feature will affect the API]

The only API breaking implication I am aware of is that using the default I suggested (rows being treated as numeric) will create "off-by-one" issues, since `iloc` is exclusive and `loc` is inclusive.

This could potentially be handled by first making the default resolve to `[False, False]` upon initial introduction, but it should eventually be deprecated to `[True, False]` as I say above, since this is the most common case.


#### Describe alternatives you've considered

[this should provide a description of any alternative solutions or features you've considered]

As mentioned above, I sprinkle my code with the ugly:

```python
df.loc[df.index[start_val:(end_val + 1)],cols_of_interest]
```

The reason this is necessary is because (a) row *names* rarely mean anything to me in my work, and (b) I try to make code as generalizable as possible.

#### Additional context

I feel the description above covers it, but I am happy to add some examples if there is confusion.