Python-For循环和计数器

我目前正在编写一个程序，它使用“for”循环和range函数来处理从999到零的所有整数。我必须在一行上用空格分隔40的循环倍数，但一行上只有6。我遇到的问题是实现一个计数器来确定何时打印了六个倍数

输出应如下所示：

所需输出

960 920 880 840 800 760 
720 680 640 600 560 520 
480 440 400 360 320 280 
240 200 160 120 80 40

目前我有：

def main():
   count = 0
   for num in range(960, 0, -40):
        print(num, end=' ') 
main()

---

我知道这应该很简单，但我正在努力将范围格式化为6列。任何帮助都将不胜感激

您可以使用Python的模运算符%来确定计数是否可被6整除。这也许不是最漂亮的答案，但是：

def main():
   count = 0
   for num in range(960, 0, -40):
        count += 1
        print(num, end=' ')
        if count % 6 == 0:
            print('')
main()

这应该起作用：

def main():
   count = 0
   for num in range(960, 0, -40):
        count += 1
        if count % 6 == 0:
            print(num, end='\n')
        else:
            print(num, end=' ')
main()

---

基本上相同的函数，只是我们检查计数是否可以被6整除，如果可以，则为下一行打印一行。

在每个循环中递增计数器，并在达到6后将其重置为零

def main():
   counter = 0
   for number in range(960, 0, -40):
       counter += 1
       print(number, end=' ')
       if counter  == 6:
           counter = 0
           print('')
main()

---

可以使用Python的

enumerate

作为计数器，并使用条件表达式使代码更加紧凑：

for i, number in enumerate(range(960, 0, -40), 1):
    print(number, end=' ' if i%6 else '\n')

这是Python3代码。对于Python 2，在文件顶部添加以下行：

from __future__ import print_function

---

这也许是不合理的，但我讨厌循环中的计数器。在这个特殊的例子中，您是否想过在混合中嵌入一个生成器？对于更复杂的情况，这是一种方便的模式：

def print_newline_after_x_iterations(my_range, x):
    i = my_range.__iter__()
    while True:
        try:
            for _ in range(x):
                yield next(i)
            print()
        except StopIteration:
            break

def main2():
    for num in print_newline_after_x_iterations(range(960, 0, -40), x=6):
        print(num, end=' ') 

输出：

>>> main2()
960 920 880 840 800 760 
720 680 640 600 560 520 
480 440 400 360 320 280 
240 200 160 120 80 40 

>>> main3()
960 920 880 840 800 760 
720 680 640 600 560 520 
480 440 400 360 320 280 
240 200 160 120 80 40 

或者甚至使用基于共同例程的版本：

def coroutine(f):
    def wrap(*args, **kwargs):
        x = f(*args, **kwargs)
        next(x)
        return x
    return wrap


@coroutine
def printer():
    while True:
        msg, end = yield
        print(str(msg), end=end)


@coroutine
def columnator(columns=6, outputer=printer):
    p = printer()
    try:
        while True:
            for _ in range(columns):
                p.send(((yield), " "))
            p.send(("", "\n"))
    except GeneratorExit as err:
        p.send(("", "\n"))


def main3():
    s = columnator(6, outputer=printer)
    for num in range(960, 0, -40):
        s.send(num)
    s.close()

输出：

>>> main2()
960 920 880 840 800 760 
720 680 640 600 560 520 
480 440 400 360 320 280 
240 200 160 120 80 40 

>>> main3()
960 920 880 840 800 760 
720 680 640 600 560 520 
480 440 400 360 320 280 
240 200 160 120 80 40 

这是一个两步任务（使用Python 2.7x）：

1.将40的倍数的所有整数放入一个列表中

2.以上列表每6个元素拆分一次，并格式化输出

>>> n=[str(x) for x in range(999,0,-1) if x%40 == 0]
>>> for x in [n[6*i:6*(i+1)] for i in range(len(n)/6)]:
...     print ' '.join(x)
...
960 920 880 840 800 760
720 680 640 600 560 520
480 440 400 360 320 280
240 200 160 120 80 40

---

非常感谢。我有一种感觉，我需要使用股息操作符，因为我的教科书关注了一会儿。我会回去仔细研究的。：）是的，但如果您想在处理更大数据时使用红利运算符获得更快的响应，则需要额外的开销。使用“time”在一个循环中运行程序一千次，看看有无红利操作符的性能差异。这是我最喜欢的答案。非常像蟒蛇。与我的答案相比，我更喜欢它，尽管正如我所描述的，我是在为更复杂的场景建议一种模式。