Résultats de recherche pour : latex python

Un chatbot en Python

La logique d’un chatbot en Python n’est pas très compliquée à comprendre. Nous allons voir dans cet article l’essentiel de cette logique.

Fractions continues en Python

Les fractions continues constituent une notion plutôt intéressant en mathématiques. C’est une façon d’écrire les nombres. Dans cet article, je vais expliquer dans les grandes lignes la notion mathématique et dans un second temps, nous allons implémenter en Python une classe permettant de représenter une fraction continue et d’en obtenir sa valeur fractionnaire.

Classe Carré magique en Python

Créer un carré magique en Python n’est pas nécessairement facile. Nous allons voir sur cette page comment créer un objet représentant un carré magique : à l’aide d’une classe.

Façade de la Passion de la Sagrada Familia, basilique de Barcelone

Cahier des charges du carré magique en Python

Faisons dans un premier temps une liste de tout ce que l’on souhaite:

  • créer un objet MagicSquare admettant en argument une liste dont la dimension sera notée n², n étant un entier naturel supérieur ou égal à 3;
  • afficher le carré magique sous forme de tableau;
  • vérifier si un carré est magique.

Le constructeur

Une classe est quelque chose qui commence très souvent par un constructeur : c’est ce qui définit les composantes de l’objet (pour faire simple).

Nous allons donc commencer par écrire;

class MagicSquare :
    def __init__(self, L) :
        self.dim = int( len(L)**0.5 )
        self.matrix = [ [ L[i+j*3] for i in range(self.dim) ] for j in range(self.dim) ]

Le constructeur définit ainsi avant tout une variable dim rattachée à l’objet (avec le “préfixe” self.), qui va représenter la dimension d’une matrice carrée définie à partir des éléments de la liste passée en argument lors de l’appel à la classe. Ainsi, quand on écrit:

>>> square = MagicSquare ( [ 1,2,3,4,5,6,7,8,9 ] )

on construit la matrice:$$\begin{pmatrix}1&2&3\\4&5&6\\7&8&9\end{pmatrix}$$ de dimension 3.

Affichage

Il nous faut maintenant pouvoir afficher le carré ainsi défini (la matrice). On écrit alors une fonction d’affichage dans la classe, que l’on appelle une méthode: comme son rôle est d’afficher l’objet, cette méthode doit être assimilée à une chaîne de caractères (mais pour l’objet défini); on va donc définir la méthode sous le nom “__str__”.

def __str__(self) :
        out = ''
        p = 1
        w = int( log( self.dim , 10) ) + 1 # nombre de chiffres dans self.dim pour le formattage de l'affichage
        formatage = '%' + str(w+3) + 'd'
        for row in self.matrix:
            for coef in row:
                out += str( formattage % ( coef ) )
                if p % self.dim == 0:
                    out += '\n'
                p += 1
        return out

Là, je me suis un peu lâché car je voulais un “bel” affichage (dans la mesure du possible). J’ai donc formaté chaque coefficient en leur attribuant une dimension horizontale dépendante des coefficients. Avec cette méthode, en écrivant:

>>> square = MagicSquare ( [ 12,11,10,9,6,3,5,2,5 ] )
>>> print(square)

s’affiche:

12 11 10
 9  6  3
 5  2  5

Vérifier si le carré est magique en Python

Un carré est dit magique si la somme de chaque ligne, de chaque colonne et des deux diagonales est égale au même nombre. On arrive à démontrer (en mathématiques) que ce nombre est nécessairement égal à \(\frac{n(n^2+1)}{2}\). On peut alors imaginer une méthode isMagic qui renvoie “False” si le carré n’est pas magique, et “True” s’il l’est:

def isMagic(self):
   # on vérifie d'abord si tous les nombres sont uniques
   liste_nombres = []
   for row in self.matrix:
      for coef in row:
         if coef not in liste_nombres:
            liste_nombres.append( coef )
         else:
            return False
   somme_theorique = self.dim * (self.dim**2 + 1) // 2
        
   # somme de chaque ligne
   for row in self.matrix:
      somme = 0
      for coef in row:
         somme += coef
      if somme != somme_theorique:
         return False
        
   # somme de chaque colonne
   for column in range(self.dim):
      somme = 0
      for row in range(self.dim):
         somme += self.matrix[row][column]
      if somme != somme_theorique:
         return False
            
   # somme des diagonales
   somme1 , somme2 = 0 , 0
   for i in range(self.dim):
      somme1 += self.matrix[i][i]
      somme2 += self.matrix[i][self.dim-1-i]
   if somme1 != somme_theorique or somme2 != somme_theorique:
      return False
        
   return True

Cette méthode n’est pas du tout optimale (car elle contient bien trop de boucles), mais cela fera l’affaire pour nous (mon but est d’être pédagogue et non de proposer tout de suite une méthode optimale). D’ailleurs, vous pouvez imaginer votre propre méthode en utilisant une autre philosophie que celle adoptée ici. Par exemple, vous pouvez jeter un coup d’œil sur cette page pour vous donner une autre idée (il y a des solutions bien plus efficaces, mais plus compliquées à comprendre).

Construire tous les carrés magiques d’une dimension donnée en Python

Nous allons nous servir de cette classe afin de construire tous les carrés magiques d’ordre 3.

def all_squares():
    for a1 in range(1,10):
        for a2 in range(1,10):
            for a3 in range(1,10):
                for b1 in range(1,10):
                    somme = a1 + a2 + a3
                    c1 = somme - a1 - b1
                    b2 = somme - a3 - c1
                    b3 = somme - b1 - b2
                    c2 = somme - a2 - b2
                    c3 = somme - c1 - c2
                    M = MagicSquare( [a1,a2,a3,b1,b2,b3,c1,c2,c3] )
                    if M.isMagic() and 0 < b2 < 10 and 0 < b3 < 10 and 0 < c1 < 10 and 0 < c2 < 10 and 0 < c3 < 10 :
                        print(M)
                        print("---------------")
                        
all_squares()

Cette solution, proposée par un élève du professeur qui a écrit cette page, fonctionne très bien. Elle affiche :

2 7 6
9 5 1
4 3 8
------------
2 9 4
7 5 3
6 1 8
------------
4 3 8
9 5 1
2 7 6
------------
4 9 2
3 5 7
8 1 6
------------
6 1 8
7 5 3
2 9 4
------------
6 7 2
1 5 9
8 3 4
------------
8 1 6
3 5 7
4 9 2
------------
8 3 4
1 5 9
6 7 2

Les abonné.e.s de mathweb.fr pourront trouver le programme Python complet sur cette page.

[Retour à la page principale]

Python, tkinter et calculatrice

Je viens de faire une calculatrice basique à l’aide de Python et de tkinter.

Extraire une image ou une vidéo Instagram ou Twitter avec Python

Les images que l’on peut voir dans le fil d’actu d’Instagram ou Twitter sont formatées de sorte à s’afficher selon un certain format. Mais les images d’origine sont tout de même stockées quelque part et des fois, il est plus agréable de les voir en vraie grandeur. Nous allons voir comment extraire une image ou une vidéo d’Instagram ou de Twitter avec Python.

Les images et Python

Dans cet article, j’ai envie de vous parler d’images, et plus particulièrement de manipulation d’images avec Python.

Quel environnement utiliser pour coder en Python?

Vouloir coder en Python, c’est bien joli mais il faut aussi trouver un environnement adapté pour prendre plaisir à le faire. Il faut donc trouver l’IDE (Integrated Development Environment) qui colle bien à ce qie l’on veut, et comme personne ne se ressemble, l’IDE qui convient à Paul ne conviendra pas à Émilie. Je vais donc tenter de vous exposer quelques IDE afin que vous fassiez le tri.

IDE natif : IDLE

En installant Python, un IDE (appelé IDLE) est automatiquement installé. Il est léger et fait le boulot, mais il n’est pas convivial. La fenêtre qui s’ouvre est une fenêtre console: on peut y écrire directement du code Python:

IDE natif de Python

On peut ouvrir un fichier dans une autre fenêtre (avec la combinaison [Ctrl] + [O]) et en appuyant sur [F5], on peut lancer le script, qui s’exécute alors dans la fenêtre console. L’inconvénient qui pourrait être perçu comme majeur est donc le fait que deux fenêtres sont nécessaires, ce qui peut paraître peu pratique.

IDE Visual Studio Code (VSC)

Cet IDE est une parade à l’inconvénient cité précédemment: on peut y exécuter du code et voir le résultat dans une même fenêtre (coupée en plusieurs cadres). Il faudra tout de même télécharger un plugin qui lui permettra d’interpréter du code Python, mais cela se fait assez simplement. Il suffit de taper du code et de sauvegarder le fichier en .py, et l’IDE propose automatiquement de télécharger ce qu’il faut. Sinon, il y a à gauche de l’écran une icône “extension” qui, lorsque l’on clique dessus, nous permet de chercher des plugins en relation avec Python:

IDE Visual Studio Code

À mes yeux, cet IDE est un peu plus pratique de l’IDLE, mais il y a un inconvénient: le script ne se lance pas en appuyant sur une touche (comme [F5]). En effet, il faut cliquer avec le bouton droit de la souris sur le script que l’on souhaite lancer, puis sélectionner “Run Python file in terminal” (le terminal étant le cadre du bas). Autre inconvénient, il n’y a pas de cadre “console”, ce qui est peu pratique quelques fois…

IDE Python Pyzo

Cet IDE est léger, donc rapide à se lancer (comme VSC), mais son interface par défaut est légèrement moins belle…

Interface Pyzo

On voit que la fenêtre est découpée par défaut en 4 : à gauche, un cadre pour le script, à gauche et en haut, un cadre console et à gauche en bas, des cadres informatifs. C’est sans doute l’un des meilleurs IDE Python pour un usage d’enseignement. Cependant, j’ai constaté des bugs dès lors que les scripts étaient plus poussés. Certains fonctionnant très bien avec l’IDLE ne fonctionnent pas avec Pyzo… Quel dommage !

IDE Python Spyder

Cet IDE est extrêmement lourd (il met très longtemps à se charger) et n’est pratiquement disponible que si l’on installe Anaconda (un environnement très lourd lui aussi). Si tout ça est lourd, c’est que c’est assez complet et je dois bien avouer que c’est un très bon IDE Python. Cependant, j’ai cessé de l’utiliser car il est vraiment très long à se charger et le fait de devoir obligatoirement passer par Anaconda ne me plaît pas non plus (je n’aime pas que l’on m’impose quoi que ce soit !).

IDE Python Thonny

Cet IDE est, à l’instar de Pyzo, très léger. Je ne l’ai pas encore testé sur du long terme, mais une fois installé, je l’ai testé sur un script qui pourrait posé problème et il a bien fonctionné (mieux que VSC). Il faut juste penser à changer l’interpréteur (par défaut, Thonny semble installer Python 3.7 alors que j’étais sous Python 3.8).

Interface Thonny

Et cerise sur le gâteau, il est facile de paramétrer l’éditeur pour un visuel à notre convenance… Pour moi, ce sera:

Interface Thonny customisée

Quelques articles qui traitent de Python

Mesure principale d’un angle avec Python

Dans les programmes de 1ère Spécialité Math, il est question de trigonométrie… Et c’est la période de l’année où les professeur.e.s peuvent aborder cette notion avec leurs élèves. J’ai donc voulu écrire un programme Python permettant de trouver la mesure principale d’un angle s’écrivant sous la forme \(\displaystyle\frac{a\pi}{b}\), c’est-à-dire la mesure comprise dans l’intervalle \(]-\pi;\pi]\) équivalente à celle donnée modulo \(2\pi\).

Une enveloppe astroïdale obtenue en Python avec Turtle

L’enveloppe de cette famille de cercles est une astroïde

L’objectif de cet article est de construire cette suite de cercles rouges à l’aide de Python et de son module Turtle.

Approche mathématique

Avant toute chose, il est nécessaire de comprendre comment sont obtenus tous les cercles rouges.

Si on regarde et analyse bien la figure, les tracés suggèrent que pour un angle \(\alpha\) donné, exprimé en degré, on trace un segment d’origine O (si on se place dans un repère, c’est l’origine) et d’angle \(\alpha\), qui coupe l’un des côté du carré inscrit dans le cercle principal.

Prenons le côté en haut à droite (donc dans le cadran x > 0 et y > 0 si on se ramène à un repère). Il a pour équation \(y=-x+R\) si on considère que le cercle principal a pour rayon \(R\). Notons I le point d’intersection de la droite d’équation \(y = x\tan(\alpha)\), qui forme un angle de \(\alpha\) avec l’horizontale, avec le segment d’équation \(y=-x+R\). Alors, ses coordonnées vérifient:$$\begin{cases}y_I=-x_I+R\\y_I=x_I\tan(\alpha)\end{cases} $$Donc:$$x_I\tan(\alpha)=-x_I+R$$d’où:$$x_I=\frac{R}{\tan(\alpha)+R}.$$

Une fois les coordonnées de I connues, on calcule la longueur IM, où M est le point du cercle principal de coordonnées \(R\cos\alpha;R\sin\alpha)\), à l’aide de la formule vue en classe de Seconde:$$IM = \sqrt{(x_I-x_M)^2 + (y_I-y_M)^2}.$$On peut alors tracer le cercle de centre I et de rayon IM : c’est un des cercles rouges.

Avec Turtle

Il faut faire appel à quelques méthodes du module Turtle; inutile donc d’écrire:

from turtle import *

En effet, le mieux est de n’importer que les méthodes qui nous intéressent. Il en est de même pour le module math, où seules les méthodes sin, cos, tan et pi sont nécessaires (pour la racine carrée, on élève à la puissance 0.5).

On commence donc par tracer un cercle (avec Turtle, c’est un peu… comment dire poliment ? … je trouve pas ! Désolé !) en se déplaçant d’abord en bas de la fenêtre puis en traçant le cercle. Ensuite, on en profite pour tracer le carré inscrit dans le cercle (avec “goto”, comme le stylo est déjà baissé, ça trace les segments).

Maintenant, on fait une boucle itérative sur l’angle variant de 0 à 359. Si vous observez bien, je ne me suis pas embêté avec les cas où l’angle est égal à 90°, 180° et 270° car ça n’a que peu d’importance au final du point de vue visuel). En fait 180° ne pose pas de problème pour la tangente, mais peu importe… Ouais, je suis une grosse feignasse !…

Remarquez aussi que j’ai pris \(R=300\) car la fenêtre par défaut fait 800×800. “300” me semblait un bon compromis. Voilà donc le programme:

Alors là, les plus observateurs.trices. d’entre vous me diront : “t’es qu’un charlatant ! Le GIF n’est pas exactement ce que fait ce programme…” et c’est vrai ! C’est en fait un ancien GIF qui traînait sur mon disque dur… quand je vous disais que j’étais une grosse feignasse !

En attendant, si vous souhaitez télécharger le programme directement plutôt que de vous embêter à le réécrire à la main, c’est sur cette page.

Ajuster en largeur un listing sous \(\LaTeX\)

Cet article est inspiré du post du forum mathematex dont l’adresse est : http://forum.mathematex.net/latex-f6/cadre-pour-algorithme-python-avec-listings-t17255.html

L’idée est ici de créer un environnement “python” (par exemple) qui permet d’écrire un code Python et de le présenter encadré de sorte que le cadre soit ajusté en largeur (ce qui n’est pas le cas par défaut car le cadre tient sur toute la largeur).

Supportscreen tag