blocks|key|641689|text|如果您需要所有的单词，只需使用'\w%2B'|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|641690|s6+=+'''Male+:+abc
+++Male+:+def'''
re.findall('\w%2B',+s6)|code-block|syntax|javascript|641691|输出：|641692|['Male',+'abc',+'Male',+'def']|641693|entityMap^0|F|5|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

If you need all the words, just use <code>'\w+'</code>:

<pre><code>s6 = '''Male : abc
 Male : def'''
re.findall('\w+', s6)
</code></pre>

Output:

<pre><code>['Male', 'abc', 'Male', 'def']
</code></pre>

blocks|key|1578999|text|我们可以尝试将字符串拆分为一个或多个非单词字符：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1579000|s6+=+"""Male+:+abc
Male+:+def"""
words+=+re.split(r'\W%2B',+s6)
print(words)

['Male',+'abc',+'Male',+'def']|code-block|syntax|javascript|1579001|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

We can try splitting your string on one or more non word characters:

<pre><code>s6 = """Male : abc
Male : def"""
words = re.split(r'\W+', s6)
print(words)

['Male', 'abc', 'Male', 'def']
</code></pre>

blocks|key|1579025|text|你可以满足你的需要，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1579026|s6+=+'''Male+:+abc
+++Male+:+def'''
re.findall('[a-zA-Z]%2B',+s6)|code-block|syntax|javascript|1579027|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can just match what your need,

<pre><code>s6 = '''Male : abc
 Male : def'''
re.findall('[a-zA-Z]+', s6)
</code></pre>

blocks|key|1889436|text|交替运算符%7C表示“匹配此正则表达式，否则匹配该正则表达式”。这两个子表达式不可能同时匹配。如果第一个是匹配的，第二个甚至将永远不会被检查。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1889437|要从冒号的两边提取内容，只需创建一个正则表达式，该表达式在相同的匹配中捕获两边的文本。|1889438|re.findall(r'([%5E\n:]%2B):([%5E\n:]%2B)',+s6)|code-block|syntax|javascript|1889439|要修剪匹配的空格，您需要一个更复杂的正则表达式，当然，如果您知道匹配的字符串总是一个标记(也就是说，每个字符串都是一个字母字符串，其中没有空格)：|1889440|re.findall(r'(\w%2B)\s*:\s*(\w%2B)',+s6)|1889441|也许对多个令牌来说|1889442|re.findall(r'\s*([%5E\n:]%2B?)\s*:\s*([%5E\n:]%2B?)(?=\s*(?:\n%7C$))',+s6)|1889443|在这里，我们非常明显地在贪婪和非贪婪的匹配之间交替，以得到尽可能短的字符串，这将仍然满足正则表达式。|1889444|或者你可以转过身来，把贪婪变成你的优势：|1889445|re.findall(r'(\w%2B(?:[%5E\n\S]%2B\w%2B)*)\s*:\s*(\w%2B(?:[%5E\n\S]%2B\w%2B)*)',+s6)|1889446|在这里，只要空格不包含换行符，我们就会尽可能多地捕获空格分隔的标记。|1889447|更详细地说，e%2B匹配尽可能多(贪婪匹配)，而e%2B?匹配尽可能少(非贪婪或吝啬匹配)。(?=...)是一种前瞻性，它需要以下表达式来匹配，而不需要捕获或使用匹配的文本。因此，当e(?=e)应用于文本时，eee将首先匹配初始的e，并且在findall的下一次迭代中立即找到下面的一个，尽管它已经参与了满足以前的匹配。当然，(?:...)是普通的非捕获分组括号，而[%5E\n\S]是一个字符类，它与任何一个不是换行符的字符和.不是空白类别的成员，所以除了换行符外，任何空白都是有效的。|1889448|还请注意，我们如何显式地避免在捕获表达式中匹配冒号或换行符。|1889449|新手：“我怎样才能匹配所有这些字符串？”|1889450|师父：“我怎样才能与这些字符串相匹配？”|1889451|entityMap^0|5|1|0|0|0|0|0|0|0|0|0|0|0|6|2|M|3|16|7|2F|6|2S|3|33|1|38|7|4F|7|4Z|7|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1C|8|@$9|1D|A|1E|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1F|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1G|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1H|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|1I|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1J|8|@]|D|@]|E|$]]|$1|S|3|T|5|J|7|1K|8|@]|D|@]|E|$K|L]]|$1|U|3|V|5|6|7|1L|8|@]|D|@]|E|$]]|$1|W|3|X|5|6|7|1M|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|J|7|1N|8|@]|D|@]|E|$K|L]]|$1|10|3|11|5|6|7|1O|8|@]|D|@]|E|$]]|$1|12|3|13|5|6|7|1P|8|@$9|1Q|A|1R|B|C]|$9|1S|A|1T|B|C]|$9|1U|A|1V|B|C]|$9|1W|A|1X|B|C]|$9|1Y|A|1Z|B|C]|$9|20|A|21|B|C]|$9|22|A|23|B|C]|$9|24|A|25|B|C]|$9|26|A|27|B|C]]|D|@]|E|$]]|$1|14|3|15|5|6|7|28|8|@]|D|@]|E|$]]|$1|16|3|17|5|6|7|29|8|@]|D|@]|E|$]]|$1|18|3|19|5|6|7|2A|8|@]|D|@]|E|$]]|$1|1A|3|-4|5|6|7|2B|8|@]|D|@]|E|$]]]|1B|$]]

The alternation operator <code>|</code> says "match this regex, or else match that regex". There is no way for the two subexpressions to match at once. If the first one is a match, the second will never even be examined.

To pull out stuff from both sides of a colon, simply craft a regular expression which captures text on both sides in the same match.

<pre><code>re.findall(r'([^\n:]+):([^\n:]+)', s6)
</code></pre>

To trim whitespace around the matches, you need a more involved regex, except of course if you know that the matching strings will always be a single token (i.e. each is a single alphabetic string with no whitespace in it):

<pre><code>re.findall(r'(\w+)\s*:\s*(\w+)', s6)
</code></pre>

Maybe for multiple tokens try

<pre><code>re.findall(r'\s*([^\n:]+?)\s*:\s*([^\n:]+?)(?=\s*(?:\n|$))', s6)
</code></pre>

where we very conspicuously alternate between greedy and non-greedy matching to get the shortest possible strings which will still satisfy the regular expression.

Or you could turn around and turn the greed to your advantage:

<pre><code>re.findall(r'(\w+(?:[^\n\S]+\w+)*)\s*:\s*(\w+(?:[^\n\S]+\w+)*)', s6)
</code></pre>

where we grab as many whitespace-separated tokens as we can into the capture, just as long as the whitespace does not contain a newline.

In some more detail, <code>e+</code> matches as many as possible (greedy matching), and <code>e+?</code> as few as possible (non-greedy or stingy matching). <code>(?=...)</code> is a lookahead which requires the following expression to match, without capturing or consuming the matching text. So <code>e(?=e)</code> when applied to the text <code>eee</code> will first match the initial <code>e</code>, and on the next iteration of <code>findall</code> find the immediately following one, even though it already participated in satisfying he previous match. And of course <code>(?:...)</code> is the plain non-capturing grouping parenthesis, and <code>[^\n\S]</code> is a character class which matches any one character which isn't a newline character and ... not not a member of the whitespace category - so effectively any whitespace except newline.

Notice also how we explicitly avoid matching a colon, or a newline, in the capturing expressions.

Novice: "How can I match all these strings?" 
Master: "How can I match only these strings?"

blocks|key|1885079|text|它不能工作，因为第一个匹配消耗了您的锚(冒号)，所以第二个匹配永远不匹配。您需要断言来解决这个问题，但是这种情况太复杂了：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1885080|import+re
compiled+=+re.compile(r'((\w%2B)\s*(?=:)%7C(?<=:)\s*(\w%2B))')+
s6+=+'''Male+:+abc+
++++Male+:+def'''+
re.findall(compiled,+s6)++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

#+Output:
[('Male+',+'Male',+''),
+('+abc',+'',+'abc'),
+('Male+',+'Male',+''),
+('+def',+'',+'def')]|code-block|syntax|javascript|1885081|因此，现在您需要对列表进行后置处理，考虑到此输入，不建议这样做。简而言之:两种情况下不要使用一个锚。|1885082|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

It isn't working because the first match consumes your anchor (the colon) so the second match never matches. You need assertions to fix that, but it's overcomplicated for this case:

<pre class="lang-py prettyprint-override"><code>import re
compiled = re.compile(r'((\w+)\s*(?=:)|(?&lt;=:)\s*(\w+))') 
s6 = '''Male : abc 
 Male : def''' 
re.findall(compiled, s6) 

# Output:
[('Male ', 'Male', ''),
 (' abc', '', 'abc'),
 ('Male ', 'Male', ''),
 (' def', '', 'def')]
</code></pre>

So now you need to do post processing on the list you have, not recommended given this input. In short: don't use one anchor for two cases using alternatives.

<pre><code>import re
s6 = '''Male : abc
 Male : def'''
re.findall(r'(.*):|:(.*)', s6)
</code></pre>

My output:

<pre><code>[('Male ', ''), (' Male ', '')]
</code></pre>

My expected output:

<pre><code>[('Male','abc'),('Male','def')]
</code></pre>

When I do <code>re.findall(r'(.*):', s6)</code> I am getting <code>['Male ', ' Male ']</code> and with <code>re.findall(r':(.*)', s6)</code> I am getting <code>[' abc', ' def']</code>. When I use the <code>|</code> symbol I am getting the wrong output.

Disclaimer: Please don't do <code>re.split</code> 

I have done <code>\w+</code> also which is working, but I want an expression in the below format. I have done <code>re.findall(r'\s*(\w+)\s*:|:\s*(\w+)', s6)</code>, which is not working individually. With <code>\s*(\w+)\s*:</code> and <code>:\s*(\w+)', s6</code> it is working. 

I want to know why with <code>|</code> it is not working.

How to regex with |?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

import res6 = '''Male : abc   Male : def'''re.findall(r'(.*):|:(.*)', s6)我的产出：[('Male ', ''), ('            Male ', '')]我的预期产出：[('Male','abc'),('Male','def')]当我...

问怎么才能和？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问怎么才能和？EN