Python：显然我无法理解 For 循环的概念

发布于 2024-09-29 13:28:52 字数 1774 浏览 2 评论 0原文

我有一个包含 400 个数字的列表，我想使用 Python 将它们放在 20x20 网格中。

我制作了一个“二维数组”（并不是真的因为Python不支持它们，我不得不使用列表的列表。）

当我尝试循环并将每个后续项目分配给网格中的下一个框时，失败了。我最终将列表中的最后一项分配给每个框。

这是代码：

numbers = "08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08 49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00 81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65 52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91 22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80 24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50 32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70 67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21 24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72 21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95 78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92 16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57 86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58 19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40 04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66 88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69 04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36 20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16 20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54 01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48"
grid = [[0 for col in range(20)] for row in range(20)]

for x in range(0, 1200, 3):
    y = x + 2
    a = numbers[x:y]
    for i in range(20):
        for j in range(20):
            grid[i][j] = a

print(grid)

我可以明白为什么会出错：生成列表坐标的两个循环位于从列表中获取每个项目的循环内部，因此每次运行它们分配的值都不会改变。

因此，我想既然它们不在循环中工作，它们就需要脱离循环。

问题是我无法弄清楚具体在哪里。

有人帮我一下吗？

原文

I've got a list of 400 numbers, and i want to but them in a 20x20 grid using Python.

I've made a "2d array" (not really because Python doesn't support them, I've had to use a list of lists.)

When i try to loop through and assign each subsequnt item to the next box in the grid, it fails. i end up assinging the last item in the list to every box.

Here's the code:

numbers = "08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08 49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00 81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65 52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91 22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80 24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50 32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70 67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21 24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72 21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95 78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92 16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57 86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58 19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40 04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66 88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69 04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36 20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16 20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54 01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48"
grid = [[0 for col in range(20)] for row in range(20)]

for x in range(0, 1200, 3):
    y = x + 2
    a = numbers[x:y]
    for i in range(20):
        for j in range(20):
            grid[i][j] = a

print(grid)

I can see why it's going wrong: the two loops that generate the list coordinates are inside the loop that gets each items from the list, so each time they run the value they are assigning doesn't change.

Therefore I guess seeing as they don't work in the loop, they need to be out of it.

The problem is that I can't work out where exactly.

Anyone give me a hand?

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

错々过的事 2024-10-06 13:28:52

这正是列表推导式所擅长的事情。

nums = iter(numbers.split())
grid = [[next(nums) for col in range(20)] for row in range(20)]

或者，作为 for 循环：

grid = [[0]*20 for row in range(20)]
nums = iter(numbers.split())
for i in xrange(20):
    for j in xrange(20):
        grid[i][j] = next(nums)

我不建议您这样做，但如果您不只是想拆分列表然后调用 next 在其迭代器上的方法是编写一个生成器来按照原来的方式解析列表，然后调用 next 。我指出这一点是因为在某些情况下内置函数不会为您执行此操作，因此您应该看到该模式（不是设计模式，只是迂腐的模式）：

def items(numbers):
    for x in range(0, len(numbers), 3):
        yield numbers[x:x+2]

 nums = items(numbers)
 for i in xrange(20):
     for j in xrange(20):
         grid[i][j] = next(nums)

这使您可以并行地逐步执行两个循环。

This is the sort of thing that list comprehensions are good for.

nums = iter(numbers.split())
grid = [[next(nums) for col in range(20)] for row in range(20)]

Alternatively, as a for loop:

grid = [[0]*20 for row in range(20)]
nums = iter(numbers.split())
for i in xrange(20):
    for j in xrange(20):
        grid[i][j] = next(nums)

I'm not recommending that you do this, but the way to do it if you don't just want to split the list and then call next on its iterator is to write a generator to parse the list the way that you were and then call next on that. I point this out because there are situations where builtins wont do it for you so you should see the pattern (not Design Pattern, just pattern for the pedantic):

def items(numbers):
    for x in range(0, len(numbers), 3):
        yield numbers[x:x+2]

 nums = items(numbers)
 for i in xrange(20):
     for j in xrange(20):
         grid[i][j] = next(nums)

This lets you step through the two loops in parallel.

回复收藏 0 原文

绝對不後悔。 2024-10-06 13:28:52

另一种选择是使用石斑鱼习语：

nums = iter(numbers.split())
grid = zip(*[nums]*20)

请注意，这会生成 < em>元组，而不是列表的列表。
如果您需要列表的列表，那么

grid = map(list,zip(*[nums]*20))

Another alternative is to use the grouper idiom:

nums = iter(numbers.split())
grid = zip(*[nums]*20)

Note that this makes a list of tuples, not a list of lists.
If you need a list of lists, then

grid = map(list,zip(*[nums]*20))

回复收藏 0 原文

贵在坚持 2024-10-06 13:28:52

您的 for 循环混乱源于循环数量超出了您的需要。

相反，一种方法是首先循环遍历网格方块，然后计算出数字列表中所需的偏移量：

for i in range(20):
  for j in range(20):
    offset = i*20*3 + j*3
    grid[i][j] = numbers[offset:offset+2]

在这种情况下，偏移量有一些常量。 i 是行，因此对于每一行，您需要跳过列表中一行的字符 (60)。 j 是列索引；每列宽 3 个字符。

当然，您可以反向执行此操作。在这种情况下，您将循环遍历数字列表，然后找出它属于哪个网格方块。它的工作原理非常相似，只不过您在上面的偏移量中使用除法和模算术而不是乘法。

希望这能让您深入了解如何使用 for 循环处理多个对象和多个维度。

Your for loop confusion stems from having more loops than you need.

Instead, one approach is to start by looping over your grid squares and then figuring out the needed offset into your list of numbers:

for i in range(20):
  for j in range(20):
    offset = i*20*3 + j*3
    grid[i][j] = numbers[offset:offset+2]

In this case, the offset has a few constants. i is the row, so for each row you need to skip over a row's worth of characters (60) in your list. j is the column index; each column is 3 characters wide.

You could, of course, do this operation in reverse. In that case, you would loop over your list of numbers and then figure out to which grid square it belongs. It works very similarly, except you'd be using division and modulo arithmetic instead of multiplication in the offset above.

Hopefully this provides some insight into how to use for loops to work with multiple objects and multiple dimensions.

回复收藏 0 原文

~没有更多了~