Python 为什么这个循环不会按照语句的顺序重复？

我在整理程序中的一个循环时遇到了问题，该循环的行为与我预期的不同。此程序允许您播放“连接四”。最后我包括了完整的（可运行的代码）和困扰我的摘录

import numpy as np
import random
import pygame
import time

BOARD_SIZE = 6
BOARD_BOX_NUM = BOARD_SIZE ** 2
GIVEN_IDS = 0

# ------------------------------- setting up pygame  --------------------------------------------
pygame.init()

display_height = 600
display_width = 600

game_display = pygame.display.set_mode((display_width, display_height))

clock = pygame.time.Clock()

# ------------------------------- colours ----------------------------------------------------

white = (255, 255, 255)
black = (0, 0, 0)

blue = (0,0,255)
light_blue = (30, 144, 255)

red = (200, 0, 0)
light_red = (255, 0, 0)

yellow = (200, 200, 0)
light_yellow = (255, 255, 0)

green = (34, 177, 76)
light_green = (0, 255, 0)

# ------------------------------- methods for the game algorythm ------------------------------


def rolling_window(a, size):
    # This method is required for the algorythm that broadcasts the board for a win
    shape = a.shape[:-1] + (a.shape[-1] - size + 1, size)
    strides = a.strides + (a. strides[-1],)
    return np.lib.stride_tricks.as_strided(a, shape=shape, strides=strides)


class Chip:
    def __init__(self, colour):
        if colour == "Blue":
            self.colour = colour
        if colour == "Red":
            self.colour = colour
        global GIVEN_IDS
        self.iD = GIVEN_IDS
        GIVEN_IDS += 1

    def get_iD(self):
        return self.iD


class Game:
    def __init__(self, player_colour="Blue", comp_colour="Red"):
        self.board = np.empty(BOARD_BOX_NUM, dtype=Chip)
        self.board = self.board.reshape(BOARD_SIZE, BOARD_SIZE)
        self.player_colour = player_colour
        self.comp_colour = comp_colour

    def get_comp_colour(self):
        return self.comp_colour

    def get_player_colour(self):
        return self.player_colour

    def give_str_board(self):
        """Returns a copy of the board array and replaces the Chip objects with the str with the colour of the chips."""
        this_board = np.copy(self.board)
        for x, y in np.ndindex(this_board.shape):
            if this_board[x, y] is not None:
                if this_board[x, y].colour == "Blue":
                    this_board[x, y] = "Blue"
                else:
                    this_board[x, y] = "Red"
        return this_board

    def print_board_in_console(self):
        """This function holds the board which is a 8x8 matrix."""
        this_board = self.give_str_board()
        print(this_board)
        print("-"*40)

    def insert_chip(self, chip, col):
        """Method for making a new entry to the board. For the player and enemy.
            The column has to be parametrised in the pythonic way. i.e. cols from 0-7."""
        # slices the entries of the column into a new array
        col_entries = self.board[:, col:col+1]
        # checks for all unoccupied pos in this column(entries are None)
        # double array of indexes with the form (array([row_i, ...]), array([column_i, ...]))
        # checking the condition with "is" is here not possible, because "is" operator cannot be overloaded
        none_indexes = np.where(col_entries == None)
        # check whether the column cannot contain an extra chip and function has to be aborted
        if len(none_indexes[0]) == 0:
            print("This column is full. Chose again.")
            return False
        # the pos where the chip will fall is the one with the highest index
        self.board[len(none_indexes[0]) - 1, col] = chip
        return True

    def get_chip(self, x, y):
        """This function can return the information about a chip in a pos of the board."""
        chip = self.board[x, y]
        return chip

    def is_won(self):
        """This function can be used to check the board on whether the game has been decided.
            The function differentiates between player and enemy and returns..."""
        winning_chip = None
        # get a copy of the board which only contains str and None
        this_board = self.give_str_board()
        flipped_board = np.fliplr(this_board)

        # in order to check the entire board for 4 Chips in a formation individual rows and cols are examined
        # use for loops to isolate rows and cols
        for this_ax in range(0, 2):
            for index in range(0, BOARD_SIZE):
                # the stack will contain the row[index] when this_ax = 0 and the col[index] when this_ax = 1
                stack = this_board.take(index, axis=this_ax)

                # this will be the patterns, that are searched for
                winning_formations = [['Blue', 'Blue', 'Blue', 'Blue'], ['Red', 'Red', 'Red', 'Red']]
                for i in winning_formations:
                    bool_array = rolling_window(stack, 4) == i

                    if [True, True, True, True] in bool_array.tolist():
                        # the stack_index is the index of the first chip in the 4xChip formation in the row/col
                        stack_index_tuple, = np.where(np.all(bool_array == [True, True, True, True], axis=1))
                        stack_index = stack_index_tuple[0]
                        loop_index = index
                        # this_ax = 0 means loop_index is row and stack_index is col
                        if this_ax == 0:
                            winning_chip = self.get_chip(loop_index, stack_index)
                            break
                        else:
                            winning_chip = self.get_chip(stack_index, loop_index)
                            break

            # This next part of the algorythm checks whether diagonal patterns of the array
            # contain a winning formation

            # if this bit is problematic: change the 0 in range()!!!

            for index in range(0, BOARD_SIZE - 2):
                for board in [this_board, flipped_board]:
                    diag_elements = board.diagonal(index)
                    for i in winning_formations:
                        bool_array = rolling_window(diag_elements, 4) == i
                        if [True, True, True, True] in bool_array.tolist():
                            # the stack_index is the index of the first chip in the 4xChip formation in the row/col
                            diag_el_index_tuple, = np.where(
                                np.all(bool_array == [True, True, True, True], axis=1))
                            diag_index = diag_el_index_tuple[0]
                            loop_index = index
                            # this_ax = 0 means loop_index is row and stack_index is col
                            if board == this_board:
                                winning_chip = self.get_chip(loop_index, diag_index)
                                break
                            else:
                                winning_chip = self.get_chip(diag_index, loop_index)
                                break

        if winning_chip is not None:
            return winning_chip.colour

        return None

    def get_comp_move(self):
        """This method generates the computer's move (the column) based on INTELLIGENCE!!!!
        Returns the column of the move"""
        c_colour = self.get_comp_colour()
        p_colour = self.get_player_colour()

        # check, if the comp can win in the next move
        for i in range(0, BOARD_SIZE):
            board = self.give_str_board()
            chip = Chip(c_colour)
            self.insert_chip(chip, i)
            if self.is_won() == c_colour:
                return i

        # check, if the player can win in the next move and block that position
        for i in range(0, BOARD_SIZE):
            board = self.give_str_board()
            chip = Chip(p_colour)
            self.insert_chip(chip, i)
            if self.is_won() == p_colour:
                return i

        # accumulate preferable positions for the next move
        good_spots = []
        board = self.give_str_board()
        for axis in range(0, 2):
            for index in range(0, BOARD_SIZE):
                # the stack will contain the row[index] when this_ax = 0 and the col[index] when this_ax = 1
                stack = board.take(index, axis=axis)

                # this will be the patterns, that are searched for
                for i in [c_colour, c_colour]:
                    bool_array = rolling_window(stack, 2) == i

                    if [True, True] in bool_array.tolist():
                        # the stack_index is the index of the first chip in the 4xChip formation in the row/col
                        stack_index_tuple, = np.where(np.all(bool_array == [True, True], axis=1))
                        stack_index = stack_index_tuple[0]
                        # this_ax = 0 means loop_index is row and stack_index is col
                        if axis == 0:
                            # "- 1" because this if-statement is called when broadcasting a row. i.e. column before
                            good_spots.append(stack_index - 1)
                        else:
                            good_spots.append(index)
            # The pick is the x-coo of the first of a series of two chips (column) or the x before (row).
            print(good_spots)
            pick = random.randint(0, len(good_spots))
            return pick

        # make a move, "better than nothing"
        flag = True
        while flag is True:
            rnd = random.randint(0, BOARD_SIZE)
            if self.board[rnd, 0] is None:
                return rnd

    # ------------------------------- this part will take care of the visualisation in pygame ------------------------

    # buttons = []
    #
    # def button(self, text, x, y, radius, inactive_colour, active_colour, action=None, size=" "):
    #     cur = pygame.mouse.get_pos()
    #     if x + radius > cur[0] > x - radius and y + radius > cur[1] > y - radius:
    #         pygame.draw.circle(game_display, active_colour, (x, y), radius)
    #
    #         ix = None
    #         iy = None
    #         for event in pygame.event.get():
    #             if event.type == pygame.MOUSEBUTTONDOWN:
    #                 ix, iy = event.pos
    #
    #         if ix is not None and iy is not None:
    #             if x + radius > ix > x - radius and y + radius > iy > y - radius and action is not None:
    #                 if action == "quit":
    #                     pygame.quit()
    #                     quit()
    #
    #                 if action == "move":
    #                     col = int(x / 80 - 90)
    #                     self.insert_chip(Chip(self.get_player_colour()), col)
    #     else:
    #         pygame.draw.circle(game_display, inactive_colour, (x, y), radius)

    def draw_board(self):
        board = self.give_str_board()
        pygame.draw.rect(game_display, green, (60, 60, 80*BOARD_SIZE, 80*BOARD_SIZE))
        for y in range(0, BOARD_SIZE):
            for x in range(0, BOARD_SIZE):
                dx = 90 + x * 80
                dy = 90 + y * 80
                if board[x, y] is None:
                    pygame.draw.circle(game_display, white, (dy, dx), 30)
                elif board[x, y] == "Blue":
                    pygame.draw.circle(game_display, blue, (dy, dx), 30)
                elif board[x, y] == "Red":
                    pygame.draw.circle(game_display, red, (dy, dx), 30)

        # draw the selector square
        pygame.draw.rect(game_display, yellow, (self.selector_pos * 80 + 80, 60, 20, 20))

    selector_pos = 0

    def move_selector(self, dir):
        selector_pos = self.selector_pos
        if dir == 'left' and selector_pos >= 0:
            new_x = selector_pos * 80 - 80
            pygame.draw.rect(game_display, yellow, (new_x, 60, 20, 20))
            self.selector_pos -= 1
        if dir == 'right' and selector_pos <= BOARD_SIZE - 1:
            new_x = selector_pos * 80 + 80
            pygame.draw.rect(game_display, yellow, (new_x, 60, 20, 20))
            self.selector_pos += 1

    def intro(self):
        return

    def game_loop(self, comp_goes_first=False):

        game_over = False
        while game_over is not True:

            # here comes the computer's move
            if comp_goes_first is True:
                col = self.get_comp_move()
                chip = Chip(self.get_comp_colour())
                self.insert_chip(chip, col)

            # This will be the player move
            move_over = False
            while move_over is not True:
                for event in pygame.event.get():
                    print(event)
                    if event.type == pygame.QUIT:
                        pygame.quit()
                        quit()
                    if event.type == pygame.KEYDOWN:
                        if event.key == pygame.K_RIGHT:
                            self.move_selector('right')
                            pygame.draw.rect(game_display, yellow, (50, 50, 50, 50))
                        if event.key == pygame.K_LEFT:
                            self.move_selector('left')
                        if event.key == pygame.K_RETURN:
                            # the selector position indicates the column which the player has chosen.
                            col = self.selector_pos
                            chip = Chip(self.get_player_colour())
                            move_over = self.insert_chip(chip, col)

                game_display.fill(white)
                self.draw_board()
                pygame.display.update()

            comp_goes_first = True
            clock.tick(15)


game = Game()
game.game_loop()

---

在我看来，你的问题在于你的人工智能逻辑。你正在制作一份电路板的副本供人工智能进行实验，但是你没有使用它，而是将芯片插入到真正的电路板中

# check, if the comp can win in the next move
        for i in range(0, BOARD_SIZE):

            # Never used.
            board = self.give_str_board()
            chip = Chip(c_colour)

            # inserting onto the real board.
            self.insert_chip(chip, i)
            print("insert check", board, self)
            if self.is_won() == c_colour:
                return i

---

请缩减您的提交内容，以便我们可以对其进行审查。像“为什么这不起作用？”和大量代码这样的问题很难审查，可能对您没有任何帮助。@Woody1193我对这个问题进行了编辑，希望您能详细说明您的答案。实际上，我只是包含了项目的全部代码，以防有人想运行它，没有人想/需要运行整个项目来帮助您解决问题。事实上，如果是这样的话，那么你可能一开始就没有设计好东西。相反，你应该发布一个非常小的例子，我不必花几个小时去看，我就可以理解它。否则就很难有人帮忙了you@Woody1193好吧我想我刚刚找到了错误的根源：-）我仍在忙着排除故障，但这是一个我可以帮助的大问题。祝您好运，排除故障。到目前为止，你做的都很好。

# check, if the comp can win in the next move
        for i in range(0, BOARD_SIZE):

            # Never used.
            board = self.give_str_board()
            chip = Chip(c_colour)

            # inserting onto the real board.
            self.insert_chip(chip, i)
            print("insert check", board, self)
            if self.is_won() == c_colour:
                return i