blocks|key|71013|text|当在赋值中使用时，Python会尝试让*b匹配到它所需要的任何东西，以使赋值有效(这是Python3中的新特性，请参阅PEP+3132)。这两个都是有效的：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|71014|a,+*b,+c+=+1,4
print(b)+#+[]

a,+*b,+c+=+1,2,3,4,5+
print(b)+#+[2,+3,+4]|code-block|syntax|javascript|71015|在函数中使用时，如果*b是函数定义中的第二个参数，则它将与函数调用中的倒数第二个参数匹配(如果有)。当你想让你的函数接受可变数量的参数时，就会用到它。下面是一些例子：|71016|def+foo(a,+*b):
++++print(b)
foo(1)+#+()
foo(1,2,3,4,5)+#+(2,3,4,5)|71017|我建议你阅读以下内容：|71018|71019|PEP+3132+--+Extended+Iterable+Unpacking|unordered-list-item|71020|Understanding+the+asterisk(*)+of+Python.|71021|Unpacking+Argument+Lists.|71022|Keyword+Arguments|71023|71024|71025|在列表和元组之间的区别上，最大的区别是可变性。列表是可变的，而元组不是。这意味着这是可行的：|71026|myList+=+[1,+2,+3]
myList[1]+=+4
print(myList)+#+[1,+4,+3]|71027|而这并不是：|71028|myTuple+=+(1,+2,+3)
myTuple[1]+=+4+#+TypeError:+'tuple'+object+does+not+support+item+assignment|71029|在本例中，b是列表的原因：|71030|a,+*b,+c+=+1,2,3,4,5+
print(b)+#+[2,+3,+4]|71031|而不是元组(就像在函数中使用*args时的情况一样)，这是因为在赋值之后，您可能想要对b做一些事情，所以最好将其设置为列表，因为列表是可变的。将其设置为元组而不是列表是在将其作为特性接受之前考虑的可能更改之一，如PEP+3132中所讨论的那样|71032|71033|使带星号的目标成为元组而不是列表。这将与函数的*args一致，但会使进一步处理结果变得更加困难。|blockquote|71034|71035|entityMap|0|LINK|mutability|MUTABLE|url|https://www.python.org/dev/peps/pep-3132/|1|2|https://medium.com/understand-the-python/understanding-the-asterisk-of-python-8b9daaa4a558|3|https://docs.python.org/3/tutorial/controlflow.html#tut-unpacking-arguments|4|https://docs.python.org/3/tutorial/controlflow.html#keyword-arguments|5|https://www.python.org/dev/peps/pep-3132/#acceptance^0|J|2|1N|8|0|0|0|A|2|0|0|0|0|0|13|1|0|0|13|2|0|0|O|3|0|0|H|4|0|0|0|0|0|0|0|5|1|0|0|E|5|17|1|2Y|8|5|0|0|0|0^^$0|@$1|2|3|4|5|6|7|22|8|@$9|23|A|24|B|C]]|D|@$9|25|A|26|1|27]]|E|$]]|$1|F|3|G|5|H|7|28|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|29|8|@$9|2A|A|2B|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|2C|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|2D|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|2E|8|@]|D|@]|E|$]]|$1|R|3|S|5|T|7|2F|8|@]|D|@$9|2G|A|2H|1|2I]]|E|$]]|$1|U|3|V|5|T|7|2J|8|@]|D|@$9|2K|A|2L|1|2M]]|E|$]]|$1|W|3|X|5|T|7|2N|8|@]|D|@$9|2O|A|2P|1|2Q]]|E|$]]|$1|Y|3|Z|5|T|7|2R|8|@]|D|@$9|2S|A|2T|1|2U]]|E|$]]|$1|10|3|-4|5|6|7|2V|8|@]|D|@]|E|$]]|$1|11|3|-4|5|6|7|2W|8|@]|D|@]|E|$]]|$1|12|3|13|5|6|7|2X|8|@]|D|@]|E|$]]|$1|14|3|15|5|H|7|2Y|8|@]|D|@]|E|$I|J]]|$1|16|3|17|5|6|7|2Z|8|@]|D|@]|E|$]]|$1|18|3|19|5|H|7|30|8|@]|D|@]|E|$I|J]]|$1|1A|3|1B|5|6|7|31|8|@$9|32|A|33|B|C]]|D|@]|E|$]]|$1|1C|3|1D|5|H|7|34|8|@]|D|@]|E|$I|J]]|$1|1E|3|1F|5|6|7|35|8|@$9|36|A|37|B|C]|$9|38|A|39|B|C]]|D|@$9|3A|A|3B|1|3C]]|E|$]]|$1|1G|3|-4|5|6|7|3D|8|@]|D|@]|E|$]]|$1|1H|3|1I|5|1J|7|3E|8|@]|D|@]|E|$]]|$1|1K|3|-4|5|6|7|3F|8|@]|D|@]|E|$]]|$1|1L|3|-4|5|6|7|3G|8|@]|D|@]|E|$]]]|1M|$1N|$5|1O|1P|1Q|E|$1R|1S]]|1T|$5|1O|1P|1Q|E|$1R|1S]]|1U|$5|1O|1P|1Q|E|$1R|1V]]|1W|$5|1O|1P|1Q|E|$1R|1X]]|1Y|$5|1O|1P|1Q|E|$1R|1Z]]|20|$5|1O|1P|1Q|E|$1R|21]]]]

When used in an assignment, Python will try to make <code>*b</code> match to whatever it needs in order to make the assignment work (this is new in Python 3, see <a href="https://www.python.org/dev/peps/pep-3132/" rel="nofollow noreferrer">PEP 3132</a>). These are both valid:

<pre><code>a, *b, c = 1,4
print(b) # []

a, *b, c = 1,2,3,4,5 
print(b) # [2, 3, 4]
</code></pre>

When used in a function, if <code>*b</code> is the second parameter in the function definition, it will match with the second to last arguments in the function call, if there are any. It's used when you want your function to accept a variable number of parameters. Some examples:

<pre><code>def foo(a, *b):
 print(b)
foo(1) # ()
foo(1,2,3,4,5) # (2,3,4,5)
</code></pre>

I recommend you read the following:

<ul>
<li><a href="https://www.python.org/dev/peps/pep-3132/" rel="nofollow noreferrer">PEP 3132 -- Extended Iterable Unpacking</a></li>
<li><a href="https://medium.com/understand-the-python/understanding-the-asterisk-of-python-8b9daaa4a558" rel="nofollow noreferrer">Understanding the asterisk(*) of Python</a>.</li>
<li><a href="https://docs.python.org/3/tutorial/controlflow.html#tut-unpacking-arguments" rel="nofollow noreferrer">Unpacking Argument Lists</a>.</li>
<li><a href="https://docs.python.org/3/tutorial/controlflow.html#keyword-arguments" rel="nofollow noreferrer">Keyword Arguments</a></li>
</ul>

<hr>

On the difference between lists and tuples, the big one is mutability. Lists are mutable, tuples aren't. That means that this works:

<pre><code>myList = [1, 2, 3]
myList[1] = 4
print(myList) # [1, 4, 3]
</code></pre>

And this doesn't:

<pre><code>myTuple = (1, 2, 3)
myTuple[1] = 4 # TypeError: 'tuple' object does not support item assignment
</code></pre>

The reason why <code>b</code> is a list in this case:

<pre><code>a, *b, c = 1,2,3,4,5 
print(b) # [2, 3, 4]
</code></pre>

And not a tuple (as is the case when using <code>*args</code> in a function), is because you'll probably want to do something with <code>b</code> after the assignment, so it's better to make it a list since lists are mutable. Making it a tuple instead of a list is one of the possible changes that were considered before this was accepted as a feature, as discussed in <a href="https://www.python.org/dev/peps/pep-3132/#acceptance" rel="nofollow noreferrer">PEP 3132</a>:

<blockquote>
 Make the starred target a tuple instead of a list. This would be
 consistent with a function's *args, but make further processing of the
 result harder.
</blockquote>

In Python, varargs collection seems to work quite differently from how sequence unpacking works in assignment statements. I'm trying to understand the reason for this potentially confusing difference. I'm sure there is a good reason, but what is it?

<pre class="lang-py prettyprint-override"><code>
# Example 1 with assignment statement
a, *b, c = 1,2,3,4
print(b) # [2, 3]

# Example 1 with function call
def foo(a, *b, c):
 print(b)
foo(1,2,3,4)
</code></pre>

The function call results in the following error:

<pre><code>Traceback (most recent call last):
 File "&lt;pyshell#309&gt;", line 1, in &lt;module&gt;
 foo(1,2,3,4)
TypeError: foo() missing 1 required keyword-only argument: 'c'
</code></pre>

Question 1: Why is b not assigned similar to how it is done in the assignment statement?

<pre class="lang-py prettyprint-override"><code># Example 2 with function call
def foo(*x):
 print(x)
 print(type(x))
foo(1,2,3) # (1, 2, 3) &lt;class 'tuple'&gt;

# Example 2 with assignment statement
a, *b, c = 1,2,3,4,5
print(b) # [2, 3, 4]
print(type(b)) # &lt;class 'list'&gt;
</code></pre>

Question 2: Why the difference in type (list vs tuple)?

Why does * work differently in assignment statements versus function calls?

Python

在Python中，varargs集合的工作方式似乎与赋值语句中序列解包的工作方式截然不同。我正在试图理解这种潜在的令人困惑的差异的原因。我相信有一个很好的理由，但它是什么呢？# Example 1 with assignment statementa, *b, c = 1,2,3,4print(b) # [2, 3]#...

问为什么*在赋值语句和函数调用中的工作方式不同？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么*在赋值语句和函数调用中的工作方式不同？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么*在赋值语句和函数调用中的工作方式不同？
EN