bunch of readbility fixes, no semantic changes

Author: tartley

cheatsheet.rst

@@ -1,77 +1,74 @@
 Python 2.7 Regular Expressions
 ==============================
 
-Special characters::
-
-    \       escapes special characters.
-    .       matches any character
-    ^       matches start of the string (or line if MULTILINE)
-    $       matches end of the string (or line if MULTILINE)
-    [5b-d]  matches any chars '5', 'b', 'c' or 'd'
-    [^a-c6] matches any char except 'a', 'b', 'c' or '6'
-    R|S     matches either regex R or regex S.
-    ()      Creates a capture group, and indicates precedence.
-
-Within ``[]``, no special chars do anything special, hence they don't need
-escaping, except for ``']'`` and ``'-'``, which only need escaping if they are
-not the 1st char. e.g. ``'[]]'`` matches ``']'``. ``'^'`` also has special
-meaning, it negates the group if it's the first character in the ``[]``, and
-needs to be escaped to match it literally.
-
-Quantifiers::
-
-    *       0 or more   (append ? for non-greedy)
-    +       1 or more    "
-    ?       0 or 1       "
-    {m}     exactly 'm'
-    {m,n}   from m to n. 'm' defaults to 0, 'n' to infinity
-    {m,n}?  from m to n, as few as possible
+Non-special chars match themselves. Exceptions are special characters::
+
+    \       Escape special char
+    .       Match any char except newline, see re.DOTALL
+    ^       Match start of the string, see re.MULTILINE
+    $       Match end of the string, see re.MULTILINE
+    []      Enclose a set of matchable chars
+    R|S     Match either regex R or regex S.
+    ()      Create capture group, and indicate precedence
+
+After '``[``', enclose a set, the only special chars are::
+
+    ]   End the set, if not the 1st char
+    -   A range, eg. a-c matches a, b or c
+    ^   Negate the set only if it is the 1st char
+
+Quantifiers (append '``?``' for non-greedy)::
+
+    *       0 or more
+    +       1 or more
+    ?       0 or 1
+    {m}     Exactly 'm'
+    {m,n}   From m (default 0) to n (default infinity)
 
 Special sequences::
 
     \A  Start of string
-    \b  Matches empty string at word boundary (between \w and \W)
-    \B  Matches empty string not at word boundary
+    \b  Match empty string at word (\w+) boundary
+    \B  Match empty string not at word boundary
     \d  Digit
     \D  Non-digit
-    \s  Whitespace: [ \t\n\r\f\v], more if LOCALE or UNICODE
+    \s  Whitespace [ \t\n\r\f\v], see LOCALE,UNICODE
     \S  Non-whitespace
-    \w  Alphanumeric: [0-9a-zA-Z_], or is LOCALE dependant
+    \w  Alphanumeric: [0-9a-zA-Z_], see LOCALE
     \W  Non-alphanumeric
     \Z  End of string
-
-    \g<id>  Match previous group, '<' & '>' are literal
-            e.g. \g<0> or \g<name> (not \g0 or \gname)
+    \g<id>  Match prev named or numbered group,
+            '<' & '>' are literal, e.g. \g<0>
+            or \g<name> (not \g0 or \gname)
 
 Special character escapes are much like those already escaped in Python string
 literals. Hence regex '``\n``' is same as regex '``\\n``'::
 
     \a  ASCII Bell (BEL)
     \f  ASCII Formfeed
     \n  ASCII Linefeed
-    \r  ASCII Carraige return
+    \r  ASCII Carriage return
     \t  ASCII Tab
     \v  ASCII Vertical tab
     \\  A single backslash
-
-    \xHH   Two digit hex character
-    \OOO   Three digit octal char
-           (or use a preceding zero, e.g. \0, \09)
-    \DD    Decimal number 1 to 99, matches previous
-           numbered group
-
-Extensions. These do not cause grouping, except for ``(?P<name>...)``::
-
-    (?iLmsux)       Matches empty string, sets re.X flags
-    (?:...)         Non-capturing version of regular parentheses
-    (?P<name>...)   Creates a named capturing group.
-    (?P=name)       Matches whatever matched previously named group
-    (?#...)         A comment; ignored.
-    (?=...)         Lookahead assertion: Matches without consuming
-    (?!...)         Negative lookahead assertion
-    (?<=...)        Lookbehind assertion: Matches if preceded
-    (?<!...)        Negative lookbehind assertion
-    (?(id)yes|no)   Match 'yes' if group 'id' matched, else 'no'
+    \xHH   Two digit hexadecimal character goes here
+    \OOO   Three digit octal char (or just use an
+           initial zero, e.g. \0, \09)
+    \DD    Decimal number 1 to 99, match
+           previous numbered group
+
+Extensions. Do not cause grouping, except '``P<name>``'::
+
+    (?iLmsux)     Match empty string, sets re.X flags
+    (?:...)       Non-capturing version of regular parens
+    (?P<name>...) Create a named capturing group.
+    (?P=name)     Match whatever matched prev named group
+    (?#...)       A comment; ignored.
+    (?=...)       Lookahead assertion, match without consuming
+    (?!...)       Negative lookahead assertion
+    (?<=...)      Lookbehind assertion, match if preceded
+    (?<!...)      Negative lookbehind assertion
+    (?(id)y|n)    Match 'y' if group 'id' matched, else 'n'
 
 Flags for re.compile(), etc. Combine with ``'|'``::
 
@@ -105,30 +102,30 @@ RegexObjects (returned from ``compile()``)::
     .split(string[, maxsplit]) -> list of strings
     .sub(repl, string[, count]) -> string
     .subn(repl, string[, count]) -> (string, int)
-    .flags       # int passed to compile()
-    .groups      # int number of capturing groups
-    .groupindex  # {} maps group names to ints
-    .pattern     # string passed to compile()
+    .flags      # int, Passed to compile()
+    .groups     # int, Number of capturing groups
+    .groupindex # {}, Maps group names to ints
+    .pattern    # string, Passed to compile()
 
 MatchObjects (returned from ``match()`` and ``search()``)::
 
-    .expand(template) -> string, backslash and group expansion
+    .expand(template) -> string, Backslash & group expansion
     .group([group1...]) -> string or tuple of strings, 1 per arg
-    .groups([default]) -> (,) of all groups, non-matching=default
-    .groupdict([default]) -> {} of named groups, non-matching=default
-    .start([group]) -> int, start/end of substring matched by group
-    .end([group])      (group defaults to 0, the whole match)
+    .groups([default]) -> tuple of all groups, non-matching=default
+    .groupdict([default]) -> {}, Named groups, non-matching=default
+    .start([group]) -> int, Start/end of substring match by group
+    .end([group]) -> int, Group defaults to 0, the whole match
     .span([group]) -> tuple (match.start(group), match.end(group))
-    .pos # value passed to search() or match()
-    .endpos # "
-    .lastindex # int index of last matched capturing group
-    .lastgroup # string name of last matched capturing group
-    .re # regex passed to search() or match()
-    .string # string passed to search() or match()
+    .pos       int, Passed to search() or match()
+    .endpos    int, "
+    .lastindex int, Index of last matched capturing group
+    .lastgroup string, Name of last matched capturing group
+    .re        regex, As passed to search() or match()
+    .string    string, "
 
 
 Gleaned from the python 2.7 're' docs. http://docs.python.org/library/re.html
 
-:Version: v0.3.1
-:Contact: tartley@tartley.com
+https://github.com/tartley/python-regex-cheatsheet
+Version: v0.3.3