home *** CD-ROM | disk | FTP | other *** search
/ EuroCD 3 / EuroCD 3.iso / Programming / Python-1.4 / Docs / Regular_Expressions_1.txt < prev    next >
Encoding:
Text File  |  1998-06-24  |  8.9 KB  |  207 lines
  1. Newsgroups: comp.lang.python
  2. From: borbor@divsun.unige.ch (Boris Borcic)
  3. Subject: Re: Regular expressions, pattern matching
  4. Date: Mon, 27 Nov 1995 08:50:58 GMT
  5.  
  6. In article <49aml2$n82@mrnews.mro.dec.com>, Peter.Mayne@cao.mts.dec.com
  7. (Peter Mayne) wrote:
  8.  
  9. > 
  10. > Please don't point me to any Emacs doc. I don't use Emacs, and I don't
  11. want to 
  12. > use Emacs, I just want to know how regular expressions and pattern matching 
  13. > work in Python.
  14.  
  15. Then you have a problem. Note that you don't need to use emacs in order
  16. to use a part of its documentation. If you insist, you might try to use
  17. the MOO doc on regexps that uses the same package (it's really the
  18. same doc with the backslash escape changed to percent).
  19.  
  20. Just in case you change your mind, I append the essential part
  21. of the emacs doc :-)
  22.  
  23. Regards,
  24.  
  25. Boris Borcic
  26. ==
  27.  
  28. Syntax of Regular Expressions
  29. =============================
  30.  
  31.    Regular expressions have a syntax in which a few characters are
  32. special constructs and the rest are "ordinary".  An ordinary character
  33. is a simple regular expression which matches that character and nothing
  34. else.  The special characters are `$', `^', `.', `*', `+', `?', `[',
  35. `]' and `\'; no new special characters will be defined.  Any other
  36. character appearing in a regular expression is ordinary, unless a `\'
  37. precedes it.
  38.  
  39.    For example, `f' is not a special character, so it is ordinary, and
  40. therefore `f' is a regular expression that matches the string `f' and
  41. no other string.  (It does not match the string `ff'.)  Likewise, `o'
  42. is a regular expression that matches only `o'.
  43.  
  44.    Any two regular expressions A and B can be concatenated.  The result
  45. is a regular expression which matches a string if A matches some amount
  46. of the beginning of that string and B matches the rest of the string.
  47.  
  48.    As a simple example, you can concatenate the regular expressions `f'
  49. and `o' to get the regular expression `fo', which matches only the
  50. string `fo'.  To do something nontrivial, you need to use one of the
  51. following special characters:
  52.  
  53. `. (Period)'
  54.      is a special character that matches any single character except a
  55.      newline.  Using concatenation, you can make regular expressions
  56.      like `a.b', which matches any three-character string which begins
  57.      with `a' and ends with `b'.
  58.  
  59. `*'
  60.      is not a construct by itself; it is a suffix, which means the
  61.      preceding regular expression is to be repeated as many times as
  62.      possible.  In `fo*', the `*' applies to the `o', so `fo*' matches
  63.      one `f' followed by any number of `o's.  The case of zero `o's is
  64.      allowed: `fo*' does match `f'.
  65.  
  66.      `*' always applies to the smallest possible preceding expression.
  67.      Thus, `fo*' has a repeating `o', not a repeating `fo'.
  68.  
  69.      The matcher processes a `*' construct by immediately matching as
  70.      many repetitions as it can find.  Then it continues with the rest
  71.      of the pattern.  If that fails, backtracking occurs, discarding
  72.      some of the matches of the `*'-modified construct in case that
  73.      makes it possible to match the rest of the pattern.  For example,
  74.      matching `ca*ar' against the string `caaar', the `a*' first tries
  75.      to match all three `a's; but the rest of the pattern is `ar' and
  76.      there is only `r' left to match, so this try fails.  The next
  77.      alternative is for `a*' to match only two `a's.  With this choice,
  78.      the rest of the regexp matches successfully.
  79.  
  80. `+'
  81.      is a suffix character similar to `*' except that it requires that
  82.      the preceding expression be matched at least once.  For example,
  83.      `ca+r' will match the strings `car' and `caaaar' but not the
  84.      string `cr', whereas `ca*r' would match all three strings.
  85.  
  86. `?'
  87.      is a suffix character similar to `*' except that it can match the
  88.      preceding expression either once or not at all.  For example,
  89.      `ca?r' will match `car' or `cr'; nothing else.
  90.  
  91. `[ ... ]'
  92.      `[' begins a "character set", which is terminated by a `]'.  In
  93.      the simplest case, the characters between the two form the set.
  94.      Thus, `[ad]' matches either one `a' or one `d', and `[ad]*'
  95.      matches any string composed of just `a's and `d's (including the
  96.      empty string), from which it follows that `c[ad]*r' matches `cr',
  97.      `car', `cdr', `caddaar', etc.
  98.  
  99.      You can include character ranges in a character set by writing two
  100.      characters with a `-' between them.  Thus, `[a-z]' matches any
  101.      lower-case letter.  Ranges may be intermixed freely with
  102.      individual characters, as in `[a-z$%.]', which matches any lower-
  103.      case letter or `$', `%', or period.
  104.  
  105.      Note that inside a character set the usual special characters are
  106.      not special any more.  A completely different set of special
  107.      characters exists inside character sets: `]', `-', and `^'.
  108.  
  109.      To include a `]' in a character set, you must make it the first
  110.      character.  For example, `[]a]' matches `]' or `a'.  To include a
  111.      `-', write `---', which is a range containing only `-'.  To
  112.      include `^', make it other than the first character in the set.
  113.  
  114. `[^ ... ]'
  115.      `[^' begins a "complement character set", which matches any
  116.      character except the ones specified.  Thus, `[^a-z0-9A-Z]' matches
  117.      all characters except letters and digits.
  118.  
  119.      `^' is not special in a character set unless it is the first
  120.      character.  The character following the `^' is treated as if it
  121.      were first (`-' and `]' are not special there).
  122.  
  123.      Note that a complement character set can match a newline, unless
  124.      newline is mentioned as one of the characters not to match.
  125.  
  126. `^'
  127.      is a special character that matches the empty string, but only if
  128.      at the beginning of a line in the text being matched.  Otherwise,
  129.      it fails to match anything.  Thus, `^foo' matches a `foo' that
  130.      occurs at the beginning of a line.
  131.  
  132. `$'
  133.      is similar to `^' but matches only at the end of a line.  Thus,
  134.      `xx*$' matches a string of one `x' or more at the end of a line.
  135.  
  136. `\'
  137.      does two things: it quotes the special characters (including `\'),
  138.      and it introduces additional special constructs.
  139.  
  140.      Because `\' quotes special characters, `\$' is a regular
  141.      expression that matches only `$', and `\[' is a regular expression
  142.      that matches only `[', and so on.
  143.  
  144.    Note: for historical compatibility, special characters are treated as
  145. ordinary ones if they are in contexts where their special meanings make
  146. no sense.  For example, `*foo' treats `*' as ordinary since there is no
  147. preceding expression on which the `*' can act.  It is poor practice to
  148. depend on this behavior; better to quote the special character anyway,
  149. regardless of where is appears.
  150.  
  151.    Usually, `\' followed by any character matches only that character.
  152. However, there are several exceptions: characters which, when preceded
  153. by `\', are special constructs.  Such characters are always ordinary
  154. when encountered on their own.  Here is a table of `\' constructs.
  155.  
  156. `\|'
  157.      specifies an alternative.  Two regular expressions A and B with
  158.      `\|' in between form an expression that matches anything A or B
  159.      matches.
  160.  
  161.      Thus, `foo\|bar' matches either `foo' or `bar' but no other string.
  162.  
  163.      `\|' applies to the largest possible surrounding expressions.
  164.      Only a surrounding `\( ... \)' grouping can limit the grouping
  165.      power of `\|'.
  166.  
  167.      Full backtracking capability exists to handle multiple uses of
  168.      `\|'.
  169.  
  170. `\( ... \)'
  171.      is a grouping construct that serves three purposes:
  172.  
  173.        1. To enclose a set of `\|' alternatives for other operations.
  174.           Thus, `\(foo\|bar\)x' matches either `foox' or `barx'.
  175.  
  176.        2. To enclose a complicated expression for the postfix `*' to
  177.           operate on.  Thus, `ba\(na\)*' matches `bananana', etc., with
  178.           any (zero or more) number of `na' strings.
  179.  
  180.        3. To mark a matched substring for future reference.
  181.  
  182.  
  183.      This last application is not a consequence of the idea of a
  184.      parenthetical grouping; it is a separate feature which happens to
  185.      be assigned as a second meaning to the same `\( ... \)' construct
  186.      because in practice there is no conflict between the two meanings.
  187.      Here is an explanation:
  188.  
  189. `\DIGIT'
  190.      after the end of a `\( ... \)' construct, the matcher remembers the
  191.      beginning and end of the text matched by that construct.  Then,
  192.      later on in the regular expression, you can use `\' followed by
  193.      DIGIT to mean "match the same text matched the DIGIT'th time by the
  194.      `\( ... \)' construct."
  195.  
  196.      The strings matching the first nine `\( ... \)' constructs
  197.      appearing in a regular expression are assigned numbers 1 through 9
  198.      in order that the open-parentheses appear in the regular
  199.      expression.  `\1' through `\9' may be used to refer to the text
  200.      matched by the corresponding `\( ... \)' construct.
  201.  
  202.      For example, `\(.*\)\1' matches any newline-free string that is
  203.      composed of two identical halves.  The `\(.*\)' matches the first
  204.      half, which may be anything, but the `\1' that follows must match
  205.      the same exact text.
  206.  
  207.