Discussion :

[PascalStl]

Bonjour à tous,

Je m'amuse à programmer des petits jeux sur python (avec Pygame) pour me faire la main en programmation. Cette semaine, je me suis mis à un petit jeu de tic tac toe.

Le jeu fonctionne super bien sauf que là, personne ne veut jouer avec moi . Alors, je me suis dit eh bien je vais me créer un ami pour jouer . J'ai donc fait une AI.

Le code fonctionne, même très bien mais... il est lourd, et assez ennuyant à lire.

En gros, c'est une fonction qui reçoit en paramètre une liste d'objets et le pion de l'AI "X" ou "O". Ces objets contiennent un attribut "case" qui représente l'endroit où se situe l'objet dans le plateau de jeu (voir figure):
------------
| 0 | 1 | 2 |
------------
| 3 | 4 | 5 |
------------
| 6 | 7 | 8 |
------------

Et chaque objet contient aussi un attribut Tag, qui nous indique si l'objet est un "X" ou un "O".

En récupérant la case et le tag, eh bien on peut savoir quoi est où. J'ai essayé de construire un dictionnaire qui associe la case au tag mais sa marche pas du tout, alors je me suis résigné à construire deux listes, une de cases et une de tags qui sont associées par leur index dans la liste. ex: listeCase[0, 1, 2...] listeTag["X", "X", "O"...] donc la case 1 = "X". Ensuite je vérifie toutes les possibilités pour chacune des cases pour une condition de victoire (si "O" a la case 1 et "O" a la case 2 et pas de "X" a la case 0 alors met "O" a la case 0) et même chose ensuite pour les conditions de défaite (si "X" a la case 1 et "X" a la case 2 et pas de "O" a la case 0 alors met "O" a la case 0) et ainsi de suite pour toutes les possibilités... Autant vous dire que c'est assez plate à écrire ce genre de code... Ensuite, si aucune de ces conditions est remplie, on choisi une case aléatoire (rd.choice = random.choice). Puis à la fin, on converti la position de la case en coordonnées pour créer un nouvel objet.

voici le code de la fonction:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
 
def joueurAI(liste, pionAI):
    """Simule on joueur"""
    caseAI = []
    caseJoueur = []
    for element in liste:
        if element.tag == pionAI:
            caseAI.append(element.case)
        elif element.tag != pionAI:
            caseJoueur.append(element.case)
 
    #si l'AI a un possibilité de gagner
    if 0 in caseAI and 1 in caseAI and not 2 in caseJoueur:
        select = 2
    elif 0 in caseAI and 2 in caseAI and not 1 in caseJoueur:
        select = 1
    elif 0 in caseAI and 3 in caseAI and not 6 in caseJoueur:
        select = 6
    elif 0 in caseAI and 6 in caseAI and not 3 in caseJoueur:
        select = 3
    elif 0 in caseAI and 4 in caseAI and not 8 in caseJoueur:
        select = 8
    elif 0 in caseAI and 8 in caseAI and not 4 in caseJoueur:
        select = 4
    elif 1 in caseAI and 2 in caseAI and not 0 in caseJoueur:
        select = 0
    elif 1 in caseAI and 4 in caseAI and not 7 in caseJoueur:
        select = 7
    elif 1 in caseAI and 7 in caseAI and not 4 in caseJoueur:
        select = 4
    elif 2 in caseAI and 4 in caseAI and not 6 in caseJoueur:
        select = 6
    elif 2 in caseAI and 6 in caseAI and not 4 in caseJoueur:
        select = 4
    elif 2 in caseAI and 5 in caseAI and not 8 in caseJoueur:
        select = 8
    elif 2 in caseAI and 8 in caseAI and not 5 in caseJoueur:
        select = 5
    elif 3 in caseAI and 4 in caseAI and not 5 in caseJoueur:
        select = 5
    elif 3 in caseAI and 5 in caseAI and not 4 in caseJoueur:
        select = 4
    elif 3 in caseAI and 6 in caseAI and not 0 in caseJoueur:
        select = 0
    elif 4 in caseAI and 5 in caseAI and not 3 in caseJoueur:
        select = 3
    elif 4 in caseAI and 6 in caseAI and not 2 in caseJoueur:
        select = 2
    elif 4 in caseAI and 8 in caseAI and not 0 in caseJoueur:
        select = 0
    elif 4 in caseAI and 7 in caseAI and not 1 in caseJoueur:
        select = 1
    elif 5 in caseAI and 8 in caseAI and not 2 in caseJoueur:
        select = 2
    elif 6 in caseAI and 7 in caseAI and not 8 in caseJoueur:
        select = 8
    elif 6 in caseAI and 8 in caseAI and not 7 in caseJoueur:
        select = 7
    elif 7 in caseAI and 8 in caseAI and not 6 in caseJoueur:
        select = 6
 
    #sinon l'AI vérifie s'il risque de perdre  
    elif 0 in caseJoueur and 1 in caseJoueur and not 2 in caseAI:
        select = 2
    elif 0 in caseJoueur and 2 in caseJoueur and not 1 in caseAI:
        select = 1
    elif 0 in caseJoueur and 3 in caseJoueur and not 6 in caseAI:
        select = 6
    elif 0 in caseJoueur and 6 in caseJoueur and not 3 in caseAI:
        select = 3
    elif 0 in caseJoueur and 4 in caseJoueur and not 8 in caseAI:
        select = 8
    elif 0 in caseJoueur and 8 in caseJoueur and not 4 in caseAI:
        select = 4
    elif 1 in caseJoueur and 2 in caseJoueur and not 0 in caseAI:
        select = 0
    elif 1 in caseJoueur and 4 in caseJoueur and not 7 in caseAI:
        select = 7
    elif 1 in caseJoueur and 7 in caseJoueur and not 4 in caseAI:
        select = 4
    elif 2 in caseJoueur and 5 in caseJoueur and not 8 in caseAI:
        select = 8
    elif 2 in caseJoueur and 8 in caseJoueur and not 5 in caseAI:
        select = 5
    elif 2 in caseJoueur and 4 in caseJoueur and not 6 in caseAI:
        select = 6
    elif 2 in caseJoueur and 6 in caseJoueur and not 4 in caseAI:
        select = 4
    elif 3 in caseJoueur and 4 in caseJoueur and not 5 in caseAI:
        select = 5
    elif 3 in caseJoueur and 5 in caseJoueur and not 4 in caseAI:
        select = 4
    elif 3 in caseJoueur and 6 in caseJoueur and not 0 in caseAI:
        select = 0
    elif 4 in caseJoueur and 5 in caseJoueur and not 3 in caseAI:
        select = 3
    elif 4 in caseJoueur and 7 in caseJoueur and not 1 in caseAI:
        select = 1
    elif 4 in caseJoueur and 6 in caseJoueur and not 2 in caseAI:
        select = 2
    elif 4 in caseJoueur and 8 in caseJoueur and not 0 in caseAI:
        select = 0
    elif 5 in caseJoueur and 8 in caseJoueur and not 2 in caseAI:
        select = 2
    elif 6 in caseJoueur and 7 in caseJoueur and not 8 in caseAI:
        select = 8
    elif 6 in caseJoueur and 8 in caseJoueur and not 7 in caseAI:
        select = 7
    elif 7 in caseJoueur and 8 in caseJoueur and not 6 in caseAI:
        select = 6
 
    #si aucun des cas est vrai, alors l'AI place son pion n'importe où
    else:
        choix = [0, 1, 2, 3, 4, 5, 6, 7, 8]
        for case in caseAI:
            choix.remove(case)
        for case in caseJoueur:
            choix.remove(case)
 
        select = rd.choice(choix)
 
    #conversion de la case en adresse
    a = 0
    for y in range(50, 349, 100):
        for x in range(0, 299, 100):
            if select == a:
                return (x, y)
            else:
                a += 1

Alors, voici ma question, quelqu'un aurait-il une idée pour faire plus simple ou moins lourd ?

Merci d'avance a tous

P.S. Je n'ai pas mis tout le code du jeu pour faire simple, mais je peux le mettre si ça peux aider avec les images et tous, vive l'open source

[Sve@r]

Alors, voici ma question, quelqu'un aurait-il une idée pour faire plus simple ou moins lourd ?

Bonjour

Oui effectivement qu'il y a moins lourd. Bon déjà c'est dommage de créer deux listes parallèles alors que la première liste n'est qu'un bête indice. Et donc sans avoir listeCase t'as listetag[1]="X" mais bon, ça c'est un détail

As-tu remarqué que le déplacement de chaque case dans les 8 directions n'est qu'un bête incrément ?
Exemples:

• pour aller de la case 4 à la case 5 il faut faire "+1". Et "-1" pour aller vers la 3
• pour aller de la case 4 à la case 1 il faut faire "-3". Et "+3" pour aller vers la 7
• pour aller de la case 4 à la case 0 il faut faire "-4". Et "+4" pour aller vers la 8.
• pour aller de la case 4 à la case 2 il faut faire "-2". Et "+2" pour aller vers la 6.

Bref il suffit de faire une boucle sur 1, 2, 3, 4 (les décalages) et une seconde sur 1, -1 pour avoir les 8 directions. Et bien entendu tu n'évalues que les cases vides puisque ce sont les seules où tu peux jouer

Exemple

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
def evaluation(couleur):
    # Valeur renvoyée par défaut
    ret=None
 
    # Boucle sur toutes les cases du jeu   
    for i in xrange(9):
        if case[i] != vide: continue
 
        # Boucle sur les 4 directions possibles
        for direction in (1, 2, 3, 4):
 
            # Boucle sur les sens de déplacement
            for sens in (1, -1):
                # Calcul déplacement
                dep=direction * sens;
 
                # Calcul indices des 2 cases alignées
                (i1, i2)=(i+dep, i+ dep * 2)
 
                # Si les indices dépassent les limites
                if range(9) not in (i1, i2): continue
 
                # Vérifications si les 2 cases dans l'alignement sont identiques
                if case[i1] == case[i2]: # 2 cases alignées identiques => gain ou perte assurée
                     if case[i] == couleur: # Ici possibilité de gain => on peut s'arrêter et renvoyer le n° de la case gagnante
                         return i
                     else: # Ici on perd la partie si l'adversaire la prend. Mais peut-être qu'une autre gagne donc on se contente de la mémoriser
                         ret=i
                # if
            # for
        # for
    # for
 
    # Si la fonction est arrivée jusque là c'est qu'aucune case n'est gagnante ou bien qu'une case perdante a été mémorisée - On renvoie donc la valeur mémorisée qui (rappel) est None par défaut
    return ret
# evaluation()

Tu appelles evaluation(ta_couleur).

• Soit tu obtiens une valeur de case à jouer obligatoirement gagnante (gagnante pour toi ou bien gagnante pour l'adversaire). Bien entendu il se peut qu'il y en ait d'autres mais de toute façon tu ne peux jouer qu'un seul coup donc tant-pis.
• Soit tu obtiens None qui indique qu'aucune case n'est gagnante ou perdante...

[PascalStl]

J'aime bien ton idée, sauf que j'ai pas réussis à la mettre en application

Car, supposons que l'on est à la case 0, alors il ne faut pas vérifier la case avant (-1) sinon sa plante, pareil pour la case 8, mais si on est à la case 1 la il faut aller voir... De plus, il faut prendre en compte les diagonales, et aussi, le fait que si on n'est à la case 0 par exemple, et qu'il y a un "O" à la case 1, et bien il faut mettre un "O" à la case 2. Si à la place, le "O" est à la case 2, alors il faut mettre un "O" à la case 1... Finalement, j'ai pas réussis à faire marcher ton exemple dsl

Par contre, sa ma donnée une idée . J'ai pondu ce code qui , une fois testé, fonctionne bien, en tout cas j'ai pas remarqué de bug.

J'ai mit plein de commentaire car il est asser dure à suivre , et aussi maintenant j'utilise l'indice de la liste comme reférence comme tu avais dit.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
def joueurAI(liste, pionAI):
    """Simule un joueur"""
 
    #Dictionnaire de toute les possibilité pour chaque case
    #on regroupe toute les lignes qui peuvent faire une suite
    #avec la case concerné ex: case 0 --> case1 et case2 font
    #une ligne donc: {0: (1,2)}
    dictLogique = {0:((1,2),(3,4),(4,8)),
                   1:((0,2),(4,7)),
                   2:((0,1),(4,6),(5,8)),
                   3:((0,6),(4,5)),
                   4:((0,8),(2,6),(1,7),(3,5)),
                   5:((2,8),(3,4)),
                   6:((0,3),(2,4),(7,8)),
                   7:((1,4),(6,8)),
                   8:((0,4),(2,5),(6,7))}
 
    case = None
    for cle in dictLogique: #pour chacune des cases
        if liste[cle].tag == pionAI: #si la case contient le signe de l'AI soit "O"
            valeur = dictLogique[cle] #alors on récupère toute les possibilité dans le dictionnaire pour cette case
            for ligne in valeur: #pour chaque possibilité dans les tuple de valeur
                for index, nombre in enumerate(ligne): #pour chaque case dans les tuple de valeur (on prend la valeur et l'index)
                    if liste[nombre].tag == pionAI: #si le signe de la case est celui de l'AI (ce qui veut dire que deux "O" se suivent)
                        if index == 0: #si on est dans la première valeur du tuple
                            if liste[ligne[index+1]].tag == "": #on vérifier si l'autre valeur du tuple est libre
                                case = ligne[index+1] #on écrit le numéro de case choisi
                        elif index == 1: #si on est dans la deuxième valeur du tuple
                            if liste[ligne[index-1]].tag == "":
                                case = ligne[index-1]
 
    #si pas de condition gagnante, alors on fais parreil mais avec les "X" de
    #l'autre joueur pour ne pas perdre
    if not case:
        for cle in dictLogique:
            if liste[cle].tag != pionAI and liste[cle].tag != "": #si la case n'est pas un "O" ni vide, c'est un "X"
                valeur = dictLogique[cle]
                for ligne in valeur:
                    for index, nombre in enumerate(ligne):
                        if liste[nombre].tag != pionAI and liste[nombre].tag != "":
                            if index == 0:
                                if liste[ligne[index+1]].tag == "":
                                    case = ligne[index+1]
                            elif index == 1:
                                if liste[ligne[index-1]].tag == "":
                                    case = ligne[index-1]
 
    #si pas de conditon perdante non plus, alors on prendre une case
    #vide au hazard
    if not case:
        vide = []
        for i in range(9):
            if liste[i].tag == "":
                vide.append(i)
 
        case = rd.choice(vide)
 
    return case

Est-ce que tu croix qu'il a moyen de faire plus simple?

[Sve@r]

Car, supposons que l'on est à la case 0, alors il ne faut pas vérifier la case avant (-1) sinon sa plante

Ce que fait mon test if range(9) not in (i1, i2): continue qui teste si les deux autres indices sont dans la plage [0-8]

De plus, il faut prendre en compte les diagonales

Ben si i vaut 0 et que deplacement vaut 4 alors (i1, i2) vaudra (4, 8) ce qui est bien une diagonale. Mais effectivement, j'ai mal codé le truc: si i vaut 4 (le centre) alors je vais regarder en 0 ou bien en 8 (la diagonale) mais je ne regarde pas (0, 8). Idem si i vaut 1 (centre d'une ligne). Je regarde en 0 ou bien en 2 mais pas en (0, 2).
Mais c'est pas super compliqué à revoir. Faut juste faire une recherche sur 2 niveaux. 1) regarder les 2 cases immédiates dans l'alignement (marche quand on est au centre d'une ligne ou d'une colonne) et 2) regarder les cases dans le prolongement (marche quand on est au début d'une ligne ou d'une colonne)

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
def evaluation(couleur):
    # Valeur renvoyée par défaut
    ret=None
 
    # Boucle sur toutes les cases du jeu   
    for i in xrange(9):
        if case[i] != vide: continue
 
        # Boucle sur les 4 directions possibles
        for direction in (1, 2, 3, 4):
            # Calcul indice des 2 cases adjacentes
            (i1, i2)=(i+direction, i-direction)
 
            # Si les indices dépassent les limites
            if range(9) not in (i1, i2): continue
 
            # Vérifications si les 2 cases adjacentes et alignées sont identiques
            if case[i1] == case[i2]: # 2 cases alignées identiques => gain ou perte assurée
                 if case[i] == couleur: # Ici possibilité de gain => on peut s'arrêter et renvoyer le n° de la case gagnante
                     return i
                 else: # Ici on perd la partie si l'adversaire la prend. Mais peut-être qu'une autre gagne donc on se contente de la mémoriser
                     ret=i
            # if
 
            # Boucle sur les sens de déplacement
            for sens in (1, -1):
                # Calcul déplacement
                dep=direction * sens;
 
                # Calcul indices des 2 cases alignées
                (i1, i2)=(i+dep, i + dep * 2)
 
                # Si les indices dépassent les limites
                if range(9) not in (i1, i2): continue
 
                # Vérifications si les 2 cases dans l'alignement sont identiques
                if case[i1] == case[i2]: # 2 cases alignées identiques => gain ou perte assurée
                     if case[i] == couleur: # Ici possibilité de gain => on peut s'arrêter et renvoyer le n° de la case gagnante
                         return i
                     else: # Ici on perd la partie si l'adversaire la prend. Mais peut-être qu'une autre gagne donc on se contente de la mémoriser
                         ret=i
                # if
            # for
        # for
    # for
 
    # Si la fonction est arrivée jusque là c'est qu'aucune case n'est gagnante ou bien qu'une case perdante a été mémorisée - On renvoie donc la valeur mémorisée qui (rappel) est None par défaut
    return ret
# evaluation()

et aussi, le fait que si on n'est à la case 0 par exemple, et qu'il y a un "O" à la case 1, et bien il faut mettre un "O" à la case 2.

Tu n'avais pas dit ça dans ta demande initiale. Tu disais que s'il n'y avait aucune possibilité de gain ou perte tu prenais une case au hasard. Effectivement dans les jeux à états finis (dames, échecs, morpions, othello, 4 en ligne, etc) il y a une stratégie (placer ses pions à l'étape 1 pour un gain à l'étape 2 ou 3 ou 500) mais ça ça se programme totalement différemment. En général on fait du récursif. On simule chaque coup possible puis on examine les réponses que l'adversaire peut faire. Pous chaque réponse on va examiner chaque coup en retour puis chaque réponse possible et etc etc etc jusqu'à ce qu'on trouve une suite gagnante absolue ou bien qu'on atteigne une profondeur trop importante pour pouvoir tout évaluer. C'est ce qu'on nomme l'algorithme alpha/beta.

Si à la place, le "O" est à la case 2, alors il faut mettre un "O" à la case 1... Finalement, j'ai pas réussis à faire marcher ton exemple dsl

Pas grave. C'est juste pour te donner des idées.

Par contre, ça m'a donnée une idée . J'ai pondu ce code qui , une fois testé, fonctionne bien, en tout cas j'ai pas remarqué de bug.

J'ai mit plein de commentaire car il est asser dur à suivre , et aussi maintenant j'utilise l'indice de la liste comme reférence comme tu avais dit.

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
def joueurAI(liste, pionAI):
    """Simule un joueur"""
 
    #Dictionnaire de toute les possibilité pour chaque case
    #on regroupe toute les lignes qui peuvent faire une suite
    #avec la case concerné ex: case 0 --> case1 et case2 font
    #une ligne donc: {0: (1,2)}
    dictLogique = {0:((1,2),(3,4),(4,8)),
                   1:((0,2),(4,7)),
                   2:((0,1),(4,6),(5,8)),
                   3:((0,6),(4,5)),
                   4:((0,8),(2,6),(1,7),(3,5)),
                   5:((2,8),(3,4)),
                   6:((0,3),(2,4),(7,8)),
                   7:((1,4),(6,8)),
                   8:((0,4),(2,5),(6,7))}
 
    case = None
    for cle in dictLogique: #pour chacune des cases
        if liste[cle].tag == pionAI: #si la case contient le signe de l'AI soit "O"
            valeur = dictLogique[cle] #alors on récupère toute les possibilité dans le dictionnaire pour cette case
            for ligne in valeur: #pour chaque possibilité dans les tuple de valeur
                for index, nombre in enumerate(ligne): #pour chaque case dans les tuple de valeur (on prend la valeur et l'index)
                    if liste[nombre].tag == pionAI: #si le signe de la case est celui de l'AI (ce qui veut dire que deux "O" se suivent)
                        if index == 0: #si on est dans la première valeur du tuple
                            if liste[ligne[index+1]].tag == "": #on vérifier si l'autre valeur du tuple est libre
                                case = ligne[index+1] #on écrit le numéro de case choisi
                        elif index == 1: #si on est dans la deuxième valeur du tuple
                            if liste[ligne[index-1]].tag == "":
                                case = ligne[index-1]
 
    #si pas de condition gagnante, alors on fais parreil mais avec les "X" de
    #l'autre joueur pour ne pas perdre
    if not case:
        for cle in dictLogique:
            if liste[cle].tag != pionAI and liste[cle].tag != "": #si la case n'est pas un "O" ni vide, c'est un "X"
                valeur = dictLogique[cle]
                for ligne in valeur:
                    for index, nombre in enumerate(ligne):
                        if liste[nombre].tag != pionAI and liste[nombre].tag != "":
                            if index == 0:
                                if liste[ligne[index+1]].tag == "":
                                    case = ligne[index+1]
                            elif index == 1:
                                if liste[ligne[index-1]].tag == "":
                                    case = ligne[index-1]
 
    #si pas de conditon perdante non plus, alors on prendre une case
    #vide au hazard
    if not case:
        vide = []
        for i in range(9):
            if liste[i].tag == "":
                vide.append(i)
 
        case = rd.choice(vide)
 
    return case

Est-ce que tu croix qu'il a moyen de faire plus simple?

Oui. Dans la mesure ou tu codes un algo pour le "O" puis que tu le recopies pour le "X" il y a obligatoirement moyen de faire plus simple. La victoire d'un joueur est aussi la défaite de l'autre. Avec un simple jeu de +1/-1 tu peux transformer une recherche de victoire en recherche de défaite. Et tu devrais séparer la recherche de gain/perte du choix de la case pour commencer à apprendre la modularité (séparer les actions dans des fonctions dédiées afin de pouvoir les reprogrammer/changer plus facilement si besoin). Par exemple mettre l'algo de recherche dans une fonction à part permet de l'appeler pour "O" (gain) ou bien pour "X" (perte).

Sinon le coup du dictionnaire est pas mal. Ca évite les calculs inutiles que je fais puis que je shunte (surtout que je les fais maintenant 2 fois). C'est bien quand l'ensemble des cas possibles est assez peu important pour que la faible mémoire utilisée soit avantageuse par rapport au temps de calcul.

De plus, il existe un truc en Python: les "list comprehension" (en fait c'est pas spécialement en Python. C'est un truc mathématique qui a été porté en Python mais aussi dans d'autres langages). Ca permet de créer des listes "à la volée".
Exemple

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
a=range(10)
b=[x**2 for x in a] # La liste des carrés des valeurs de a
c=[x**3 for x in a if x % 2] # La liste des cubes de seules valeurs impaires de a

Super pratique pour des algos de création de listes. Exemple: ta recherche des cases vides

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
vide = []
for i in range(9):
    if liste[i].tag == "":
        vide.append(i)

Va se transformer en

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

vide=[i for i in range(9) if liste[i].tag == ""]

Ce qui permet de transformer tout le gros bloc final en un simple

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

return case or rd.choice([i for i in range(9) if liste[i].tag == ""])

[PascalStl]

Super les list comprehension je ne connaissais pas ça

Mais là, je pense que j'ai crié victoire trop vite car en faisant des tests j'ai remarqué que lorsqu'il y a un "X" en case 4 et 8, l'AI ne met pas de "O" à la case 0, pareil lorsqu'il y a un "X" en 2 et en 4... Je suis embêté car si ça marche pour tout le reste ça devrait marcher pour là...

Je vais regarder pour les algorithmes alpha/beta ça m'intéresse