/locale/ja/LC_MESSAGES/library/re.po

Large files files are truncated, but you can click here to view the full file

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 1990-2013, Python Software Foundation
# This file is distributed under the same license as the Python package.
# 
# Translators:
# Naoki INADA <songofacandy@gmail.com>, 2013
# Masato HASHIMOTO <cabezon.hashimoto@gmail.com>, 2012
# Nozomu Kaneko <nozom.kaneko@gmail.com>, 2012
msgid ""
msgstr ""
"Project-Id-Version: (Deprecated)Python Document Japanese\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2013-12-30 03:15+0900\n"
"PO-Revision-Date: 2013-12-29 18:37+0000\n"
"Last-Translator: Naoki INADA <songofacandy@gmail.com>\n"
"Language-Team: Japanese (http://www.transifex.com/projects/p/python-doc-ja/language/ja/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: ja\n"
"Plural-Forms: nplurals=1; plural=0;\n"

# d8b4772fe4ae4e59afde551d31304908
#: ../../library/re.rst:2
msgid ":mod:`re` --- Regular expression operations"
msgstr ":mod:`re` --- 正規表現操作"

# e4cd8346f4fa46529d50a20dc603c614
#: ../../library/re.rst:10
msgid ""
"This module provides regular expression matching operations similar to those"
" found in Perl."
msgstr "このモジュールでは、Perl などと同様の正規表現マッチング操作を提供しています。"

# a59b3338fd2a4f6e9023c146e6b86d47
#: ../../library/re.rst:13
msgid ""
"Both patterns and strings to be searched can be Unicode strings as well as "
"8-bit strings. However, Unicode strings and 8-bit strings cannot be mixed: "
"that is, you cannot match an Unicode string with a byte pattern or vice-"
"versa; similarly, when asking for a substitution, the replacement string "
"must be of the same type as both the pattern and the search string."
msgstr "パターンと文字列には Unicode 文字列および 8 ビット文字列が使用できます。しかし、Unicode 文字列と8ビット文字列の混在はできません。すなわち、Unicode 文字列をバイト列のパターンでマッチングや、その逆はできません。同様に、置き換え時の置換文字列はパターンおよび検索文字列と同じ型でなくてはなりません。"

# c4edfbaf1d4643bc88552fc112ad5be7
#: ../../library/re.rst:19
msgid ""
"Regular expressions use the backslash character (``'\\'``) to indicate "
"special forms or to allow special characters to be used without invoking "
"their special meaning.  This collides with Python's usage of the same "
"character for the same purpose in string literals; for example, to match a "
"literal backslash, one might have to write ``'\\\\\\\\'`` as the pattern "
"string, because the regular expression must be ``\\\\``, and each backslash "
"must be expressed as ``\\\\`` inside a regular Python string literal."
msgstr "正規表現では、特殊な形式を表したり、特殊文字の持つ特別な意味を呼び出さずにその特殊な文字を使えるようにするために、バックスラッシュ文字 (``'\\'``) を使います。こうしたバックスラッシュの使い方は、Python の文字列リテラルにおける同じバックスラッシュ文字と衝突を起こします。例えば、バックスラッシュ自体にマッチさせるには、パターン文字列として ``'\\\\\\\\'`` と書かなければなりません、というのも、正規表現は ``\\\\`` でなければならず、さらに正規な Python 文字列リテラルでは各々のバックスラッシュを ``\\\\`` と表現しなければならないからです。"

# fad5cf7d641f4f60af640bbd67ca50bf
#: ../../library/re.rst:28
msgid ""
"The solution is to use Python's raw string notation for regular expression "
"patterns; backslashes are not handled in any special way in a string literal"
" prefixed with ``'r'``.  So ``r\"\\n\"`` is a two-character string "
"containing ``'\\'`` and ``'n'``, while ``\"\\n\"`` is a one-character string"
" containing a newline.  Usually patterns will be expressed in Python code "
"using this raw string notation."
msgstr "正規表現パターンに Python の raw 文字列記法を使えばこの問題を解決できます。``'r'`` を前に付けた文字列リテラル内ではバックスラッシュを特別扱いしません。従って、``\"\\n\"`` が改行一文字の入った文字列になるのに対して、``r\"\\n\"`` は ``'\\'`` と ``'n'`` という二つの文字の入った文字列になります。通常、Python コード中では、パターンをこの文字列記法を使って表現します。"

# 99e1dce256c1449791680ba69ce67ae4
#: ../../library/re.rst:35
msgid ""
"It is important to note that most regular expression operations are "
"available as module-level functions and methods on :ref:`compiled regular "
"expressions <re-objects>`.  The functions are shortcuts that don't require "
"you to compile a regex object first, but miss some fine-tuning parameters."
msgstr "大抵の正規表現操作が、モジュールレベルの関数と、 :ref:`コンパイル済み正規表現 <re-objects>` のメソッドとして提供されることに注意して下さい。関数は正規表現オブジェクトのコンパイルを必要としない近道ですが、いくつかのチューニング変数を失います。"

# 5f7940a676084b558c8baeaba0c9bcf5
#: ../../library/re.rst:45
msgid "Mastering Regular Expressions"
msgstr "Mastering Regular Expressions (邦題『詳説 正規表現』)"

# 00769c7daa294964b581be69508dd616
#: ../../library/re.rst:44
msgid ""
"Book on regular expressions by Jeffrey Friedl, published by O'Reilly.  The "
"second edition of the book no longer covers Python at all, but the first "
"edition covered writing good regular expression patterns in great detail."
msgstr "Jeffrey Friedl 著、O'Reilly 刊の正規表現に関する書籍です。この本の第2版では Pyhon については触れていませんが、良い正規表現パターンの書き方を非常に詳しく説明しています。"

# dbf06a20658b43158c8cefb14a917b19
#: ../../library/re.rst:52
msgid "Regular Expression Syntax"
msgstr "正規表現の構文"

# 61ae6ae871fe4e05a8b2faadb1ab413f
#: ../../library/re.rst:54
msgid ""
"A regular expression (or RE) specifies a set of strings that matches it; the"
" functions in this module let you check if a particular string matches a "
"given regular expression (or if a given regular expression matches a "
"particular string, which comes down to the same thing)."
msgstr "正規表現 (RE) は、表現にマッチする文字列の集合を表しています。このモジュールの関数を使えば、ある文字列が指定の正規表現にマッチするか (または指定の正規表現がある文字列にマッチするか、つまりは同じことですが) を検査できます。"

# 8c663ff834604490b8b0722b6c8dcf9a
#: ../../library/re.rst:59
msgid ""
"Regular expressions can be concatenated to form new regular expressions; if "
"*A* and *B* are both regular expressions, then *AB* is also a regular "
"expression. In general, if a string *p* matches *A* and another string *q* "
"matches *B*, the string *pq* will match AB.  This holds unless *A* or *B* "
"contain low precedence operations; boundary conditions between *A* and *B*; "
"or have numbered group references.  Thus, complex expressions can easily be "
"constructed from simpler primitive expressions like the ones described here."
"  For details of the theory and implementation of regular expressions, "
"consult the Friedl book referenced above, or almost any textbook about "
"compiler construction."
msgstr "正規表現を連結すると新しい正規表現を作れます。*A* と *B* がともに正規表現であれば *AB* も正規表現です。一般的に、文字列 *p* が *A* とマッチし、別の文字列 *q* が *B* とマッチすれば、文字列 *pq* は AB にマッチします。ただし、この状況が成り立つのは、*A* と *B* との間に境界条件がある場合や、番号付けされたグループ参照のような、優先度の低い演算を *A* や *B* が含まない場合だけです。このようにして、ここで述べるような、より簡単でプリミティブな正規表現から、複雑な正規表現を容易に構築できます。正規表現に関する理論と実装の詳細については上記の Friedl 本か、コンパイラの構築に関するテキストを参照してください。"

# 118f06bbc0154f0690e5bcc0ab73e6ab
#: ../../library/re.rst:69
msgid ""
"A brief explanation of the format of regular expressions follows.  For "
"further information and a gentler presentation, consult the :ref:`regex-"
"howto`."
msgstr "以下で正規表現の形式に関する簡単な説明をします。より詳細な情報やよりやさしい説明に関しては、:ref:`regex-howto` を参照下さい。"

# e26637a5eb264b9686728a5787ed5dac
#: ../../library/re.rst:72
msgid ""
"Regular expressions can contain both special and ordinary characters. Most "
"ordinary characters, like ``'A'``, ``'a'``, or ``'0'``, are the simplest "
"regular expressions; they simply match themselves.  You can concatenate "
"ordinary characters, so ``last`` matches the string ``'last'``.  (In the "
"rest of this section, we'll write RE's in ``this special style``, usually "
"without quotes, and strings to be matched ``'in single quotes'``.)"
msgstr "正規表現には、特殊文字と通常文字の両方を含めることができます。``'A'``、``'a'``、あるいは ``'0'`` のようなほとんどの通常文字は最も簡単な正規表現になります。こうした文字は、単純にその文字自体にマッチします。通常の文字は連結できるので、``last`` は文字列 ``'last'`` とマッチします。(この節の以降の説明では、正規表現を引用符を使わずに ``この表示スタイル: special style`` で書き、マッチ対象の文字列は、``'引用符で括って'`` 書きます。)"

# 5d38edace05649c781004617a0c08fcc
#: ../../library/re.rst:79
msgid ""
"Some characters, like ``'|'`` or ``'('``, are special. Special characters "
"either stand for classes of ordinary characters, or affect how the regular "
"expressions around them are interpreted. Regular expression pattern strings "
"may not contain null bytes, but can specify the null byte using a "
"``\\number`` notation such as ``'\\x00'``."
msgstr "``'|'`` や ``'('`` といったいくつかの文字は特殊文字です。特殊文字は通常の文字の種別を表したり、あるいは特殊文字の周辺にある通常の文字に対する解釈方法に影響します。正規表現パターン文字列には、null byte を含めることができませんが、``\\number`` 記法や、``'\\x00'`` などとして指定することができます。"

# a1ab48f6bb104618b417e1c0c9f6409a
#: ../../library/re.rst:86
msgid "The special characters are:"
msgstr "特殊文字を以下に示します:"

# 26a82dd2764b41328b515371a844228c
#: ../../library/re.rst:91
msgid "``'.'``"
msgstr "``'.'``"

# 8608ed81d3c5493985b66d12b9cd2909
#: ../../library/re.rst:89
msgid ""
"(Dot.)  In the default mode, this matches any character except a newline.  "
"If the :const:`DOTALL` flag has been specified, this matches any character "
"including a newline."
msgstr "(ドット) デフォルトのモードでは改行以外の任意の文字にマッチします。:const:`DOTALL` フラグが指定されていれば改行も含むすべての文字にマッチします。"

# f494cc2181fd4dcf842afee1a2d42b92
#: ../../library/re.rst:95
msgid "``'^'``"
msgstr "``'^'``"

# 8bc94827e9654c0499a999c82bbc9935
#: ../../library/re.rst:94
msgid ""
"(Caret.)  Matches the start of the string, and in :const:`MULTILINE` mode "
"also matches immediately after each newline."
msgstr "(キャレット) 文字列の先頭とマッチします。:const:`MULTILINE` モードでは各改行の直後にマッチします。"

# d45b11575adb4f40874bec9a04d61366
#: ../../library/re.rst:104
msgid "``'$'``"
msgstr "``'$'``"

# 28dc29f6d1d947dcae511a9291ec26f5
#: ../../library/re.rst:98
msgid ""
"Matches the end of the string or just before the newline at the end of the "
"string, and in :const:`MULTILINE` mode also matches before a newline.  "
"``foo`` matches both 'foo' and 'foobar', while the regular expression "
"``foo$`` matches only 'foo'.  More interestingly, searching for ``foo.$`` in"
" ``'foo1\\nfoo2\\n'`` matches 'foo2' normally, but 'foo1' in "
":const:`MULTILINE` mode; searching for a single ``$`` in ``'foo\\n'`` will "
"find two (empty) matches: one just before the newline, and one at the end of"
" the string."
msgstr "文字列の末尾、あるいは文字列の末尾の改行の直前にマッチします。例えば、``foo`` は 'foo' と 'foobar' の両方にマッチします。一方、正規表現 ``foo$`` は 'foo' だけとマッチします。興味深いことに、``'foo1\\nfoo2\\n'`` を ``foo.$`` で検索した場合、通常のモードでは 'foo2' だけにマッチし、:const:`MULTILINE` モードでは 'foo1' にもマッチします。``$`` だけで ``'foo\\n'`` を検索した場合、2箇所 (内容は空) でマッチします: 1つは、改行の直前で、もう1つは、文字列の最後です。"

# 0d51ecc5ca8b4d4bacbce075998ae2c8
#: ../../library/re.rst:109
msgid "``'*'``"
msgstr "``'*'``"

# a9faee5c42ce4a4d98825857eb3455ec
#: ../../library/re.rst:107
msgid ""
"Causes the resulting RE to match 0 or more repetitions of the preceding RE, "
"as many repetitions as are possible.  ``ab*`` will match 'a', 'ab', or 'a' "
"followed by any number of 'b's."
msgstr "直前にある RE に作用して、RE を 0 回以上できるだけ多く繰り返したものにマッチさせるようにします。例えば ``ab*`` は 'a'、'ab'、あるいは 'a' に任意個数の 'b' を続けたものにマッチします。"

# cf40e6dae9ef4a41bf411dc78dff9889
#: ../../library/re.rst:114
msgid "``'+'``"
msgstr "``'+'``"

# 5643385c828244beb8a76826c0b5c096
#: ../../library/re.rst:112
msgid ""
"Causes the resulting RE to match 1 or more repetitions of the preceding RE. "
"``ab+`` will match 'a' followed by any non-zero number of 'b's; it will not "
"match just 'a'."
msgstr "直前にある RE に作用して、RE を、1 回以上繰り返したものにマッチさせるようにします。例えば ``ab+`` は 'a' に一つ以上の 'b' が続いたものにマッチし、'a' 単体にはマッチしません。"

# 0eb048391e82458d94b7ec75cf9b245b
#: ../../library/re.rst:118
msgid "``'?'``"
msgstr "``'?'``"

# e571b407d7e54c919d3fa12f59b09b79
#: ../../library/re.rst:117
msgid ""
"Causes the resulting RE to match 0 or 1 repetitions of the preceding RE. "
"``ab?`` will match either 'a' or 'ab'."
msgstr "直前にある RE に作用して、RE を 0 回か 1 回繰り返したものにマッチさせるようにします。例えば ``ab?`` は 'a' あるいは 'ab' にマッチします。"

# 36143788b89c461fbdc700b010afd7cd
#: ../../library/re.rst:127
msgid "``*?``, ``+?``, ``??``"
msgstr "``*?``, ``+?``, ``??``"

# 8b5a5f5a760f4ceaa43b35b9d5493d5f
#: ../../library/re.rst:121
msgid ""
"The ``'*'``, ``'+'``, and ``'?'`` qualifiers are all :dfn:`greedy`; they "
"match as much text as possible.  Sometimes this behaviour isn't desired; if "
"the RE ``<.*>`` is matched against ``'<H1>title</H1>'``, it will match the "
"entire string, and not just ``'<H1>'``.  Adding ``'?'`` after the qualifier "
"makes it perform the match in :dfn:`non-greedy` or :dfn:`minimal` fashion; "
"as *few* characters as possible will be matched.  Using ``.*?`` in the "
"previous expression will match only ``'<H1>'``."
msgstr "``'*'`` 、``'+'``、``'?'`` といった修飾子は、すべて :dfn:`貪欲 (greedy)` マッチ、すなわちできるだけ多くのテキストにマッチするようになっています。時にはこの動作が望ましくない場合もあります。例えば正規表現 ``<.*>`` を ``'<H1>title</H1>'`` にマッチさせると、``'<H1>'`` だけにマッチするのではなく全文字列にマッチしてしまいます。``'?'`` を修飾子の後に追加すると、:dfn:`非貪欲 (non-greedy)` あるいは :dfn:`最小一致 (minimal)` のマッチになり、できるだけ *少ない* 文字数のマッチになります。例えば上の式で ``.*?`` を使うと ``'<H1>'`` だけにマッチします。"

# 6971524b463a4f37a058acbcb036060b
#: ../../library/re.rst:132
msgid "``{m}``"
msgstr "``{m}``"

# 48d78f79631a4eca853b7538a3a677f3
#: ../../library/re.rst:130
msgid ""
"Specifies that exactly *m* copies of the previous RE should be matched; "
"fewer matches cause the entire RE not to match.  For example, ``a{6}`` will "
"match exactly six ``'a'`` characters, but not five."
msgstr "前にある RE の *m* 回の正確なコピーとマッチすべきであることを指定します; マッチ回数が少なければ、RE 全体ではマッチしません。例えば、``a{6}`` は、正確に 6 個の ``'a'`` 文字とマッチしますが、5 個ではマッチしません。"

# 0dbe7aac0d654496ac632d490eb32597
#: ../../library/re.rst:141
msgid "``{m,n}``"
msgstr "``{m,n}``"

# 978d8202a0144b1db8ab0e9b5c0725b5
#: ../../library/re.rst:135
msgid ""
"Causes the resulting RE to match from *m* to *n* repetitions of the "
"preceding RE, attempting to match as many repetitions as possible.  For "
"example, ``a{3,5}`` will match from 3 to 5 ``'a'`` characters.  Omitting *m*"
" specifies a lower bound of zero,  and omitting *n* specifies an infinite "
"upper bound.  As an example, ``a{4,}b`` will match ``aaaab`` or a thousand "
"``'a'`` characters followed by a ``b``, but not ``aaab``. The comma may not "
"be omitted or the modifier would be confused with the previously described "
"form."
msgstr "結果の RE は、前にある RE を、*m* 回から *n* 回まで繰り返したもので、できるだけ多く繰り返したものとマッチするように、マッチします。例えば、``a{3,5}`` は、3個から 5個の ``'a'`` 文字とマッチします。*m* を省略するとマッチ回数の下限として0を指定した事になり、*n* を省略することは、上限が無限であることを指定します;  ``a{4,}b`` は ``aaaab`` や、1,000 個の ``'a'`` 文字に ``b`` が続いたものとマッチしますが、``aaab`` とはマッチしません。コンマは省略できません、省略すると修飾子が上で述べた形式と混同されてしまうからです。"

# 2ebd413c87e34ae3bd2886233b826a41
#: ../../library/re.rst:148
msgid "``{m,n}?``"
msgstr "``{m,n}?``"

# 317a68fbdf254c4c84e27255f56a2443
#: ../../library/re.rst:144
msgid ""
"Causes the resulting RE to match from *m* to *n* repetitions of the "
"preceding RE, attempting to match as *few* repetitions as possible.  This is"
" the non-greedy version of the previous qualifier.  For example, on the "
"6-character string ``'aaaaaa'``, ``a{3,5}`` will match 5 ``'a'`` characters,"
" while ``a{3,5}?`` will only match 3 characters."
msgstr "結果の RE は、前にある RE の *m* 回から *n* 回まで繰り返したもので、できるだけ *少なく* 繰り返したものとマッチするように、マッチします。これは、前の修飾子の控え目バージョンです。例えば、6 文字文字列 ``'aaaaaa'`` では、 ``a{3,5}`` は、5 個の ``'a'`` 文字とマッチしますが、``a{3,5}?`` は 3 個の文字とマッチするだけです。"

# 51777eb4738d4618bf7feaf6b7fb061c
#: ../../library/re.rst:161
msgid "``'\\'``"
msgstr "``'\\'``"

# 576b93d56c0b4d7aacbc8410eaa2af4b
#: ../../library/re.rst:151
msgid ""
"Either escapes special characters (permitting you to match characters like "
"``'*'``, ``'?'``, and so forth), or signals a special sequence; special "
"sequences are discussed below."
msgstr "特殊文字をエスケープする (``'*'`` や ``'?'`` 等のような文字とのマッチをできるようにする) か、あるいは、特殊シーケンスの合図です; 特殊シーケンスは後で説明します。"

# 4ecee429ad604581956a13433cef25f6
#: ../../library/re.rst:155
msgid ""
"If you're not using a raw string to express the pattern, remember that "
"Python also uses the backslash as an escape sequence in string literals; if "
"the escape sequence isn't recognized by Python's parser, the backslash and "
"subsequent character are included in the resulting string.  However, if "
"Python would recognize the resulting sequence, the backslash should be "
"repeated twice.  This is complicated and hard to understand, so it's highly "
"recommended that you use raw strings for all but the simplest expressions."
msgstr "もしパターンを表現するのに raw 文字列を使用していないのであれば、Python も、バックスラッシュを文字列リテラルでのエスケープシーケンスとして使っていることを覚えておいて下さい; もしエスケープシーケンスを Python の構文解析器が認識して処理しなければ、そのバックスラッシュとそれに続く文字は、結果の文字列にそのまま含まれます。しかし、もし Python が結果のシーケンスを認識するのであれば、バックスラッシュを 2 回繰り返さなければなりません。このことは複雑で理解しにくいので、最も簡単な表現以外は、すべて raw 文字列を使うことを強く推奨します。"

# f2b925df5b3347b68e2f0f3e6ad9b1df
#: ../../library/re.rst:193
msgid "``[]``"
msgstr "``[]``"

# 5a4f1d25082147889b22b1376da0f86b
#: ../../library/re.rst:164
msgid "Used to indicate a set of characters.  In a set:"
msgstr "文字の集合を指定するのに使用します。集合には以下のものが指定できます:"

# 3fd60fddd6ff4f4c84f1f751fb173292
#: ../../library/re.rst:166
msgid ""
"Characters can be listed individually, e.g. ``[amk]`` will match ``'a'``, "
"``'m'``, or ``'k'``."
msgstr "個別に指定できる文字。``[amk]`` は ``'a'``、``'m'``、または ``'k'`` とマッチします。"

# 14ea04b2480d40779be07f0eb03a994c
#: ../../library/re.rst:169
msgid ""
"Ranges of characters can be indicated by giving two characters and "
"separating them by a ``'-'``, for example ``[a-z]`` will match any lowercase"
" ASCII letter, ``[0-5][0-9]`` will match all the two-digits numbers from "
"``00`` to ``59``, and ``[0-9A-Fa-f]`` will match any hexadecimal digit.  If "
"``-`` is escaped (e.g. ``[a\\-z]``) or if it's placed as the first or last "
"character (e.g. ``[a-]``), it will match a literal ``'-'``."
msgstr "連続した文字の範囲を、先頭と最後の2文字とその間に ``'-'`` を挟んだ形で指定できます。``[a-z]`` はすべての小文字の ASCII 文字とマッチします。``[0-5][0-9]`` は ``00`` から ``59`` までの、すべての 2 桁の数字とマッチします。``[0-9A-Fa-f]`` はすべての 16 進数とマッチします。``-`` が、エスケープされた場合 (例: ``[a\\-z]``)、あるいは先頭か末尾に置かれた場合 (例: ``[a-]``)、リテラル ``'-'`` とマッチします。"

# 9e0fc2c27d8e418e823f774ccb28c4c7
#: ../../library/re.rst:176
msgid ""
"Special characters lose their special meaning inside sets.  For example, "
"``[(+*)]`` will match any of the literal characters ``'('``, ``'+'``, "
"``'*'``, or ``')'``."
msgstr "集合内では、特殊文字はその意味を失います。``[(+*)]`` はリテラル文字 ``'('``、``'+'``、``'*'``、あるいは ``')'`` のいずれかとマッチします。"

# 9e5c6edd7d654dd18ff8e17304284dcf
#: ../../library/re.rst:180
msgid ""
"Character classes such as ``\\w`` or ``\\S`` (defined below) are also "
"accepted inside a set, although the characters they match depends on whether"
" :const:`ASCII` or :const:`LOCALE` mode is in force."
msgstr "``\\w`` や ``\\S`` のような文字クラス (後述) も集合内に指定できますが、それらにマッチする文字は :const:`ASCII` か :const:`LOCALE` のどちらか有効にされているモードに依存します。"

# 9a30dc0ed4f04e758a9bafbc92354e72
#: ../../library/re.rst:184
msgid ""
"Characters that are not within a range can be matched by "
":dfn:`complementing` the set.  If the first character of the set is ``'^'``,"
" all the characters that are *not* in the set will be matched.  For example,"
" ``[^5]`` will match any character except ``'5'``, and ``[^^]`` will match "
"any character except ``'^'``.  ``^`` has no special meaning if it's not the "
"first character in the set."
msgstr "範囲内にない文字とは、その集合の :dfn:`補集合` をとることでマッチできます。集合の最初の文字が ``'^'`` の時、集合に *ない* 文字すべてとマッチします。``[^5]`` は ``'5'`` を除くあらゆる文字にマッチします。``[^^]`` は ``'^'`` を除くあらゆる文字にマッチします。``^`` は集合の最初の文字でない限り特別の意味を持ちません。"

# b5eb496a612840feb9f49a09ce1937ae
#: ../../library/re.rst:191
msgid ""
"To match a literal ``']'`` inside a set, precede it with a backslash, or "
"place it at the beginning of the set.  For example, both ``[()[\\]{}]`` and "
"``[]()[{}]`` will both match a parenthesis."
msgstr "集合内でリテラル ``']'`` をマッチさせるには、その前にバックスラッシュをつけるか、集合の先頭に置きます。``[()[\\]{}]`` と ``[]()[{}]`` はどちらも ``']'`` にマッチします。"

# 7a5e993ecf574f55bd77be3f8f5ecd45
#: ../../library/re.rst:204
msgid "``'|'``"
msgstr "``'|'``"

# 40a73048203148429945b7a955f87227
#: ../../library/re.rst:196
msgid ""
"``A|B``, where A and B can be arbitrary REs, creates a regular expression "
"that will match either A or B.  An arbitrary number of REs can be separated "
"by the ``'|'`` in this way.  This can be used inside groups (see below) as "
"well.  As the target string is scanned, REs separated by ``'|'`` are tried "
"from left to right. When one pattern completely matches, that branch is "
"accepted. This means that once ``A`` matches, ``B`` will not be tested "
"further, even if it would produce a longer overall match.  In other words, "
"the ``'|'`` operator is never greedy.  To match a literal ``'|'``, use "
"``\\|``, or enclose it inside a character class, as in ``[|]``."
msgstr "``A|B`` (A と B は任意の RE) は、A か B のどちらかとマッチする正規表現を作成します。任意個数の RE を、このように ``'|'`` で分離することができます。これはグループ (下記参照) 内部でも使えます。走査対象文字列をスキャンする中で、``'|'`` で分離された RE は左から右への順に走査されます。一つでも完全にマッチしたパターンがあれば、そのパターン枝が受理されます。このことは、もし ``A`` がマッチすれば、たとえ ``B`` によるマッチが全体としてより長いマッチになったとしても、``B`` を決して走査しないことを意味します。言いかえると、``'|'`` 演算子は決して貪欲 (greedy) にはなりません。リテラル ``'|'`` とマッチするには、``\\|`` を使うか、あるいは ``[|]`` のように文字クラス内に入れます。"

# d33d91b6a3094c3fbb7ed154485c5c0d
#: ../../library/re.rst:211
msgid "``(...)``"
msgstr "``(...)``"

# 630d185934a84fe89eb5652a7d9f1f9e
#: ../../library/re.rst:207
msgid ""
"Matches whatever regular expression is inside the parentheses, and indicates"
" the start and end of a group; the contents of a group can be retrieved "
"after a match has been performed, and can be matched later in the string "
"with the ``\\number`` special sequence, described below.  To match the "
"literals ``'('`` or ``')'``, use ``\\(`` or ``\\)``, or enclose them inside "
"a character class: ``[(] [)]``."
msgstr "丸括弧の中にどのような正規表現があってもマッチし、丸括弧はグループの開始と終了を表します; グループの中身は、マッチが実行された後に回収され、特殊シーケンス ``\\number`` (後述) で参照することができます。リテラル ``'('`` や ``')'`` とマッチするには、``\\(`` や ``\\)`` を使うか、それらを文字クラス内に入れます:  ``[(] [)]``。"

# a7df3b3b5c1040d5a65df67cc86b098c
#: ../../library/re.rst:218
msgid "``(?...)``"
msgstr "``(?...)``"

# d0889816d7164b589720d8c3ad863c6b
#: ../../library/re.rst:214
msgid ""
"This is an extension notation (a ``'?'`` following a ``'('`` is not "
"meaningful otherwise).  The first character after the ``'?'`` determines "
"what the meaning and further syntax of the construct is. Extensions usually "
"do not create a new group; ``(?P<name>...)`` is the only exception to this "
"rule. Following are the currently supported extensions."
msgstr "これは拡張記法です (``'('`` に続く ``'?'`` は他に意味がありません)。``'?'`` の後の最初の文字が、この構造の意味とこれ以上の構文がどういうものかを決定します。拡張記法は通常新しいグループを作成しません; ``(?P<name>...)`` がこの規則の唯一の例外です。以下に現在サポートされている拡張記法を示します。"

# 1708254eb3ae44ebb8e472e11311bc4e
#: ../../library/re.rst:235
msgid "``(?aiLmsux)``"
msgstr "``(?aiLmsux)``"

# 8be153d589854d559d889aada2c2e95a
#: ../../library/re.rst:221
msgid ""
"(One or more letters from the set ``'a'``, ``'i'``, ``'L'``, ``'m'``, "
"``'s'``, ``'u'``, ``'x'``.)  The group matches the empty string; the letters"
" set the corresponding flags: :const:`re.A` (ASCII-only matching), "
":const:`re.I` (ignore case), :const:`re.L` (locale dependent), :const:`re.M`"
" (multi-line), :const:`re.S` (dot matches all), and :const:`re.X` (verbose),"
" for the entire regular expression. (The flags are described in :ref"
":`contents-of-module-re`.) This is useful if you wish to include the flags "
"as part of the regular expression, instead of passing a *flag* argument to "
"the :func:`re.compile` function."
msgstr "(集合 ``'a'``, ``'i'``, ``'L'``, ``'m'``, ``'s'``, ``'u'``, ``'x'`` から1文字以上)。グループは空文字列ともマッチします; 文字は、正規表現全体の対応するフラグ :const:`re.A` (ASCII 限定マッチ)、:const:`re.I` (大文字・小文字を区別しない)、:const:`re.L` (ロケール依存)、:const:`re.M` (MULTILINE モード)、:const:`re.S` (DOTALL モード)、および :const:`re.X` (冗長) を設定します (フラグについては :ref:`contents-of-module-re` を参照)。これは、*flag* 引数を :func:`re.compile` 関数に渡すのではなく、そのフラグを正規表現の一部に含めたい場合に役立ちます。"

# 3356bb20b9a64e1885c9458ab5cd205b
#: ../../library/re.rst:232
msgid ""
"Note that the ``(?x)`` flag changes how the expression is parsed. It should "
"be used first in the expression string, or after one or more whitespace "
"characters. If there are non-whitespace characters before the flag, the "
"results are undefined."
msgstr "``(?x)`` フラグは、表現の解析方法を変更することに注意して下さい。これは表現文字列内の最初か、あるいは 1 つ以上の空白文字の後で使うべきです。このフラグの前に非空白文字がある場合の結果は定義されていません。"

# b537ffceadc74458a8fb953d03447166
#: ../../library/re.rst:241
msgid "``(?:...)``"
msgstr "``(?:...)``"

# 91d58d5966dd4d6f9015bcdeac79f46b
#: ../../library/re.rst:238
msgid ""
"A non-capturing version of regular parentheses.  Matches whatever regular "
"expression is inside the parentheses, but the substring matched by the group"
" *cannot* be retrieved after performing a match or referenced later in the "
"pattern."
msgstr "正規表現の丸括弧をキャプチャしないバージョンです。丸括弧内にどのような正規表現があってもマッチしますが、グループにマッチされたサブ文字列は、マッチを実行したあと回収することも、後でパターンで参照することも *できません* 。"

# bc1dc008103c49cbbb537dddca93d608
#: ../../library/re.rst:266
msgid "``(?P<name>...)``"
msgstr "``(?P<name>...)``"

# 7a19633ed134421499d054b19e203a61
#: ../../library/re.rst:244
msgid ""
"Similar to regular parentheses, but the substring matched by the group is "
"accessible via the symbolic group name *name*.  Group names must be valid "
"Python identifiers, and each group name must be defined only once within a "
"regular expression.  A symbolic group is also a numbered group, just as if "
"the group were not named."
msgstr ""

# 04cf130d38824980878d42d41e8a2a0f
#: ../../library/re.rst:250
msgid ""
"Named groups can be referenced in three contexts.  If the pattern is "
"``(?P<quote>['\"]).*?(?P=quote)`` (i.e. matching a string quoted with either"
" single or double quotes):"
msgstr ""

# 5cae64a3a4a746c7bc3d8c01628e6929
#: ../../library/re.rst:255
msgid "Context of reference to group \"quote\""
msgstr ""

# f8fdcc747ac04e499eac18d1bebdf503
#: ../../library/re.rst:255
msgid "Ways to reference it"
msgstr ""

# f8a0715fb18b48748489508badec1c83
#: ../../library/re.rst:257
msgid "in the same pattern itself"
msgstr ""

# fb2cc376e29d4f8890971e679b44f7c8
#: ../../library/re.rst:257
msgid "``(?P=quote)`` (as shown)"
msgstr ""

# f2c4eb67a17c44d5afbe62f25f59bfdf
# 17074ddecda34b9197417daea44eef82
#: ../../library/re.rst:258 ../../library/re.rst:265
msgid "``\\1``"
msgstr ""

# b26ba6a3de264a798645adc3ab3eef01
#: ../../library/re.rst:260
msgid "when processing match object ``m``"
msgstr ""

# 38507046b8f74e858133c539c8efb1d6
#: ../../library/re.rst:260
msgid "``m.group('quote')``"
msgstr ""

# 36773553c0424650af95b27596cfc367
#: ../../library/re.rst:261
msgid "``m.end('quote')`` (etc.)"
msgstr ""

# e83c33022f6b4ba4b89efd8f4c2d84a0
#: ../../library/re.rst:263
msgid "in a string passed to the ``repl`` argument of ``re.sub()``"
msgstr ""

# 9a02dc5441ae4e82b844699f3cbbf8bc
#: ../../library/re.rst:263
msgid "``\\g<quote>``"
msgstr ""

# dd9560b9d0824d08b714d5cf45734e93
#: ../../library/re.rst:264
msgid "``\\g<1>``"
msgstr ""

# 01e71a73c09b4a10b6f2165417931f8c
#: ../../library/re.rst:270
msgid "``(?P=name)``"
msgstr "``(?P=name)``"

# 230694368ab043feb148c6a26a5ad6f0
#: ../../library/re.rst:269
msgid ""
"A backreference to a named group; it matches whatever text was matched by "
"the earlier group named *name*."
msgstr ""

# 783e6e03ca014cfeb0162315bda9defd
#: ../../library/re.rst:273
msgid "``(?#...)``"
msgstr "``(?#...)``"

# 0b10267e754c478d8ddf23f9ddddec2e
#: ../../library/re.rst:273
msgid "A comment; the contents of the parentheses are simply ignored."
msgstr "コメントです; 括弧の内容は無視されます。"

# fa4dab5d027a4962b3298cdcf854ddab
#: ../../library/re.rst:278
msgid "``(?=...)``"
msgstr "``(?=...)``"

# e9c1f4d1c99644788217488345b30080
#: ../../library/re.rst:276
msgid ""
"Matches if ``...`` matches next, but doesn't consume any of the string.  "
"This is called a lookahead assertion.  For example, ``Isaac (?=Asimov)`` "
"will match ``'Isaac '`` only if it's followed by ``'Asimov'``."
msgstr "``...`` が次に続くものとマッチすればマッチしますが、文字列をまったく消費しません。これは先読みアサーション (lookahead assertion) と呼ばれます。例えば、``Isaac (?=Asimov)`` は、``'Isaac '`` に ``'Asimov'`` が続く場合だけ、``'Isaac '`` とマッチします。"

# a7ae214b9fc84adcb9d5a857f48da399
#: ../../library/re.rst:283
msgid "``(?!...)``"
msgstr "``(?!...)``"

# 1f67431bb2c6475e896a33cbeeac4107
#: ../../library/re.rst:281
msgid ""
"Matches if ``...`` doesn't match next.  This is a negative lookahead "
"assertion. For example, ``Isaac (?!Asimov)`` will match ``'Isaac '`` only if"
" it's *not* followed by ``'Asimov'``."
msgstr "``...`` が次に続くものとマッチしなければマッチします。これは否定先読みアサーション (negative lookahead assertion) です。例えば、``Isaac (?!Asimov)`` は、``'Isaac '`` に ``'Asimov'`` が続か *ない* 場合のみマッチします。"

# 75976af3d26d4b669d54ec944d496eb3
#: ../../library/re.rst:305
msgid "``(?<=...)``"
msgstr "``(?<=...)``"

# 3faeae5d2593422c86d4dece0ba05ea8
#: ../../library/re.rst:286
msgid ""
"Matches if the current position in the string is preceded by a match for "
"``...`` that ends at the current position.  This is called a :dfn:`positive "
"lookbehind assertion`. ``(?<=abc)def`` will find a match in ``abcdef``, "
"since the lookbehind will back up 3 characters and check if the contained "
"pattern matches. The contained pattern must only match strings of some fixed"
" length, meaning that ``abc`` or ``a|b`` are allowed, but ``a*`` and "
"``a{3,4}`` are not.  Note that patterns which start with positive lookbehind"
" assertions will not match at the beginning of the string being searched; "
"you will most likely want to use the :func:`search` function rather than the"
" :func:`match` function:"
msgstr "文字列内の現在位置の前に、現在位置で終わる ``...`` とのマッチがあれば、マッチします。これは :dfn:`後読みアサーション` と呼ばれます。``(?<=abc)def`` は ``abcdef`` にマッチを見つけます。後読みは 3 文字をバックアップし、含まれているパターンとマッチするかどうか検査します。含まれるパターンは、固定長の文字列にのみマッチしなければなりません。すなわち、``abc`` や ``a|b`` は許されますが、``a*`` や ``a{3,4}`` は許されません。肯定後読みアサーションで始まるパターンは、検索される文字列の先頭とは決してマッチしないことに注意して下さい; この表現を使用するのは、おそらく :func:`match` 関数より :func:`search` 関数の方が適しています:"

# 1706c17163514a5294e844f6d1a990e2
#: ../../library/re.rst:301
msgid "This example looks for a word following a hyphen:"
msgstr "この例ではハイフンに続く単語を探します:"

# c105d6ac08bb447fa31dcece73070b3f
#: ../../library/re.rst:312
msgid "``(?<!...)``"
msgstr "``(?<!...)``"

# 5484e8a54f7146c5bb88d3dc911966d8
#: ../../library/re.rst:308
msgid ""
"Matches if the current position in the string is not preceded by a match for"
" ``...``.  This is called a :dfn:`negative lookbehind assertion`.  Similar "
"to positive lookbehind assertions, the contained pattern must only match "
"strings of some fixed length.  Patterns which start with negative lookbehind"
" assertions may match at the beginning of the string being searched."
msgstr "文字列内の現在位置の前に ``...`` とのマッチがない場合に、マッチします。これは :dfn:`否定後読みアサーション(negative lookbehind assertion)` と呼ばれます。肯定後読みアサーションと同様に、含まれるパターンは固定長さの文字列だけにマッチしなければなりません。否定後読みアサーションで始まるパターンは、検索される文字列の先頭とマッチできます。"

# ab4fd2f3059b4f569d8238e12b351e18
#: ../../library/re.rst:321
msgid "``(?(id/name)yes-pattern|no-pattern)``"
msgstr "``(?(id/name)yes-pattern|no-pattern)``"

# a7f540eb6d0946e9a888cc8899207581
#: ../../library/re.rst:315
msgid ""
"Will try to match with ``yes-pattern`` if the group with given *id* or "
"*name* exists, and with ``no-pattern`` if it doesn't. ``no-pattern`` is "
"optional and can be omitted. For example, "
"``(<)?(\\w+@\\w+(?:\\.\\w+)+)(?(1)>|$)`` is a poor email matching pattern, "
"which will match with ``'<user@host.com>'`` as well as ``'user@host.com'``, "
"but not with ``'<user@host.com'`` nor ``'user@host.com>'``."
msgstr ""

# edd2b8a8704249e1b8652410d69b7a7f
#: ../../library/re.rst:323
msgid ""
"The special sequences consist of ``'\\'`` and a character from the list "
"below. If the ordinary character is not on the list, then the resulting RE "
"will match the second character.  For example, ``\\$`` matches the character"
" ``'$'``."
msgstr "特殊シーケンスは ``'\\'`` と以下のリストの文字から構成されます。リストにない通常文字の場合 RE は 2 番目の文字とマッチします。例えば、``\\$`` は文字 ``'$'`` とマッチします。"

# 780018588a6847089545672f09c3741f
#: ../../library/re.rst:335
msgid "``\\number``"
msgstr "``\\number``"

# e117423d8d3041329ea7b07f041592f5
#: ../../library/re.rst:328
msgid ""
"Matches the contents of the group of the same number.  Groups are numbered "
"starting from 1.  For example, ``(.+) \\1`` matches ``'the the'`` or ``'55 "
"55'``, but not ``'thethe'`` (note the space after the group).  This special "
"sequence can only be used to match one of the first 99 groups.  If the first"
" digit of *number* is 0, or *number* is 3 octal digits long, it will not be "
"interpreted as a group match, but as the character with octal value "
"*number*. Inside the ``'['`` and ``']'`` of a character class, all numeric "
"escapes are treated as characters."
msgstr ""

# eddd7c0e2752450f9628234b1e2646ba
#: ../../library/re.rst:338
msgid "``\\A``"
msgstr "``\\A``"

# 8be782690a754cdea3d5cf2c8dcb3596
#: ../../library/re.rst:338
msgid "Matches only at the start of the string."
msgstr "文字列の先頭だけにマッチします。"

# b95dcfc643ca4195a2147fac10658e11
#: ../../library/re.rst:353
msgid "``\\b``"
msgstr "``\\b``"

# 82107550c05b44b1b5b0eaabc5e4d52b
#: ../../library/re.rst:341
msgid ""
"Matches the empty string, but only at the beginning or end of a word. A word"
" is defined as a sequence of Unicode alphanumeric or underscore characters, "
"so the end of a word is indicated by whitespace or a non-alphanumeric, non-"
"underscore Unicode character.  Note that formally, ``\\b`` is defined as the"
" boundary between a ``\\w`` and a ``\\W`` character (or vice versa), or "
"between ``\\w`` and the beginning/end of the string. This means that "
"``r'\\bfoo\\b'`` matches ``'foo'``, ``'foo.'``, ``'(foo)'``, ``'bar foo "
"baz'`` but not ``'foobar'`` or ``'foo3'``."
msgstr "空文字列とマッチしますが、単語の先頭か末尾の時だけです。単語とは Unicode 英数字 (日本語など英字以外も含む非記号) またはアンダースコアからなるシーケンスで、単語の終わりは空白文字、あるいはアンダースコアを除く記号で表します。``\\\\b`` は ``\\\\w`` および ``\\\\W`` の間 (およびその逆) あるいは ``\\\\w`` と文字列の開始/終了との間の境界として定義されています。例えば、``r'\\\\bfoo\\\\b'`` は ``'foo'``、``'foo.'``、``'(foo)'``、``'bar foo baz'`` にマッチしますが、``'foobar'`` や ``'foo3'`` にはマッチしません。"

# b1f8bba1f14e499da80f7369cb962f71
#: ../../library/re.rst:350
msgid ""
"By default Unicode alphanumerics are the ones used, but this can  be changed"
" by using the :const:`ASCII` flag.  Inside a character range, ``\\b`` "
"represents the backspace character, for compatibility with Python's string "
"literals."
msgstr "デフォルトでは、Unicode 英数字 (日本語など英字以外も含む非記号) が使用されますが、これは :const:`ASCII` フラグを使って ASCII に限定できます。文字範囲内では、``\\\\b`` は Python の文字列リテラルとの互換性のため、後退 (backspace) 文字を表します。"

# fba105aaf66a40ae90f1be2db403d366
#: ../../library/re.rst:361
msgid "``\\B``"
msgstr "``\\B``"

# 48e0e2202f3e4fa0a0c4e91cf36bd42f
#: ../../library/re.rst:356
msgid ""
"Matches the empty string, but only when it is *not* at the beginning or end "
"of a word.  This means that ``r'py\\B'`` matches ``'python'``, ``'py3'``, "
"``'py2'``, but not ``'py'``, ``'py.'``, or ``'py!'``. ``\\B`` is just the "
"opposite of ``\\b``, so word characters are Unicode alphanumerics or the "
"underscore, although this can be changed by using the :const:`ASCII` flag."
msgstr "空文字列とマッチしますが、それが単語の先頭あるいは末尾に *ない* 時だけです。``r'py\\\\B'`` は ``'python'``、``'py3'``、``'py2'`` にはマッチしますが、``'py'``、``'py.'``、あるいは ``'py!'`` にはマッチしません。``\\\\B`` は ``\\\\b`` のちょうど反対で、単語の文字は Unicode 英数字 (日本語など英字以外も含む非記号) またはアンダースコアですが、:const:`ASCII` フラグで ASCII に限定できます。"

# 00d966883406411984f8add175326807
#: ../../library/re.rst:372
msgid "``\\d``"
msgstr "``\\d``"

# 63211587d977418d9a3c0f03fba0a89f
# 5f75052176224188b5e696c2c9f4467e
# e2fd59dec88244bf94353621c9030ec4
#: ../../library/re.rst:369 ../../library/re.rst:389 ../../library/re.rst:408
msgid "For Unicode (str) patterns:"
msgstr "ユニコード (str) パターンに対して:"

# 70979492aa214a25b197a7170270b4a5
#: ../../library/re.rst:365
msgid ""
"Matches any Unicode decimal digit (that is, any character in Unicode "
"character category [Nd]).  This includes ``[0-9]``, and also many other "
"digit characters.  If the :const:`ASCII` flag is used only ``[0-9]`` is "
"matched (but the flag affects the entire regular expression, so in such "
"cases using an explicit ``[0-9]`` may be a better choice)."
msgstr "任意の Unicode 10進数 (Unicode 文字カテゴリ [Nd]) とマッチします。これには ``[0-9]`` とその他の 10 進数文字が含まれます。:const:`ASCII` が使用された場合、``[0-9]`` のみマッチします。ただし、このフラグは正規表現全体に作用しますので、明示的に ``[0-9]`` と指定する方が良い場合があるかもしれません。"

# 677c73e1ff5942818f7d604caca97009
# 2580599ab76c4d25bb0799238e1efaaf
# ff8ba2d87b174a67bc0d11043179a679
#: ../../library/re.rst:372 ../../library/re.rst:393 ../../library/re.rst:412
msgid "For 8-bit (bytes) patterns:"
msgstr "8bit (bytes) パターンに対して:"

# e26fbf2fe2ab4786b901bb670e1db454
#: ../../library/re.rst:372
msgid "Matches any decimal digit; this is equivalent to ``[0-9]``."
msgstr "任意の 10 進数にマッチします; これは ``[0-9]`` と等価です。"

# 06808ee418e6430297a65475a6411237
#: ../../library/re.rst:379
msgid "``\\D``"
msgstr "``\\D``"

# 3f0e6b380c5344c3a15c0273a7cc6f2d
#: ../../library/re.rst:375
msgid ""
"Matches any character which is not a Unicode decimal digit. This is the "
"opposite of ``\\d``. If the :const:`ASCII` flag is used this becomes the "
"equivalent of ``[^0-9]`` (but the flag affects the entire regular "
"expression, so in such cases using an explicit ``[^0-9]`` may be a better "
"choice)."
msgstr "任意の非 Unicode 10 進数文字にマッチします。これは ``\\\\d`` の反対です。:const:`ASCII` フラグを使用すると ``[^0-9]`` と等価になります。ただし、このフラグは正規表現全体に作用しますので、明示的に ``[^0-9]`` と指定する方が良い場合があるかもしれません。"

# 3a4d3cfe12204e2281d5a2abc6ac6b78
#: ../../library/re.rst:393
msgid "``\\s``"
msgstr "``\\s``"

# b69082445df242eba01cc028d3144c01
#: ../../library/re.rst:383
msgid ""
"Matches Unicode whitespace characters (which includes ``[ "
"\\t\\n\\r\\f\\v]``, and also many other characters, for example the non-"
"breaking spaces mandated by typography rules in many languages). If the "
":const:`ASCII` flag is used, only ``[ \\t\\n\\r\\f\\v]`` is matched (but the"
" flag affects the entire regular expression, so in such cases using an "
"explicit ``[ \\t\\n\\r\\f\\v]`` may be a better choice)."
msgstr "任意の空白文字とマッチします。これには ``[ \\t\\n\\r\\f\\v]`` およびノーブレークスペースなど、多くの言語におけるタイポグラフィ規則で定義された文字が含まれます。:const:`ASCII` フラグを使用すると、``[ \\\\t\\\\n\\\\r\\\\f\\\\v]`` のみにマッチします。ただし、このフラグは正規表現全体に作用しますので、明示的に ``[ \\t\\n\\r\\f\\v]`` と指定する方が良い場合があるかもしれません。"

# 6db52065fde34619aee867de5e0ae2c7
#: ../../library/re.rst:392
msgid ""
"Matches characters considered whitespace in the ASCII character set; this is"
" equivalent to ``[ \\t\\n\\r\\f\\v]``."
msgstr "ASCII 文字セットにおける空白文字とマッチします。これは ``[ \\t\\n\\r\\f\\v]`` と等価です。"

# f0d26fcd41f7404082070ff95338154a
#: ../../library/re.rst:400
msgid "``\\S``"
msgstr "``\\S``"

# 2326189b52fe4f7289566a88381f7bed
#: ../../library/re.rst:396
msgid ""
"Matches any character which is not a Unicode whitespace character. This is "
"the opposite of ``\\s``. If the :const:`ASCII` flag is used this becomes the"
" equivalent of ``[^ \\t\\n\\r\\f\\v]`` (but the flag affects the entire "
"regular expression, so in such cases using an explicit ``[^ "
"\\t\\n\\r\\f\\v]`` may be a better choice)."
msgstr "任意の非空白文字にマッチします。これは ``\\s`` の反対です。:const:`ASCII` フラグを使用すると ``[^ \\t\\n\\r\\f\\v]`` と等価になります。ただし、このフラグは正規表現全体に作用しますので、明示的に ``[^ \\t\\n\\r\\f\\v]`` と指定する方が良い場合があるかもしれません。"

# 4a7c50e43eff43c4bc0ca6d291c5d495
#: ../../library/re.rst:412
msgid "``\\w``"
msgstr "``\\w``"
…

Large files files are truncated, but you can click here to view the full file