Vous avez enfin décidé de débarquer et d’explorer le vaste monde de la programmation ? Dans ce cas, bienvenue chez les fous ! Entre cassage d’écran, arrachage de cheveux, ou encore saut par la fenêtre, vous vous rendrez vite compte comment ce vaste univers peut vous rendre maboule de 1001 manières. Ainsi, si vous souhaitez gagner du temps et être productif en programmation, ce tutoriel est fait pour vous !
En effet, il existe heureusement depuis quelques années des outils, se perfectionnant de mois en mois (voire même de jour en jour), permettant de vous faciliter la vie et surtout de gagner énormément de temps. La chose dont une développeuse ou un développeur a le plus besoin. L’un des outils ayant fait le plus parlé de lui ces dernières semaines est #ChatGPT, une intelligence artificielle capable de dialoguer avec nous en nous apportant des connaissances dans quasiment tous les domaines (mathématiques, langues, physique, etc.). Et donc dans ce tutoriel nous nous intéresseront à l’utilisation de #ChatGPT dans le domaine de la programmation en Python.
Une IA, c’est quoi ?
L’intelligence artificielle (IA) est une technologie qui permet à des machines de simuler l’intelligence humaine. Elle est utilisée dans de nombreux domaines, allant de la reconnaissance de la parole et de l’image à la robotique en passant par la finance et la santé.
Dans le domaine de la programmation, l’IA peut être utilisée pour automatiser certaines tâches de développement, comme la génération de code, la correction de bugs et la modification de scripts existants. Elle peut également être utilisée pour analyser et optimiser des algorithmes, ainsi que pour effectuer des tâches de test et de débogage.
Avantages de l’utilisation d’une IA
L’utilisation de l’intelligence artificielle (IA) dans le domaine de la programmation peut apporter plusieurs avantages incroyables. Voici une ribambelle d’exemples :
L’automatisation de tâches fastidieuses : l’IA peut être utilisée pour automatiser certaines tâches de développement, comme la génération de code, la correction de bugs et la modification de scripts existants. Cela peut aider les développeurs à gagner du temps et à se concentrer sur des tâches plus complexes.
Amélioration de la qualité du code : l’IA peut être utilisée pour analyser et optimiser des algorithmes, ce qui peut aider à améliorer la qualité du code et à réduire les erreurs.
Test et débogage plus efficaces : l’IA peut être utilisée pour effectuer des tests et du débogage de manière plus rapide et plus précise, ce qui peut réduire le temps de développement.
Il est important de noter que l’utilisation de l’IA dans le domaine de la programmation nécessite un minimum de compétence en matière de développement. Une IA n’est pas (encore) parfaite et peut commettre des erreurs, il est donc nécessaire de toujours relire, vérifier, comprendre, et tester un code généré par une IA. Il est également important de veiller à utiliser l’IA de manière éthique et responsable. 😉
Comment accéder à l’IA
Nous utiliserons donc dans ce tutoriel ChatGPT, un chatbot qui utilise l’intelligence artificielle.
Le chat est disponible à tous gratuitement via l’URL suivante : https://chat.openai.com/auth/login. Voici la page dans laquelle vous accèderez :
Comme vous l’avez sans doute deviner, vous aurez besoin d’un compte OpenAI pour utiliser cette IA. Cliquez donc sur le bouton Sign up pour créer un compte, ou sur Log in si vous en avez déjà un.
Quand vous vous serez alors connecté avec succès, vous tomberez normalement nez à nez avec la page suivante, la page principale :
Cette page est assez simple au final, nous retrouvons en haut à gauche un bouton qui nous permet de créer d’autres chat. En effet, l’IA est capable de « retenir », réutiliser, et prendre en compte l’historique des précédents messages ! Donc si on discute avec elle sur des sujets précis, et que nous souhaitons ne pas mélanger des conversations, nous pouvons en ouvrir plusieurs qui seront indépendantes les unes des autres, il suffit donc d’appuyer sur ce bouton, intitulé New Chat.
Et puis en bas, nous retrouvons la barre où nous pourrons écrire et discuter avec l’IA. Tout ce qu’il y a de plus classique.
Utilisation de l’IA pour générer et modifier des scripts Python
L’IA peut être utilisé pour la génération, ou plutôt l’écriture de scripts Python.
Voici donc ci-dessous quelques exemples, assez époustouflants, où nous pouvons utiliser l’IA pour générer des scripts Python.
Mise en situation : Catastrophe, un DS de mathématiques demain et j’avais complètement oublié ! Il me faudrait un script Python qui puisse me calculer le discriminant ainsi que les racines d’une fonction, cela me ferait gagner beaucoup de temps…
Voyons de quoi est capable l’IA :
Aussitôt dit, aussitôt fait, l’IA nous pond une fonction python qui nous permet de calculer le discriminant et les racines d’une fonction du second degré.
Vous noterez qu’il est déjà possible d’obtenir le discriminant et les racines d’une fonction du second degré sans script python en sachant bien utiliser sa calculatrice. 😁
Essayons autre chose, un peu d’art pour voir ! J’aurai besoin d’une fonction me permettant de créer une étoile, à l’aide du module Turtle. Mais ajoutons un peu de piment à tout ça ! La fonction devra prendre en paramètre : La position x et y de l’étoile, la couleur de l’étoile, la taille de l’étoile, ainsi que le nombre de branches de l’étoile. 😈
Et maintenant, la question tant attendu : Est-ce que ça marche cette sorcellerie ? Et bien la meilleur façon de savoir, c’est de tester !
Voici donc le rendu sur Thonny :
Comme vous le voyez c’est très très impressionnant.
En expliquant clairement nos attentes, et nos contraintes. L’IA les respecte (ou en tout cas essaie) et nous offre un code documenté, et la plupart du temps optimisé.
À ce stade, la première question que nous pouvons nous poser est de savoir si le code généré par l’IA sort de ses mains, ou si elles il vient d’Internet. Pour le savoir, je vous laissez deviner, demandons lui simplement !
Ainsi, nous avons vu que l’IA était capable d’écrire du code python selon nos envies. Mais à l’évidence, elle peut aussi être utilisée pour modifier du code python. De la même manière, nous n’avons qu’à lui soumettre notre script à modifier, et lui demander ce qu’elle a à faire. Ensuite, laissez la magie opérer…
Voyons cela, voici le code suivant (qui n’a pas été écrit par l’IA) :
n = input("Choisissez un nombre.\t")
try:
n = int(n)
except ValueError:
exit("Ce n'est pas un nombre.")
is_prime = 1*(n > 1)
for i in range(2, n):
if n % i == 0:
is_prime = 0
break
print("Ce nombre est premier." if is_prime else "Ce nombre n'est pas premier.")
Grosso modo, ce script nous dit si un nombre n est premier ou non. Demandons lui de l’optimiser :
Effrayant ou époustouflant ? 🤔
Utilisation de l’IA pour corriger des scripts Python
Bon jusqu’ici, nous n’avons pas été déçu. Voyons de quoi elle vaut dans la correction de scripts python. Voici ci-dessous un exemple concret d’utilisation pour corriger un script Python.
Ci-dessous, un script Python censé afficher la table de 5 :
table = 5
print("Table de" + table + ":")
for i in range(11):
print("5x" + i + " = " + 5*i)
Malheureusement, je n’arrive à lancer le script et je ne comprends pas l’erreur : TypeError: can only concatenate str (not "int") to str
Demandons donc à l’IA. Enfin, nous allons seulement lui envoyer notre bout de code tel quel et observer ce qu’il se passe :
Vous avez bien compris, l’IA a deviné par elle même que je voulais qu’elle corrige mon code en python, en remarquant qu’il y avait des erreurs dans celui-ci.
Nonobstant, en cas d’incompréhension d’une erreur, je conseille d’abord de demander à l’IA ce que signifie l’erreur, et d’essayer de la corriger sans son aide. L’IA est capable d’expliquer très clairement un concept, avec des exemples et possiblement des formulations différentes :
Comme vous le voyez, c’est assez spectaculaire, l’IA nous explique explicitement l’erreur, et ajoute des exemples tout au long de son explication. En l’occurrence comme vous l’avez vu, c’était un problème de concaténation.
Conclusion
En conclusion, l’utilisation d’une intelligence artificielle (IA) peut être un outil très utile pour aider les développeurs Python à générer, corriger et modifier leur code. Il existe de nombreux outils et bibliothèques qui permettent d’intégrer l’IA dans le développement de logiciels, comme nous l’avons vu précédemment il y a ChatGPT, mais il existe aussi des alternatives tout aussi époustouflantes, comme GitHub Copilot.
En utilisant ces outils, les développeurs peuvent gagner du temps et de l’efficacité dans leur travail quotidien et se concentrer sur des tâches plus complexes. Cependant, il est important de noter qu’il est toujours important de comprendre et de maîtriser les principes de base du développement de logiciels, même si l’on utilise l’IA pour automatiser certaines tâches.
Vous l’aurez compris, pour ne pas finir à l’hôpital des fous, il est toujours sympa d’avoir un petit assistant sous la main !
Dans ce tutoriel je vais vous expliquer clairement le mode de fonctionnement de l’une des intelligences artificielle les plus développer actuellement présente dans le milieu informatique, qui vous permettra de devenir un véritable artiste peintre en quelques minutes.
Cette innovation est menée par l’entreprise Nvidia qui est entre autres reconnue mondialement pour ces cartes graphiques. En effet le jeudi 24 juin 2021 l’entreprise publie officiellement la bêta public de son intelligence artificielle. Celle-ci est de nos jours encore en constantes évolutions, c’est-à-dire que l’on a accès à seulement une petite partie des fonctionnalités de l’application définitives. Elle a donc pour but de « vulgariser » afin de rendre accessible au monde entier le talent d’artiste peintre. Cependant elle peut aussi convenir aux artistes afin de les aider à imaginer une première version de leur travail.
La création de l’intelligence artificielle
Cette avancée majeure dans le monde des IA est en partie grâce aux développeurs de chez Nvidia qui ont fait analyser des millions d’images de paysages existant de notre monde, afin qu’elle puisse en créer une de toutes pièces, tout en gardant une vision vraisemblable.
Conditions d’utilisation :
Cependant cette technologie n’est disponible seulement sous le système d’exploitation Windows 10. De plus sa demande en vitesse de calcul étant très élevé elle n’est disponible que sous certaines conditions :
Une unité de traitement graphique (GPU) tels que la NVIDIA GeForce RTX, ou NVIDIA RTX, et TITAN RTX.
Un disque dur en SSD (un disque dur utilisant des éléments de mémoire flash comme éléments de stockage des données).
Un pilote possédant la version 471.68 au minimum.
Ces contraintes d’utilisation montrent pour le moment que cette technologie n’est donc pas accessible à un grand nombre de personnes, puisqu’elle demande des composants d’une certaine valeur. Cette IA est donc plus fréquemment utilisée par des professionnels.
Le fonctionnement de l’IA
Comme indiqué ci-dessus, cette technique est basée sur un système d’utilisation simple afin qu’elle soit accessible à tous. Ainsi lorsque nous nous retrouvons sur ce logiciel l’on retrouve différents paramètres qui nous seront utiles lors de la création mais aussi de l’exportation de notre dessin une fois terminé.
L’on distingue donc 3 zones ou se regroupe les paramètres :
La première partie est destinée à la création d’un point de vue technique du dessin puisque l’on peut retrouver des fonctionnalités telles que le pinceau servant a choisir l’environnement que l’on souhaite utiliser. Mais aussi un outil nous aidant à tracer des lignes droites et bien évidemment la fonctionnalité gommes et remplissage. D’un point de vue pratique la bêta propose une fonctionnalité permettant de choisir précisément une couleur, ou bien celle permettant choisir l’épaisseur de la pointe du stylo.
Dans la seconde partie l’on retrouve tout ce qui rapporte au fichier et à l’affichage de celui-ci. Ainsi l’on a l’opportunité d’ouvrir une nouvelle feuille vierge afin d’effectuer un nouveau dessin mais aussi ce qui concerne l’enregistrement et l’exportation de ce dessin. De plus, la loupe permet d’agrandir plus ou moins le dessin lors de sa création mais aussi l’on peut choisir de voir le dessin (à gauche) et le rendu final après l’intervention de l’IA (à droite) en même temps ou bien chaque rendu à part, c’est-à-dire ou l’un ou l’autre, c’est à vous de choisir.
Enfin dans la troisième partie l’on retrouve l’aspect graphique. Notamment avec le choix d’une vingtaine de matériaux comme par exemple avec des nuages, des montagnes, de l’herbe, une rivière et de la brume et de la pluie ainsi qu’une quinzaine d’autres textures. De plus l’on retrouve l’opportunité d’utiliser des « layers » tout comme Photoshop par exemple cela nous donne l’opportunité d’avoir plusieurs calques superposés. Enfin l’on a accès à 9 styles ce qui permet d’appliquer au dessin une ambiance différente telle qu’un coucher de soleil ou bien un environnement ensoleillé.
Comme l’on dit « une image vaut mieux que mille mots« , alors je vous mets à disposition différent dessin réaliser avec Nvidia Canvas.
Vous pouvez donc voir le potentiel juste immense de cette intelligence artificielle qui est en constante évolution, il ne vous reste qu’à la télécharger grâce à ce lien pour les tester de vous-même et laisser s’exprimer votre créativité : https://www.nvidia.com/fr-fr/studio/canvas/
En conclusion j’espère que ce tutoriel que j’ai moi-même pris du plaisir à réaliser, vous aura permis de découvrir cette intelligence artificielle et qu’il vous guidera lors de son utilisation.
Dans ce tutoriel, je vais vous montrer comment détourer gratuitement une image en quelques secondes avec l’Intelligence Artificielle Arc Tencent.
Introduction
Le détourage d’image est une technique utilisée pour séparer un objet ou une personne d’un arrière-plan dans une image. Cela peut être utile pour ajouter des effets spéciaux à une image, pour enlever un arrière-plan indésirable ou simplement pour mettre en valeur un objet ou une personne.
Le détourage d’image peut être un processus long et fastidieux lorsqu’il est effectué manuellement, mais heureusement, il existe maintenant des outils d’IA qui permettent de détourer rapidement et facilement une image.
Présentation de l’outil ARC Tencent
L’IA de Tencent est un service de intelligence artificielle développé par Tencent, une entreprise chinoise spécialisée dans les technologies de l’information et de la communication.
Elle utilise des technologies avancées de deep learning et de machine learning pour fournir des résultats de haute qualité et des performances rapides. L’IA de Tencent est utilisée par de nombreuses entreprises et organisations à travers le monde pour améliorer leurs opérations et leur productivité.
Simple et rapide, ce service en ligne gratuit offrira de meilleurs résultats que RemoveBG et vous permettra des résultats téléchargeables en Full HD.
L’IA, c’est quoi ?
L’intelligence artificielle (IA) est un domaine de la science informatique qui vise à créer des programmes informatiques capables de réaliser des tâches qui nécessiteraient de l’intelligence humaine, comme la reconnaissance de la parole, la traduction de langues, le raisonnement et la prise de décision.
Il existe plusieurs types d’IA, notamment l’IA faible (également appelée IA de premier ordre) et l’IA forte (également appelée IA de deuxième ordre). L’IA faible est capable de réaliser des tâches spécifiques mais ne peut pas raisonner ou prendre des décisions de manière autonome. L’IA forte, en revanche, est capable de raisonner et de prendre des décisions de manière autonome, comme le ferait un humain.
L’IA est utilisée dans de nombreux domaines, notamment la robotique, la reconnaissance de la parole, la traduction, la finance et les jeux vidéo. Elle est également utilisée pour améliorer l’efficacité et la productivité dans les entreprises et les organisations.
Comment détourer son image
Voici les étapes simples à suivre pour détourer une image grâce à l’IA de Tencent :
1/ Tout d’abord, il faut aller sur son navigateur et dans la barre d’URL taper l’adresse ci-dessous afin de se rendre sur le site en ligne.
2/ Une fois sur le site, choisissez la version qui vous semble la mieux (souvent la V1.2 donne de meilleurs résultats, sur les cheveux par exemple) Vous pouvez déjà tester l’IA avec les 3 images proposé.
3/ A présent, cliquez sur Upload (en bleu) pour détourer l’image que vous souhaitez.
4/ Choisissez votre image (ici j’ai choisi un lion)
5/ Attendez quelques secondes et voilà le résultat !
6/ Vous n’avez plus qu’à la télécharger en cliquant sur Download.
En quelques secondes seulement mon lion a été parfaitement détouré automatiquement, sans faire quoi que ce soit de ma part si ce n’est qu’attendre.
Autres fonctionnalités de restauration
Il y a 2 autres fonctionnalités, « Face Restoration » qui va permettre de rendre une photo flou très nette et « Animation Enhancement » qui fait la même chose mais sur des illustrations, des dessins…
Voici un aperçu, c’est le même principe que pour le détourage d’image.
Conclusion
En suivant les étapes décrites dans ce tutoriel, vous avez appris comment détourer gratuitement une image en 2 clics avec l’IA de Tencent, que peut être très utile pour des miniatures Youtube par exemple.
Si vous souhaitez ajouter des modifications ou des retouches à l’image détourée, vous pouvez utiliser les outils d’édition d’image disponibles dans l’application Tencent AI Lab.
L’objectif de ce tutoriel était de vous montrer comment utiliser l’IA de Tencent pour détourer facilement et rapidement une image, sans avoir besoin de compétences en retouche photo ou en détourage manuel.
DALL-E 2 est une puissante intelligence artificielle conçue pour générer du contenu visuel à partir de textes de description. Il est capable de créer des images de tout ce que vous pouvez imaginer, simplement en tapant une description de ce que vous voulez voir. Dans ce tutoriel, nous vous guiderons pas à pas à travers les étapes de base pour utiliser DALL-E 2. Vous apprendrez comment formuler des requêtes de génération d’images, comment naviguer dans l’interface de l’outil et comment enregistrer et télécharger vos créations.
Tapez une description de l’image que vous souhaitez générer dans la boîte de texte. Vous pouvez utiliser n’importe quel type de description, allant de concepts simples à des combinaisons complexes de concepts visuels et textuels. Par exemple, vous pouvez taper « un chat avec des ailes et une queue de lion », « un robot qui joue du violoncelle », ou « un paysage de montagne avec un arbre en forme de cœur ».
Capture de la boîte de texte.
Générer son image.
Cliquez sur le bouton « Generate » pour lancer le processus de génération de l’image. DALL-E 2 va utiliser votre description pour générer une image et l’afficher sur la page. Selon la complexité de votre description et la puissance de votre ordinateur, cela peut prendre quelques secondes à plusieurs minutes.
Capture prise pendant le téléchargement.
Afficher son image.
Lorsque l’image est générée, vous pouvez l’afficher en taille réelle en cliquant dessus.
Capture des images générées.Capture après avoir cliqué sur une image.
Variations.
Vous pouvez également utiliser le bouton « Variations » pour afficher d’autres images qui ressemble a la votre.
Capture des variations de l’image.
Filtre et modification de l’image.
Vous pouvez également utiliser les options de filtre et de modification de l’image pour ajuster l’apparence de l’image générée. Pour cela, appuyer sur « Edit ». Prenez en main la gomme.
Capture de l’onglet d’édition.
Vous pouvez a présent effacer une partie de votre image et décrire par quoi vous voulez qu’elle soit remplacé.
Capture du gommage.
Appuyer sur « Generate ».
Capture des résultats.
De plus vous pouvez générer la suite de votre image. Prenez en main le premier outil.
Vous pouvez a présent déplacer une partie de votre image et décrire par quoi vous voulez qu’elle soit compléter.
Capture du décalage de l’image.
Exemple de l’outil expliqué précédemment.
Téléchargement de son image.
Si vous êtes satisfait de l’image générée, vous pouvez télécharger l’image en cliquant sur le bouton « Save ». Vous pouvez choisir entre plusieurs formats de fichier, tels que PNG, JPG et GIF.
Partager son image.
Si vous souhaitez enregistrer votre travail et partager vos images générées avec d’autres personnes, vous pouvez vous connecter avec votre compte OpenAI ou créer un nouveau compte. Vous pouvez alors enregistrer vos images dans votre bibliothèque et les partager via un lien ou en les publiant sur les réseaux sociaux.
A savoir.
Il est important de noter que DALL-E 2 est encore en développement et que ses résultats peuvent varier en qualité et en cohérence avec la description donnée. Cependant, c’est un outil amusant et créatif pour expérimenter avec des combinaisons de concepts
Vous avez toujours rêvé de bons tutoriels, mais vous ne savez pas comment vous y prendre ? Nous avons la solution idéale pour vous ! Dans ce tutoriel, nous vous révélerons les secrets pour rédiger un tutoriel informatique de qualité qui saura captiver votre public. Grâce à nos conseils pratiques et faciles à mettre en œuvre, vous deviendrez bientôt le prochain spécialiste incontournable de la technologie. Alors, prêt à découvrir comment faire un bon tutoriel informatique ?
Définir le public cible du tutoriel
Avant de commencer à rédiger votre tutoriel, il est essentiel de déterminer à qui s’adresse votre contenu. En effet, en connaissant votre public cible, vous pourrez mieux adapter votre niveau de langage et votre approche à leurs besoins et connaissances.
La qualité de votre contenu dépend en grande partie de votre connaissance de votre public cible.
Neil Patel
Pour définir votre public cible, voici quelques questions à se poser :
Quel est le niveau de connaissances en informatique de votre public ? Sont-ils débutants, intermédiaires ou avancés ?
Quel est l’objectif de votre tutoriel ? Voulez-vous enseigner une compétence précise ou donner une vue d’ensemble d’un sujet ?
Quel est l’âge de votre public ? Est-ce que votre tutoriel s’adresse à des enfants, des adolescents, des adultes ou un public plus âgé ?
Quel est le profil de votre public ? Sont-ils des professionnels, des étudiants, des passionnés de technologie ou des utilisateurs occasionnels ?
En répondant à ces questions, vous devriez être en mesure de définir avec précision votre public cible. Cela vous permettra de mieux cibler votre tutoriel et de garantir une meilleure compréhension de votre contenu. N’oubliez pas, en connaissant votre public, vous pourrez mieux répondre à leurs besoins et leur offrir une expérience d’apprentissage optimale.
Choisir un sujet précis et adapté
Le choix du sujet de votre tutoriel est crucial pour assurer son succès. En effet, il est important de s’assurer que le sujet choisi est intéressant et utile pour votre public cible. Pour cela, voici quelques points à prendre en compte :
Choisissez un sujet qui répond à un besoin ou à une demande de votre public. Si vous êtes en mesure de répondre à une question ou de résoudre un problème précis, vous avez de fortes chances de captiver l’attention de votre public.
Évitez les sujets trop vastes ou trop généraux. Si vous couvrez trop de domaines différents, vous risquez de perdre en profondeur et en qualité. Il vaut mieux se concentrer sur un sujet précis et le traiter en détail plutôt que de survoler de nombreux sujets de manière superficielle.
Sélectionnez un sujet qui correspond à vos compétences et à votre expertise. Si vous êtes passionné et connaissez bien votre sujet, vous serez en mesure de transmettre votre savoir de manière claire et convaincante.
Faites en sorte que votre sujet soit original et innovant. Si vous arrivez à proposer une nouvelle perspective ou une approche originale, vous aurez plus de chances de susciter l’intérêt de votre public.
Il est important de choisir un sujet qui vous passionne, afin de transmettre votre enthousiasme et votre savoir à votre public.
Marie Forleo
En choisissant un sujet précis et adapté, vous vous assurerez de fournir une information de qualité et de captiver l’attention de votre public. N’hésitez pas à prendre le temps de réfléchir à votre sujet et à le peaufiner afin de vous assurer qu’il répond parfaitement à vos objectifs et à ceux de votre public.
Rechercher les informations nécessaires
Une fois que vous avez choisi votre sujet et défini votre public cible, il est important de vous documenter correctement afin de s’assurer de la qualité et de l’exactitude de l’information fournie. Pour cela, voici quelques astuces :
Utilisez des sources fiables et reconnues. Pour vous assurer de la qualité de vos informations, il est important de privilégier des sources sérieuses et crédibles. Vous pouvez par exemple vous renseigner sur des sites spécialisés, des articles de revues professionnelles ou encore des ouvrages de référence.
Prenez le temps de vous documenter en profondeur. Il ne s’agit pas de survoler rapidement une multitude de sources, mais bien de vous plonger dans le sujet et de comprendre tous les aspects de celui-ci. Cela vous permettra de mieux vous approprier le sujet et de le présenter de manière plus complète et précise.
La qualité de votre tutoriel dépend en grande partie de la qualité de vos sources. Il est essentiel de se documenter auprès de sources fiables et de s’assurer de la véracité de vos informations
Simon Sinek
N’hésitez pas à consulter des experts. Si vous avez des questions ou des doutes sur un aspect précis de votre sujet, n’hésitez pas à vous tourner vers des experts dans le domaine. Vous pourrez leur poser des questions, échanger avec eux et ainsi vous enrichir de leur savoir et de leur expérience.
Utilisez différentes sources d’information. Pour avoir une vue d’ensemble la plus complète possible de votre sujet, il est conseillé de consulter plusieurs sources différentes. Cela vous permettra de comparer et de vous faire une idée la plus objective possible du sujet.
En prenant le temps de bien vous documenter, vous vous assurerez de fournir des informations de qualité et de répondre de manière précise et détaillée aux questions de votre public. N’oubliez pas, en matière de tutoriel informatique, il est essentiel de s’appuyer sur des sources fiables et de bien comprendre le sujet avant de le présenter.
Organiser les informations
Une fois que vous avez rassemblé toutes les informations nécessaires, il est important de les organiser de manière logique et cohérente afin de faciliter la compréhension de votre public. Pour cela, voici quelques astuces :
Créez une introduction qui présente votre sujet et donne envie de poursuivre la lecture. Cette introduction doit être concise et aller droit au but, tout en étant attractive et engageante.
Divisez votre tutoriel en parties thématiques. Cela vous permettra de structurer votre contenu de manière logique et de ne pas perdre votre public en cours de route. Vous pouvez par exemple utiliser des sous-titres ou des numérotations pour séparer vos parties.
Utilisez des exemples concrets et des illustrations pour rendre votre tutoriel plus attractif et plus facile à comprendre. Des exemples concrets permettront à votre public de mieux visualiser les concepts abordés et de les mettre en pratique plus facilement.
Terminez votre tutoriel par une conclusion qui résume les principaux points abordés et qui incitera votre public à mettre en pratique ce qu’il vient d’apprendre.
Il est important de prendre le temps d’organiser vos informations afin de proposer un tutoriel fluide et agréable à suivre.
Dan Dennett
Si le tutoriel est rédigé sur un outil tel que WordPress :
Il est conseillé de n’utiliser qu’un seul niveau de titre html, les titres de niveau 2 (h2) uniquement devraient être utilisés afin de ne pas créer une arborescence profonde.
Il est souhaitable de ne pas modifier manuellement les couleurs, tailles et polices des textes et titres, d’utiliser les possibilités de la barre d’outil sans tenter de contourner une fonctionnalité de son utilisation initiale. Par exemple, même si les titres h2 ne sont pas à votre goût, il ne faut pas surcharger le style par défaut en changeant la couleur, agrandissant le texte, ce genre de modification est proscrite car elle va contrer la charte graphique (probablement imparfaite) définie dans la feuille de style.
Il faut s’interdire absolument de souligner. Ceci est donc l’exemple de ce qu’il ne faut pas faire.
Si vous avez besoin de structurer davantage, étant donné que vous ne devez pas utiliser les titre de niveau 3 (h3) vous pouvez exploiter les listes à puces, les listes numérotés, les textes sur une unique ligne en gras, comme dans ce tutoriel.
Le plus souvent possible, il faut prévisualiser le rendu final avec le bouton prévisualiser.
En organisant vos informations de manière claire et logique, vous facilitez la compréhension de votre public et vous vous assurez de transmettre efficacement votre savoir. N’hésitez pas à y consacrer du temps et à peaufiner votre structure afin de proposer un tutoriel fluide et agréable à suivre.
Rédiger le tutoriel
Une fois que vous avez organisé vos informations de manière cohérente, il est temps de passer à la rédaction de votre tutoriel. Pour cela, voici quelques astuces :
Écrivez de manière claire et concise. Il est important de ne pas perdre votre public en proposant un contenu trop dense ou trop technique. Utilisez un langage simple et accessible, et n’hésitez pas à utiliser des synonymes ou des métaphores pour rendre votre rédaction plus agréable à lire.
Faites des paragraphes courts et aérées. Pour faciliter la lecture et la compréhension de votre public, il est conseillé de ne pas écrire de trop longs paragraphes. Utilisez des retours à la ligne et des espacements pour rendre votre tutoriel plus lisible et plus digeste.
Utilisez des exemples concrets et des illustrations pour rendre votre tutoriel plus attractif et plus facile à comprendre. Des exemples concrets permettront à votre public de mieux visualiser les concepts abordés et de les mettre en pratique plus facilement.
N’hésitez pas à utiliser des témoignages ou des anecdotes pour rendre votre tutoriel plus vivant et plus engageant. Ces éléments personnels pourront susciter l’intérêt de votre public et lui donner envie de poursuivre la lecture.
Un élève du lycée Louis Pasteur en train de rédiger son tutoriel pendant les vacances de Noël.
En rédigeant votre tutoriel de manière claire et concise, vous facilitez la compréhension de votre public et vous vous assurez de transmettre efficacement votre savoir. N’oubliez pas, en matière de tutoriel informatique, il est essentiel de proposer un contenu de qualité et de le rendre le plus attractif et le plus accessible possible.
Vérifier l’orthographe et la grammaire
Une orthographe irréprochable est la preuve d’un savoir-faire et d’un respect envers son lecteur
Victor Hugo
Une fois que vous avez terminé la rédaction de votre tutoriel, il est important de vérifier l’orthographe et la grammaire afin de s’assurer de la qualité de la rédaction. Pour cela, voici quelques astuces :
Utilisez un correcteur orthographique. La plupart des logiciels de traitement de texte disposent d’un correcteur orthographique intégré qui peut vous aider à détecter et à corriger les fautes de frappe et les erreurs de grammaire. N’hésitez pas à utiliser cet outil pour vous assurer de la qualité de votre rédaction. Il existe d’ailleurs une excellente extension pour le navigateur Firefox, elle pourrait vous être d’un grand secours : grammalecte Cette extension fait apparaître un petit rond en bas de chaque paragraphe, il suffit de cliquer sur le rond pour avoir une correction, puis on clique sur l’erreur et on valide la correction !
Faites relire votre tutoriel par une personne extérieure. En faisant relire votre tutoriel par une personne qui n’est pas familière avec le sujet, vous aurez un regard extérieur et vous pourrez vous assurer que votre contenu est compréhensible et facile à suivre.
Prenez le temps de relire votre tutoriel attentivement. Même si vous utilisez un correcteur orthographique et que vous faites relire votre tutoriel, il est important de le relire attentivement pour vous assurer qu’il n’y a pas de fautes ou de coquilles qui ont pu échapper aux outils de correction.
N’hésitez pas à demander de l’aide si vous avez des doutes sur l’orthographe ou la grammaire. Si vous êtes incertain sur un mot ou une construction, n’hésitez pas à demander de l’aide à un ami ou à un professionnel. Cela vous permettra de vous assurer de la qualité de votre rédaction.
En vérifiant l’orthographe et la grammaire de votre tutoriel, vous vous assurez de proposer un contenu de qualité et professionnel. N’oubliez pas, en matière de tutoriel informatique, il est essentiel de s’assurer de la qualité de la rédaction afin de garantir une meilleure compréhension de votre contenu.
Publier le tutoriel
Une fois que votre tutoriel est rédigé et vérifié, il est temps de le publier et de le partager avec votre public.
En publiant votre tutoriel de manière adéquate et en le promouvant sur les réseaux sociaux et les plateformes de partage de contenu, vous aurez plus de chances de le faire découvrir à un large public et de susciter l’intérêt de votre public. N’oubliez pas, en matière de tutoriel informatique, il est essentiel de choisir le bon support et de promouvoir votre contenu pour garantir sa diffusion.
Conclusion
En conclusion, rédiger un tutoriel en informatique nécessite de suivre certaines étapes clés pour assurer sa qualité et sa pertinence. En définissant votre public cible, en choisissant un sujet adapté et en recherchant les informations nécessaires, vous vous assurez de proposer un contenu de qualité et utile à votre public. En organisant vos informations de manière logique et en rédigeant votre tutoriel de manière claire et concise, vous facilitez la compréhension de votre public et vous vous assurez de transmettre efficacement votre savoir. Enfin, en vérifiant l’orthographe et la grammaire et en publiant votre tutoriel de manière adéquate, vous avez plus de chances de le faire découvrir à un large public et de susciter l’intérêt de votre public.
Les images utilisées dans ce tutoriel ont été prises du site web pixabay.com, Il n’est pas impossible qu’une (grande) partie de ce tutoriel ait été rédigée par un générateur de blabla, une IA à la mode. Je pense d’ailleurs que certaines citations sont fausses, c’est à vérifier. 😉
En suivant ces conseils, vous serez en mesure de rédiger un tutoriel informatique de qualité qui saura répondre aux besoins de votre public.
Enseignant de mathématiques et de spécialité NSI, Lycée Louis Pasteur d’Avignon.
Aime compter jusqu’à 666 mais s’arrête souvent à 42.
Auteur du livre Découvrir la calculatrice NumWorks.
Comment ça on peut coder des IA qui apprennent en Python en 1ère ? C’est pas censé être un truc ultra pointu ? Eh bien en fait c’est relativement facile à faire pour des jeux aux règles simples comme l’Hexapawn.
Un Hexapawn, quésaco
Il s’agit d’un jeu d’échec miniature, qui se joue sur un plateau de jeu constitué de 9 cases (3×3), et dans lequel chaque joueur possède 3 pions – d’où le nom: hexa, six et pawn, pion en anglais.
Les règles du jeu sont simples: les pions se déplacent comme des pions d’échec:
Ils ne se déplacent que d’une case à la fois et uniquement vers l’avant
Ils ne peuvent manger qu’en diagonale, là aussi dans un rayon d’une case
Le but est de réussir à amener l’un de ses pions de l’autre côté du plateau ou d’éliminer la totalité des pions adverses.
Dans le cas ou aucun pion ne peut plus bouger, il y a égalité
Ce projet a été inspiré par une vidéo de Vsauce2, une chaîne présentant divers jeux ayant lien avec les mathématiques ou la logique.
Particularités du jeu
Comme les règles de l’Hexapawn sont très simples, il suffit simplement d’empêcher l’ordi de refaire des mouvements qui l’ont amené à perdre afin de le faire s’améliorer au fur et a mesure qu’il joue.
La principale difficulté dans la réalisation de ce projet a été de devoir prendre en compte toutes les possibilités de jeu, ce qui rend au final le script assez long.
En bonus, on s’est dit que ce serait sympa d’ajouter un menu afin de personnaliser les couleurs de l’interface
Commencer le projet : les Libraries nécessaires
Ce jeu a été entièrement codé en Python, et en Python, la première chose à faire lorsqu’on commence quelque chose est d’importer les Libraries (programmes externes) nécessaires pour sa réalisation.
#les différentes libraries nécessaires
from tkinter import *
import tkinter as tk
from functools import partial
from random import *
import webbrowser
Les différentes libraries que nous avons choisi d’utiliser sont les suivantes :
tkinter (abrégé de ToolKit Interface) qui permet de créer une interface graphique,
la fonction partial de la library functools, qui va nous être utile lors de la création des différents boutons,
random, qui va permettre d’ajouter de l’aléatoire dans certaines actions,
webbrowser, qui va permettre d’ouvrir des pages web.
Maintenant que l’on a importé tous les modules nécessaires, on va pouvoir commencer à coder le projet en lui-même.
Configuration de la fenêtre
Comme l’on utilise tkinter afin de pouvoir donner une interface graphique à notre jeu, on va commencer par configurer notre fenêtre (taille, titre, couleur de fond etc…)
couleur = "#424242"
#mise en place de la fenêtre
window = Tk()
window.title("♟ Hexapawn ♟")
window.geometry("1080x720")
window.config(bg=couleur)
Ici on a donc une fenêtre de couleur grise, dont le titre est « ♟ Hexapawn ♟ » et dont la taille est de 1080 x 720 pixels
Création des variables
Une fois la fenêtre créée, on configure les variables qui seront utilisées par le script (le nombre de points de chacun, l’état des cases -vides au début-, les différentes variables à afficher…)
Tkinter ne peut pas afficher des variables classiques dans les fenêtres, c’est pourquoi il est nécessaire de créer des variables spéciales que l’on déclare comme ceci :
Comme la majorité de ces variables tkinter sont associées à des variables classiques, nous avons décidé d’ajouter « _display » à la fin de leur nom pour pouvoir plus facilement les différencier.
Par exemple, la variable a1 sera associée à la variable tkinter a1_display qui sera actualisée dans le script à chaque fois que a1 change de valeur
Configuration des boites
Maintenant on crée les différentes boites. Elles permettront d’afficher les différents éléments qu’elles contiennent quand elles seront appelées (la boite menu, règle etc…) ou de ne plus les afficher lorsqu’elles seront oubliées.
Afin d’avoir une interface claire, il est important d’ajouter des éléments textuels: titre, règles du jeu etc.
Dans tkinter, les éléments textuels sont nommés labels. On les déclare comme ceci:
#mise en place des différents éléments textuels
titre = Label(boite_titre, text =
'''
.----------------. .----------------. .----------------. .----------------. .----------------. .----------------. .----------------. .-----------------.
| .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. || .--------------. |
| | ____ ____ | || | _________ | || | ____ ____ | || | __ | || | ______ | || | __ | || | _____ _____ | || | ____ _____ | |
| | |_ || _| | || | |_ ___ | | || | |_ _||_ _| | || | / \ | || | |_ __ \ | || | / \ | || ||_ _||_ _|| || ||_ \|_ _| | |
| | | |__| | | || | | |_ \_| | || | \ \ / / | || | / /\ \ | || | | |__) | | || | / /\ \ | || | | | /\ | | | || | | \ | | | |
| | | __ | | || | | _| _ | || | > `' < | || | / ____ \ | || | | ___/ | || | / ____ \ | || | | |/ \| | | || | | |\ \| | | |
| | _| | | |_ | || | _| |___/ | | || | _/ /'`\ \_ | || | _/ / \ \_ | || | _| |_ | || | _/ / \ \_ | || | | /\ | | || | _| |_\ |_ | |
| | |____||____| | || | |_________| | || | |____||____| | || ||____| |____|| || | |_____| | || ||____| |____|| || | |__/ \__| | || ||_____|\____| | |
| | | || | | || | | || | | || | | || | | || | | || | | |
| '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' || '--------------' |
'----------------' '----------------' '----------------' '----------------' '----------------' '----------------' '----------------' '----------------'
''', font=("consolas",7), bg = couleur, fg = couleur_texte)
sep = Label(boite_titre, text = "."*200, font=("consolas",7), bg = couleur, fg = couleur_texte)
regles_label = Label(boite_regles, text =
'''
Regles du jeu:
Vous possédez 3 pions, qui peuvent se déplacer comme des pions aux échecs:
-ils ne peuvent que se déplacer vers l'avant
-ils ne peuvent se déplacer que d'une case à la fois
-ils ne peuvent "manger" un pion adverse qu'en diagonale
2 conditions de victoire possibles:
-l'adversaire ne possède plus aucun pion
-vous parvenez à amener un pion à l'autre bout du plateau
Pour déplacer un pion, cliquez sur lui puis sur la case vers laquelle vous
voulez qu'il aille.
Lorsque vous avez joué, cliquez sur le bouton sous l'échéquier
'''
, font=("consolas",15), bg = couleur, fg = couleur_texte)
resultat_Label = Label(boite_resultat, text = "", font=("consolas",15), bg = couleur, fg = couleur_texte)
scores = Label(boite_resultat, text = "%s à %s" %(score_joueur_display.get(),score_ordi_display.get()), font=("consolas",15), bg = couleur, fg = couleur_texte)
retour_selection = Label(boite_couleurs, text = "", font=("consolas",10), bg = couleur, fg = couleur_texte)
contour1 = Label(boite_menu, text = contour_texte.get(), font=("consolas",7), bg = couleur, fg = couleur_texte)
contour2 = Label(boite_menu, text = contour_texte.get(), font=("consolas",7), bg = couleur, fg = couleur_texte)
contour3 = Label(boite_menu, text = contour_texte.get(), font=("consolas",7), bg = couleur, fg = couleur_texte)
contour4 = Label(boite_menu, text = contour_texte.get(), font=("consolas",7), bg = couleur, fg = couleur_texte)
contour5 = Label(boite_menu, text = contour_texte.get(), font=("consolas",7), bg = couleur, fg = couleur_texte)
contour6 = Label(boite_menu, text = contour_texte.get(), font=("consolas",7), bg = couleur, fg = couleur_texte)
Pour le titre, nous avons décidé de l’écrire en ASCII à l’aide de ce générateur
Chaque Label possède plusieurs attributs: la boîte dans lequel il va apparaître, le texte qu’il contient, la police et la taille d’écriture, la couleur de fond et enfin la couleur de l’écriture.
Comme vous pouvez le constater, certains de ces Labels font appel à des variables tkinter qui nous avons précédemment définies comme celui-ci par exemple:
scores = Label(boite_resultat, text = "%s à %s" %(score_joueur_display.get(),score_ordi_display.get()), font=("consolas",15), bg = couleur, fg = couleur_texte)
Pour appeler ces variables, il suffit d’écrire leur nom suivi de .get()
Maintenant que l’on a défini les éléments texte, on va pouvoir s’attaquer aux différentes fonctions du script.
Premières fonctions: fonctions de navigation
Comme l’on a décidé d’utiliser une ineterface graphique pour ce projet, la plupart des fonctions seront appelées à l’aide de boutons.
#commande permettant d'afficher les règles du jeu
def command_regles():
boite_menu.pack_forget()
boite_regles.pack(pady = 25)
Cette fonction par exemple permettra d’afficher les règles du jeu. Il suffit d’ajouter .pack() à la fin du nom d’une boite pour la faire apparaître, et .pack_forget() pour la faire disparaître.
Ainsi, lorsque cette fonction sera appelée, les éléments de la boite_menu disparaîtront pour laisser place à ceux de la boite_regles
Cette fonction sera associée à un bouton de la manière suivante :
b_regles = Button(boite_menu, text = "Règles du jeu", font = ("consolas", 15), bg = couleur_texte, fg = couleur, command = command_regles)
On créé un nouvel élément nommé b_regles: un bouton (Button) à qui on donne différents attributs: une boite, un texte, une police et une taille, une couleur de fond, une couleur de texte, et surtout une fonction (l’attribut command) qui sera appelée en cas de clic.
Lorsque l’on cliquera sur ce bouton, la fonction command_regles sera exécutée, ce qui aura pour effet d’afficher les règles du jeu.
On procède de même avec les autres fonctions qui vont nous permettre de naviguer dans notre fenêtre :
#commande pour retourner au menu depuis les règles
def command_retour_regles():
boite_menu.pack(pady = 25)
boite_regles.pack_forget()
#commande pour afficher le menu de personnalisation des couleurs
def command_personnaliser():
boite_menu.pack_forget()
boite_couleurs.pack(pady = 25)
boite_couleurs2.pack()
#commande pour retourner au menu principal depuis celui de personnalisation des couleurs
def command_retour_personnaliser():
boite_menu.pack(pady = 25)
boite_couleurs.pack_forget()
boite_couleurs2.pack_forget()
Ainsi qu’avec leurs boutons respectifs
b_retour_regles = Button(boite_regles, text = "Retour", font = ("consolas", 15), bg = couleur_texte, fg = couleur, command = command_retour_regles)
b_personnaliser = Button(boite_menu, text = "Personnaliser", font = ("consolas", 15), bg = couleur_texte, fg = couleur, command = command_personnaliser)
b_retour_personnaliser = Button(boite_couleurs2, text = "Retour", font = ("consolas", 15), bg = couleur_texte, fg = couleur, command = command_retour_personnaliser)
Personnalisation des couleurs
Grâce au menu de personnalisation des couleurs, les utilisateurs du script pourront choisir les couleurs qui leur plait ainsi créant des mélanges uniques.
Ce menu est constitué de plusieurs boutons :
b_couleur1 = Button(boite_couleurs2, text = "Changer la couleur principale ", font = ("consolas", 15), bg = couleur_texte, fg = couleur, command = partial(changer_couleur,0))
b_couleur2 = Button(boite_couleurs2, text = "Changer la couleur secondaire ", font = ("consolas", 15), bg = couleur_texte, fg = couleur, command = partial(changer_couleur,1))
b_couleur3 = Button(boite_couleurs2, text = "Changer la couleur de selection", font = ("consolas", 15), bg = couleur_texte, fg = couleur, command = partial(changer_couleur,2))
b_couleur_joueur = Button(boite_couleurs2, text = " Changer la couleur du joueur ", font = ("consolas", 15), bg = couleur_texte, fg = couleur, command = partial(changer_couleur,3))
b_couleur_ordi = Button(boite_couleurs2, text = " Changer la couleur de l'ordi ", font = ("consolas", 15), bg = couleur_texte, fg = couleur, command = partial(changer_couleur,4))
b_personnaliser = Button(boite_menu, text = "Personnaliser", font = ("consolas", 15), bg = couleur_texte, fg = couleur, command = command_personnaliser)
couleur_entry = Entry(boite_couleurs, text = "#", textvariable=valeur, font=("Helvetica",15) , bg="white", fg="black")
b_ok = Button(boite_couleurs, text = "Cliquez pour appliquer", font = ("consolas", 15), bg = couleur_texte, fg = couleur, command = rien)
C’est ici que la fonction partial que nous avons importée va nous être utile: en effet, tous les boutons de ce menu vont exécuter la même fonction, mais avec un paramètre différent, ce qui nous permet de n’écrire qu’une seule fonction au lieu de 5 différentes.
Lorsque le bouton « Cliquez pour appliquer » est cliqué la fonction appliquer est exécutée avec un paramètre différent en fonction du bouton sélectionné auparavant.
La fonction change la couleur demandée puis rafraîchit tous les éléments différents afin que le changement de couleur apparaisse.
Il est à noter que le script ne comprend que certains noms de couleur en anglais ou les couleurs données en hexadécimal
Ce menu comporte aussi un bouton permettant d’ouvrir une page web avec un panneau pour sélectionner la couleur de son choix et avoir son code en hexadécimal :
b_trouver_hex = Button(boite_couleurs2, text = " Trouver des couleurs ", font = ("consolas", 15), bg = couleur_texte, fg = couleur, command = pick_hex)
L’ouverture de la page depuis le script est faite grâce a la Library webbrowser
Elle permet de mettre en place le plateau de jeu en faisant apparaître les boites boite_jeu et boite_ordi et en faisant disparaître les autres.
Ensuite les pions sont placés sur le plateau et le compteur de tours, et ceux des pions sont mis à leurs valurs initiales
Enfin, le script teste les cases à partir desquelles l’on peut bouger nos pions à l’aide de la fonction tester_cases_selectionnables().
Les possibilités de déplacement
La fonction « tester_cases_selectionnables() » teste les cases sur lesquels se trouve les pions du joueur et permet au joueur de cliquer le bouton si jamais un de ses pions y est présent.
Ensuite, selon la case sélectionnée le script étudie les mouvements possibles et modifie les commandes éxécutées en cas de clic sur la case en conséquence :
def selected(case):
global a1, a2, a3, b1, b2, b3, c1, c2, c3
global tour
if tour == 0 :
if case == "c1":
b_b1.config(command = partial(jouer_vers,"c1","b1"))
b_b2.config( command = rien)
b_b3.config(command = rien)
b_c1.config(fg=couleur_selection)
b_c2.config(fg=couleur_joueur)
b_c3.config(fg=couleur_joueur)
b_b2.config(command = rien)
b_b3.config(command = rien)
elif case == "c2":
b_b2.config(command = partial(jouer_vers,"c2","b2"))
b_c2.config(fg=couleur_selection)
b_c1.config(fg=couleur_joueur)
b_c3.config(fg=couleur_joueur)
b_b1.config(command = rien)
b_b3.config(command = rien)
#et ainsi de suite avec les autres cases
elif tour >= 2:
if case == "c1":
reset_commandes()
tester_cases_selectionnables()
b_c1.config(fg=couleur_selection)
if b1 == " ":
b_b1.config(command = partial(jouer_vers,"c1","b1"))
if b2 == "♟":
b_b2.config(command = partial(jouer_vers,"c1","b2"))
elif case == "c2":
reset_commandes()
tester_cases_selectionnables()
b_c2.config(fg=couleur_selection)
if b2 == " ":
b_b2.config(command = partial(jouer_vers,"c2","b2"))
if b1 == "♟":
b_b1.config(command = partial(jouer_vers,"c2","b1"))
if b3 == "♟":
b_b3.config(command = partial(jouer_vers,"c2","b3"))
#etc...
Après avoir choisi le pion qu’il souhaitait déplacer, le joueur va cliquer sur la case vers laquelle il veut que le pion se déplace.
La fonction jouer_vers va alors être exécutée avec en paramètres la case de départ et la case d’arrivée du pion.
La fonction va rendre vide la case de départ du pion et va mettre un pion blanc dans la case d’arrivée
def jouer_vers(case1, case2):
global tour, jeu
global a1, a2, a3, b1, b2, b3, c1, c2, c3
global pions_ordi, ordi_gagne
if tour / 2 == tour // 2 and not ordi_gagne:
if case1 == "c1":
c1 = " "
c1_display.set(c1)
b_c1.config(text = c1_display.get())
elif case1 == "c2":
c2 = " "
c2_display.set(c2)
b_c2.config(text = c2_display.get())
#etc...
if case2 == "b1":
if b1 == "♟":
pions_ordi -= 1
b1 = "♙"
b1_display.set(b1)
b_b1.config(text = b1_display.get(), fg = couleur_joueur)
jeu += case2
elif case2 == "b2":
if b2 == "♟":
pions_ordi -= 1
b2 = "♙"
b2_display.set(b2)
b_b2.config(text = b2_display.get(), fg = couleur_joueur)
jeu += case2
#etc...
Si le joueur a réussi à amener l’un de ses pions de l’autre côté, il gagne un point et le résultat de la partie est affiché avec les scores.
Les mouvements possible de l’ordinateur sont étudiés par la fonction « ordi() ».
#début de la fonction ordi()
def ordi():
global tour
global a1, a2, a3, b1, b2, b3, c1, c2, c3
global pions_joueur, points_joueur, ordi_gagne, points_ordi, pions_ordi, joueur_gagne, pions_bloques, resultat, egalite, coups_gagnants, coups_perdants, jeu, couleur_ordi
Elle étudie tout d’abord si il y a un vainqueur ou une égalité ( grâce à la fonction « tester_tie() » expliquée un peu plus plus loin ) .
if pions_ordi == 0:
joueur_gagne = True
if pions_joueur == 0:
ordi_gagne = True
tester_tie()
if pions_bloques == pions_ordi:
egalite = Tr
Si il n’y a pas de vainqueur ou d’égalité et que c’est au tour de l’ordi de jouer, le script analyse les mouvements possibles de l’ordinateur. si il s’aperçoit qu’un mouvement l’a amené à perdre dans une configuration similaire, il ne l’inclura pas dans la liste des mouvements possibles.
Si, au contraire un des mouvements l’a fait gagner précédemment, il le mettra dans une liste spéciale
elif tour/2 != tour//2 and not joueur_gagne and not ordi_gagne :
mvt_possibles = []
mvt_gagnants = []
if a1 == "♟":
if b1 == " " and jeu + "a1b1" not in coups_perdants :
mvt_possibles.append("a1b1")
if jeu + "a1b1" in coups_gagnants:
mvt_gagnants.append("a1b1")
if b2 == "♙" and jeu + "a1b2" not in coups_perdants:
mvt_possibles.append("a1b2")
if jeu + "a1b2" in coups_gagnants:
mvt_gagnants.append("a1b2")
if a2 == "♟":
if b1 == "♙" and jeu + "a2b1" not in coups_perdants :
mvt_possibles.append("a2b1")
if jeu + "a2b1" in coups_gagnants:
mvt_gagnants.append("a2b1")
if b2 == " " and jeu + "a2b2" not in coups_perdants:
mvt_possibles.append("a2b2")
if jeu + "a2b2" in coups_gagnants:
mvt_gagnants.append("a2b2")
if b3 == "♙" and jeu + "a2b3" not in coups_perdants:
mvt_possibles.append("a2b3")
if jeu + "a2b3" in coups_gagnants:
mvt_gagnants.append("a2b3")
#et ainsi de suite avec toutes les cases...
Ensuite, la fonction teste si des mouvements possibles peuvent amener l’ordi à gagner à coup sûr. Si c’est le cas, un mouvement aléatoire est pioché parmi la liste mvt_gagnants.
Sinon, l’ordi choisit un mouvement aléatoire parmi les mouvements possibles.
Le coup joué est ensuite ajouté à la variable jeu.
Si le mouvement amène l’ordi à prendre un pion, le nombre de pions du joueur est décrémenté de 1
Si l’ordi a amené l’un de ses pions de l’autre côté, la variable ordi_gagne devient « vraie » (True)
jeu += mvt_ordi
Si l’ordi a gagné, c’est à dire si ordi_gagne est True, son score est incrémenté, la variable « jeu » est ajouté à la liste des coups gagnants et le score ainsi que le résultat de la partie sont affichés
Si le joueur avait déjà gagné au début du tour (l’ordi n’a donc pas joué) ou s’il y a égalité le score est incrémenté en conséquence et l’issue de la partie est affichée
Si aucune de ces conditions n’est vérifiées, c’est au tour du joueur de jouer.
Plisieurs conditions peuvent mettre fin à la partie
Le joueur ou l’ordi amène l’un de ses pions de l’autre côté du plateau
le joueur ou l’ordi ne possèdent plus de pions
Tous les pions sont bloqués
Les deux premières conditions sont facilement vérifiables et sont déjà testées directement dans les fonctions ordi() et jouer_vers()
On teste donc s’il y a égalité à l’aide de la fonction tester_tie(), appelée à l’interieur de la fonction ordi() comme vu précédemment.
Cette fonction teste tout simplement pour chaque case si le pion présent n’a plus de possibilités de mouvement, et ajoute au compteur de pions bloqués 1 si jamais le pion ne peut plus bouger.
def tester_tie():
global a1, a2, a3, b1, b2, b3, c1, c2, c3, pions_bloques
pions_bloques = 0
if a1 == "♟":
if b1 == "♙":
if b2 == "♟" or b2 == " ":
pions_bloques += 1
else:
pass
else:
pass
if a2 == "♟":
if b2 == "♙":
if b1 == "♟" or b1 == " ":
if b3 == "♟" or b3 == " ":
pions_bloques += 1
else:
pass
else:
pass
else:
pass
if a3 == "♟":
if b3 == "♙":
if b2 == "♟" or b2 == " ":
pions_bloques += 1
else:
pass
else:
pass
if b1 == "♟":
if c1 == "♙":
if c2 == "♟" or c2 == " ":
pions_bloques += 1
else:
pass
else:
pass
if b2 == "♟":
if c2 == "♙":
if c1 == "♟" or c1 == " ":
if c3 == "♟" or c3 == " ":
pions_bloques += 1
else:
pass
else:
pass
else:
pass
if b3 == "♟":
if c3 == "♙":
if c2 == "♟" or c2 == " ":
pions_bloques += 1
else:
pass
else:
pass
Si jamais tous les pions de l’ordi sont bloqués il y a égalité
if pions_bloques == pions_ordi:
egalite = True
if egalite:
reset_commandes()
boite_ordi.pack_forget()
resultat = "Egalité"
resultat_display.set(resultat)
resultat_Label.config(text = resultat_display.get())
boite_resultat.pack()
L’affichage
Maintenant que toutes les fonction sont définies, il faut afficher tous les différents éléments de la fenêtre:
Et surtout ne pas oublier d’ouvrir la fenêtre en cas d’exéction du script
window.mainloop()
Captures d’écran
Le menu principal
Le menu de personnalisation des couleurs
De nouvelles couleurs…
Une partie d’Hexapawn
La machine dépasserait-elle l’humain ?
Si vous souhaitez vous mesurer à cette IA et vérifier qu’elle apprend bel et bien de ses erreurs, vous pourrez télécharger le script du projet (défi : dépasser un score de 17!).
Tutoriels
