• il serpente appare e scompare per tre secondi per far capire al giocatore che il gioco sta per cominciare;
• main loop del gioco;
• game over, con il serpente e la mela che diventano bianchi per tre secondi per far capire al giocatore che il gioco è finito.

import pygame

WINDOWWIDTH = 320
WINDOWHEIGHT = 240
DISPLAYSURF = pygame.display.set_mode((WINDOWWIDTH, WINDOWHEIGHT))

CELLSIZE = 10
CELLWIDTH = WINDOWWIDTH / CELLSIZE
CELLHEIGHT = WINDOWHEIGHT / CELLSIZE
ALL_COORDS = []
for x in range(0, CELLWIDTH):
    for y in range(0, CELLHEIGHT):
        ALL_COORDS.append((x, y))

BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
GREEN = (0, 255, 0)
RED   = (255, 0, 0)

FPS = 15
CLOCK = pygame.time.Clock()

def get_new_head(direction, old_head_coordinates):
    """Given a string which specify the snake's direction and a tuple
    containing the old head coordinates, return a tuple containing the
    new head coordinates.
    """
    x, y = old_head_coordinates
    if direction == 'up':
        return (x, y-1)
    elif direction == 'down':
        return (x, y+1)
    elif direction == 'right':
        return (x+1, y)
    elif direction == 'left':
        return (x-1, y)

import random
from cnst import ALL_COORDS


def get_random_coords(snake_coords):
    """Given a list containing all the coordinates occupied by the snake,
    return a tuple of free coordinates.
    """
    all_free = [coords for coords in ALL_COORDS if coords not in snake_coords]
    return random.choice(all_free)

import sys, pygame, snake, apple
from cnst import *
from pygame.locals import *


def get_cell_rect(coords):
    """Given a tuple containing a pair of coordinates, return a rect
    object.
    """
    x, y = coords
    return pygame.Rect(x*CELLSIZE+1, y*CELLSIZE+1, CELLSIZE-1, CELLSIZE-1)


def draw_cell_square(rect, color):
    """Given a rect object and a color, draw a square on the rect."""
    pygame.draw.rect(DISPLAYSURF, color, rect)


def initialize_game():
    # initialize snake's starting coordinates and direction
    snake_coords = [(5, 11), (4, 11), (3, 11)]
    snake_direction = 'right'
    
    # initialize first apple coordinates
    apple_coords = apple.get_random_coords(snake_coords)

    # create the needed rects
    snake_rects = [get_cell_rect(coords) for coords in snake_coords]

    # blink the snake for three seconds while checking if player wants to quit
    for half_sec in range(1, 7):
        for event in pygame.event.get():
            if event.type == QUIT:
                terminate()
            elif event.type == KEYDOWN:
                if event.key == K_ESCAPE:
                    terminate()
        else:
            for rect in snake_rects:
                if half_sec % 2 == 0:
                    draw_cell_square(rect, GREEN)
                else:
                    DISPLAYSURF.fill(BLACK)
            pygame.display.update(snake_rects)
            pygame.time.delay(500)
    return snake_coords, snake_direction, apple_coords


def run_game(snake_coords, snake_direction, apple_coords):
    while True:
        # manage pygame event queue
        event = pygame.event.poll()
        if event.type == QUIT:
            terminate()
        elif event.type == KEYDOWN:
            if event.key == K_a and snake_direction != 'right':
                snake_direction = 'left'
            elif event.key == K_d and snake_direction != 'left':
                snake_direction = 'right'
            elif event.key == K_w and snake_direction != 'down':
                snake_direction = 'up'
            elif event.key == K_s and snake_direction != 'up':                 
                snake_direction = 'down'
            elif event.key == K_ESCAPE:
                terminate()

        # add snake's new head inside its data structure
        new_head_coords = snake.get_new_head(snake_direction, snake_coords[0])
        snake_coords.insert(0, new_head_coords)

        # check if snake's new head has hit an edge
        x, y = new_head_coords
        if x == -1 or x == CELLWIDTH:
            return snake_coords, apple_coords
        if y == -1 or y == CELLHEIGHT:
            return snake_coords, apple_coords
      
        # check if snake's new head has hit its body
        for body_coords in snake_coords[1:]:
            if new_head_coords == body_coords:
                return snake_coords, apple_coords

        # check if snake's new head has eaten the apple
        if new_head_coords == apple_coords:
            apple_coords = apple.get_random_coords(snake_coords)
            tail_coords = snake_coords[-1]  # previous iteration tail
        else:
            tail_coords = snake_coords.pop()
        
        # create the needed rects
        head_rect = get_cell_rect(new_head_coords)
        tail_rect = get_cell_rect(tail_coords)
        apple_rect = get_cell_rect(apple_coords)

        # draw background, snake's head and apple
        DISPLAYSURF.fill(BLACK)
        draw_cell_square(head_rect, GREEN)
        draw_cell_square(apple_rect, RED)
        
        # update selected display rects
        rects = [head_rect, tail_rect, apple_rect]
        pygame.display.update(rects)
        CLOCK.tick_busy_loop(FPS)


def game_over(snake_coords, apple_coords):
    # create the needed rects
    snake_rects = [get_cell_rect(coords) for coords in snake_coords]
    apple_rect = get_cell_rect(apple_coords)

    # draw snake's body and apple
    for rect in snake_rects:
        draw_cell_square(rect, WHITE)
    draw_cell_square(apple_rect, WHITE)
    
    # update selected display rects
    rects = snake_rects[:]
    rects.append(apple_rect)
    pygame.display.update(rects)
    
    # freeze the game for three seconds but check if player wants to quit
    for half_sec in range(1, 7):
        for event in pygame.event.get():
            if event.type == QUIT:
                terminate()
            elif event.type == KEYDOWN:
                if event.key == K_ESCAPE:
                    terminate()
        else:
            pygame.time.delay(500)
    
    # clear the screen for next iteration
    DISPLAYSURF.fill(BLACK)
    pygame.display.update(rects)
    return


def terminate():
    pygame.quit()
    sys.exit()


def main():
    pygame.init()
    pygame.display.set_caption('Snake')

    # block unwanted events
    blocked_events = [MOUSEMOTION, MOUSEBUTTONUP, MOUSEBUTTONDOWN]
    pygame.event.set_blocked(blocked_events)

    while True:
        init_args = initialize_game()
        final_args = run_game(*init_args)
        game_over(*final_args)


if __name__ == '__main__':
    main()

* cnst.py? se hai dei tasti rotti e non puoi permetterti una tastiera nuova, dammi il tuo indirizzo e te la faccio mandare. se no chiamalo constants.py e basta... tanto quello e'. e si... e' una pratica comune anche in codice "serio", per un progetto di queste dimensioni e' una buona idea. poi si potrebbe aprire una discussione lunghissima sul perfetto piazzamento delle costanti, ma tipicamente il beneficio di usare costanti e avere uno schema chiaro di dove vanno porta piu' beneficio che passare da uno schema decoroso a quello perfetto. Quindi...

* Ah... in un mondo di costanti, dubita di quello che non e' costante. ALL_COORDS e' meglio che sia una tupla, non una lista. Considera anche di avere semplicemente un generatore per quelle costanti... tanto mi aspetto che ti serva piu' che altro per iterarci sopra. E allora il generatore e' la cosa giusta. Ovviamente quindi non una costante, ma una funzione che ti torna il generatore.

def gen_all_coords():
    for x in range(0, CELLWIDTH):
        for y in range(0, CELLHEIGHT):
            yield (x, y)

def get_random_coords(snake_coords):
    """Given a list containing all the coordinates occupied by the snake,
    return a random tuple of free coordinates.
    """
    all_coords = gen_all_coords()
    free_coords = [xy for xy in all_coords if xy not in snake_coords]
    return random.choice(free_coords)

* CLOCK mi inquieta. E' un oggetto "ricco" messo come costante. Ora io capisco che sia molto comodo averlo in un posto comodo (appunto), ma... appena ti metti a scrivere i test diventa una scomodita'. Io ti suggerirei di metterti li e aggiungere il famoso clock alle funzioni che ne hanno bisogno come parametro. E poi magari ti rendi conto che qualche gruppo di funzioni che operano su un set di dati comuni finisce che dovrebbero essere una classe (e allora il clock diventa un bell'attributo della classe e le cose tornano snelle meglio di prima).

* up, down, etc... costanti.

* def get_cell_rect(coords): -> def get_cell_rect((x, y)), funzionalmente equivalente a quello che hai scritto, con una riga di codice in meno. Poi verrebbe da chiedersi se le coordinate visto che le usi spesso non debbano essere un oggetto (tipo una namedtuple). A me verrebbe da dire di si.

* non usare * import.

import constants

constants.RED

from constants import RED

RED

import pygame

pg = pygame

* initialize_game contiene troppa logica. e molte delle cose che ha direttamente in pancia dovrebbero essere funzioni. inoltre fa *due* cose: inizializza il sistema dal punto di vista del software, *poi* passa il controllo all'utente per fare partire il gioco (dal punto di vista dell'utente). Questo e' gia' praticamente un "main" (o meglio, parte di).  Grosso modo la stessa cosa vale per le funzioni nello stesso modulo. E vedrai anche che ci sono pezzi comuni che puoi astrarre.

        # check if snake's new head has hit an edge
        x, y = new_head_coords
        if x == -1 or x == CELLWIDTH:
            return snake_coords, apple_coords
        if y == -1 or y == CELLHEIGHT:
            return snake_coords, apple_coords
      
        # check if snake's new head has hit its body
        for body_coords in snake_coords[1:]:
            if new_head_coords == body_coords:
                return snake_coords, apple_coords

def edge_hit((x, y)):
    """Given the head coords, return True if the head hits the edge of
    the screen, otherwise return False.
    """
    if x == -1 or x == CELLWIDTH or y == -1 or y == CELLHEIGHT:
        return True
    else:
        return False


def body_hit(snake_coords):
    """Given a list containing the snake's coords, return True if the
    head of the snake hits its body, otherwise return False.
    """
    for body_coords in snake_coords[1:]:
        if snake_coords[0] == body_coords:
            return True
    else:
        return False

        # check game over conditions
        if snake.edge_hit(snake_coords[0]) or snake.body_hit(snake_coords):
            return snake_coords, apple_coords

Si, corretto. Le parentesi attorno ad x e y non sono necessarie, ma al di la di quello, tutto bene.

Detto questo, parliamo di astrazione... vista come e' fatta quella funzione, io andrei di

def gen_all_coords(max_width, max_height)

o al limite

def gen_all_coords(max_width=CELLWIDTH, max_height=CELLWEIGHT)

Mi sembra ragionevole avere una funzione che lavora indifferentemente a prescindere dall'attuale area di gioco.

In generale il problema e' che quando fai uno star import, non hai idea di cosa stai importando. Non solo: modifiche innocue alle tue dipendenze possono romperti.

Comunque il problema e' ben discusso qui. https://www.python.org/dev/peps/pep-0008/#imports
In generale vale la pena conoscere *bene* cosa c'e' in quel documento. Tu mi sembra sia molto appassionato di scrivere codice "pulito" e "secondo best practice". Bene... amerai quel documento.

Se scrivessi i test per il tuo codice, non ti porresti questa domanda. Nel senso che testare due funzioni corte e' molto piu' semplice che testarne una lunga.

Detto questo... hai due funzioni per testare se hai sbattuto la testa sul muro o ti sei troncato il corpo. Mi sembra utile.
Vuoi vedere un side effect? Io il tuo codice lo avevo gia' visto... ma non mi ero accorto di un errore che fai. L'errore e' che scrivi una roba in molto complicato quando potresti semplificare. Solo che fintanto che era un coso unico, lo avevo solo preso per assunto. Quando mi e' stato chiaro che in effetti quel pezzo di codice deve solo dirmi se la testa coincide con il corpo, mi e' stato chiaro che hai molti modi piu' efficienti e/o coincisi per risolvere questo problema:

a. snake[0] in snake[1:] /
b. Counter(snake) e poi guardi se qualcosa ha 2 occorrenze e in generale ogni sistema buono per
c. snake.count(snake[0]) > 1
d. etc etc etc

Tutti questi sistemi sono molto coincisi. Ma ancora una volta non spiegano *esattamente* cosa vuoi fare. Non ti dicono perche' snake.count(snake[0]) > 1... ovvero non ti dicono come risolve il tuo problema.

Mettilo dentro un metodo body_hit ed e' immediatamente chiaro *perhe'* hai scritto quella cosa e come mai quella cosa funziona.