Question

我想创建一个无限循环，该循环从0到100到0到0（依此类推）计数，并且仅在满足循环中的某些收敛条件时才停止，所以基本上是这样的：

for i in range(0, infinity):
    for j in range(0, 100, 1):
        print(j) # (in my case 100 lines of code)
    for j in range(100, 0, -1):
        print(j) # (same 100 lines of code as above)

有没有办法将j上的两个for循环合并为一个，这样我就不会在循环内两次写相同的代码了？

Answer 1

使用chain的{{1}}方法

itertools

如@Chepner所建议，您可以将import itertools for i in range(0, infinity): for j in itertools.chain(range(0, 100, 1), range(100, 0, -1)): print(j) # (in my case 100 lines of code)用于无限循环：

itertools.cycle()

Answer 2

以及其他答案，您可以使用一些数学运算：

while(True):
    for i in range(200):
        if i > 100:
            i = 200 - i

Answer 3

这里还有另一种可能性：

while notConverged:
    for i in xrange(-100, 101):
        print 100 - abs(i)

Answer 4

如果您有重复的代码集，请使用一个函数来节省空间和精力：

def function(x, y, x, num_from_for_loop):
    # 100 lines of code 

while not condition:
    for i in range(1, 101):
        if condition:
            break
        function(x, y, z, i)
    for i in range(100, 0, -1):
        if condition:
            break
        function(x, y, z, i)

您甚至可以使用while True

Answer 5

如果您使用的是Python 3.5+，则可以使用常规拆包：

for j in (*range(0, 100, 1), *range(100, 0, -1)):

或在Python 3.5之前，您可以使用itertools.chain：

from itertools import chain

...

for j in chain(range(0, 100, 1), range(100, 0, -1)):

Answer 6

up = True # since we want to go from 0 to 100 first

while True: #for infinite loop

    # For up == True we will print 0-->100 (0,100,1)
    # For up == False we will print 100-->0 (100,0,-1)


    start,stop,step = (0,100,1) if up else (100,0,-1)
    for i in range(start,stop,step):
        print(i)

    up = not up # if we have just printed from 0-->100 (ie up==True), we want to print 100-->0 next so make up False ie up = not up( True) 

    # up will help toggle, between 0-->100 and 100-->0

Answer 7

def up_down(lowest_value, highest_value):
    current = lowest_value
    delta = 1
    while True: # Begin infinite loop
        yield current
        current += delta
        if current <= lowest_value or current >= highest_value:
            delta *= -1 # Turn around when either limit is hit

这定义了一个生成器，只要需要，它将继续产生值。例如：

>>> u = up_down(0, 10)
>>> count = 0
>>> for j in u:
    print(j) # for demonstration purposes
    count += 1 # your other 100 lines of code here
    if count >= 25: # your ending condition here
        break


0
1
2
3
4
5
6
7
8
9
10
9
8
7
6
5
4
3
2
1
0
1
2
3
4

Answer 8

与直接回答问题相比，这更多是部分答案，但您也可以使用三角函数及其振荡的概念来模仿“来回”循环。

如果我们有一个振幅为100的cos函数，并向左和向上移动，使得f(x) = 0和0 <= f(x) <= 100，则我们有公式f(x) = 50(cos(x-pi)+1)（可以找到图形的图here。范围是您所需要的，并且会发生振荡，因此不需要取反任何值。

>>> from math import cos, pi
>>> f = lambda x: 50*(cos(x-pi)+1)
>>> f(0)
0.0
>>> f(pi/2)
50.0
>>> f(pi)
100.0
>>> f(3*pi/2)
50.0
>>> f(2*pi)
0.0

当然，问题在于该函数不能这么容易地给出整数值，因此并不是那么有用-但这可能对将来的读者有用，因为三角函数可能会对他们的情况有所帮助。

Answer 9

前段时间我遇到了类似的问题，我也想以无限三角波的形式创建值，但想跨步一些值。我最终使用了一个生成器（和其他范围函数也一直在使用）：

private String saveToInternalStorage(Bitmap bitmapImage){
    ContextWrapper cw = new ContextWrapper(getApplicationContext());
     // path to /data/data/yourapp/app_data/imageDir
    File directory = cw.getDir("imageDir", Context.MODE_PRIVATE);
    // Create imageDir
    File mypath=new File(directory,"profile.jpg");

    FileOutputStream fos = null;
    try {           
        fos = new FileOutputStream(mypath);
   // Use the compress method on the BitMap object to write image to the OutputStream
        bitmapImage.compress(Bitmap.CompressFormat.PNG, 100, fos);
    } catch (Exception e) {
          e.printStackTrace();
    } finally {
        try {
          fos.close();
        } catch (IOException e) {
          e.printStackTrace();
        }
    } 
    return directory.getAbsolutePath();
}

精心选择了最小值，最大值和步长值（即均分），

def tri_wave(min, max, step=1):
    while True:
        yield from range(min, max, step)
        yield from range(max, min, -1 * step)

我只获得一次最小值和最大值，这是我的目标：

for value in tri_wave(0, 8, 2):
    print(value, end=", ")

我当时使用的是Python 3.6。

Answer 10

我很好奇是否有可能在没有条件和枚举的情况下实现这种三角振荡器。好吧，一种选择如下：

def oscillator(magnitude):
   i = 0
   x = y = -1
   double_magnitude = magnitude + magnitude

   while True:
       yield i
       x = (x + 1) * (1 - (x // (double_magnitude - 1)))  # instead of (x + 1) % double_magnitude
       y = (y + 1) * (1 - (y // (magnitude - 1)))         # instead of (y + 1) % magnitude
       difference = x - y                                 # difference ∈ {0, magnitude}
       derivative = (-1 * (difference > 0) + 1 * (difference == 0))
       i += derivative

其背后的想法是采用两个周期不同的锯齿波，然后从另一个中减去一个。结果将是一个方波，其值为{0，幅值}。然后我们分别用{-1，+1}代替{0，幅值}以获得目标信号的导数。

让我们看一下magnitude = 5的示例：

o = oscillator(5)
[next(o) for _ in range(21)]

这将输出[0, 1, 2, 3, 4, 5, 4, 3, 2, 1, 0, 1, 2, 3, 4, 5, 4, 3, 2, 1, 0]。

如果允许abs()，则可以简化使用。例如，以下代码提供与上面相同的输出：

[abs(5 - ((x + 5) % 10)) for x in range(21)]

来回循环Python

10 个答案: