有人可以解释为什么这个导入不会引发错误吗？

Question

Everything I know about import suggests that this should raise an error.

It's grossly exaggerated to exemplify my confusion.

Can someone explain this import execution and why it does not raise an error?

import conway.blahblahspongebobsquarepantsinthedinerboogiefacesmahboxhammerblrrrbswwwpnoobiedoopieaaaayeeeeee

Sample Output: This is how it is supposed to look when executed properly so it works perfectly
## #  # #  ### # ##  ### # #  #  # # ##      # #  ###  ##   
   # #### # # #   # # ## # # #  ##  ### #####  ###  #  ## ##
## #     #    #####   ###### #  ###  # ### #  ### # #  # #  

# Conway's Game of Life
import random, time, copy
WIDTH = 60      # set value for width
HEIGHT = 20     # set value for height

# Create a list of list for the cells:
nextCells = []                              # create an empty list called nextcells
for x in range(WIDTH):                      # evaluates for x in range(60) we loop until nextcells is full
    column = [] # Create a new column.      # create a (60) lists called column inside nextcells
    for y in range(HEIGHT):                 # now we give each cell a 50/50 chance of starting off alive/dead
        if random.randint(0, 1) == 0:
            column.append('#') # Add a living cell.           # we append (basically we are building the
        else:                                                 # column from scratch or "starting at 0"
            column.append(' ') # Add a dead cell.
    nextCells.append(column) # nextCells is a list of column lists.

while True: # Main program loop.
    print('\n\n\n\n\n') # Separate each step with newlines.       # create some space between each automation
    currentCells = copy.deepcopy(nextCells)                       # copy our nextcells list

    # Print currentCells on the screen:
    for y in range(HEIGHT):                                         # this is the beginning column
        for x in range(WIDTH):                                      # we nest this so that each row gets printed
            print(currentCells[x][y], end='') # Print the # or space.   # completely x loops and prints the entire
        print() # Print a newline at the end of the row.                # row for each row in the column

    # Calculate the next step's cells based on current step's cells:
    for x in range(WIDTH):
        for y in range(HEIGHT):
            # Get neighboring coordinates:
            # `% WIDTH` ensures leftCoord is always between 0 and WIDTH - 1
            leftCoord  = (x - 1) % WIDTH             # % wraps our range to remain in bounds 0 -1 in this case
            rightCoord = (x + 1) % WIDTH                # would equal 59 since our WIDTH = 60 or(00 - 59)
            aboveCoord = (y - 1) % HEIGHT            # % wraps our height the same way
            belowCoord = (y + 1) % HEIGHT            # so this evaluates to 1/20 = remainder 19
                                                        # if we are in the first column
            # Count number of living neighbors:
            numNeighbors = 0
            if currentCells[leftCoord][aboveCoord] == '#':           # for each square we evaluate alive/dead
                numNeighbors += 1 # Top-left neighbor is alive.      # for the 8 squares around it
            if currentCells[x][aboveCoord] == '#':
                numNeighbors += 1 # Top neighbor is alive.
            if currentCells[rightCoord][aboveCoord] == '#':
                numNeighbors += 1 # Top-right neighbor is alive.
            if currentCells[leftCoord][y] == '#':
                numNeighbors += 1 # Left neighbor is alive.
            if currentCells[rightCoord][y] == '#':
                numNeighbors += 1 # Right neighbor is alive.
            if currentCells[leftCoord][belowCoord] == '#':
                numNeighbors += 1 # Bottom-left neighbor is alive.
            if currentCells[x][belowCoord] == '#':
                numNeighbors += 1 # Bottom neighbor is alive.
            if currentCells[rightCoord][belowCoord] == '#':
                numNeighbors += 1 # Bottom-right neighbor is alive.

            # Set cell based on Conway's Game of Life rules:
            if currentCells[x][y] == '#' and (numNeighbors == 2 or    # 2 conditions if this square is "alive"
numNeighbors == 3):                                                   # and has 2 - 3 living neighbors it stays "alive"
                # Living cells with 2 or 3 neighbors stay alive:
                nextCells[x][y] = '#'
            elif currentCells[x][y] == ' ' and numNeighbors == 3:     # we now run the check on dead squares to see
                # Dead cells with 3 neighbors become alive:         # if they come to life
                nextCells[x][y] = '#'
            else:
                # Everything else dies or stays dead:
                nextCells[x][y] = ' '
    time.sleep(20) # Add a 1-second pause to reduce flickering.       # lastly we add a 1 second delay

Answer 1

The first step of import conway.whatever is to import conway . When that is complete, see if it has a whatever variable or subpackage. Since your code has an infinite loop at module level, it runs forever on import and python never gets around to that second step of finding out whether "whatever" exists.

That script isn't built to be imported. To do that, you'd move the module level code to a function, say "game_of_life" and call it when the program knows it is being run as a scirpt.

def game_of_life():
    .... that module level stuff

if __name__ == "__main__":
    game_of_life()