<p>Python不像perl那样优先处理模式匹配和字符串操作。这些是类似的模式,是的,Python的更长(它也有很多很棒的东西,比如它是面向对象的,不使用奇怪的全局变量)。你知道吗</p>
<p>不过,作为记录,您可以使用tuple unpacking使其更加简洁:</p>
<pre><code>var1, var2 = mySearch.groups()
</code></pre>
<p><strong>更新:</strong></p>
<h3>元组解包</h3>
<p>元组解包是Python的一个有用特性。要理解它,我们首先要问,什么是<a href="https://docs.python.org/2/tutorial/datastructures.html#tuples-and-sequences" rel="nofollow">tuple</a>。元组的核心是一个不可变的序列,与列表不同的是,不能追加、弹出或任何类似的内容。从语法上讲,声明一个元组非常简单,它只是由逗号分隔的几个值。你知道吗</p>
<pre><code>my_tuple = "I", "am", "awesome"
my_tuple[0] # "I"
my_tuple[1] # "am"
my_tuple[2] # "awesome"
</code></pre>
<p>人们通常认为元组实际上是由周围的括号<code>my_tuple = ("I", "am", "awesome")</code>定义的,但这是错误的;括号只在阐明或强制执行某种操作顺序时才有用。你知道吗</p>
<p>元组解包是Python中最可爱的特性之一。在左侧定义一个包含未定义名称的元组数据结构,然后将右侧的<code>iterable</code>解压到其中。右侧可以包含<em>任何</em>类型的<code>iterable</code>,但其包含的数据的形状必须与左侧名称的元组结构完全匹配。你知道吗</p>
<pre><code># some_var and other_var are both undefined
print some_var # NameError: some_var is undefined
print other_var # NameError: other_var is undefined
my_iterable = ["so", "cool"]
# note that 'some_var, other_var' looks a whole lot like a tuple
some_var, other_var = my_iterable
print some_var # "so"
print other_var # "cool"
</code></pre>
<p>同样,我们不需要右边的列表,而是任何类型的iterable,例如,生成器:</p>
<pre><code>def some_generator():
yield 1
yield 2
yield 3
a, b, c = some_generator()
print a # 1
print b # 2
print c # 3
</code></pre>
<p>甚至可以用嵌套的数据结构进行元组解包。你知道吗</p>
<pre><code>nested_list = [1, [2, 3], 4]
# note that parentheses are necessary here to delimit tuples
a, (b, c), d = nested_list
</code></pre>
<p>如果右侧的iterable与左侧的模式不匹配,则会爆炸:</p>
<pre><code># THESE EXAMPLES DON'T WORK
a, b = [1, 2, 3] # ValueError: too many values to unpack
a, b = [] # ValueError: need more than 0 values to unpack
</code></pre>
<p>实际上,这种嘈杂的失败使元组解包成为我从<code>iterable</code>中获取项目的最常用方法,因为我认为<code>iterable</code>中应该只有一个项目,如果它有多个项目,我希望我的代码失败。你知道吗</p>
<pre><code># note that the left side below is how you define a tuple of one
bank_statement, = bank_statements # we def want to blow up if too many statements
</code></pre>
<h3>多重分配</h3>
<p>人们所认为的多重赋值实际上只是简单的元组解包。你知道吗</p>
<pre><code>a, b = 1, 2
print a # 1
print b # 2
</code></pre>
<p>这没什么特别的。解释器将等式的右侧计算为<code>tuple</code>记住,元组只是由逗号分隔的值(文本、变量、已计算的函数调用等),然后解释器将其与左侧匹配,就像上面所有示例一样。你知道吗</p>
<h3>带回家</h3>
<p>我写这篇文章是为了解释你在这个问题上得到的两个不同的答案:</p>
<pre><code>var1, var2 = mySearch.group(1), mySearch.group(2)
</code></pre>
<p>以及</p>
<pre><code>var1, var2 = mySearch.groups()
</code></pre>
<p>首先,认识到这两个语句,对于<code>mySearch</code>是由带有两个匹配组的正则表达式生成的<code>MatchObject</code>的情况,在功能上是完全等价的。你知道吗</p>
<p>它们只是在元组解包的性质方面有很小的不同。第一个在右边声明一个元组,而第二个使用<code>MatchObject.groups</code>返回的元组。你知道吗</p>
<p>这实际上并不适用于您的情况,但了解<code>MatchObject.group</code>和<code>MatchObject.groups</code>的行为略有不同可能会很有用(请参见<a href="https://docs.python.org/2/tutorial/datastructures.html#tuples-and-sequences" rel="nofollow">here</a>和<a href="https://docs.python.org/2/library/re.html#re.MatchObject.group" rel="nofollow">here</a>)。<code>MatchObject.groups</code>返回regex遇到的所有“子组”(subgroups),即捕获组,而<code>MatchObject.group</code>返回单个组,并将整个模式计数为0处可访问的组。你知道吗</p>
<p>实际上,在这种情况下,你应该使用这两个你认为是最具表现力或最清晰的。我个人认为在右边提到组1和组2是多余的,而且我经常被<code>MatchObject.groups(0)</code>返回与整个模式匹配的字符串,从而将所有“子组”偏移到一个索引中这一事实所困扰。你知道吗</p>