blocks|key|950649|text|_是for循环和元组赋值中被忽略成员的标准占位符名称，例如|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|950650|[''+for+_+in+myList]

[a%2Bd+for+a,+_,+_,+d,+_+in+fiveTuples]|code-block|syntax|javascript|950651|顺便说一句，你的列表可以在没有列表理解的情况下编写(假设你想创建一个不可变成员的列表，比如字符串、整数等)。|950652|['']+*+len(myList)|950653|entityMap^0|0|1|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|$]]

<code>_</code> is a standard placeholder name for ignored members in a for-loop and tuple assignment, e.g.

<pre><code>['' for _ in myList]

[a+d for a, _, _, d, _ in fiveTuples]
</code></pre>

BTW your list could be written without list comprehension (assuming you want to make a list of immutable members like strings, integers etc.).

<pre><code>[''] * len(myList)
</code></pre>

blocks|key|950683|text|不是的。正如禅宗所说:特殊情况还不足以打破规则。特殊情况是循环不使用正在迭代的对象的项，规则是有一个“目标”可以解包。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|950684|但是，您可以使用_作为变量名，这通常被理解为“故意不使用”(甚至连PyLint等都知道并尊重这一点)。|offset|length|style|CODE|950685|entityMap^0|0|8|1|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

No. As the Zen puts it: Special cases aren't special enough to break the rules. The special case being loops not using the items of the thing being iterated and the rule being that there's a "target" to unpack to.

You can, however, use <code>_</code> as variable name, which is usually understood as "intentionally unused" (even PyLint etc. knows and respect this).

blocks|key|734849|text|事实证明，使用dummy*+(起始词是dummy)作为变量名可以实现与_相同的功能。_是一个已知的标准，最好使用有意义的变量名。所以你可以使用dummy，dummy1，dummy_anything。通过使用这些变量名，PyLint不会抱怨。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|734850|entityMap^0|7|6|Z|1|16|1|1Z|5|25|6|2C|E|31|6|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]|$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|G|$]]

It turns out that using <code>dummy*</code> (starting word is dummy) as the variable name does the same trick as <code>_</code>. <code>_</code> is a known standard and it would be better to use meaningful variable names. So you can use <code>dummy</code>, <code>dummy1</code>, <code>dummy_anything</code>. By using these variable names <code>PyLint</code> won't complain.

blocks|key|951027|text|在同一行的for循环之后添加以下注释：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|951028|#pylint:禁用=未使用的变量|951029|for+i+in+range(100):+#pylint:+disable=unused-variable|code-block|syntax|javascript|951030|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Add the following comment after the for loop on the same line:

#pylint: disable=unused-variable

<pre><code>for i in range(100): #pylint: disable=unused-variable
</code></pre>

blocks|key|950861|text|如果您需要为参数命名(例如，在编写不使用通过名称引用的某些参数的模拟时)，您可以添加此快捷方式方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|950862|def+UnusedArgument(_):
++pass|code-block|syntax|javascript|950863|然后像这样使用它|950864|def+SomeMethod(name_should_remain):
++UnusedArgument(name_should_remain)|950865|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

If you need to name your arguments (in case, for example, when writing mocks that don't use certain arguments that are referenced by name), you can add this shortcut method:

<pre><code>def UnusedArgument(_):
 pass
</code></pre>

and then use it like this

<pre><code>def SomeMethod(name_should_remain):
 UnusedArgument(name_should_remain)
</code></pre>

blocks|key|734622|text|生成器对象实际上并不使用变量。所以就像这样|type|unstyled|depth|inlineStyleRanges|entityRanges|data|734623|list((''+for+x+in+myList))|code-block|syntax|javascript|734624|应该能行得通。请注意，x没有被定义为生成器理解之外的变量。|734625|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|$]]

The generator objects don't actually use the variables. So something like

<pre><code>list(('' for x in myList))
</code></pre>

should do the trick. Note that x is not defined as a variable outside of the generator comprehension.

blocks|key|950981|text|如果您喜欢为变量指定一个人类可读的名称，也可以在变量名称前面加上_。例如，你可以使用_foo，_foo1，_anything和PyLint都不会抱怨。在for循环中，它将如下所示：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|950982|for+_something+in+range(10):
++++do_something_else()|code-block|syntax|javascript|950983|编辑:添加示例|950984|entityMap^0|W|1|16|4|1B|5|1H|9|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|N|$]]

You can also prepend a variable name with <code>_</code> if you prefer giving the variable a human readable name. For example you can use <code>_foo</code>, <code>_foo1</code>, <code>_anything</code> and PyLint won't complain. In a for loop, it would be like:

<pre class="lang-py prettyprint-override"><code>for _something in range(10):
 do_something_else()
</code></pre>

edit: Add example

blocks|key|951083|text|一种详细的方式是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|951084|newList+=+[]
while+len(newList)+<+len(mylist):
++++newList.append('')|code-block|syntax|javascript|951085|可以避免以这种方式声明已使用的变量。|951086|您还可以将可变和不可变对象(如字典)添加到newList中。|offset|length|style|CODE|951087|另外，对于像我这样的python新手来说，'_'，'dummy‘有点令人不安。|951088|entityMap^0|0|0|0|L|7|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|V|8|@$K|W|L|X|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

A verbose way is:

<pre><code>newList = []
while len(newList) &lt; len(mylist):
 newList.append('')
</code></pre>

You avoid declaring an used variable this way.

Also you can append both mutable and immutable objects (like dictionaries) into <code>newList</code>. 

Another thing for python newbies like me, '_', 'dummy' are a bit disconcerting.

blocks|key|950781|text|注释到How+can+I+get+around+declaring+an+unused+variable+in+a+for+loop?+(已用完注释大小)|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|950782|Python为创建的对象维护相同的引用。(与可变性无关)，例如，|950783|In+[1]:+i+=+1

In+[2]:+j+=+1

In+[3]:+id(i)
Out[3]:+142671248

In+[4]:+id(j)
Out[4]:+142671248|code-block|syntax|javascript|950784|你可以看到i和j，在memory.What中引用相同的对象，当我们改变一个不可变变量的值时。|950785|In+[5]:+j+=+j%2B1

In+[6]:+id(i)
Out[6]:+142671248

In+[7]:+id(j)
Out[7]:+142671236|950786|您可以看到j现在开始指向一个新的位置(存储2的位置)，而我仍然指向存储1的位置。在评估时，|950787|j+=+j%2B1|950788|从142671248中挑选该值，计算(如果尚未缓存)，并将其放置在新位置142671236。使J指向新位置。简而言之，每次修改不可变变量时，都会创建一个新的副本。|950789|易变性|950790|在这一点上，可变对象的行为没有什么不同。所指向的值|950791|In+[16]:+a+=+[]

In+[17]:+b+=+a

In+[18]:+id(a)
Out[18]:+3071546412L

In+[19]:+id(b)
Out[19]:+3071546412L|950792|A和B都指向相同的内存位置。|950793|In+[20]:+a.append(5)|950794|A所指向的内存位置被修改。|950795|In+[21]:+a
Out[21]:+[5]

In+[22]:+b
Out[22]:+[5]

In+[23]:+id(a)
Out[23]:+3071546412L

In+[24]:+id(b)
Out[24]:+3071546412L|950796|A和b仍然指向相同的存储器位置。换句话说，可变变量与变量所指向的内存位置相同，而不是复制变量所指向的值，就像不可变变量那样。|950797|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/5477134/how-can-i-get-around-declaring-an-unused-variable-in-a-for-loop/5477153#5477153^0|3|1S|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1I|8|@]|9|@$A|1J|B|1K|1|1L]]|C|$]]|$1|D|3|E|5|6|7|1M|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|1N|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|1O|8|@]|9|@]|C|$]]|$1|M|3|N|5|H|7|1P|8|@]|9|@]|C|$I|J]]|$1|O|3|P|5|6|7|1Q|8|@]|9|@]|C|$]]|$1|Q|3|R|5|H|7|1R|8|@]|9|@]|C|$I|J]]|$1|S|3|T|5|6|7|1S|8|@]|9|@]|C|$]]|$1|U|3|V|5|6|7|1T|8|@]|9|@]|C|$]]|$1|W|3|X|5|6|7|1U|8|@]|9|@]|C|$]]|$1|Y|3|Z|5|H|7|1V|8|@]|9|@]|C|$I|J]]|$1|10|3|11|5|6|7|1W|8|@]|9|@]|C|$]]|$1|12|3|13|5|H|7|1X|8|@]|9|@]|C|$I|J]]|$1|14|3|15|5|6|7|1Y|8|@]|9|@]|C|$]]|$1|16|3|17|5|H|7|1Z|8|@]|9|@]|C|$I|J]]|$1|18|3|19|5|6|7|20|8|@]|9|@]|C|$]]|$1|1A|3|-4|5|6|7|21|8|@]|9|@]|C|$]]]|1B|$1C|$5|1D|1E|1F|C|$1G|1H]]]]

Comment to <a href="https://stackoverflow.com/questions/5477134/how-can-i-get-around-declaring-an-unused-variable-in-a-for-loop/5477153#5477153">How can I get around declaring an unused variable in a for loop?</a> (Ran out of comment size)

Python maintains the same reference for the object created. (irrespective of mutability),for example,

<pre><code>In [1]: i = 1

In [2]: j = 1

In [3]: id(i)
Out[3]: 142671248

In [4]: id(j)
Out[4]: 142671248
</code></pre>

You, can see both i and j, refer to the same object in memory.What happens, when we change the value of one immutable variable.

<pre><code>In [5]: j = j+1

In [6]: id(i)
Out[6]: 142671248

In [7]: id(j)
Out[7]: 142671236
</code></pre>

you can see j now starts to point a new location, (where 2 is stored), and i still points to location where 1 is stored.
While evaluating, 

<pre><code>j = j+1
</code></pre>

The value is picked from 142671248, calculated(if not already cached), and put at a new location 142671236. j is made to point to
the new location. In simpler terms a new copy made everytime an immutable variable is modified.

<h2>Mutability</h2>

Mutable objects act little different in this regard. When the value pointed by

<pre><code>In [16]: a = []

In [17]: b = a

In [18]: id(a)
Out[18]: 3071546412L

In [19]: id(b)
Out[19]: 3071546412L
</code></pre>

Both a and b point to the same memory location.

<pre><code>In [20]: a.append(5)
</code></pre>

Memory location pointed by a is modified.

<pre><code>In [21]: a
Out[21]: [5]

In [22]: b
Out[22]: [5]

In [23]: id(a)
Out[23]: 3071546412L

In [24]: id(b)
Out[24]: 3071546412L
</code></pre>

Both a and b, still point to the same memory location. In other word, mutable variables act of the same memory location pointed by the variable, instead of making a copy of the value pointed by the variable, like in immutable variable case.

If I have a list comprehension (for example) like this:

<pre><code>['' for x in myList]
</code></pre>

Effectively making a new list that has an empty string for every element in a list, I never use the <code>x</code>. Is there a cleaner way of writing this so I don't have to declare the unused <code>x</code> variable?

How can I get around declaring an unused variable in a for loop?

Python

如果我有一个这样的列表理解(例如)：['' for x in myList]有效地创建了一个新列表，该列表中的每个元素都有一个空字符串，因此我从不使用x。有没有一种更干净的方式来写这段代码，这样我就不必声明未使用的x变量？

问如何避免在for循环中声明未使用的变量？
EN

回答 9

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何避免在for循环中声明未使用的变量？EN

回答 9

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何避免在for循环中声明未使用的变量？
EN