Python 正規表現 re モジュールの詳細な紹介
- WBOYオリジナル
- 2016-06-16 08:44:061256ブラウズ
本模块提供了和Perl里的正则表达式类似的功能，不关是正则表达式本身还是被搜索的字符串，都可以是Unicode字符，这点不用担心，python会处理地和Ascii字符一样漂亮。
正则表达式使用反斜杆（\）来转义特殊字符，使其可以匹配字符本身，而不是指定其他特殊的含义。这可能会和python字面意义上的字符串转义相冲突，这也许有些令人费解。比如，要匹配一个反斜杆本身，你也许要用'\\\\'来做为正则表达式的字符串，因为正则表达式要是\\，而字符串里，每个反斜杆都要写成\\。
你也可以在字符串前加上 r 这个前缀来避免部分疑惑，因为 r 开头的python字符串是 raw 字符串，所以里面的所有字符都不会被转义，比如r'\n'这个字符串就是一个反斜杆加上一字母n，而'\n'我们知道这是个换行符。因此，上面的'\\\\'你也可以写成r'\\'，这样，应该就好理解很多了。可以看下面这段：
>>> import re
>>> s = '\x5c' #0x5c就是反斜杆
>>> print s
\
>>> re.match('\\\\', s) #这样可以匹配
<_sre.SRE_Match object at 0xb6949e20>
>>> re.match(r'\\', s) #这样也可以
<_sre.SRE_Match object at 0x80ce2c0>
>>> re.match('\\', s) #但是这样不行
Traceback (most recent call last):
File "
File "/usr/lib/python2.6/re.py", line 137, in match
return _compile(pattern, flags).match(string)
File "/usr/lib/python2.6/re.py", line 245, in _compile
raise error, v # invalid expression
sre_constants.error: bogus escape (end of line)
>>>
另外值得一提的是，re模块的方法，大多也就是RegexObject对象的方法，两者的区别在于执行效率。这个在最后再展开吧。
正则表达式语法
正则表达式（RE）指定一个与之匹配的字符集合；本模块所提供的函数，将可以用来检查所给的字符串是否与指定的正则表达式匹配。
正则表达式可以被连接，从而形成新的正则表达式；例如A和B都是正则表达式，那么AB也是正则表达式。一般地，如果字符串p与A匹配，q与B匹配的话，那么字符串pq也会与AB匹配，但A或者B里含有边界限定条件或者命名组操作的情况除外。也就是说，复杂的正则表达式可以用简单的连接而成。
正则表达式可以包含特殊字符和普通字符，大部分字符比如'A'，'a'和'0'都是普通字符，如果做为正则表达式，它们将匹配它们本身。由于正则表达式可以连接，所以连接多个普通字符而成的正则表达式last也将匹配'last'。（后面将用不带引号的表示正则表达式，带引号的表示字符串）
下面就来介绍正则表达式的特殊字符：
'.'
点号，在普通模式，它匹配除换行符外的任意一个字符；如果指定了 DOTALL 标记，匹配包括换行符以内的任意一个字符。
'^'
尖尖号，匹配一个字符串的开始，在 MULTILINE 模式下，也将匹配任意一个新行的开始。
'$'
美元符号，匹配一个字符串的结尾或者字符串最后面的换行符，在 MULTILINE 模式下，也匹配任意一行的行尾。也就是说，普通模式下，foo.$去搜索'foo1\nfoo2\n'只会找到'foo2′，但是在 MULTILINE 模式，还能找到 ‘foo1′，而且就用一个 $ 去搜索'foo\n'的话，会找到两个空的匹配：一个是最后的换行符，一个是字符串的结尾，演示：
>>> re.findall('(foo.$)', 'foo1\nfoo2\n')
['foo2']
>>> re.findall('(foo.$)', 'foo1\nfoo2\n', re.MULTILINE)
['foo1', 'foo2']
>>> re.findall('($)', 'foo\n')
['', '']
'*'
星号，指定将前面的RE重复0次或者任意多次，而且总是试图尽量多次地匹配。
'+'
加号，指定将前面的RE重复1次或者任意多次，而且总是试图尽量多次地匹配。
'?'
问号，指定将前面的RE重复0次或者1次，如果有的话，也尽量匹配1次。
*?, +?, ??
前の説明から、「*」、「+」、「?」はすべて貪欲であることがわかりますが、これはそうではない可能性があります。これは「はい」を意味するので、最後に疑問符を追加し、戦略を非貪欲に変更し、可能な限り少数の RE のみと一致させることができます。 2 つの違いを理解するための例:
>>> re.findall( '<(.*)>', '
title
')['H1>title>>> .findall(' <(.*?)>', '
title
')['H1', '/H1']
{m}
m は、前の RE を m 回繰り返すことを指定する数値です。
{m,n}
m と n は両方とも数値で、前の RE を m ～ n 回繰り返すように指定します。たとえば、a{3,5} は 3 ～ 5 つの連続する a に一致します。 。 m が省略された場合は、0 から n 個の以前の RE が照合され、n が省略された場合は、n から無限個までの以前の RE が照合されます。もちろん、中間のカンマは省略できません。省略しない場合は、前の形式になります。
{m,n}?
前述の {m,n} も、{3,5} に 5 つ以上の連続する a がある場合、そのうちの 5 つと一致します。 . 、これは疑問符を追加することで変更することもできます。 a{3,5}? は、可能であれば 3 a のみに一致します。
''
バックスラッシュ、'*'、'?' などの特殊文字をエスケープするか、特殊なシーケンスを指定します (詳細は後述)
前述の理由により、正規表現を表現するには生の文字列を使用することを強くお勧めします。
[]
角括弧。文字のセットを指定するために使用されます。文字は個別にリストすることも、「-」を使用して開始文字と終了文字を接続して範囲を表すこともできます。たとえば、[akm$] は文字「a」、「k」、「m」、または「$」を表し、$ も通常の文字に変換されます。 [a-z] は任意の小文字に一致し、[a-zA-Z0-9] は任意の文字または数字に一致します。 「]」または「-」そのものと一致させたい場合は、バックスラッシュでエスケープするか、角括弧の前に置く必要があります。たとえば、[]] は「]」と一致します。
また、文字セットは、この文字セットにない文字と一致するように否定されます。否定演算は、他の場所に配置された文字セットの先頭に「^」を置くことによって表されます。これは特別な役割を果たしません。たとえば、[^5] は「5」以外の任意の文字と一致し、[^^] は「^」以外の任意の文字と一致します。
注: 角括弧内の +、*、(,) などの文字は特別な意味を失い、通常の文字としてのみ使用されます。後方参照も角括弧内で使用できません。
'|'
パイプ シンボル、A と B は任意の RE、A|B は A または B に一致する新しい RE です。このようにパイプ記号で区切って任意の数の RE を接続できます。このフォームはグループで使用できます (詳細は後ほど)。ターゲット文字列については、'|' で区切られた RE が左から右に 1 つずつテストされ、1 つのテストが成功すると、後続の RE がより長い文字列に一致する場合でもテストされなくなります。つまり、「|」演算子は貪欲ではありません。リテラル '|' と一致させるには、バックスラッシュでエスケープするか (|)、後角括弧で囲みます ([|])。
(...)
は、括弧内で一致する RE の内容と一致し、グループの開始位置と終了位置を指定します。グループ内のコンテンツを抽出したり、後続の照合に数値などの特別なシーケンスを使用したりできます。リテラルの「(」と「)」を一致させるには、バックスラッシュ (,) でエスケープするか、[(], [)] のように後ろ括弧で囲みます。
(?...)
これは式の展開記号です。 「?」の後の最初の文字は、式全体の構文と意味を決定します。(?P...) を除き、式は新しいグループを生成しません。現在サポートされている拡張機能をいくつか示します:
(?iLmsux)
「i」、「L」、「m」、「s」、「u」、「x」の 1 つ以上の文字。この式はどの文字にも一致しませんが、対応するフラグ: re.I (大文字と小文字を無視)、re.L (ロケールに依存)、re.M (複数行モード)、re.S (. はすべての文字に一致)、re を指定します。 .U (Unicode に依存)、re.X (冗長モード)。各モードの違いについては、以下の特別セクションで紹介します。 re.compile() または呼び出し時に flag パラメーターを指定する代わりに、この構文を使用します。
たとえば、上記の例は次のように書き換えることができます (re.MULTILINE を指定したのと同じ効果):
>>> re.findall('(?m)(foo.$)', 'foo1nfoo2n')
['foo1', 'foo2']
また、(?x)マークがある場合は必ず前に配置してください。
(?:...)
は、内部 RE が一致するものと一致しますが、グループは作成されません。
(?P
デモ:
>>> m=re.match('(?P[a-zA-Z_]\w*)', 'abc=123')
>>> m.group('var')
'abc'
>>> m.group(1)
'abc'
(?P=name)
匹配之前以name命名的组里的内容。
演示一下：
>>> re.match('<(?P
xxx') #这个不匹配
>>> re.match('<(?P\w*)>.*', 'xxx
') #这个匹配
<_sre.SRE_Match object at 0xb69588e0>
(?#...)
注释，圆括号里的内容会被忽略。
(?=...)
如果 ... 匹配接下来的字符，才算匹配，但是并不会消耗任何被匹配的字符。例如 Isaac (?=Asimov) 只会匹配后面跟着 'Asimov' 的 'Isaac '，这个叫做“前瞻断言”。
(?!...)
和上面的相反，只匹配接下来的字符串不匹配 ... 的串，这叫做“反前瞻断言”。
(?<=...)
只有当当前位置之前的字符串匹配 ... ，整个匹配才有效，这叫“后顾断言”。字符串'abcdef'可以匹配正则(?<=abc)def，因为会后向查找3个字符，看是否为abc。所以内置的子RE，需要是固定长度的，比如可以是abc、a|b，但不能是a*、a{3,4}。注意这种RE永远不会匹配到字符串的开头。举个例子，找到连字符（'-'）后的单词：
复制代码 代码如下:
>>> m = re.search('(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
(?同理，这个叫做“反后顾断言”，子RE需要固定长度的，含义是前面的字符串不匹配 ... 整个才算匹配。
(?(id/name)yes-pattern|no-pattern)
如有由id或者name指定的组存在的话，将会匹配yes-pattern，否则将会匹配no-pattern，通常情况下no-pattern也可以省略。例如：(<)?(\w+@\w+(?:\.\w+)+)(?(1)>)可以匹配 '' 和 'user@host.com'，但是不会匹配 '
下面列出以'\'开头的特殊序列。如果某个字符没有在下面列出，那么RE的结果会只匹配那个字母本身，比如，\$只匹配字面意义上的'$'。
\number
匹配number所指的组相同的字符串。组的序号从1开始。例如：(.+) \1可以匹配'the the'和'55 55'，但不匹配'the end'。这种序列在一个正则表达式里最多可以有99个，如果number以0开头，或是有3位以上的数字，就会被当做八进制表示的字符了。同时，这个也不能用于方括号内。
\A
只匹配字符串的开始。
\b
匹配单词边界（包括开始和结束），这里的“单词”，是指连续的字母、数字和下划线组成的字符串。注意，\b的定义是\w和\W的交界，所以精确的定义有赖于UNICODE和LOCALE这两个标志位。
\B
和\b相反，\B匹配非单词边界。也依赖于UNICODE和LOCALE这两个标志位。
\d
未指定UNICODE标志时，匹配数字，等效于：[0-9]。指定了UNICODE标志时，还会匹配其他Unicode库里描述为字符串的符号。便于理解，举个例子（好不容易找的例子啊，呵呵）：
复制代码 代码如下:
#\u2076\和u2084分别是上标的6和下标的4，属于unicode的DIGIT
>>> unistr = u'\u2076\u2084abc'
>>> print unistr
⁶₄abc
>>> print re.findall('\d+', unistr, re.U)[0]
⁶₄
\D
和\d相反，不多说了。
\s
当未指定UNICODE和LOCALE这两个标志位时，匹配任何空白字符，等效于[ \t\n\r\f\v]。如果指定了LOCALE，则还要加LOCALE相关的空白字符；如果指定了UNICODE，还要加上UNICODE空白字符，如较常见的空宽度连接空格（\uFEFF）、零宽度非连接空格(\u200B)等。
\S
和\s相反，也不多说。
\w
当未指定UNICODE和LOCALE这两个标志位时，等效于[a-zA-Z0-9_]。当指定了LOCALE时，为[0-9_]加上当前LOCAL指定的字母。当指定了UNICODE时，为[0-9_]加上UNICODE库里的所有字母。
\W
和\w相反，不多说。
\Z
只匹配字符串的结尾。
匹配之搜索
python提供了两种基于正则表达式的操作：匹配（match）从字符串的开始检查字符串是否个正则匹配。而搜索（search）检查字符串任意位置是否有匹配的子串（perl默认就是如此）。
注意，即使search的正则以'^'开头，match和search也还是有许多不同的。
复制代码 代码如下:
>>> re.match("c", "abcdef") # 不匹配
>>> re.search("c", "abcdef") # 匹配
<_sre.SRE_Match object at ...>
模块的属性和方法
re.compile(pattern[, flags])
把一个正则表达式pattern编译成正则对象，以便可以用正则对象的match和search方法。
得到的正则对象的行为（也就是模式）可以用flags来指定，值可以由几个下面的值OR得到。
以下两段内容在语法上是等效的：
复制代码 代码如下:
prog = re.compile(pattern)
result = prog.match(string)
result = re.match(pattern, string)
区别是，用了re.compile以后，正则对象会得到保留，这样在需要多次运用这个正则对象的时候，效率会有较大的提升。再用上面用过的例子来演示一下，用相同的正则匹配相同的字符串，执行100万次，就体现出compile的效率了（数据来自我那1.86G CPU的神舟本本）：
复制代码 代码如下:
>>> timeit.timeit(
... setup='''import re; reg = re.compile('<(?P\w*)>.*')''',
... stmt='''reg.match('xxx
')''',
... number=1000000)
1.2062149047851562
>>> timeit.timeit(
... setup='''import re''',
... stmt='''re.match('<(?P\w*)>.*', 'xxx
')''',
... number=1000000)
4.4380838871002197
re.I
re.IGNORECASE
让正则表达式忽略大小写，这样一来，[A-Z]也可以匹配小写字母了。此特性和locale无关。
re.L
re.LOCALE
让\w、\W、\b、\B、\s和\S依赖当前的locale。
re.M
re.MULTILINE
影响'^'和'$'的行为，指定了以后，'^'会增加匹配每行的开始（也就是换行符后的位置）；'$'会增加匹配每行的结束（也就是换行符前的位置）。
re.S
re.DOTALL
影响'.'的行为，平时'.'匹配除换行符以外的所有字符，指定了本标志以后，也可以匹配换行符。
re.U
re.UNICODE
让\w、\W、\b、\B、\d、\D、\s和\S依赖Unicode库。
re.X
re.VERBOSE
运用这个标志，你可以写出可读性更好的正则表达式：除了在方括号内的和被反斜杠转义的以外的所有空白字符，都将被忽略，而且每行中，一个正常的井号后的所有字符也被忽略，这样就可以方便地在正则表达式内部写注释了。也就是说，下面两个正则表达式是等效的：
复制代码 代码如下:
a = re.compile(r"""\d + # the integral part
\. # the decimal point
\d * # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
re.search(pattern, string[, flags])
扫描string，看是否有个位置可以匹配正则表达式pattern。如果找到了，就返回一个MatchObject的实例，否则返回None，注意这和找到长度为0的子串含义是不一样的。搜索过程受flags的影响。
re.match(pattern, string[, flags])
如果字符串string的开头和正则表达式pattern匹配的话，返回一个相应的MatchObject的实例，否则返回None
注意：要在字符串的任意位置搜索的话，需要使用上面的search()。
re.split(pattern, string[, maxsplit=0])
パターンで括弧が使用されている場合は、パターンに一致する文字列を部分文字列で分割します。も戻り値リストの一部になります。 maxsplit が 0 でない場合、最大でも maxsplit の部分文字列に分割され、残りの部分は全体として返されます。
コードをコピー コードは次のとおりです:
>>> re.split('W+', '単語、単語、単語。')
['単語', '単語', '単語', '']
>>> re.split('(W+)', '単語、単語, 単語。')
['単語', ', ', '単語', ', ', '単語', '.', '']
>>> W+', '単語、単語、単語。'、1)
['単語', '単語、単語。']
正規表現に括弧があり、文字列の先頭と一致する場合、戻り値の最初の項目は空の文字列になります。文字の末尾までのマッチングについても同様です:
コードをコピー コードは次のとおりです:
>> ;> re.split ('(W+)', '...単語、単語...')
['', '...', '単語', ', ', '単語', '...', '']
分割は長さ 0 の正規表現では分割されないことに注意してください。例:
コードをコピー コードは次のとおりです:
>>> re.split('x*', 'foo')
['foo']
>> ;> re.split("(?m )^$", "foonnbarn")
['foonnbarn']
re.findall(パターン, string[, flags ])
パターンに一致する文字列の重複しない部分文字列をリスト形式で返します。文字列は左から右に順番にスキャンされ、返されたリストも左から右に照合されます。パターンにグループが含まれている場合は、一致するグループのリストが返されます。パターンに複数のグループがある場合は、各グループが最初にタプルを形成し、次にタプルのリストが返されます。
この関数には MatchObject などの概念が含まれていないため、初心者にとっては理解しやすく、使用するのが最も簡単な関数です。以下に簡単な例をいくつか示します。
コードをコピー コードは次のとおりです。
#Simple findall
> ; >> re.findall('w+', 'hello, world!')
['hello', 'world']
#これはタプルのリストを返します
>> ;> re.findall('(d+).(d+).(d+).(d+)', '私の IP は 192.168.0.2、あなたの IP は 192.168.0.3.')
[('192' , '168 ', '0', '2'), ('192', '168', '0', '3')]
re.finditer(pattern, string[, flags])
上記の findall() と似ていますが、MatchObject のインスタンスのイテレータを返します。
例で問題を説明します。
コードをコピー コードは次のとおりです。 > for m in re.finditer( 'w+', 'hello, world!'):
... print m.group()
...
hello
world
re.sub(pattern, repl, string[, count])
Replace、パターンに一致する文字列の一部を repl で最大 count 回置換します (残りの一致は処理されません)、置換された文字列が返されます。文字列内にパターンに一致する文字列がない場合は、変更せずに返されます。 repl は文字列または関数にすることができます (前の例を参照することもできます)。 repl が文字列の場合、バックスラッシュが処理されます。たとえば、n は改行文字に変換され、バックスラッシュと数字が対応するグループに置き換えられます。たとえば、6 はパターンに一致する 6 番目のグループを意味します。 。 コンテンツ。
例:
コードをコピーします コードは次のとおりです。
>>> r'defs+ ([a-zA-Z_][a-zA-Z_0-9]*)s*(s*):',
... r'static PyObject*npy_1(void)n{',
... 'def myfunc():')
'static PyObject*npy_myfunc(void)n{'
repl が関数の場合、パターンが一致するたびに 1 回呼び出されます一致した MatchObject オブジェクトを渡すには、文字列を返し、返された文字列の一致した位置を埋める必要があります。
例:
コードをコピーします コードは次のとおりです:
>>> ):
... matchobj.group(0) == '-' の場合: return ' '
... else: return '-'
>>> -{1 ,2}'、dashrepl、'pro----gram-files')
'pro--gram files'
次のような長さゼロの一致も置き換えられます。 🎜>
コードをコピーします コードは次のとおりです:>>> re.sub('x*', ' -'、'abcxxd')
'-a-b-c-d-'
特に、置換文字列に g のような記述があると、通常の名前付きグループ (前述したように、(?P...) のように定義されたもの) と一致します。 g のように書くことも数値のグループです。つまり、 g は通常 2 に相当しますが、2 の直後にリテラルの 0 を書きたい場合は、20 として書くことはできません (これは 20 番目のグループを表すためです)。 ）、この時点では g0 と記述する必要があります。さらに、g は一致した部分文字列全体を表します。
例:
コードをコピーします コードは次のとおりです。
>>> '-( d+)-'、'-g0g'、'a-11-b-22-c')
'a-110-11-b-220-22-c'
re.subn(pattern, repl, string[, count])
タプル (new string 、一致の数)
、例を使用してみましょう:
コードをコピーします コードは次のとおりです:
> ;> ;> re.subn('-(d+)-', '-g0g', 'a-11-b-22-c')
('a-110- 11- b-220-22-c', 2)
re.escape(string)
文字列内の文字と数字以外の文字を削除します。どちらも傾斜防止ロッドを追加します。
コードをコピー コードは次のとおりです:
>>> print re.escape('abc123_@# $')
abc123_@#$
例外 re.error
この例外は、文字列を正規表現に正常にコンパイルできない場合、または正規表現の照合プロセス中にエラーが発生した場合にスローされます。ただし、正規表現がどのテキストにも一致しない場合、この例外はスローされません。
通常のオブジェクト
re.compile() によって返される通常のオブジェクト。以下のプロパティとメソッドがあります。
match(string[, pos[, endpos]])
この関数はモジュールの match() 関数に似ていますが、違いは最後の 2 つのパラメーターです。
pos は検索を開始する位置で、デフォルトは 0 です。 endpos は検索の終了位置です。endpos が pos より小さい場合、結果は必ず空になります。つまり、pos から endpos-1 までの文字列のみが検索されます。
例:
コードをコピー コードは次のとおりです:
> pattern = re。 COMPILE(" o")
>>> pattern.match("dog") # 開始位置が o ではないため、
>>> と一致しません。 Dog", 1) # いいえ。2 つの文字は o なので、
<_sre.SRE_Match object at...>
search(string[, pos[, endpos]])function と module search() 関数は似ており、pos パラメーターと endpos パラメーターは上記の match() 関数に似ています。
split(string[, maxsplit=0])findall(string[, pos[, endpos]])
finditer(string[, pos[, endpos]])
sub(repl, string[, count=0])
subn(repl, string[, count=0])
これらの関数はすべて、モジュールの対応する関数と一致しています。
flags
この RE のコンパイル時に指定されたフラグ ビット。フラグ ビットが指定されていない場合は 0 になります。
コードをコピーします コードは次のとおりです。>>> pattern = re.compile("o" 、re.S|re.U)
>48
groupsRE に含まれるグループの数。
groupindex
名前付きグループの名前とシリアル番号の関係を定義する辞書。
例: この正規表現には 3 つのグループがあり、一致した場合、最初のグループは市外局番と呼ばれ、最後のグループは内線番号と呼ばれ、中央のグループは名前がありません
コードをコピーします コードは次のとおりです: >>> pattern = re.compile("(?Pd+)-(d+)-(?P< fenjihao>d+)")>>> pattern.groups3
>>> pattern.groupindex
{'fenjihao': 3, 'quhao': 1}
pattern
この RE の元の文字列、つまりソースコードに相当する文字列を作成します（笑）。
上記と同じ通常のルールがそのまま返されることがわかります。
コードをコピーします コードは次のとおりです。 : > 印刷パターン.パターン(?Pd+)-(d+)-(?Pd+)
一致オブジェクト
re.MatchObject をブール判定に使用すると、常に True が返されるため、特定の match() が成功したかどうかを if 文で判定しても安全です。
次のメソッドとプロパティがあります:
expand(template)
sub() の動作と同じように、MatchObject を展開するテンプレートとしてテンプレートを使用します。例を参照してください:
コードをコピー コードは次のとおりです:
>>> m = re.match('a=(\d+)', 'a=100')
>>> m.expand('above a is \g<1>')
'above a is 100'
>>> m.expand(r'above a is \1')
'above a is 100'
group([group1, ...])
返回一个或多个子组。如果参数为一个，就返回一个子串；如果参数有多个，就返回多个子串注册的元组。如果不传任何参数，效果和传入一个0一样，将返回整个匹配。如果某个groupN未匹配到，相应位置会返回None。如果某个groupN是负数或者大于group的总数，则会抛出IndexError异常。
复制代码 代码如下:
>>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")
>>> m.group(0) # 整个匹配
'Isaac Newton'
>>> m.group(1) # 第一个子串
'Isaac'
>>> m.group(2) # 第二个子串
'Newton'
>>> m.group(1, 2) # 多个子串组成的元组
('Isaac', 'Newton')
如果有其中有用(?P...)这种语法命名过的子串的话，相应的groupN也可以是名字字符串。例如：
复制代码 代码如下:
>>> m = re.match(r"(?P\w+) (?P\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
如果某个组被匹配到多次，那么只有最后一次的数据，可以被提取到：
复制代码 代码如下:
>>> m = re.match(r"(..)+", "a1b2c3") # 匹配到3次
>>> m.group(1) # 返回的是最后一次
'c3'
groups([default])
返回一个由所有匹配到的子串组成的元组。default参数，用于给那些没有匹配到的组做默认值，它的默认值是None
例如：
复制代码 代码如下:
>>> m = re.match(r"(\d+)\.(\d+)", "24.1632")
>>> m.groups()
('24', '1632')
default的作用：
复制代码 代码如下:
>>> m = re.match(r"(\d+)\.?(\d+)?", "24")
>>> m.groups() # 第二个默认是None
('24', None)
>>> m.groups('0') # 现在默认是0了
('24', '0')
groupdict([default])
返回一个包含所有命名组的名字和子串的字典，default参数，用于给那些没有匹配到的组做默认值，它的默认值是None，例如：
复制代码 代码如下:
>>> m = re.match(r"(?P\w+) (?P\w+)", "Malcolm Reynolds")
>>> m.groupdict()
{'first_name': 'Malcolm', 'last_name': 'Reynolds'}
start([group])
end([group])
返回的是：被组group匹配到的子串在原字符串中的位置。如果不指定group或group指定为0，则代表整个匹配。如果group未匹配到，则返回 -1。
对于指定的m和g，m.group(g)和m.string[m.start(g):m.end(g)]等效。
注意：如果group匹配到空字符串，m.start(group)和m.end(group)将相等。
例如：
复制代码 代码如下:
>>> m = re.search('b(c?)', 'cba')
>>> m.start(0)
1
>>> m.end(0)
2
>>> m.start(1)
2
>>> m.end(1)
2
下面是一个把email地址里的“remove_this”去掉的例子：
复制代码 代码如下:
>>> email = "tony@tiremove_thisger.net"
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
'tony@tiger.net'span([group])
タプルを返します: (m.start(group), m.end(group))
pos
は、RE オブジェクトの search() または match() メソッドに渡されるパラメーター pos で、RE が文字列の検索を開始する位置を表します。
endpos
は、RE オブジェクトの search() または match() メソッドに渡されるパラメータ endpos で、RE 検索文字列の終了位置を表します。
lastindex
最後に一致したグループの数値シーケンス番号。一致しない場合は、None が取得されます。
例: (a)b、((a)(b)) および ((ab)) は正規表現で 'ab' と一致し、取得される lastindex は 1 です。 (a)(b) を使用して「ab」と一致する場合、取得される lastindex は 2 です。
lastgroup
最後に一致したグループの名前。一致するものがない場合、または最後のグループに名前がない場合は、None が返されます。
re
この Match オブジェクトの正規表現オブジェクトを取得します。これは、search() または match() を実行するオブジェクトです。
string
search() または match() に渡される文字列。
以下の例は省略します。本文には私自身の例が多数追加されています。さらに多くの例が必要な場合は、英語の原文 (https://docs.python.org/2) を参照してください。 /ライブラリ/ re.html)。
xxx
') #这个匹配<_sre.SRE_Match object at 0xb69588e0>
(?#...)
注释，圆括号里的内容会被忽略。
(?=...)
如果 ... 匹配接下来的字符，才算匹配，但是并不会消耗任何被匹配的字符。例如 Isaac (?=Asimov) 只会匹配后面跟着 'Asimov' 的 'Isaac '，这个叫做“前瞻断言”。
(?!...)
和上面的相反，只匹配接下来的字符串不匹配 ... 的串，这叫做“反前瞻断言”。
(?<=...)
只有当当前位置之前的字符串匹配 ... ，整个匹配才有效，这叫“后顾断言”。字符串'abcdef'可以匹配正则(?<=abc)def，因为会后向查找3个字符，看是否为abc。所以内置的子RE，需要是固定长度的，比如可以是abc、a|b，但不能是a*、a{3,4}。注意这种RE永远不会匹配到字符串的开头。举个例子，找到连字符（'-'）后的单词：
>>> m = re.search('(?<=-)\w+', 'spam-egg')
>>> m.group(0)
'egg'
(?同理，这个叫做“反后顾断言”，子RE需要固定长度的，含义是前面的字符串不匹配 ... 整个才算匹配。
(?(id/name)yes-pattern|no-pattern) 下面列出以'\'开头的特殊序列。如果某个字符没有在下面列出，那么RE的结果会只匹配那个字母本身，比如，\$只匹配字面意义上的'$'。 \number \A \b \B \d \D \s \S \w \W \Z 匹配之搜索 python提供了两种基于正则表达式的操作：匹配（match）从字符串的开始检查字符串是否个正则匹配。而搜索（search）检查字符串任意位置是否有匹配的子串（perl默认就是如此）。 模块的属性和方法 re.compile(pattern[, flags]) 区别是，用了re.compile以后，正则对象会得到保留，这样在需要多次运用这个正则对象的时候，效率会有较大的提升。再用上面用过的例子来演示一下，用相同的正则匹配相同的字符串，执行100万次，就体现出compile的效率了（数据来自我那1.86G CPU的神舟本本）： re.L re.M re.S re.U re.X re.match(pattern, string[, flags]) 注意：要在字符串的任意位置搜索的话，需要使用上面的search()。 re.split(pattern, string[, maxsplit=0]) re.sub(pattern, repl, string[, count]) re.subn(pattern, repl, string[, count]) 例外 re.error 通常のオブジェクト re.compile() によって返される通常のオブジェクト。以下のプロパティとメソッドがあります。 match(string[, pos[, endpos]]) findall(string[, pos[, endpos]]) flags RE に含まれるグループの数。
re.MatchObject をブール判定に使用すると、常に True が返されるため、特定の match() が成功したかどうかを if 文で判定しても安全です。
如果有其中有用(?P...)这种语法命名过的子串的话，相应的groupN也可以是名字字符串。例如： 如果某个组被匹配到多次，那么只有最后一次的数据，可以被提取到： default的作用： groupdict([default]) 返回的是：被组group匹配到的子串在原字符串中的位置。如果不指定group或group指定为0，则代表整个匹配。如果group未匹配到，则返回 -1。 span([group]) pos endpos lastindex lastgroup re string
如有由id或者name指定的组存在的话，将会匹配yes-pattern，否则将会匹配no-pattern，通常情况下no-pattern也可以省略。例如：(<)?(\w+@\w+(?:\.\w+)+)(?(1)>)可以匹配 '
匹配number所指的组相同的字符串。组的序号从1开始。例如：(.+) \1可以匹配'the the'和'55 55'，但不匹配'the end'。这种序列在一个正则表达式里最多可以有99个，如果number以0开头，或是有3位以上的数字，就会被当做八进制表示的字符了。同时，这个也不能用于方括号内。
只匹配字符串的开始。
匹配单词边界（包括开始和结束），这里的“单词”，是指连续的字母、数字和下划线组成的字符串。注意，\b的定义是\w和\W的交界，所以精确的定义有赖于UNICODE和LOCALE这两个标志位。
和\b相反，\B匹配非单词边界。也依赖于UNICODE和LOCALE这两个标志位。
未指定UNICODE标志时，匹配数字，等效于：[0-9]。指定了UNICODE标志时，还会匹配其他Unicode库里描述为字符串的符号。便于理解，举个例子（好不容易找的例子啊，呵呵）：
#\u2076\和u2084分别是上标的6和下标的4，属于unicode的DIGIT
>>> unistr = u'\u2076\u2084abc'
>>> print unistr
⁶₄abc
>>> print re.findall('\d+', unistr, re.U)[0]
⁶₄
和\d相反，不多说了。
当未指定UNICODE和LOCALE这两个标志位时，匹配任何空白字符，等效于[ \t\n\r\f\v]。如果指定了LOCALE，则还要加LOCALE相关的空白字符；如果指定了UNICODE，还要加上UNICODE空白字符，如较常见的空宽度连接空格（\uFEFF）、零宽度非连接空格(\u200B)等。
和\s相反，也不多说。
当未指定UNICODE和LOCALE这两个标志位时，等效于[a-zA-Z0-9_]。当指定了LOCALE时，为[0-9_]加上当前LOCAL指定的字母。当指定了UNICODE时，为[0-9_]加上UNICODE库里的所有字母。
和\w相反，不多说。
只匹配字符串的结尾。
注意，即使search的正则以'^'开头，match和search也还是有许多不同的。
>>> re.match("c", "abcdef") # 不匹配
>>> re.search("c", "abcdef") # 匹配
<_sre.SRE_Match object at ...>
把一个正则表达式pattern编译成正则对象，以便可以用正则对象的match和search方法。
得到的正则对象的行为（也就是模式）可以用flags来指定，值可以由几个下面的值OR得到。
以下两段内容在语法上是等效的：
prog = re.compile(pattern)
result = prog.match(string)
result = re.match(pattern, string)
>>> timeit.timeit(
... setup='''import re; reg = re.compile('<(?P
... stmt='''reg.match('xxx
')''',
... number=1000000)
1.2062149047851562
>>> timeit.timeit(
... setup='''import re''',
... stmt='''re.match('<(?Pxxx
')''',
... number=1000000)
4.4380838871002197
re.I
re.IGNORECASE
让正则表达式忽略大小写，这样一来，[A-Z]也可以匹配小写字母了。此特性和locale无关。
re.LOCALE
让\w、\W、\b、\B、\s和\S依赖当前的locale。
re.MULTILINE
影响'^'和'$'的行为，指定了以后，'^'会增加匹配每行的开始（也就是换行符后的位置）；'$'会增加匹配每行的结束（也就是换行符前的位置）。
re.DOTALL
影响'.'的行为，平时'.'匹配除换行符以外的所有字符，指定了本标志以后，也可以匹配换行符。
re.UNICODE
让\w、\W、\b、\B、\d、\D、\s和\S依赖Unicode库。
re.VERBOSE
运用这个标志，你可以写出可读性更好的正则表达式：除了在方括号内的和被反斜杠转义的以外的所有空白字符，都将被忽略，而且每行中，一个正常的井号后的所有字符也被忽略，这样就可以方便地在正则表达式内部写注释了。也就是说，下面两个正则表达式是等效的：
a = re.compile(r"""\d + # the integral part
\. # the decimal point
\d * # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
re.search(pattern, string[, flags])
扫描string，看是否有个位置可以匹配正则表达式pattern。如果找到了，就返回一个MatchObject的实例，否则返回None，注意这和找到长度为0的子串含义是不一样的。搜索过程受flags的影响。
如果字符串string的开头和正则表达式pattern匹配的话，返回一个相应的MatchObject的实例，否则返回None
パターンで括弧が使用されている場合は、パターンに一致する文字列を部分文字列で分割します。も戻り値リストの一部になります。 maxsplit が 0 でない場合、最大でも maxsplit の部分文字列に分割され、残りの部分は全体として返されます。
>>> re.split('W+', '単語、単語、単語。')
['単語', '単語', '単語', '']
>>> re.split('(W+)', '単語、単語, 単語。')
['単語', ', ', '単語', ', ', '単語', '.', '']
>>> W+', '単語、単語、単語。'、1)
['単語', '単語、単語。']
正規表現に括弧があり、文字列の先頭と一致する場合、戻り値の最初の項目は空の文字列になります。文字の末尾までのマッチングについても同様です:
>> ;> re.split ('(W+)', '...単語、単語...')
['', '...', '単語', ', ', '単語', '...', '']
分割は長さ 0 の正規表現では分割されないことに注意してください。例:
>>> re.split('x*', 'foo')
['foo']
>> ;> re.split("(?m )^$", "foonnbarn")
['foonnbarn']
re.findall(パターン, string[, flags ])
パターンに一致する文字列の重複しない部分文字列をリスト形式で返します。文字列は左から右に順番にスキャンされ、返されたリストも左から右に照合されます。パターンにグループが含まれている場合は、一致するグループのリストが返されます。パターンに複数のグループがある場合は、各グループが最初にタプルを形成し、次にタプルのリストが返されます。
この関数には MatchObject などの概念が含まれていないため、初心者にとっては理解しやすく、使用するのが最も簡単な関数です。以下に簡単な例をいくつか示します。
#Simple findall
> ; >> re.findall('w+', 'hello, world!')
['hello', 'world']
#これはタプルのリストを返します
>> ;> re.findall('(d+).(d+).(d+).(d+)', '私の IP は 192.168.0.2、あなたの IP は 192.168.0.3.')
[('192' , '168 ', '0', '2'), ('192', '168', '0', '3')]
re.finditer(pattern, string[, flags])
上記の findall() と似ていますが、MatchObject のインスタンスのイテレータを返します。
例で問題を説明します。
... print m.group()
...
hello
world
Replace、パターンに一致する文字列の一部を repl で最大 count 回置換します (残りの一致は処理されません)、置換された文字列が返されます。文字列内にパターンに一致する文字列がない場合は、変更せずに返されます。 repl は文字列または関数にすることができます (前の例を参照することもできます)。 repl が文字列の場合、バックスラッシュが処理されます。たとえば、n は改行文字に変換され、バックスラッシュと数字が対応するグループに置き換えられます。たとえば、6 はパターンに一致する 6 番目のグループを意味します。 。 コンテンツ。
例:
>>> r'defs+ ([a-zA-Z_][a-zA-Z_0-9]*)s*(s*):',
... r'static PyObject*npy_1(void)n{',
... 'def myfunc():')
'static PyObject*npy_myfunc(void)n{'
repl が関数の場合、パターンが一致するたびに 1 回呼び出されます一致した MatchObject オブジェクトを渡すには、文字列を返し、返された文字列の一致した位置を埋める必要があります。
例:
>>> ):
... matchobj.group(0) == '-' の場合: return ' '
... else: return '-'
>>> -{1 ,2}'、dashrepl、'pro----gram-files')
'pro--gram files'
次のような長さゼロの一致も置き換えられます。 🎜>
'-a-b-c-d-'
特に、置換文字列に g のような記述があると、通常の名前付きグループ (前述したように、(?P...) のように定義されたもの) と一致します。 g のように書くことも数値のグループです。つまり、 g は通常 2 に相当しますが、2 の直後にリテラルの 0 を書きたい場合は、20 として書くことはできません (これは 20 番目のグループを表すためです)。 ）、この時点では g0 と記述する必要があります。さらに、g は一致した部分文字列全体を表します。
例:
>>> '-( d+)-'、'-g0g'、'a-11-b-22-c')
'a-110-11-b-220-22-c'
タプル (new string 、一致の数)
、例を使用してみましょう:
> ;> ;> re.subn('-(d+)-', '-g0g', 'a-11-b-22-c')
('a-110- 11- b-220-22-c', 2)
re.escape(string)
文字列内の文字と数字以外の文字を削除します。どちらも傾斜防止ロッドを追加します。
>>> print re.escape('abc123_@# $')
abc123_@#$
この例外は、文字列を正規表現に正常にコンパイルできない場合、または正規表現の照合プロセス中にエラーが発生した場合にスローされます。ただし、正規表現がどのテキストにも一致しない場合、この例外はスローされません。
この関数はモジュールの match() 関数に似ていますが、違いは最後の 2 つのパラメーターです。
pos は検索を開始する位置で、デフォルトは 0 です。 endpos は検索の終了位置です。endpos が pos より小さい場合、結果は必ず空になります。つまり、pos から endpos-1 までの文字列のみが検索されます。
例:
> pattern = re。 COMPILE(" o")
>>> pattern.match("dog") # 開始位置が o ではないため、
>>> と一致しません。 Dog", 1) # いいえ。2 つの文字は o なので、
<_sre.SRE_Match object at...>
search(string[, pos[, endpos]])function と module search() 関数は似ており、pos パラメーターと endpos パラメーターは上記の match() 関数に似ています。
split(string[, maxsplit=0])
finditer(string[, pos[, endpos]])
sub(repl, string[, count=0])
subn(repl, string[, count=0])
これらの関数はすべて、モジュールの対応する関数と一致しています。
この RE のコンパイル時に指定されたフラグ ビット。フラグ ビットが指定されていない場合は 0 になります。
>48
groups
名前付きグループの名前とシリアル番号の関係を定義する辞書。
例: この正規表現には 3 つのグループがあり、一致した場合、最初のグループは市外局番と呼ばれ、最後のグループは内線番号と呼ばれ、中央のグループは名前がありません
>>> pattern.groupindex
{'fenjihao': 3, 'quhao': 1}
pattern
この RE の元の文字列、つまりソースコードに相当する文字列を作成します（笑）。
上記と同じ通常のルールがそのまま返されることがわかります。
一致オブジェクト
sub() の動作と同じように、MatchObject を展開するテンプレートとしてテンプレートを使用します。例を参照してください:
>>> m = re.match('a=(\d+)', 'a=100')
>>> m.expand('above a is \g<1>')
'above a is 100'
>>> m.expand(r'above a is \1')
'above a is 100'
group([group1, ...])
返回一个或多个子组。如果参数为一个，就返回一个子串；如果参数有多个，就返回多个子串注册的元组。如果不传任何参数，效果和传入一个0一样，将返回整个匹配。如果某个groupN未匹配到，相应位置会返回None。如果某个groupN是负数或者大于group的总数，则会抛出IndexError异常。
>>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")
>>> m.group(0) # 整个匹配
'Isaac Newton'
>>> m.group(1) # 第一个子串
'Isaac'
>>> m.group(2) # 第二个子串
'Newton'
>>> m.group(1, 2) # 多个子串组成的元组
('Isaac', 'Newton')
>>> m = re.match(r"(?P
>>> m.group('first_name')
'Malcolm'
>>> m.group('last_name')
'Reynolds'
>>> m = re.match(r"(..)+", "a1b2c3") # 匹配到3次
>>> m.group(1) # 返回的是最后一次
'c3'
groups([default])
返回一个由所有匹配到的子串组成的元组。default参数，用于给那些没有匹配到的组做默认值，它的默认值是None
例如：
>>> m = re.match(r"(\d+)\.(\d+)", "24.1632")
>>> m.groups()
('24', '1632')
>>> m = re.match(r"(\d+)\.?(\d+)?", "24")
>>> m.groups() # 第二个默认是None
('24', None)
>>> m.groups('0') # 现在默认是0了
('24', '0')
返回一个包含所有命名组的名字和子串的字典，default参数，用于给那些没有匹配到的组做默认值，它的默认值是None，例如：
>>> m = re.match(r"(?P
>>> m.groupdict()
{'first_name': 'Malcolm', 'last_name': 'Reynolds'}
start([group])
end([group])
对于指定的m和g，m.group(g)和m.string[m.start(g):m.end(g)]等效。
注意：如果group匹配到空字符串，m.start(group)和m.end(group)将相等。
例如：
>>> m = re.search('b(c?)', 'cba')
>>> m.start(0)
1
>>> m.end(0)
2
>>> m.start(1)
2
>>> m.end(1)
2
下面是一个把email地址里的“remove_this”去掉的例子：
>>> email = "tony@tiremove_thisger.net"
>>> m = re.search("remove_this", email)
>>> email[:m.start()] + email[m.end():]
'tony@tiger.net'
タプルを返します: (m.start(group), m.end(group))
は、RE オブジェクトの search() または match() メソッドに渡されるパラメーター pos で、RE が文字列の検索を開始する位置を表します。
は、RE オブジェクトの search() または match() メソッドに渡されるパラメータ endpos で、RE 検索文字列の終了位置を表します。
最後に一致したグループの数値シーケンス番号。一致しない場合は、None が取得されます。
例: (a)b、((a)(b)) および ((ab)) は正規表現で 'ab' と一致し、取得される lastindex は 1 です。 (a)(b) を使用して「ab」と一致する場合、取得される lastindex は 2 です。
最後に一致したグループの名前。一致するものがない場合、または最後のグループに名前がない場合は、None が返されます。
この Match オブジェクトの正規表現オブジェクトを取得します。これは、search() または match() を実行するオブジェクトです。
search() または match() に渡される文字列。
以下の例は省略します。本文には私自身の例が多数追加されています。さらに多くの例が必要な場合は、英語の原文 (https://docs.python.org/2) を参照してください。 /ライブラリ/ re.html)。