# data[].attributes.attachment_link.readable_text
Le module PIL permet de manipuler un grand nombre de formats d'image. Ce module n'est pas inclus d'office dans Python, il faut télécharger puis installer la bibliothèque pillow comme indiqué en page d'accueil.

Pour plus d'informations sur les possibilités de ce module, on pourra consulter le site de référence.

Cette page présente comment concevoir une nouvelle image avec PIL en construisant ligne par ligne un programme. On commence par importer le module en en-tête du fichier :

Le module PIL permet de créer très facilement l'image représentée ci-contre qui est un rectangle de 100 pixels de largeur et 256 pixels de hauteur, de couleur dégradée du noir ( en haut) vers le rouge.

Pour créer une nouvelle image, il faut indiquer :

le nom de la variable qui " contiendra " cette image ;

l'encodage des couleurs de cette image

'RGBA' : couleurs avec gestion de la transparence (4 octets)

'RGB' : couleurs sans gestion de la transparence

'L' : nuances de gris

'1' : noir & blanc

les dimensions en pixels (largeur et hauteur) de cette image (sous forme de tuple - liste non modifiable).

Dans notre exemple, on stockera l'image dans la variable im, avec un encodage couleur en'RGB' et des dimensions 100 x 256 :

 im2 = Image.new('RGB', (100, 256))

Application

Copiez/collez le programme Python ci-dessous puis exécutez-le.

 ##----- Importation des modules -----## from PIL import Image ##----- Variables et constantes -----## largeur = 100 hauteur = 256 couleur = 'RGB' ##------ Nouvelle image ------## im = Image.new(couleur, (largeur, hauteur)) ##----- Fermeture et affichage -----## im.save('Degrade.jpg') im.show()

Vérifiez qu'une image de dimensions 100 x 256 a bien été définie. Quelle remarque peut-on faire ?

Contrairement à la lecture et à l'écriture dans un fichier texte, le module PIL permet "d'atteindre" et de modifier directement n'importe quel pixel de l'image grâce à ses coordonnées.

Les coordonnées d'un pixel de l'image sont sous la forme d'un tuple (x, y).

Selon l'encodage des couleurs du fichier, il faudra saisir une valeur entière différente pour le pixel correspondant :

'RGBA' : un quadruplet (r, g,b, a) de valeurs comprises entre 0 et255

'RGB' : un triplet (r, g,b) de valeurs comprises entre 0 et 255

'L' : une valeur g comprise entre0 et 255

'1' : une valeur nb comprise entre0 et 1

Illustration

L'illustration ci-contre présente comment PIL " agit " sur une image pour colorier le pixel de coordonnées(3, 1) en rouge :

 # On injecte dans le pixel de coordonnées (3, 1) la couleur rouge (255, 0, 0) en RGB im.putpixel((3, 1), (255, 0, 0))

Application

Compléter le programme précédent afin d'obtenir l'image d'un rectangle de 100 pixels de largeur et 256 pixels de hauteur, de couleur dégradée du noir ( en haut) vers le rouge.

 ##----- Importation des modules -----## from PIL import Image ##----- Variables et constantes -----## largeur = 100 hauteur = 256 couleur = 'RGB' ##------ Nouvelle image ------## im = Image.new(couleur, (largeur, hauteur)) ##----- Fermeture et affichage -----## im.save('Degrade.jpg') im.show()

# data[].attributes.attachment_link.keywords[]
académie de lyon - formation isn : python

# data[].attributes.attachment_link.authors[].name
Groupe IREM-ISN - Pascal BUSAC - Nicolas BUYLE-BODIN - Ludovic FASQUELLE - Cédric FRAYSSINET - Jean-Manuel MENY - Brice PORTIER - Olivier TOURAILLE

# data[].attributes.attachment_link.description
Le module PIL permet de manipuler un grand nombre de formats d'image. Ce module n'est pas inclus d'office dans Python, il faut télécharger puis installer la bibliothèque pillow comme indiqué en page d'accueil. Pour plus d'informations sur les possibilités de ce module, on pourra consulter le site de référence.

# data[].attributes.attachment_link.keywords[]
académie de lyon - formation isn : python

# data[].attributes.attachment_link.authors[].name
Groupe IREM-ISN - Pascal BUSAC - Nicolas BUYLE-BODIN - Ludovic FASQUELLE - Cédric FRAYSSINET - Jean-Manuel MENY - Brice PORTIER - Olivier TOURAILLE

# data[].attributes.attachment_link.description
Cette page présente comment réaliser des opérations sur les images avec PIL en construisant ligne par ligne un programme. On commence toujours par importer le module en en-tête du fichier :

# data[].attributes.attachment_link.readable_text
soit des chaînes de caractères (extension du fichier, encodage des couleurs, ...) ;

soit des tuples de nombres, que l'on peut interpréter grossièrement comme des listes de nombres non modifiables (dimensions de l'image, intensité des composantes RVB).

1. Cliquer sur l'image ci-contre pour télécharger le logo ISN-IREM au format .jpg.

2. Concevoir un unique programme permettant d'afficher trois images distinctes, chacune représentant les composantes rouge, vert et bleu de l'image d'origine :

Composante rouge

Composante verte

Composante bleue

Une piste

Une solution classique

Une solution plus originale

Les dimensions des images sont celles de l'image d'origine, l'encodage couleur des images est celui de l'image d'origine...

On parcourt chaque pixel de l'image d'origine et on enregistre les composantes r, v, b de ce pixel. La l ère image créée ne reçoit que la composante rouge. Quelle valeur peut-on alors donner aux composantes vertes et bleues ?

 ##----- Importation des Modules -----## from PIL import Image # Ne pas oublier de l'importer pour un programme indépendant ##----- Informations sur l'image d'origine -----## im = Image.open('Logo_ISN-IREM.jpg') couleur = im.mode l, h = im.size ##----- Conception de la nouvelle image -----## im_rouge = Image.new(couleur, (l, h)) # Composante rouge im_verte = Image.new(couleur, (l, h)) # Composante verte im_bleue = Image.new(couleur, (l, h)) # Composante bleue for x in range(l): for y in range(h): # On parcourt chaque pixel de l'image analysée plus haut r, v, b = im.getpixel((x, y)) # On récupère le triplet de couleur im_rouge.putpixel((x, y), (r, 0, 0)) # Il faut un tuple pour les intensités de couleur im_verte.putpixel((x, y), (0, v, 0)) im_bleue.putpixel((x, y), (0, 0, b)) im_rouge.save('Logo_ISN-IREM_Rouge.jpg') im_verte.save('Logo_ISN-IREM_Vert.jpg') im_bleue.save('Logo_ISN-IREM_Bleu.jpg') im_rouge.show() im_verte.show() im_bleue.show()

 ##----- Importation des Modules -----## from PIL import Image # Ne pas oublier de l'importer pour un programme indépendant ##----- Informations sur l'image d'origine -----## im = Image.open('Logo_ISN-IREM.jpg') couleur = im.mode l, h = im.size ##----- Conception de la nouvelle image -----## liste=[0, 0, 0] # Future liste des images_composantes for i in range(3): liste[i] = Image.new(couleur, (l, h)) # Chaque élément de la liste est une image en devenir for x in range(l): for y in range(h): triplet = im.getpixel((x, y)) # Composantes sous forme de liste for i in range(3): a=[0, 0] # On insère la composante R, V ou B dans la liste selon la valeur de i a.insert(i, triplet[i]) liste[i].putpixel((x, y), tuple(a)) # Il faut un tuple pour les intensités de couleur for i in range(3): liste[i].save('Logo_ISN-IREM_{0}.jpg'.format(i)) liste[i].show()

1. utiliser la moyenne des trois composantes RVB : \(G = \frac {R+V+B} {3}\).

2. utiliser la formule recommandée (recommandation 601) par la C.I.E (Commission Internationale de l'Éclairage) pour les couleurs non-linéaires (image vue à partir d'un écran vidéo) : \(G = 0,299 R + 0,587 V + 0,114 B\).

Il y a deux possibilités pour l'image à concevoir :

Ou bien on la définit avec le mode couleur 'RGB' et les trois composantes du triplet doivent prendre la même valeur ;

Ou bien on la définit avec le mode couleur 'L' et il suffit de donner une unique valeur pour la nuance de gris.

 ##----- Importation des Modules -----## from PIL import Image # Ne pas oublier de l'importer pour un programme indépendant ##----- Informations sur l'image d'origine -----## im = Image.open('Logo_ISN-IREM.jpg') l, h = im.size ##----- Conception de la nouvelle image -----## im_gris = Image.new('L', (l, h)) for x in range(l): for y in range(h): # On parcourt chaque pixel de l'image ouverte plus haut r, v, b = im.getpixel((x, y)) # On récupère le triplet de couleur # g=(r+v+b)//3 # Quotient pour obtenir une valeur entière... g = int(0.299*r + 0.587*v + 0.114*b) im_gris.putpixel((x, y), g) im_gris.save('Logo_ISN-IREM_Gris.jpg') im_gris.show()

1. Commencer par colorier en noir toute la zone extérieure au petit cercle et en blanc la zone intérieure.

2. Compléter le programme en coloriant en blanc la zone extérieure au grand cercle.

3. Finir par tracer les deux zones bleues à l'intérieur du petit cercle.

Les pixels situés à l'extérieur d'un cercle de centre A de coordonnées (a,b) et de rayon r sont des points M de coordonnées (x,y) telles que la distance de A à M est supérieure à r, ce qui s'écrit (x-a)**2+(y-b)**2>r**2

 ##----- Importation des Modules -----## from PIL import Image # Ne pas oublier de l'importer pour un programme indépendant ##----- Informations sur l'image d'origine -----## couleur = 'RGB' l, h = 400, 400 ##----- Conception de la nouvelle image -----## wbm = Image.new(couleur, (l, h)) # création nouvelle image vierge for x in range(l): for y in range(h): # On parcourt chaque pixel if (x-200)**2+(y-200)**2>16900: # si on est au-delà du petit cercle if (x-200)**2+(y-200)**2<32400: # mais à l'interieur du grand wbm.putpixel((x,y),(0,0,0)) # on colorie en noir else: # sinon wbm.putpixel((x,y),(255,255,255))	# on colorie en blanc else: # si on est à l'intérieur du petit cercle if x>200 and y>200 or x<200 and y<200:	# et si on est dans le quart inférieur droit ou supérieur gauche wbm.putpixel((x,y),(0,0,255)) # on colorie en bleu else: # sinon wbm.putpixel((x,y),(255,255,255))	# on colorie en blanc wbm.save('sigle.jpg') # on sauvegarde wbm.show() # on affiche l'image créée

1. L'image ci-contre représente le logo ISN-IREM après une symétrie horizontale. Un pixel du logo d'origine a pour coordonnées(x, y). Quelles sont les coordonnées du pixel correspondant dans l'image à obtenir ?

2. En déduire le programme permettant d'obtenir cette image.

3. Améliorer ce programme pour que, selon la valeur d'un unique paramètre, la symétrie soit verticale ou horizontale.

Une illustration

Une solution

Une amélioration

 ##----- Importation des Modules -----## from PIL import Image # Ne pas oublier de l'importer pour un programme indépendant ##----- Informations sur l'image d'origine -----## im = Image.open('Logo_ISN-IREM.jpg') couleur = im.mode l, h = im.size ##----- Conception de la nouvelle image -----## im_hori = Image.new(couleur, (l, h)) # Symetrie horizontale for x in range(l): for y in range(h): # On parcourt chaque pixel de l'image analysée plus haut triplet = im.getpixel((x, y)) # On récupère le triplet de couleur im_hori.putpixel((x, h-1-y), triplet) # La ligne du bas a pour ordonnée h-1... im_hori.save('Logo_ISN-IREM_sym_hori.jpg') im_hori.show()

 ##----- Importation des Modules -----## from PIL import Image # Ne pas oublier de l'importer pour un programme indépendant ##----- Informations sur l'image d'origine -----## im = Image.open('Logo_ISN-IREM.jpg') couleur = im.mode l, h = im.size ##----- Conception de la nouvelle image -----## param = 1 # Lorsque param prend la valeur 0, la symétrie sera horizontale # Lorsque param prend la valeur 1, la symétrie sera verticale im_sym = Image.new(couleur, (l, h)) for x in range(l): for y in range(h): # On parcourt chaque pixel de l'image ouverte plus haut triplet = im.getpixel((x, y)) # On récupère le triplet de couleur # avec param = 1, on a (1-param) = 0 et vice-versa... im_sym.putpixel(((l-1)*param + x*(-1)**param, (h-1)*(1-param) + y*(-1)**(1-param)), triplet) im_sym.save('Logo_ISN-IREM_sym.jpg') im_sym.show()

1. Récupérer les informations d'une image existante ;

2. Créer une nouvelle image avec le même encodage couleur, de largeur et hauteur échangées ;

3. Faire en sorte que l'image obtenue soit l'image d'origine soumise à une rotation de 90° dans le sens direct ;

4. Afficher l'image ainsi "tournée".

Une illustration

Une solution

L'image n'est pas modifiée, elle est simplement tournée. Ce ne sont donc pas les composantes couleur qu'il faut modifier mais plutôt les coordonnées de chaque pixel. Pour trouver les opérations méthématiques à effectuer, le plus simple est de faire un schéma de l'image dans lequel on place un pixel de coordonnées (x, y) avant la rotation, puis le même pixel après la rotation. En déterminant ses nouvelles coordonnées à partir du pixel haut-gauche de l'image tournée, on peut en déduire les calculs à effectuer sur les coordonnées(x, y) d'origine.

On en déduit l'illustration ci-dessous. Les figures de couleurs représentent les pixels des 4 coins de l'image, avec leurs coordonnées avant pui après la rotation. Le pixel quelconque de coordonnées (x, y) est représenté par la carré rouge "évidé".

 ##----- Importation des Modules -----## from PIL import Image # Ne pas oublier de l'importer pour un programme indépendant ##----- Informations sur l'image d'origine -----## im = Image.open('Logo_ISN-IREM.jpg') couleur = im.mode l, h = im.size ##----- Conception de la nouvelle image -----## im2 = Image.new(couleur, (h, l)) # Création d'une image encodée en RGB, de largeur h et de hauteur l for x in range(l): for y in range(h): # On parcourt chaque pixel de l'image analysée plus haut triplet = im.getpixel((x, y)) # On récupère son "code couleur" im2.putpixel((y, l-1-x), triplet) # Attention à la numérotation des pixels, de 0 à l-1 en abscisses... im2.save('Logo_ISN-IREM_tourne.jpg') im2.show()

# data[].attributes.attachment_link.keywords[]
académie de lyon - formation isn : python

# data[].attributes.attachment_link.authors[].name
Groupe IREM-ISN - Pascal BUSAC - Nicolas BUYLE-BODIN - Ludovic FASQUELLE - Cédric FRAYSSINET - Jean-Manuel MENY - Brice PORTIER - Olivier TOURAILLE

# data[].attributes.attachment_link.description
soit des chaînes de caractères (extension du fichier, encodage des couleurs, ...) ; soit des tuples de nombres, que l'on peut interpréter grossièrement comme des listes de nombres non modifiables (dimensions de l'image, intensité des composantes RVB). Cliquer sur l'image ci-contre pour télécharger le logo ISN-IREM au format .jpg.

# data[].attributes.attachment_link.readable_text
Le module graphique turtle permet de piloter un "crayon" afin de tracer dynamiquement des figures géométriques.

Les dessins sont réalisés dans un repère orthonormé virtuel centré sur la fenêtre d'affichage. L'unité des axes est le pixel. Le repère n'est pas visible à l'écran.

La forme par défaut du crayon de tracé est une flèche "orientée", placé au départ à l'origine du repère. Le crayon est situé à la pointe, la flèche montre le sens du tracé en cours ou à venir.

La liste complète des fonctions disponibles grâce au module turtle est disponible sur la documentation officielle.
On pourra aussi télécharger un petit résumé au format.pdf en cliquant ici.

Pour dessiner avec turtle, il faudra écrire en en-tête du fichier :

Attention avec l'interpréteur de Pyzo

Après avoir exécuté correctement un programme utilisant le module turtle une première fois, le moteur d'interface graphique de Pyzo renvoie parfois un signal d'erreur qui se termine par :

turtle.Terminator

Dans cette situation, il faut redémarrer l'environnement en cliquant sur le bouton .

Avec des élèves en difficulté, ce module peut être un bon outil de remédiation. En effet...

on peut l'utiliser en entrant les instructions du tracé : celles-ci seront affectées au crayon défini par défaut.

on peut aussi définir (nommer) un crayon et appliquer les méthodes précédentes à ce crayon sous la formenom_crayon.nom_methode(parametres_eventuels). Cette seconde méthode sera privilégiée par la suite car elle est plus explicite (on ne s'adresse pas à un crayon anonyme) et permet de piloter plusieurs crayon en même temps (voire même une liste de crayons).

Les déplacements peuvent être relatifs ( ils dépendent de la position dans laquelle est la tortue) ou absolus ( selon les coordonnées et l'orientation angulaire du repère). Les deux scripts suivants permettent d'obtenir le même dessin de carré que celui représenté ci-contre.

Un carré obtenu par déplacements relatifs :

Le même carré obtenu par déplacements absolus :

Le module turtle accepte les paramètres représentant les couleurs sous deux formats :

Le format RGB sous la forme d'un triplet (tuple) de composantes. Dans ce cas, il faut initier la valeur maximale des composantes avec la méthodecolormode(a) (valeur de 1.0 par défaut).

La dénomination des couleurs sous forme de chaînes de caractères. Cette dénomination peut être explicite ('red', 'blue', etc...) ou donnée par un code hexadécimal (par exemple '#FF0000' pour le rouge). On peut obtenir ces codes facilement avec un "analyseur de couleur" commeJust Color Picker.

Deux méthodes nécessitent une valeur de couleur en paramètre :

pencolor(coul) qui indique la couleur (coul) du tracé.

fillcolor(coul) qui indique la couleur (coul) du remplissage.

 from turtle import * stylo = Turtle() colormode(255) stylo.width(2) stylo.pencolor((0, 0, 255)) stylo.fillcolor((255, 255, 0)) stylo.begin_fill() # Indispensable pour "remplir" un tracé for i in range(5): stylo.forward(100) stylo.right(144) stylo.end_fill()

Ces deux méthodes sont incluses dans la méthode color() qui prend soit un, soit deux paramètres :

Avec un seul paramètre (valeur de la couleur), le tracé et le remplissage se feront de la même couleur.

Avec deux paramètres, le tracé se fera dans la couleur correspondant 1er paramètre, le remplissage se fera avec celle du 2nd paramètre.

Le module turtle permet d'afficher une fenêtre contenant un formulaire à compléter par l'utilisateur. Ce formulaire renverra au programme :

un texte (type str) avec l'instructiontextinput('Nom de la fenêtre', 'message').

un nombre (type float) avec l'instructionnuminput('Nom de la fenêtre', 'message').

 from turtle import * nom = textinput('Saisie d\'un texte', 'Entrer un message :') a = numinput('Saisie d\'un nombre', 'Combien de répétitions ?') stylo = Turtle() stylo.speed(0) for i in range(int(a)): stylo.write(nom, font = ('Times New Roman', 12)) stylo.left(10) stylo.up() stylo.forward(10*i) stylo.down() exitonclick()

Il est aussi possible de prendre en compte des évènements :

L'appui sur une touche du clavier avec l'instruction onkey(f, key) où f est la fonction (sans paramètre !) à exécuter lorsque l'utilisateur appui sur la touchekey (nommée par une chaîne de carcactères comme 'Left', 'space','A', ...).

Le clic (gauche) de souris avec l'instructiononscreenclick(f) où f est la fonction à exécuter (avec pour paramètres l'abscisse x et l'ordonnee y du clic dans la fenêtre).

Les deux instructions précédentes doivent être suivie par l'instruction listen() qui permet d'attendre les événements.
Le programmedoit se terminer par l'instructionmainloop(), boucle d'attente des événements (on le reverra dans l'étude du module d'interfaces graphiques tkinter)

 ##----- Importation des Modules -----## from turtle import * ##----- Définition des Fonctions -----## def effacer(): """Efface la fenêtre après appui sur la barre espace.""" stylo.clear() def tracer(x, y): """Trace un disque de centre le clic de souris.""" global n # Prise en compte (manipulation) de la variable globale n += 1 stylo.up() stylo.goto(x, y) stylo.down() if n<=25: stylo.dot(10*n, (10*n, 255-10*n, 10*n)) stylo.up() stylo.forward(10*n/2) stylo.down() stylo.write(str(n), font = ('Times New Roman', 12)) ##----- Programme principal -----## n = 0 # Variable globale, prenant en compte le n° du clic stylo = Pen() colormode(255) onscreenclick(tracer) onkey(effacer, 'space') listen() mainloop()

# data[].attributes.attachment_link.keywords[]
académie de lyon - formation isn : python

# data[].attributes.attachment_link.authors[].name
Groupe IREM-ISN - Pascal BUSAC - Nicolas BUYLE-BODIN - Ludovic FASQUELLE - Cédric FRAYSSINET - Jean-Manuel MENY - Brice PORTIER - Olivier TOURAILLE

# data[].attributes.attachment_link.description
Le module graphique turtle permet de piloter un "crayon" afin de tracer dynamiquement des figures géométriques. Les dessins sont réalisés dans un repère orthonormé virtuel centré sur la fenêtre d'affichage. L'unité des axes est le pixel. Le repère n'est pas visible à l'écran.

# data[].attributes.attachment_link.readable_text
Les programmes ci-dessous ne sont pas à réaliser le jour de la formation ( sauf s'il vous reste du temps bien évidemment). Ils sont là pour vous donner d'autres idées d'exercices ( ou vous entraîner si besoin).

Le programme à concevoir doit faire en sorte que l'image obtenue soit l'image d'origine en "négatif", comme le présentent les deux images ci-dessous. L'image du logo ISN-IREM est téléchargeable en cliquant dessus.

Image d'origine au format .png

Négatif de l'image

 ##----- Importation des Modules -----## from PIL import Image # Ne pas oublier de l'importer pour un programme indépendant ##----- Informations sur l'image d'origine -----## im = Image.open('Logo_ISN-IREM.jpg') couleur = im.mode l, h = im.size ##----- Conception de la nouvelle image -----## im_nega = Image.new(couleur, (l, h)) # Symetrie horizontale for x in range(l): for y in range(h): # On parcourt chaque pixel de l'image analysée plus haut r, v, b = im.getpixel((x, y)) # On récupère le triplet de couleur im_nega.putpixel((x, y), (255-r, 255-v, 255-b)) im_nega.save('Logo_ISN-IREM_Negatif.jpg') im_nega.show()

L'image ci-contre est constituée de sept carrés de couleur noir, rouge, vert, jaune, bleu, magenta et cyan.

1. Rappeler les triplets RGB permettant de représenter les couleurs précédentes.

2. Concevoir une fonction carre() qui permet d'ajouter à une image un carré de100 pixels de côté et de couleur unie.

3. Utiliser cette fonction pour obtenir l'image ci-contre.

 def carre(im, h, r, v, b): """ Entrees : im est une image, h est une ordonnée, (r, v, b) est un triplet d'entiers entre 0 et 255 Sorties : Ajoute à une image im (à partir de l'ordonnée h) un carré de 100 pixels de côté et de couleur ayant pour composantes (r, v, b).""" for x in range(100) : for y in range(h*100, (h+1)*100) : im.putpixel((x, y), (r, v, b))

 ##----- Importation des Modules -----## from PIL import Image # Ne pas oublier de l'importer pour un programme indépendant ##------ Définition des Fonctions ------## def carre(im, h, r, v, b): """Cette fonction ajoute à une image im un carré de 100 pixels de côté et de couleur unie.""" for x in range(100) : for y in range(h*100, (h+1)*100) : im.putpixel((x, y), (r, v, b)) ##------ Programme principal ------## ##----- Informations sur l'image -----## largeur = 100 # largeur de l'image, en pixels hauteur = 700 # hauteur de l'image, en pixels couleur = 'RGB' ##----- Conception de la nouvelle image -----## im = Image.new(couleur, (largeur, hauteur)) h = 0 for i in range(2): for j in range(2): for k in range(2): if not(i == j == k ==1): carre(im, h, 255*k, 255*j, 255*i) h += 1 im.save('Carres_Empiles.jpg') im.show()

On souhaite afficher la palette de toutes les couleurs possibles ( certaines en double) au format RGB ( ci-contre, sans les textes).

1. Quelles sont les dimensions, en pixels, de cette figure ?

2. On s'intéresse au rectangle Jaune-Cyan-Bleu-Rouge.
Exprimer les composantes R, G et B d'un pixel en fonction de son abscisse x et de sa colonne y.

3. Exprimer de la même manière les composantes R, G et B d'un pixel du second rectangle en fonction de son abscisse x et de sa colonne y.

4. En déduire le programme permettant d'afficher cette palette de couleur.

 ##----- Importation des Modules -----## from PIL import Image # Ne pas oublier de l'importer pour un programme indépendant ##----- Informations sur l'image -----## largeur = 511 # largeur de l'image, en pixels hauteur = 511 # hauteur de l'image, en pixels couleur = 'RGB' ##----- Conception de la nouvelle image -----## im = Image.new(couleur, (largeur, hauteur)) for x in range(largeur): # La figure est divisée en quatre carrés # Première moitié des abscisses if x < 256: r = 255-x b = 0 # Seconde moitié des abscisses else: r = 0 b = x-255 for y in range(hauteur): # Le carré "blanc" if x < 256 and y > 255: r, v, b = 255, 255, 255 # Première moitié des ordonnées elif y < 256: v = 255-y # Seconde moitié des ordonnées else: v = 0 r = y-255 im.putpixel((x, y), (r, v, b)) im.save('Palette.jpg') im.show()

Cet exercice est un extrait et une adaptation du document ressource disponible sur le site eduscol.

Dans une image matricielle, chaque pixel a, au maximum, huit voisins.
On a représenté ci-contre le pixel de coordonnées (x, y) avec ses voisins.
A partir d'une image en nuances de gris ( au format 'L' du module PIL, c'est-à-dire que la nuance de chaque pixel est définie par un unique entier compris entre0 et 255.), programmer l'algorithme ci-dessous afin d'obtenir une "mise en relief" de cette image :

On considère un pixel de coordonnées (x, y) et de niveau de grisg.

On calcule la nouvelle valeur de g à partir des niveaux de gris des pixels voisins :
g = 128 + (-2*m-n-p+q+s+2*t) // 8.
On pourra définir une fonction voisins() qui renvoie la liste des coordonnées des pixels voisins du pixel de coordonnées(x, y).

Question supplémentaire : justifier que cette nouvelle valeur de g est bien comprise entre 0 et 255.

Image d'origine

Image en relief

Une piste

La fonction voisins()

Une solution

Une variante

 def voisins(x, y, l, h): """ Entrees : x et y sont les coordonnées d'un pixel situé dans une image de largeur l et de hauteur h Sorties : Renvoie la liste des coordonnées des pixels voisins de ce pixel.""" liste = [(x-1, y-1), # On considère que chaque pixel a 8 voisins (x-1, y), (x-1, y+1), (x, y-1), (x, y+1), (x+1, y-1), (x+1, y), (x+1, y+1)] return liste

 def voisins(x, y, l, h): """ Entrees : x et y sont les coordonnées d'un pixel situé dans une image de largeur l et de hauteur h Sorties : Renvoie la liste des coordonnées des pixels voisins de ce pixel.""" liste = [(x-1, y-1), # On considère que chaque pixel a 8 voisins (x-1, y), (x-1, y+1), (x, y-1), (x, y+1), (x+1, y-1), (x+1, y), (x+1, y+1)] for coor in reversed(liste): # On parcourt la liste renversée if coor[0]<0 or coor[0]>l-1 or coor[1]<0 or coor[1]>h-1: liste.remove(coor) # Lorsque les coordonnées sont hors-domaine, on les enlève de la liste # (raison pour laquelle il faut parcourir la liste renversée) return liste

 ##----- Importation des Modules -----## from PIL import Image ##----- Définition des Fonctions -----## def voisins(x, y, l, h): """ Entrees : x et y sont les coordonnées d'un pixel situé dans une image de largeur l et de hauteur h Sorties : Renvoie la liste des coordonnées des pixels voisins de ce pixel.""" liste = [(x-1, y-1), # On considère que chaque pixel a 8 voisins (x-1, y), (x-1, y+1), (x, y-1), (x, y+1), (x+1, y-1), (x+1, y), (x+1, y+1)] return liste def compo(im, liste): """ Entrees : im est une image, liste contient les coordonnées des voisins d'un pixel Sorties : Renvoie la composante grise du pixel calculée à partir des composantes de ses 6 voisines m, n, p, q, s et t dont les coordonnées se trouvent aux indices 0, 1, 3, 4, 6, 7 dans la liste.""" for i in range(8): liste[i] = int(im.getpixel(liste[i])) return 128 + (-2*liste[0]-liste[1]-liste[3]+liste[4]+liste[6]+2*liste[7]) ##----- Informations sur l'image d'origine -----## im = Image.open('Logo_ISN-IREM_Gris.jpg') l, h = im.size ##----- Ajout de bords à cette image -----## im_grande = Image.new('L', (l+2, h+2)) for x in range(l+2): for y in range(h+2): if x==0 or y==0 or x==l+1 or y==h+1: im_grande.putpixel((x,y), 0) else: im_grande.putpixel((x,y), im.getpixel((x-1, y-1))) im_grande.save('Logo_ISN-IREM_Bords.jpg') im_grande.show() ##----- Conception de la nouvelle image -----## im_grande = Image.open('Logo_ISN-IREM_Bords.jpg') im_relief = Image.new('L', (l, h)) for x in range(l): for y in range(h): im_relief.putpixel((x,y), compo (im_grande, voisins(x+1, y+1, l, h))) ##-----Finalisation-----## im_relief.save('Logo_ISN-IREM_Relief.jpg') im_relief.show()

 ##----- Importation des Modules -----## from PIL import Image ##----- Définition des Fonctions -----## def voisins(im, x, y, l, h): """ Entrees : x et y sont les coordonnées d'un pixel situé dans l'image im de largeur l et de hauteur h Sorties : Renvoie la liste des coordonnées des pixels voisins de ce pixel.""" liste = [(x-1, y-1), # On considère les 6 voisins "intéressants" (x-1, y), (x, y-1), (x, y+1), (x+1, y), (x+1, y+1)] s = [] # Liste des composantes actualisées m, n, p, q, s et t for coor in liste: if coor[0]<0 or coor[0]>l-1 or coor[1]<0 or coor[1]>h-1: s.append(255) # Si le pixel est "hors cadre", on lui attribue la couleur blanc else: s.append(im.getpixel(coor)) # Sinon on ajoute sa composante g = 128 + (-2*s[0]-s[1]-s[2]+s[3]+s[4]+2*s[5]) return g ##----- Informations sur l'image d'origine -----## im = Image.open('Logo_ISN-IREM_Gris.jpg') l, h = im.size ##----- Conception de la nouvelle image -----## im_relief = Image.new('L', (l, h)) for x in range(l): for y in range(h): im_relief.putpixel((x,y), voisins(im, x, y, l, h)) ##-----Finalisation-----## im_relief.save('Logo_ISN-IREM_Relief.jpg') im_relief.show()

Pour localiser différents objets dans une image, il est nécessaire de réussir à localiser les contours de ces objets. Généralement, les nuances des pixels voisins seront très différentes les unes des autres.

Pour cela, on peut appliquer un algorithme de distance 1 ( au sens de "distance dans un repère orthonormé") qui va calculer pour le pixel de coordonnées(x, y) la distance entre les niveaux de gris de ses voisins : \(d = \sqrt{\left(n-s\right)^2+\left(p-q \right)^2}\).

En comparant cette distance à un certain seuil ( à définir), le pixel de coordonnées(x, y) sera affiché soit en noir, soit en blanc. Appliquer le programme ainsi conçu au logo ISN-IREM Gris définit en nuances de gris.

Image d'origine

Image détourée

 ##----- Importation des Modules -----## from PIL import Image from math import sqrt ##----- Définition des Fonctions -----## def ecart(im, x, y, l, h): """ Entrees : x et y sont les coordonnées d'un pixel situé dans une image de largeur l et de hauteur h Sorties : calcule les variations de niveau de gris autour (distance 1) de ce pixel""" liste = [(x, y-1),  # On considère les 4 voisins "intéressants" (x, y+1), (x-1, y), (x+1, y)] compo = []   	# Liste des composantes actualisées n, s, p et q for coor in liste: if coor[0]<0 or coor[0]>l-1 or coor[1]<0 or coor[1]>h-1: compo.append(255) 	# Si le pixel est "hors cadre", on lui attribue la couleur blanc else: compo.append(im.getpixel(coor)) 	# Sinon on ajoute sa composante d = int(sqrt((compo[0]-compo[1])**2+(compo[2]-compo[3])**2)) return d ##----- Informations sur l'image d'origine -----## im = Image.open('Logo_ISN-IREM_Gris.jpg') l, h = im.size ##----- Conception de la nouvelle image -----## seuil = 25 # Seuil de "détourage" im_detour = Image.new('L', (l, h)) for x in range(l): for y in range(h): if ecart(im, x, y, l, h) < seuil: im_detour.putpixel((x,y), 255) else: im_detour.putpixel((x,y), 0) ##-----Finalisation-----## im_detour.save('Logo_ISN-IREM_detoure.jpg') im_detour.show()

Le logo ISN-IREM est trop grand ( 1600*1000) pour être utilisée en vraie grandeur dans certains des exercices précédents L'image a été compressée ( réduite) de manière automatique par le logiciel d'affichage ( ici le navigateur).

Le but de cet exercice est de programmer une compression de l'image en suivant l'algorithme ci-dessous :

1. On note k le coefficient de réduction : la largeur et la hauteur de l'image seront divisées park donc le nombre total de pixels sera divisé park².

2. On "regroupe" les pixels par carrés de côtés k.
Ci-contre, de côté k = 2.

3. On remplace ces k² pixels par un unique pixel dont les composantes(r, v, b) sont les moyennes des composantes des k² pixels de l'image d'origine.

Une solution

Une variante

 ##----- Importation des Modules -----## from PIL import Image ##----- Coefficient de Réduction -----## k = 4 ##----- Informations sur l'image d'origine -----## im = Image.open('Logo_ISN-IREM_Original.jpg') l, h = im.size ##----- Conception de la nouvelle image -----## largeur, hauteur = l//k, h//k # Nouvelles dimensions im_red = Image.new('RGB', (largeur, hauteur)) # Image "compressée" for x in range(0, largeur*k, k): # Saut de k en k en largeur for y in range(0, hauteur*k, k): # Saut de k en k en hauteur rouge, vert, bleu = 0, 0, 0 # Somme des composantes des k² pixels for i in range(k): for j in range(k): r, v, b = im.getpixel((x+i, y+j)) rouge += r vert += v bleu += b rouge = rouge//(k*k) # On divise les sommes par le nombre de pixels (moyennne) vert = vert//(k*k) bleu = bleu//(k*k) # On place le pixel dans l'image réduite (attention aux coordonnées...) im_red.putpixel((x//k, y//k), (rouge, vert, bleu)) ##-----Finalisation-----## im_red.save('Logo_ISN-IREM_Reduit.jpg') # Sauvegarde im_red.show() # Affichage

 ##----- Importation des Modules -----## from PIL import Image ##----- Définition des Fonctions -----## def moy(im, x, y, k): """ Entrees : im est une image, x et y sont les coordonées du pixel étudié, k est le coef de réduction Sorties : Renvoie le nouveu triplet de composantes (r, v, b) du pixel de coordonnées (x, y). Ces composantes sont la moyenne des composantes d'un carré de pixels de côté k.""" rouge, vert, bleu = 0, 0, 0 # Somme des composantes des k² pixels for i in range(k): for j in range(k): r, v, b = im.getpixel((x+i, y+j)) rouge += r vert += v bleu += b rouge = rouge//(k*k) # On divise les sommes par le nombre de pixels (moyennne) vert = vert//(k*k) bleu = bleu//(k*k) return (rouge, vert, bleu) ##----- Coefficient de Réduction -----## k = 4 ##----- Informations sur l'image d'origine -----## im = Image.open('Logo_ISN-IREM_Original.jpg') l, h = im.size ##----- Conception de la nouvelle image -----## largeur, hauteur = l//k, h//k # Nouvelles dimensions im_red = Image.new('RGB', (largeur, hauteur)) # Image "compressée" espace_l = (l-k*largeur)//2 # nombre de pixels à enlever à gauche des lignes espace_c = (h-k*hauteur)//2 # nombre de pixels à enlever en haut des colonnes for x in range(espace_l, espace_l+largeur*k, k): # Saut de k en k en largeur for y in range(espace_c, espace_c+hauteur*k, k): # Saut de k en k en hauteur # On place le pixel dans l'image réduite (attention aux coordonnées...) im_red.putpixel((x//k, y//k), moy(im, x, y, k)) ##-----Finalisation-----## im_red.save('Logo_ISN-IREM_Reduit.jpg') # Sauvegarde im_red.show() # Affichage

# data[].attributes.attachment_link.keywords[]
académie de lyon - formation isn : python

# data[].attributes.attachment_link.authors[].name
Groupe IREM-ISN - Pascal BUSAC - Nicolas BUYLE-BODIN - Ludovic FASQUELLE - Cédric FRAYSSINET - Jean-Manuel MENY - Brice PORTIER - Olivier TOURAILLE

# data[].attributes.attachment_link.description
Les programmes ci-dessous ne sont pas à réaliser le jour de la formation ( sauf s'il vous reste du temps bien évidemment). Ils sont là pour vous donner d'autres idées d'exercices ( ou vous entraîner si besoin). Le programme à concevoir doit faire en sorte que l'image obtenue soit l'image d'origine en "négatif", comme le présentent les deux images ci-dessous.

# data[].attributes.attachment_link.readable_text
PIL (Python Imaging Library) est une bibliothèque pour la manipulation des images. Vous retrouverez de nombreux modules qui vous permettront de traiter des images de n'importe quel format. Cette bibliothèque permet également aux interfaces graphiques construites avec Tkinter d'utiliser des images déclarer avec PIL.
Ce tutoriel est proposé par Fredrik Lundh et Matthew Ellis

Pour télécharger cette bibliothèque, consultez notre rubrique Outils Python

Vous pouvez également consulter la documentation en ligne:

Vous pouvez également télécharger cette documentation sous format pdf

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants :

# data[].attributes.attachment_link.description
PIL (Python Imaging Library) est une bibliothèque pour la manipulation des images. Vous retrouverez de nombreux modules qui vous permettront de traiter des images de n'importe quel format. Cette bibliothèque permet également aux interfaces graphiques construites avec Tkinter d'utiliser des images déclarer avec PIL.

# data[].attributes.attachment_link.readable_text
Le module turtle permet programmer des dessins. Il est issu de l'ancien langage LOGO. C'est un module qui permet d'aborder de nombreux thèmes en ISN :

la notion de boucles ;

la définition des couleurs (nommées, au format RGB ou héxadécimal) ;

la création de fonctions ;

l'utilisation conjointe avec d'autres modules (math, random,PIL, etc...).

Les principales fonctions mises à votre disposition dans le module turtle sont les suivantes :

Vous pouvez aussi télécharger un petit résumé au format .pdf en cliquant ici.

Testez les deux scripts suivants :

1. Écrire une fonction carre() permettant de tracer un carré rouge de coté 100 à l'appel decarre(100, 'red').

2. Écrire un script utilisant la fonction carre() et donnant le résultat :

3. Reprendre les deux questions précédentes en remplaçant le carré par un triangle équilatéral de côté 100 pixels.

Une piste ?

Une solution ?

 from turtle import * # Fonction carre def carre(taille, couleur): """fonction qui dessine un carré de taille et de couleur déterminées""" color(couleur) for k in range(4): forward(taille) right(90) # Fonction triangle def triangle(taille, couleur): """fonction qui dessine un triangle équilatéral de taille et de couleur déterminées""" color(couleur) for k in range(3): forward(taille) left(120)

Écrire un script avec Python permettant d'obtenir la figure suivante :

Une piste ?

Une solution ?

 from turtle import * def carre(taille, couleur): "fonction qui dessine un carré de taille et de couleur déterminées" color(couleur) begin_fill() c = 0 while c < 4: forward(taille) # en pixels right(90) # tourner le curseur à droite de 90 degrés c = c + 1 end_fill() up() # relever le crayon goto(-150, -50) # reculer en haut à gauche def ncarre(n): "Choisir le nombre de carré(s) en argument" for i in range(n): down() # abaisser le crayon carre(25, 'red') # tracer un carré up() # relever le crayon forward(30) # avancer + loin left(10) ncarre(36) # appel de la fonction précédente pour dessiner 36 carrés pour faire une tour complet

-->

Écrire un script avec Python permettant d'obtenir la figure suivante :

Une piste ?

Une solution ?

 from turtle import * def carre(taille, couleur): "fonction qui dessine un carré de taille et de couleur déterminées" color(couleur) begin_fill() c = 0 while c < 4: forward(taille) # en pixels right(90) # tourner le curseur à droite de 90 degrés c = c + 1 end_fill() # Fonction triangle def triangle(taille, couleur): "fonction qui dessine un triangle équilatéral de taille et de couleur déterminées" color(couleur) begin_fill() for k in range(3): forward(taille) left(120) end_fill() up() # relever le crayon goto(-150, -30) # reculer en haut à gauche def npolygone(n): "Choisir le nombre de carré(s) en argument" for i in range(n): down() # abaisser le crayon carre(25, 'red') # tracer un carré up() # relever le crayon forward(30) # avancer + loin left(10) triangle(25, 'blue') forward(30) # avancer + loin left(10) npolygone(18) # appel de la fonction précédente pour dessiner 18 séries carré+triangle

Écrire un programme permettant de dessiner les flocons de neige ci-dessous :

 ##----------Importation des modules---------## from turtle import * ##----------Définition des Fonctions----------## def retour(t, x, y): t.up() t.goto(x, y) t.down() def pointe1(t, dist): """Cette fonction trace une pointe de flèche.""" t.right(135) t.forward(dist) t.backward(dist) t.right(90) t.forward(dist) t.right(135) # Retour à l'orientation d'origine def pointe2(t, dist): """Cette fonction trace une pointe de flèche inversée.""" t.right(180) pointe1(t, dist) t.right(180) # Retour à l'orientation d'origine def pointec(t, dist): """Cette fonction trace une pointe carrée.""" t.right(45) for i in range(4): t.forward(dist) t.left(90) t.left(45) # Retour à l'orientation d'origine ##----------Programme Principal----------## stylo = Pen() stylo.width(2) stylo.speed(0) rayon = 100 cote = 20 for i in range(3): stylo.setheading(-30) abscisse = 3*rayon*(i-1) retour(stylo, abscisse, 0) for j in range(6): stylo.left(60) stylo.forward(rayon) if i%3==0: pointe1(stylo, cote) elif i%3 == 1: pointe2(stylo, cote) else: pointec(stylo, cote) retour(stylo, abscisse, 0) stylo.hideturtle() exitonclick()

Dessiner en utilisant les mathématiques, c'est joli. Le programme ci-dessous doit :

1. Demander à l'utilisateur les valeurs de deux nombres entiers \(n\) et \(d\) ;

2. Afficher à l'écran la valeur simplifiée de la fraction \(k = \frac{n}{d}\)

3. Tracer la rosace d'équation polaire \(r = \cos(k\theta)\).

Un "rappel" : la forme paramétrique de la courbe est alors donnée par les fonctions \(x = \cos(k\theta)\sin(\theta)\) et \(y = \cos(k\theta)\cos(\theta)\).

 ##----- Importation des Modules -----## from turtle import * from math import * ##----- Définition des Fonctions -----## def pgcd(a, b): """Déterminer le pgcd entre deux nombres.""" quotient = a//b reste = a%b while reste != 0 : a = b b = reste quotient, reste = a//b, a%b return b def simplifier(a, b): """Renvoie les valeurs simplifiées du numérateur et du dénominateur d'une fraction.""" p = pgcd(a, b) a = a//p b = b//p return (a, b) def ecrire(a, b): """Renvoie l'écriture de la forme irréductible de la fraction a/b.""" a, b = simplifier(a, b) if b == 1: return str(a) else: return str(a)+'/'+str(b) ##----- Déclaration des Variables -----## n = int(numinput('Saisie d\'un nombre', 'Donner la valeur d\'un entier n')) d = int(numinput('Saisie d\'un autre nombre', 'Donner la valeur d\'un entier d')) k = n/d stylo = Pen() ##----- Écriture de la fraction simplifiée -----## stylo.up() stylo.goto(-120, 120) stylo.down() stylo.write('k = '+ecrire(n, d)) ##----- Tracé de la rosace -----## angle = 0 stylo.up() stylo.goto(0, 100) stylo.down() stylo.width(2) if k%2 == 1: # Pour gérer au mieux le nombre de répétitions tours = 1 else: tours = 2*simplifier(n, d)[1] while angle <= tours*pi: angle += pi/72 x = 100*cos(k*angle)*sin(angle) # On multiplie par 100 pour y voir quelque chose... y = 100*cos(k*angle)*cos(angle) stylo.goto(x, y) stylo.hideturtle() exitonclick()

La rosace ci-contre a été dessinée en utilisant un liste de crayons. Chaque "pétale" a été dessiné par un crayon différent. Voici quelques pistes pour reproduire cette figure :

1. Demander à l'utilisateur le nombre de pétales désirés.

2. Définir une liste vide qui contiendra les futurs crayons.

3. En utilisant une boucle, créer un nouveau crayon, définir ses caractéristiques (épaisseur, couleur, orientation, etc...) puis ajouter ce crayon à la liste précédente.

4. Chaque crayon effectue ensuite une succession de déplacements de 15 pixels, entrecoupés d'une rotation dont l'angle va de0 à16 degrés puis revient à0 degrés avec un pas de1.

Une piste ?

Une autre piste ?

Une solution ?

 ##----- Importation des Modules -----## from turtle import * ##----- Définition des Fonctions -----## def deplacer(liste_crayons, longueur, angle): for stylo in liste_crayons: stylo.forward(longueur) stylo.left(angle) ##----- Déclaration des Variables -----## colormode(255) # Couleurs au format RGB liste_stylos = [] n = int(numinput('Saisie d\'un nombre', 'Donner le nombre de crayons à manipuler')) angle = 360/n # Ecart angulaire entre chaque crayon orientation = 0 # Orientation du 1er crayon ##----- Création de la liste de crayons -----## for i in range(n): stylo = Pen() # Un crayon quelconque stylo.setheading(orientation) stylo.width(2) stylo.pencolor(255*1/(i+1), 255*1/(n-i), 255*(n-i)/n) stylo.speed(10) liste_stylos.append(stylo) orientation += angle ##----- Tracé de la rosace -----## for i in range(16): deplacer(liste_stylos, 15, i) for i in range(16, -2, -1): deplacer(liste_stylos, 15, i) for stylo in liste_stylos: stylo.hideturtle() exitonclick()

# data[].attributes.attachment_link.keywords[]
académie de lyon - formation isn : python

# data[].attributes.attachment_link.authors[].name
Groupe IREM-ISN - Pascal BUSAC - Nicolas BUYLE-BODIN - Ludovic FASQUELLE - Cédric FRAYSSINET - Jean-Manuel MENY - Brice PORTIER - Olivier TOURAILLE

# data[].attributes.attachment_link.description
Le module turtle permet programmer des dessins. Il est issu de l'ancien langage LOGO. C'est un module qui permet d'aborder de nombreux thèmes en ISN : la notion de boucles ; la définition des couleurs (nommées, au format RGB ou héxadécimal) ; la création de fonctions ; l'utilisation conjointe avec d'autres modules (math, random,PIL, etc...).

# data[].attributes.attachment_link.readable_text
Après avoir vu différents types de données, nous allons maintenant, à l'aide du langage de programmation Python, apprendre à effectuer des traitements sur ces données.

À faire vous-même 1

Ouvrez le logiciel Spyder

Dans un Spyder vous pouvez saisir du code (partie "Editeur de texte") mais aussi, saisir des commandes (nous verrons ce concept de commande plus loin) dans la partie "Console".

Pour traiter des données, nous allons utiliser la bibliothèque Python Pandas. Une bibliothèque Python permet de rajouter des fonctionnalités par rapport au langage de base. La bibliothèque Pandas est donc très utilisée pour tout ce qui touche au traitement des données.

Pour nos premiers pas avec Pandas, nous allons utiliser des données très simples au format CSV : ces données sont contenues dans le fichier ident_virgule.csv.

À faire vous-même 2

Après avoir téléchargé le fichier ident_virgule.csv, placez-le dans le dossier de votre choix (par exemple dans un dossier nommé "act_pandas")

À faire vous-même 3

Dans la partie "Editeur de texte" de Spyder, saisissez le code Python suivant :

 import pandas iden=pandas.read_csv("ident_virgule.csv")

Une fois le code saisi, enregistrer le fichier contenant ce code dans le même répertoire que le fichier "ident_virgule.csv"

Le code ci-dessus est très simple :

Avec la première ligne, nous importons la bibliothèque pandas afin de pouvoir l'utiliser

À la deuxième ligne, nous créons une variable "iden" qui va contenir les données présentes dans le fichier "ident_virgule.csv"

À faire vous-même 4

Dans spyder cliquez sur le triangle vert qui permet d'exécuter le programme que vous venez de saisir. Placez ensuite le curseur de la souris dans la console de spyder juste à côté d'un "In [X]" (avec X égal à 1, 2, 3..., selon les cas, dans l'exemple ci-dessous nous avons "In [3]"). Tapez alors "iden"

Vous devriez voir apparaitre les données contenues dans la variable "iden" rangées sous la forme d'un tableau, un peu comme ce que nous obtenions en ouvrant le fichier "ident_virgule.csv" avec un tableur.

Vous avez peut-être remarqué qu'une colonne a été ajoutée par rapport à ce que nous obtenions avec le tableur :

Les nombres présents dans cette colonne sont appelés des index. Chaque ligne du tableau a un index (première ligne : index 0, deuxième ligne index 1...)

ATTENTION : les index commencent à 0 et pas à 1

Les colonnes possèdes également des index, dans notre exemple ces index correspondent au "nom" (index de la première colonne), au "prenom" (index de la deuxième colonne) et à "date_naissance" (index de la troisième colonne)

En résumé : les lignes possèdent des index (0,1,2..), les colonnes possèdent aussi des index ("nom", "prenom",...)

Il est possible de récupérer certaines données du tableau, par exemple, certaines lignes, certaines colonnes ou bien encore des valeurs uniques. Pour cela, il suffit d'utiliser l'instruction "loc" avec les index des lignes et les index des colonnes. Le principe de fonctionnement de "loc" est relativement simple puisque l'on aura une instruction de la forme "loc[index_ligne,index_colonne]"

À faire vous-même 5

Testez le programme suivant :

 import pandas iden=pandas.read_csv("ident_virgule.csv") info=iden.loc[1,'prenom']

Vérifiez que la variable "info" contient bien le prénom "christophe"

À faire vous-même 6

Modifiez le programme du "À faire vous-même 4" pour que la variable info contienne "12/06/1978"

Il est possible de récupérer toutes les lignes d'une colonne, il suffit de remplacer la partie "index_ligne" de "loc" par ":"

À faire vous-même 7

Testez le programme suivant :

 import pandas iden=pandas.read_csv("ident_virgule.csv") info=iden.loc[:,'nom']

Vérifiez que la variable "info" contient bien toutes les données de la colonne d'index "nom", autrement dit, tous les noms

Il est possible de récupérer toutes les colonnes d'une ligne particulière, cette fois en remplaçant la partie "index_colonne" de "loc" par ":"

À faire vous-même 8

Testez le programme suivant :

 import pandas iden=pandas.read_csv("ident_virgule.csv") info=iden.loc[2,:]

Vérifiez que la variable "info" contient bien toutes les données de la dernière ligne (index 2)

Il est aussi possible de récupérer seulement certaines lignes et certaines colonnes en utilisant la notation suivante : loc[[index_ligne_1,index_ligne_2,...],[index_colonne_1,index_colonne_2,...]]

À faire vous-même 9

Testez le programme suivant :

 import pandas iden=pandas.read_csv("ident_virgule.csv") info=iden.loc[[0,1],['nom','date_naissance']]

Vérifiez que la variable "info" contient bien un tableau avec uniquement les colonnes "nom" et "date_naissance" de la première ligne (index 0) et de la deuxième ligne (index 1).

Afin d'avoir des exemples plus complexes à traiter, dans la suite, nous allons travailler sur les données contenues dans le fichier ville_virgule.csv.

À faire vous-même 10

Testez le programme suivant :

 import pandas info_villes=pandas.read_csv("villes_virgule.csv")

Vérifiez que la variable "info_villes" contient bien les données contenues dans le fichier ville_virgule.csv.

Comme vous pouvez le constater, il manque des données dans le tableau qui s'affiche dans la console spyder (les données manquantes sont symbolisées par des ...), en effet, le tableau contient trop données pour qu'il soit entièrement affiché dans la console spyder. Heureusement, il existe une solution :

Dans spyder, dans la fenêtre située juste au-dessus de la console, vous allez trouver un onglet "Explorateur de variables". Cliquez sur cet onglet, vous devriez alors obtenir ceci :

Double-cliquez sur "info_villes" et vous devriez alors voir apparaitre une nouvelle fenêtre qui contiendra un tableau avec l'ensemble des données.

En explorant le tableau, vous devriez, notamment dans les colonnes l'altitude mini et maxi, voir apparaitre un étrange "nan" pour les dernières villes du tableau. "nan" signifie "not a number", ici, cela veut tout simplement dire que certaines données sont manquantes.

Nous allons maintenant introduire des conditions dans la sélection des villes. Imaginez par exemple que vous désirez obtenir un tableau contenant toutes les villes qui ont une altitude minimum supérieure à 1500 m :

À faire vous-même 11

Analysez et testez le programme suivant :

 import pandas info_villes=pandas.read_csv("villes_virgule.csv") nom_alt=info_villes.loc[info_villes["alt_min"]>1500,["nom","alt_min"]]

Dans le "loc", l'expression "info_villes["alt_min"]>1500" est bien avant la virgule, elle concerne donc les index des lignes du tableau. On sélectionnera uniquement les lignes qui auront la valeur du descripteur "alt_min" supérieure à 1500. Nous allons donc bien sélectionner les villes qui ont une altitude minimum supérieure à 1500 m

À faire vous-même 12

En vous inspirant de ce qui a été fait au "À faire vous-même 11", écrivez un programme qui permettra d'avoir les villes qui ont une densité d'habitant inférieure à 50 (dans le tableau ainsi créé, on aura 3 colonnes : le nom de la ville, la densité de la population et l'altitude minimum)

Il est possible de combiner plusieurs facteurs de sélection en utilisant un "et"("&") ou un "ou"("|").

À faire vous-même 13

Analysez et testez le programme suivant :

 import pandas info_villes=pandas.read_csv("villes_virgule.csv") nom_alt=info_villes.loc[(info_villes["alt_min"]>1500) & (info_villes["dens"]>50),["nom","dens","alt_min"]]

Vous devriez constater qu'il y a, en France, une seule ville avec une densité de population supérieure à 50 et une altitude minimum supérieure à 1500 m.

Il est aussi possible d'effectuer des calculs sur des colonnes, par exemple des moyennes. Il suffit d'utiliser l'instruction "mean" pour effectuer une moyenne :

À faire vous-même 14

Analysez et testez le programme suivant :

 import pandas info_villes=pandas.read_csv("villes_virgule.csv") moyenne_alt_min=info_villes.loc[:,"alt_min"].mean()

Vous devriez constater que l'altitude minimum moyenne est de 193 m en France. Je rappelle que dans "loc[:,"alt_min"]" le ":" signifie que l'on considère toutes les lignes du tableau. De plus le "alt_min" que le calcul de la moyenne porte bien sur les données du descripteur "alt_min".

À faire vous-même 15

Écrivez un programme permettant de calculer le nombre moyen d'habitants en 2012

Pour l'instant nous avons calculé une moyenne sur l'ensemble des lignes, il est aussi possible d'imposer une condition sur les lignes qui seront utilisées pour le calcul.

À faire vous-même 16

Analysez et testez le programme suivant :

 import pandas info_villes=pandas.read_csv("villes_virgule.csv") nbe_hab=info_villes.loc[info_villes["alt_min"]>1500,"nb_hab_2012"].mean() print(nbe_hab)

Vous devriez constater que les villes ayant une altitude minimum supérieure à 1500 m avaient en moyenne 350 habitants en 2012.

Il est aussi possible de trier le tableau en fonction des valeurs d'un descripteur. Il suffit d'utiliser l'instruction "sort_values"

À faire vous-même 17

Analysez et testez le programme suivant :

 import pandas info_villes=pandas.read_csv("villes_virgule.csv") tri_alt_min=info_villes.sort_values(by=["alt_min"])

Vous devriez obtenir un nouveau tableau de données "tri_alt_min" trié dans l'ordre croissant des altitudes minimums. Quelle est la ville ayant l'altitude minimum la plus faible de France ?

Il est aussi possible de trier par ordre décroissant en ajoutant "ascending=False" :

À faire vous-même 18

Analysez et testez le programme suivant :

 import pandas info_villes=pandas.read_csv("villes_virgule.csv") tri_alt_min=info_villes.sort_values(by=["alt_min"], ascending=False)

Quelle est la ville ayant l'altitude minimum la plus importante de France ?

À faire vous-même 19

Écrivez un programme permettant de répondre à la question suivante : quelle est la ville ayant la densité de population la plus forte ?

Auteur : David Roche

# data[].attributes.attachment_link.description
Après avoir vu différents types de données, nous allons maintenant, à l'aide du langage de programmation Python, apprendre à effectuer des traitements sur ces données. À faire vous-même 1 Ouvrez le logiciel Spyder Dans un Spyder vous pouvez saisir du code (partie "Editeur de texte") mais aussi, saisir des commandes (nous verrons ce concept de commande plus loin) dans la partie "Console".

# data[].attributes.attachment_link.readable_text
Nous allons utiliser les cartes proposées par Open Street Map et le langage Python afin de générer des cartes personnalisées. Plus exactement, nous allons utiliser une bibliothèque Python nommée Folium. Une bibliothèque Python permet de rajouter des fonctionnalités au langage de base. Folium va donc nous permettre de créer nos propres cartes à partir des cartes proposées par Open Street Map

À faire vous-même 1

Créez un dossier et nommez-le par exemple "cartoOSM"

À faire vous-même 2

Utilisez le logiciel spyder pour saisir le programme ci-dessous. Le fichier devra être enregistré dans le répertoire créé au "À faire vous-même 1" (le fichier pourra être nommé "carte_1.py").

 import folium c= folium.Map(location=[46.078025, 6.409053]) c.save('maCarte.html')

Une fois le code ci-dessus exécuté, rendez-vous dans le répertoire que vous avez créé au "À faire vous-même 1". Vous devriez trouver un fichier "maCarte.html". Double-cliquez sur ce fichier, cela devrait normalement ouvrir un navigateur web : la carte centrée sur la ville de Bonneville est à votre disposition. Notez bien que nous avons une véritable carte et pas une simple image (il est possible de zoomer ou de se déplacer).

Le programme du "À faire vous-même 2" est simple à comprendre :

La première ligne : "import folium" permet d'importer la bibliothèque folium afin de pouvoir l'utiliser

La deuxième ligne est le coeur de notre programme, nous définissons une variable "c" qui va contenir notre objet carte. "folium.Map(location=[46.078025, 6.409053])" génère cet objet carte, la carte sera centrée sur le point de latitude "46.078025" et de longitude "6.409053". Plus généralement nous avons "folium.Map(location=[latitude, longitude])". Il suffit donc de renseigner la bonne longitude et la bonne latitude pour que la carte soit centrée sur le point désiré.

La dernière ligne permet de générer la page HTML qui va permettre d'afficher la carte.

À faire vous-même 3

Modifiez le programme du "À faire vous-même 2" pour qu'il génère une carte centrée sur la ville de votre choix (la longitude et la latitude d'une ville sont facilement trouvables sur le web).

Il est possible d'obtenir un niveau de zoom différent en ajoutant un paramètre "zoom_start"

À faire vous-même 4

Saisissez et testez le programme ci-dessous (si vous désirez garder la carte précédente, n'oubliez pas de modifier la dernière ligne en changeant le nom du fichier HTML généré)

 import folium c= folium.Map(location=[46.078025, 6.409053],zoom_start=15) c.save('maCarte.html')

Plus la valeur de "zoom_start" sera grande et plus le zoom sera important.

Afin de vraiment personnaliser la carte, il est possible d'ajouter des marqueurs sur la carte. Un marqueur sera simplement défini par ses coordonnées (latitude et longitude).

À faire vous-même 5

Saisissez et testez le programme ci-dessous

 import folium c= folium.Map(location=[46.078025, 6.409053],zoom_start=20) folium.Marker([46.078637266899, 6.4111924884134]).add_to(c) c.save('maCarte.html')

Nous avons uniquement ajouté la ligne "folium.Marker...", il faut juste renseigner les coordonnées souhaitées (ici 46.078637266899 pour la latitude et 6.4111924884134 pour la longitude)

Il est possible d'ajouter plusieurs marqueurs sur une même carte, il suffira d'ajouter autant de ligne "folium.Marker([latitude, longitude]).add_to(c)" que de marqueurs désirés.

Il est possible d'associer une information à un marqueur en ajoutant le paramètre "popup"

À faire vous-même 6

Saisissez et testez le programme ci-dessous

 import folium c= folium.Map(location=[46.078025, 6.409053],zoom_start=20) folium.Marker([46.078637266899, 6.4111924884134],popup="Lycée G Fichet").add_to(c) c.save('maCarte.html')

Il suffit de cliquer sur le marqueur pour que l'information définie par le paramètre "popup" apparaisse à l'écran (ici en cliquant sur le marqueur nous verrons donc apparaitre "Lycée G Fichet").

Auteur : David Roche

# data[].attributes.attachment_link.description
Nous allons utiliser les cartes proposées par Open Street Map et le langage Python afin de générer des cartes personnalisées. Plus exactement, nous allons utiliser une bibliothèque Python nommée Folium. Une bibliothèque Python permet de rajouter des fonctionnalités au langage de base.

# data[].attributes.attachment_link.readable_text
Tutoriel français sur matplotlib pour apprendre à créer des graphiques impressionnants avec python. On peut même créer plusieurs graphiques avec matplotlib subplot !

Matplotlib pyplot est simple à comprendre: on créer une figure avec plt.figure() puis on ajoute des courbes avec plot. Si on veut ajouter plus d'une courbe, on utilise subplot.
Timecode de la vidéo:

00:38 La visualisation de données doit être un atout !

02:42 premier graphique avec plt.plot()

04:36 Les styles les plus importants

05:48 Le cycle de vie d'une figure Matplotlib (IMPORTANT)

10:23 Subplot: afficher plusieurs graphiques avec matplotlib

12:44 Matplotlib Orienté Objets

16:05 BILAN et EXERCICE Matplotlib subplots TRES UTILE !

Sommaire de la formation:

# data[].attributes.attachment_link.title
Formation Python - Machine Learning 14/30 : Matplotlib facile - Actu IA

# data[].attributes.attachment_link.description
Tutoriel français sur matplotlib pour apprendre à créer des graphiques impressionnants avec python. On peut même créer plusieurs graphiques avec matplotlib subplot ! Matplotlib pyplot est simple à comprendre: on créer une figure avec plt.figure() puis on ajoute des courbes avec plot. Si on veut ajouter plus d'une courbe, on utilise subplot.

# data[].attributes.attachment_link.title
A la façon de Vera Molnar - toutatice.fr

# data[].attributes.attachment_link.description
Les premiers travaux permettent d'obtenir des pavages de plus en plus complexes à l'aide de plusieurs motifs choisis aléatoirement. - Les derniers travaux permettent d'obtenir des pavages à l'aide d'un seul motif qui est lui même obtenu aléatoirement. - Les groupes les plus rapides doivent obtenir leurs propres œuvres.

# data[].attributes.attachment_link.readable_text
builds on the data wrangling strengths of the Python ecosystem and the mapping strengths of the library. Manipulate your data in Python, then visualize it in on a Leaflet map via .

Concepts

makes it easy to visualize data that's been manipulated in Python on an interactive leaflet map. It enables both the binding of data to a map for choropleth visualizations as well as passing rich vector/raster/HTML visualizations as markers on the map.

The library has a number of built-in tilesets from OpenStreetMap, Mapbox, and Stamen, and supports custom tilesets with Mapbox or Cloudmade API keys. supports both Image, Video, GeoJSON and TopoJSON overlays.

# data[].attributes.attachment_link.description
builds on the data wrangling strengths of the Python ecosystem and the mapping strengths of the library. Manipulate your data in Python, then visualize it in on a Leaflet map via . makes it easy to visualize data that's been manipulated in Python on an interactive leaflet map.

# data[].attributes.headline
Capsule 2 - Matplotlib, les 5 graphiques les plus cool

# data[].attributes.subject
Capsule 2 - Matplotlib, les 5 graphiques les plus cool

# data[].attributes.attachment_link.readable_text
Tutoriel français python matplotlib pour apprendre comment tracer des graphiques cools et utiles avec matplotlib ! Parmi ces graphiques on retrouvera les graphiques 3D, plt scatter, l'histogramme, le contour plot et bien sur imshow qui permet de visualiser n'importe quelle matrice numpy ! Python est vraiment facile et ce tutoriel français matplotlib va vous le prouver !
Pour les codes couleurs utilisés dans cette vidéo : https://matplotlib.org/3.1.0/tutorials/colors/colormaps.html Sommaire de la formation:

# data[].attributes.attachment_link.title
Formation Python - Machine Learning 15/30 : Matplotlib, les 5 graphiques les plus cool - Actu IA

# data[].attributes.attachment_link.description
Tutoriel français python matplotlib pour apprendre comment tracer des graphiques cools et utiles avec matplotlib ! Parmi ces graphiques on retrouvera les graphiques 3D, plt scatter, l'histogramme, le contour plot et bien sur imshow qui permet de visualiser n'importe quelle matrice numpy ! Python est vraiment facile et ce tutoriel français matplotlib va vous le...

# data[].attributes.attachment_link.title
Algorithmique et programmation - Mathématiques - Éduscol

# data[].attributes.attachment_link.description
Java's Cool (alias Javascool) est un logiciel libre conçu par l'INRIA pour l'apprentissage des bases de la programmation. Il permet de manipuler un Macro-Langage de programmation, basé sur le langage Java. Il a été créé pour apprendre aux personnes qui savent juste allumer leur ordinateur à programmer, par exemple des jeux (en 2D) ou des minis-logiciels.

# data[].attributes.attachment_link.description
EduPython est un environnement de développement Python gratuit permettant une prise en main rapide, qui simplifier la programmation en Python pour les élèves et les débutants.

# data[].attributes.attachment_link.readable_text
We're sorry this site works best with Javascript enabled browsers.
Forms and other actions may not work properly.

Individual Edition

With over 20 million users worldwide, the open-source Individual Edition (Distribution) is the easiest way to perform Python/R data science and machine learning on a single machine. Developed for solo practitioners, it is the toolkit that equips you to work with thousands of open-source packages and libraries.

Anaconda Individual Edition is the world's most popular Python distribution platform with over 20 million users worldwide. You can trust in our long-term commitment to supporting the Anaconda open-source ecosystem, the platform of choice for Python data science.

Search our cloud-based repository to find and install over 7,500 data science and machine learning packages. With the conda-install command, you can start using thousands of open-source Conda, R, Python and many other packages.

Individual Edition is an open source, flexible solution that provides the utilities to build, distribute, install, update, and manage software in a cross-platform manner. Conda makes it easy to manage multiple data environments that can be maintained and run separately without interference from each other.

Build machine learning models

Build and train machine learning models using the best Python packages built by the open-source community, including scikit-learn, TensorFlow, and PyTorch.

Get Started

The open-source community at your fingertips

With Anaconda Individual Edition, the open-source world is your oyster. From robotics to data visualization, you can access the open-source software you need for projects in any field.

Open Source

User interface makes learning easier

Anaconda Navigator is a desktop GUI that comes with Anaconda Individual Edition. It makes it easy to launch applications and manage packages and environments without using command-line commands.

Expedite your data science journey with easy access to training materials, documentation, and community resources including Anaconda.org.

Install Anaconda

Anaconda for the enterprise

With Anaconda's Team and Enterprise Editions, our stack can handle the most advanced enterprise data science requirements.

See Products

What is Anaconda used for?

Getting started with Anaconda

Expedite your data science journey with easy access to training materials, documentation, and community resources including Anaconda Cloud.

Anaconda Installers

Supercharge your data science efforts with Anaconda .
Get Started

This website uses cookies to ensure you get the best experience on our website. Privacy Policy

# data[].attributes.attachment_link.description
Anaconda's open-source Individual Edition is the easiest way to perform Python/R data science and machine learning on a single machine.

# data[].attributes.attachment_link.description
Trinket lets you run and write code in any browser, on any device.

# data[].attributes.attachment_link.readable_text
Skip to content

Build software collaboratively with the power of AI, on any device, without spending a second on setup

Join 20 million software creators building on Replit

Generate, edit, and explain code with Replit AI. Collaborate in our real-time multiplayer editor. Build, test, and deploy directly from the browser.

"Tightly integrated code generation, editing and output - well executed. Sets a high bar for computing education."

"The team at Replit are on fire as always - constantly seeing initiatives like this coming out that make me so excited to get coding and bring new ideas into my workshops and lessons 🔥"

"What Replit is doing in the DevEx space is a truly revolution and it will change how we develop apps."

"Lately, every time I open Replit, something new is added. I can really appreciate Replit when I think of the tremendous development costs I would have incurred if I had to make something like this myself."

"Replit has fulfilled my dreams of making tinkering with my code from my phone both viable and fun."

Code faster with AI

Built right into the editor, Replit AI enables you to debug, autocomplete, and turn natural language into code with one-click.

# data[].attributes.attachment_link.title
Replit: The software creation platform. IDE, AI, and Deployments

# data[].attributes.attachment_link.description
Run code live in your browser. Write and run code in 50+ languages online with Replit, a powerful IDE, compiler, & interpreter.

# data[].attributes.attachment_link.readable_text
Création d'une classe

Lorsqu'on dispose d'un compte sur l'environnement de programmation Python en ligne repl.it et qu'on est connecté, on peut cliquer sur l'onglet *teacher* puis créer une classe :

Inviter des élèves

À l'intérieur de la nouvelle classe, on peut inviter des élèves en cliquant sur le bouton *invite more*. Le plus simple est de leur communiquer l'adresse du lien d'invitation directe *Direct invitation link*. Ce lien va les diriger vers la classe (en les faisant éventuellement passer par le formulaire de création de compte la première fois) :

Distribuer un devoir

Bien sûr, avant d'inviter les élèves, on aura pris soin de créer un devoir à réaliser (*assignement*).

Voici un exemple :

Les élèves trouveront ce devoir dans l'espace classe, pourront y travailler puis enregistrer leurs travaux.

L'ensemble des travaux des élèves sera alors automatiquement visible pour le professeur, qui pourra vérifier et annoter les productions individuellement. Chaque étape de ce processus est notifiée par un mail permettant de ne rien manquer des activités de chacun.

# data[].attributes.attachment_link.title
Python : Proposer des exercices à la classe

# data[].attributes.attachment_link.description
Lorsqu'on dispose d'un compte sur l'environnement de programmation Python en ligne repl.it et qu'on est connecté, on peut cliquer sur l'onglet *teacher* puis créer une classe : À l'intérieur de la nouvelle classe, on peut inviter des élèves en cliquant sur le bouton *invite more*.

# data[].attributes.attachment_link.readable_text
Thonny 4 is dedicated to Ukraine fighting the Russian invasion.
🇺🇦 Please support Ukraine! 🇺🇦

Features

Demo

Credits

From 2014 to 2018 the main development of Thonny took place in Institute of Computer Science of University of Tartu, Estonia.

Since September 2018 development of Thonny is partially supported by Cybernetica AS.

Development of several features in Thonny 3.0 and 3.3 was proposed and supported by Raspberry Pi Foundation.

We are also grateful for the help of several contributors from the open-source community around the world.

Instructions & downloads

Latest stable releases are linked in the download box at the top of this page. Older releases and prereleases can be found at https://github.com/thonny/thonny/releases

Plug-ins

Thonny has simple infrastructure for extensions.

These are some known Thonny plug-ins:

Note that Thonny developers are neither endorsing nor responsible for these plug-ins!

Contact & News

Papers

# data[].attributes.attachment_link.description
Thonny 4 is dedicated to Ukraine fighting the Russian invasion. 🇺🇦 Please support Ukraine! 🇺🇦 From 2014 to 2018 the main development of Thonny took place in Institute of Computer Science of University of Tartu, Estonia. Since September 2018 development of Thonny is partially supported by Cybernetica AS.

# data[].attributes.attachment_link.description
Pyzo is a free and open-source computing environment based on Python. If you're used to e.g. Matlab, Pyzo can be considered a free alternative. Pyzo is a Python IDE that works with any Python interpreter installed on your system, including Conda environments.

# data[].attributes.attachment_link.title
Programme de mathématiques de 2nde générale et technologique

# data[].attributes.attachment_link.title
Programme de spécialité mathématiques de 1ère générale

# data[].attributes.headline
Programme de spécialité maths en terminale

# data[].attributes.subject
Programme de spécialité maths en terminale

# data[].attributes.attachment_link.title
Programme de spécialité de mathématiques de terminale générale

# data[].attributes.attachment_link.title
Programme de maths complémentaires en terminale générale

# data[].attributes.attachment_link.title
Programme de maths expertes en terminale générale

# data[].attributes.headline
Algorithme et programmation - Lien vers le dossier complet (et autres ressources)

# data[].attributes.subject
Algorithme et programmation - Lien vers le dossier complet (et autres ressources)

# data[].attributes.attachment_link.provider_name
éduscol | Ministère de l'Éducation nationale, de la Jeunesse et des Sports - Direction générale de l'enseignement scolaire

# data[].attributes.attachment_link.readable_text
Programmes en vigueur

Les programmes de mathématiques en seconde générale et technologique et STHR, en première technologique, de spécialité en première générale sont définis par arrêtés du 17-1-2019 publiés au BO spécial n° 1 du 22 janvier 2019.

Les programmes de mathématiques en terminale technologique, de spécialité et optionnels en terminale générale sont définis par arrêtés du 19-7-2019 publiés au BO spécial n° 8 du 25 juillet 2019.

Nota : Vous pouvez également consulter les programmes et ressources en enseignement scientifique.

# data[].attributes.attachment_link.title
Programmes et ressources en mathématiques - voie GT

# data[].attributes.attachment_link.description
Les programmes de mathématiques en seconde générale et technologique et STHR, en première technologique, de spécialité en première générale sont définis par arrêtés du 17-1-2019 publiés au BO spécial n° 1 du 22 janvier 2019. Les programmes de mathématiques en terminale technologique, de spécialité et optionnels en terminale générale sont définis par arrêtés du 19-7-2019 publiés au BO spécial n° 8 du 25 juillet 2019.

# data[].attributes.attachment_link.readable_text
Une ressource : Python

Des tutoriels pour apprendre à parler Python.

Le langage Python correspond parfaitement à la demande des aménagements de programme de 2 de qui précisent (sans le nommer) qu'il faudra utiliser un langage textuel.

Un document ressources - qui mentionne clairement Python - vient de paraître sur le thème " algorithmique et programmation " (PDF, environ 1,2 Mo) et donne également des pistes pour passer de Scratch à Python. Il est destiné à la formation des professeurs.

On pourra également consulter le site mathématiques de l'académie de Bordeaux propose une sélection de cours en lignes, tutoriels et autres ressources pour développer, découvrir ou perfectionner la manipulation de ce langage.

À noter également : EduPython et AmiensPython, notamment pour la bibliothèque " lycée ". Ne pas hésiter à consulter les documentations de ces logiciels (disponibles sur leurs sites, dans la partie enseignants), très bien faites.
Retour aux articles

# data[].attributes.attachment_link.title
Une ressource : Python - Mathématiques - Éduscol

# data[].attributes.attachment_link.description
Des tutoriels pour apprendre à parler Python. Le langage Python correspond parfaitement à la demande des aménagements de programme de 2 de qui précisent (sans le nommer) qu'il faudra utiliser un langage textuel.

# data[].attributes.attachment_link.description
Activités autour du nouveau programme de mathématiques et de sa partie Algorithmique et programmation

# data[].attributes.headline
Lien vers les ressources cycle 4 - dossier complet

# data[].attributes.subject
Lien vers les ressources cycle 4 - dossier complet

# data[].attributes.attachment_link.provider_name
éduscol | Ministère de l'Éducation nationale et de la Jeunesse - Direction générale de l'enseignement scolaire

# data[].attributes.attachment_link.title
Ressources d’accompagnement du programme de mathématiques (cycle 4)

# data[].attributes.attachment_link.description
Ressources d’accompagnement du programme de cycle 4.

# data[].attributes.attachment_link.description
Cette section vous propose plusieurs fiches d'activités à faire en classe ou à la maison pour appréhender le langage Python. Elle sera enrichie au cours du temps par de nouvelles activités pratiques à réaliser.

# data[].attributes.attachment_link.readable_text
Les sites Web de TI utilisent des cookies pour optimiser leur fonctionnalité et améliorer votre expérience. Pour en savoir plus ou pour modifier vos préférences, visitez notre page sur la politique d'utilisation des cookies. Cliquez sur Accepter et poursuivre pour accepter les cookies et accéder au site.

# data[].attributes.attachment_link.description
Les sites Web de TI utilisent des cookies pour optimiser leur fonctionnalité et améliorer votre expérience. Pour en savoir plus ou pour modifier vos préférences, visitez notre page sur la politique d'utilisation des cookies. Cliquez sur Accepter et poursuivre pour accepter les cookies et accéder au site.

# data[].attributes.attachment_link.title
24.5. turtle - Turtle graphics for Tk - Python 2.7.15 documentation

# data[].attributes.attachment_link.description
The procedural interface provides functions which are derived from the methods of the classes and . They have the same names as the corresponding methods. A screen object is automatically created whenever a function derived from a Screen method is called.

# data[].attributes.attachment_link.readable_text
Les bases

Modules standards

Modules non standards

> Modules non standards > Matplotlib > Introduction à matplotlib

Matplotlib : c'est une librairie qui permet de tracer des graphes (dans le sens graphiques) :

inspiré de Matlab au départ.

inclus 2 façons de l'utiliser :

soit avec une approche objet : plus compliquée et plus verbeuse, mais plus évoluée.

soit via des appels de fonctions, avec pyplot : plus simple. pyplot fournit ainsi des raccourcis qui évitent la formulation objet plus longue à écrire.

permet de faire des graphes qui peuvent être comlètement adaptés si besoin. Sur une figure, on peut tracer plusieurs graphes.

permet aussi de dessiner.

matplotlib rend ainsi possible la création de graphes à l'intérieur d'applications complexes autorisées par le langage python, et ceci sans quitter le langage python.

Notions principales pour les graphes sous matplotlib :

figure : une figure qui peut être sauvée dans un fichier.

axe : un graphe (graphique) individuel appartenant à une figure qui peut en compter plusieurs. Attention, ce n'est pas un axe de coordonnées !

axis : un axe de coordonnées appartenant à un objet axe.

divers objets graphiques qui dérivent de la classe Artist et qui participent au graphe. Ce sont par exemple des rectangles, des lignes, du texte. Ces différents objets peuvent être totalement configurés (y compris individuellement) pour adapter le graphe aux besoins en appelant dessus des méthodes pour modifier leurs propriétés !

programmer en python, tutoriel python, graphes en python, Aymeric Duclert

# data[].attributes.attachment_link.description
Les bases Modules standards Modules non standards > Modules non standards > Matplotlib > Introduction à matplotlib Matplotlib : c'est une librairie qui permet de tracer des graphes (dans le sens graphiques) : inspiré de Matlab au départ. inclus 2 façons de l'utiliser : soit avec une approche objet : plus compliquée et plus verbeuse, mais plus évoluée.

# data[].attributes.attachment_link.readable_text
S'intéresser à la fréquence d'apparition des lettres dans un texte sert principalement à déchiffrer un texte codé par substitution. Cette technique n'est plus utilisée car elle ne résiste pas à l'analyse fréquentielle et à la puissance des ordinateurs. On arrive, après analyse fréquentielle et différents tests à retrouver le texte initial. Plusieurs options, pour le chiffrement comme pour le décodage, sont possibles : [
prise en compte ou pas de la ponctuation ;
remplacement ou suppression des caractères accentués ; 1]
prise en compte des chiffres ;
remplacement ou suppression des ç, €, %, &, (),[], œ, ...
Le type de document analysé a aussi son importance, si c'est un texte technique, un roman, un texte narratif. Sa longueur est également un critère important, plus il est long, plus il est théoriquement sensé donner des fréquences correspondant au modèle, nous utiliserons le résultat suivant, pour un texte en langue française :
e:14,2% ; a:8,3% ; i:7,7% ; s:7,6% ; n:7,5% ; r:7,1% ; t:6,9% ; o:5,9% ; l:5,8% ; u:5,3% ; d:4,3% ; c:3,7% ; m:3,1% ; p:2,9% ; g:1,4% ; b:1,3% ; v:1,3% ; h:1,3% ; f:1,3% ; q:0,8% ; y:0,5% ; x:0,4% ; j:0,4% ; k:0,3% ; w:0,2% ; z:0,2%.
Nous nous intéresserons donc à des textes codés uniquement avec des lettres minuscules.
Soit le texte codé suivant :

Tous les caractères autres que ceux de l'alphabet classique ont été enlevés et les majuscules ont été remplacées par des minuscules à l'aide des deux fonctions suivantes :

Utilisation :

Pour illustrer notre propos, nous avons utilisé un texte plus long, enregistré dans un fichier texte nommé "texte_analyse.txt" avec le code suivant :

Le texte a ensuite été transformé (le résultat est dans le cadre ci-dessus) à l'aide d'un chiffrement affine qui peut ne pas être expliqué aux élèves, selon le script suivant :

Le code ci-dessus transforme le code ascii de chaque lettre en un nombre compris entre 0 et 25, ce nombre est transformé par la fonction affine $f(x) = mx + p$, puis ramené à un nombre compris entre 0 et 25, transformé en code ascii d'une lettre minuscule en ajoutant 97. Ce codage affine ne fonctionne pas si m et 26 ne sont pas premiers entre eux car plusieurs lettres sont alors codées par la même lettre. Si $m=1$, on retrouve le chiffrement de César qui consiste en un simple décalage des lettres (a -> e, b ->f, c ->g, ...).
Cette fonction sert aussi de fonction de décodage, en effet si $y \equiv mx + p [26]$ alors $y - p \equiv mx [26]$ et $x \equiv m^{-1}y - m^{-1}p [26]$ où $m^{-1}$ est tel que $mm^{-1} \equiv 1 [26]$, c'est-à-dire que $m^{-1}$ est l'inverse modulaire de $m$ modulo 26 (Par exemple : 9 est l'inverse modulaire de 3 car $9\times 3 = 27 \equiv 1 [26]$). On peut alors décoder le texte avec codage_affine(texte,$m^{-1},- m^{-1}p$).
Procédons maintenant au décryptage du texte codé, commençons par l'analyse fréquentielle d'apparition des lettres dans ce texte, à l'aide du script suivant :

Utilisation :

Au vu des résultats ci-dessus, on conjecture que c'est la lettre "x" qui code la lettre "e", on procède alors au changement de la lettre "x" par la lettre "e" dans le texte codé, sauf que si on fait cela on ne va plus distinguer le "e" codé du "e" décodé, on va donc procéder au changement de la lettre "x" par la lettre "E" dans le texte codé afin de faire la distinction. Ceci à l'aide du code suivant :

Ce qui donne comme résultat :

Rien dans le résultat ne nous permet de dire si cette conjecture est vraie ou fausse, continuons en gardant cette permutation.
On conjecture alors que c'est la lettre "n" qui code la lettre "a", on procède au changement de lettre dans le texte et on obtient :

La suite de lettre "EAEA" nous laisse à penser que ce n'est pas la bonne solution.
On conjecture alors que c'est la lettre "q" qui code la lettre "a", on procède au changement de lettre dans le texte et on obtient :

La suite de lettre "EAAE" nous laisse à penser que ce n'est pas la bonne solution.
On conjecture alors que c'est la lettre "l" qui code la lettre "a", on procède au changement de lettre dans le texte et on obtient :

Rien dans le résultat ne nous permet de dire si cette conjecture est vraie ou fausse, continuons en gardant cette permutation.
Et ainsi de suite, jusqu'au résultat final :

En rajoutant "à la main" les espaces et la ponctuation :
"L'ANALYSE FRÉQUENTIELLE OU ANALYSE DE FRÉQUENCES EST UNE METHODE DE ..."

Le fichier qui contient le texte initial en français.

Pour un texte en Anglais :
la procédure est exactement la même avec le tableau des fréquences d'apparition des lettres en Anglais :

Donc les lettres les plus fréquentes arrivent dans cet ordre : ETAONISRH ...
Soit le texte suivant à décoder :

On obtient alors :

On procède alors au changement de lettres "f" -> "E", "g" -> "T" et "d" -> "A" qui ne montrent pas d'incohérences. En suivant l'ordre logique, le changement suivant est "q" -> "O" et, en cherchant des incohérences, je constate que si on remplace "a" par "H", on voit apparaitre de nombreux "THE" et "THAT", ce qui semble être une bonne chose, le texte "TAOAO" m'incite à procéder au changement "q" -> "N". Le texte présente de nombreux "zz" voire "zzz" ce qui conduit à procéder au changement "z" -> "S" puis "h" -> "I", "x" -> "O" et "s" -> "R". On a alors placé toutes les lettres aux fréquences les plus importantes. On intuite ensuite les changements "e" -> "P", "t" -> "G", "j" -> "M", "c" -> "L", "y" -> "D", "p" -> "Y", "v" -> "K", "b" -> "W", "n" -> "U", "l" -> "Q", "o" -> "J", "i" -> "X" en complétant des mots partiellement découverts.

Le fichier qui contient le texte initial en anglais.

# data[].attributes.attachment_link.title
Les algorithmes du programme de spécialité mathématiques de Première (2019). - Les nouvelles technologies pour l'enseignement des mathématiques

# data[].attributes.attachment_link.description
S'intéresser à la fréquence d'apparition des lettres dans un texte sert principalement à déchiffrer un texte codé par substitution. Cette technique n'est plus utilisée car elle ne résiste pas à l'analyse fréquentielle et à la puissance des ordinateurs. On arrive, après analyse fréquentielle et différents tests à retrouver le texte initial.

# data[].attributes.attachment_link.readable_text
Parce que les graphiques c'est cool
Lecture zen

Vous connaissez le langage Python et vous avez envie de l'utiliser pour dessiner ou pour faire des graphiques et dessins.

Ici, nous verrons rapidement le module pyplot de la bibliothèque matplotlib qui nous permettra de faire des graphes.

Pour cela, nous allons nous donner un objectif : créer une fonction qui nous permettra de tracer la courbe représentative de n'importe quelle fonction passée en paramètre.

Nous allons donc introduire tout le long du tutoriel les fonctionnalités du module pour finir par faire notre super fonction.

Prérequis
Connaissance des bases du Python (un tutoriel est disponible ici).

Objectifs
Présenter rapidement le module pyplot en apprenant à tracer des courbes de fonctions mathématiques.

matplotlib.pyplot, le module qu'il nous faut

Commençons par le début, présentons matplotlib. Il s'agit sûrement de l'une des bibliothèques python les plus utilisées pour représenter des graphiques en 2D. Elle permet de produire une grande variété de graphiques et ils sont de grande qualité.

Le module pyplot de matplotlib est l'un de ses principaux modules. Il regroupe un grand nombre de fonctions qui servent à créer des graphiques et les personnaliser (travailler sur les axes, le type de graphique, sa forme et même rajouter du texte). Avec lui, nous avons déjà de quoi faire de belles choses.

Le fonctionnement de matplotlib est très semblable à celui de matlab. Le fonctionnement, et même les noms des fonctions par exemple, sont quasiment toujours les mêmes.

Il est maintenant temps de l'installer.

Installation sous Linux

C'est sans doute sous Linux que matplotlib est le plus simple à installer. Il suffit d'utiliser son gestionnaire de paquets (en ligne de commande ou en graphique). Voici quelques exemples de commande d'installation.

Utiliser le gestionnaire de paquets est la méthode la plus simple mais nous pouvons également utiliser le programme pip (qui est souvent installé par défaut) en entrant cette commande dans un terminal.

Il se chargera d'installer toutes les dépendances nécessaires au bon fonctionnement de matplotlib.

Installation sous Windows

Sous Windows, la meilleure façon d'installer matplotlib est d'utiliser pip et de s'aider de ce site. Il référence les différentes dépendances à installer et donne également un lien pour les installer (toujours avec pip). Il faut juste télécharger la version associée à votre version de Python et à son architecture (32 ou 64 bits). Certaines dépendances ont des dépendances, mais très peu. Pour avoir le moins de risques d'erreurs possibles, nous conseillons de les installer à la main. Dans l'ordre nous allons installer :

numpy ;

scipy (ce n'est pas une obligation, mais il est très utile) ;

six qui est une dépendance de dateutil ;

dateutil ;

pitz (le site de pitz propose des fichiers .egg à installer avec la commande easy_install nom_fichier.egg) ;

setuptools ;

et pour finir matplotlib.

Ouvrir une fenêtre

Tout d'abord, importons le module pyplot. La plupart des gens ont l'habitude de l'importer en tant que plt et nous ne dérogerons pas à la règle. On place donc cette ligne au début de notre fichier.

La première commande que nous allons voir dans ce module s'appelle show. Elle permet tout simplement d'afficher un graphique dans une fenêtre. Par défaut, celui-ci est vide. Nous devrons utiliser d'autres commandes pour définir ce que nous voulons afficher.

Finalement, voici notre premier code.

Mais, il fait rien le code. Qu'est-ce qui se passe ?

En fait, la commande show sert bien à ouvrir la fenêtre, à " show " donc montrer ce que l'on a fait précédemment. Mais nous n'avons rien fait. Nous devons alors introduire une troisième commande, la commande plot. Finalement, voici notre vrai premier code.

Voilà, notre fenêtre s'ouvre bien devant nos yeux émerveillés. Nous pouvons regarder les options offertes par la fenêtre dans le menu horizontal (zoom, déplacement, enregistrement en tant qu'image...).

La fonction show est bloquante. Tant que la fenêtre n'a pas été fermée, le reste du code ne s'exécute pas.

Tracer des lignes brisées

Pour tracer des lignes, nous devons utiliser la commande plot du module pyplot. Elle peut ne prendre aucun argument comme nous venons de le voir, mais c'est bien avec des arguments qu'elle est utile. En effet, si nous lui passons une liste [a, b, c] en argument, elle reliera le points A(0, a) au point B(1, b) et ce point B au point C(2, c). En fait, nous fournissons les ordonnées dans une liste, et les abscisses, elles, sont automatiquement générées et vont de 0 à len(liste) - 1. Ainsi, le code suivant...

... Permet d'obtenir la droite passant par les points A(0, 0), B(1, 1) et C(2, 2).

Notre premier graphique.

Au contraire, le code...

... Permet d'obtenir la droite passant par les points A(0, 1), B(1, 0) et C(2, 2).

Une belle ligne brisée.

Tracer une figure

Cependant, nous pouvons aussi passer deux listes en arguments à plot. La première liste correspondra à la liste des abscisses des points que nous voulons relier et la seconde à la liste de leurs ordonnées. Ainsi, notre code précédent pourrait être le suivant.

Ceci nous permet alors de revenir au point de départ et de relier le dernier point au premier. Grâce à cela, nous pouvons dessiner des figures géométriques très facilement.

Essayons donc de dessiner le triangle ABC avec A(0, 0), B(1, 1) et C(-1, 1).

Et nous avons obtenu l'image suivante.

C'est un triangle ça ?

Pas très fermé comme triangle, hein ! En fait, c'est tout bête. Chaque point est relié au point le précédent ; donc, avec ce que nous avons écrit, nous ne relions pas le dernier point au premier. Il nous faut donc faire comme ça.

Et là, nous voyons apparaître notre triangle.

Enfin un triangle !

Nous pouvons également passer en paramètre à plot plusieurs listes pour avoir plusieurs tracés. Par exemple avec ce code...

... Nous obtenons trois figures en une. Nous aurions également pu obtenir ce résultat en utilisant trois fois la commande plot avant d'utiliser la commande show.

Le résultat reste le même.

Plusieurs courbes.

Amusons-nous un moment, dessinons des carrés, des losanges, des triangles... Et habituons-nous aux commandes.

Paramètres supplémentaires

C'est bien beau et tout ce qu'on a fait, mais nous avons parlé de personnalisation des graphiques. Il serait temps d'en parler. Et oui, c'est l'heure de voir quelques moyens de personnalisation.

Tout d'abord, pour rajouter un titre au graphique, il suffit d'utiliser la commande title en lui envoyant comme paramètre une chaîne de caractères.

Ensuite, la commande plot possède plusieurs autres paramètres. Voyons quelques-uns d'entre eux rapidement.

Notons qu'il est possible d'utiliser LaTeX pour écrire des mathématiques dans nos textes avec matplotlib. Par exemple, nous pouvons avoir le titre title = '$\alpha = f(\beta)$'. (Pour en savoir plus sur l'utilisation des mathématiques avec LaTeX, nous pouvons lire ce tutoriel).

color

Le paramètre color permet de changer la couleur du tracé. Cette couleur peut être donnée sous plusieurs formes.

Sous forme de chaîne de caractères représentant les noms (ou abréviations) pour les couleurs primaires, le noir et le blanc : b ou blue, g ou green, r ou red, c ou cyan, m ou magenta, y ou yellow, k ou black, w ou white. C'est quand même assez explicite, il suffit d'écrire les noms en anglais.

Sous la forme d'un tuple correspondant aux valeurs RGB de la couleur. Cependant, ce tuple doit contenir des valeurs entre 0 et 1 (il suffit alors de diviser les valeurs RGB par 255.0). Ainsi, ce sera color = (255 / 255.0, 0, 0) pour obtenir du rouge. Notons que nous pouvons ajouter une valeur (toujours entre 0 et 1) à ce tuple pour représenter la transparence alpha.

Sous la forme de chaîne de caractères représentant la couleur en notation hexadécimale. On aura donc color = '#00FF00' pour obtenir du vert.

Et les adeptes des nuances de gris pourront donner en paramètre une chaîne de caractères correspondant à l'intensité en gris. Par exemple color = '0.8' permet d'obtenir un gris pâle.

Nous avons donc plusieurs méthodes juste pour choisir une couleur.

Le style de ligne

Nous pouvons également changer le style des lignes en passant à la commande plot une chaîne de caractères. Les caractères acceptés et leur signification sont disponibles sur la documentation de la commande plot. Tous ces styles ne relient pas les points entre eux, certains ne font qu'afficher le signe à l'endroit où se situe le point. Présentons quelques caractères :

- est le style par défaut, il correspond à une ligne pleine ;

-- correspond à une ligne en pointillés ;

: correspond à une ligne formée de points ;

-. correspond à une ligne formée d'une suite de points et de tirets.

Ces caractères correspondent au paramètre linestyle. Nous pouvons aussi ajouter des marqueurs avec le paramètre marker qui rajoute alors un marqueur pour chaque point de votre graphique. Ce paramètre est aussi une chaîne de caractères. Voici quelques marqueurs : *, +, o.

Les chaînes de caractères représentant les marqueurs fonctionnent aussi avec le paramètre linestyle. Le contraire n'est pas vrai.

Nous pouvons également changer l'épaisseur du trait (ou des points) avec le paramètre lw (linewidth).

La grille

Nous pouvons ajouter une grille avec la fonction grid qui affiche un quadrillage en pointillés. Nous pouvons bien sûr changer le style de ce quadrillage.

Le paramètre axis nous permet de choisir quels axes doivent être quadrillés. Il peut prendre les valeurs both (les deux), x ou y.

Le paramètre color nous permet de choisir la couleur de l'axe. Il fonctionne de la même manière que le paramètre color de la fonction plot.

Le paramètre linewidth permet de choisir l'épaisseur des traits.

Le paramètre linestyle permet de choisir le style de quadrillage. Il peut prendre comme valeur (tout comme plot) -, --, :, -..

On a maintenant de quoi faire plusieurs styles de grilles.

Les axes

Nous pouvons effectuer plusieurs opérations sur les axes. Tout d'abord les légender :

xlabel permet de donner un nom à l'axe des abscisses ;

ylabel permet de donner un nom à l'axe des ordonnées.

Ces deux commandes prennent en paramètres le nom que l'on veut donner à l'axe.

On peut également " cadrer " les axes avec la commande axis qu'on utilise ainsi : plt.axis([xmin, xmax, ymin, ymax]).

Une question d'échelle

Lorsque nous dessinerons des graphiques, nous aurons affaire à un problème particulier : la déformation.

Pour l'introduire, essayons de dessiner un carré centré autour de l'origine du repère. Traçons le carré ABCD avec A(1, 0), B(0, 1), C(-1, 0) et D(0, -1). Le code logique pour tracer ce carré est le suivant.

Pourtant, en exécutant ce code, on se rend compte que... Notre carré n'est pas carré.

Les proportions c'est pas trop ça.

Cela est dû au fait que le repère choisi n'est pas orthonormal. Pour rendre le repère orthonormal, nous pouvons utiliser la fonction axis en lui passant comme paramètre la chaîne de caractère 'equal'. Finalement, voici le code obtenu.

Et on obtient notre carré.

Un carré bien carré.

Voilà. C'est la fin de cette partie. Il nous faut maintenant pratiquer tout ce que nous avons vu, nous en aurons besoin pour la partie suivante.

Voici un code qui utilise ce qu'on a vu pour afficher un beau sapin vert.

Mon beau sapin.

Maintenant que nous avons vu comment utiliser le module pyplot, nous allons l'utiliser pour tracer des fonctions sur un intervalle donné.

La méthode secrète

Vous vous demandez sûrement comment nous allons faire pour tracer des fonctions. L'astuce est très simple. Nous allons relier des points dont nous savons qu'ils appartiennent à la courbe. Par exemple, pour tracer la fonction cosinus sur l'intervalle [0, 2π], nous allons relier les point A(0, cos(0)) et B(2π, cos(2π)).

Mais c'est nul ta méthode. On a essayé et on obtient juste une droite. Comment tu fais, toi, pour avoir une courbe ?

Oui, nous obtenons juste une droite, et c'est bien normal, nous avons juste relié deux points. Pour obtenir la courbe (en tout cas l'approcher), nous allons relier des points très proche qui appartiennent à la courbe. Par exemple, nous pouvons couper l'intervalle en 100 et donc relier 101 points plutôt que deux points. On appelle cela, subdiviser l'intervalle.

Notre subdivision sera à pas constant (le pas $\delta$ est l'espace entre deux points de la subdivision). Le pas est donc égal à la longueur de l'intervalle divisé par le nombre $n$ de points de la subdivision.

$$ \delta = \frac{x_{max} - x_{min}}{n}. $$

Ainsi pour dessiner la fonction cosinus :

on coupe l'intervalle en $n$ tranches (on choisit par exemple $n = 100$) ;

le pas est donc $\delta = \frac{2\pi}{100}$ ;

on relie les points de la subdivision.

Nous pouvons remarquer qu'en divisant notre intervalle en 100 tranches, nous obtenons une subdivision de 101 points (les deux bornes de l'intervalle sont dans la subdivision).

Voici le code qui s'ensuit.

Là, nous obtenons une belle sinusoïdale.

La belle bleue.

Maintenant, essayons de dessiner la fonction logarithme.

Voici la correction.

Les fonctions discontinues ou à valeurs interdites

Cependant, la méthode précédente peut présenter quelques problèmes dans des cas particuliers. Pour bien le voir, essayons de dessiner la fonction inverse ($x \mapsto \frac{1}{x}$) sur l'intervalle [-1, 1].

On obtient  ce graphe.

La fonction inverse ?

C'est quoi cette droite verticale au milieu de l'écran ?

La fonction inverse n'est pas définie en 0. Normalement, nous aurions dû obtenir une erreur lorsque nous demandions 1 / abscisse et qu'abscisse valait 0. Cependant, les erreurs d'approximation de python font que l'on ne passe pas par 0 mais par un point proche.

Néanmoins, il ne reste pas moins vrai que la fonction inverse est fortement divergente au voisinage de 0. Elle tend vers $-\infty$ lorsque $x$ tend vers 0 par valeur négative mais tend au contraire vers $+\infty$ lorsque $x$ tend vers 0 en étant positif.

La droite que nous observons est donc une conséquence de cela. On relie un point qui a une ordonnée très négative (le premier point avant 0) à un autre point qui a une ordonnée très positive (le premier point après 0).

Pour éviter cela, on est obligé de dessiner la fonction en deux fois. Une fois avant 0 et une fois après. Finalement, notre code est le suivant.

Et il nous donne bien  cette courbe.

La fonction inverse.

Nous pouvons bien entendu le modifier pour par exemple avoir les deux bouts de courbes de la même couleur, ou changer les axes.

Avec numpy (facultatif)

Pour ceux qui connaissent le module numpy, sachez que plot accepte aussi ses modules, ce qui permet de faire ce que nous venons de faire plus simplement.

Pour la fonction cosinus, on peut alors écrire ce code.

Et pour la fonction inverse celui-là.

La fonction zplot minimale

Notre fonction zplot doit prendre comme paramètre :

l'intervalle [a, b] sur lequel dessiner la fonction ;

la fonction à dessiner ;

il peut être intéressant de pouvoir choisir le pas.

Ainsi, notre prototype est le suivant.

Maintenant, il ne reste plus qu'à faire ce que nous faisons depuis la partie précédente. Voici le code que nous finirons par obtenir.

Voilà. Avec cette fonction, il faut juste faire ceci pour avoir la courbe de la fonction cosinus sur [0, 2π] :

Oui d'accord, mais pour les fonctions qui ne sont pas définies, on fait comment ?

Là, nous avons deux possibilités :

définir la fonction ;

utiliser une fonction lambda.

Traçons la courbe de la fonction inverse sur l'intervalle [1, 10] des deux manières.

En définissant la fonction inverse, on obtient ce code.

Et avec la fonction lambda, on obtient ce code.

Nous le voyons, notre fonction zplot marche dans les deux situations.

Personnaliser zplot

Et grâce à ça, nous pouvons par exemple tracer la fonction cosinus avec des étoiles.

Et voilà le résultat.

La fonction cosinus en étoiles.

Notre fonction zplot pourrait être encore plus personnalisable. Nous pourrions afficher une grille par défaut, demander le nom de la courbe pour l'afficher en label, demander le nom des axes... Tout ça avec des nouveaux paramètres optionnels.

Voilà, c'est fini. Mais ce n'était qu'une introduction. Le module pyplot et surtout matplotlib peuvent faire beaucoup de choses.

Allez vers la documentation pour en apprendre plus.

Vous pouvez également décider d'en apprendre plus sur numpy ou encore d'utiliser d'autres bibliothèques de dessin. La bibliothèque seaborn par exemple est basée sur matplotlib et permet de dessiner des graphiques (en particulier statistiques). Dans tous les cas, ne restez pas sur vos acquis, nous avons tous beaucoup plus à apprendre.

Mes remerciements à Gabbro et à Kje pour leurs commentaires durant la bêta. Je remercie également artragis pour son aide et ses commentaires durant la validation.

# data[].attributes.attachment_link.title
Introduction aux graphiques en Python avec matplotlib.pyplot * Tutoriels * Zeste de Savoir

# data[].attributes.attachment_link.description
Lecture zen Vous connaissez le langage Python et vous avez envie de l'utiliser pour dessiner ou pour faire des graphiques et dessins. Ici, nous verrons rapidement le module pyplot de la bibliothèque matplotlib qui nous permettra de faire des graphes.

# data[].attributes.attachment_link.readable_text
The so-called CSV (Comma Separated Values) format is the most common import and export format for spreadsheets and databases. CSV format was used for many years prior to attempts to describe the format in a standardized way in RFC 4180. The lack of a well-defined standard means that subtle differences often exist in the data produced and consumed by different applications. These differences can make it annoying to process CSV files from multiple sources. Still, while the delimiters and quoting characters vary, the overall format is similar enough that it is possible to write a single module which can efficiently manipulate such data, hiding the details of reading and writing the data from the programmer.

The module implements classes to read and write tabular data in CSV format. It allows programmers to say, "write this data in the format preferred by Excel," or "read data from this file which was generated by Excel," without knowing the precise details of the CSV format used by Excel. Programmers can also describe the CSV formats understood by other applications or define their own special-purpose CSV formats.

See also

The Python Enhancement Proposal which proposed this addition to Python.

Module Contents

The module defines the following functions:

Return a reader object which will iterate over lines in the given csvfile. csvfile can be any object which supports the protocol and returns a string each time its method is called - file objects and list objects are both suitable. If csvfile is a file object, it should be opened with . 1 An optional dialect parameter can be given which is used to define a set of parameters specific to a particular CSV dialect. It may be an instance of a subclass of the class or one of the strings returned by the function. The other optional fmtparams keyword arguments can be given to override individual formatting parameters in the current dialect. For full details about the dialect and formatting parameters, see section Dialects and Formatting Parameters .

Each row read from the csv file is returned as a list of strings. No automatic data type conversion is performed unless the QUOTE_NONNUMERIC format option is specified (in which case unquoted fields are transformed into floats).

A short usage example:

Return a writer object responsible for converting the user's data into delimited strings on the given file-like object. csvfile can be any object with a method. If csvfile is a file object, it should be opened with 1. An optional dialect parameter can be given which is used to define a set of parameters specific to a particular CSV dialect. It may be an instance of a subclass of the class or one of the strings returned by the function. The other optional fmtparams keyword arguments can be given to override individual formatting parameters in the current dialect. For full details about the dialect and formatting parameters, see section Dialects and Formatting Parameters . To make it as easy as possible to interface with modules which implement the DB API, the value is written as the empty string. While this isn't a reversible transformation, it makes it easier to dump SQL NULL data values to CSV files without preprocessing the data returned from a cursor.fetch* call. All other non-string data are stringified with before being written.

A short usage example:

Associate dialect with name. name must be a string. The dialect can be specified either by passing a sub-class of , or by fmtparams keyword arguments, or both, with keyword arguments overriding parameters of the dialect. For full details about the dialect and formatting parameters, see section Dialects and Formatting Parameters .

Delete the dialect associated with name from the dialect registry. An is raised if name is not a registered dialect name.

Return the dialect associated with name. An is raised if name is not a registered dialect name. This function returns an immutable .

Returns the current maximum field size allowed by the parser. If new_limit is given, this becomes the new limit.

The module defines the following classes:

Create an object that operates like a regular reader but maps the information in each row to a whose keys are given by the optional fieldnames parameter.

The fieldnames parameter is a . If fieldnames is omitted, the values in the first row of file f will be used as the fieldnames. Regardless of how the fieldnames are determined, the dictionary preserves their original ordering.

If a row has more fields than fieldnames, the remaining data is put in a list and stored with the fieldname specified by restkey (which defaults to ). If a non-blank row has fewer fields than fieldnames, the missing values are filled-in with .

A short usage example:

Create an object which operates like a regular writer but maps dictionaries onto output rows. The fieldnames parameter is a of keys that identify the order in which values in the dictionary passed to the method are written to file f. The optional restval parameter specifies the value to be written if the dictionary is missing a key in fieldnames. If the dictionary passed to the method contains a key not found in fieldnames, the optional extrasaction parameter indicates what action to take. If it is set to , the default value, a is raised. If it is set to , extra values in the dictionary are ignored. Any other optional or keyword arguments are passed to the underlying instance.

Note that unlike the class, the fieldnames parameter of the class is not optional.

A short usage example:

The class is a container class relied on primarily for its attributes, which are used to define the parameters for a specific or instance.

The class defines the usual properties of an Excel-generated CSV file. It is registered with the dialect name .

The class defines the usual properties of an Excel-generated TAB-delimited file. It is registered with the dialect name .

The class defines the usual properties of a CSV file generated on UNIX systems, i.e. using as line terminator and quoting all fields. It is registered with the dialect name .

Analyze the given sample and return a subclass reflecting the parameters found. If the optional delimiters parameter is given, it is interpreted as a string containing possible valid delimiter characters.

Analyze the sample text (presumed to be in CSV format) and return if the first row appears to be a series of column headers.

The module defines the following constants:

Instructs objects to only quote those fields which contain special characters such as delimiter, quotechar or any of the characters in lineterminator.

Instructs the reader to convert all non-quoted fields to type float.

Instructs objects to never quote fields. When the current delimiter occurs in output data it is preceded by the current escapechar character. If escapechar is not set, the writer will raise if any characters that require escaping are encountered.

The module defines the following exception:

Raised by any of the functions when an error is detected.

Dialects and Formatting Parameters

To make it easier to specify the format of input and output records, specific formatting parameters are grouped together into dialects. A dialect is a subclass of the class having a set of specific methods and a single method. When creating or objects, the programmer can specify a string or a subclass of the class as the dialect parameter. In addition to, or instead of, the dialect parameter, the programmer can also specify individual formatting parameters, which have the same names as the attributes defined below for the class.

Dialects support the following attributes:

A one-character string used to separate fields. It defaults to .

Controls how instances of quotechar appearing inside a field should themselves be quoted. When , the character is doubled. When , the escapechar is used as a prefix to the quotechar. It defaults to .

A one-character string used by the writer to escape the delimiter if quoting is set to and the quotechar if doublequote is . On reading, the escapechar removes any special meaning from the following character. It defaults to , which disables escaping.

A one-character string used to quote fields containing special characters, such as the delimiter or quotechar, or which contain new-line characters. It defaults to .

Controls when quotes should be generated by the writer and recognised by the reader. It can take on any of the constants (see section Module Contents ) and defaults to .

Reader Objects

Reader objects ( instances and objects returned by the function) have the following public methods:

Return the next row of the reader's iterable object as a list (if the object was returned from ) or a dict (if it is a instance), parsed according to the current dialect. Usually you should call this as next(reader) .

Reader objects have the following public attributes:

DictReader objects have the following public attribute:

Writer Objects

objects ( instances and objects returned by the function) have the following public methods. A row must be an iterable of strings or numbers for objects and a dictionary mapping fieldnames to strings or numbers (by passing them through first) for objects. Note that complex numbers are written out surrounded by parens. This may cause some problems for other programs which read CSV files (assuming they support complex numbers at all).

Write the row parameter to the writer's file object, formatted according to the current dialect. Return the return value of the call to the write method of the underlying file object.

Changed in version 3.5: Added support of arbitrary iterables.

Write all elements in rows (an iterable of row objects as described above) to the writer's file object, formatted according to the current dialect.

Writer objects have the following public attribute:

DictWriter objects have the following public method:

Examples

The simplest example of reading a CSV file:

Reading a file with an alternate format:

The corresponding simplest possible writing example is:

Since is used to open a CSV file for reading, the file will by default be decoded into unicode using the system default encoding (see locale.getpreferredencoding() ). To decode a file using a different encoding, use the argument of open:

The same applies to writing in something other than the system default encoding: specify the encoding argument when opening the output file.

Registering a new dialect:

A slightly more advanced use of the reader - catching and reporting errors:

And while the module doesn't directly support parsing strings, it can easily be done:

Footnotes

# data[].attributes.attachment_link.title
csv - CSV File Reading and Writing - Python 3.8.0 documentation

# data[].attributes.attachment_link.description
The so-called CSV (Comma Separated Values) format is the most common import and export format for spreadsheets and databases. CSV format was used for many years prior to attempts to describe the format in a standardized way in RFC 4180 .

# data[].attributes.attachment_link.readable_text
This chapter describes some things you've learned about already in more detail, and adds some new things as well.

5.1. More on Lists

The list data type has some more methods. Here are all of the methods of list objects:

Extend the list by appending all the items from the iterable. Equivalent to .

Insert an item at a given position. The first argument is the index of the element before which to insert, so inserts at the front of the list, and is equivalent to .

Remove the first item from the list whose value is equal to x. It raises a if there is no such item.

Remove the item at the given position in the list, and return it. If no index is specified, removes and returns the last item in the list. (The square brackets around the i in the method signature denote that the parameter is optional, not that you should type square brackets at that position. You will see this notation frequently in the Python Library Reference.)

Return zero-based index in the list of the first item whose value is equal to x. Raises a if there is no such item.

The optional arguments start and end are interpreted as in the slice notation and are used to limit the search to a particular subsequence of the list. The returned index is computed relative to the beginning of the full sequence rather than the start argument.

Return the number of times x appears in the list.

Sort the items of the list in place (the arguments can be used for sort customization, see for their explanation).

An example that uses most of the list methods:

You might have noticed that methods like , or that only modify the list have no return value printed - they return the default . 1 This is a design principle for all mutable data structures in Python.

Another thing you might notice is that not all data can be sorted or compared. For instance, doesn't sort because integers can't be compared to strings and None can't be compared to other types. Also, there are some types that don't have a defined ordering relation. For example, isn't a valid comparison.

5.1.1. Using Lists as Stacks

The list methods make it very easy to use a list as a stack, where the last element added is the first element retrieved ("last-in, first-out"). To add an item to the top of the stack, use . To retrieve an item from the top of the stack, use without an explicit index. For example:

5.1.2. Using Lists as Queues

It is also possible to use a list as a queue, where the first element added is the first element retrieved ("first-in, first-out"); however, lists are not efficient for this purpose. While appends and pops from the end of list are fast, doing inserts or pops from the beginning of a list is slow (because all of the other elements have to be shifted by one).

To implement a queue, use which was designed to have fast appends and pops from both ends. For example:

5.1.3. List Comprehensions

List comprehensions provide a concise way to create lists. Common applications are to make new lists where each element is the result of some operations applied to each member of another sequence or iterable, or to create a subsequence of those elements that satisfy a certain condition.

For example, assume we want to create a list of squares, like:

Note that this creates (or overwrites) a variable named that still exists after the loop completes. We can calculate the list of squares without any side effects using:

or, equivalently:

which is more concise and readable.

A list comprehension consists of brackets containing an expression followed by a clause, then zero or more or clauses. The result will be a new list resulting from evaluating the expression in the context of the and clauses which follow it. For example, this listcomp combines the elements of two lists if they are not equal:

and it's equivalent to:

Note how the order of the and statements is the same in both these snippets.

If the expression is a tuple (e.g. the in the previous example), it must be parenthesized.

List comprehensions can contain complex expressions and nested functions:

5.1.4. Nested List Comprehensions

The initial expression in a list comprehension can be any arbitrary expression, including another list comprehension.

Consider the following example of a 3x4 matrix implemented as a list of 3 lists of length 4:

The following list comprehension will transpose rows and columns:

As we saw in the previous section, the nested listcomp is evaluated in the context of the that follows it, so this example is equivalent to:

which, in turn, is the same as:

In the real world, you should prefer built-in functions to complex flow statements. The function would do a great job for this use case:

See Unpacking Argument Lists for details on the asterisk in this line.

There is a way to remove an item from a list given its index instead of its value: the statement. This differs from the method which returns a value. The statement can also be used to remove slices from a list or clear the entire list (which we did earlier by assignment of an empty list to the slice). For example:

Referencing the name hereafter is an error (at least until another value is assigned to it). We'll find other uses for later.

5.3. Tuples and Sequences

We saw that lists and strings have many common properties, such as indexing and slicing operations. They are two examples of sequence data types (see Sequence Types - list, tuple, range ). Since Python is an evolving language, other sequence data types may be added. There is also another standard sequence data type: the tuple.

A tuple consists of a number of values separated by commas, for instance:

As you see, on output tuples are always enclosed in parentheses, so that nested tuples are interpreted correctly; they may be input with or without surrounding parentheses, although often parentheses are necessary anyway (if the tuple is part of a larger expression). It is not possible to assign to the individual items of a tuple, however it is possible to create tuples which contain mutable objects, such as lists.

Though tuples may seem similar to lists, they are often used in different situations and for different purposes. Tuples are , and usually contain a heterogeneous sequence of elements that are accessed via unpacking (see later in this section) or indexing (or even by attribute in the case of ). Lists are , and their elements are usually homogeneous and are accessed by iterating over the list.

A special problem is the construction of tuples containing 0 or 1 items: the syntax has some extra quirks to accommodate these. Empty tuples are constructed by an empty pair of parentheses; a tuple with one item is constructed by following a value with a comma (it is not sufficient to enclose a single value in parentheses). Ugly, but effective. For example:

The statement is an example of tuple packing: the values , and are packed together in a tuple. The reverse operation is also possible:

This is called, appropriately enough, sequence unpacking and works for any sequence on the right-hand side. Sequence unpacking requires that there are as many variables on the left side of the equals sign as there are elements in the sequence. Note that multiple assignment is really just a combination of tuple packing and sequence unpacking.

Python also includes a data type for sets. A set is an unordered collection with no duplicate elements. Basic uses include membership testing and eliminating duplicate entries. Set objects also support mathematical operations like union, intersection, difference, and symmetric difference.

Curly braces or the function can be used to create sets. Note: to create an empty set you have to use , not ; the latter creates an empty dictionary, a data structure that we discuss in the next section.

Here is a brief demonstration:

Similarly to list comprehensions , set comprehensions are also supported:

5.5. Dictionaries

Another useful data type built into Python is the dictionary (see Mapping Types - dict ). Dictionaries are sometimes found in other languages as "associative memories" or "associative arrays". Unlike sequences, which are indexed by a range of numbers, dictionaries are indexed by keys, which can be any immutable type; strings and numbers can always be keys. Tuples can be used as keys if they contain only strings, numbers, or tuples; if a tuple contains any mutable object either directly or indirectly, it cannot be used as a key. You can't use lists as keys, since lists can be modified in place using index assignments, slice assignments, or methods like and .

It is best to think of a dictionary as a set of key: value pairs, with the requirement that the keys are unique (within one dictionary). A pair of braces creates an empty dictionary: . Placing a comma-separated list of key:value pairs within the braces adds initial key:value pairs to the dictionary; this is also the way dictionaries are written on output.

The main operations on a dictionary are storing a value with some key and extracting the value given the key. It is also possible to delete a key:value pair with . If you store using a key that is already in use, the old value associated with that key is forgotten. It is an error to extract a value using a non-existent key.

Performing on a dictionary returns a list of all the keys used in the dictionary, in insertion order (if you want it sorted, just use instead). To check whether a single key is in the dictionary, use the keyword.

Here is a small example using a dictionary:

In addition, dict comprehensions can be used to create dictionaries from arbitrary key and value expressions:

When the keys are simple strings, it is sometimes easier to specify pairs using keyword arguments:

5.6. Looping Techniques

When looping through dictionaries, the key and corresponding value can be retrieved at the same time using the method.

It is sometimes tempting to change a list while you are looping over it; however, it is often simpler and safer to create a new list instead.

5.7. More on Conditions

The conditions used in and statements can contain any operators, not just comparisons.

The comparison operators and check whether a value occurs (does not occur) in a sequence. The operators and compare whether two objects are really the same object; this only matters for mutable objects like lists. All comparison operators have the same priority, which is lower than that of all numerical operators.

Comparisons may be combined using the Boolean operators and , and the outcome of a comparison (or of any other Boolean expression) may be negated with . These have lower priorities than comparison operators; between them, has the highest priority and the lowest, so that is equivalent to . As always, parentheses can be used to express the desired composition.

The Boolean operators and are so-called short-circuit operators: their arguments are evaluated from left to right, and evaluation stops as soon as the outcome is determined. For example, if and are true but is false, does not evaluate the expression . When used as a general value and not as a Boolean, the return value of a short-circuit operator is the last evaluated argument.

It is possible to assign the result of a comparison or other Boolean expression to a variable. For example,

Note that in Python, unlike C, assignment inside expressions must be done explicitly with the walrus operator . This avoids a common class of problems encountered in C programs: typing in an expression when was intended.

5.8. Comparing Sequences and Other Types

Sequence objects typically may be compared to other objects with the same sequence type. The comparison uses lexicographical ordering: first the first two items are compared, and if they differ this determines the outcome of the comparison; if they are equal, the next two items are compared, and so on, until either sequence is exhausted. If two items to be compared are themselves sequences of the same type, the lexicographical comparison is carried out recursively. If all items of two sequences compare equal, the sequences are considered equal. If one sequence is an initial sub-sequence of the other, the shorter sequence is the smaller (lesser) one. Lexicographical ordering for strings uses the Unicode code point number to order individual characters. Some examples of comparisons between sequences of the same type:

Note that comparing objects of different types with or is legal provided that the objects have appropriate comparison methods. For example, mixed numeric types are compared according to their numeric value, so 0 equals 0.0, etc. Otherwise, rather than providing an arbitrary ordering, the interpreter will raise a exception.

Footnotes

# data[].attributes.attachment_link.title
5. Data Structures - Python 3.8.2 documentation

# data[].attributes.attachment_link.description
This chapter describes some things you've learned about already in more detail, and adds some new things as well. The list data type has some more methods. Here are all of the methods of list objects: Extend the list by appending all the items from the iterable. Equivalent to .

# data[].attributes.attachment_link.description
Sololearn is the world’s largest community of people learning to code. With over 25 programming courses, choose from thousands of topics to learn how to code, brush up your programming knowledge, upskill your technical ability, or stay informed about the latest trends.

# data[].attributes.attachment_link.title
Premiers scripts en Python - toutatice.fr

# data[].attributes.attachment_link.description
Découvrir la notion de fonction, d'instruction conditionnelle et de boucle bornée

# data[].attributes.attachment_link.title
Progression sur les fonctions avec Python - toutatice.fr

# data[].attributes.attachment_link.description
Une progression en algorithmique permettant d'illustrer les fonctions

# data[].attributes.attachment_link.title
Progression en probabilités avec Python - toutatice.fr

# data[].attributes.attachment_link.description
Il faut bien sûr continuer à utiliser le tableur ou la calculatrice pour installer la notion de probabilité et diversifier les usages d'outils numériques. Des activités classiques comme "Surbooking" ont donc tout à fait leur place. Il existe par ailleurs une version avec prise d'initiative et sans simulation informatique imposée de l'activité Attention, l'utilisation de Python n'est pas exclusive !

# data[].attributes.attachment_link.readable_text
Cet article est une synthèse des notions de base du langage de programmation PYTHON. A la fin de cet article, à travers des tutoriels vidéos, nous vous proposons une prise en main progressive du langage de programmation PYTHON dans la perspective de son utilisation dans la cadre des nouveaux programmes de Physique-Chimie du lycée.

" Le codage et l'algorithmique pour l'enseignement de la physique-chimie "

" Le codage et l'algorithmique pour l'enseignement de la physique-chimie "

Pourquoi PYTHON dans les nouveaux programmes ?

Le choix du langage de programmation Python dans les nouveaux programmes de Physique-Chimie du lycée est tout sauf anodin. Python (version 3 ou supérieure) est un langage de programmation interprété généraliste, interactif, orienté objet et de haut niveau.
Il présente de nombreux avantages :

Il est open source ", gratuit, multi-plateformes, simple à apprendre et puissant .

Il est en outre le langage de programmation qui connaît ces dernières années la plus forte progression chez les programmeurs du monde entier en raison de sa simplicité, de sa puissance et de sa polyvalence grâce à de nombreuses bibliothèques spécialisées. Il est le langage de programmation préféré des scientifiques (mathématiciens, physiciens, chimistes, ingénieurs...) et des "Data Analyst".

La première version de PYTHON date de 1991 : elle est le fruit du travail du programmeur néerlandais Guido VAN ROSSUM.
EN SAVOIR PLUS SUR PYTHON : Meilleur langage en 2018 selon l'IEEE : Python conforte sa place de leader
Comment installer PYTHON ?

Nous recommandons d'utiliser avec vos élèves la dernière version de la distribution EDUPYTHON qui existe également sous la forme d'une version portable. Cette distribution utilise la branche 3.x de PYTHON.
> Installation d'EDUPYTHON sous Windows
Elle est classique et simple. Il suffit de télécharger la dernière version de l'exécutable et de suivre les instructions à l'écran.

ATTENTION : si EDUPYTHON est installé sur un PC intégré au réseau pédagogique d'un établissement scolaire, il faudra préciser l'IP du PROXY et son PORT lors de la première phase de l'installation.
> Installation d'EDUPYTHON sous MAC OS.
L'installation se déroule en trois étapes.

1) Installer XQuartz sur votre système MAC OS. XQuartz est nécessaire pour que Wine puisse fonctionner.
2) Installer la version stable de WineHQ sur votre système MAC OS. Wine vous permettra d'installer et de faire fonctionner sur votre MAC des logiciels Windows.
3) Télécharger l'exécutable Windows d'EDUPYTHON sur votre système MAC OS. Faire un clic droit sur l'icône "Wine" d'EDUPYTHON et choisir "Ouvrir avec Wine (stable)".
Le tutoriel vidéo suivant vous explique pas à pas comment installer EDUPYTHON sous MAC OS puis comment le lancer avec WINE. > L'interface d'EDUPYTHON
Lorsqu'on démarre EDUPYTHON on lance un IDE (Integrated Development Environment) c'est-à-dire un environnement de développement intégré. Deux zones sont à distinguer dans l'IDE :

l'éditeur, zone dans laquelle on entre les lignes de codes ;

l'interpréteur, zone dans laquelle les lignes de codes sont exécutées.

Après avoir entré les lignes de codes dans l'éditeur, on lance leur exécution grâce au bouton vert "Exécuter". On observe dans l'interpréteur le résultat de l'exécution des lignes de codes.

Installer d'autres distributions PYTHON

D'autres distributions PYTHON TM moins simples de prise en main existent. La distribution Open Source multiplateformes la plus complète pour le calcul scientifique est ANACONDA. Elle intègre de nombreux outils dont l'IDE PYTHON TM SPYDER mais est lourde à installer. Pour des usages avancés ou si vous éprouvez des difficultés à installer EDUPYTHON sur MAC OS ou GNU LINUX, cette distribution est toute indiquée. L'IDE PYZO ou THONNY sont également des alternatives intéressantes.

A la découverte de PYTHON
Les vidéos suivantes réalisées par David LATOUCHE (Lycée Saint-Exupéry, Mantes-la-Jolie) vous permettront d'acquérir progressivement les bases nécessaires à la programmation en PYTHON dans le cadre des nouveaux programmes de Physique-Chimie du lycée. Bonne découverte !
Pour aller plus loin...

Le "Memento" ci-dessous rappelle les éléments de base du langage de programmation PYTHON :

La bibliothèque matplotlib est dédiée au tracé des graphiques. Vous trouverez ci-dessous une fiche synthétique réalisée par Cédric GERLAND (Lycée Saint-Exupéry, Mantes-la-Jolie) résumant ses principales instructions :

Stéphane LEBLOND, technicien de laboratoire (Lycée Saint-Exupéry, Mantes-la-Jolie) propose une approche complète de PYTHON pour la physique-chimie (voir dossier complet en annexe).

Formation PYTHON pour la Physique-Chimie

# data[].attributes.attachment_link.description
Prise en main du langage de programmation PYTHON

# data[].attributes.attachment_link.readable_text
Introduction

Les académies qui ont participé aux TraAM 2018-2019 ont axé leurs productions sur la thématique du codage et de l'algorithmique pour l'enseignement de la physique-chimie.

Les six académies ayant contribué cette année à ce projet national ont élaboré différents types de scénarios pédagogiques, testés en classe, pour lesquels les objectifs de la pratique innovante, le contexte pédagogique, les outils ou fonctionnalités nécessaires ainsi que des exemples d'usages ont été définis. Les scénarios font également le bilan des apports et des freins rencontrés lors de la mise en œuvre en classe.

Les pages TraAM des académies

Synthèse des travaux

Collège
Des signaux pour observer et communiquer L'énergie et ses conservations Mouvement et interactions Organisation et transformations de la matière Transition écologique et développement durable
Lycée
Constitution et transformation de la matière Énergie Mouvement et interactions Ondes et signaux Radioactivité Sources de lumières colorées Signaux et capteurs Vision et image
Lycée pro
Livrer une installation
Supérieur
Traitement numérique du signal Mouvement et interactions Capsules vidéo
Conclusion

Dans le cadre des enseignements de physique-chimie, les élèves utilisent fréquemment des logiciels de simulation, d'acquisition ou de traitement de données basés sur des algorithmes et des programmes qui leur sont inconnus la plupart du temps.

En mettant au point des algorithmes en relation avec des problématiques de physique-chimie et en les programmant eux-mêmes, même modestement, les élèves peuvent dépasser cette logique de " boite noire ", démystifier ces outils et mieux appréhender les notions scientifiques qui sont mobilisées.

Les exemples d'usages proposés par les différents groupes académiques engagés dans les TraAM 2018-2019 permettent de s'éloigner de cette logique de " boite noire " inconnue. Les séquences pédagogiques réalisées intègrent des outils divers et variés : tableur-grapheur ; programmes en Python Arduino ou Scratch ; microcontrôleurs... L'introduction de ces différents outils s'est toujours fait au service de la physique et de la chimie.

Constitution du groupe de travail national

Les Travaux académiques mutualisés de physique-chimie 2018-2019 ont été menés à bien par le groupe de travail suivant :

Jean Cavailles (IGEN) ;
Le groupe d'experts de la DNE :

département du développement des usages et de la valorisation des pratiques (DNE-A2) : Sophie Edouard, David Latouche ;

département du développement et de la diffusion des ressources numériques (DNE-A1) : Christine Trabado.

Les académies impliquées et les professeurs référents :

Amiens : Perrine Gaffet ; Anne-Sophie Agbo-Sonan (IA-IPR) et Thouraya Abdellatif (IA-IPR) ;

Aix-Marseille : Sophie Maier ; Isabelle Tarride (IA-IPR) ;

Créteil : Thomas Lavarenne ; Claude Murcuillat (IA-IPR) ;

Lyon : Sarah Roques ; Marie-Alice Trossat (IA-IPR) ;

Strasbourg : Fabrice Maquère ; Philippe Martin (IA-IPR) ;

Versailles : Alban Goulley ; Annie Zentilin (IA-IPR) et Romain Salvan (IA-IPR).

# data[].attributes.attachment_link.title
Le codage et l\'algorithmique pour l\'enseignement de la physique-chimie (2018-2019) - Physique-Chimie - Éduscol

# data[].attributes.attachment_link.description
Les académies qui ont participé aux TraAM 2018-2019 ont axé leurs productions sur la thématique du codage et de l'algorithmique pour l'enseignement de la physique-chimie. Les six académies ayant contribué cette année à ce projet national ont élaboré différents types de scénarios pédagogiques, testés en classe, pour lesquels les objectifs de la pratique innovante, le contexte pédagogique, les outils ou fonctionnalités nécessaires ainsi que des exemples d'usages ont été définis.

# data[].attributes.attachment_link.provider_name
éduscol | Ministère de l'Éducation nationale et de la Jeunesse - Direction générale de l'enseignement scolaire

# data[].attributes.attachment_link.readable_text
Pour l'année scolaire 2020-2021, le GRIESP aborde la thématique de la prolongation hors du temps scolaire de la formation expérimentale des élèves. Il s'agit de montrer comment il est possible de renforcer les compétences expérimentales des élèves par une articulation entre le temps de formation expérimentale indispensable en classe et une activité, en amont ou en aval, réalisée à distance par les élèves.

Le GRIESP propose des séquences pédagogiques pour le collège, avec un accent mis sur le changement climatique et le développement durable, pour le lycée général et technologique et le lycée professionnel, en lien avec les nouveaux programmes de lycée.

# data[].attributes.attachment_link.title
Recherche et innovation pour l'enseignement des sciences physiques

# data[].attributes.attachment_link.description
Pour l'année scolaire 2020-2021, le GRIESP aborde la thématique de la prolongation hors du temps scolaire de la formation expérimentale des élèves. Il s'agit de montrer comment il est possible de renforcer les compétences expérimentales des élèves par une articulation entre le temps de formation expérimentale indispensable en classe et une activité, en amont ou en aval, réalisée à distance par les élèves.

# data[].attributes.headline
Les exemples d'algorithmes du lycée général, en Python

# data[].attributes.subject
Les exemples d'algorithmes du lycée général, en Python

# data[].attributes.attachment_link.readable_text
Pour des données réelles ou issues d'une simulation, lire et comprendre une fonction écrite en Python renvoyant la moyenne m, l'écart type s, et la proportion d'éléments appartenant à [m-2s,m+2s]
Les données issues d'une simulation peuvent être fabriquées l'une après l'autre dans une boucle (c'est ce qu'on fera en sections technologiques dans un autre article), mais pour homogénéiser les approches "données réelles" et "simulation", il convient de se poser la question " sur quoi ces fonctions doivent-elles porter ? ". Le type de Python le plus adapté à des statistiques est la liste ( tableau dans les autres langages de programmation) notée entre crochets. On propose donc de définir des fonctions moyenne, écart_type et proportion_2_sigmas s'appliquant à des listes de nombres et renvoyant des nombres (flottants).

Comme les listes prises en entrée sont des listes de nombres, il est possible de calculer

la somme des éléments de la liste (avec la fonction sum de Python)

le nombre d'éléments de la liste (avec la fonction len, abrégée de length, de Python)

la liste des carrés des éléments de la liste (avec la fonction map de Python, en "mappant" la fonction carré définie précédemment, sur la liste).

On arrive alors à

Explication de la fonction variance : ne construit pas la liste des carrés, mais un objet de type map. Il est donc nécessaire de convertir cet objet en liste (avec la fonction list) pour pouvoir se livrer à des calculs statistiques sur cet objet.

Remarque sur la définition de la variance : On connaît deux algorithmes classiques de calcul de la variance :

Moyenne des carrés des écarts à la moyenne (choisi en général comme définition) ;

La moyenne des carrés moins le carré de la moyenne (formule de Huygens, choisie en général comme propriété caractéristique).

Le mot " variance " ne figurant pas au programme de 2nde, on peut effectuer le choix que l'on veut, et définir la variance par la formule de Huygens. L'essentiel étant d'aller rapidement à la notion d'écart-type, qui est la racine carrée de la variance.

On remarque que les fonctions carré et racine définies dans l'onglet sur les fonctions, trouvent assez rapidement leur utilité.

Pour calculer la probabilité d'appartenance à un intervalle à 2σ près, on peut utiliser les fonctions précédentes ainsi :

Remarque : Les listes en compréhension permettent de faire plus court, mais elles n'apparaissent qu'au programme de 1ère générale. On a donc préféré faire comme en 1ère technologique, en créant une variable nombre_de_succès initialisée à 0 et incrémentée à chaque succès. La fréquence de succès est le quotient du nombre de succès par l'effectif total.
Lire et comprendre une fonction Python renvoyant le nombre ou la fréquence de succès dans un échantillon de taille n pour une expérience aléatoire à deux issues
La première question à se poser est " qu'est-ce qu'un échantillon ? ". Comme en 1ère seules les listes sont considérées, on va donc modéliser ici un échantillon par une liste. Et par souci de concision on va la décrire, osons-le, en compréhension :

Le fait qu'on construit une liste se voit aux crochets, qui dénotent les listes en Python. La partie garantit qu'il y a n valeurs dans la liste (elle est de longueur n, dans le jargon de Python). Mais que sont ces valeurs ? est un booléen, égal à si random() est inférieur à p et sinon. Cette technique sera utilisée dans le programme de 1ère technologique. La probabilité d'avoir est p justement. Et on est bien obligé de gérer ce second paramètre p puisque l'hypothèse d'équiprobabilité entre les deux issues ne figure pas dans le programme.

Il y a d'autres moyens d'obtenir un échantillon pour une expérience aléatoire à deux issues, par exemple lancer une punaise 1000 fois et écrire True si elle est tombée la pointe en haut, False sinon. Mais cela risque d'être vécu comme fastidieux par les élèves. La question essentielle ici est de savoir ce qu'on fait de l'échantillon une fois qu'il est constitué :

Pour avoir le nombre de succès, on demande à Python de compter les occurences de True dans l'échantillon. Pour avoir la fréquence des succès, on divise le nombre de succès par n qui se trouve être la taille de l'échantillon.

La théorie du pile ou face biaisé est de Jacques Bernoulli qui est aussi l'auteur d'autres algorithmes que l'on verra plus bas. Il cherchait avant tout à appliquer les mathématiques aux sciences sociales et le nombre de succès dans un échantillon est présent, entre autres, dans la théorie des suffrages.
Observer la loi des grands nombres à l'aide d'une simulation sur Python ou tableur
La loi des grands nombres dit, en substance, que si n grandit, la fréquence de succès se rapproche de p, en fluctuant à cause du hasard, mais de moins en moins. On peut la vérifier en affichant (avec print, horreur !) la fréquence de succès pour n de plus en plus grand :

(ici, la fréquence de "6" lorsqu'on lance un dé équilibré à 6 faces, se rapproche de 0,1666666... mais pas très vite).

Le résultat est assez convaincant :

Simuler N échantillons de taille n d'une expérience aléatoire à deux issues. Si p est la probabilité d'une issue et f sa fréquence observée dans un échantillon, calculer la proportion des cas où l'écart entre p et f est inférieur ou égal à 1/√(N)
Simuler N échantillons, c'est répéter N fois la simulation d'un échantillon. Pour cela, on boucle N fois, et dans la boucle on fait appel à la fonction fréquence_succès(n,p) définie plus haut, en incrémentant la variable normal uniquement si l'écart entre f et p est inférieur ou égal à 1/√(N) :

# data[].attributes.attachment_link.title
Les exemples d'algorithmes du nouveau lycée général, en Python - Les nouvelles technologies pour l'enseignement des mathématiques

# data[].attributes.attachment_link.description
Pour des données réelles ou issues d'une simulation, lire et comprendre une fonction écrite en Python renvoyant la moyenne m, l'écart type s, et la proportion d'éléments appartenant à [m-2s,m+2s] Les données issues d'une simulation peuvent être fabriquées l'une après l'autre dans une boucle (c'est ce qu'on fera en sections technologiques dans un autre article), mais pour homogénéiser les approches "données réelles" et "simulation", il convient de se poser la question " sur quoi ces fonctions doivent-elles porter ?

# data[].attributes.headline
Les algorithmes en première technologique 

# data[].attributes.subject
Les algorithmes en première technologique 

# data[].attributes.attachment_link.readable_text
identifier les entrées et les sorties d'une fonction ;
Prenons l'exemple de la loi de Bernoulli, on peut définir une fonction loi de Bernoulli de paramètre 0.7 :

Il n'y a pas d'entrée, et en sortie on obtient 1 si l'expérience est un succès, 0 sinon.
Si l'on veut définir une loi de Bernoulli de paramètre p (au lieu de 0.7), on prendra en entrée le paramètre p, la sortie étant la même que précédemment :

Si l'on veut répéter n fois l'expérience :

En entrée, on renseigne le nombre d'expériences n et la probabilité du succès p. En sortie, on récupère le nombre de succès.
structurer un programme en ayant recours aux fonctions. (Ceci est illustré partout dans l'article, nous n'en dirons pas plus ...)
Commentaires
L'accent est mis sur la programmation modulaire qui permet de découper une tâche complexe en tâches plus simples.
Prenons l'exemple du calcul de l'écart-type pour une liste de données, on peut programmer la fonction :

On peut aussi programmer les fonctions esperance et variance afin de les utiliser dans la fonction ecarttype et éventuellement de s'en servir par ailleurs :

traiter un fichier contenant des données réelles pour en extraire de l'information et l'analyser ;
Nous utiliserons un gros fichier de données issu du site de l' INSEE, sur les communes de France métropolitaine et de Corse, débarrassé des données incomplètes (pour les DOM-TOM) :

Nous traiterons ce fichier avec le module pandas qui est une librairie Python spécialisée dans l'analyse des données. Pour ma part, je l'utilise dans Spyder, mais cela est un détail à régler de votre côté ... Un objet de type "data frame" permet de réaliser de nombreuses opérations de filtrage, prétraitements, etc., préalables à la modélisation statistique.
Dans Spyder, on crée un fichier Python :

On obtient dans la console un extrait des données qui sont enregistrées dans 36568 lignes et 12 colonnes, des "..." indiquent les "trous" présents dans cet affichage :

Par rapport au fichier original, la colonne des index des lignes a été rajoutée à gauche.
Il est possible d'afficher toutes les données grâce à l'explorateur de variables :

Structure DataFrame
Une matrice DataFrame correspond à une matrice individus-variables où les lignes correspondent à des observations, les colonnes à des attributs décrivant les individus. Concernant notre fichier "villes_virgule.csv" : la première ligne correspond aux noms des champs (des variables) ; à partir de la seconde ligne, nous disposons des valeurs pour chaque enregistrement (individu, ici une commune). Dans ce qui suit, nous chargeons le fichier de données et nous procédons à quelques vérifications.
Si l'on demande le type de data :

Voyons maintenant l'architecture de la structure DataFrame :

La ligne d'en-tête et la colonne d'index ne sont pas comptées.
Pour afficher l'en-tête de toutes les colonnes :

On a donc le numéro du département, le nom de la commune, le code postal, le nombre d'habitants en 2010, le nombre d'habitants en 1999, le nombre d'habitants en 2012, la densité, la surface, la longitude, la latitude, l'altitude minimum et l'altitude maximum.
On peut récupérer les données statistiques de base pour chacune des colonnes :

Certaines des données ont plus ou moins d'intérêt selon le contexte, ici par exemple count correspond au nombre de données pour chaque colonne c'est-à-dire 36568 ...
On peut alors demander plus précisément les données pour une colonne précise :

Si l'on demande le calcul explicite de la moyenne :

Ou la population totale en 2010 :

Le nombre de communes par département :

data["dens"] est une liste, on peut donc lui appliquer toutes les méthodes des listes :

On peut accéder aux valeurs du DataFrame via des indices ou plages d'indice. La structure se comporte alors comme une matrice. La cellule en haut et à gauche est de coordonnées (0,0). Il y a différentes manières de le faire, l'utilisation de .iloc[,] constitue une des solutions les plus simples. N'oublions pas que Shape permet d'obtenir les dimensions (lignes et colonnes) du DataFrame :

Nous pouvons isoler les sous-ensembles d'observations répondant à des critères définis sur les champs. Nous utiliserons préférentiellement la méthode .loc[,] dans ce cadre. Par exemple si l'on veut toutes les données correspondant au code postal 34400 :

Si l'on veut les communes du Nord de l'Hérault :

pour visualiser l'évolution démographique des communes Héraultaises de plus de 10000 habitants en 1999 :

réaliser un tableau croisé de données sur deux critères à partir de données brutes.

On utilisera un second fichier, plus approprié, qui répertorie, selon leur ville de résidence, la LV2 étudiée par des lycéens :

On peut alors calculer les effectifs et les fréquences :

Et réaliser le tri croisé :

Ou avec la métode pivot_table(), qui donne exactement la même chose :
Suites numériques
Pour une suite déterminée de manière explicite :

Taper dans la console :

Pour une suite déterminée de manière récurrente :

Taper dans la console :

Pour une suite, définie de manière explicite, pour laquelle on cherche à partir de quel rang son terme devient supérieur à un seuil donné :

utilisation :

Le seuil de 1000 est dépassé au rang 74 avec $u_{74}=1008$.

Pour une suite, définie par récurrence, pour laquelle on cherche à partir de quel rang son terme devient supérieur à un seuil donné :

utilisation :

Le seuil de 1000 est dépassé au rang 6 avec $u_{6}=1336$.

Pour une suite, définie de manière explicite, pour laquelle on cherche à partir de quel rang son terme devient inférieur à un seuil donné :

utilisation :

La suite passe sous le seuil de 500 au rang 54 avec $u_{54}=481.6$.

Pour une suite, définie par récurrence, pour laquelle on cherche à partir de quel rang son terme devient inférieur à un seuil donné :

utilisation :

La suite passe sous le seuil de 250 au rang 10 avec $u_{11}\approx 69.77$.

Déterminer le rang à partir duquel les termes d'une suite sont supérieurs aux termes de même rang d'une autre suite avec deux suites définies par récurrence :

utilisation :

Déterminer le rang à partir duquel les termes d'une suite sont supérieurs aux termes de même rang d'une autre suite avec deux suites définies de manière implicite :

utilisation :
Fonctions de la variable réelle
Cette méthode, classique, consiste, pour une fonction continue et monotone sur un intervalle [a ; b] dans lequel on sait trouver la solution de $f(x) = k$, à calculer $f(x)$, pour $x$ allant de a à b avec un pas de h, après avoir vérifié la croissance ou la décroissance de la fonction. Si f est croissante, "Tant Que" f(x) < k est vérifiée (On utilisera pour cela un While.), on calcule f(x). Dès que f(x) > k on arrête l'algorithme. Si f est décroissante, "Tant Que" f(x) > k est vérifiée, on calcule f(x). Dès que f(x) < k on arrête l'algorithme. On obtient un encadrement de longueur h de la solution
Il faut déterminer a et b, les bornes de l'intervalle dans lequel on va appliquer le balayage.
Fonction qui calcule cet encadrement, renvoyé dans un tuple, en fonction du nombre n de décimales souhaitées :
Cet algorithme détermine par balayage un encadrement de racine de 2 d'amplitude 10^(-n).

Utilisation : Compiler le fichier puis dans la console :

Le round permet ici de corriger quelques erreurs d'affichage des flottants.
Il est à noter que cet algorithme est très long à donner une réponse si n>=9.
On peut donc chercher à l'optimiser, par exemple en utilisant une boucle for qui va faire la même chose que le programme précédent mais pour h allant de 10⁻¹ à 10-n en réduisant l'intervalle [a ; b] à chaque boucle.
C'est beaucoup plus rapide, jusqu'à n=16 où ça bogue, parce que les flottants (décimaux) ne sont affichés qu'avec 16 chiffres après la virgule.

Soit l'on se donne une telle liste soit on la génère aléatoirement, par exemple :

On obtient par exemple :

On peut alors déterminer différents sous-ensembles :
Variables aléatoires
On peut illustrer graphiquement le résultat obtenu après avoir calculé la fréquence du succès lors de N expériences d'un échantillon de taille n (voir paragraphe précédent la fonction frequences(N,n,p) réutilisée ici) :
par un histogramme :

Utilisation :

par un nuage de points :

Utilisation :

Pour calculer l'écart-type :

Pour compter le nombre de valeurs situées dans un intervalle de la forme $[p-ks ; p+ks]$ pour $k\in\left\{1 ; 2 ; 3\right\}$ :

Utilisation :

Et si l'on veut plutôt récupérer la fréquence de 1 dans ces intervalles :

Utilisation (en utilisant la fonction fréquence vue deux paragraphes au-dessus) :

On peut utiliser la fonction nuage(N,n,p) vue précédemment pour y rajouter les droites d'équations y =μ-kσ et y = μ +kσ pour illustrer cela :

Utilisation :

Bernoulli
Bibliographie

# data[].attributes.attachment_link.title
Les algorithmes du programme de Mathématiques de Première technologique (2019). - Les nouvelles technologies pour l'enseignement des mathématiques

# data[].attributes.attachment_link.description
identifier les entrées et les sorties d'une fonction ; Prenons l'exemple de la loi de Bernoulli, on peut définir une fonction loi de Bernoulli de paramètre 0.7 : Il n'y a pas d'entrée, et en sortie on obtient 1 si l'expérience est un succès, 0 sinon.

# data[].attributes.body
Par la méthode de Monte Carlo

# data[].attributes.headline
Paradoxe du Duc de Toscane (probabilités, simulation)

# data[].attributes.subject
Paradoxe du Duc de Toscane (probabilités, simulation)

# data[].attributes.headline
Prévoir le réactif limitant et calculer les quantités de matière finales d’une réaction grâce à python

# data[].attributes.subject
Prévoir le réactif limitant et calculer les quantités de matière finales d’une réaction grâce à python

# data[].attributes.attachment_link.title
Prévoir le réactif limitant et calculer les quantités de matière finales d’une réaction grâce à python

# data[].attributes.headline
Prévoir le réactif limitant et calculer les quantités de matière finales d’une réaction grâce à python (script)

# data[].attributes.subject
Prévoir le réactif limitant et calculer les quantités de matière finales d’une réaction grâce à python (script)

# data[].attributes.attachment_link.readable_text
print("Équation de la réaction : aA + bB +eE-> cC + dD+fF\n Entrer les coefficients stoechiométriques a, b, c, d, e et f")
a = float(input("a = "))
b = float(input("b = "))
c = float(input("c = "))
d = float(input("d = "))
e = float(input("e = "))
f = float(input("f = "))
print("Entrer les quantités initiales des réactifs en mol")
nA = float(input("n0(A) = "))
nB = float(input("n0(B) = "))
nE = float(input("n0(E) = "))

xmaxA, xmaxB, xmaxE = nA / a, nB / b, nE/e

if xmaxA == xmaxB and xmaxA == xmaxE:
        print("Le mélange est dans les proportions stoechiométriques")
        xmax = xmaxA
elif xmaxA <= xmaxB and xmaxA <= xmaxE:
        print("A est le réactif limitant")
        xmax = xmaxA
elif xmaxE <= xmaxB and xmaxE <= xmaxA:
        print("E est le réactif limitant")
        xmax = xmaxE
else:
        print("B est le réactif limitant")
        xmax = xmaxB

print("xmax =", xmax, "mol")

nfA, nfB, nfE= nA - a * xmax, nB - b * xmax, nE-e*xmax
nfC, nfD, nfF = c * xmax, d * xmax, f*xmax

print("Le bilan final est")
print("nf(A) = {} mol \nnf(B) = {} mol\nnf(E) = {} mol\nnf(C) = {} mol\nnf(D) = {} mol\nnf(F) = {} mol".format(nfA, nfB, nfE,nfC, nfD,nfF))

# data[].attributes.body
Augmentation de la population et autosuffisance pour son agriculture (avant le brexit ;-)

# data[].attributes.headline
exercice de suite annale 0 spé math 1ere

# data[].attributes.subject
exercice de suite annale 0 spé math 1ere

# data[].attributes.body
3 scripts évolutifs

# data[].attributes.attachment_link.readable_text
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Wed Feb  5 14:06:02 2020

@author: stagiaire.08
"""

#exemple 1 - annale  premiere spé math#

n=0
I=400
while I>(1-70/100)*400:
    I=0.8*I
    n=n+1
print (n)



#exemple 2- annale avec fonction 1 variable#
def g(t):
    n=0
    I=400
    while I>(1-t/100)*400:
       I=0.8*I
       n=n+1
    print (n)
    return n




#exemple 3- annale avec fonction 2 variables#
def f(t,k):
    n=0
    J=k
    while J>(1-t/100)*k:
        J=0.8*J
        n=n+1
    print (n)
    return n

# data[].attributes.headline
Autour du seuil : d'après annales 0 de 1ères

# data[].attributes.subject
Autour du seuil : d'après annales 0 de 1ères

# data[].attributes.attachment_link.provider_name
Ministère de l'Education Nationale et de la Jeunesse

# data[].attributes.attachment_link.title
Épreuve orale dite « Grand oral » de la classe de terminale de la voie générale à compter de la session 2021 de l’examen du baccalauréat

# data[].attributes.attachment_link.description
Le Bulletin officiel de l’éducation nationale, de la jeunesse et des sports publie des actes administratifs : décrets, arrêtés, notes de service, etc. La mise en place de mesures ministérielles et les opérations annuelles de gestion font l’objet de textes réglementaires publiés dans des BO spéciaux.