Jeu de la vie

Merci pour ta réponse forte utile!
Je travaille sur un plateau fini (j'ai un contour de cellules mortes qui le restent quoi qu'il arrive) et mes cellules vivantes sont symbolisées par un "O" et les mortes par un point "."
j'ai "en gros" compris ton raisonnement mais je n'arrive pas à l'appliquer... si j'appelle x la ligne de mon tableau et y la colonne, et que ma cellule de depart est de coordonnées (x,y) et que je souhaite compter le nombre de cellule autour? Qu'est ce que cela donnerait?

Dans ce cas, appelons y-1 la ligne du dessus, y+1 la ligne du dessous (ou l'inverse, comme tu veux) et pareil pour x: x+1 la cellule à droite et x-1 celle à gauche.

Pour compter les cellules entourant la cellule (x,y), on peut faire:

 
count = 0
for i in range(-1, 2):
    for j in range(-1, 2):
        if not (i == 0 and j == 0):
            if (x + i, y + j) == "O":
                count += 1

à la fin, count contiens le nombre de cellules vivantes.
La condition " if not (i == 0 and j == 0): " est là pour ne pas compter la cellule pour laquelle tu cherche le nombre de cellules vivantes voisines.

Pour quelque chose de plus concis, tu peux utiliser les listes sous cette forme:

count = sum([1 for i in range(-1, 2) for j in range(-1, 2) if  not (i == 0 and j == 0) and (x + i, y + j) == "O"])

'fin, après, c'est juste une question de goût...

J'arrive presque à bout du programme, mais impossible de réussir à éclaircir mes idées à propos des tableaux : j'ai créé un tableau, placé mes cellules, puis dupliqué ce tableau pour y compter les cellules alive autour de chaque cellule, puis j'applique la mort/résurection/survie des cellules dans le tableau initial, est-ce ce qu'il faut faire ?

Personnellement, quand j'ai codé ce jeu, j'avais 3 tableaux:alive qui contenais mes cellules, j'ai déterminé toutes les qui allaient vivre que je mettais dans un tableau new, et toute celles qui allaient mourir que je mettais dans died. Ensuite, j'ajoutais au tableau alive celles dans new, et je supprimais du tableau alive celles dans died.
Mais si ce que tu fais fonctionne, tu devrais le voir:
teste avec commes cellules (O = vivant; . = mort):
O.O
O.O
OOO
au bout d'un moment tu devrais avoir une forme comme celle sur https://fr.wikipedia.org/wiki/Jeu_de_la_vie chapitre "Dimension et complexité".

Personnellement je prenais toujours comme référence cette figure( le 'u' qui devient un clown) pour savoir si mes jeux fonctionnaient.

Waow... Là j'avoue n'avoir pas bien compris ta question... Tu as écris quoi pour le moment?
Tu veux que je te donnes le déroulement du prog sans code source? En tous cas, je ne duplique pas de tableau, je fais:

tableau=[[x,y],[x,y]...]
while 1:
    new_gen=[calcul de la new génération]
    for i in new gen:
        affichage(i)
    tableau=[]+new_gen

'fin, c'est un peu plus compliqué que ça, et ce sera différent de toi, vu qu'on travaille de deux manière différentes. (interface/console)
Ps: je viens de remarquer qu'en travaillant avec des set, ça va beaucoup plus vite qu'avec des list.

Je suis désolé, je ne me suis pas bien exprimé. Pour le moment, j'ai :
-une fonction qui crée un tableau.
-une fonction qui compte le voisinage (count = nombre de cellules vivantes)
-une fonction qui modifie (si count == (2), la cellule reste reste vivante,...)
-et un cellule qui balaye, appliquant le comptage et la modification à toutes les cellules.
Ma question est la suivante : à quel moment mon tableau 1 doit-il intervenir et à quel moment le tableau 2 doit intervenir?
Je ne connais pas encore les set...

Le second tableau dans ton cas, interviendrais où tu applique les modifications:
il faudrait créer un second tableau qui va contenir le génération suivante, car toutes les cellules doivent "mourir" et "naître" en même temps, or si tu modifie ton tableau au fur et à mesure que tu le parcours, ça créera des problèmes (je suppose).

Là, je ne vois pas ce qu'il y a à écrire de plus:
tu as la fonction qui calcule la génération suivante, il ne te reste que l'affichage et la copie du nouveau tableau dans l'ancien...

Pour ce qui est des set, j'ai demandé autre part, et apparemment, les set sont plus rapides pour ce qui est des test de présence ou d'absence d'objet en leur sein, les listes sont plus rapides avec les itérations, donc dans ton cas, je dirais que les listes sont plus avantageuses.
Lien vers la discussion https://openclassrooms.com/forum/sujet/set-plus-rapide-que-list
Attention, si tu ne tiens vraiment à ne pas voir mon code source, il y est écrit au début...