def keep_params(self, base_key, *params):
        """
        Method to keep only specific parameters from a parameter documentation.

        This method extracts the given `param` from the `base_key` item in the
        :attr:`params` dictionary and creates a new item with the original
        documentation with only the description of the param. This method works
        for ``'Parameters'`` like sections.

        The new docstring with the selected parts will be accessible as
        ``base_key + '.' + '|'.join(params)``, e.g.
        ``'original_key.param1|param2'``

        Parameters
        ----------
        base_key: str
            key in the :attr:`params` dictionary
        ``*params``
            str. Parameter identifier of which the documentations shall be
            in the new section

        See Also
        --------
        keep_types, delete_params

        Examples
        --------
        To extract just two parameters from a function and reuse their
        docstrings, you can type::

            >>> from docrep import DocstringProcessor
            >>> d = DocstringProcessor()
            >>> @d.get_sectionsf('do_something')
            ... def do_something(a=1, b=2, c=3):
            ...     '''
            ...     That's %(doc_key)s
            ...
            ...     Parameters
            ...     ----------
            ...     a: int, optional
            ...         A dummy parameter description
            ...     b: int, optional
            ...         A second dummy parameter that will be excluded
            ...     c: float, optional
            ...         A third parameter'''
            ...     print(a)

            >>> d.keep_params('do_something.parameters', 'a', 'c')

            >>> @d.dedent
            ... def do_less(a=1, c=4):
            ...     '''
            ...     My second function with only `a` and `c`
            ...
            ...     Parameters
            ...     ----------
            ...     %(do_something.parameters.a|c)s'''
            ...     pass

            >>> print(do_less.__doc__)
            My second function with only `a` and `c`
            <BLANKLINE>
            Parameters
            ----------
            a: int, optional
                A dummy parameter description
            c: float, optional
                A third parameter

        Equivalently, you can use the :meth:`delete_params` method to remove
        parameters::

            >>> d.delete_params('do_something.parameters', 'b')

            >>> @d.dedent
            ... def do_less(a=1, c=4):
            ...     '''
            ...     My second function with only `a` and `c`
            ...
            ...     Parameters
            ...     ----------
            ...     %(do_something.parameters.no_b)s'''
            ...     pass

        """
        self.params[base_key + '.' + '|'.join(params)] = self.keep_params_s(
            self.params[base_key], params)