Python:TypeError:'；非类型'；对象不可下标（尝试写入snake）

开始学习python，有些问题我无法解决

这个错误并不是每次都会发生——有时在启动程序时会发生十几次，然后就可以正常工作了

错误代码：

Traceback (most recent call last):
  File "snake.py", line 124, in <module>
    pg.draw.rect(win, red, [apple1[0], apple1[1], s
TypeError: 'NoneType' object is not subscriptable

回溯（最近一次呼叫最后一次）：
文件“snake.py”，第124行，在
pg.draw.rect（胜利，红色，[apple1[0]，apple1[1]，s
TypeError:“非类型”对象不可下标

实际代码：

    import pygame as pg
import pygame.freetype
import time
import random

pg.init()

white = (255,255,255)
black = (0,0,0)
red = (255,0,0)
blue = (0,0,255)
green = (0,255,0)

win_h = 600
win_w = 600

win = pg.display.set_mode((win_h, win_w))
pg.display.set_caption('SNEK!')
font_size = 40
font = pygame.freetype.SysFont("bauhaus93", font_size)

snake_size = 20
apple_is = False
dir = ''
score = 0
# board size must be divisible by snake_size*2
board_size = (240, 320)
# top, right, bottom, left (must be divisible by snake_size)
board_margin = (40, 20, 20, 80)
board_border_width = 4
bdw = board_border_width

# Snake start point
x1 = board_margin[3] + board_size[0] / 2 - snake_size
y1 = board_margin[0] + board_size[1] / 2 - snake_size
dx = 0
dy = 0
snake_list = [[x1, y1]]

clock = pg.time.Clock()
speed = 10

run = True
start = False
pause = False

def random_apple(j):
    seed = time.time()
    seed = str(seed)
    apple = []
    random.seed(seed[14:len(seed)])
    a = random.randrange(board_margin[3] / snake_size, board_size[0] / snake_size, 1)*snake_size
    random.seed(seed[13:len(seed)-1])
    b = random.randrange(board_margin[0] / snake_size, board_size[1] / snake_size, 1)*snake_size
    for x, v in enumerate(j):
        if a != v[0] and b != v[1]:
            apple.clear()
            apple.append([a, b])
            return apple[0]
        else:
            apple.clear()
            random_apple(j)
    
apple1 = random_apple(snake_list)
    
while run:
    for event in pg.event.get():
        if event.type == pg.QUIT:
            run = False
        if event.type == pg.KEYDOWN:
            if event.key == pg.K_LEFT and dir != 'RIGHT':
                dx = -snake_size
                dy = 0
                dir = 'LEFT'
            elif event.key == pg.K_RIGHT and dir != 'LEFT':
                dx = snake_size
                dy = 0
                dir = 'RIGHT'
            elif event.key == pg.K_UP and dir != 'DOWN':
                dx = 0
                dy = -snake_size
                dir = 'UP'
            elif event.key == pg.K_DOWN and dir != 'UP':
                dx = 0
                dy = snake_size
                dir = 'DOWN'
            elif event.key == pg.K_ESCAPE:
                run = False
            elif event.key == pg.K_p:
                if pause:
                    pause = False
                else:
                    pause = True
            start = True
    # Collision detection with borders      
    if x1 >= board_size[0] + board_margin[3] or x1 < board_margin[3] or y1 < board_margin[0] or y1 >= board_size[1] + board_margin[0]:
        run = False
    # Collision detection with snake itself 
    if len(snake_list) > 2:
        for x, v in enumerate(snake_list):
            if x > 1 and v == snake_list[0]:
                run  = False
                
    win.fill(black)
    # Draw board borders [top, right, bottom, left]
    pg.draw.line(win, white, [board_margin[3] - bdw, board_margin[0] - bdw + 1], [board_size[0] + board_margin[3] + bdw/2, board_margin[0] - bdw + 1], bdw)
    pg.draw.line(win, white, [board_size[0] + board_margin[3] + bdw/2 - 1, board_margin[0] - bdw], [board_size[0] + board_margin[3] + bdw/2 - 1, board_size[1] + board_margin[0] + bdw/2], bdw)
    pg.draw.line(win, white, [board_margin[3] - bdw, board_size[1] + board_margin[0] + bdw/2 - 1], [board_size[0] + board_margin[3] + bdw/2, board_size[1] + board_margin[0] + bdw/2 - 1], bdw)
    pg.draw.line(win, white, [board_margin[3] - bdw + 1, board_margin[0] - bdw], [board_margin[3] - bdw + 1, board_size[1] + board_margin[0] + bdw/2], bdw)
    # Generate apple coordinates
    if apple_is == False:
            apple1 = random_apple(snake_list)
            apple_is = True
    # Moving the snake head
    if run and not pause:
        x1 += dx
        y1 += dy
    # Store snake coordinates
    if start and not pause:
        snake_list.insert(0, [x1, y1])
        if len(snake_list) > 1:
            snake_list.pop()
    # Draw apple    
    pg.draw.rect(win, red, [apple1[0], apple1[1], snake_size, snake_size])
    # Apple eating
    if x1 == apple1[0] and y1 == apple1[1]:
        apple_is = False
        snake_list.insert(0, [x1, y1])
        score += 1
    # Draw snake head and body
    if run:
        for x, v in enumerate(snake_list):
            if x == 0:
                pg.draw.rect(win, blue, [int(v[0]), int(v[1]), snake_size, snake_size])
            elif x > 0:
                pg.draw.rect(win, green, [int(v[0]), int(v[1]), snake_size, snake_size])
    font.render_to(win, (board_size[0] + board_margin[1] + board_margin[3], board_margin[0]), f'Score: {score}', white) # score
    font.render_to(win, (board_margin[3], board_size[1] + board_margin[2] + board_margin[0]), f'Press ESC to Exit', white) # escape
    font.render_to(win, (board_margin[3], board_size[1] + board_margin[2] + board_margin[0] + font_size), f'Press P to Pause', white) # pause
    if pause:
        paused_text = font.render_to(win, (2000, 2000), f'Paused', white) # paused message
        font.render_to(win, (board_margin[3] + int(board_size[0]/2) - int(paused_text[2]/2), board_margin[0] + int(board_size[1]/2) - int(paused_text[3]/2)), f'Paused', white)
    
    pg.display.update()
    clock.tick(speed)
    
pg.quit()
quit()

将pygame导入为pg
导入pygame.freetype
导入时间
随机输入
第init页（）
白色=（255255）
黑色=（0,0,0）
红色=（255,0,0）
蓝色=（0,0255）
绿色=（0255,0）
win_h=600
温w=600
win=pg.display.set_模式（（win_h，win_w））
pg.display.set_标题（'SNEK！'）
字体大小=40
font=pygame.freetype.SysFont（“包豪斯93”，字体大小）
蛇的大小=20
苹果是假的
dir=''
分数=0
#电路板大小必须可以被snake_大小*2整除
电路板尺寸=（240320）
#顶部、右侧、底部、左侧（必须可被蛇形大小整除）
董事会保证金=（40,20,20,80）
板_边框_宽度=4
bdw=电路板\u边框\u宽度
#蛇形起点
x1=电路板边缘[3]+电路板尺寸[0]/2-蛇形尺寸
y1=线路板间距[0]+线路板尺寸[1]/2-线路板尺寸
dx=0
dy=0
snake_list=[[x1，y1]]
时钟=pg.time.clock（）
速度=10
运行=真
开始=错误
暂停=错误
def随机_苹果（j）：
seed=time.time（）
seed=str（seed）
苹果=[]
随机。种子（种子[14:len（种子）]）
a=random.randrange（board_margin[3]/snake_size，board_size[0]/snake_size，1）*snake_size
random.seed（seed[13:len（seed）-1]）
b=random.randrange（board_边距[0]/蛇形大小，board_大小[1]/蛇形大小，1）*蛇形大小
对于枚举（j）中的x，v：
如果a！=v[0]和b！=v[1]：
苹果
apple.append（[a，b]）
返回苹果[0]
其他：
苹果
随机苹果（j）
apple1=随机苹果（蛇列表）
运行时：
对于pg.event.get（）中的事件：
如果event.type==pg.QUIT：
运行=错误
如果event.type==pg.KEYDOWN：
如果event.key==pg.K_LEFT and dir！='RIGHT'：
dx=-snake\u尺寸
dy=0
dir=‘左’
elif event.key==pg.K_RIGHT and dir！='LEFT'：
dx=蛇的大小
dy=0
dir=‘右’
elif event.key==pg.K_UP and dir！=“DOWN”：
dx=0
dy=-snake\u尺寸
dir='UP'
elif event.key==pg.K_DOWN and dir！='UP'：
dx=0
dy=蛇的大小
dir='DOWN'
elif event.key==pg.K_ESCAPE:
运行=错误
elif event.key==pg.K\p：
如果暂停：
暂停=错误
其他：
暂停=正确
开始=真
#带边界的碰撞检测
如果x1>=线路板尺寸[0]+线路板边缘[3]或x1<线路板边缘[3]或y1<线路板边缘[0]或y1>=线路板尺寸[1]+线路板边缘[0]：
运行=错误
#snake自身的碰撞检测
如果len（蛇形列表）>2：
对于枚举中的x，v（蛇_列表）：
如果x>1且v==snake_列表[0]：
运行=错误
win.fill（黑色）
#绘制板边框[上、右、下、左]
pg.draw.line（win，white，[板间距[3]-bdw，板间距[0]-bdw+1]，[板间距[0]+板间距[3]+bdw/2，板间距[0]-bdw+1]，bdw）
pg.draw.line（win，white，[board_size[0]+board_margin[3]+bdw/2-1，board_margin[0]-bdw]，[board_size[0]+board_margin[3]+bdw/2-1，board_size[1]+board_margin[0]+bdw/2]，bdw）
pg.draw.line（win，white，[板间距[3]-bdw，板间距[1]+板间距[0]+bdw/2-1]，[板间距[0]+板间距[3]+bdw/2，板间距[1]+板间距[0]+bdw/2-1]，bdw）
pg.draw.line（win，white，[板间距[3]-bdw+1，板间距[0]-bdw]，[板间距[3]-bdw+1，板间距[1]+板间距[0]+bdw/2]，bdw）
#生成苹果坐标
如果apple_为==假：
apple1=随机苹果（蛇列表）
苹果是真的
#移动蛇头
如果运行且未暂停：
x1+=dx
y1+=dy
#存储蛇坐标
如果启动而不是暂停：
snake_列表。插入（0，[x1，y1]）
如果len（蛇形列表）>1：
snake_list.pop（）
#画苹果
pg.draw.rect（胜利，红色，[apple1[0]，apple1[1]，蛇的大小，蛇的大小]）
#吃苹果
如果x1==apple1[0]和y1==apple1[1]：
苹果是假的
snake_列表。插入（0，[x1，y1]）
分数+=1
#画蛇头和蛇身
如果运行：
对于枚举中的x，v（蛇_列表）：
如果x==0：
pg.draw.rect（赢，蓝，[int（v[0]），int（v[1]），蛇的大小，蛇的大小]）
elif x>0：
pg.draw.rect（赢，绿，[int（v[0]），int（v[1]），蛇的大小，蛇的大小]）
字体.呈现给（赢，（棋盘大小[0]+棋盘空白[1]+棋盘空白[3]，棋盘空白[0]），f'Score:{Score}'，白色）#分数
字体.渲染到（赢，（棋盘空白[3]，棋盘大小[1]+棋盘空白[2]+棋盘空白[0]），f'按ESC退出'，白色）#退出
字体。渲染到（赢，（棋盘空白[3]，棋盘大小[1]+棋盘空白[2]+棋盘空白[0]+棋盘大小），f'按P暂停'，白色）#暂停
如果暂停：
暂停的文字=字体。呈现到（win，（2000，2000），f'paused'，white）#暂停的消息
字体.渲染至（win，（棋盘空白[3]+int（棋盘空白[0]/2]-int（暂停的棋盘空白[2]/2]），棋盘空白[0]+int（棋盘空白[1]/2]-int（暂停的棋盘空白[3]/2]），f'暂停'，白色）
pg.display.update（）
时钟滴答声（速度）
第页退出
退出

---

这是写得不好的随机函数的错误吗？有什么办法改进这个函数吗？

您正在使用函数

random\u apple

生成一个apple，但并不总是r

None[0]