>>> m = re.search('(?<=-)\w+', 'spam-egg')

>>> m.group(0)

'egg'

\a      \b      \f      \n

\r      \t      \u      \U

\v      \x      \\

改变在3.3版本：在'\u'和'\U'转义序列已被添加。

因为3.5版本已过时，将在3.6版本中移除：由未知逃逸'\'和ASCII字母现在养不赞成警告，将在Python 3.6被禁止。

也可以看看

精通正则表达式

本书由杰弗里·弗里德尔正则表达式，由O'Reilly出版。该书的第二版不再涵盖Python的所有，但第一版涵盖了非常详细编写好的正则表达式模式。

模块内容

模块定义了几个函数、 常量和一个异常。某些函数是编译正则表达式全特性方法的简化版本。大多数复杂应用程序总是使用已编译的形式。

re.compile(pattern, flags=0)

将正则表达式模式编译成一个正则表达式对象，匹配时可以调用它的 match() 和 search() 方法，如下所述。

可以通过指定flags 值修改表达式的行为。值可以是任何以下变量， 组合使用 OR ( | 运算符).

The sequence

prog = re.compile(pattern)

result = prog.match(string)

等同于

result = re.match(pattern, string)

但表达式在单个程序中多次使用时， 使用re.compile() 和保存生成的正则表达式对象重用效率更高。

re.search(pattern, string, flags=0)

通过扫描字符串寻找那里的正则表达式的第一个位置模式产生匹配，并返回相应的匹配对象。返回None如果字符串中没有位置的模式相匹配; 注意，这是从字符串中的某个时刻找到一个零长度的比赛不同。

re.match(pattern, string, flags=0)

如果在开始的零个或多个字符的字符串匹配正则表达式模式，返回相应的匹配对象。返回None如果字符串不匹配模式; 注意，这是从零长度匹配不同。

需要注意的是，即使在MULTILINE模式下，re.match()将只匹配于字符串的开头，而不是在每一行的开头。

If you want to locate a match anywhere in string, use search() instead (see also search() vs. match()).

re.fullmatch(pattern, string, flags=0)

如果整个字符串匹配正则表达式模式，返回相应的匹配对象。返回None如果字符串不匹配模式; 注意，这是从零长度匹配不同。

在新版本3.4。

re.split(pattern, string, maxsplit=0, flags=0)

分割字符串用的发生模式。如果捕获括号中所用图案，然后在图案所有组的文本也被返回作为结果列表的一部分。如果maxsplit非零，至多maxsplit分裂发生，并且该串的剩余部分作为返回列表的最后一个元件。

>>> re.split('\W+', 'Words, words, words.')

['Words', 'words', 'words', '']

>>> re.split('(\W+)', 'Words, words, words.')

['Words', ', ', 'words', ', ', 'words', '.', '']

>>> re.split('\W+', 'Words, words, words.', 1)

['Words', 'words, words.']

>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)

['0', '3', '9']

>>>

>>> re.split('(\W+)', '...words, words...')

['', '...', 'words', ', ', 'words', '...', '']

这样，分离器组件总是在结果列表中的相同相对索引找到。

Note

注意

split()目前并不在一个空的模式匹配拆分的字符串。例如：

>>>

>>> re.split('x*', 'axbc')

['a', 'bc']

在3.1版本的变化：增加了可选的标志参数。

改变在3.5版本中：分割上可以匹配一个空字符串现在提出一个警告的模式。现在的模式，只能匹配空字符串被拒绝。

>>>

>>> re.split("^$", "foo\n\nbar\n", flags=re.M)

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

  ...

ValueError: split() requires a non-empty pattern match.

在3.1版本的变化：增加了可选的标志参数。

改变在3.5版本中：分割上可以匹配一个空字符串现在提出一个警告的模式。现在的模式，只能匹配空字符串被拒绝。

re.findall(pattern, string, flags=0)

Return all non-overlapping matches of pattern in string, as a list of strings. The string是从左到右扫描的，所以匹配的内容是按照该顺序来的If one or more groups are present in the pattern, return a list of groups; this will be a list of tuples if the pattern has more than one group. Return all non-overlapping matches of pattern in string, as a list of strings. The string是从左到右扫描的，所以匹配的内容是按照该顺序来的If one or more groups are present in the pattern, return a list of groups; this will be a list of tuples if the pattern has more than one group. Empty matches are included in the result unless they touch the beginning of another match.

re.finditer(pattern, string, flags=0)

返回一个迭代器产生的匹配对象，在为RE的所有非重叠的匹配模式的字符串。该字符串进行扫描左到右，而匹配的中发现的顺序返回。空场比赛都包括在结果，除非他们碰另一场比赛的开始。

re.sub(pattern, repl, string, count=0, flags=0)

返回由替换最左边的非重叠事件中获得的字符串模式在字符串的置换REPL。如果未找到模式，串原样返回。REPL可以是一个字符串或函数; 如果它是一个字符串，任何反斜杠在它被处理。即，\n被转换为单一的换行符，\r被转换成一个回车，等等。未知的转义如\&被单独留在家中。反向引用，如\6，被替换为由组6中的图案相匹配的子串。例如：

>>>

>>> re.sub(r'def\s+([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是一个函数，它被称为为每个非重叠出现的格局。该函数有一个匹配的对象参数，返回替换字符串。例如：

>>>

>>> def dashrepl(matchobj):

...     if matchobj.group(0) == '-': return ' '

...     else: return '-'

>>> re.sub('-{1,2}', dashrepl, 'pro----gram-files')

'pro--gram files'

>>> re.sub(r'\sAND\s', ' & ', 'Baked Beans And Spam', flags=re.IGNORECASE)

'Baked Beans & Spam'

该图案可以是字符串或RE对象。

可选参数计数是要被替换的模式出现的最大数量; 计数必须是一个非负整数。如果省略或为零，所有出现将被替换。该模式匹配空更换，只有当不相邻的上一个比赛，所以回报。sub('x*', '-','abc')'-a-b-c-'

在字符串类型的REPL参数，除了上述的字符转义和反向引用，\g<name>将使用指定的组相匹配的子字符串name，由定义的(?P<name>...)语法。\g<number>使用相应的组号; \g<2>因此等效于\2，但不是在更换诸如模棱两可\g<2>0。\20将被解释为对组20中的引用，而不是对第2组的基准后跟文字字符'0'。反向引用\g<0>整个字符串替代由RE相匹配。

在3.1版本的变化：增加了可选的标志参数。

在3.5版本中改为：无与伦比的群体被替换为空字符串。

因为3.5版本已过时，将在3.6版本中删除：未知逃逸包括'\'与ASCII字母现在养不赞成警告，将在Python 3.6被禁止。

re.subn(pattern, repl, string, count=0, flags=0)

执行相同的操作sub()，但返回的元组。(new_string, number_of_subs_made)

在3.1版本的变化：增加了可选的标志参数。

在3.5版本中改为：无与伦比的群体被替换为空字符串。

re.escape(string)

逃避所有的模式，除了ASCII字母，数字和字符'_'。如果你想匹配，可能有正则表达式元字符在它的任意文字字符串，这非常有用。

在3.3版本中更改：该'_'字符不再逃跑。

re.purge()

清除正则表达式缓存。

exception re.error(msg, pattern=None, pos=None)

这里的时候，一个字符串传递的功能之一提出的例外是不是一个有效的正则表达式（例如，它可能包含括号不匹配），或在编译或匹配时发生其他一些错误。如果一个字符串包含敌不过一个模式，是永远不会出错。错误实例具有以下附加属性：

msg

未格式化的错误消息。

pattern

正则表达式模式。

pos

指数模式，其中编译失败。

lineno

相对于线路POS。

colno

相应于列POS。

在3.5版本中变化：增加了额外的属性。

6.2.3. 正则表达式对象

已编译的正则表达式对象支持下列方法和属性︰

regex.search(string[, pos[, endpos]])

扫描string 寻找正则表达式产生匹配后的第一个位置 , 然后返回一个相对应的 match object.Return None if no position in the string matches the pattern; note that this is different from finding a zero-length match at some point in the string.

可选的第二个参数 pos 给索引在字符串中搜索在哪里开始;它默认为 0。This is not completely equivalent to slicing the string; the '^' pattern character matches at the real beginning of the string and at positions just after a newline, but not necessarily at the index where the search is to start.

可选参数endpos限制字符串将在多大程度上被搜索; 将它作为字符串是否endpos字符长，所以只能从人物POS机，以将搜索匹配。endpos - 1如果endpos低于POS，不匹配会被发现; 否则，如果RX是一个正则表达式编译对象，就等于。rx.search(string, 0, 50)rx.search(string[:50], 0)

>>>

>>> pattern = re.compile("d")

>>> pattern.search("dog")     # Match at index 0

<_sre.SRE_Match object; span=(0, 1), match='d'>

>>> pattern.search("dog", 1)  # No match; search doesn't include the "d"

regex.match(string[, pos[, endpos]])

I

如果在零个或多个字符开头的字符串匹配这个正则表达式，返回相应的匹配对象。如果返回 None，则该字符串不匹配模式;注意这不同于一个零字节长度的匹配。

可选的POS和endpos参数的含义与对于相同的search()方法。

>>>

>>> pattern = re.compile("o")

>>> pattern.match("dog")      # 没有匹配的“O”是不是在“狗”的开始。

>>> pattern.match("dog", 1)   # 匹配为“O”是“狗”的第2个字符。

<_sre.SRE_Match object; span=(1, 2), match='o'>

如果您想要的任何地方找到一个匹配的字符串，用search()代替， use search() instead (see also search() vs. match()).

regex.fullmatch(string[, pos[, endpos]])

如果整个字符串这个正则表达式匹配，返回相应的匹配对象。返回None如果字符串不匹配模式; 注意，这是从零长度匹配不同。

可选的POS和endpos参数的含义与对于相同的search()方法。

>>>

>>> pattern = re.compile("o[gh]")

>>> pattern.fullmatch("dog")      # No match as "o" is not at the start of "dog".

>>> pattern.fullmatch("ogre")     # No match as not the full string matches.

>>> pattern.fullmatch("doggie", 1, 3)   # Matches within given limits.

<_sre.SRE_Match object; span=(1, 3), match='og'>

New in version 3.4.

regex.split(string, maxsplit=0)

相同的split()功能，采用编图案。

regex.findall(string[, pos[, endpos]])

类似于 findall() 的功能，使用已编译的模版，但也接受可选的 pos 和 endpos 参数限制搜索区域像 match （）。

regex.finditer(string[, pos[, endpos]])

类似于 findall() 的功能，使用已编译的模版，但也接受可选的 pos 和 endpos 参数像 match （）限制搜索区域。

regex.sub(repl, string, count=0)

相同的sub()功能，采用编图案。

regex.subn(repl, string, count=0)

相同的subn()功能，采用编图案。

regex.flags

T正则表达式匹配标志。这是提供给标志的组合compile()，任何(?...)在图案内联的标志，并且如隐标志UNICODE如果该图案是Unicode字符串。

regex.groups

在图案捕获基团的数目。

regex.groupindex

对应的字典定义为任何符号的组名(?P<id>)，以组号码。如果没有符号组分别在模式中使用的字典是空的。

regex.pattern

该模式字符串从中RE对象被编译。

match = re.search(pattern, string) 
if match:
    process(match)

Checking for a Pair

在这个例子中，我们将使用下面的辅助函数来显示匹配的对象多了几分优雅：

def displaymatch(match):

    if match is None:

        return None

    return '<Match: %r, groups=%r>' % (match.group(), match.groups())

假设你正在编写一个球员的手表示为5个字符的字符串代表一个卡的每个字符扑克节目，“一”的王牌，“K”为王，“Q”为皇后，“J”的插孔， “T”为10，“2”至“9”表示与该值的卡。

要查看是否给定的字符串是一个有效的手，我们可以做到以下几点：

>>>

>>> valid = re.compile(r"^[a2-9tjqk]{5}$")

>>> displaymatch(valid.match("akt5q"))  # Valid.

"<Match: 'akt5q', groups=()>"

>>> displaymatch(valid.match("akt5e"))  # Invalid.

>>> displaymatch(valid.match("akt"))    # Invalid.

>>> displaymatch(valid.match("727ak"))  # Valid.

"<Match: '727ak', groups=()>"

>>>

>>> pair = re.compile(r".*(.).*\1")

>>> displaymatch(pair.match("717ak"))     # Pair of 7s.

"<Match: '717', groups=('7',)>"

>>> displaymatch(pair.match("718ak"))     # No pairs.

>>> displaymatch(pair.match("354aa"))     # Pair of aces.

"<Match: '354aa', groups=('a',)>"

>>>

>>> pair.match("717ak").group(1)

'7'

# Error because re.match() returns None, which doesn't have a group() method:

>>> pair.match("718ak").group(1)

Traceback (most recent call last):

  File "<pyshell#23>", line 1, in <module>

    re.match(r".*(.).*\1", "718ak").group(1)

AttributeError: 'NoneType' object has no attribute 'group'

>>> pair.match("354aa").group(1)

'a'

6.2.5.2. Simulating scanf()

Python中目前没有一个相当于scanf()。正则表达式一般都比较强大，虽也更详细，比scanf()格式字符串。下表提供的一些或多或少等价映射scanf()格式标记和正则表达式。

提取像一个字符串的文件名和号码

/usr/sbin/sendmail - 0 errors, 4 warnings

你可以使用一个scanf()类似的格式

%s - %d errors, %d warnings

等效正则表达式会

(\S+) - (\d+) errors, (\d+) warnings

search() vs. match()

Python 提供基于正则表达式两个不同的原语操作re.match()仅在字符串的开头进行匹配检查，而re.search()进行匹配的字符串中的任何检查（这是Perl并默认情况下）。

例如：

>>>

>>> re.match("c", "abcdef")    # No match

>>> re.search("c", "abcdef")   # Match

<_sre.SRE_Match object; span=(2, 3), match='c'>

开头的正则表达式'^'可以用来search()限制匹配的字符串的开头：

>>>

>>> re.match("c", "abcdef")    # No match没有匹配

>>> re.search("^c", "abcdef")  # No match

>>> re.search("^a", "abcdef")  # Match

<_sre.SRE_Match object; span=(0, 1), match='a'>

但是请注意，在MULTILINE模式match()仅在字符串的开头相匹配，而使用search()带开始正则表达式'^'匹配在每个行的开始。

>>>

>>> re.match('X', 'A\nB\nX', re.MULTILINE)  # No match

>>> re.search('^X', 'A\nB\nX', re.MULTILINE)  # Match

<_sre.SRE_Match object; span=(4, 5), match='X'>

Making a Phonebook通讯录

split()将一个字符串复制到传递模式分隔列表。该方法是非常宝贵的，用于将文本数据转换为可以容易地读取和Python的改性如下面的示例，创建一个电话簿证明的数据结构。

首先，这里是输入。通常，它可能来自一个文件，这里我们使用三引号字符串语法：

>>>

>>> text = """Ross McFluff: 834.345.1254 155 Elm Street

...

... Ronald Heathmore: 892.345.3428 436 Finley Avenue

... Frank Burger: 925.541.7625 662 South Dogwood Way

...

...

... Heather Albrecht: 548.326.4584 919 Park Place"""

的条目被一个或多个新行分开。现在我们转换成字符串具有其自身的条目中的每个非空行的列表：

>>>

>>> entries = re.split("\n+", text)

>>> entries

['Ross McFluff: 834.345.1254 155 Elm Street',

'Ronald Heathmore: 892.345.3428 436 Finley Avenue',

'Frank Burger: 925.541.7625 662 South Dogwood Way',

'Heather Albrecht: 548.326.4584 919 Park Place']

最后，拆每个条目与姓，名，电话号码和地址的列表。我们使用maxsplit的参数，split()因为地址有空格，我们的分裂模式，在其中：

>>>

>>> [re.split(":? ", entry, 3) for entry in entries]

[['Ross', 'McFluff', '834.345.1254', '155 Elm Street'],

['Ronald', 'Heathmore', '892.345.3428', '436 Finley Avenue'],

['Frank', 'Burger', '925.541.7625', '662 South Dogwood Way'],

['Heather', 'Albrecht', '548.326.4584', '919 Park Place']]

The :? pattern matches the colon after the last name, so that it does not occur in the result list. With a maxsplit of 4, 我们可以分开街道名称门牌号码：

>>>

>>> [re.split(":? ", entry, 4) for entry in entries]

[['Ross', 'McFluff', '834.345.1254', '155', 'Elm Street'],

['Ronald', 'Heathmore', '892.345.3428', '436', 'Finley Avenue'],

['Frank', 'Burger', '925.541.7625', '662', 'South Dogwood Way'],

['Heather', 'Albrecht', '548.326.4584', '919', 'Park Place']]

Text Munging文字改写

sub()替换字符串或函数的结果的图形的每一个发生。这个例子演示了使用sub()带有功能为“munge”的文字，或在随机除了第一个和最后一个字符一个句子中每个单词的所有字符的顺序：

>>>

>>> def repl(m):

...     inner_word = list(m.group(2))

...     random.shuffle(inner_word)

...     return m.group(1) + "".join(inner_word) + m.group(3)

>>> text = "Professor Abdolmalek, please report your absences promptly."

>>> re.sub(r"(\w)(\w+)(\w)", repl, text)

'Poefsrosr Aealmlobdk, pslaee reorpt your abnseces plmrptoy.'

>>> re.sub(r"(\w)(\w+)(\w)", repl, text)

'Pofsroser Aodlambelk, plasee reoprt yuor asnebces potlmrpy.'

找到所有副词

findall()匹配所有的模式的出现，不仅是第一个search()做。例如，如果一个人是一个作家，想找到所有的副词的一些文字，他或她可能使用findall()的方式如下：

>>>

>>> text = "He was carefully disguised but captured quickly by police."

>>> re.findall(r"\w+ly", text)

['carefully', 'quickly']

找到所有的副词及其位置

如果想了解比匹配的文本模式的所有匹配的更多信息，finditer()因为它提供了非常有用的匹配对象，而不是字符串。与继续前面的例子，如果一个是谁想要找到所有的副词的作家和他们的立场的一些文字，他或她会用finditer()的方式如下：

>>>

>>> text = "He was carefully disguised but captured quickly by police."

>>> for m in re.finditer(r"\w+ly", text):

...     print('%02d-%02d: %s' % (m.start(), m.end(), m.group(0)))

07-16: carefully

40-47: quickly

raw字符串表示

原始字符串符号（r"text"）保持正则表达式理智。没有它，每一个反斜杠（'\'）在正则表达式必须与另一个逃跑呢前缀。例如，以下两个行代码在功能上是相同的：

>>>

>>> re.match(r"\W(.)\1\W", " ff ")

<_sre.SRE_Match object; span=(0, 4), match=' ff '>

>>> re.match("\\W(.)\\1\\W", " ff ")

<_sre.SRE_Match object; span=(0, 4), match=' ff '>

当一个人想匹配一个反斜杠，它必须在正则表达式进行转义。随着原始字符串符号，这意味着r"\\"。如果没有原始字符串符号，你必须使用"\\\\"，使得代码功能相同下面几行：

>>>

>>> re.match(r"\\", r"\\")

<_sre.SRE_Match object; span=(0, 1), match='\\'>

>>> re.match("\\\\", r"\\")

<_sre.SRE_Match object; span=(0, 1), match='\\'>

一个标记生成器或扫描仪分析字符串进行分类字符组。这是写一个编译器或解释有益的第一步。

文本类别与正则表达式指定。该技术是将这些组合成一个单一的主正则表达式和遍历连续匹配：

import collections

import re

Token = collections.namedtuple('Token', ['typ', 'value', 'line', 'column'])

def tokenize(code):

    keywords = {'IF', 'THEN', 'ENDIF', 'FOR', 'NEXT', 'GOSUB', 'RETURN'}

    token_specification = [

        ('NUMBER',  r'\d+(\.\d*)?'),  # Integer or decimal number

        ('ASSIGN',  r':='),           # Assignment operator

        ('END',     r';'),            # Statement terminator

        ('ID',      r'[A-Za-z]+'),    # Identifiers

        ('OP',      r'[+\-*/]'),      # Arithmetic operators

        ('NEWLINE', r'\n'),           # Line endings

        ('SKIP',    r'[ \t]+'),       # Skip over spaces and tabs

        ('MISMATCH',r'.'),            # Any other character

    ]

    tok_regex = '|'.join('(?P<%s>%s)' % pair for pair in token_specification)

    line_num = 1

    line_start = 0

    for mo in re.finditer(tok_regex, code):

        kind = mo.lastgroup

        value = mo.group(kind)

        if kind == 'NEWLINE':

            line_start = mo.end()

            line_num += 1

        elif kind == 'SKIP':

            pass

        elif kind == 'MISMATCH':

            raise RuntimeError('%r unexpected on line %d' % (value, line_num))

        else:

            if kind == 'ID' and value in keywords:

                kind = value

            column = mo.start() - line_start

            yield Token(kind, value, line_num, column)

statements = '''

    IF quantity THEN

        total := total + price * quantity;

        tax := price * 0.05;

    ENDIF;

'''

for token in tokenize(statements):

    print(token)

标记生成器产生以下的输出：

Token(typ='IF', value='IF', line=2, column=4)

Token(typ='ID', value='quantity', line=2, column=7)

Token(typ='THEN', value='THEN', line=2, column=16)

Token(typ='ID', value='total', line=3, column=8)

Token(typ='ASSIGN', value=':=', line=3, column=14)

Token(typ='ID', value='total', line=3, column=17)

Token(typ='OP', value='+', line=3, column=23)

Token(typ='ID', value='price', line=3, column=25)

Token(typ='OP', value='*', line=3, column=31)

Token(typ='ID', value='quantity', line=3, column=33)

Token(typ='END', value=';', line=3, column=41)

Token(typ='ID', value='tax', line=4, column=8)

Token(typ='ASSIGN', value=':=', line=4, column=12)

Token(typ='ID', value='price', line=4, column=15)

Token(typ='OP', value='*', line=4, column=21)

Token(typ='NUMBER', value='0.05', line=4, column=23)

Token(typ='END', value=';', line=4, column=27)

Token(typ='ENDIF', value='ENDIF', line=5, column=4)

Token(typ='END', value=';', line=5, column=9)

re常用正则表达式符号

'.'     默认匹配除\n之外的任意一个字符，若指定flag DOTALL,则匹配任意字符，包括换行

'^'     匹配字符开头，若指定flags MULTILINE,这种也可以匹配上(r"^a","\nabc\neee",flags=re.MULTILINE)

'$'     匹配字符结尾，或e.search("foo$","bfoo\nsdfsf",flags=re.MULTILINE).group()也可以

'*'     匹配*号前的字符0次或多次，re.findall("ab*","cabb3abcbbac")  结果为['abb', 'ab', 'a']

'+'     匹配前一个字符1次或多次，re.findall("ab+","ab+cd+abb+bba") 结果['ab', 'abb']

'?'     匹配前一个字符1次或0次

'{m}'   匹配前一个字符m次

'{n,m}' 匹配前一个字符n到m次，re.findall("ab{1,3}","abb abc abbcbbb") 结果'abb', 'ab', 'abb']

'|'     匹配|左或|右的字符，re.search("abc|ABC","ABCBabcCD").group() 结果'ABC'

'(...)' 分组匹配，re.search("(abc){2}a(123|456)c", "abcabca456c").group() 结果 abcabca456c

'\A'    只从字符开头匹配，re.search("\Aabc","alexabc") 是匹配不到的

'\Z'    匹配字符结尾，同$

'\d'    匹配数字0-9

'\D'    匹配非数字

'\w'    匹配[A-Za-z0-9]

'\W'    匹配非[A-Za-z0-9]

's'     匹配空白字符、\t、\n、\r , re.search("\s+","ab\tc1\n3").group() 结果 '\t'

'(?P<name>...)' 分组匹配 re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{4})","371481199306143242").groupdict("city") 结果{'province': '3714', 'city': '81', 'birthday': '1993'}

最常用的匹配语法

re.match 从头开始匹配

re.search 匹配包含

re.findall 把所有匹配到的字符放到以列表中的元素返回

re.splitall 以匹配到的字符当做列表分隔符

re.sub      匹配字符并替换

match

# match，从起始位置开始匹配，匹配成功返回一个对象，未匹配成功返回None

 match(pattern, string, flags=0)

 # pattern： 正则模型

 # string ： 要匹配的字符串

 # falgs  ： 匹配模式

     X  VERBOSE     Ignore whitespace and comments for nicer looking RE's.

     I  IGNORECASE  Perform case-insensitive matching.

     M  MULTILINE   "^" matches the beginning of lines (after a newline)

                    as well as the string.

                    "$" matches the end of lines (before a newline) as well

                    as the end of the string.

     S  DOTALL      "." matches any character at all, including the newline.

     A  ASCII       For string patterns, make \w, \W, \b, \B, \d, \D

                    match the corresponding ASCII character categories

                    (rather than the whole Unicode categories, which is the

                    default).

                    For bytes patterns, this flag is the only available

                    behaviour and needn't be specified.

     L  LOCALE      Make \w, \W, \b, \B, dependent on the current locale.

     U  UNICODE     For compatibility only. Ignored for string patterns (it

                    is the default), and forbidden for bytes patterns.

实例：

# 无分组

        r = re.match("h\w+", origin)

        print(r.group())     # 获取匹配到的所有结果

        print(r.groups())    # 获取模型中匹配到的分组结果

        print(r.groupdict()) # 获取模型中匹配到的分组结果

        # 有分组

        # 为何要有分组？提取匹配成功的指定内容（先匹配成功全部正则，再匹配成功的局部内容提取出来）

        r = re.match("h(\w+).*(?P<name>\d)$", origin)

        print(r.group())     # 获取匹配到的所有结果

        print(r.groups())    # 获取模型中匹配到的分组结果

        print(r.groupdict()) # 获取模型中匹配到的分组中所有执行了key的组

Demo

search

# search,浏览整个字符串去匹配第一个，未匹配成功返回None

# search(pattern, string, flags=0)

实例：

# 无分组

        r = re.search("a\w+", origin)

        print(r.group())     # 获取匹配到的所有结果

        print(r.groups())    # 获取模型中匹配到的分组结果

        print(r.groupdict()) # 获取模型中匹配到的分组结果

        # 有分组

        r = re.search("a(\w+).*(?P<name>\d)$", origin)

        print(r.group())     # 获取匹配到的所有结果

        print(r.groups())    # 获取模型中匹配到的分组结果

        print(r.groupdict()) # 获取模型中匹配到的分组中所有执行了key的组

demo

import re

obj = re.match('\d+', '123uuasf')

if obj:

    print(obj.group())

a = '123abc456'
print(re.search('([0-9]*)([a-z]*)([0-9]*)',a).group())#123abc456
print(re.search('([0-9]*)([a-z]*)([0-9]*)',a).group(0))#123abc456
print(re.search('([0-9]*)([a-z]*)([0-9]*)',a).group(1))#123
print(re.search('([0-9]*)([a-z]*)([0-9]*)',a).group(2))#abc

import re

obj = re.search('\d+', 'u123uu888asf')

if obj:

    print(obj.group())

group和groups

a = "123abc456"

print re.search("([0-9]*)([a-z]*)([0-9]*)", a).group()

print re.search("([0-9]*)([a-z]*)([0-9]*)", a).group(0)

print re.search("([0-9]*)([a-z]*)([0-9]*)", a).group(1)

print re.search("([0-9]*)([a-z]*)([0-9]*)", a).group(2)

print re.search("([0-9]*)([a-z]*)([0-9]*)", a).groups()

findall

# findall，获取非重复的匹配列表；如果有一个组则以列表形式返回，且每一个匹配均是字符串；如果模型中有多个组，则以列表形式返回，且每一个匹配均是元祖；

# 空的匹配也会包含在结果中

#findall(pattern, string, flags=0)

实例：

# 无分组

        r = re.findall("a\w+",origin)

        print(r)

        # 有分组

        origin = "hello alex bcd abcd lge acd 19"

        r = re.findall("a((\w*)c)(d)", origin)

        print(r)

Demo

import re

obj = re.findall('\d+', 'fa123uu888asf')

print(obj)

sub

# sub，替换匹配成功的指定位置字符串

sub(pattern, repl, string, count=0, flags=0)

# pattern： 正则模型

# repl   ： 要替换的字符串或可执行对象

# string ： 要匹配的字符串

# count  ： 指定匹配个数

# flags  ： 匹配模式

实例：

# 与分组无关

        origin = "hello alex bcd alex lge alex acd 19"

        r = re.sub("a\w+", "999", origin, 2)

        print(r)

根据指定匹配进行分组

content = "'1 - 2 * ((60-30+1*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2) )'"

new_content = re.split('\*', content)

# new_content = re.split('\*', content, 1)

print new_content

2

content = "'1 - 2 * ((60-30+1*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2) )'"

new_content = re.split('[\+\-\*\/]+', content)

# new_content = re.split('\*', content, 1)

print new_content

3

inpp = '1-2*((60-30 +(-40-5)*(9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2))'

inpp = re.sub('\s*','',inpp)

new_content = re.split('\(([\+\-\*\/]?\d+[\+\-\*\/]?\d+){1}\)', inpp, 1)

print new_content

相比于str.split更加强大

实例：计算器源码

split

# split，根据正则匹配分割字符串

split(pattern, string, maxsplit=0, flags=0)

# pattern： 正则模型

# string ： 要匹配的字符串

# maxsplit：指定分割个数

# flags  ： 匹配模式

实例：

# 无分组

        origin = "hello alex bcd alex lge alex acd 19"

        r = re.split("alex", origin, 1)

        print(r)

        # 有分组

        origin = "hello alex bcd alex lge alex acd 19"

        r1 = re.split("(alex)", origin, 1)

        print(r1)

        r2 = re.split("(al(ex))", origin, 1)

        print(r2)

Demo

IP：

^(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}$

手机号：

^1[3|4|5|8][0-9]\d{8}$

邮箱：

[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+

常用正则表达式

>>> import re

>>> re.findall(r'\bf[a-z]*', 'which foot or hand fell fastest')

['foot', 'fell', 'fastest']

>>> re.sub(r'(\b[a-z]+) \1', r'\1', 'cat in the the hat')

'cat in the hat'

>>> 'tea for too'.replace('too', 'two')

'tea for two'

>>> import math

>>> math.cos(math.pi / 4)

0.70710678118654757

>>> math.log(1024, 2)

10.0

>>> import random

>>> random.choice(['apple', 'pear', 'banana'])

'apple'

>>> random.sample(range(100), 10)   # sampling without replacement

[30, 83, 16, 4, 8, 81, 41, 50, 18, 33]

>>> random.random()    # random float

0.17970987693706186

>>> random.randrange(6)    # random integer chosen from range(6)

4

>>> import statistics

>>> data = [2.75, 1.75, 1.25, 0.25, 0.5, 1.25, 3.5]

>>> statistics.mean(data)

1.6071428571428572

>>> statistics.median(data)

1.25

>>> statistics.variance(data)

1.3720238095238095