PageRenderTime 51ms CodeModel.GetById 19ms RepoModel.GetById 0ms app.codeStats 1ms

/library/re.rst.diff.html

https://code.google.com/p/python-doc-ja/
HTML | 282 lines | 236 code | 46 blank | 0 comment | 0 complexity | 9193bedaae1987af7696b941acda3e72 MD5 | raw file
Possible License(s): BSD-3-Clause 
    

  1. <html>
    2. 

  2. <head>
    3. 

  3. <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
    4. 

  4. <title>library/re.rst</title>
    5. 

  5. <style type="text/css">
    6. 

  6. .highlight .hll { background-color: #ffffcc }
    7. 

  7. .highlight  { background: #f8f8f8; }
    8. 

  8. .highlight .c { color: #408080; font-style: italic } /* Comment */
    9. 

  9. .highlight .err { border: 1px solid #FF0000 } /* Error */
    10. 

  10. .highlight .k { color: #008000; font-weight: bold } /* Keyword */
    11. 

  11. .highlight .o { color: #666666 } /* Operator */
    12. 

  12. .highlight .cm { color: #408080; font-style: italic } /* Comment.Multiline */
    13. 

  13. .highlight .cp { color: #BC7A00 } /* Comment.Preproc */
    14. 

  14. .highlight .c1 { color: #408080; font-style: italic } /* Comment.Single */
    15. 

  15. .highlight .cs { color: #408080; font-style: italic } /* Comment.Special */
    16. 

  16. .highlight .gd { color: #A00000 } /* Generic.Deleted */
    17. 

  17. .highlight .ge { font-style: italic } /* Generic.Emph */
    18. 

  18. .highlight .gr { color: #FF0000 } /* Generic.Error */
    19. 

  19. .highlight .gh { color: #000080; font-weight: bold } /* Generic.Heading */
    20. 

  20. .highlight .gi { color: #00A000 } /* Generic.Inserted */
    21. 

  21. .highlight .go { color: #808080 } /* Generic.Output */
    22. 

  22. .highlight .gp { color: #000080; font-weight: bold } /* Generic.Prompt */
    23. 

  23. .highlight .gs { font-weight: bold } /* Generic.Strong */
    24. 

  24. .highlight .gu { color: #800080; font-weight: bold } /* Generic.Subheading */
    25. 

  25. .highlight .gt { color: #0040D0 } /* Generic.Traceback */
    26. 

  26. .highlight .kc { color: #008000; font-weight: bold } /* Keyword.Constant */
    27. 

  27. .highlight .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */
    28. 

  28. .highlight .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */
    29. 

  29. .highlight .kp { color: #008000 } /* Keyword.Pseudo */
    30. 

  30. .highlight .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */
    31. 

  31. .highlight .kt { color: #B00040 } /* Keyword.Type */
    32. 

  32. .highlight .m { color: #666666 } /* Literal.Number */
    33. 

  33. .highlight .s { color: #BA2121 } /* Literal.String */
    34. 

  34. .highlight .na { color: #7D9029 } /* Name.Attribute */
    35. 

  35. .highlight .nb { color: #008000 } /* Name.Builtin */
    36. 

  36. .highlight .nc { color: #0000FF; font-weight: bold } /* Name.Class */
    37. 

  37. .highlight .no { color: #880000 } /* Name.Constant */
    38. 

  38. .highlight .nd { color: #AA22FF } /* Name.Decorator */
    39. 

  39. .highlight .ni { color: #999999; font-weight: bold } /* Name.Entity */
    40. 

  40. .highlight .ne { color: #D2413A; font-weight: bold } /* Name.Exception */
    41. 

  41. .highlight .nf { color: #0000FF } /* Name.Function */
    42. 

  42. .highlight .nl { color: #A0A000 } /* Name.Label */
    43. 

  43. .highlight .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */
    44. 

  44. .highlight .nt { color: #008000; font-weight: bold } /* Name.Tag */
    45. 

  45. .highlight .nv { color: #19177C } /* Name.Variable */
    46. 

  46. .highlight .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */
    47. 

  47. .highlight .w { color: #bbbbbb } /* Text.Whitespace */
    48. 

  48. .highlight .mf { color: #666666 } /* Literal.Number.Float */
    49. 

  49. .highlight .mh { color: #666666 } /* Literal.Number.Hex */
    50. 

  50. .highlight .mi { color: #666666 } /* Literal.Number.Integer */
    51. 

  51. .highlight .mo { color: #666666 } /* Literal.Number.Oct */
    52. 

  52. .highlight .sb { color: #BA2121 } /* Literal.String.Backtick */
    53. 

  53. .highlight .sc { color: #BA2121 } /* Literal.String.Char */
    54. 

  54. .highlight .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */
    55. 

  55. .highlight .s2 { color: #BA2121 } /* Literal.String.Double */
    56. 

  56. .highlight .se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */
    57. 

  57. .highlight .sh { color: #BA2121 } /* Literal.String.Heredoc */
    58. 

  58. .highlight .si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */
    59. 

  59. .highlight .sx { color: #008000 } /* Literal.String.Other */
    60. 

  60. .highlight .sr { color: #BB6688 } /* Literal.String.Regex */
    61. 

  61. .highlight .s1 { color: #BA2121 } /* Literal.String.Single */
    62. 

  62. .highlight .ss { color: #19177C } /* Literal.String.Symbol */
    63. 

  63. .highlight .bp { color: #008000 } /* Name.Builtin.Pseudo */
    64. 

  64. .highlight .vc { color: #19177C } /* Name.Variable.Class */
    65. 

  65. .highlight .vg { color: #19177C } /* Name.Variable.Global */
    66. 

  66. .highlight .vi { color: #19177C } /* Name.Variable.Instance */
    67. 

  67. .highlight .il { color: #666666 } /* Literal.Number.Integer.Long */
    68. 

  68. </style>
    69. 

  69. </head>
    70. 

  70. <body>
    71. 

  71. <div class="highlight"><pre><span class="gu">@@ -215,25 +215,25 @@</span>
    72. 

  72.     and :const:`re.X` (verbose), for the entire regular expression. (The
    73. 

  73.     flags are described in :ref:`contents-of-module-re`.) This
    74. 

  74.     is useful if you wish to include the flags as part of the regular
    75. 

  75.     expression, instead of passing a *flag* argument to the
    76. 

  76.     :func:`re.compile` function.
    77. 

  77.  
    78. 

  78.     Note that the ``(?x)`` flag changes how the expression is parsed. It should be
    79. 

  79.     used first in the expression string, or after one or more whitespace characters.
    80. 

  80.     If there are non-whitespace characters before the flag, the results are
    81. 

  81.     undefined.
    82. 

  82.  
    83. 

  83.  ``(?:...)``
    84. 

  84. <span class="gd">-   A non-grouping version of regular parentheses. Matches whatever regular</span>
    85. 

  85. <span class="gi">+   A non-capturing version of regular parentheses.  Matches whatever regular</span>
    86. 

  86.     expression is inside the parentheses, but the substring matched by the group
    87. 

  87.     *cannot* be retrieved after performing a match or referenced later in the
    88. 

  88.     pattern.
    89. 

  89.  
    90. 

  90.  ``(?P&lt;name&gt;...)``
    91. 

  91.     Similar to regular parentheses, but the substring matched by the group is
    92. 

  92.     accessible within the rest of the regular expression via the symbolic group
    93. 

  93.     name *name*.  Group names must be valid Python identifiers, and each group
    94. 

  94.     name must be defined only once within a regular expression.  A symbolic group
    95. 

  95.     is also a numbered group, just as if the group were not named.  So the group
    96. 

  96.     named ``id`` in the example below can also be referenced as the numbered group
    97. 

  97.     ``1``.
    98. 

  98. <span class="gu">@@ -323,25 +323,26 @@</span>
    99. 

  99.     precise set of characters deemed to be alphanumeric depends on the values of the
    100. 

  100.     ``UNICODE`` and ``LOCALE`` flags.  Inside a character range, ``\b`` represents
    101. 

  101.     the backspace character, for compatibility with Python&#39;s string literals.
    102. 

  102.  
    103. 

  103.  ``\B``
    104. 

  104.     Matches the empty string, but only when it is *not* at the beginning or end of a
    105. 

  105.     word.  This is just the opposite of ``\b``, so is also subject to the settings
    106. 

  106.     of ``LOCALE`` and ``UNICODE``.
    107. 

  107.  
    108. 

  108.  ``\d``
    109. 

  109.     When the :const:`UNICODE` flag is not specified, matches any decimal digit; this
    110. 

  110.     is equivalent to the set ``[0-9]``.  With :const:`UNICODE`, it will match
    111. 

  111. <span class="gd">-   whatever is classified as a digit in the Unicode character properties database.</span>
    112. 

  112. <span class="gi">+   whatever is classified as a decimal digit in the Unicode character properties</span>
    113. 

  113. <span class="gi">+   database.</span>
    114. 

  114.  
    115. 

  115.  ``\D``
    116. 

  116.     When the :const:`UNICODE` flag is not specified, matches any non-digit
    117. 

  117.     character; this is equivalent to the set  ``[^0-9]``.  With :const:`UNICODE`, it
    118. 

  118.     will match  anything other than character marked as digits in the Unicode
    119. 

  119.     character  properties database.
    120. 

  120.  
    121. 

  121.  ``\s``
    122. 

  122.     When the :const:`LOCALE` and :const:`UNICODE` flags are not specified, matches
    123. 

  123.     any whitespace character; this is equivalent to the set ``[ \t\n\r\f\v]``. With
    124. 

  124.     :const:`LOCALE`, it will match this set plus whatever characters are defined as
    125. 

  125.     space for the current locale. If :const:`UNICODE` is set, this will match the
    126. 

  126. <span class="gu">@@ -527,59 +528,64 @@</span>
    127. 

  127.  
    128. 

  128.     If zero or more characters at the beginning of *string* match the regular
    129. 

  129.     expression *pattern*, return a corresponding :class:`MatchObject` instance.
    130. 

  130.     Return ``None`` if the string does not match the pattern; note that this is
    131. 

  131.     different from a zero-length match.
    132. 

  132.  
    133. 

  133.     .. note::
    134. 

  134.  
    135. 

  135.        If you want to locate a match anywhere in *string*, use :func:`search`
    136. 

  136.        instead.
    137. 

  137.  
    138. 

  138.  
    139. 

  139. <span class="gd">-.. function:: split(pattern, string[, maxsplit=0])</span>
    140. 

  140. <span class="gi">+.. function:: split(pattern, string[, maxsplit=0, flags=0])</span>
    141. 

  141.  
    142. 

  142.     Split *string* by the occurrences of *pattern*.  If capturing parentheses are
    143. 

  143.     used in *pattern*, then the text of all groups in the pattern are also returned
    144. 

  144.     as part of the resulting list. If *maxsplit* is nonzero, at most *maxsplit*
    145. 

  145.     splits occur, and the remainder of the string is returned as the final element
    146. 

  146.     of the list.  (Incompatibility note: in the original Python 1.5 release,
    147. 

  147.     *maxsplit* was ignored.  This has been fixed in later releases.)
    148. 

  148.  
    149. 

  149.        &gt;&gt;&gt; re.split(&#39;\W+&#39;, &#39;Words, words, words.&#39;)
    150. 

  150.        [&#39;Words&#39;, &#39;words&#39;, &#39;words&#39;, &#39;&#39;]
    151. 

  151.        &gt;&gt;&gt; re.split(&#39;(\W+)&#39;, &#39;Words, words, words.&#39;)
    152. 

  152.        [&#39;Words&#39;, &#39;, &#39;, &#39;words&#39;, &#39;, &#39;, &#39;words&#39;, &#39;.&#39;, &#39;&#39;]
    153. 

  153.        &gt;&gt;&gt; re.split(&#39;\W+&#39;, &#39;Words, words, words.&#39;, 1)
    154. 

  154.        [&#39;Words&#39;, &#39;words, words.&#39;]
    155. 

  155. <span class="gi">+      &gt;&gt;&gt; re.split(&#39;[a-f]+&#39;, &#39;0a3B9&#39;, flags=re.IGNORECASE)</span>
    156. 

  156. <span class="gi">+      [&#39;0&#39;, &#39;3&#39;, &#39;9&#39;]</span>
    157. 

  157.  
    158. 

  158.     If there are capturing groups in the separator and it matches at the start of
    159. 

  159.     the string, the result will start with an empty string.  The same holds for
    160. 

  160.     the end of the string:
    161. 

  161.  
    162. 

  162.        &gt;&gt;&gt; re.split(&#39;(\W+)&#39;, &#39;...words, words...&#39;)
    163. 

  163.        [&#39;&#39;, &#39;...&#39;, &#39;words&#39;, &#39;, &#39;, &#39;words&#39;, &#39;...&#39;, &#39;&#39;]
    164. 

  164.  
    165. 

  165.     That way, separator components are always found at the same relative
    166. 

  166.     indices within the result list (e.g., if there&#39;s one capturing group
    167. 

  167.     in the separator, the 0th, the 2nd and so forth).
    168. 

  168.  
    169. 

  169.     Note that *split* will never split a string on an empty pattern match.
    170. 

  170.     For example:
    171. 

  171.  
    172. 

  172.        &gt;&gt;&gt; re.split(&#39;x*&#39;, &#39;foo&#39;)
    173. 

  173.        [&#39;foo&#39;]
    174. 

  174.        &gt;&gt;&gt; re.split(&quot;(?m)^$&quot;, &quot;foo\n\nbar\n&quot;)
    175. 

  175.        [&#39;foo\n\nbar\n&#39;]
    176. 

  176.  
    177. 

  177. <span class="gi">+   .. versionchanged:: 2.7</span>
    178. 

  178. <span class="gi">+      Added the optional flags argument.</span>
    179. 

  179. <span class="gi">+</span>
    180. 

  180.  
    181. 

  181.  .. function:: findall(pattern, string[, flags])
    182. 

  182.  
    183. 

  183.     Return all non-overlapping matches of *pattern* in *string*, as a list of
    184. 

  184.     strings.  The *string* is scanned left-to-right, and matches are returned in
    185. 

  185.     the order found.  If one or more groups are present in the pattern, return a
    186. 

  186.     list of groups; this will be a list of tuples if the pattern has more than
    187. 

  187.     one group.  Empty matches are included in the result unless they touch the
    188. 

  188.     beginning of another match.
    189. 

  189.  
    190. 

  190.     .. versionadded:: 1.5.2
    191. 

  191.  
    192. 

  192. <span class="gu">@@ -592,75 +598,81 @@</span>
    193. 

  193.     Return an :term:`iterator` yielding :class:`MatchObject` instances over all
    194. 

  194.     non-overlapping matches for the RE *pattern* in *string*.  The *string* is
    195. 

  195.     scanned left-to-right, and matches are returned in the order found.  Empty
    196. 

  196.     matches are included in the result unless they touch the beginning of another
    197. 

  197.     match.
    198. 

  198.  
    199. 

  199.     .. versionadded:: 2.2
    200. 

  200.  
    201. 

  201.     .. versionchanged:: 2.4
    202. 

  202.        Added the optional flags argument.
    203. 

  203.  
    204. 

  204.  
    205. 

  205. <span class="gd">-.. function:: sub(pattern, repl, string[, count])</span>
    206. 

  206. <span class="gi">+.. function:: sub(pattern, repl, string[, count, flags])</span>
    207. 

  207.  
    208. 

  208.     Return the string obtained by replacing the leftmost non-overlapping occurrences
    209. 

  209.     of *pattern* in *string* by the replacement *repl*.  If the pattern isn&#39;t found,
    210. 

  210.     *string* is returned unchanged.  *repl* can be a string or a function; if it is
    211. 

  211.     a string, any backslash escapes in it are processed.  That is, ``\n`` is
    212. 

  212.     converted to a single newline character, ``\r`` is converted to a linefeed, and
    213. 

  213.     so forth.  Unknown escapes such as ``\j`` are left alone.  Backreferences, such
    214. 

  214.     as ``\6``, are replaced with the substring matched by group 6 in the pattern.
    215. 

  215.     For example:
    216. 

  216.  
    217. 

  217.        &gt;&gt;&gt; re.sub(r&#39;def\s+([a-zA-Z_][a-zA-Z_0-9]*)\s*\(\s*\):&#39;,
    218. 

  218.        ...        r&#39;static PyObject*\npy_\1(void)\n{&#39;,
    219. 

  219.        ...        &#39;def myfunc():&#39;)
    220. 

  220.        &#39;static PyObject*\npy_myfunc(void)\n{&#39;
    221. 

  221.  
    222. 

  222.     If *repl* is a function, it is called for every non-overlapping occurrence of
    223. 

  223.     *pattern*.  The function takes a single match object argument, and returns the
    224. 

  224.     replacement string.  For example:
    225. 

  225.  
    226. 

  226.        &gt;&gt;&gt; def dashrepl(matchobj):
    227. 

  227.        ...     if matchobj.group(0) == &#39;-&#39;: return &#39; &#39;
    228. 

  228.        ...     else: return &#39;-&#39;
    229. 

  229.        &gt;&gt;&gt; re.sub(&#39;-{1,2}&#39;, dashrepl, &#39;pro----gram-files&#39;)
    230. 

  230.        &#39;pro--gram files&#39;
    231. 

  231. <span class="gi">+      &gt;&gt;&gt; re.sub(r&#39;\sAND\s&#39;, &#39; &amp; &#39;, &#39;Baked Beans And Spam&#39;, flags=re.IGNORECASE)</span>
    232. 

  232. <span class="gi">+      &#39;Baked Beans &amp; Spam&#39;</span>
    233. 

  233.  
    234. 

  234. <span class="gd">-   The pattern may be a string or an RE object; if you need to specify regular</span>
    235. 

  235. <span class="gd">-   expression flags, you must use a RE object, or use embedded modifiers in a</span>
    236. 

  236. <span class="gd">-   pattern; for example, ``sub(&quot;(?i)b+&quot;, &quot;x&quot;, &quot;bbbb BBBB&quot;)`` returns ``&#39;x x&#39;``.</span>
    237. 

  237. <span class="gi">+   The pattern may be a string or an RE object.</span>
    238. 

  238.  
    239. 

  239.     The optional argument *count* is the maximum number of pattern occurrences to be
    240. 

  240.     replaced; *count* must be a non-negative integer.  If omitted or zero, all
    241. 

  241.     occurrences will be replaced. Empty matches for the pattern are replaced only
    242. 

  242.     when not adjacent to a previous match, so ``sub(&#39;x*&#39;, &#39;-&#39;, &#39;abc&#39;)`` returns
    243. 

  243.     ``&#39;-a-b-c-&#39;``.
    244. 

  244.  
    245. 

  245.     In addition to character escapes and backreferences as described above,
    246. 

  246.     ``\g&lt;name&gt;`` will use the substring matched by the group named ``name``, as
    247. 

  247.     defined by the ``(?P&lt;name&gt;...)`` syntax. ``\g&lt;number&gt;`` uses the corresponding
    248. 

  248.     group number; ``\g&lt;2&gt;`` is therefore equivalent to ``\2``, but isn&#39;t ambiguous
    249. 

  249.     in a replacement such as ``\g&lt;2&gt;0``.  ``\20`` would be interpreted as a
    250. 

  250.     reference to group 20, not a reference to group 2 followed by the literal
    251. 

  251.     character ``&#39;0&#39;``.  The backreference ``\g&lt;0&gt;`` substitutes in the entire
    252. 

  252.     substring matched by the RE.
    253. 

  253.  
    254. 

  254. <span class="gi">+   .. versionchanged:: 2.7</span>
    255. 

  255. <span class="gi">+      Added the optional flags argument.</span>
    256. 

  256.  
    257. 

  257. <span class="gd">-.. function:: subn(pattern, repl, string[, count])</span>
    258. 

  258. <span class="gi">+</span>
    259. 

  259. <span class="gi">+.. function:: subn(pattern, repl, string[, count, flags])</span>
    260. 

  260.  
    261. 

  261.     Perform the same operation as :func:`sub`, but return a tuple ``(new_string,
    262. 

  262.     number_of_subs_made)``.
    263. 

  263.  
    264. 

  264. <span class="gi">+   .. versionchanged:: 2.7</span>
    265. 

  265. <span class="gi">+      Added the optional flags argument.</span>
    266. 

  266. <span class="gi">+</span>
    267. 

  267.  
    268. 

  268.  .. function:: escape(string)
    269. 

  269.  
    270. 

  270.     Return *string* with all non-alphanumerics backslashed; this is useful if you
    271. 

  271.     want to match an arbitrary literal string that may have regular expression
    272. 

  272.     metacharacters in it.
    273. 

  273.  
    274. 

  274.  
    275. 

  275.  .. function:: purge()
    276. 

  276.  
    277. 

  277.     Clear the regular expression cache.
    278. 

  278.  
    279. 

  279. </pre></div>
    280. 

  280. 

  281. </body>
    282. 

  282. </html>
    283.