Problème avec Spyder sur mac

from tkinter import *
from tkinter import font
import time


# Variables globales
nbLignes = 28           # nombre de lignes
nbColonnes = 40         # nombre de colonnes
grille = []             # LA grille de cellules
cases = []              # Les cases clickables de l'interface graphique
prochaineGeneration = False     # Indique si on doit calculer la prochaine génération (True)
doReset = False         # Indique si on doit faire un reset du jeu de vie (True)

# Création d'une grille avec toutes les cellules à 0
def creerGrille(nLignes, nColonnes):
    nouvelle_grille = []
    for i in range(nLignes):
        ligne = []
        for j in range(nColonnes):
            ligne.append(0)
        nouvelle_grille.append(ligne)
    return nouvelle_grille

# Initialise l'interface du jeu de la vie
def initInterface(racine):
    global prochaineGeneration
    prochaineGeneration = False
    global doReset
    doReset = False
    global feuille
    feuille = Frame()
    feuille.parent = racine
    feuille.grid(row = 0, column = 0)
    feuille.size_x = nbColonnes
    feuille.size_y = nbLignes
    creerFenetre()

# Création de la fenêtre principale
def creerFenetre():	
    global feuille
    feuille.parent.title("Jeu de la Vie")
    # Barre de titre et d'instructions
    feuille.titre = Frame(feuille.parent)
    feuille.titre.grid(row = 0, column = 0, columnspan = 4)

    feuille.Font_titre = font.Font(family="Helvetica", size=14)
    texte_titre = Label(feuille.titre, text = "Le Jeu de la Vie de Conway", font = feuille.Font_titre)
    texte_titre.pack(side = TOP)

    instructions = Label(feuille.titre, text = "Clickez sur les cellules pour configurer la situation de départ et appuyer sur démarrer.")
    instructions.pack(side = BOTTOM)

    creerPlateau()
    
	# Bouton pour démarrer le jeu de la vie
    global bouton_jouer
    bouton_jouer = Button(feuille.parent, text = "Jouer", command = jouer)
    bouton_jouer.grid(row = 1, column = 1, sticky = E)
    
    # Bouton Pause
    global bouton_pause
    bouton_pause = Button(feuille.parent, text = "Pause", state = DISABLED, command = pause)
    bouton_pause.grid(row = 1, column = 2, sticky = E)

    # Bouton reset
    global bouton_reset
    bouton_reset = Button(feuille.parent, text = "Reset", state = DISABLED, command = reset)
    bouton_reset.grid(row =1 , column = 3, sticky = W)    

# Création du plateau représentant la grille de cellules.
# Case blanche = cellule morte, case noir = cellule vivante.
# Les cases sont interactives. 
def creerPlateau():
    global feuille
    global cases
    
    # Création d'une frame spéciale pour le plateau
    feuille.plateau = Frame(
        feuille.parent, width = feuille.size_x + 2, height = feuille.size_y + 2, borderwidth = 1, relief = SUNKEN)
    feuille.plateau.grid(row = 2, column = 0, columnspan = 4)

    # Création des cases du plateau. Chaque case est un bouton.
    for i in range(feuille.size_y + 2):
        ligne = []
        for j in range(feuille.size_x + 2):
            ligne.append(Button(feuille.plateau, bg = "white", width = 2, height = 1))
        cases.append(ligne)
    
    # Ajout de la commande pour changer l'état des cases (et des cellules)
    for i in range(0, feuille.size_y):
        for j in range(0, feuille.size_x):	
            cases[i][j].grid(row = i, column = j, sticky = W+E)
            cases[i][j]['command'] = lambda i=i, j=j:changer_case(cases[i][j], i, j)

# Désactive les clicks des cases et le bouton "jouer"
# Active les boutons "pause" et "reset"            
def desactiver_boutons():
    global cases
    global bouton_jouer
    global bouton_reset
    global bouton_pause
    if cases[0][0] != DISABLED:
        for i in range(nbLignes):
            for j in range(nbColonnes):
                cases[i][j].configure(state = DISABLED)
    bouton_reset.configure(state = NORMAL)
    bouton_pause.configure(state = NORMAL)
    bouton_jouer.configure(state = DISABLED)

# Active les clicks des cases et le bouton "jouer"
# Désactive les boutons "pause" et "reset" 
def activer_boutons():
    global cases
    global bouton_jouer
    global bouton_reset
    global bouton_pause
    for i in range(nbLignes):
        for j in range(nbColonnes):
            cases[i][j].configure(state = NORMAL)
    bouton_reset.configure(state = DISABLED)
    bouton_pause.configure(state = DISABLED)
    bouton_jouer.configure(state = NORMAL)

# Change l'état d'une cellule et met à jour la case correspondante
def changer_case(case, i , j):
    global grille
    if grille[i][j] == 0:
        grille[i][j] = 1
    else:
        grille[i][j]=0
    grilleVersPlateau()

# Transforme l'état des cellules dans la grille en case de couleur sur le plateau
# Blanche = morte, Noire = vivante
def grilleVersPlateau():
    global cases
    for i in range(nbLignes):
        for j in range(nbColonnes):
            if grille[i][j] == 0:
                cases[i][j]['bg']="white"
            else:
                cases[i][j]['bg']="black"

# Timer qui déclenche une nouvelle génération toutes les 100 ms                
def timer():
    global prochaineGeneration
    global doReset
    global grille
    if prochaineGeneration:
        grille = grilleSuivante()
        grilleVersPlateau()
        feuille.after(100, timer)
    else:
        if doReset:
            grille = creerGrille(nbLignes, nbColonnes)
            grilleVersPlateau()
            doReset = False
            activer_boutons()

# Gestion du bouton "jouer"                
def jouer():
    print("Jouer !")
    global prochaineGeneration
    desactiver_boutons()
    prochaineGeneration = True
    timer()

# Gestion du bouton "reset"        
def reset():
    global prochaineGeneration
    global doReset
    print("Reset !")
    prochaineGeneration = False;
    doReset = True;

# Gestion du bouton "pause"    
def pause():
    global prochaineGeneration
    if prochaineGeneration:
        print("Pause !")
        prochaineGeneration = False;
    else:
        print("Restart !")
        prochaineGeneration = True;
        timer();

# Création de la grille de la génération t+1
def grilleSuivante():
    global grille
    nouvelleGrille = grille[:] # à modifier !
    return nouvelleGrille # à modifier !

# Calcule le nombre de voisins vivantes de grille[x][y]
def nombreVoisinsVivants(x, y):
    return 0 # à modifier !

# Partie pour lancer le programme
root = Tk()
initInterface(root)
grille = creerGrille(nbLignes, nbColonnes)
grilleVersPlateau()
root.mainloop()