Asterisk, backquote, vertical bar, and underscore are inline
delimiter characters. Asterisk, backquote, and vertical bar act
like quote marks; matching characters surround the marked-up word
or phrase, whitespace or other quoting is required outside them,
and there can't be whitespace just inside them. If you want to use
inline delimiter characters literally, escape
(with backslash) or quote them (with double backquotes; i.e.
use inline literals).

In detail, the reStructuredText specification says that in
inline markup, the following rules apply to start-strings and
end-strings (inline markup delimiters):

The start-string must start a text block or be
immediately preceded by whitespace or any of
' " ( [ { or <.

The start-string must be immediately followed by non-whitespace.

The end-string must be immediately preceded by non-whitespace.

The end-string must end a text block (end of document or
followed by a blank line) or be immediately followed by whitespace
or any of ' " . , : ; ! ? - ) ] } / \
or >.

If a start-string is immediately preceded by one of
' " ( [ { or <, it must not be
immediately followed by the corresponding character from
' " ) ] } or >.

An end-string must be separated by at least one
character from the start-string.

An unescaped backslash preceding a
start-string or end-string will disable markup recognition, except
for the end-string of inline literals.

Also remember that inline markup may not be nested (well,
except that inline literals can contain any of the other inline
markup delimiter characters, but that doesn't count because
nothing is processed).

reStructuredText uses backslashes ("\") to override the special
meaning given to markup characters and get the literal characters
themselves. To get a literal backslash, use an escaped backslash
("\\"). For example:

Raw reStructuredText

Typical result

*escape* ``with`` "\"

escapewith ""

\*escape* \``with`` "\\"

*escape* ``with`` "\"

In Python strings it will, of course, be necessary
to escape any backslash characters so that they actually
reach reStructuredText.
The simplest way to do this is to use raw strings:

=====Title=====Subtitle--------Titles are underlined (or over-and underlined) with a printingnonalphanumeric 7-bit ASCIIcharacter. Recommended choicesare "``= - ` : ' " ~ ^ _ * + # < >``".The underline/overline must be atleast as long as the title text.A lone top-level (sub)sectionis lifted up to be the document's(sub)title.

Title

Subtitle

Titles are underlined (or over-
and underlined) with a printing
nonalphanumeric 7-bit ASCII
character. Recommended choices
are "= - ` : ' " ~ ^ _ * + # < >".
The underline/overline must be at
least as long as the title text.

A lone top-level (sub)section is
lifted up to be the document's
(sub)title.

3. This is the first item4. This is the second item5. Enumerators are arabic numbers, single letters, or roman numerals6. List items should be sequentially numbered, but need not start at 1 (although not all formatters will honour the first index).#. This item is auto-enumerated

Enumerated lists:

This is the first item

This is the second item

Enumerators are arabic numbers, single letters,
or roman numerals

List items should be sequentially numbered,
but need not start at 1 (although not all
formatters will honour the first index).

Field lists are used as part of an extension syntax, such as
options for directives, or database-like
records meant for further processing. Field lists may also be
used as generic two-column table constructs in documents.

| Line blocks are useful for addresses,| verse, and adornment-free lists.|| Each new line begins with a| vertical bar ("|").| Line breaks and initial indents| are preserved.| Continuation lines are wrapped portions of long lines; they begin with spaces in place of vertical bars.

Line blocks are useful for addresses,

verse, and adornment-free lists.

Each new line begins with a

vertical bar ("|").

Line breaks and initial indents

are preserved.

Continuation lines are wrapped portions
of long lines; they begin
with spaces in place of vertical bars.

Doctest blocks are interactive
Python sessions. They begin with
"``>>>``" and end with a blank line.

>>> print "This is a doctest block."
This is a doctest block.

Doctest blocks are interactive
Python sessions. They begin with
">>>" and end with a blank line.

>>> print "This is a doctest block."
This is a doctest block.

"The doctest
module searches a module's docstrings for text that looks like an
interactive Python session, then executes all such sessions to
verify they still work exactly as shown." (From the doctest docs.)

Explicit markup blocks are used for constructs which float
(footnotes), have no direct paper-document representation
(hyperlink targets, comments), or require specialized processing
(directives). They all begin with two periods and whitespace, the
"explicit markup start".

The numbering of auto-numbered footnotes is determined by the
order of the footnotes, not of the references. For auto-numbered
footnote references without autonumber labels
("[#]_"), the references and footnotes must be in the
same relative order. Similarly for auto-symbol footnotes
("[*]_").

"Fold-in" is the representation typically used in HTML
documents (think of the indirect hyperlink being "folded in" like
ingredients into a cake), and "call-out" is more suitable for
printed documents, where the link needs to be presented explicitly, for
example as a footnote. You can force usage of the call-out form by
using the
"target-notes"
directive.

reStructuredText also provides for embedded URIs (details),
a convenience at the expense of readability. A hyperlink
reference may directly embed a target URI inline, within angle
brackets. The following is exactly equivalent to the example above:

The second hyperlink target (the line beginning with
"__") is both an indirect hyperlink target
(indirectly pointing at the Python website via the
"Python_" reference) and an anonymous hyperlink
target. In the text, a double-underscore suffix is used to
indicate an anonymous hyperlink reference. In an anonymous
hyperlink target, the reference text is not repeated. This is
useful for references with long text or throw-away references, but
the target should be kept close to the reference to prevent them
going out of sync.

Directives are a general-purpose extension mechanism, a way of
adding support for new constructs without adding new syntax. For
a description of all standard directives, see reStructuredText
Directives.