Since docstrings are free-form, it really depends on what you use to parse code to generate API documentation.

I would recommend getting familiar with the Sphinx markup, since it is widely used and is becoming the de-facto standard for documenting Python projects, in part because of the excellent readthedocs.org service. To paraphrase an example from the Sphinx documentation as a Python snippet:

def send_message(sender, recipient, message_body, priority=1) -> int:
   """
   Send a message to a recipient.

   :param str sender: The person sending the message
   :param str recipient: The recipient of the message
   :param str message_body: The body of the message
   :param priority: The priority of the message, can be a number 1-5
   :type priority: integer or None
   :return: the message id
   :rtype: int
   :raises ValueError: if the message_body exceeds 160 characters
   :raises TypeError: if the message_body is not a basestring
   """

This markup supports cross-referencing between documents and more. Note that the Sphinx documentation uses (e.g.) :py:attr: whereas you can just use :attr: when documenting from the source code.

Naturally, there are other tools to document APIs. There's the more classic Doxygen which uses \param commands but those are not specifically designed to document Python code like Sphinx is.

Note that there is a similar question with a similar answer in here...

A good first step would be to use type hints:

#!/usr/bin/env python3

from typing import Callable, TypeVar


def low_level(x: int) -> int:
    return x + 5


T = TypeVar("T")


def high_level(f: Callable[[int], T]) -> T:
    return f(5)

This already tells you everything you need to know: high_level takes a Callable object as its argument, which in turn gets passed an int and returns "something", and that "something" is also the return type of high_level.

As for documentation, I would follow the style of the Python standard library, which contains many higher-order functions such as itertools.accumulate.

I am not very familiar with Python documentation generators, but I would assume that the documentation for high_level would be rendered something like this:

high_level<T>(f: int → T) → T