How to document a method with parameter(s)?

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...

Based on my experience, the numpy docstring conventions (PEP257 superset) are the most widely-spread followed conventions that are also supported by tools, such as Sphinx.

One example:

Parameters----------x : type    Description of parameter `x`.

Conventions:

• PEP 257 Docstring Conventions
• PEP 287 reStructuredText Docstring Format

Tools:

• Epydoc: Automatic API Documentation Generation for Python
• sphinx.ext.autodoc – Include documentation from docstrings
• PyCharm has some nice support for docstrings

Update: Since Python 3.5 you can use type hints which is a compact, machine-readable syntax:

from typing import Dict, Uniondef foo(i: int, d: Dict[str, Union[str, int]]) -> int:    """    Explanation: this function takes two arguments: `i` and `d`.    `i` is annotated simply as `int`. `d` is a dictionary with `str` keys    and values that can be either `str` or `int`.    The return type is `int`.    """

The main advantage of this syntax is that it is defined by the language and that it's unambiguous, so tools like PyCharm can easily take advantage from it.