Python 使用嵌套循环进行更大的重复，还是将整个范围放在一个循环中更好？哪个更快/更简单？

哪一个更好

for x in range(0,100):
   print("Lorem Ipsum")

---

---

第一个更容易阅读和理解。用那个

关于性能，我怀疑它有什么区别，如果有，0-100更快，因为它的代码更小（如果没有优化双循环），因此代码路径更小

---

如果对这些事情有疑问，请使用阅读代码时更容易理解的方法。过早优化是一种罪过。

第二种方法更难阅读，并且您构建了一个不必要的

范围
可重用（Python 2中的
列表
，Python 3中的
范围
对象消耗的内存更少，创建速度更快）

内部
for
循环从不必要的iterable构造了一个不必要的迭代器（Python 2中是
list\u迭代器，Python 3中是
range\u迭代器）。
您可以使用
dis
From
dis
模块来分解和分析哪个循环的字节码更好（在某种程度上，您的循环需要更少的内存、更少的迭代器等…）

以下是回溯：

from dis import dis
def loop1():
    for x in range(100):
        pass

def loop2():
    for x in range(10):
        for j in range(10):
            pass

现在查看每个环的罩下：

dis(loop1)
  2           0 SETUP_LOOP              20 (to 23)
              3 LOAD_GLOBAL              0 (range)
              6 LOAD_CONST               1 (100)
              9 CALL_FUNCTION            1 (1 positional, 0 keyword pair)
             12 GET_ITER
        >>   13 FOR_ITER                 6 (to 22)
             16 STORE_FAST               0 (x)

  3          19 JUMP_ABSOLUTE           13
        >>   22 POP_BLOCK
        >>   23 LOAD_CONST               0 (None)
             26 RETURN_VALUE

并查看第二个循环中所需的数据量和操作量：

dis(loop2)
  2           0 SETUP_LOOP              43 (to 46)
              3 LOAD_GLOBAL              0 (range)
              6 LOAD_CONST               1 (10)
              9 CALL_FUNCTION            1 (1 positional, 0 keyword pair)
             12 GET_ITER
        >>   13 FOR_ITER                29 (to 45)
             16 STORE_FAST               0 (x)

  3          19 SETUP_LOOP              20 (to 42)
             22 LOAD_GLOBAL              0 (range)
             25 LOAD_CONST               1 (10)
             28 CALL_FUNCTION            1 (1 positional, 0 keyword pair)
             31 GET_ITER
        >>   32 FOR_ITER                 6 (to 41)
             35 STORE_FAST               1 (j)

  4          38 JUMP_ABSOLUTE           32
        >>   41 POP_BLOCK
        >>   42 JUMP_ABSOLUTE           13
        >>   45 POP_BLOCK
        >>   46 LOAD_CONST               0 (None)
             49 RETURN_VALUE

因为，两个循环都做相同的事情，第一个循环要好得多。
试想一下，如何将嵌套循环修改为101次而不是100次，缺点是显而易见的。
第二个循环毫无意义。除非需要在两件事上循环。嵌套循环不会被优化掉。
dis(loop2)
  2           0 SETUP_LOOP              43 (to 46)
              3 LOAD_GLOBAL              0 (range)
              6 LOAD_CONST               1 (10)
              9 CALL_FUNCTION            1 (1 positional, 0 keyword pair)
             12 GET_ITER
        >>   13 FOR_ITER                29 (to 45)
             16 STORE_FAST               0 (x)

  3          19 SETUP_LOOP              20 (to 42)
             22 LOAD_GLOBAL              0 (range)
             25 LOAD_CONST               1 (10)
             28 CALL_FUNCTION            1 (1 positional, 0 keyword pair)
             31 GET_ITER
        >>   32 FOR_ITER                 6 (to 41)
             35 STORE_FAST               1 (j)

  4          38 JUMP_ABSOLUTE           32
        >>   41 POP_BLOCK
        >>   42 JUMP_ABSOLUTE           13
        >>   45 POP_BLOCK
        >>   46 LOAD_CONST               0 (None)
             49 RETURN_VALUE