天道酬勤,学无止境

How to print regex match results in python 3?

I was in IDLE, and decided to use regex to sort out a string. But when I typed in what the online tutorial told me to, all it would do was print:

<_sre.SRE_Match object at 0x00000000031D7E68>

Full program:

import re
reg = re.compile("[a-z]+8?")
str = "ccc8"
print(reg.match(str))

result:

<_sre.SRE_Match object at 0x00000000031D7ED0>

Could anybody tell me how to actually print the result?

评论

You need to include .group() after to the match function so that it would print the matched string otherwise it shows only whether a match happened or not. To print the chars which are captured by the capturing groups, you need to pass the corresponding group index to the .group() function.

>>> import re
>>> reg = re.compile("[a-z]+8?")
>>> str = "ccc8"
>>> print(reg.match(str).group())
ccc8

Regex with capturing group.

>>> reg = re.compile("([a-z]+)8?")
>>> print(reg.match(str).group(1))
ccc

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

If zero or more characters at the beginning of string match the regular expression pattern, return a corresponding MatchObject instance. Return None if the string does not match the pattern; note that this is different from a zero-length match.

Note that even in MULTILINE mode, re.match() will only match at the beginning of the string and not at the beginning of each line.

If you need to get the whole match value, you should use

m = reg.match(r"[a-z]+8?", text)
if m:                          # Always check if a match occurred to avoid NoneType issues
  print(m.group())             # Print the match string

If you need to extract a part of the regex match, you need to use capturing groups in your regular expression. Enclose those patterns with a pair of unescaped parentheses.

To only print captured group results, use Match.groups:

Return a tuple containing all the subgroups of the match, from 1 up to however many groups are in the pattern. The default argument is used for groups that did not participate in the match; it defaults to None.

So, to get ccc and 8 and display only those, you may use

import re
reg = re.compile("([a-z]+)(8?)")
s = "ccc8"
m = reg.match(s)
if m:
  print(m.groups()) # => ('ccc', '8')

See the Python demo

受限制的 HTML

  • 允许的HTML标签:<a href hreflang> <em> <strong> <cite> <blockquote cite> <code> <ul type> <ol start type> <li> <dl> <dt> <dd> <h2 id> <h3 id> <h4 id> <h5 id> <h6 id>
  • 自动断行和分段。
  • 网页和电子邮件地址自动转换为链接。

相关推荐
  • Python,从字符串中删除所有非字母字符(Python, remove all non-alphabet chars from string)
    问题 我正在编写python MapReduce字数统计程序。 问题是数据中散布着许多非字母字符,我发现这篇文章从Python的字符串中剥离了除了字母数字字符之外的所有内容,这显示了使用正则表达式的一个很好的解决方案,但是我不确定如何实现它 def mapfn(k, v): print v import re, string pattern = re.compile('[\W_]+') v = pattern.match(v) print v for w in v.split(): yield w, 1 恐怕我不确定该如何使用库re或正则表达式。 我不确定如何将正则表达式模式正确地应用于传入的字符串(书行) v以检索没有任何非字母数字字符的新行。 有什么建议吗? 回答1 使用re.sub import re regex = re.compile('[^a-zA-Z]') #First parameter is the replacement, second parameter is your input string regex.sub('', 'ab3d*E') #Out: 'abdE' 或者,如果您只想删除一组特定的字符(因为输入中可以使用撇号...) regex = re.compile('[,\.!?]') #etc. 回答2 如果您不想使用正则表达式,可以尝试 ''
  • 您如何将这种正则表达式习语从Perl转换为Python?(How do you translate this regular-expression idiom from Perl into Python?)
    问题 大约一年前,我从Perl切换到Python,并且没有回头。 我发现只有成语比起Python可以更容易地在Perl中完成: if ($var =~ /foo(.+)/) { # do something with $1 } elsif ($var =~ /bar(.+)/) { # do something with $1 } elsif ($var =~ /baz(.+)/) { # do something with $1 } 相应的Python代码不是那么优雅,因为if语句不断嵌套: m = re.search(r'foo(.+)', var) if m: # do something with m.group(1) else: m = re.search(r'bar(.+)', var) if m: # do something with m.group(1) else: m = re.search(r'baz(.+)', var) if m: # do something with m.group(2) 有没有人有优雅的方法可以在Python中重现此模式? 我已经看到使用了匿名函数调度表,但是对于少量的正则表达式来说,这些表对我来说似乎有点笨拙…… 回答1 从Python 3.8开始,并引入赋值表达式(PEP 572)( :=运算符)
  • python正则表达式re库详解
      我们已经了解到正则表达式是处理字符串的强大工具,具有自己的语法结构,有了它,能实现字符串的检索、替换、匹配验证码等。  当然本文着重讲它在爬虫方向的用法,从html中提取信息。正则表达式虽然看起来一团糟,其实它也有自己的语法规范特定的规则,可以再多了解一些用法我不在赘述。  我们来了解它的常用方法。  1.match()方法  match()会从字符串的起始位置匹配正则表达式,如果匹配成功会输出匹配的结果,出错会返回None。  示例如下:  import re  content = 'Hello 1234567 World_This is a Regex Demo'  result = re.match('^Hello\s(\d+)\sWorld', content)  print(result)  print(result.group())  print(result.span())  运行结果:  Hello 1234567 World  (0, 19)  1  2  3  我们打印了这个输出可以看到是一个re.Match对象,这表明我们匹配成功了,该对象有两个方法group()方法可以输出正则表达式所匹配到的内容;span()方法可以输出匹配的范围。  匹配目标  我们貌似已经提取了匹配的内容。但是如果我们想要的仅仅是一段数字的电话呢
  • 在 if 块内匹配和捕获 Perl 的 Python 等效项(Python equivallent of Perl match and capture within if block)
    问题 我正在慢慢地从 Perl 迁移到 Python,并试图了解使用正则表达式的最佳实践。 我有以下 Perl 代码 - 此代码基本上将字符串作为输入,并根据正则表达式匹配和捕获将重新排列的字符串作为输出: #!/usr/bin/env perl use strict; use warnings; my $str = $ARGV[0] || die "Arg?"; my $result; if($str =~ m/^\d{12}$/) { $result = $str; } elsif($str =~ m{^(\d{2})/(\d{2})/(\d{4})$}) { $result = "${1}${2}0000${3}"; } elsif($str =~ m{^(\d{4})$}) { $result = "01010000${1}"; } else { die "Invalid string"; } print("Result: $result\n"); 在 Python 3 中什么是好的等价物? 到目前为止,我想出了以下内容,但在 elif 部分匹配两次似乎效率低下。 在开始时编译所有正则表达式似乎也效率低下。 #!/usr/bin/env python3 import re, sys str = sys.argv[1] p1 = re.compile('\d{12}') p2
  • Python正则表达式模块模糊匹配:替换计数不符合预期(Python regex module fuzzy match: substitution count not as expected)
    问题 背景 Python 模块正则表达式允许模糊匹配。 您可以指定允许的替换数 (s)、插入数 (i)、删除数 (d) 和总错误数 (e)。 匹配结果的 Fuzzy_counts 属性返回一个元组 (0,0,0),其中: match.fuzzy_counts[0] = count for 's' match.fuzzy_counts[1] = count for 'i' match.fuzzy_counts[2] = count for 'd' 问题 删除和插入按预期计算,但不计算替换。 在下面的示例中,唯一的变化是查询中删除了一个字符,但替换计数为 6 (如果删除了 BESTMATCH 选项,则为 7)。 换人次数是如何计算的? 我会很感激有人可以向我解释这是如何工作的。 >>> import regex >>> reference = "(TATGGGA[CT][GC]AAAG[CT]CT[AC]AA[GA]CCATGTG){s<7,i<3,d<3,e<8}" >>> query = "TATGGACCAAAGTCTCAAGCCATGTG" >>> match = regex.search(reference, query, regex.BESTMATCH) >>> print(match.fuzzy_counts) (6,0,1) 回答1
  • Python正则表达式模块模糊匹配:替换计数不符合预期(Python regex module fuzzy match: substitution count not as expected)
    问题 背景 Python 模块正则表达式允许模糊匹配。 您可以指定允许的替换数 (s)、插入数 (i)、删除数 (d) 和总错误数 (e)。 匹配结果的 Fuzzy_counts 属性返回一个元组 (0,0,0),其中: match.fuzzy_counts[0] = count for 's' match.fuzzy_counts[1] = count for 'i' match.fuzzy_counts[2] = count for 'd' 问题 删除和插入按预期计算,但不计算替换。 在下面的示例中,唯一的变化是查询中删除了一个字符,但替换计数为 6 (如果删除了 BESTMATCH 选项,则为 7)。 换人次数是如何计算的? 我会很感激有人可以向我解释这是如何工作的。 >>> import regex >>> reference = "(TATGGGA[CT][GC]AAAG[CT]CT[AC]AA[GA]CCATGTG){s<7,i<3,d<3,e<8}" >>> query = "TATGGACCAAAGTCTCAAGCCATGTG" >>> match = regex.search(reference, query, regex.BESTMATCH) >>> print(match.fuzzy_counts) (6,0,1) 回答1
  • 条件中的 Python 正则表达式匹配(Python regex matching in conditionals)
    问题 我正在解析文件,我想根据一些复杂的正则表达式检查每一行。 像这样的东西 if re.match(regex1, line): do stuff elif re.match(regex2, line): do other stuff elif re.match(regex3, line): do still more stuff ... 当然,要做这些事情,我需要匹配对象。 我只能想到三种可能性,每一种都有不足之处。 if re.match(regex1, line): m = re.match(regex1, line) do stuff elif re.match(regex2, line): m = re.match(regex2, line) do other stuff ... 这需要进行两次复杂的匹配(这些是长文件和长正则表达式:/) m = re.match(regex1, line) if m: do stuff else: m = re.match(regex2, line) if m: do other stuff else: ... 随着我缩进越来越深,这变得很糟糕。 while True: m = re.match(regex1, line) if m: do stuff break m = re.match(regex2, line) if m: do
  • Python:如何将嵌套括号与正则表达式匹配?(Python: How to match nested parentheses with regex?)
    问题 我正在尝试匹配带有嵌套括号的类似数学表达式的字符串。 import re p = re.compile('\(.+\)') str = '(((1+0)+1)+1)' print p.findall(s) ['((((1 + 0)+1)+1)'] 我希望它匹配所有包含的表达式,例如(1 + 0),((1 + 0)+1)... 我什至不在乎它是否与诸如(((1 + 0), 为什么它还没有这样做,我该怎么做? 回答1 正则表达式尝试匹配尽可能多的文本,从而消耗了您的所有字符串。 它不会在该字符串的某些部分上寻找正则表达式的其他匹配项。 这就是为什么您只能得到一个答案的原因。 解决方案是不使用正则表达式。 如果您实际上是试图解析数学表达式,请使用真实的解析解决方案。 如果您真的只想捕获括号中的片段,则只需在看到(和)时循环计数字符,然后增加一个递减的计数器即可。 回答2 正如其他人所提到的,使用正则表达式并不是嵌套结构的必经之路。 我将使用pyparsing给出一个基本示例: import pyparsing # make sure you have this installed thecontent = pyparsing.Word(pyparsing.alphanums) | '+' | '-' parens = pyparsing.nestedExpr( '(', ')'
  • 在python正则表达式中将1个单词限制为区分大小写,其他不区分大小写 | (管道)(restrict 1 word as case sensitive and other as case insensitive in python regex | (pipe))
    问题 我明白了| (管道特殊字符)在正则表达式,Python 中。 它匹配第一个或第二个。 ex : a|b匹配 a 或 b。 我的问题:如果我想在上面的例子中匹配a区分大小写和b不区分大小写怎么办? 前任: s = "Welcome to PuNe, Maharashtra" result1 = re.search("punnee|MaHaRaShTrA",s) result2 = re.search("pune|maharashtra",s) result3 = re.search("PuNe|MaHaRaShTrA",s) result4 = re.search("P|MaHaRaShTrA",s) 我想搜索浦那我已经写在上面的语句的方式s即PuNe 。 但是我必须通过忽略大小写来搜索马哈拉施特拉邦。 如何搜索区分大小写的 1 个单词和不区分大小写的其他单词? 因此, result1 、 result2 、 result3 、 result4将给出not null值。 我试过: result1 = re.search("pune|MaHaRaShTrA",s1, re.IGNORECASE) 但这忽略了这两个词的情况。 如何将 1 个单词限制为区分大小写而其他单词不区分大小写? 回答1 在 Python 3.6 及更高版本中,您可以使用内联修饰符组: >>> s =
  • 为什么某些正则表达式引擎在单个输入字符串中匹配 .* 两次?(Why do some regex engines match .* twice in a single input string?)
    问题 许多正则表达式引擎在单行字符串中匹配.*两次,例如,在执行基于正则表达式的字符串替换时: 正如预期的那样,第一个匹配项是 - 根据定义 - 整个(单行)字符串。 在许多引擎中有第二个匹配项,即空字符串; 也就是说,即使第一个匹配已经消耗了整个输入字符串, .*也会再次匹配,然后匹配输入字符串末尾的空字符串。 注意:要确保只找到一个匹配项,请使用^.* 我的问题是: 这种行为有充分的理由吗? 一旦输入字符串被完全消耗,我不希望再次尝试找到匹配项。 除了反复试验之外,您能否从文档/正则表达式方言/标准支持哪些引擎表现出这种行为中收集? 更新:雷沃的有用的答案解释了当前行为如何; 至于潜在的原因,请参阅此相关问题。 确实表现出行为的语言/平台: # .NET, via PowerShell (behavior also applies to the -replace operator) PS> [regex]::Replace('a', '.*', '[$&]' [a][] # !! Note the *2* matches, first the whole string, then the empty string # Node.js $ node -pe "'a'.replace(/.*/g, '[$&]')" [a][] # Ruby $ ruby -e "puts 'a'
  • re.finditer 和 re.findall 之间的不同行为(Different behavior between re.finditer and re.findall)
    问题 我正在使用以下代码: CARRIS_REGEX=r'<th>(\d+)</th><th>([\s\w\.\-]+)</th><th>(\d+:\d+)</th><th>(\d+m)</th>' pattern = re.compile(CARRIS_REGEX, re.UNICODE) matches = pattern.finditer(mailbody) findall = pattern.findall(mailbody) 但是 finditer 和 findall 正在寻找不同的东西。 Findall 确实会找到给定字符串中的所有匹配项。 但是 finditer 只找到第一个,返回一个只有一个元素的迭代器。 如何使 finditer 和 findall 的行为相同? 谢谢 回答1 我无法在这里重现。 用 Python 2.7 和 3.1 都试过了。 finditer和findall之间的一个区别是,前者返回正则表达式匹配对象,而另一个返回匹配捕获组的元组(如果没有捕获组,则返回整个匹配项)。 所以 import re CARRIS_REGEX=r'<th>(\d+)</th><th>([\s\w\.\-]+)</th><th>(\d+:\d+)</th><th>(\d+m)</th>' pattern = re.compile(CARRIS_REGEX, re
  • Python网络爬虫数据采集实战:Requests和Re库
    ​ 熟悉爬虫的基本概念之后,我们可以直接开始爬虫实战的学习,先从Python的requests库即re库入手,可以迅速“get”到python爬虫的思想以及流程,并且通过这两个库就可以建立一个完整的爬虫系统。 目录 一、requests库 1.简介 2.入门测试 3.主要方法 二、re库 1.简介 2.入门测试 3.主要方法 一、requests库 1.简介 Requests是用Python语言编写的,基于urllib3来改写的,采用Apache2 Licensed 来源协议的HTTP库。它比urllib更加方便,可以节约我们大量的工作,完全满足HTTP测试需求。在日常使用中我们绝大部分使用requests库向目标网站发起HTTP请求。 通过上图官网对requests的介绍可知此库的强大之处:Requests是唯一适用于Python的Non-GMO HTTP库,可供人类安全使用。 2.入门测试 我们首先通过代码实例测试一下Requests库的使用情景。首先本文采用配置环境为win10+anaconda3+Python3.7.4,直接在终端运行: pip install requests 如果出现以下字样即代表安装完成。 urllib 库中的urlopen()方法实际上是以GET方式请求网页,而requests 中相应的方法就是get()。在Python中运行以下代码: import
  • Why do some regex engines match .* twice in a single input string?
    Many regex engines match .* twice in a single-line string, e.g., when performing regex-based string replacement: The 1st match is - by definition - the entire (single-line) string, as expected. In many engines there is a 2nd match, namely the empty string; that is, even though the 1st match has consumed the entire input string, .* is matched again, which then matches the empty string at the end of the input string. Note: To ensure that only one match is found, use ^.* My questions are: Is there a good reason for this behavior? Once the input string has been consumed in full, I wouldn't expect
  • 在Python中,如何分割字符串并保留分隔符?(In Python, how do I split a string and keep the separators?)
    问题 这是解释此问题的最简单方法。 这是我正在使用的: re.split('\W', 'foo/bar spam\neggs') -> ['foo', 'bar', 'spam', 'eggs'] 这就是我想要的: someMethod('\W', 'foo/bar spam\neggs') -> ['foo', '/', 'bar', ' ', 'spam', '\n', 'eggs'] 原因是我想将字符串拆分为标记,对其进行操作,然后将其重新放回原处。 回答1 >>> re.split('(\W)', 'foo/bar spam\neggs') ['foo', '/', 'bar', ' ', 'spam', '\n', 'eggs'] 回答2 如果要在换行符上拆分,请使用splitlines(True)。 >>> 'line 1\nline 2\nline without newline'.splitlines(True) ['line 1\n', 'line 2\n', 'line without newline'] (这不是一个通用的解决方案,但是请在此处添加此功能,以防万一有人来这里而没有意识到此方法的存在。) 回答3 另一个示例,拆分非字母数字并保留分隔符 import re a = "foo,bar@candy*ice%cream" re.split('([^a
  • python正则表达式re库详解
    re库详解 我们已经了解到正则表达式是处理字符串的强大工具,具有自己的语法结构,有了它,能实现字符串的检索、替换、匹配验证码等。 当然本文着重讲它在爬虫方向的用法,从html中提取信息。正则表达式虽然看起来一团糟,其实它也有自己的语法规范特定的规则,可以再多了解一些用法我不在赘述。 我们来了解它的常用方法。 1.match()方法 match()会从字符串的起始位置匹配正则表达式,如果匹配成功会输出匹配的结果,出错会返回None。 示例如下: import re content = 'Hello 1234567 World_This is a Regex Demo' result = re.match('^Hello\s(\d+)\sWorld', content) print(result) print(result.group()) print(result.span()) 运行结果: <re.Match object; span=(0, 19), match='Hello 1234567 World'> Hello 1234567 World (0, 19) 我们打印了这个输出可以看到是一个re.Match对象,这表明我们匹配成功了,该对象有两个方法group()方法可以输出正则表达式所匹配到的内容;span()方法可以输出匹配的范围。 匹配目标 我们貌似已经提取了匹配的内容
  • Python:在字符串中查找模式(Python: Find pattern in a string)
    问题 我试图找到一种方法来匹配python中字符串s中的模式p。 s = 'abccba' ss = 'facebookgooglemsmsgooglefacebook' p = 'xyzzyx' # s, p -> a, z # s and p can only be 'a' through 'z' def match(s, p): if s matches p: return True else: return False match(s, p) # return True match(ss, p) # return True 我刚试过: import re s = "abccba" f = "facebookgooglemsmsgooglefacebook" p = "xyzzyx" def fmatch(s, p): p = re.compile(p) m = p.match(s) if m: return True else: return False print fmatch(s, p) print fmatch(f, p) 两者都返回false; 他们应该是真的。 回答1 我将您的模式转换为可被re.match使用的正则表达式。 例如,您的xyzzyx变成(.+)(.+)(.+)\3\2\1$ (每个字母的第一个出现成为捕获组(.+) ,随后出现的成为正确的后向引用)
  • Python正则表达式匹配特定单词(Python regex to match a specific word)
    问题 我想匹配测试报告中的所有行,其中包含单词“ Not Ok”。 范例文字行: 'Test result 1: Not Ok -31.08' 我尝试了这个: filter1 = re.compile("Not Ok") for line in myfile: if filter1.match(line): print line 应该可以根据http://rubular.com/进行工作,但是输出没有任何结果。 任何想法,可能有什么问题吗? 测试了其他各种参数,例如“”。 和“ ^ Test”,它们可以完美地工作。 回答1 您应该在这里使用re.search而不是re.match 。 从有关re.match的文档中: 如果要在字符串中的任意位置找到匹配项,请改用search()。 如果您要查找确切的单词'Not Ok'则使用\b单词边界,否则,如果您仅查找子字符串'Not Ok'则使用simple: if 'Not Ok' in string 。 >>> strs = 'Test result 1: Not Ok -31.08' >>> re.search(r'\bNot Ok\b',strs).group(0) 'Not Ok' >>> match = re.search(r'\bNot Ok\b',strs) >>> if match: ... print "Found"
  • Python:跨文件块边界的正则表达式匹配(Python: regex match across file chunk boundaries)
    问题 巨大的纯文本数据文件 我使用 python 分块读取了一个大文件。 然后我在那个块上应用一个正则表达式。 基于标识符标签,我想提取相应的值。 由于块大小的原因,块边界处的数据丢失。 要求: 文件必须分块读取。 块大小必须小于或等于 1 GiB。 Python代码示例 identifier_pattern = re.compile(r'Identifier: (.*?)\n') with open('huge_file', 'r') as f: data_chunk = f.read(1024*1024*1024) m = re.findall(identifier_pattern, data_chunk) 块数据示例好:标签的数量等于值的数量 标识符:值标识符:值标识符:值标识符:值 由于块的大小,您会遇到如下所列的不同边界问题。 第三个标识符返回一个不完整的值,“v”而不是“value”。 下一个块包含“alue”。 这会导致解析后丢失数据。 错误:标识符值不完整 标识符:值标识符:值标识符: v 你如何解决像这样的块边界问题? 回答1 假设这是您的确切问题,您可能只需调整您的正则表达式并逐行读取(这不会将完整文件加载到内存中): import re matches = [] identifier_pattern = re.compile(r'Identifier: (.*
  • Python正则表达式在给定的字符串中向前查找“文档”单词并替换为空字符串(Python regex to find "document" word in a given string in forward direction and replace by empty string)
    问题 如果可以通过从给定字符串中删除字符来生成单词“document”,则将从字符串中删除拼写为“document”的字母。 如果可以删除结果字符串中的字母以保留字符串“document”,则删除该字符串中拼写为“document”的字母。 这一直持续到无法删除字母以离开“文档”,此时将返回最终字符串。 例如,如果字符串是: documdocumententer ^^^^^^^^ “document”可以通过去掉开头的“docum”和“end”的“enter”形成,所以去掉中间的“document”,留下 documenter ^^^^^^^^ 然后将重复该过程以离开 er 由于“er”不包含“document”,将返回“er”。 同样,如果字符串是: adbocucdmefgnhtj ^ ^^^ ^^ ^ ^ 拼写为“document”的字母将被删除,留下: abcdfghj 该字符串将被返回,因为它不包含“文档”。 例子 doconeument转换为one documdocumentent被转换为empty string documentone转换为one pydocdbument转换为pydb documentdocument被转换为empty string 如何从给定的字符串中获取感兴趣的字符串(仅针对特定单词“文档”)。 我通过 python for 循环尝试了这个查询
  • Python使用正则表达式和replace()在某些字符之间查找子字符串(Python finding substring between certain characters using regex and replace())
    问题 假设我有一个包含很多随机内容的字符串,如下所示: strJunk ="asdf2adsf29Value=five&lakl23ljk43asdldl" 我对获取位于“Value=' 和”&”之间的子字符串感兴趣,在本例中为“5”。 我可以使用如下的正则表达式: match = re.search(r'Value=?([^&>]+)', strJunk) >>> print match.group(0) Value=five >>> print match.group(1) five 为什么 match.group(0) 是“Value=five”的全部,而 group(1) 只是“5”? 有没有办法让我得到“五”作为唯一的结果? (这个问题源于我对正则表达式的了解很少) 我还必须在此字符串中进行替换,例如以下内容: val1 = match.group(1) strJunk.replace(val1, "six", 1) 其中产生: 'asdf2adsf29Value=six&lakl23ljk43asdldl' 考虑到我计划一遍又一遍地执行上述两项任务(查找 'Value=' 和 '&' 之间的字符串,以及替换该值),我想知道是否还有其他更有效的方法来查找子字符串并将其替换为原始字符串。 我很好地坚持我所拥有的,但我只是想确保如果有更好的方法,我不会占用比我必须更多的时间。