ENH: Add an `assert`  method to Series and DataFrame to assert on the fly in chaining
#### Is your feature request related to a problem?

When chaining methods, one may want to make some check and raise errors accordingly. Currently it is not possible to define these checks on the fly but one rather has to define a function like :

```
def assert_a_positive(df):
    if not (df.a > 0).all():
        raise ValueError()
    return df
```

so as to be able to do later, for example:

```
(
    pd.DataFrame({"a": [1, 2]})
    .pipe(assert_a_positive)
    .assign(b=lambda df: 1 / df.a)
)
```

This lakes flexibility and readability. Eventually it refrains from writing more test for data scientist that, even though then don't write unit test, at least are used to write sanity check like that.

#### Describe the solution you'd like

Adding an `assert` method to `pd.Series` and `pd.DataFrame` such that the above example could be written:

```
(
    pd.DataFrame({"a": [1, 2]})
    .assert(lambda df: (df.a > 0).all())
    .assign(b=lambda df: 1 / df.a)
)
```

#### API breaking implications

It doest not break a thing but just add a new method

#### Describe alternatives you've considered

There is actually a [great-expectation](https://github.com/great-expectations/great_expectations) package that does this sort of thing but with pre-built check. It is not as natural as writing down directly `assert` on-the-fly and requires an extra dep.

#### Additional context

In my current projects, I have just added these few lines at init:

```
from pandas.core.frame import DataFrame
from pandas.core.series import Series


def pandas_assert(df, func, *args, error_type=AssertionError):
    if not func(df):
        raise error_type(*[arg(df) if callable(arg) else arg for arg in args])
    return df


setattr(DataFrame, "assert_", pandas_assert)  # assert cannot be used
setattr(Series, "assert_", pandas_assert)
```

so that I can then do for example:

```
(
    pd.DataFrame({"a": [-1, 1, 2, 0]})
    .assert_(lambda df: (df.a > 0).all())
    .assign(b=lambda df: 1 / df.a)
)
(
    pd.DataFrame({"a": [-1, 1, 2, 0]})
    .assert_(lambda df: (df.a > 0).all(), "some a are lower than 0")
    .assign(b=lambda df: 1 / df.a)
)
(
    pd.DataFrame({"a": [-1, 1, 2, 0]})
    .assert_(
        lambda df: (df.a > 0).all(), "some a are lower than 0", error_type=ValueError
    )
    .assign(b=lambda df: 1 / df.a)
)
(
    pd.DataFrame({"a": [-1, 1, 2, 0]})
    .assert_(
        lambda df: (df.a > 0).all(),
        lambda df: f"some a are lower than 0:\n{df[df.a <= 0]}",
        error_type=ValueError,
    )
    .assign(b=lambda df: 1 / df.a)
)
```