Design of DataFrame.where() is potentially counter-intuitive
#### Code Sample

```python
>>> s = pd.Series(range(5))
>>> s.where(s > 1, 10)
0    10
1    10
2    2
3    3
4    4
dtype: int64
```
#### Problem description

This is a purely design-related issue!

I think that the behavior of the `DataFrame.where()` is potentially confusing, and can easily be misunderstood. The core of the issue is the use of the `other` parameter. 

The behavior when `other`  is set by the user can be confusing,

```python
>>> s = pd.Series(range(5))
>>> s.where(s > 1, 10)
0    10
1    10
2    2
3    3
4    4
dtype: int64
```

Reading `s.where(s > 1, 10)`, I think the logical way to read that, or to use a function called `.where()`, is:

> Replace values in `s` where `s > 1` is `True` with `10`

While the proper use of `other` may make sense if you're fully familiar with the default behavior of `.where()`, it can be confusing to those reading it for the first time.

I think this boils down to the function being,

> Replace values where the condition is **False**

Instead of,

> Replace values where the condition is **True**

which I think is the expected behavior based on the function name.

[this should explain **why** the current behaviour is a problem and why the expected output is a better solution.]

#### Expected Output

Changing the behavior of `.where()` to be:

> Replace values where the condition is **True**

This would then give,

```python
>>> s = pd.Series(range(5))
>>> s.where(s > 1, 10)
0    0
1    1
2    10
3    10
4    10
dtype: int64
```

So, to replicate the output of the initial snippet,

```python
>>> s = pd.Series(range(5))
>>> s.where(s < 2, 10)
0    10
1    10
2    2
3    3
4    4
dtype: int64
```

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

Not applicable