blocks|key|423103|text|不需要while循环。使用for循环：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|423104|>>>+def+f(n):
...+++++for+_+in+range(n):
...+++++++++dostuff()|code-block|syntax|javascript|423105|_在for循环中用作变量名，通常用作占位符。这个循环循环n次。所以f(5)会循环五次。|offset|length|style|CODE|423106|entityMap^0|0|0|0|1|X|4|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

No need for a while-loop. Use a for-loop:

<pre><code>&gt;&gt;&gt; def f(n):
... for _ in range(n):
... dostuff()
</code></pre>

<code>_</code> is used as a variable name in a for loop normally to be a placeholder. This loop loops through n amount of times. So <code>f(5)</code> would loop five times.

blocks|key|423108|text|def+f(c=-1):
++++while+c:
++++++++print+'blah'
++++++++if+c+>+0:+c+-=+1|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|423109|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>def f(c=-1):
 while c:
 print 'blah'
 if c &gt; 0: c -= 1
</code></pre>

blocks|key|1563983|text|虽然我同意其他人的观点，这是一个糟糕的想法，但它完全(而且很容易)是可能的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1563984|class+BoolChange:
++++def+__init__(self):
++++++++self.count+=+0

++++def+__bool__(self):
++++++++self.count+%2B=+1
++++++++return+self.count+<=+5

x+=+BoolChange()
while+x:
++++print("Running")|code-block|syntax|javascript|1563985|这将输出Running五次，然后退出。|offset|length|style|CODE|1563986|这是一个坏主意的主要原因是，这意味着检查对象的状态会修改它，这是人们不会预料到的奇怪行为。我想不出这有什么好的用例。|1563987|entityMap^0|0|0|4|7|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

While I agree with the others that this is a bad idea, it is entirely (and easily) possible:

<pre><code>class BoolChange:
 def __init__(self):
 self.count = 0

 def __bool__(self):
 self.count += 1
 return self.count &lt;= 5

x = BoolChange()
while x:
 print("Running")
</code></pre>

This outputs <code>Running</code> five times, then exits.

The main reason this is a bad idea is that it means checking the state of the object modifies it, which is weird behaviour people won't expect. I can't imagine a good use case for this.

blocks|key|1480433|text|你不能完全按照你所描述的去做。在python中传递的不是表达式，而是一个值。一个对象。不可变对象通常求值为True或False。它在循环期间不会改变。可变对象可以改变它的真值，但是你不能在一个通用的循环中改变任意的对象(它不会以任何方式接触到它)。一般来说，正如这里所说的，你确实需要使用for语句，或者传入一个可调用的对象(比如一个函数)：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1480434|def+f(is_true+=+lambda+x+:+True):
++++while+is_true():
++++++++blah()|code-block|syntax|javascript|1480435|注意，可调用的解决方案是可接受的，而“隐藏在布尔值中”的@Lattyware则不是，原因是这里的附加连接是显式的-+()告诉读者，这里几乎可以发生任何事情，这取决于传递的对象，并且您不需要知道此对象中的__bool__方法是静默调用的，并且预期会有副作用。|1480436|entityMap^0|1H|4|1M|5|40|3|0|0|1M|2|2T|8|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]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|N|$]]

You can't do exactly what you describe. What is passed in python is not an expression, but a value. An object. An Immutable object in general evaluate to either <code>True</code> or to <code>False</code>. It will not change during the loop. Mutable object can change its truth value, but you can't make arbitrary object change during a general loop (which does not touch it in any way). In general, as have been said here, you really need to use <code>for</code> statement, or pass in a callable object (say, a function): 

<pre><code>def f(is_true = lambda x : True):
 while is_true():
 blah()
</code></pre>

Note that the reason that the callable solution is acceptable, while the "hiding in boolean" @Lattyware demonstrated is not, is that the additional coputation here is explicit - the <code>()</code> tells the reader that almost anything can happen here, depending on the object passed, and you don't need to know that the <code>__bool__</code> method in this object is silently called and is expected to have side effect.

blocks|key|423153|text|使用a+generator+as+a+coroutine怎么样？|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|423154|def+blah():
++++print+'hi'

def+f():
++++while+True:
++++++++blah()
++++++++yield

x+=+f()
next(x)+#+"hi"|code-block|syntax|javascript|423155|这里的生成器不是用来产生什么的，但是你可以控制它在外部的blahs次数，因为它在每次blahs的时候都会产生控制。|423156|for+i+in+range(3):
++++next(x)+#+blah+blah+blah|423157|entityMap|0|LINK|mutability|MUTABLE|url|http://www.python.org/dev/peps/pep-0342/^0|2|Q|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

How about using <a href="http://www.python.org/dev/peps/pep-0342/" rel="nofollow">a generator as a coroutine</a>?

<pre><code>def blah():
 print 'hi'

def f():
 while True:
 blah()
 yield

x = f()
next(x) # "hi"
</code></pre>

The generator here isn't be used for what it yields, but you get to control how many times it blahs externally, because it yields control ever time it blahs.

<pre><code>for i in range(3):
 next(x) # blah blah blah
</code></pre>

blocks|key|1480500|text|这也是可行的-|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1480501|def+foo(n=[1,2,3]):
+++++foo.func_defaults+=+tuple([foo.func_defaults[0][:-1]],)
+++++return+n

while+foo():
++++blah()|code-block|syntax|javascript|1480502|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|$]]

This will also work -

<pre><code>def foo(n=[1,2,3]):
 foo.func_defaults = tuple([foo.func_defaults[0][:-1]],)
 return n

while foo():
 blah()
</code></pre>

I have a function

<pre><code> def f():
 while True:
 blah
</code></pre>

I want to alter f in such a way that the caller could control the number of times the while loop in f runs, without altering much of the code in f (specially not adding a counter in f). Something like

<pre><code> def f(num_executions = True):
 while num_executions:
 blah()
</code></pre>

f() will run an infinite loop
but f(an_expression_that_evaluates_to_true_n_times) will run the while loop n times.
What could such an expression be?

UPDATE:
I know, there are plenty of way to control how many times a loop will run, but the real question here is -

Can an expression in python evaluate to True for configurable number of times?

Some ideas I am toying with 

-making an expression out of list = list[:-1]

-modifying default parameters of a function within a function

python expression that evaluates to True n times

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我有一个函数 def f():      while True:           blah我想以这样一种方式修改f，即调用者可以控制f中while循环运行的次数，而不会更改f中的大部分代码(特别是不在f中添加计数器)。就像这样 def f(num_executions = True):      while num...

问计算结果为True n次的python表达式
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问计算结果为True n次的python表达式EN