Le langage Python

Historique et Présentation

Le langage Python est, à la base, un langage de script interprété, qui a été créé par Guido van Rossum dans les années 1980.

La commande python3 (pour les versions 3) peut être utilisée seule pour une exécution interactive en mode terminal, suivie le nom du fichier python (.py) pour fonctionner en interpréteur, ou encore avec le module py_compile pour compiler le code python. Dans ce dernier cas, le fichier exécutable possède l'extension .pyc et se trouve dans le répertoire __pycache__.

Ce qui suit est inspiré de ce site sur la programmation en python et de la documentation plus complète du site python.

Avertissement : tous les exemples de programmes python ont été testés sous linux.

#!/usr/bin/python3

print("bonjour le monde")
				

pyhton3 hello.py

def main(args):
	print("bonjour le monde")	
	return 0

if __name__ == '__main__':
	import sys
	sys.exit(main(sys.argv))
				

Sous linux, si le fichier est exécutable et si la première ligne contient la commande spécifique d'accès à l'interpréteur, il peut être utilisé directement comme une commande linux.

import sys importe le module sys qui contient les fonctions d'accès au système d'exploitation. sys.exit(code) termine le programme avec le code qui correspond au code de retour de la fonction main. La variable __name__ contient __main__, cela correspond au module directement exécuté. si ce module est exécuté à partir d'un autre module, cette variable contient le nom du module.

Exemple :

from module2 import main

if __name__ == '__main__':
	import sys
	sys.exit(main(sys.argv))
				

def main(args):
	print(__name__)
	print("bonjour le monde")	
	return 0

if __name__ == '__main__':
	import sys
	sys.exit(main(sys.argv))
				

module2
bonjour le monde
				

__main__
bonjour le monde
				

En python, il n'y a pas de caractère de fin d'instruction, ni de caractères de début et de fin de bloc. On a une ligne par instruction et une indentation (tabulation) par niveau d'imbrication de bloc.

Enfin, le langage Python peut être également structuré en langage objet comme le langage C++

class Message:
	def __init__(self,typemessage):
		self.entete = typemessage
		
	def afficher(self,message):
		print(self.entete + " " + message)
				

from Affichage import Message

def main(args):
	affichage = Message("info : ")
	affichage.afficher("bonjour le monde")	
	return 0

if __name__ == '__main__':
	import sys
	sys.exit(main(sys.argv))
				

Syntaxe et structure du langage

Les types de données

En python, les types des données peuvent être :

Les valeurs entières sont écrites en base décimale (base 10) par défaut, mais elle peuvent être écrites en hexadécimal en utilisant le préfixe 0x ou encore en octal (base 8) en utilisant le préfixe 0.

Les fonctions permettent de forcer le type ou bien d'effectuer un transtypage.

Les variables

Les variables ne sont pas déclarées, sauf s'il est nécessaire de les initialiser. Le type de la variable est défini automatiquement lors de l'affectation d'une valeur constante ou bien du résultat de l'expression de calcul.

La fonction type(nomvariable) permet de connaître le type de la variable.

Les variables de type chaînes de caractères

Les délimiteurs des chaînes de caractères sont les guillemets.

Le langage python fournit un ensemble de fonctions de chaînes de caractères. Pour les utiliser, il faut faire suivre le nom de la chaîne par le nom de la fonction séparée par un point. Parmi toutes ces fonctions, on peut citer :

• len(variableliste) renvoie le nombre d'éléments dans variablechaine.
• variablechaine.format(liste variable) donne une chaîne de caractères où les {} sont remplacées par une variable transmise dans la liste des variables dans l'ordre des variables de la liste.
• variablechaine.index(chaine) renvoie la position de début dechaine dans variablechaine si chaine est présent dans la variablechaine.
• variablechaine.strip(chaine) supprime les caractères présents dans chaine au début et à la fin de variablechaine.
• variablechaine.lstrip(chaine) supprime les caractères présents dans chaine au début de variablechaine.
• variablechaine.rstrip(chaine) supprime les caractères présents dans chaine à la fin de variablechaine.
• variablechaine.replace(chaine1,chaine2) remplace chaine1 par chaine2 dans variablechaine.

Toutes les fonctions créent une nouvelle chaine, la chaine d'origine (variablechaine) n'est pas modifiée.

L'affectation

Le symbole d'affectation est le signe =. L'expression située à droite du symbole = est évaluée, le résultat est affecté à la variable située à gauche du symbole =. Le type de cette variable est défini en fonction du type du résultat.

La conversion entre types

Elle peut être effectué en utilisant les fonctions associées aux types, comme par exemple prendre la partie entière d'un réel.

reel = 8.62
print(reel)
entier = int(reel*100)
print(entier)
				

8.62
861
				

On peut observer qu'il y a une erreur de calcul, car 8.62 × 100=862. 8.62 × 100 donne une valeur approchée 861.9999, ce qui fait que la valeur de la partie entière est 861. Cette erreur a déjà été constatée avec octave et scilab et avec le langage C. Cela est du au mode d'enregistrement et de calcul de la machine.

Les opérateurs

Opérateurs arithmétiques

Opérateurs de comparaisons

Le résultat d'une comparaison est de type booléen.

Pour les chaînes de caractères la comparaison est lexicographique.

Opérateurs logiques

Il fonctionnent avec des booléens.

Opérateurs bits à bits

Ils effectuent des opérations logiques sur chaque bit des opérandes au sens de la représentation binaire des entiers.

Affectation et opérateurs combinés

L'opérande de gauche est calculée avec l'expression de droite, le résultat est affecté à l'opérande de gauche

L'entrée et la sortie standard

Affichage sur la sortie standard

Cela se fait avec la fonction print(variable) qui permet d'afficher la valeur d'une variable sur la sortie standard suivi d'un retour à la ligne suivante.

Pour afficher des valeurs de variables combinées avec du texte, il faut soit convertir les autres types en chaîne de caractères (str) et concaténer l'ensemble, soit utiliser une chaîne de formatage de la forme :

f"texte {variable} ...."

où chaque variable est entre accolade et peut être suivie de caractères de formatage, comme par exemple :

• {x:3d} pour l'affichage de l'entier x aligné à droite sur 3 colonnes
• {y:.4f} pour l'affichage du réel y avec 4 chiffres après la virgule

Le détail des formats est disponible sur la partie python du site w3schools

Il est également possible de formater l'affichage des variables avec la fonction format(liste variables) où le format d'affichage est précisé entre accolades sans la variable et la variable transmise à la fonction format sous la forme chaineformat.format(liste des variables).

Saisie sur l'entrée standard

Elle utilise la fonction input(texte), où texte est le texte à afficher avant d'attendre la saisie. la fonction retourne la saisie sous la forme d'une chaîne de caractères. Dans le cas de saisie de nombres, il faudra effectuer la conversion de type adaptée avant de faire les calculs.

Les structures de contrôle

L'alternative

Elle permet d'effectuer un traitement en fonction d'un résultat booléen

if (expression booleenne):
	traitement si expression booleenne vraie
elif (expression booleene 2):
	traitement si expression booleenne 2 varie
else:
	traitement dans les autres cas

Les traitements sont décalés (indentés) d'une tabulation par rapport au niveau d'indentation de if. Les blocs elif et else ne sont pas obligatoires.

Exemple de résolution d'équation de degré 2 dans ℂ

from math import *

def main(args):
	ch_a=input("a? ")
	ch_b=input("b? ")
	ch_c=input("c? ")
	a=float(ch_a)
	b=float(ch_b)
	c=float(ch_c)
	delta=b**2-4*a*c
	print(f"delta={delta}")
	if (delta > 0):
		x1 = (-b-sqrt(delta))/(2*a)
		x2 = (-b+sqrt(delta))/(2*a)
		print(f"x1={x1} , x2={x2}")
	elif (delta == 0):
		x = (-b)/(2*a)
		print(f"x={x}")
	else:
		x1 = (-b-sqrt(-delta)*1j)/(2*a)
		x2 = (-b+sqrt(-delta)*1j)/(2*a)
		print(f"x1={x1} , x2={x2}")
	return 0

if __name__ == '__main__':
	import sys
	sys.exit(main(sys.argv))
					

Les répétitions

for variable in liste:
	traitement
				

while (expression booleenne):
	traitement
				

def main(args):
	ch_m=input("table des ")
	m=int(ch_m)
	for i in range(1,11):
		p=m*i
		print(f"{m:2d} X {i:2d} = {p:2d}")
	return 0

if __name__ == '__main__':
	import sys
	sys.exit(main(sys.argv))
					

table des 3
 3 X  1 =  3
 3 X  2 =  6
 3 X  3 =  9
 3 X  4 = 12
 3 X  5 = 15
 3 X  6 = 18
 3 X  7 = 21
 3 X  8 = 24
 3 X  9 = 27
 3 X 10 = 30
					

def main(args):
	un=0.7
	for i in range(1,31) :
		un = 10*un-6.3
		print(f"{i} : {un}")
	return 0

if __name__ == '__main__':
    import sys
    sys.exit(main(sys.argv))
					

1 : 0.7000000000000002
2 : 0.700000000000002
3 : 0.7000000000000197
4 : 0.7000000000001974
5 : 0.7000000000019737
6 : 0.7000000000197373
7 : 0.700000000197373
8 : 0.7000000019737298
9 : 0.7000000197372982
10 : 0.7000001973729821
11 : 0.7000019737298215
12 : 0.7000197372982155
13 : 0.7001973729821556
14 : 0.7019737298215558
15 : 0.7197372982155583
16 : 0.8973729821555834
17 : 2.673729821555834
18 : 20.43729821555834
19 : 198.0729821555834
20 : 1974.429821555834
21 : 19737.998215558342
22 : 197373.68215558343
23 : 1973730.5215558342
24 : 19737298.915558342
25 : 197372982.8555834
26 : 1973729822.255834
27 : 19737298216.258343
28 : 197372982156.28345
29 : 1973729821556.5344
30 : 19737298215559.043
					

Les structures de données

Les listes (list)

Les listes sont des suites de variables ordonnées. Elles peuvent être utilisées pour implémenter des tableaux.

listeentiers = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

listeentiers = [ i for i in range(1,11) ]

listeentiers[3]

Les principales fonctions de traitement des listes sont :

• len(variableliste) renvoie le nombre d'éléments dans la liste.
• variableliste.append(variable) ajoute variable en fin de variableliste.
• variableliste.clear() efface l'ensemble des éléments de variableliste.
• variableliste.index(variable) renvoie la position de la variable dans variableliste.

Il est possible de joindre deux listes avec l'opérateur +

listn = [ i for i in range(1,7) ]

def main(args):
	ch_m=input("m ? ")
	m=int(ch_m)
	for i in listn:
		p=m*i
		print(f"{m:2d} X {i:2d} = {p:2d}")
	return 0

if __name__ == '__main__':
	import sys
	sys.exit(main(sys.argv))
					

table des 3
 3 X  1 =  3
 3 X  2 =  6
 3 X  3 =  9
 3 X  4 = 12
 3 X  5 = 15
 3 X  6 = 18
 3 X  7 = 21
 3 X  8 = 24
 3 X  9 = 27
 3 X 10 = 30
					

Les listes non modifiables (tuple)

Les listes non modifiables (tuple) sont des suites de variables ordonnées. On ne peut pas ajouter de valeur ni les modifier.

listeentiers = ( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 )

listeentiers = ( i for i in range(1,11) )

listeentiers[3]

Les principales fonctions de traitement des listes sont :

• len(variableliste) renvoie le nombre d'éléments dans la liste.
• variableliste.index(variable) renvoie la position de la variable dans variableliste.

Il est possible de joindre deux listes avec l'opérateur +

listn = ( i for i in range(1,7) )

def main(args):
	ch_m=input("m ? ")
	m=int(ch_m)
	for i in listn:
		p=m*i
		print(f"{m:2d} X {i:2d} = {p:2d}")
	return 0

if __name__ == '__main__':
	import sys
	sys.exit(main(sys.argv))
					

table des 3
 3 X  1 =  3
 3 X  2 =  6
 3 X  3 =  9
 3 X  4 = 12
 3 X  5 = 15
 3 X  6 = 18
 3 X  7 = 21
 3 X  8 = 24
 3 X  9 = 27
 3 X 10 = 30
					

Les dictionnaires (dictionary)

Un dictionnaire est une suite de paires <clé,valeur>. On accède à la valeur par l'intermédiaire de la clé.

dict={ "x" : "y" , "a" : "b"}

dict["x"]

Les principales fonctions de traitement des dictionnaires sont :

• len(variabledictionnaire) renvoie le nombre d'éléments (cle,valeur) dans variabledictionnaire.
• variabledictionnaire.get(cle) renvoie la valeur correspondant à cle dans variabledictionnaire.
• variabledictionnaire.keys() renvoie la liste des clés de variabledictionnaire.
• variabledictionnaire.values() renvoie la liste des valeurs de variabledictionnaire.

Les ensembles (set)

Les ensembles sont des suites de variables non ordonnées. Les valeurs ne peuvent être dupliquées. C'est un ensemble au sens mathématique du terme.

A = { 1, 2, 3, 4, 5 }

A={i for i in range(6)}

Les principales fonctions de traitement des ensembles sont :

• len(A) renvoie le cardinal de l'ensemble
• A.clear() efface l'ensemble des éléments de A.
• A.intersection(B) renvoie l'ensemble des valeurs appartenant à A et à B : A ⋂ B. On peut utiliser l'opérateur & et écrire A & B
• A.union(B) renvoie l'ensemble des valeurs appartenant à A et à B : A ⋃ B. On peut utiliser l'opérateur & et écrire A | B

Fonction pour ces structures de données

• listeresultat=map(nomfonction,liste) applique la fonction nomfonction à chaque élément de la liste et renvoie la nouvelle liste.

Les fonctions

def nomfonction():
	traitement
				

def nomfonction(liste parametres):
	traitement
				

Les paramètres par valeur concernent les entiers, réels, complexes, chaînes de caractères. Une modification du contenu par la fonction n'est pas transmise à la fonction qui l'a appelée

Les paramètres par références concernent les liste, dictionnaires et objets. Une modification du contenu par la fonction est transmise à la fonction qui l'a appelée

Les valeurs de retour des fonctions

C'est une fonction avec ou sans paramètres qui renvoie une valeur.

def nomfonction(liste parametres):
	traitement et calcul de la valeur de retour
	return valeurretour
		

Il est possible d'avoir un retour avec une liste de valeurs, ce qui permet de compenser l'absence de paramètres par référence pour les entiers, réels, complexes.

Exemples

def multifactorielle(n,k):
	f=1
	if (n>1):
		f=multifactorielle(n-k,k)*n
	return f

listen = [ i+1 for i in range(10)]

def main(args):
	ch_k=input("k ? ")
	k=int(ch_k)
	for i in listen:
		f=multifactorielle(i,k)
		print(f"{i}!{k}={f}")
	return 0

if __name__ == '__main__':
	import sys
	sys.exit(main(sys.argv))
					

k ? 2
1!2=1
2!2=2
3!2=3
4!2=8
5!2=15
6!2=48
7!2=105
8!2=384
9!2=945
10!2=3840
					

def echange(x,y):
	tmp=x
	x=y
	y=tmp
	return x,y

def main(args):
	ch_a=input("a ? ")
	ch_b=input("b ? ")
	a=float(a)
	b=float(b)
	print(f"a={a} b={b}")
	a,b=echange(a,b)
	print(f"a={a} b={b}")
	return 0

if __name__ == '__main__':
	import sys
	sys.exit(main(sys.argv))
					

a ? 1.2
b ? 9.6
a=1.2 b=9.6
a=9.6 b=1.2
					

La portée des variables

Toutes les variables sont locales aux fonctions dans lesquelles elles ont été utilisées.

Une variable déclarée en dehors des fonctions est une variable globale qui est accessible par toutes les fonctions mais non modifiable par ces fonctions.

Si cette variable globale est déclarée avec le mot clé global dans une fonction, alors elle est modifiable par cette fonction.

La gestion des fichiers

Ouverture et fermeture

L'ouverture se fait avec la fonction open qui retourne un objet. L'accès au contenu du fichier se fait avec les méthodes de cette objet.

fd=open(nomfichier,mode)

• r : ouverture en lecture seule
• a : ouverture en écriture, ajout en fin de fichier
• w : ouverture en écriture, positionnement en début de fichier, le fichier est créé s'il n'existe pas
• x : création de fichier, on obtient une erreur si le fichier existe

Cette première lettre peut être suivie d'un "+" (optionnel) pour passer en mode lecture et mise à jour.

• t : fichier de type texte (interprétation des codes particuliers comme les caractères de fin de ligne), open renvoie un objet de type TextIoBase
• b : fichier de type binaire (pas d'interprétation des codes particulier), open renvoie un objet de type BufferedIoBase

La fermeture se fait avec la méthode close de l'objet renvoyé par open

fd.close()

Gestion des erreurs

Les fonctions d'accès au fichier nécessitent l'utilisation de la structure try...except

try:
	traitement normal du fichier
except TYPEXCEPTION:
	affichage de message
		

• FileNotFoundError pour fichier non trouvé
• IOError pour une erreur d'entrée sortie plus générale

Il peut y avoir plusieurs blocs except afin de gérer plusieurs erreurs différentes.

Lecture

Mode texte

La lecture peut se faire sur le fichier entier avec objetfichier.readlines() ou bien ligne par ligne avec objetfichier.readline().

readlines() renvoie un liste de chaînes ou chaque élément correspond à une ligne incluant les caractères de fin de ligne.

readline renvoie une chaîne de caractères qui contient la ligne en incluant les caractères de fin de ligne

def main(args):
	nomfichier=args[1]
	try:
		fd=open(nomfichier,"r")
		texte = fd.readlines()
		for ligne in texte:
			print(ligne.rstrip("\n"))
		fd.close()
	except FileNotFoundError:
		print("fichier non trouve")
	return 0

if __name__ == '__main__':
    import sys
    sys.exit(main(sys.argv))
					

def main(args):
	nomfichier=args[1]
	try:
		fd=open(nomfichier,"r")
		ligne = fd.readline()
		while (ligne):
			print(ligne.rstrip("\n"))
			ligne = fd.readline()
		fd.close()
	except FileNotFoundError:
		print("fichier non trouve")
	return 0

if __name__ == '__main__':
    import sys
    sys.exit(main(sys.argv))
					

Mode binaire

La lecture se fait avec la fonction objetfichier.read(taille) avec taille qui représente le nombre d'octets à lire. Cette fonction renvoie une liste d'octets.

def main(args):
	nomfichier=args[1]
	try:
		fd=open(nomfichier,"rb")
		octets = fd.read(1)
		while (len(octets)>0):
			print(octets[0])
			octets=fd.read(1)
		fd.close()
	except FileNotFoundError:
		print("fichier non trouve")
	return 0

if __name__ == '__main__':
    import sys
    sys.exit(main(sys.argv))
					

Ecriture

Mode texte

L'écriture se fait avec la fonction objetfichier.write(chaine) où chaine est une chaîne de caractères. Les autres types de données doivent être convertis en chaîne de caractères formatée si nécessaire.

def main(args):
	nomfichier=args[1]
	try:
		fd=open(nomfichier,"w")
		ch_a=input("a= ")
		fd.write(ch_a)
		fd.close()
	except IOError:
		print("Erreur")
	return 0

if __name__ == '__main__':
    import sys
    sys.exit(main(sys.argv))
					

Mode binaire

L'écriture se fait avec la fonction objetfichier.write(octets) où octets est un tableau d'octets Les autres types de données doivent être convertis en tableau d'octets si nécessaire.

Dans le cas d'un entier on peut utiliser la conversion vers un tableau d'octet du type entier e.to_bytes(taille,format) avec e qui est l'entier , taille le nombre d'octets et format qui correspond à l'ordre dans lequel sont enregistrés les octets de l'entier big endian ou little endian.

def main(args):
	nomfichier=args[1]
	try:
		fd=open(nomfichier,"wb")
		ch_a=input("a ? ")
		a=int(ch_a)
		fd.write(a.to_bytes(4,"little"))
		fd.close()
	except IOError:
		print("Erreur")
	return 0

if __name__ == '__main__':
    import sys
    sys.exit(main(sys.argv))
					

Les mathématiques

Le module math

Ce module contient l'ensemble des fonctions mathématiques standard pour les nombres réels : trigonométrie, exponentielle, logarithme.

from math import *

def complexe_module(c):
	m=abs(c)
	return m

def complexe_arg(c):
	a=atan2(c.imag,c.real)
	return a

def complexe_conjugue(c):
	cbar=c.conjugate()
	return cbar
					

from complexes import *

def main(args):
	z=2+3j
	m=complexe_module(z)
	print(f"||{z}|| = {m}")
	a=complexe_arg(z)
	print(f"arg({z}) = {a}")
	zbar=complexe_conjugue(z)
	ligne = "{}/ = {}"
	print(f"/{z} = {zbar}")	
	zp = z * zbar
	m2=m**2
	print(f"||{z}||^2 = {zp.real} = {m2}")	
	return 0

if __name__ == '__main__':
    import sys
    sys.exit(main(sys.argv))
					

||(2+3j)|| = 3.605551275463989
arg((2+3j)) = 0.982793723247329
/(2+3j) = (2-3j)
||(2+3j)||^2 = 13.0 = 12.999999999999998			
					

Les complexes et le module cmath

Le module cmath permet d'utiliser les différentes fonctions mathématiques pour les nombres complexes.

• cmath.phase(complexe) renvoie l'argument du nombre complexe.
• cmath.exp(complexe) renvoie l'exponentielle du nombre complexe.
• cmath.log(complexe) renvoie le logarithme naturel du nombre complexe.

Les matrices et le module numpy

Le module numpy permet d'effectuer des calculs matriciels.

Les matrices sont représentées par des tableaux avec le type array de ce module. Ce module permet d'effectuer les opérations sur les matrices comme, par exemple, l'addition avec l'opérateur +, la transposition, le produit (dot).

import numpy as np

def main(args):
	A=np.array([[1,2],[3,4]])
	B=np.array([[4,6],[1,5]])
	S=A+B
	P=np.dot(A,B)
	Bt=B.T
	print(A)
	print(B)
	print(S)
	print(P)
	print(Bt)
	return 0

if __name__ == '__main__':
    import sys
    sys.exit(main(sys.argv))
					

[[1 2]
 [3 4]]
[[4 6]
 [1 5]]
[[5 8]
 [4 9]]
[[ 6 16]
 [16 38]]
[[4 1]
 [6 5]]
					

Représentation graphique

Le module matplotlib permet de tracer des graphiques avec une syntaxe proche du logiciel octave

Tracé d'une courbe

• objplot.plot(x,y) où x et y sont des listes de valeurs respectivement pour l'axe horizontal x et l'axe vertical y
• objplot.xlabel(nom) où nom correspond à la dénomination de l'axe x
• objplot.ylabel(nom) où nom correspond à la dénomination de l'axe y
• objplot.title(nom) où nom correspond au titre du graphique
• objplot.axis([xmin,xmax,ymin,ymax]) qui permet de déterminer les valeurs extrêmes des axes x et y
• objplot.grid() pour afficher la grille
• objplot.show() pour afficher le graphique

import matplotlib.pyplot as plt
import numpy as np

def Horner(coeffs,x):
	nb=len(coeffs)
	y=coeffs[nb-1]
	for i in range(nb-1):
		y=coeffs[nb-i-2]+x*y
	return y

def main(args):
	coeffs=[15, 16, 6 , 1]
	lx = np.linspace(-7, 3, 100)
	ly= []
	for x in lx:
		y=Horner(coeffs,x)
		ly.append(y)
	plt.plot(lx,ly)
	plt.xlabel('x')
	plt.ylabel('y')
	plt.axis([-7,3,-150,150])
	plt.title("Fonction polynomiale")
	plt.grid()
	plt.show()
	return 0

if __name__ == '__main__':
	import sys
	sys.exit(main(sys.argv))
					

Affichage du résultat

L'évaluation de la fonction polynomiale utilise la méthode de Horner

Tracé d'un camembert

• plt.pie(donnees,liste d'options) : affiche les données en forme de camembert, les options peuvent être
  • labels : liste des étiquettes des données
  • colors : liste des couleurs associées à chaque donnée
  • explode : liste des pourcentages des décalages des portions des données
  • shadow : booléen True pour afficher une ombre

import matplotlib.pyplot as plt
import numpy as np

def main(args):
	abonnement=34.01
	consommation=46.62
	taxes=12.71
	contribution=6.65
	etiquettes = ["abonnement", "consommation", "taxes et contributions", "contributions"]
	extraire = [0, 0.3, 0, 0]
	couleurs = ["yellow", "green", "orange", "red"]
	donnees = np.array([abonnement, consommation, taxes, contribution])
	plt.pie(donnees,labels=etiquettes,explode=extraire,colors=couleurs,shadow = False)
	plt.show()
	return 0

if __name__ == '__main__':
	import sys
	sys.exit(main(sys.argv))
					

Affichage du résultat

Tracé du diagramme de Venn

Ce tracé se fait en utilisant le module matplotlib_venn

• venn2(liste ensembles,liste des noms des ensembles) pour la création d'un diagramme de Venn avec 2 ensembles, renvoie un objet diagramme.
• objetdiagramme.get_label_by_id(id).set_text(chaine variables) affichage dans chaque partie du digramme la liste des éléments, après que ceux-ci aient été convertis en chaînes de caractères. id est l'identificateur de la partie concernée, si A est le premier ensemble transmis et B le deuxième, on a :
  • "10" pour les éléments de A n'appartenant pas à B
  • "01" pour les éléments de B n'appartenant pas à A
  • "11" pour les éléments de A appartenant également à B

import matplotlib.pyplot as plt
from matplotlib_venn import venn2

def main(args):
	A={0,1,2,3,4,5}
	B={4,5,6,7,8,9}
	C=set(map(str,A-B))
	D=set(map(str,B-A))
	E=set(map(str,A & B))
	venn=venn2((A,B),('A','B'))
	venn.get_label_by_id('10').set_text(';'.join(C))
	venn.get_label_by_id('01').set_text(';'.join(D))
	venn.get_label_by_id('11').set_text(';'.join(E))
	plt.show()
	return 0

if __name__ == '__main__':
	import sys
	sys.exit(main(sys.argv))
					

Affichage du résultat

Programmation objet

Définitions

Le concept objet a été présenté avec le langage C++. On présente donc la syntaxe objet en python

class nom_classe:

	def __init__(self,parametres):
		# initialisation des attributs
		self.attribut = 
		seld.__attribut = 

	def methode(self,parametres):
		# traitement
		# eventuellement valeur de retour
		return valeurretour
		
	def __add__(self,parametres):
		# traitement
		return objet
				

from math import *

class Complexe():
	def __init__(self,c):
		self.__z = c
		
	def get(self):
		return self.__z

	def module(self):
		m=abs(self.__z)
		return m
		
	def argument(self):
		a=atan2(self.__z.imag,self.__z.real)
		return a
	
	def conjugue(self):
		zbar=self.__z.conjugate()
		return Complexe(zbar)

	def __add__(self,z2):
		s = self.__z + z2.get()
		return Complexe(s)
		
	def __sub__(self,z2):
		d = self.__z + z2.get()
		return Complexe(d)
	
	def __mul__(self,z2):
		p = self.__z * z2.get()
		return Complexe(p)
		
	def __truediv__(self,z2):
		q = self.__z / z2.get()
		return Complexe(q)
					

from complexes import Complexe

def main(args):
	z1=Complexe(1+3j)
	z2=Complexe(1+1j)
	m1=z1.module()
	print(f"||{z1.get()}|| = {m1}")
	a1=z1.argument()
	print(f"arg({z1.get()}) = {a1}")
	z1bar=z1.conjugue()
	print(f"/{z1.get()} = {z1bar.get()}")	
	zs = z1 + z2
	print(f"{z1.get()} + {z2.get()} = {zs.get()}")	
	zp = z1 * z2
	print(f"{z1.get()} X {z2.get()} = {zp.get()}")	
	return 0

if __name__ == '__main__':
	import sys
	sys.exit(main(sys.argv))
					

Héritage

from module import classe_parent
					
class nom_classe(classe_parent):

	def __init__(self,parametres):
		classe_parent.__init__(parametres parents)
		# initialisation des attributs
		self.attribut = 
		seld.__attribut = 
		
	def methode(self,parametres):
		pass

	def methode(self,parametres):
		# traitement
		# eventuellement valeur de retour
		return valeurretour
				

Héritage multiple

from module import classe1
from module2 import classe2
					
class nom_classe(classe1,classe2):

	def __init__(self,parametres):
		classe1.__init__(parametres parents1)
		classe2.__init__(parametres parents2)
		# initialisation des attributs
		self.attribut = 
		seld.__attribut = 

	def methode(self,parametres):
		# traitement
		# eventuellement valeur de retour
		return valeurretour
				

Exemple de calcul de l'intégrale d'une fonction polynomiale déjà vue en C++

class Polynome():
	
	def __init__(self,p):
		self.coeffs = p
		self.taille = len(p)
	
	def Horner(self,x):
		y = self.coeffs[self.taille-1]
		for i in range(self.taille-1):
			y = self.coeffs[self.taille-i-2]+x*y
		return y
					

class Integrale():
	
	def __init__(self,a,b):
		self.a = a
		self.b = b
		self.dx = 0.01
		
	def fonction(self,x):
		pass
		
	def calculer(self):
		total = 0
		n = (self.b-self.a)/self.dx
		x0=self.a
		while x0 < self.b:
			total += (self.fonction(x0)+self.fonction(x0+self.dx))*self.dx/2
			x0 += self.dx
		return total;
					

from Integrale import Integrale
from Polynome import Polynome

class IntegralePolynome(Integrale,Polynome):
	
	def __init__(self,p,a,b):
		Integrale.__init__(self,a,b)
		Polynome.__init__(self,p)
	
	def fonction(self,x):
		return self.Horner(x)
					

from IntegralePolynome import IntegralePolynome

def main(args):
	polynome = [ -1 , 0.5 ]
	integralepoly=IntegralePolynome(polynome,2,6)
	aire = integralepoly.calculer()
	print(f"aire = {aire}")
	return 0

if __name__ == '__main__':
	import sys
	sys.exit(main(sys.argv))