Aide-mémoire, PYTHON

Table des matières

Aide-mémoire, PYTHON..................................................................................................................................................1
Liens................................................................................................................................................................................. 2
En cas de fermeture de la console...................................................................................................................................2
Généralités...................................................................................................................................................................... 2
Aide sur les commandes..................................................................................................................................................2
Raccourcis clavier............................................................................................................................................................2
Gestion des erreurs – Mode pas à pas.............................................................................................................................2
Les imports...................................................................................................................................................................... 3
Affectation, calculs..........................................................................................................................................................3
Entrées/Sorties................................................................................................................................................................3
Les fonctions.................................................................................................................................................................... 3
Tests................................................................................................................................................................................ 4
Boucles............................................................................................................................................................................ 4
Simulation – Tirage aléatoire...........................................................................................................................................4
Pour faire des maths........................................................................................................................................................4
Listes................................................................................................................................................................................ 5
Les compréhensions de listes..........................................................................................................................................5
Les tuples......................................................................................................................................................................... 5
Les dictionnaires..............................................................................................................................................................5
Les ensembles : set..........................................................................................................................................................6
Graphisme avec matplotlib..............................................................................................................................................6
Le module turtle : pour dessiner.....................................................................................................................................7
Le module sympy : le calcul formel..................................................................................................................................7
Le module Numpy : manipulation de matrices et de tableaux........................................................................................8
La lecture de fichiers........................................................................................................................................................8
La bibliothèque csv pour le travail sur les fichiers csv.....................................................................................................8
La bibliothèque pandas : manipulation des données......................................................................................................8
La bibliothèque networkX : étude des graphes et des réseaux.......................................................................................9
La bibliothèque PIL : traitement d’images.....................................................................................................................10
Autres bibliothèques.....................................................................................................................................................10
Annexes :.......................................................................................................................................................................11
PIP.............................................................................................................................................................................. 11
JUPYTER.....................................................................................................................................................................11
Utiliser jupyter depuis EduPython.................................................................................................................................11

1
Liens
[Link]

[Link]

[Link] MDP : ozanam_2018-19

[Link]

En cas de fermeture de la console

Si un élève ferme par mégarde la console, on peut la rouvrir en suivant le chemin :

Affichage – Fenêtre de l’IDE – Console interactive

Généralités
Les commentaires sont précédés du symbole # ¿ ceci est un commentaire
Indentation : PYTHON fonctionne par blocs écrits avec un if x >0 :
décalage. Un bloc est annoncé par le symbole : y=x
else :
y=− x

Aide sur les commandes

Avoir de l’aide sur une fonction help(fonction)
Exemple : help(sqrt)
Les docstrings permettent d’écrire une aide sur les def exemple(x) :
fonctions. Cette aide s’affiche lorsque l’on tape la "ceci est texte qui s’affichera"
fonction. Corps de la fonction

Raccourcis clavier
Aller à l’étape suivante dans le mode pas à pas F7
Reprendre des commandes saisies plus « haut » dans la console Flèche haut
Compléter une commande La tabulation
Récupérer une valeur Le _ (underscore)

Gestion des erreurs – Mode pas à pas

On peut effectuer le programme étape par étape grâce à la commande (« aller à l’étape suivante » - raccourci
clavier : F7) et visualiser l’état de chaque variable en se plaçant dans l’onglet « variables » (en bas à gauche de l’écran
dans la configuration classique) :

On sort ensuite du mode pas à pas grâce à la commande (stopper le débuggage).

Lorsqu’un programme rencontre une erreur on peut « revenir en arrière » (Menu Outil Analyse rétrospective) afin
de voir ce qui se passe, en utilisant la console pour faire des tests, l’onglet variable ou même en laissant le curseur
sur le code pour voir la valeur d’une variable.

2
Les imports
# -*- coding: utf-8 -*-
from math import *
from random import *
import [Link] as plt
import numpy as np

Affectation, calculs
Affecter à la variable a la valeur 5 a =5
Affectation multiple xA,yA=2.0 , 3.0
Calculer une puissance a n a∗¿ n
Quotient dans la division euclidienne de a par b a //b
Reste dans la division euclidienne de a par b a %b

Pour certains calculs, il est nécessaire d’importer un module spécifique. Par exemple, pour importer le module
maths, on doit taper dans la zone de saisie du programme : from math import *

On a alors accès aux instructions suivantes :

Racine carrée de a sqrt(a )

Partie entière de a floor(a )
Arrondir un nombre à i chiffre près round(x,i)
Arrondir par excès à l’entier ceil(nombre) (avec le module
math)

Entrées/Sorties
On appelle directement les sin ⁡(2.3)
Saisir dans la console
fonctions dans la console mon_milieu(1.0,2.0)
la valeur de la variable a print(a )
la lettre a print(a )
un mélange texte et valeur print( la valeur de a est , a)
Afficher dans la ou mieux
console print(On trouve a:%f et b:%f % (a ,b) )
avec le formatage :
print( f ' ' On trouve {a :.2 f } et { b :2 f } '')
pour un affichage à deux décimales
Exemple :
Définir une fonction f de paramètres a ,b , c … renvoyant def f (x) :
une valeur y . return 3∗x+1

Les fonctions
La commande assert permet de tester une Assert test
condition avant le corps de la fonction Exemple (assert a !=0)
La fonction lambda. Elle évite de définir une f = lambda x : x**2+1
fonction par la commande def Exemple pour f ( x )=x 2 +1
Commenter ses fonctions avec docstrings. def delta(a,b,c):
On accède au teste par la commande "Renvoie le discriminant
help(NomDeLaFonction) d'un polynôme du second degré"
3
 return b**2-4*a*c
Variable globale dans une fonction. Spécifier dans le corps de la fonction :
global a (par exemple)
Passage d’arguments. Python offre une def delta(a=1,b=1,c=1):
souplesse dans le passage d’arguments "Renvoie le discriminant
d'un polynôme du second degré"
Dans l’exemple on peut appeler delta(b=3) ; return b**2-4*a*c
delta(), etc.

Tests
Si le reste dans la division euclidienne de a par 2 est nul def est_pair(a):
Alors a est pair if a %2==0:
Sinon a est impair return True
else:
return False
Tester l’égalité a=b a=¿ b
Tester a ≠ b a !=b
Tester a ≤ b a <=b
Sinon si (contraction de else et de if) elif condition :

Le « alors » se traduit par deux points et un décalage des instructions. L’indentation est automatique lorsque l’on
tape sur la touche entrée après les deux points.
Le « else » traduisant « sinon » est au même niveau que le « if ».

Boucles
Tant que a <10 while a <10 :
bloc d’instructions indenté
Pour i allant de 1 à n (i prend les valeurs entières de l’intervalle [1 ;n+1[ ) for i in range(1,n +1) :
bloc d’instructions indenté
i prend tour à tour les valeurs entières de 0 à 4 (intervalle [0 ;5[) for i in range(5) :
i prend les valeurs entières de l’intervalle [3 ;11[ avec un pas de 2 for i in range(3 , 11, 2) :

Simulation – Tirage aléatoire

Il faut penser à importer le module random en tapant dans le script : from random import *

Renvoyer un entier aléatoire entre a et b randint(a ,b )

Renvoyer un nombre aléatoire entre 0 et 1 random()
Renvoyer un nombre décimal aléatoire entre a et b uniform(a ,b )

Pour faire des maths

Il existe de nombreuses bibliothèques pour faire des maths.
La plus utile est math (cmath si on veut travailler avec des complexes)
Il existe des modules pour travailler sur les fractions, les nombres décimaux, etc

Définir un complexe A=complex(3,4) ou a=3+4*1j

Partie réél, partie imaginaire [Link] [Link]
Importer cmath pour calculer module, argument,etc From cmath import *
Module fractions From fractions import Fraction

4
 Définir une fraction A=Fraction(4,5)
Module decimal From decimal import Decimal
Définir un nombre décimal A=decimal(‘0.1’)

Listes
Les listes sont des objets qui peuvent en contenir d'autres. La liste peut être modifiée.

Créer une liste vide L L=[]

Créer une liste de nombres L L=[1,3,7,8]
Ajouter un élément à la fin de la liste L [Link](élément)
Retirer un élément [Link](élément)
Indiquer le nombre d’éléments d’une liste L len(L)
Trier les éléments [Link]()
Compter le nombre d’apparitions d’un élément n=[Link](élément)
Tirer au sort un élément d’une liste n=choice(L)
Savoir si un élément n est présent if n in L
Trouver l’index d’un élément [Link](élément)
Minimum d’une liste min(liste)
Maximum d’une liste max(liste)
Retirer un élément à partir de son index del L[0] (retire le premier élément
de la liste l)
Retirer le dernier élément del L(-1)
Effectuer la somme des éléments d’une liste sum(L)

Attention, l’indice du premier élément d’une liste est 0. Ainsi, L[n ] renverra le (n+1)ème élément de la liste.

Les compréhensions de listes

On peut définir les éléments d’une liste directement dans la liste.

Créer une liste 10 000 entiers aléatoires entre 1 et 6 L1=[randint(1,6) for i in

range(10000)]
Créer la liste des 100 premiers entiers naturels L2=[i for i in range(100)]
Créer la liste des 10 premiers carrés L3=[i**2 for i in range(100)]
Créer la liste des carrés des éléments de la liste L2 L3=[i**2 for i in L2]
Créer la liste des valeurs d’une fonction à partir d’une liste L2=[f(i) for i in L1 if i != 4]
avec une condition.

Les tuples.
Un tuple est une liste qui ne peut plus être modifiée.
Créer un tuple vide A=()
Créer un tuple à un élément A=(1,) ou A=1,

Les dictionnaires
Un dictionnaire en python est une sorte de liste mais au lieu d'utiliser des index , on utilise
des clés , c'est à dire des valeurs autres que numériques.

Exemple Dic1={"name": "Olivier", "age": 30}={clé:valeur}

5
 Initialisation d’un dictionnaire Dic1={}
Ajouter une valeur (indiquer une clé et une valeur) Dic1[clé]=valeur
Obtenir une valeur dans un dictionnaire [Link]("name") renvoi Olivier
Supprimer une entrée del Dic1[clé]
Lister les clés [Link]()
Lister les valeurs [Link]()
Lister les clés et les valeurs en même temps [Link]()

Les ensembles : set

Un ensemble est une collection non ordonnée d’objets uniques et immuables (en profondeur).
Les ensembles peuvent être utiles en maths pour les notions de réunion, d’intersection,
d’appartenance.
Initialisation d’un ensemble A={‘1’,3,’Robert’}
Ne pas utiliser d’ensemble vide car PYTHON considère que
l’on déclare un dictionnaire.
Intersection de deux set A&B
Réunion de deux set A|B

Graphisme avec matplotlib

Pour afficher les graphiques Chaque graphisme devra se terminer par :
[Link]()
Affichage des axes [Link]([0,6,0,20]) Axe des abscisses puis
ordonnées.
Créer une liste de 15 valeurs entre -2 et 2 lx=[Link](-2,2,15)
Représenter une fonction [Link](lx,f(lx))
Pour changer de couleur : rouge :
[Link](x,f,'r') en rouge
[Link](x,f,'b') en bleu
Représenter un nuage de points On dispose de deux listes, la première l1
contenant les abscisses et la seconde l2 les
ordonnées
[Link](l1,l2,'o')
'o' impose une représentation par des disques
'–' impose une représentation par des tirets
'^' impose une représentation par des triangles
Pour changer de couleur :
rouge :
[Link](l1,l2,'ro')
bleu :
[Link](l1,l2,'bo')
triangle rouge :
[Link](l1,l2,'r^')
Faire une pause pour animer [Link](1) Pour une pause de 1 seconde :
Indiquer une légende sur l'axe des abscisses [Link]('image de la fonction ')
Indiquer une légende sur l'axe des ordonnées [Link]('image de la fonction ')

6
Indiquer une légende sur le graphique (par [Link](lx,f(lx),label=''f(x) '')
exemple pour identification, dans le cas de [Link]( ) → cette commande permet
plusieurs courbes) l'affichage de la légende
Pour modifier la tailler des objets lines=[Link](l1,l2)
[Link](lines,color='r',linewidth=2)
Afficher la grille [Link]( )
Histogramme Avec 10 barres par défaut : [Link](l)
Pour contrôler le nombre de barres
[Link](l,bins=50)
Pour normer les valeurs :
[Link](l,bins=50,normed=True)
Exemple pour la simulation [Link]([randint(1,6) for i in
range(100)],bins=6,range=(1,6),normed=True)
Diagramme en barres / bâtons [Link](L1, L2, 0.1, color ='r' ) : pour une liste L1
en abscisses, une liste L2 en ordonnée et des
barres de largeur 0,1

Le module turtle : pour dessiner

Ne fonctionne sous Jupyter.

Importation de la libraire from turtle import *

Sortie de la fenêtre exitonclick()
Dessiner down()
Se déplacer sans dessiner up()
Aller à goto(x,y)

Le module sympy : le calcul formel

Importation de la libraire from sympy import *
Déclarer une variable x=symbol('x') ou Symbol('x')
Dériver une fonction expr=x**2
diff(expr,x)
Obtenir un développement en 0 à l'ordre 8 series(expr,x,0,8)
Résoudre une équation dans C solve(x**2+x+1,x)
Développer une expression expand((x+5)**2)
Factoriser une expression factor(x**2-1)
Limite en +infini limit(1/(x+1),x,oo)
Limite en -infini limit(1/(x+1),x,oo)
Limite en 0 limit(1/(x+1),x,0)
Limite en 0+ limit(1/(x+1),x,0,'+')

7
Primitive integrate(1/x,x)
Intégrale integrate(1/x,(x,1,E))
Résoudre 2x+y=2 et -3x-5y=1 x,y=symbols('x y')
solve([2x+y-2,-3x-5y-1],[x,y])

Le module Numpy : manipulation de matrices et de tableaux

NumPy est destinée à manipuler des matrices ou tableaux multidimensionnels ainsi que des fonctions
mathématiques opérant sur ces tableaux.

Importation de la libraire import numpy as np

M=[Link]() Tableau d’éléments
M=[Link]([3,4,6])
Matrice : M=[Link]([[4,2],[3,4]])
Matrice 2,2
dot(a,b) Produit matriciel

La lecture de fichiers
Ouvrir un fichier en mode lecture fichier = open("[Link]", "r")
r= read
w=write
a= se positionne à la fin du fichier
texte=[Link]() Lit le fichier et créer une liste d’éléments
split() Permet de transformer une chaine en liste.
Exemple : liste=[Link]('\n') \n est le
Renvoie une liste. délimiteur \n fin de ligne
[Link](‘,’) pour un fichier csv
[Link]() Ferme le fichier
[Link]() Lit les lignes du fichier

La bibliothèque csv pour le travail sur les fichiers csv.

Importer la bibliothèque csv Import csv
Ouvrir un fichier csv en se positionnant à la fin fichier = open("[Link]", 'a',
newline='')
Déclarer un fichier csv FichierCSV= [Link](fichier,delimiter=",")
Ecrire à la fin du fichier la liste [Link](Liste)

La bibliothèque pandas : manipulation des données.

Bibliothèque permettant la manipulation et l'analyse des données.

Importer la bibliothèque Pandas sous l’alias pd import pandas as pd

Lit le fichier ‘seconde_B.xlsx’ df = pd.read_excel('seconde_B.xlsx')
Lit les cinq premiers enregistrements [Link]()
Lit la ligne nb [Link][nb]
Donne le nombre de lignes len(df)
Donne la première ligne [Link]
Calcule des indicateurs statistiques pour chaque [Link]()
colonne

8
La bibliothèque networkX : étude des graphes et des réseaux.
Bibliothèque permettant le travail sur les graphes et les réseaux

Importer la bibliothèque networkx sous import networkx as nx

l’alias nx
La bibilothèque est dépendante de
matplot et de numpy
Créer un graphe g = [Link]() # DiGraph() pour un graphe orienté

Sommets du graphe [Link]()

Ajouter des liaisons dans le graphe. g.add_edges_from()

Exemples :

g.add_nodes_from(range(5))

g.add_edges_from([(0,1),(3,4),(4,2),(1,3),(4,0),(1,2)])

Degrés des sommets du graphe g [Link]()

Nombre de sommets du graphe g g.number_of_nodes()

Nombre d’arcs du graphe g g.number_of_edges()

Liste des prédécesseurs du sommet i [Link](i)

Liste des successeurs du sommet i [Link](i)

Liste des voisins du sommet i [Link](i)

Pour dessiner un graphe [Link]()

[Link](g)
[Link]()

Construire la matrice d’adjacence nx.to_numpy_matrix(g)

Vérifier l’existence d’un chemin nx.has_path(g,nodeA,nodeB)

Tester la connexité nx.is_connected(g)

Tester la caractère Eulérien nx.is_eulerian(g)

La bibliothèque PIL : traitement d’images.

Bibliothèque permettant l’ouverture des images dans plusieurs formats standards et leur traitement.

9
 Importer la sous-bibliothèque Image, dans from PIL import Image
laquelle se trouve l’essentiel
Ouverture d’une image image=[Link](“[Link]”)
Sauvegarder une image [Link](“[Link]”)
Créer une image semblable mais avec image_nouvelle=[Link](largeur, hauteur)
d’autres dimensions.
Renvoyer la dimension d’une image L,H=[Link]
Afficher une image [Link]()
Appliquer un filtre image_nouvelle=[Link]([Link])
Pour l’utilisation des filtres, importer la -Exemples de ce que l’on peut tester, à placer à la
sous-bibliothèque ImageFilter (from PIL place de FILTRE : BLUR, DETAIL, CONTOUR,
import ImageFilter) EDGE_ENHANCE, EDGE_ENHANCE_MORE,
EMBOSS, FIND_EDGES, SMOOTH, SMOOTH_MORE,
SHARPEN.
Conversion de MODE : image_nouvelle=[Link](“MODE”)
On travaille le plus souvent avec des images -Exemples de MODE : 1 (pour le noir et blanc), L
en mode RGB, parfois RGBA (pour ajouter la (pour niveaux de gris), RGB, RGBA.
transparence) mais aussi en mode noir et
blanc ou en niveaux de gris.
Renvoie les trois composantes couleurs de R,V,B=[Link]()
chaque pixel
Créer une image à partir des trois Image_nouvelle=[Link]("RGB",(R,V,B))
composantes
Créer le tableau des pixels p=[Link]()
Créer la liste des pixels L=liste([Link]())
Reconstruit une image à partir de la liste [Link](L)
Renvoie les trois composantes du pixel rouge,vert,bleu=[Link]((i,j))
désigné
Affecte au pixel désigné les trois image_nouvelle.putpixel((i,j),(rouge,vert,bleu))
composantes données (rouge, vert et bleu prennent toute valeur entière
de 0 à 255.)
Mélange de deux images image_nouvelle=[Link](image1,image2,alpha)
Appliquer des transformations image_nouvelle=
(on peut utiliser ces transformations [Link]([Link])
prédéfinies mais il est intéressant -Exemples de transformations :
pédagogiquement d’en construire une FLIP_LEFT_RIGHT, FLIP_TOP_BOTTOM,
bonne partie avec les élèves). ROTATE_180.

Autres bibliothèques
Bibliothèque Tkinter from tkinter import *
Interface graphique avec gestion d’évènements
Bibliothèque openCV import cv2
Traitement d’images
Bibliothèque PIL from PIL import Image
Traitement d’images
Bibliothèque pour accéder à internet import [Link]
Bibliothèque Pygame import pygame
Interface graphique avec gestion d’évènements from [Link] import *

10
 Bibliothèque NetworkX import networkx as nx
Pour l’étude des graphes et des réseaux import numpy as np
import [Link] as plt
Bibliothèque GPio pour la gestion d’un import [Link] as GPIO
Raspberry
Bibliothèque pour l’utilisation des réseaux scapy From [Link] import *
Installation de la version 2.4.0
Pip install scapy==2.4.0

Pour installer la bibliothèque openCV : pip install opencv-python

Lien intéressant : [Link]

Lien bases pour Python : [Link]

[Link]

Annexes :
PIP : Les commandes pipeline pour installer des modules supplémentaires
Installer une bibliothèque pip install nom
Installer une version d’une bibliothèque pip install nom==version
Désinstaller une bibliothèque pip uninstall nom
Chercher une bibliothèque avec ses Pip search nom
dépendances
Obtenir la liste des bibliothèques installées Pip freeze

JUPYTER : Les commandes Jupyter

Activer de nombreuses extensions visibles dans jupyter contrib nbextension install --user
nbextension

Utiliser jupyter depuis EduPython

 Aller dans le menu Outils/Outils/Installation d’un nouveau module
 Choisir conda
 Taper jupyter
 (En ligne de commande) Une fois l’installation terminée, aller dans EduPython\App\Scripts
 (En ligne de commande) exécuter [Link]
 Par la suite, il vau mieux créer un fichier .bat qui procède au lancement de jupyter

11