Une variable est un espace mémoire dans lequel il est possible de stocker une valeur (une donnée).
Ouvrir IDLE :
Démarrer → Programmes → Python → IDLE (Python GUI)
Le nom d'une variable s'écrit avec des lettres (non accentuées), des chiffres ou bien l'underscore _
Le nom d'une variable ne doit pas commencer par un chiffre.
En langage Python, l'usage est de ne pas utiliser de lettres majuscules pour nommer les variables (celles-ci sont réservées pour nommer les classes).
Exemple : age, mon_age, temperature1
A éviter : Age, AGE, MonAge, monAge, Temperature1
Pour affecter (on dit aussi assigner) la valeur 17 à la variable nommée age :
>>> age = 17
La fonction print() affiche la valeur de la variable :
>>> print(age)
17
La fonction type() retourne le type de la variable :
>>> print(type(age))
<class 'int'>
int est le type des nombres entiers.
| >>> # ceci est un commentaire >>> age = age + 1 # en plus court : age += 1 >>> print(age) 18 >>> age = age - 3 # en plus court : age -= 3 >>> print(age) 15 >>> age = age*2 # en plus court : age *= 2 >>> print(age) 30 >>> a = 6*3 - 20 >>> print(a) -2 >>> b = 25 >>> c = a + 2*b >>> print(b, c) # ne pas oublier la virgule 25 48 |
L'opérateur // donne la division entière :
>>> tour = 450//360
>>> print(tour)
1
L'opérateur % donne le reste de la division (opération modulo) :
>>> angle = 450%360
>>> print(angle)
90
L'opérateur ** donne la puissance :
>>> mo = 2**20
>>> print(mo)
1048576
>>> racine2 = 2**0.5
>>> print(racine2)
1.41421356237
>>> b = 17.0 # le séparateur décimal est un point (et non une virgule)
>>> print(b)
17.0
>>> print(type(b))
<class 'float'>
>>> c = 14.0/3.0
>>> print(c)
4.66666666667
>>> c = 14.0//3.0 # division entière
>>> print(c)
4.0
Attention : avec des nombres entiers, l'opérateur / fait une division classique et retourne un type float :
>>> c = 14/3 >>> print(c)
4.66666666667
Notation scientifique :
>>> a = -1.784892e4
>>> print(a)
-17848.92
Pour utiliser les fonctions mathématiques, il faut commencer par importer le module math :
>>> import math
La fonction dir() retourne la liste des fonctions et données d'un module :
>>> dir(math)
['__doc__', '__name__', '__package__', 'acos', 'acosh', 'asin', 'asinh', 'atan',
'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf',
'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum',
'gamma', 'hypot', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p',
'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']
Pour appeler une fonction d'un module, la syntaxe est la suivante : module.fonction(arguments)
Pour accéder à une donnée d'un module :
| >>> print() # donnée pi du module math (nombre pi) 3.14159265359 >>> print(()) # fonction sin() du module math (sinus) 0.707106781187 >>> print((2.0)) # fonction sqrt() du module math (racine carrée) 1.41421356237 >>> print((-5.0)) Traceback (most recent call last): print (-5.0) ValueError: math domain error >>> print((-3.0)) # fonction exp() du module math (exponentielle) 0.0497870683679 |
>>> print((math.e)) # fonction log() du module math (logarithme népérien)
1.0
| >>> nom = 'Dupont' # entre apostrophes >>> print(nom) Dupont >>> print(type(nom)) <class 'str'> >>> prenom = "Pierre" # on peut aussi utiliser les guillemets >>> print(prenom) Pierre >>> print(nom, prenom) # ne pas oublier la virgule Dupont Pierre |
La concaténation désigne la mise bout à bout de plusieurs chaînes de caractères.
La concaténation utilise l'opérateur +
>>> chaine = nom + prenom # concaténation de deux chaînes de caractères
>>> print(chaine)
DupontPierre
>>> chaine = prenom + nom # concaténation de deux chaînes de caractères
>>> print(chaine)
PierreDupont
>>> chaine = prenom + ' ' + nom
>>> print(chaine)
Pierre Dupont
>>> chaine = chaine + ' 18 ans'# en plus court : chaine += ' 18 ans'
>>> print(chaine)
Pierre Dupont 18 ans
La fonction len() retourne la longueur (length) de la chaîne de caractères :
>>> print(len(chaine))
20
Indexage et slicing :
| >>> print(chaine[0]) # premier caractère (indice 0) P >>> print(chaine[1]) # deuxième caractère (indice 1) i >>> print(chaine[1:4]) # slicing ier >>> print(chaine[2:]) # slicing erre Dupont 18 ans >>> print(chaine[-1]) # dernier caractère (indice -1) s >>> print(chaine[-6:]) # slicing 18 ans |
En résumé :
+---+---+---+---+---+---+
| M | u | r | i | e | l |
+---+---+---+---+---+---+
0 1 2 3 4 5 6
-6 -5 -4 -3 -2 -1
| >>> chaine = 'Aujourd' SyntaxError: invalid syntax | hui | ' | |
| >>> chaine = 'Aujourd\'hui' d'échappement \' >>> print(chaine) Aujourd'hui >>> chaine = "Aujourd'hui" >>> print(chaine) Aujourd'hui | # séquence | ||
La séquence d'échappement \n représente un saut ligne :
>>> chaine = 'Première ligne\nDeuxième ligne'
>>> print(chaine)
Première ligne
Deuxième ligne
Plus simplement, on peut utiliser les triples guillemets (ou les triples apostrophes) pour encadrer une chaîne définie sur plusieurs lignes :
| >>> chaine = """Première ligne Deuxième ligne""" >>> print(chaine) Première ligne Deuxième ligne |
On ne peut pas mélanger les serviettes et les torchons (ici type str et type int) :
| >>> chaine = '17.45' >>> print(type(chaine)) <class 'str'> >>> chaine = chaine + 2 TypeError: Can't convert 'int' object to str implicitly |
La fonction float() permet de convertir un type str en type float
>>> nombre = float(chaine)
>>> print(nombre)
17.45
| >>> print(type(nombre)) <class 'float'> >>> nombre = nombre + 2 nombre += 2 >>> print(nombre) 19.45 | # en plus court : |
La fonction input() lance une invite de commande (en anglais : prompt) pour saisir une chaîne de caractères.
>>> # saisir une chaîne de caractères et valider avec la touche Enter
>>> chaine = input("Entrer un nombre : ")
Entrer un nombre : 14.56
>>> print(chaine)
14.56
>>> print(type(chaine))
<class 'str'>
>>> nombre = float(chaine)# conversion de type
>>> print(nombre**2)
211.9936
Une liste est une structure de données.
Le premier élément d'une liste possède l'indice (l'index) 0.
Dans une liste, on peut avoir des éléments de plusieurs types.
>>> infoperso = ['Pierre', 'Dupont', 17, 1.75,
72.5]
>>> # la liste infoperso contient 5 éléments de types str, str, int, float et float
>>> print(type(infoperso))
<class 'list'>
>>> print(infoperso)
['Pierre', 'Dupont', 17, 1.75, 72.5]
| >>> print('Prénom : ', infoperso[0]) | # |
| premier élément (indice 0) Prénom : Pierre >>> print('Age : ', infoperso[2]) | # le |
| troisième élément a l'indice 2 Age : 17 >>> print('Taille : ', infoperso[3]) quatrième élément a l'indice 3 Taille : 1.75 | # le |
La fonction range() crée une liste d'entiers régulièrement espacés :
| >>> maliste = range(10) >>> print(list(maliste)) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> print(type(maliste)) <class 'range'> >>> maliste = range(1,10,2) | # range(début,fin |
| non comprise,intervalle) >>> print(list(maliste)) [1, 3, 5, 7, 9] >>> print(maliste[2]) élément a l'indice 2 5 | # le troisième |
On peut créer une liste de listes, qui s'apparente à un tableau à 2 dimensions (ligne, colonne) :
0 1 2
10 11 12
20 21 22
>>> maliste = [[0, 1, 2], [10, 11, 12], [20, 21, 22]]
>>> print(maliste[0])
[0, 1, 2]
>>> print(maliste[0][0])
0
| >>> print(maliste[2][1]) # élément à la troisième ligne et deuxième colonne 21 >>> maliste[2][1] = 69 # nouvelle affectation >>> print(maliste) [[0, 1, 2], [10, 11, 12], [20, 69, 22]] |
Deux valeurs sont possibles : True et False
>>> choix = True
>>> print(type(choix))
<class 'bool'>
Les opérateurs de comparaison :
| Opérateu r | Signification | Remarques |
| < | strictement inférieur | |
| <= | inférieur ou égal | |
| > | strictement supérieur | |
| >= | supérieur ou égal | |
| == | égal | Attention : deux signes == |
| != | différent |
>>> b = 10
>>> print(b > 8)
True
>>> print(b == 5)
False
>>> print(b != 10)
False
>>> print(0 <= b <= 20)
True
Les opérateurs logiques : and, or, not
>>> note = 13.0
>>> mention_ab = note >= 12.0 and note < 14.0 # ou bien : mention_ab = 12.0 <= note < 14.0
>>> print(mention_ab)
True
>>> print(not mention_ab)
False
>>> print(note == 20.0 or note == 0.0)
False
L'opérateur in s'utilise avec des chaînes (type str) ou des listes (type list) :
| >>> chaine = 'Bonsoir' >>> # la sous-chaîne 'soir' fait-elle partie de la chaîne 'Bonsoir' ? >>> resultat = 'soir' in chaine >>> print(resultat) True >>> print('b' in chaine) False >>> maliste = [4, 8, 15] >>> # le nombre entier 9 est-il dans la liste ? >>> print(9 in maliste) False >>> print(8 in maliste) True >>> print(14 not in maliste) True |
Un dictionnaire stocke des données sous la forme clé ⇒ valeur
Une clé est unique et n'est pas nécessairement un entier (comme c'est le cas de l'indice d'une liste).
>>> moyennes = {'math': 12.5, 'anglais': 15.8} # entre accolades
>>> print(type(moyennes))
<class 'dict'>
>>> print(moyennes['anglais']) # entre crochets
15.8
>>> moyennes['anglais'] = 14.3 # nouvelle affectation >>> print(moyennes)
{'anglais': 14.3, 'math': 12.5}
>>> moyennes['sport'] = 11.0 # nouvelle entrée
>>> print(moyennes)
{'sport': 11.0, 'anglais': 14.3, 'math': 12.5}
Nous avons vu les types les plus courants. Il en existe bien d'autres :
§ complex (nombres complexes, par exemple 1+2.5j)
§ tuple (structure de données)
§ set (structure de données)
§ file (fichiers)
§
Python est un langage de programmation orienté objet (comme les langages C++, Java, PHP, Ruby ).
Une variable est en fait un objet d'une certaine classe.
Par exemple, la variable amis est un objet de la classe list.
On dit aussi que la variable amis est une instance de la classe list. L'instanciation (action d'instancier) est la création d'un objet à partir d'une classe (syntaxe : NouvelObjet = NomdelaClasse(arguments)) :
>>> # instanciation de l'objet amis de la classe list
>>> amis = ['Nicolas', 'Julie']# ou bien : amis = list(['Nicolas', 'Julie'])
>>> print(type(amis))
<class 'list'>
Une classe possède des fonctions que l'on appelle méthodes et des données que l'on appelle attributs.
La méthode append() de la classe list ajoute un nouvel élément en fin de liste :
>>> # instanciation d'une liste vide
>>> amis = [] # ou bien : amis = list()
>>> amis.append('Nicolas')# synthase générale : objet.méthode(arguments)
>>> print(amis)
['Nicolas']
>>> amis.append('Julie') # ou bien : amis = amis + ['Julie']
>>> print(amis)
['Nicolas', 'Julie']
>>> amis.append('Pauline')
>>> print(amis)
['Nicolas', 'Julie', 'Pauline']
>>> () # la méthode sort() trie les éléments >>> print(amis)
['Julie', 'Nicolas', 'Pauline']
>>> amis.reverse() # la méthode reverse() inverse la liste des éléments
>>> print(amis)
['Pauline', 'Nicolas', 'Julie']
La méthode lower() de la classe str retourne la chaîne de caractères en casse minuscule :
>>> # la variable chaine est une instance de la classe str
| >>> chaine = "BONJOUR" # ou bien : chaine = str("BONJOUR") >>> chaine2 = chaine.lower() # on applique la méthode lower() à l'objet chaine >>> print(chaine2) bonjour >>> print(chaine) BONJOUR |
La méthode pop() de la classe dict supprime une clé :
>>> # instanciation de l'objet moyennes de la classe dict
>>> moyennes = {'sport': 11.0, 'anglais': 14.3, 'math': 12.5}
>>> # ou : moyennes = dict({'sport': 11.0,
'anglais': 14.3, 'math': 12.5})
>>> ('anglais')
14.3
>>> print(moyennes)
{'sport': 11.0, 'math': 12.5}
>>> print(()) # la méthode keys() retourne la liste des clés dict_keys(['sport', 'math'])
>>> print(moyennes.values()) # la méthode values() retourne la liste des valeurs dict_values([11.0, 12.5])
Exercice 1.1 ☆ Afficher la taille en octets et en bits d'un fichier de 536 ko.
On donne : 1 ko (1 kilooctet) = 210 octets !!!
1 octet = 1 byte = 8 bits
Exercice 1.2 ★ Le numéro de sécurité sociale est constitué de 13 chiffres auquel s'ajoute la clé de contrôle (2 chiffres).
Exemple : 1 89 11 26 108 268 91
La clé de contrôle est calculée par la formule : 97 - (numéro de sécurité sociale modulo 97)
Retrouver la clé de contrôle de votre numéro de sécurité sociale. Quel est l'intérêt de la clé de contrôle ?
Exercice 1.3 ★ Afficher la valeur numérique de √(4,63 - 15/16) Comparer avec votre calculette.
Exercice 1.4 ★ A partir des deux variables prenom et nom, afficher les initiales (par exemple LM pour Léa Martin).
Exercice 1.5 ★☆ L'identifiant d'accès au réseau du lycée est construit de la manière suivante : initiale du prénom puis les 8 premiers caractères du nom (le tout en minuscule).
Exemple : Alexandre Lecouturier → alecoutur
A partir des deux variables prenom et nom, construire l'identifiant.
Exercice 1.6 ★★ On donne un extrait des logins d'accès au réseau du lycée :
alecoutur Huz4 lmartin monty fsincere gnugpl
1) Créer une variable de type dict qui contient les couples identifiant - mot de passe ci-dessus.
2) La saisie du login fournit deux
variables identifiant et motdepasse : une pour l'identifiant et l'autre pour le mot de passe.
Construire une variable booléenne qui donne True en cas d'identification correcte, et False dans le cas contraire :
lmartin monty → True alecoutur fqsdf → False
martin monty → False (ce cas est plus compliqué à traiter)
| if expression: | # ne pas oublier le signe | |
| de ponctuation ':' | # attention à | |
| bloc d'instructions l'indentation # suite du programme | ||
Si l'expression est vraie (True) alors le bloc d'instructions est exécuté. Si l'expression est fausse (False) on passe directement à la suite du programme.
Nous allons commencer par créer le script :
Ouvrir IDLE :
Démarrer → Programmes → Python → IDLE (Python GUI)
File → New Window
Copier puis coller le code source ci-dessous :
| # script chaine = input("Note sur 20 : ") note = float(chaine) if note >= 10.0: # ce bloc est exécuté si l'expression (note >= 10.0) est vraie print("J'ai la moyenne") print("Fin du programme") |
File → Save As
Répertoire : C:\PythonXX
Nom du fichier :
Pour exécuter le script :
Run → Run Module (ou touche F5) :
>>>
Note sur 20 : 16 J'ai la moyenne
Fin du programme
>>>
Note sur 20 : 5 Fin du programme
Une instruction else est toujours associée à une instruction if
| if expression: | # attention à | ||
| bloc d'instructions 1 l'indentation | |||
| else: | # else est au même niveau | ||
| que if | # attention à | ||
| bloc d'instructions 2 l'indentation # suite du programme | |||
Si l'expression est vraie (True) alors le bloc d'instructions 1 est exécuté. Si l'expression est fausse (False) alors c'est le bloc d'instructions 2 qui est
exécuté.
| # script chaine = input("Note sur 20 : ") note = float(chaine) if note >= 10.0: # ce bloc est exécuté si l'expression (note >= 10.0) est vraie print("J'ai la moyenne") else: # ce bloc est exécuté si l'expression (note >= 10.0) est fausse print("C'est en dessous de la moyenne") print("Fin du programme") >>> Note sur 20 : 15 J'ai la moyenne Fin du programme >>> Note sur 20 : 8.5 C'est en dessous de la moyenne Fin du programme >>> Note sur 20 : 56 J'ai la moyenne |
Fin du programme
Pour traiter le cas des notes invalides (<0 ou >20), on peut imbriquer des instructions conditionnelles :
| # script chaine = input("Note sur 20 : ") note = float(chaine) if note > 20.0 or note < 0.0: # ce bloc est exécuté si l'expression (note > 20.0 or note < 0.0) est vraie print("Note invalide !") else: # ce bloc est exécuté si l'expression (note > 20.0 or note < 0.0) est fausse if note >= 10.0: # ce bloc est exécuté si l'expression (note >= 10.0) est vraie print("J'ai la moyenne") else: # ce bloc est exécuté si l'expression (note >= 10.0) est fausse print("C'est en dessous de la moyenne") print("Fin du programme") >>> Note sur 20 : 56 Note invalide ! Fin du programme >>> Note sur 20 : 14.6 J'ai la moyenne Fin du programme |
On ajoute encore un niveau d'imbrication pour traiter les cas particuliers 0 et 20 :
| # script chaine = input("Note sur 20 : ") note = float(chaine) if note > 20.0 or note < 0.0: print("Note invalide !") else: if note >= 10.0: print("J'ai la moyenne") if note == 20.0: # ce bloc est exécuté si l'expression (note == 20.0) est vraie print("C'est même excellent !") else: print("C'est en dessous de la moyenne") if note == 0.0: # ce bloc est exécuté si l'expression (note == 0.0) est vraie print(" lamentable !") print("Fin du programme") >>> Note sur 20 : 20 J'ai la moyenne C'est même excellent ! Fin du programme >>> Note sur 20 : 3 C'est en dessous de la moyenne Fin du programme |
Une instruction elif (contraction de else if) est toujours associée à une instruction if
| if expression 1: | |
| bloc d'instructions 1 expression 2: bloc d'instructions 2 expression 3: bloc d'instructions 3 # ici deux instructions f, mais il n'y a pas de limitation : bloc d'instructions 4 # suite du programme | |
| elif | |
| elif | |
| eli else | |
Si l'expression 1 est vraie alors le bloc d'instructions 1 est exécuté, et on passe à la suite du programme.
Si l'expression 1 est fausse alors on teste l'expression 2 :
§ si l'expression 2 est vraie on exécute le bloc d'instructions 2, et on passe à la suite du programme.
§ si l'expression 2 est fausse alors on teste l'expression 3, etc.
Le bloc d'instructions 4 est donc exécuté si toutes les expressions sont fausses (c'est le bloc "par défaut").
Parfois il n'y a rien à faire.
Dans ce cas, on peut omettre l'instruction else :
| if expression 1: | |
| bloc d'instructions 1 expression 2: bloc d'instructions 2 expression 3: bloc d'instructions 3 # suite du programme | |
| elif | |
| elif | |
L'instruction elif évite souvent l'utilisation de conditions imbriquées (et souvent compliquées).
| # script # ce script fait la même chose que note = float(input("Note sur 20 : ")) if note == 0.0: print("C'est en dessous de la moyenne") print(" lamentable !") elif note == 20.0: print("J'ai la moyenne") print("C'est même excellent !") elif note < 10.0 and note > 0.0: # ou bien : elif 0.0 < note < 10.0: print("C'est en dessous de la moyenne") elif note >= 10.0 and note < 20.0: # ou bien : elif 10.0 <= note < 20.0: print("J'ai la moyenne") else: print("Note invalide !") print("Fin du programme") >>> Note sur 20 : 20 J'ai la moyenne C'est même excellent ! Fin du programme >>> Note sur 20 : 3 C'est en dessous de la moyenne Fin du programme >>> |
Note sur 20 : 77 Note invalide !
Fin du programme
Exercice 2.1 ★ Le numéro de sécurité sociale est constitué de 13 chiffres auquel s'ajoute la clé de contrôle (2 chiffres).
La clé de contrôle est calculée par la formule : 97 - (numéro de sécurité sociale modulo 97)
Ecrire un script qui contrôle la validité d'un numéro de sécurité sociale. On pourra utiliser la fonction int()pour convertir le type str en type int.
Exemple :
>>>
Entrer votre numéro de sécurité sociale (13 chiffres) --> 1891126108268
Entrer votre clé de contrôle (2 chiffres)
--------------> 91
Votre numéro de sécurité sociale est valide. >>>
Entrer votre numéro de sécurité sociale (13 chiffres) --> 2891126108268
Entrer votre clé de contrôle (2 chiffres)
--------------> 91
Votre numéro de sécurité sociale est INVALIDE !
>>>
Exercice 2.2 ★ Nombre entier non signé et signé
Dans un octet, on peut stocker un nombre entier compris entre
0b00000000 = 0 et 0b11111111 = 255 (entier non signé, en numération binaire naturel).
On peut aussi stocker un entier compris entre -128 et +127 (entier signé, représentation dite en complément à deux).
En complément à deux, les nombres négatifs sont codés de la manière suivante :
-1 correspond à 255 en binaire naturel
-2 correspond à 254 en binaire naturel
-127 correspond à 129 en binaire naturel
-128 correspond à 128 en binaire naturel
1) Ecrire un script qui donne la correspondance entre entier signé et entiernon signé. Par exemple :
>>>
Entrer un entier signé en complément à deux (-128 à +127): 25
La représentation en binaire naturel est : 25
>>>
Entrer un entier signé en complément à deux (-128 à +127): -15
La représentation en binaire naturel est : 241
2) Ecrire un script qui donne la correspondance entre entier non signé et entier signé. Par exemple :
>>>
Entrer un nombre entier (0 à 255): 250
Cela représente l'entier signé : -6
Exercice 2.3 ★ Ecrire un script qui demande la note au bac et qui affiche la mention correspondante. Par exemple :
>>>
Note au bac (sur 20) : 13.5 Bac avec mention Assez Bien >>>
Note au bac (sur 20) : 10.9
Bac avec mention Passable
>>>
Note au bac (sur 20) : 4
Recalé
>>>
Exercice 2.4 ★ Ecrire un script qui calcule l'indice de masse corporelle (IMC) d'un adulte et qui en donne l'interprétation (corpulence normale, surpoids ).
Par exemple :
>>>
Votre taille en cm ? 170
Votre masse en kg ? 68.5
IMC = 23.70 kg/m²
Interprétation : corpulence normale
>>>
Exercice 2.5 ★★ Ecrire un script qui résout l'équation du second degré : ax² + bx + c = 0 Par exemple :
| >>> Résolution de l'équation du second degré : ax² + bx + c = 0 Coefficient a ? 1 Coefficient b ? -0.9 Coefficient c ? 0.056 Discriminant : 0.586 Deux solutions : 0.0672468158199 0.83275318418 >>> Résolution de l'équation du second degré : ax² + bx + c = 0 Coefficient a ? 2 Coefficient b ? 1.5 Coefficient c ? 4 Discriminant : -29.75 Il n'y a pas de solution. |
Une boucle permet d'exécuter une portion de code plusieurs fois de suite.
| while expression: | # ne pas oublier le signe | |
| de ponctuation ':' | # attention à | |
| bloc d'instructions l'indentation # suite du programme | ||
Si l'expression est vraie (True) le bloc d'instructions est exécuté, puis l'expression est à nouveau évaluée.
Le cycle continue jusqu'à ce que l'expression soit fausse (False) : on passe alors à la suite du programme.
# script
# initialisation de la variable de comptage
| compteur = 1 while compteur < 5: # ce bloc est exécuté tant que la condition (compteur < 5) est vraie print(compteur, compteur < 5) compteur += 1 # incrémentation du compteur, compteur = compteur + 1 print(compteur < 5) print("Fin de la boucle") >>> 1 True 2 True 3 True 4 True False Fin de la boucle |
# script
compteur = 1 # initialisation de la variable de comptage while compteur <= 10:
# ce bloc est exécuté tant que la condition
(compteur <= 10) est vraie print(compteur, '* 8 =', compteur*8) compteur += 1 # incrémentation du compteur, compteur = compteur + 1 print("Et voilà !")
>>>
1 * 8 = 8
2 * 8 = 16
3 * 8 = 24
4 * 8 = 32
5 * 8 = 40
6 * 8 = 48
7 * 8 = 56
8 * 8 = 64
9 * 8 = 72
10 * 8 = 80 Et voilà !
| # script import time # importation du module time quitter = 'n' # initialisation while quitter != 'o': # ce bloc est exécuté tant que la condition est vraie # strftime() est une fonction du module time print('Heure courante ', time.strftime('%H:%M: %S')) quitter = input("Voulez-vous quitter le programme (o/n) ? ") print("A bientôt") >>> Heure courante 09:48:54 Voulez-vous quitter le programme (o/n) ? n Heure courante 09:48:58 Voulez-vous quitter le programme (o/n) ? o A bientôt |
| for élément in séquence : | |
| bloc d'instructions # suite du programme | |
Les éléments de la séquence sont issus d'une chaîne de caractères ou bien d'une liste.
| # script chaine = 'Bonsoir' for lettre in chaine: variable d'itération print(lettre) print("Fin de la boucle") | # lettre est la |
La variable lettre est initialisée avec le premier élément de la séquence ('B').
Le bloc d'instructions est alors exécuté.
Puis la variable lettre est mise à jour avec le second élément de la séquence ('o') et le bloc d'instructions à nouveau exécuté Le bloc d'instructions est exécuté une dernière fois lorsqu'on arrive au dernier élément de la séquence ('r') :
| >>> B o n s o i r Fin de la boucle |
# script
maliste = ['Pierre', 67.5, 18] for element in maliste: print(element) print("Fin de la boucle")
Là, on affiche dans l'ordre les éléments de la liste :
>>>
Pierre
67.5
18
Fin de la boucle
L'association avec la fonction range() est très utile pour créer des séquences automatiques de nombres entiers :
# script print(list(range(1,5)))
for i in range(1,5):
print(i) print("Fin de la boucle")
>>>
[1, 2, 3, 4]
1
2
3
4
Fin de la boucle
La création d'une table de multiplication paraît plus simple avec une boucle for qu'avec une boucle while :
| # script for compteur in range(1,11): print(compteur, '* 9 =', compteur*9) print("Et voilà !") >>> 1 * 9 = 9 2 * 9 = 18 3 * 9 = 27 4 * 9 = 36 5 * 9 = 45 6 * 9 = 54 7 * 9 = 63 8 * 9 = 72 9 * 9 = 81 10 * 9 = 90 Et voilà ! |
L'instruction break provoque une sortie immédiate d'une boucle while ou d'une boucle for.
Dans l'exemple suivant, l'expression True est toujours vraie : on a une boucle sans fin.
L'instruction break est donc le seul moyen de sortir de la boucle.
# script
import time # importation du module time while True:
# strftime() est une fonction du module time print('Heure courante ', time.strftime('%H:%M:
%S'))
| quitter = input('Voulez-vous quitter le programme (o/n) ? ') if quitter == 'o': break print("A bientôt") >>> Heure courante 14:25:12 Voulez-vous quitter le programme (o/n) ? n Heure courante 14:25:20 Voulez-vous quitter le programme (o/n) ? o A bientôt |
Si vous connaissez le nombre de boucles à effectuer, utiliser une boucle for.
Autrement, utiliser une boucle while (notamment pour faire des boucles sans fin).
Exercice 3.1 ★ Ecrire un script qui affiche toutes les tables de multiplication (de 1 à 10).
Exercice 3.2 ★ Ecrire un script qui calcule la moyenne d'une série de notes.
On pourra utiliser une variable qui contient la somme intermédiaire des notes.
>>>
Nombre de notes ? 3
--> 15
--> 11.5
--> 14
Moyenne : 13.5
>>>
Exercice 3.3 ★
1) Avec une boucle for, écrire un script qui compte le nombre de lettres z dans une chaîne de caractères. Par exemple :
>>>
Entrer la chaîne : Zinedine Zidane
Résultat : 2
2) Faire la même chose, directement avec la méthode count() de la classe str.
Pour obtenir de l'aide sur cette méthode :
>>> help(str.count)
Exercice 3.4 ★ Avec une boucle while, écrire un script qui affiche l'heure courante avec une actualisation chaque seconde.
On utilisera la fonction sleep() du module time. Pour obtenir de l'aide sur cette fonction :
>>> import time >>> help(time.sleep)
Par exemple :
>>> # Taper CTRL + C pour arrêter le programme.
>>>
Heure courante 12:40:59
Heure courante 12:41:00
Heure courante 12:41:01
Heure courante 12:41:02
KeyboardInterrupt
>>>
Remarque : il est vilain de forcer l'arrêt d'un programme avec CTRL + C Nous verrons comment interrompre proprement un programme dans le chapitreGestion des exceptions.
Exercice 3.5 ★☆
1) Ecrire le script du jeu de devinette suivant :
>>>
Le jeu consiste à deviner un nombre entre 1 et 100 :
| ---> 50 trop petit ! ---> 75 trop petit ! ---> 87 trop grand ! ---> 81 trop petit ! ---> 84 trop petit ! ---> 85 Gagné en 6 coups ! |
2) Quelle est la stratégie la plus efficace ?
3) Montrer que l'on peut deviner un nombre en 7 coups maximum.
Bibliographie :La dichotomie
Remarque : pour créer un nombre entier aléatoire entre 1 et 100 :
import random
nombre = random.randint(1,100)
Exercice 3.6 ★★ Code de César
En cryptographie, le code de César est une technique de chiffrement élémentaire qui consiste à décaler une lettre de 3 rangs vers la droite :
A → D
B → E
Z → C
1) Ecrire le script de ce exemple :
>>>
Message à coder ? abcdefghijklmnopqrstuvwxyz defghijklmnopqrstuvwxyzabc
>>>
Message à coder ? Monty Python's Flying Circus prqwb sbwkrq'v ioblqj flufxv
On pourra utiliser la chaîne 'abcdefghijklmnopqrstuvwxyz' et la méthode find() de la classe str.
Pour obtenir de l'aide sur cette méthode :
>>> help()
2) Ecrire le script du dé exemple :
>>>
Message à décoder ? prqwb sbwkrq'v ioblqj flufxv monty python's flying circus
Exercice 3.7 ★★ Ecrire un script qui donne l'évolution de la suite convergente : un+1 = un/2 + 1/un Par exemple :
>>>
Valeur initiale ? 20
Jusqu'à quel rang ? 10
0 20.0
1 10.05
2 5.12450248756
3 2.75739213842
4 1.74135758045
5 1.44494338196
6 1.41454033013
7 1.41421360012
8 1.41421356237
9 1.41421356237
10 1.41421356237
>>>
Exercice 3.8 ★★ Fraction continue infinie
Estimer la valeur numérique de la fraction continue suivante :
Comparer avec la valeur exacte : (1 + √5)/2
Exercice 3.9
1) ★ Ecrire un script qui détermine si un nombre entier est premier ou pas. Par exemple :
>>>
Nombre ? 17
17 est un nombre premier
2) ★★ Ecrire un script qui décompose un nombre entier en un produit de facteurs premiers.
>>>
Nombre à décomposer ? 2142
Nous avons déjà vu beaucoup de fonctions : print(), type(), len(), input(), range()
Ce sont des fonctions pré-définies (built-in functions).
Nous avons aussi la possibilité de créer nos propres fonctions !
Une fonction est une portion de code que l'on peut appeler au besoin (c'est une sorte de sous-programme).
L'utilisation des fonctions évite des redondances dans le code : on obtient ainsi des programmes plus courts et plus lisibles.
Par exemple, nous avons besoin de convertir à plusieurs reprises des degrés Celsius en degrés Fahrenheit :
>>> print(100.0*9.0/5.0 + 32.0)
212.0
>>> print(37.0*9.0/5.0 + 32.0)
98.6
>>> print(233.0*9.0/5.0 + 32.0)
451.4
La même chose en utilisant une fonction :
>>> def fahrenheit(degre_celsius):
""" Conversion degré Celsius en degré Fahrenheit """ print(degre_celsius*9.0/5.0 + 32.0)
>>> fahrenheit(100)
212.0
>>> fahrenheit(37)
98.6
>>> temperature = 233
>>> fahrenheit(temperature)
451.4
Rien ne vous oblige à définir des fonctions dans vos scripts, mais cela est tellement pratique qu'il serait improductif de s'en passer !
| def nom_de_la_fonction(parametre1, parametre2, parametre3, ): | |
| """ Documentation on peut écrire plusieurs lignes """ # docstring entouré de 3 llemets (ou apostrophes) bloc d'instructions # attention à ndentation return resultat # la fonction retourne le
contenu de la variable resultat | |
| qu' sur gui | |
| l'i | |
# script
def mapremierefonction(): # cette fonction n'a pas de paramètre
""" Cette fonction affiche 'Bonjour' """ print("Bonjour") return # cette fonction ne retourne rien ('None')
# l'instruction return est ici
facultative
Une fois la fonction définie, nous pouvons l'appeler :
| >>> mapremierefonction() parenthèses () Bonjour | # ne pas oublier les |
L'accès à la documentation se fait avec la fonction pré-définie help() :
>>> help(mapremierefonction) # affichage de la documentation
Help on function mapremierefonction in module __main__:
mapremierefonction()
Cette fonction affiche 'Bonjour'
La fonction suivante simule le comportement d'un dé à 6 faces.
Pour cela, on utilise la fonction randint() du modulerandom.
# script
def tirage_de():
""" Retourne un nombre entier aléatoire entre 1 et 6 """ import random valeur = random.randint(1, 6) return valeur >>> print(tirage_de()) 3
>>> print(tirage_de())
6
>>> resultat = tirage_de()
>>> print(resultat)
1
| # script # définition des fonctions def info(): """ Informations """ print("Touche q pour quitter") print("Touche Enter pour continuer") def tirage_de(): """ Retourne un nombre entier aléatoire entre 1 et 6 """ import random valeur = random.randint(1, 6) return valeur # début du programme info() while True: choix = input() if choix == 'q': break print("Tirage :", tirage_de()) >>> Touche q pour quitter Touche Enter pour continuer |
Tirage : 5
Tirage : 6 q >>>
Une fonction avec deux paramètres :
| # script # définition de fonction def tirage_de2(valeur_min, valeur_max): """ Retourne un nombre entier aléatoire entre valeur_min et valeur_max """ import random return random.randint(valeur_min, valeur_max) # début du programme for i in range(5): print(tirage_de2(1, 10)) # appel de la fonction avec les arguments 1 et 10 >>> 6 7 1 10 2 >>> |
Une fonction qui retourne une liste :
# script
| # définition de fonction def tirage_multiple_de(nombretirage): """ Retourne une liste de nombres entiers aléatoires entre 1 et 6 """ import random resultat = [random.randint(1, 6) for i in range(nombretirage)] # compréhension de listes (Cf. annexe) return resultat # début du programme print(tirage_multiple_de(10)) >>> [4, 1, 3, 3, 2, 1, 6, 6, 2, 5] >>> help(tirage_multiple_de) Help on function tirage_multiple_de in module __main__: tirage_multiple_de(nombretirage) Retourne une liste de nombres entiers aléatoires entre 1 et 6 |
Une fonction qui affiche la parité d'un nombre entier.
Il peut y avoir plusieurs instructions return dans une fonction.
L'instruction return provoque le retour immédiat de la fonction.
| # script # définition de fonction def parite(nombre): """ Affiche la parité d'un nombre entier """ if nombre%2 == 1: # L'opérateur % donne le reste d'une division |
| print(nombre, 'est impair') return if nombre%2 == 0: print(nombre, 'est pair') return >>> parite(13) 13 est impair >>> parite(24) 24 est pair |
La portée d'une variable est l'endroit du programme où on peut accéder à la variable.
Observons le script suivant :
| a = 10 # variable globale au programme def mafonction(): a = 20# variable locale à la fonction print(a) return >>> print(a) # nous sommmes dans l'espace global du programme 10 >>> mafonction() # nous sommes dans l'espace local de la fonction 20 >>> print(a) # de retour dans l'espace global 10 |
Nous avons deux variables différentes qui portent le même nom a
Une variable a de valeur 20 est créée dans la fonction : c'est une variable locale à la fonction.
Elle est détruite dès que l'on sort de la fonction.
global
L'instruction global rend une variable globale :
a = 10 # variable globale
def mafonction():
global a # la variable est maintenant globale a = 20 print(a) return >>> print(a)
10
>>> mafonction()
20
>>> print(a)
20
Remarque : il est préférable d'éviter l'utilisation de l'instruction global car c'est une source d'erreurs (on peut ainsi modifier le contenu d'une variable globale en croyant agir sur une variable locale). La sagesse recommande donc de suivre la règle suivante :
§ ne jamais affecter dans un bloc de code local une variable de même nom qu'une variable globale
La compréhension de listes est une structure syntaxique disponible dans un certain nombre de langages de programmation, dont Python. C'est une manière de créer efficacement des listes.
Revenons sur l'exemple vu dans le script :
resultat = [random.randint(1, 6) for i in range(10) ]
>>> print(resultat)
[3, 1, 5, 6, 4, 2, 1, 1, 3, 1]
carres = [i*i for i in range(11)]
>>> print(carres)
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
La compréhension de listes évite donc d'écrire le code "classique" suivant :
carres = [] for i in range(11): carres.append(i*i)
Exercice 4.1 ☆
1) Ecrire une fonction carre() qui retourne le carré d'un nombre :
>>> print(carre(11.11111))
123.4567654321
2) Avec une boucle while et la fonction carre(), écrire un script qui affiche le carré des nombres entiers de 1 à 100 :
| >>> 1² = 1 2² = 4 3² = 9 99² = 9801 100² = 10000 Fin du programme |
Exercice 4.2 ☆
1) Ecrire une fonction qui retourne l'aire de la surface d'un disque de rayon R. Exemple :
>>> print(airedisque(2.5))
19.6349540849
2) Ajouter un paramètre qui précise l'unité de mesure :
>>> print(airedisque2(4.2, 'cm'))
55.4176944093 cm²
Exercice 4.3 ★
1) Ecrire une fonction qui retourne la factorielle d'un nombre entier N.
On rappelle que : N ! = 1×2× ×(N-1)×N Exemple :
>>> print(factorielle(50))
304140932017133780436126081660647688443776415689605 12000000000000
2) Comparez avec le résultat de la fonctionfactorial() du module math.
Exercice 4.4 ★
1) A l'aide de la fonction randint() du module random, écrire une fonction qui retourne un mot de passe de longueur N (chiffres, lettres minuscules ou majuscules). On donne :
chaine =
'0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz'
>>> print(password(10)) mHVeC5rs8P
>>> print(password(6))
PYthoN
2) Reprendre la question 1) avec la fonction choice() du module random.
Pour obtenir de l'aide sur cette fonction :
>>> import random
>>> help(random.choice)
3) Quel est le nombre de combinaisons possibles ?
4) Quelle durée faut-il pour casser le mot de passe avec un logiciel capable de générer 1 million de combinaisons par seconde ? Lien utile
Exercice 4.5 ★ Ecrire une fonction qui retourne une carte (au hasard) d'un jeu de Poker à 52 cartes.
On utilisera la fonction choice() ou randint() du module random.
On donne :
ListeCarte =
['2s','2h','2d','2c','3s','3h','3d','3c','4s','4h',
'4d','4c','5s','5h','5d','5c',
'6s','6h','6d','6c','7s','7h','7d','7c','8s','8h','
8d','8c','9s','9h','9d','9c',
'Ts','Th','Td','Tc','Js','Jh','Jd','Jc','Qs','Qh','
Qd','Qc','Ks','Kh','Kd','Kc','As','Ah','Ad','Ac'] >>> print(tiragecarte()) 7s
>>> print(tiragecarte())
Kd
Exercice 4.6 ★★
1) Ecrire une fonction qui retourne une liste de N cartes différentes d'un jeu de Poker à 52 cartes.
Noter qu'une fonction peut appeler une fonction : on peut donc réutiliser la fonction tiragecarte() de l'exercice précédent. Exemple :
>>> print(tirage_n_carte(2))
['As', 'Ah']
>>> print(tirage_n_carte(25))
['Jc', 'Jh', 'Tc', '2d', '3h', 'Qc', '8d', '7c', 'As', 'Td', '8h', '9c', 'Ad', 'Qh',
'Kc', '6s', '5h', 'Qd', 'Kh', '9h', '5d', 'Js', 'Ks', '5c', 'Th']
2) Simplifier le script avec la fonction shuffle() ou sample() du module random.
Exercice 4.7 ★ Ecrire une fonction qui retourne une grille de numéros du jeu Euro Millions.
On utilisera la fonction sample() du module random.
>>> print(euromillions())
[37, 23, 9, 11, 49, 2, 11]
>>> print(euromillions()) [16, 32, 8, 30, 40, 6, 4]
Exercice 4.8 ★★
1) Ecrire une fonction qui retourne la valeur de la fonction mathématique f(x)= 27x3 -27x2 -18x +8 :
>>> print(f(0), f(1), f(0.5), f(0.25), f(0.375))
8.0 -10.0 -4.375 2.234375 -1.123046875
2) On se propose de chercher les zéros de cette fonction par laméthode .
Ecrire le script correspondant.
| >>> Recherche d'un zéro dans l'intervalle [a,b] a? 0 b? 1 Précision ? 1e-12 0.5 0.25 0.375 0.3125 0.34375 0.328125 0.3359375 0.33203125 0.333984375 0.3330078125 0.33349609375 0.333251953125 |
0.333333333333
>>>
3) Chercher tous les zéros de cette fonction.
Annexe : représentation graphique de la fonction f(x)= 27x3 -27x2 -
18x +8 (graphique réalisé avec la librairiematplotlib de Python)
Intéressons-nous au script suivant :
# script chaine = input('Entrer un nombre : ') nombre = float(chaine) inverse = 1.0/nombre
print("L'inverse de", nombre, "est :", inverse)
Ce script vous demande de saisir un nombre, puis il calcule et affiche son inverse.
Quand vous entrez un nombre, tout se déroule normalement :
>>>
Entrer un nombre : 10
L'inverse de 10.0 est : 0.1
>>>
Mais que se passe-t-il autrement ?
| >>> Entrer un nombre : bonjour Traceback (most recent call last): File "", line 3, in <module> nombre = float(chaine) ValueError: could not convert string to float: bonjour >>> >>> Entrer un nombre : 0 Traceback (most recent call last): File "", line 4, in <module> inverse = 1.0/nombre ZeroDivisionError: float division by zero >>> |
Python a détecté une erreur : une exception est levée.
Ici nous avons une exception de type ZeroDivisionError (division par 0) et une exception de type ValueError.
Une exception arrête l'exécution normale d'un programme.
Heureusement, il est possible de gérer les exceptions pour éviter l'arrêt brutal du programme.
Par cela, on utilise conjointement les instructions try et except. L'instruction else est optionnelle :
try:
| chaine = input('Entrer un nombre : ') nombre = float(chaine) inverse = 1.0/nombre except: #ce bloc est exécuté si une exception est levée dans le bloc try print("Erreur !") else: #on arrive ici si aucune exception n'est levée dans le bloc try print("L'inverse de", nombre, "est :", inverse) >>> Entrer un nombre : 56 L'inverse de 56.0 est : 0.0178571428571 >>> Entrer un nombre : 0 Erreur ! >>> |
On peut distinguer les différents types d'exceptions :
| try: chaine = input('Entrer un nombre : ') nombre = float(chaine) inverse = 1.0/nombre except ValueError: #ce bloc est exécuté si une exception de type ValueError est levée dans le bloc try print(chaine, "n'est pas un nombre !") except ZeroDivisionError: #ce bloc est exécuté si une exception de type ZeroDivisionError est levée dans le bloc try print("Division par zéro !") |
| else: #on arrive ici si aucune exception n'est levée dans le bloc try print("L'inverse de", nombre, "est :", inverse) >>> Entrer un nombre : 0 Division par zéro ! >>> Entrer un nombre : bonjour bonjour n'est pas un nombre ! >>> |
N'oubliez pas : un programme bien écrit doit gérer proprement les exceptions.
Exercice 5.1
1) Compléter le script précédent de manière à ressaisir le nombre en cas d'erreur. Par exemple :
| >>> Entrer un nombre : salut ! salut ! n'est pas un nombre ! Entrer un nombre : 2,3 2,3 n'est pas un nombre ! Entrer un nombre : 2.3 L'inverse de 2.3 est : 0.434782608696 >>> |
2) Compléter le script de manière à accepter la virgule comme séparateur décimal. Par exemple :
>>>
Entrer un nombre : 2,3
L'inverse de 2.3 est : 0.434782608696
>>>
On pourra utiliser la méthode replace() de la classe str
Exercice 5.2 Ecrire un script qui calcule la racine carrée d'un nombre, avec gestion des exceptions. Par exemple :
| >>> Entrer un nombre : go go n'est pas un nombre valide ! Entrer un nombre : -5.26 -5.26 n'est pas un nombre valide ! Entrer un nombre : 16 La racine carrée de 16.0 est : 4.0 >>> |
Exercice 5.3 Soit le script :
i = 0 while True: i += 1 print(i)
Il s'agit d'une boucle sans fin.
Pour arrêter ce programme, il faut appuyer sur les touches CTRL + C, ce qui lève une exception de type KeyboardInterrupt :
>>>
1
1216
1217
1218
1219
1220
Traceback (most recent call last):
raise KeyboardInterrupt
KeyboardInterrupt
>>>
Compléter le script pour gérer proprement l'exception :
>>>
1
966
967
968
Fin du programme
>>>
La classe est un concept de base de la programmation orientée objet. En langage Python, vous pouvez très bien écrire un script sans définir de classes (c'est ce que nous avons fait jusqu'à présent).
Cependant, vous manipulez forcément des objets (ou instances de classes) : une variable entière est une instance de la classe int, une chaîne de caractères est une instance de la classe str
Le module Tkinter (que nous aborderons dans lechapitre 7) sert à créer des interfaces graphiques : ce module fournit une bibliothèque de classes.
Il est donc important d'étudier les classes notamment pour bien comprendre comment les utiliser (pour un débutant, c'est déroutant !).
Ce chapitre est difficile : je vous conseille de relire ce que l'on a vu dans lechapitre 1.
Voici un exemple de script qui utilise une classe définie par l'utilisateur.
Nous allons commencer par créer le fichier source (on parlera par la suite du module CompteBancaire) :
Ouvrir IDLE :
Démarrer → Programmes → Python → IDLE (Python GUI)
File → New Window
Copier puis coller le code source ci-dessous :
# -*- coding: utf-8 -*-
| # # définition de la classe Compte class Compte: """Un exemple de classe : gestion d'un compte bancaire""" # définition de la méthode spéciale __init__ def __init__(self, soldeInitial): """Initialisation du compte avec la valeur soldeInitial.""" # assignation de l'attribut d'instance solde self.solde = float(soldeInitial) # définition de la méthode NouveauSolde() def NouveauSolde(self, somme): """Nouveau solde de compte avec la valeur somme.""" self.solde = float(somme) # définition de la méthode Solde() def Solde(self): """Retourne le solde.""" return self.solde # définition de la méthode Credit() def Credit(self, somme): """Crédite le compte de la valeur somme. Retourne le solde.""" self.solde += somme |
| return self.solde # définition de la méthode Debit() def Debit(self, somme): """Débite le compte de la valeur somme. Retourne le solde.""" self.solde -= somme return self.solde # définition de la méthode spéciale __add__ (surcharge de l'opérateur +) def __add__(self, somme): """x.__add__(somme) <=> x+somme Crédite le compte de la valeur somme. Affiche 'Nouveau solde : somme'""" self.solde += somme print("Nouveau solde : {:+.2f} €".format(self.solde)) return self # définition de la méthode spéciale __sub__ (surcharge de l'opérateur -) def __sub__(self, somme): """x.__sub_(somme) <=> x-somme Débite le compte de la valeur somme. Affiche 'Nouveau solde : somme'""" self.solde -= somme print("Nouveau solde : {:+.2f} €".format(self.solde)) return self if __name__ == '__main__': |
| # Ce bloc d'instructions est exécuté si le module est lancé en tant que programme autonome # Instanciation de l'objet cb1 de la classe Compte cb1 = Compte(1000) # formatage des données pour afficher deux chiffres après la virgule et le signe print("{:+.2f}".format(cb1.Solde())) print("{:+.2f}".format(cb1.Credit(200))) print("{:+.2f}".format(cb1.Debit(50.23))) print("{:+.2f}".format(cb1.Solde())) cb1.NouveauSolde(5100) print("{:+.2f}".format(cb1.Solde())) cb1+253.2 cb1-1000+100 cb1-cb1.Solde() |
File → Save As
Répertoire : C:\PythonXX
Nom du fichier :
Puis exécuter le module :
Run → Run Module (ou touche F5) :
>>>
+1000.00
+1200.00
+1149.77
+1149.77
+5100.00
Nouveau solde : +5353.20 €
Nouveau solde : +4353.20 €
Nouveau solde : +4453.20 €
Nouveau solde : +0.00 €
>>>
Pour définir la nouvelle classe Compte, on utilise l'instruction class. Une classe possède des fonctions que l'on appelle méthodes et des données que l'on appelle attributs.
Une méthode se définit de la même manière qu'une fonction (on commence par l'instruction def).
Une méthode possède au moins un paramètre qui s'appelle self. Le paramètre self désigne toutes les instances qui seront créées par cette classe.
7 méthodes sont ainsi définies.
Un seul attribut d'instance est utilisé dans cette classe : solde (à ne pas confondre avec la méthode Solde()).
La méthode spéciale __init__() est exécutée automatiquement lorsque l'on instancie (crée) un nouvel objet de la classe. Cette méthode s'apparente à un constructeur.
Deux autres méthodes spéciales sont utilisées : __add__() et __sub__().
L'écriture cb1+253.2 est équivalente à cb1.__add__(253.2) L'opérateur + représente ici une addition sur le solde. L'écriture cb1-1000 est équivalente à cb1.__sub__(1000) L'opérateur - représente ici une soustraction sur le solde.
>>> cb1.NouveauSolde(500)
>>> print(cb1.Solde())
500.0
>>> cb1.__add__(1000)
Nouveau solde : +1500.00 €
>>> cb1+2000 # cette écriture est très pratique !
Nouveau solde : +3500.00 €
>>>
L'instruction if __name__ == '__main__':
Ici, le module est exécuté en tant que programme principal : les instructions qui suivent sont donc exécutées.
Dans le cas où ce module est importé dans un autre programme, cette partie du code est sans effet.
La fonction help() est très utile.
On comprend ici l'intérêt de bien documenter ses programmes avec les """docstrings""" :
>>> help(cb1)
Help on instance of Compte in module __main__:
class Compte
| Un exemple de classe :
| gestion d'un compte bancaire
|
| Methods defined here:
|
| Credit(self, somme)
| Crédite le compte de la valeur somme. Retourne le solde.
|
| Debit(self, somme)
| Débite le compte de la valeur somme. Retourne le solde.
|
| NouveauSolde(self, somme)
| Nouveau solde de compte avec la valeur somme.
|
| Solde(self)
| Retourne le solde.
|
| __add__(self, somme)
| x.__add__(somme) <=> x+somme
| Crédite le compte de la valeur somme.
| Affiche 'Nouveau solde : somme'
|
| __init__(self, soldeInitial)
| Initialisation du compte avec la valeur soldeInitial.
|
| __sub__(self, somme)
| x.__sub_(somme) <=> x-somme
| Débite le compte de la valeur somme.
| Affiche 'Nouveau solde : somme'
>>>
La fonction dir() retourne la liste des méthodes et attributs :
>>> dir(cb1)
['Credit', 'Debit', 'NouveauSolde', 'Solde', '__add__',
'__doc__', '__init__', '__module__', '__sub__', 'solde']
On peut instancier plusieurs objets d'une même classe :
>>> cb2 = Compte(10000)
>>> print(cb2.Credit(500))
10500.0
>>> cb3 = Compte(6000) # et encore un !
>>> cb3-500
Nouveau solde : +5500.00 €
>>>
Même si cela n'est pas recommandable, vous pouvez accéder directement aux attributs d'instance :
>>> print(cb2.solde)
10500.0
>>> cb2.solde = 5000.0 # assignation de l'attribut d'instance solde
>>> print(cb2.solde)
5000.0
>>> print(cb2.Solde())
5000.0
>>>
Notez que des mécanismes sont prévus pour personnaliser le mode d'accès aux attributs : fonction property() ou décorateur @property
L'importation de notre module personnel CompteBancaire se fait de la même façon que pour les modules de base (math, random, time ).
Redémarrer l'interpréteur interactif (Python Shell) : Shell → Restart Shell
>>> import CompteBancaire
>>> cb = CompteBancaire.Compte(1500)
>>> print(cb.Debit(200))
1300.0
>>> print(cb.solde)
1300.0
>>> cb+2000
Nouveau solde : +3300.00 €
>>>
Le module CompteBancaire est importé par le programme principal (ici l'interpréteur interactif).
La partie du code qui suit l'instruction if __name__ == '__main__': est ignorée (il n'y a donc pas d'affichage après l'instruction import CompteBancaire).
IDLE dispose de l'outil Path Browser pour connaître la structure d'un module.
File → Path Browser
Un module peut contenir des classes (CompteBancaire), des fonctions (animation) ou des fonctions et des classes.
Le module standard math est un module de fonctions.
Pour s'en convaincre :
| >>> import math >>> help(math) Help on built-in module math: NAME math FILE (built-in) |
| DESCRIPTION This module is always available. It provides access to the mathematical functions defined by the C standard. FUNCTIONS acos( ) acos(x) Return the arc cosine (measured in radians) of x. acosh( ) acosh(x) Return the hyperbolic arc cosine (measured in radians) of x. trunc( ) trunc(x:Real) -> Integral Truncates x to the nearest Integral toward 0. Uses the __trunc__ magic method. DATA e = 2.718281828459045 pi = 3.141592653589793 |
Le module math a également deux données (pi et e) :
>>> print(math.e) # donnée e du module math (nombre d'Euler)
2.71828182846
>>> print() # donnée pi du module math (nombre pi)
3.14159265359
>>> print(()) # fonction sin() du module math (sinus)
0.707106781187
>>> print((2.0)) # fonction sqrt() du module math (racine carrée)
1.41421356237
>>> print((-3.0)) # fonction exp() du module math (exponentielle)
0.0497870683679
>>> print((math.e)) # fonction log() du module math (logarithme népérien)
1.0
Si vous êtes familiarisé avec le module Tkinter, voici un exemple qui montre toute la puissance des classes et de la notion d'héritage :
| # -*- coding: utf-8 -*from tkinter import * class EnterMessage(Frame): """ Classe EnterMessage (Frame de saisie du mes sage) |
| Cette classe dérive de la classe Tkinter.Frame""" def __init__(self, master=None): """Initialisation : création d'un widget Fr ame""" Frame.__init__(self, master, bg='navy') (padx=10, pady=10) self.CreateWidgets() def CreateWidgets(self): """ Création des widgets Entry et Button dans le widget Frame """ self.NouveauMessage = StringVar() Entry(master=self, textvariable=self.Nouvea uMessage).pack(side=LEFT, padx=10, pady=10) Button(master=self, text="Nouveau", fg="nav y", command=self.Nouveau).pack(padx=10, pady=10) def Nouveau(self): """ Création d'une instance de la classe Ne wPostIt """ if () != "": NewPostIt(master=self.master, message=s ()) ("") class NewPostIt(Frame): """ Classe post-it (Frame Post-It) Cette classe dérive de la classe Tkinter.Frame" "" def __init__(self, master=None, message=None): """Initialisation : création d'un widget Fr ame""" Frame.__init__(self, master, bg="maroon") (side=LEFT, padx=10, pady=10) self.CreateWidgets(message) def CreateWidgets(self, message): """ Création des widgets Label et Button da ns le widget Frame""" Label(master=self, text=message, fg='maroon ', bg='white').pack(padx=10, pady=10) Button(master=self, text="Effacer", fg="nav y", command=self.destroy).pack(padx=10, pady=10) if __name__ == '__main__': |
| # création de la fenêtre principale Mafenetre = Tk() Mafenetre.title('Post-it') Mafenetre['bg'] = 'bisque' # Création d'une instance de la classe EnterMes sage EnterMessage(master=Mafenetre) Mafenetre.mainloop() |
Exercice 6.0 ★ On s'intéresse au moduleCompteBancaire. Dans les méthodes __add__() et __sub__(), remplacer la ligne return self par simplement return
Tester ce nouveau code et expliquer la différence.
Exercice 6.1 ★ On s'intéresse au moduleCompteBancaire.
Définir une nouvelle méthode Decouvert() de la classe Compte, qui affiche selon le cas Solde positif ou Solde négatif :
>>> CompteFabrice = Compte(2000)
>>> CompteFabrice-3000
Nouveau solde : -1000.00 €
>>> CompteFabrice.Decouvert()
Solde négatif
>>> CompteFabrice+10000
Nouveau solde : +9000.00 €
>>> CompteFabrice.Decouvert()
Solde positif
>>>
Exercice 6.2 ★★ On s'intéresse au moduleCompteBancaire.
Définir une nouvelle méthode Suivi() qui affiche l'historique du solde. On pourra définir un nouvel attribut de type list :
>>> CompteMuriel = Compte(5000)
>>> CompteMuriel-1000
Nouveau solde : +4000.00 €
>>> CompteMuriel+5000
Nouveau solde : +9000.00 €
>>> CompteMuriel.Suivi() [5000.0, 4000.0, 9000.0]
>>>
Le module Tkinter ("Tk interface") de Python permet de créer des interfaces graphiques (GUI : graphical user interface).
De nombreux composants graphiques (ou widgets) sont disponibles : fenêtre (classe Tk), bouton (classe Button), case à cocher
(classe Checkbutton), étiquette (classe Label), zone de texte simple (classe Entry), menu (classe Menu), zone graphique (classe Canvas), cadre (classe Frame)
On peut gérer de nombreux événements : clic sur la souris, déplacement de la souris, appui sur une touche du clavier, top d'horloge
Tkinter est l'interface graphique des logicielsIDLE (environnement de développement intégré pour le langage Python) et(logiciel libre de visualisation de structures chimiques en 3D) :
Des scripts pour débuter
Les exemples qui suivent ont été écrits avec Python version 3.
Commençons par le traditionnel Hello world !
# -*- coding: utf-8 -*# script from tkinter import *
# Création de la fenêtre principale (main window) Mafenetre = Tk()
# Création d'un widget Label (texte 'Bonjour tout le monde !')
Label1 = Label(Mafenetre, text = 'Bonjour tout le monde !', fg = 'red')
# Positionnement du widget avec la méthode pack() ()
# Création d'un widget Button (bouton Quitter) Bouton1 = Button(Mafenetre, text = 'Quitter', comma nd = Mafenetre.destroy) ()
# Lancement du gestionnaire d'événements Mafenetre.mainloop()
Ce code est détailléici.
Ce script simule un dé à 6 faces :
| # script #(C) Fabrice Sincère from tkinter import * import random def NouveauLance(): nb = random.randint(1,6) ('Résultat -> ' + str(nb)) # Création de la fenêtre principale (main window) |
Mafenetre = Tk()
Mafenetre.title('Dé à 6 faces')
Mafenetre.geometry('300x100+400+400')
# Création d'un widget Button (bouton Lancer)
BoutonLancer = Button(Mafenetre, text ='Lancer', command = NouveauLance)
# Positionnement du widget avec la méthode pack()
(side = LEFT, padx = 5, pady = 5)
# Création d'un widget Button (bouton Quitter)
BoutonQuitter = Button(Mafenetre, text ='Quitter', command = Mafenetre.destroy)
(side = LEFT, padx = 5, pady = 5)
Texte = StringVar()
NouveauLance()
# Création d'un widget Label (texte 'Résultat -> x')
LabelResultat = Label(Mafenetre, textvariable = Texte, fg ='red', bg ='white')
(side = LEFT, padx = 5, pady = 5)
Mafenetre.mainloop()
Ce code est détailléici.
Un widget Frame est une zone rectangulaire qui peut contenir d'autres widgets.
| # script #(C) Fabrice Sincère from tkinter import * # Création de la fenêtre principale Mafenetre = Tk() Mafenetre.title('Frame widget') Mafenetre['bg']='bisque' # couleur de fond # création d'un widget Frame dans la fenêtre princi pale Frame1 = Frame(Mafenetre,borderwidth=2,relief=GROOV E) (side=LEFT,padx=10,pady=10) # création d'un second widget Frame dans la fenêtre principale Frame2 = Frame(Mafenetre,borderwidth=2,relief=GROOV E) (side=LEFT,padx=10,pady=10) # création d'un widget Frame dans un widget Fram e # le widget Frame1 est le parent du widget Frame3 # le parent du widget Frame1 est le widget Mafenetr e (fenêtre principale) Frame3 = Frame(Frame1,bg="white",borderwidth=2,reli ef=GROOVE) (side=LEFT,padx=10,pady=10) # création d'un widget Label et d'un widget Button dans un widget Frame Label(Frame1,text="RDV dentiste samedi à 15h").pack (padx=10,pady=10) Button(Frame1,text="Effacer",fg='navy',command=Fram e1.destroy).pack(padx=10,pady=10) |
Label(Frame2,text="Réviser le contrôle d'info").pac k(padx=10,pady=10)
Button(Frame2,text="Effacer",fg='navy',command=Fram e2.destroy).pack(padx=10,pady=10)
Label(Frame3,text="RDV dentiste à 10h",bg="white"). pack(padx=10,pady=10)
Button(Frame3,text="Effacer",fg='navy',command=Fram e3.destroy).pack(padx=10,pady=10)
Mafenetre.mainloop()
Un script d'authentification :
| # script #(C) Fabrice Sincère from tkinter import * from tkinter.messagebox import * # boîte de dialogue def Verification(): if () == 'python27': # le mot de passe est bon : on affiche une boîte de dialogue puis on ferme la fenêtre showinfo('Résultat','Mot de passe correct.\nAu revoir !') Mafenetre.destroy() |
else:
# le mot de passe est incorrect : on affiche une boîte de dialogue showwarning('Résultat','Mot de passe incorrect.\nVeuillez recommencer !') ('')
# Création de la fenêtre principale (main window)
Mafenetre = Tk()
Mafenetre.title('Identification requise')
# Création d'un widget Label (texte 'Mot de passe')
Label1 = Label(Mafenetre, text = 'Mot de passe ')
(side = LEFT, padx = 5, pady = 5)
# Création d'un widget Entry (champ de saisie)
Motdepasse= StringVar()
Champ = Entry(Mafenetre, textvariable= Motdepasse, show='*', bg ='bisque', fg='maroon')
Champ.focus_set()
(side = LEFT, padx = 5, pady = 5)
# Création d'un widget Button (bouton Valider)
Bouton = Button(Mafenetre, text ='Valider', command = Verification)
(side = LEFT, padx = 5, pady = 5)
Mafenetre.mainloop()
| # script #(C) Fabrice Sincère from tkinter import * def carre(): """ Calcul du carré """ ("Carré = "+str(float(()) **2)) # Création de la fenêtre principale (main window) Mafenetre = Tk() Mafenetre.title("Spinbox widget") Valeur = StringVar() (2.0) # Création d'un widget Spinbox boite = Spinbox(Mafenetre,from_=0,to=10,increment=0 .5,textvariable=Valeur,width=5,command=carre) (padx=30,pady=10) # Création d'un widget Label Resultat = StringVar() carre() Label(Mafenetre,textvariable=Resultat).pack(padx=30 ,pady=10) Mafenetre.mainloop() |
| # script #(C) Fabrice Sincère from tkinter import * def maj(nouvelleValeur): # nouvelle valeur en argument print(nouvelleValeur) def plus(): (str(int(())+10)) print(()) def moins(): (str(int(())-10)) print(()) # Création de la fenêtre principale (main window) Mafenetre = Tk() Mafenetre.title("Scale widget") Valeur = StringVar() (50) # Création d'un widget Scale echelle = Scale(Mafenetre,from_=- 100,to=100,resolution=10,orient=HORIZONTAL,\ length=300,width=20,label="Offset",tickinterval=20, variable=Valeur,command=maj) (padx=10,pady=10) # Création d'un widget Button (bouton +) Button(Mafenetre,text="+",command=plus).pack(padx=1 0,pady=10) |
# Création d'un widget Button (bouton -)
Button(Mafenetre,text="-",command=moins).pack(padx= 10,pady=10)
Mafenetre.mainloop()
Le script dessine, à chaque clic sur le bouton Go, un disque de rayon 20 pixels à une position aléatoire :
| # script #(C) Fabrice Sincère from tkinter import * import random def Cercle(): """ Dessine un cercle de centre (x,y) et de rayon r """ x = random.randint(0,Largeur) y = random.randint(0,Hauteur) |
| r = 20 Canevas.create_oval(x-r, y-r, x+r, y+r, outline='blue', fill='blue') def Effacer(): """ Efface la zone graphique """ Canevas.delete(ALL) # Création de la fenêtre principale (main window) Mafenetre = Tk() Mafenetre.title('Cercle') # Création d'un widget Canvas (zone graphique) Largeur = 480 Hauteur = 320 Canevas = Canvas(Mafenetre, width = Largeur, height =Hauteur, bg ='white') (padx =5, pady =5) # Création d'un widget Button (bouton Go) BoutonGo = Button(Mafenetre, text ='Go', command = Cercle) (side = LEFT, padx = 10, pady = 10) # Création d'un widget Button (bouton Effacer) BoutonEffacer = Button(Mafenetre, text ='Effacer', command = Effacer) (side = LEFT, padx = 5, pady = 5) # Création d'un widget Button (bouton Quitter) BoutonQuitter = Button(Mafenetre, text ='Quitter', command = Mafenetre.destroy) |
(side = LEFT, padx = 5, pady = 5)
Mafenetre.mainloop()
Ce code est détailléici.
Ce script reprend le script avec une image de fond
(méthode create_image() de la classe Canvas) et la possibilité d'effacer la dernière action (pour cela, on se sert du numéro identifiant de chaque item d'un widget Canvas) :
| # script #(C) Fabrice Sincère from tkinter import * import random def Cercle(): """ Dessine un cercle de centre (x,y) et de ray on r """ x = random.randint(0,Largeur) y = random.randint(0,Hauteur) r = 10 # on dessine un cercle dans la zone graphique item = Canevas.create_oval(x-r, y-r, x+r, y+r, outline='black', fill='black') print("Création du cercle (item" , item ,")") # affichage de tous les items de Canevas print(Canevas.find_all()) def Undo(): """ Efface le dernier cercle""" if len(Canevas.find_all()) > 1: item = Canevas.find_all()[-1] # on efface le cercle Canevas.delete(item) print("Suppression du cercle (item" , item ,")") # affichage de tous les items de Canevas print(Canevas.find_all()) def EffacerTout(): """ Efface tous les cercles""" while len(Canevas.find_all()) > 1: Undo() # Création de la fenêtre principale (main window) Mafenetre = Tk() Mafenetre.title('Cible') # Image de fond photo = PhotoImage(file="") # Création d'un widget Canvas (zone graphique) Largeur = 550 Hauteur = 550 |
Canevas = Canvas(Mafenetre,width = Largeur, height
=Hauteur)
item = Canevas.create_image(0,0,anchor=NW, image=ph oto)
print("Image de fond (item",item,")") ()
# Création d'un widget Button
BoutonGo = Button(Mafenetre, text ='Tirer', command
= Cercle)
(side = LEFT, padx = 10, pady = 10)
# Création d'un widget Button
BoutonEffacer = Button(Mafenetre, text ='Effacer le dernier tir', command = Undo)
(side = LEFT, padx = 10, pady = 1 0)
# Création d'un widget Button
BoutonEffacerTout = Button(Mafenetre, text ='Efface r tout', command = EffacerTout)
(side = LEFT, padx = 10, pady = 10)
# Création d'un widget Button (bouton Quitter) BoutonQuitter = Button(Mafenetre, text ='Quitter', command = Mafenetre.destroy)
(side = LEFT, padx = 10, pady = 1 0)
Mafenetre.mainloop()
Télécharger l'image de fond
Exemple n°8 : widgets Menu et Canvas ; gestion des images ; boîtes de
Le script suivant est un browser d'images (formats .gif .ppm .pgm), avec un widget Menu :
une boîte de dialogue FileDialog pour rechercher un fichier :
et un widget Canvas dans lequel sera affiché l'image :
| # script #(C) Fabrice Sincère from tkinter import * import tkinter.messagebox import tkinter.filedialog def Ouvrir(): Canevas.delete(ALL) # on efface la zone graphiq ue filename = tkinter.filedialog.askopenfilename(t itle="Ouvrir une image",filetypes=[('gif files','.g if'),('all files','.*')]) print(filename) photo = PhotoImage(file=filename) gifdict[filename] = photo # référence print(gifdict) Canevas.create_image(0,0,anchor=NW,image=photo) Canevas.config(height=photo.height(),width=phot o.width()) Mafenetre.title("Image "+str(photo.width())+" x |
| "+str(photo.height())) def Fermer(): Canevas.delete(ALL) Mafenetre.title("Image") def Apropos(): tkinter.messagebox.showinfo("A propos","Tutoria l Python Tkinter\n(C) Fabrice Sincère") # Main window Mafenetre = Tk() Mafenetre.title("Image") # Création d'un widget Menu menubar = Menu(Mafenetre) menufichier = Menu(menubar,tearoff=0) menufichier.add_command(label="Ouvrir une image",co mmand=Ouvrir) menufichier.add_command(label="Fermer l'image",comm and=Fermer) menufichier.add_command(label="Quitter",command=Maf enetre.destroy) menubar.add_cascade(label="Fichier", menu=menufichi er) menuaide = Menu(menubar,tearoff=0) menuaide.add_command(label="A propos",command=Aprop os) menubar.add_cascade(label="Aide", menu=menuaide) # Affichage du menu Mafenetre.config(menu=menubar) # Création d'un widget Canvas Canevas = Canvas(Mafenetre) (padx=5,pady=5) # Utilisation d'un dictionnaire pour conserver une référence gifdict={} Mafenetre.mainloop() |
# dans le programme principal gifdict = {}
# dans la fonction Ouvrir() gifdict[filename] = photo
Si vous enlevez les lignes ci-dessus, l'ouverture des images ne fonctionne plus correctement.
En effet, photo est une variable locale à la fonction Ouvrir(). En dehors, elle n'existe plus et la référence à l'image est perdue.
Une manière de conserver la référence est d'utiliser un dictionnaire ou une liste qui ont "naturellement" une portée globale :
# dans le programme principal giflist = []
# dans la fonction Ouvrir() giflist.append(photo)
On peut aussi rendre globale la variable photo avec ce code au début de la fonction Ouvrir() :
global photo
Pour finir, la façon la plus élégante de résoudre ce genre de situation est de pratiquer la programmation orientée objet (encapsulation dans une classe) :voir le programme
L'heure courante est mise à jour toutes les secondes :
Pour cela, on utilise la méthode after() qui appelle une fonction après une durée donnée en millisecondes :
| # script #(C) Fabrice Sincère from tkinter import * import time def maj(): # on arrive ici toutes les 1000 ms (time.strftime('%H:%M:%S')) Mafenetre.after(1000,maj) |
Mafenetre = Tk()
Mafenetre.title("Heure courante")
# Création d'un widget Label heure = StringVar()
Label(Mafenetre,textvariable=heure).pack(padx=10,pa dy=10) maj()
Mafenetre.mainloop()
Le script est un exemple d'animation (affichage d'environ 20 disques par seconde) :
On se sert de la méthode after() pour actualiser la zone graphique toutes les 50 ms :
# script #(C) Fabrice Sincère from tkinter import *
| import random def Cercle(): """ Dessine un cercle de centre (x,y) et de rayon r """ global Arret x = random.randint(0,Largeur) y = random.randint(0,Hauteur) r = 10 Canevas.create_oval(x-r, y-r, x+r, y+r, outline='red', fill='red') if Arret == False: # appel de la fonction Cercle() après une pause de 50 millisecondes Mafenetre.after(50,Cercle) def Arreter(): """ Arrêt de l'animation """ global Arret Arret = True def Demarrer(): """ Démarre l'animation """ global Arret Canevas.delete(ALL) if Arret == True: Arret = False Cercle() # un seul appel à cette fonction Arret = True |
# Création de la fenêtre principale (main window)
Mafenetre = Tk()
Mafenetre.title('Animation')
# Création d'un widget Canvas
Largeur = 480
Hauteur = 320
Canevas = Canvas(Mafenetre, width = Largeur, height =Hauteur, bg ='white')
(padx =5, pady =5)
# Création d'un widget Button (bouton Démarrer)
BoutonGo = Button(Mafenetre, text ='Démarrer', command = Demarrer)
(side = LEFT, padx = 10, pady = 10)
# Création d'un widget Button (bouton Arrêter)
BoutonArreter = Button(Mafenetre, text ='Arrêter', command = Arreter)
(side = LEFT, padx = 5, pady = 5)
# Création d'un widget Button (bouton Quitter)
BoutonQuitter = Button(Mafenetre, text ='Quitter', command = Mafenetre.destroy)
(side = LEFT, padx = 5, pady = 5)
Mafenetre.mainloop()
Le script est une animation qui gère le déplacement d'une balle et de ses rebonds sur les bords :
| # script #(C) Fabrice Sincère from tkinter import * import math,random LARGEUR = 480 HAUTEUR = 320 RAYON = 15 # rayon de la balle # position initiale au milieu X = LARGEUR/2 Y = HAUTEUR/2 # direction initiale aléatoire vitesse = random.uniform(1.8,2)*5 angle = random.uniform(0,2*) DX = vitesse*(angle) DY = vitesse*(angle) def deplacement(): """ Déplacement de la balle """ global X,Y,DX,DY,RAYON,LARGEUR,HAUTEUR # rebond à droite if X+RAYON+DX > LARGEUR: X = 2*(LARGEUR-RAYON)-X DX = -DX |
| # rebond à gauche if X-RAYON+DX < 0: X = 2*RAYON-X DX = -DX # rebond en bas if Y+RAYON+DY > HAUTEUR: Y = 2*(HAUTEUR-RAYON)-Y DY = -DY # rebond en haut if Y-RAYON+DY < 0: Y = 2*RAYON-Y DY = -DY X = X+DX Y = Y+DY # affichage Canevas.coords(Balle,X-RAYON,YRAYON,X+RAYON,Y+RAYON) # mise à jour toutes les 50 ms Mafenetre.after(50,deplacement) # Création de la fenêtre principale Mafenetre = Tk() Mafenetre.title("Animation Balle") # Création d'un widget Canvas Canevas = Canvas(Mafenetre,height=HAUTEUR,width=LAR GEUR,bg='white') (padx=5,pady=5) # Création d'un objet graphique Balle = Canevas.create_oval(X-RAYON,YRAYON,X+RAYON,Y+RAYON,width=1,fill='green') deplacement() Mafenetre.mainloop() |
Le script dessine un carré à l'endroit du clic de la souris.
Pour cela, on utilise l'événement associé au clic gauche de la souris.
| # script #(C) Fabrice Sincère from tkinter import * def Clic(event): """ Gestion de l'événement Clic gauche sur la zone graphique """ # position du pointeur de la souris X = event.x Y = event.y # on dessine un carré r = 20 Canevas.create_rectangle(X-r, Y-r, X+r, Y+r, outline='black',fill='green') def Effacer(): """ Efface la zone graphique """ |
Canevas.delete(ALL)
# Création de la fenêtre principale
Mafenetre = Tk()
Mafenetre.title('Carrés')
# Création d'un widget Canvas
Largeur = 480
Hauteur = 320
Canevas = Canvas(Mafenetre, width = Largeur, height =Hauteur, bg ='white')
# La méthode bind() permet de lier un événement avec une fonction :
# un clic gauche sur la zone graphique provoquera l'appel de la fonction utilisateur Clic()
('<Button-1>', Clic)
(padx =5, pady =5)
# Création d'un widget Button (bouton Effacer)
Button(Mafenetre, text ='Effacer', command =
Effacer).pack(side=LEFT,padx = 5,pady = 5)
# Création d'un widget Button (bouton Quitter)
Button(Mafenetre, text ='Quitter', command =
Mafenetre.destroy).pack(side=LEFT,padx=5,pady=5)
Mafenetre.mainloop()
Ce code est détailléici.
Nous allons voir comment déplacer un objet graphique avec la souris (clic, drag and drop) :
| # script #(C) Fabrice Sincère from tkinter import * def Clic(event): """ Gestion de l'événement Clic gauche """ global DETECTION_CLIC_SUR_OBJET # position du pointeur de la souris X = event.x Y = event.y print("Position du clic -> ",X,Y) # coordonnées de l'objet [xmin,ymin,xmax,ymax] = Canevas.coords(Carre) print("Position objet -> ",xmin,ymin,xmax,ymax) if xmin<=X<=xmax and ymin<=Y<=ymax: DETECTION_C LIC_SUR_OBJET = True else: DETECTION_CLIC_SUR_OBJET = False print("DETECTION CLIC SUR OBJET -> ",DETECTION_CLIC_SUR_OBJET) def Drag(event): """ Gestion de l'événement bouton gauche enfonc é """ X = event.x Y = event.y print("Position du pointeur -> ",X,Y) if DETECTION_CLIC_SUR_OBJET == True: # limite de l'objet dans la zone graphique if X<0: X=0 if X>Largeur: X=Largeur if Y<0: Y=0 if Y>Hauteur: Y=Hauteur |
# mise à jour de la position de l'objet (dr ag)
Canevas.coords(Carre,X-TailleCarre,Y-
TailleCarre,X+TailleCarre,Y+TailleCarre)
DETECTION_CLIC_SUR_OBJET = False
# Création de la fenêtre principale
Mafenetre = Tk()
Mafenetre.title("Drag and drop")
# Création d'un widget Canvas
Largeur = 480
Hauteur = 160
TailleCarre = 20
Canevas = Canvas(Mafenetre,width=Largeur,height=Hau teur,bg ='white')
# Création d'un objet graphique
Carre = Canevas.create_rectangle(0,0,TailleCarre*2, TailleCarre*2,fill='maroon')
# La méthode bind() permet de lier un événement ave c une fonction
('<Button-1>',Clic) # évévement clic ga uche (press)
('<B1-Motion>',Drag) # événement bouton gauche enfoncé (hold down)
Canevas.focus_set()
(padx=10,pady=10)
Mafenetre.mainloop()
Le script gère le déplacement d'un pion avec le clavier. Pour se faire, on utilise l'événement associé à l'appui d'une touche du clavier.
| a |
| q |
| l |
| m |
§ touche déplacement vers le haut
§ touche déplacement vers le bas
§ touche déplacement vers la gauche
§ touche déplacement vers la droite
| # script #(C) Fabrice Sincère from tkinter import * def Clavier(event): """ Gestion de l'événement Appui sur une touche du clavier """ global PosX,PosY touche = event.keysym print(touche) # déplacement vers le haut if touche == 'a': PosY -= 20 # déplacement vers le bas if touche == 'q': PosY += 20 # déplacement vers la droite |
| if touche == 'm': PosX += 20 # déplacement vers la gauche if touche == 'l': PosX -= 20 # on dessine le pion à sa nouvelle position Canevas.coords(Pion,PosX -10, PosY -10, PosX +10, PosY +10) # Création de la fenêtre principale Mafenetre = Tk() Mafenetre.title('Pion') # position initiale du pion PosX = 230 PosY = 150 # Création d'un widget Canvas (zone graphique) Largeur = 480 Hauteur = 320 Canevas = Canvas(Mafenetre, width = Largeur, height =Hauteur, bg ='white') Pion = Canevas.create_oval(PosX-10,PosY- 10,PosX+10,PosY+10,width=2,outline='black',fill='re d') Canevas.focus_set() ('<Key>',Clavier) (padx =5, pady =5) # Création d'un widget Button (bouton Quitter) Button(Mafenetre, text ='Quitter', command = Mafenetre.destroy).pack(side=LEFT,padx=5,pady=5) |
Mafenetre.mainloop()
Ce code est détailléici.
'Up', 'Down', 'Left', 'Right' (flèches directionnelles haut, bas, gauche, droite), 'Return' (touche Entrée), 'space' (barre Espace)
Le module pygame est un module externe de création de jeux vidéo en 2D. pygame contient un sous module pygame.mixer qui permet de charger et de lire des musiques ou des sons dans plusieurs formats (mp3, ogg, wav ).
La procédure d'installation de pygame se trouveici.
| # script #(C) Fabrice Sincère # python version 3.2 # pygame version 1.9.2 from tkinter import * import pygame () ("chavmusic7.mp3") # réglage volume pygame.mixer.music.set_volume(0.3) son1 = pygame.mixer.Sound("") son1.set_volume(0.5) son2 = pygame.mixer.Sound("") son2.set_volume(1.0) def PlaySon1(): () def PlaySon2(): () def Music(): |
| print(()) if () == 1: # 1 (ON) # joue en boucle (-1) else: # 0 (OFF) () # Création de la fenêtre principale (main window) Mafenetre = Tk() Mafenetre.title("Checkbutton widget + Pygame.mixer" ) # Création d'un widget Button Button(Mafenetre,text="son 1",command=PlaySon1).pac k(side=LEFT,padx=10,pady=10) # Création d'un widget Button Button(Mafenetre,text="son 2",command=PlaySon2).pac k(side=LEFT,padx=10,pady=10) # Création d'un widget Checkbutton musique = IntVar() (1) # ON Checkbutton(Mafenetre,text="Musique de fond",variab le=musique,command=Music).pack(side=LEFT,padx=10,pa dy=10) Music() Mafenetre.mainloop() |
Télécharger le
Télécharger le
Télécharger la musiquechavmusic7.mp3
Exercice 7.1 ★ En s'inspirant des
scripts et , écrire une application avec interface graphique qui calcule la racine carrée d'un nombre.
Par exemple, le calcul de √3 donne :
Exercice 7.2 ★ Reprendre le script de manière à limiter le nombre d'essais à trois.
Exercice 7.3 ★ En s'inspirant des
scripts et , écrire une application avec interface graphique qui calcule l'addition ou la soustraction de deux nombres :
Exercice 7.4 ★ A partir du script , dessiner des disques de positions, rayons et couleurs aléatoires :
Exercice 7.5 ★ A partir du script , faire une animation avec des disques de positions, rayons et couleurs aléatoires.
Exercice 7.6 ★★ A partir du script , faire une animation qui gère la trajectoire d'un nombre quelconque de balles :
Remarque : on ne tiendra pas compte des chocs entre balles.
Exercice 7.7 ★★
1) Reprendre le script et remplacer le disque noir par une image :
Télécharger l'
Remarque : l'image de l'impact doit avoir un fond transparent.
2) En s'inspirant du script , ajouter un effet sonore ().
Exercice 7.8 ★★ En s'inspirant du script , faire l'animation d'un mouvement aléatoire brownien.
On utilisera la méthode create_line() de la classe Canvas.
Exercice 7.9 ★ Compléter le script de manière à dessiner une grille.
On utilisera la méthode create_line() de la classe Canvas.
Exercice 7.10 ★★
Ecrire un script qui tire une carte et l'affiche à une position aléatoire.
Il faut se servir d'une référence comme dans le script Télécharger les images des 52 cartes et un squelette du scriptici.
Projet n°1 ★★★ Jeu Tic-Tac-Toe (jeu du morpion) Un projet relativement simple pour un travail en binôme.
Le fichier exécutable est téléchargeableici.
Remarque : dans ma version, le code source Python fait une bonne centaine de lignes.
On pourra compléter ce projet par une version en réseau (plus d'informationsici).
Projet n°2 ★★★★★ Jeu de Tetris avec classement en ligne Un gros projet à décomposer en plusieurs tâches :
§ jeu en local avec Python
§ applications Web(en PHP ou CGI-Python, base de données MySQL)
§
§ (essayez !)
§
§
§
§
§ Télécharger le fichier exécutable
Le fichier exécutable est téléchargeableici.
Projet n°3 ★★★★ Jeu de SnakeDuel
Un jeu qui se joue à deux, ou seul contre l'ordinateur.
Le fichier exécutable est téléchargeableici.
Projet n°4 ★★★★ Jeu de Pong Un jeu qui se joue à deux.
Le fichier exécutable est téléchargeableici.
Projet n°5 ★★★★ Puzzle
Le fichier exécutable est téléchargeableici.
Projet n°6 ★★★ Simulation de feux de forêt
Liens utiles :
§
§
Projet n°7 ★★★ Distance entre deux villes
Vous aurez besoin des modules urllib et json ainsi que de l'Google Maps.
Pas besoin d'avoir Python sur votre machine !
Les programmes exécutables (extension .exe) des exercices et de la plupart des projets sont téléchargeablesici (7 Mo). Décompresser ensuite l'archive.
Pour jouer à Tetris (par exemple), lancer le
programme
Plus d'informations sur les jeux. Have fun !
Un fichier stocke des informations sur un support physique (disque dur, clé USB, CD, DVD, carte mémoire SD ).
Ouvrir un fichier consiste à le charger dans la mémoire vive (RAM) de l'ordinateur (c'est une mémoire volatile : elle s'efface quand on éteint l'ordinateur).
Enregistrer un fichier consiste à l'écrire sur un support physique de stockage (l'information est alors conservée de manière permanente).
Il existe deux types de fichiers :
§ Les fichiers textes : l'information est stockée sous forme de caractères lisibles par un éditeur de texte (principalement des lettres et des chiffres).
§ Les fichiers binaires : l'information est stockée en binaire (une suite d'octets dont la valeur est comprise entre 0x00 et 0xFF).
L'écriture dans un fichier se fait avec la fonction open() en mode écriture :
# script
NomFichier = ''
# création et ouverture du fichier en mode write 'w' (écriture)
# si le fichier existe déjà, il est écrasé Fichier = open(NomFichier, 'w') # instanciation de l'objet Fichier de la classe file
# écriture dans le fichier avec la méthode write()
Fichier.write('Bonjour à tous !')
# fermeture du fichier avec la méthode close()
Fichier.close()
Le fichier est créé dans le répertoire courant (sous Windows c'est normalement le répertoire C:/PythonXX, mais on peut aussi choisir un emplacement quelconque en spécifiant le chemin absolu, par exemple NomFichier = 'F:/Mon ').
Vous pouvez vérifier son contenu en l'ouvrant avec un éditeur de texte (ou même avec un logiciel de traitement de texte) :
Pour Python, le codage par défaut des caractères est cp1252 (Windows1252) sous Windows, et UTF-8 sous GNU/Linux.
Avec le codage cp1252, le fichier fait 16 octets :
Avec le codage UTF-8, le fichier fait 17 octets !
La différence est due au codage du caractère accentué à :
1 octet (0xE0) pour le codage cp1252 et 2 octets (0xC3 0xA0) pour le codage UTF-8.
Les autres caractères ont un codage commun sur un octet (codage ASCII).
Une bonne pratique est de spécifier l'encodage, par exemple :
Fichier = open(NomFichier, 'w', encoding='utf8')
Pour écrire à la fin d'un fichier, on utilise la fonction open() en mode ajout.
Repartons du fichier précédent :
# ouverture du fichier en mode append 'a' (ajout)
Fichier = open('', 'a') # instanciation de l'objet Fichier
Fichier.write('\nUne deuxième ligne.\n')# '\n' saut de ligne
Fichier.write('abc\tABC\t123\n') # '\t' tabulation
Fichier.write(str(126.85)+'\n') # str() transforme un nombre en chaîne de caractères
Fichier.write('\x31\x41\x61\n') # écriture de '1Aa' en code ASCII
Fichier.write(chr(0x62)+'\n') # écriture de 'b' en code ASCII
Fichier.write(chr(99)) # écriture de
'c' en code ASCII
Fichier.close()
Ce qui donne :
La lecture dans un fichier texte se fait avec la fonction open() en mode lecture :
# ouverture du fichier en mode read 'r'
(lecture en mode texte)
Fichier = open('', 'r') # instanciation de l'objet Fichier de la classe file # lecture dans le fichier avec la méthode read() chaine = () # affichage du contenu du fichier print('Contenu du fichier :\n' + chaine) # fermeture du fichier avec la méthode close()
Fichier.close()
>>>
Contenu du fichier :
Bonjour à tous !
Une deuxième ligne.
| abc ABC 126.85 1Aa b c | 123 |
En mode texte, un fichier est lu caractère par caractère.
En mode binaire, un fichier est lu octet par octet : c'est un peu différent !
Par exemple, si on veut la taille d'un fichier, il faut utiliser la lecture en mode binaire 'rb' (read binary) :
| # ouverture du fichier en mode read binary 'rb' (lecture en mode binaire) Fichier = open('', 'rb') data = () # affichage de la taille du fichier print('Taille du fichier :', len(data), 'octets') # affichage du contenu (en hexadécimal) import binascii print(binascii.hexlify(data)) # fermeture du fichier avec la méthode close() Fichier.close() >>> Taille du fichier : 69 octets b'426f6e6a6f757220e020746f757320210d0a556e652064657 57869e86d65206c69676e652e0d0a6162630941424309313233 0d0a3132362e38350d0a3141610d0a620d0a63' |
La taille du fichier est 69 octets avec le codage cp1252 (sous Windows) et 65 octets avec le codage UTF-8 (sous Linux).
Avec la lecture en mode texte 'r', on obtient 63 octets avec le codage cp1252 (sous Windows) et 65 octets avec le codage UTF-8 (sous Linux) !
Pourquoi ce décalage ?
Car sous Windows, un saut de ligne est codé sur 2 octets (0x0D 0x0A) et le caractère spécial d'une chaîne \n sur un seul octet !
Sous Linux, c'est plus simple avec un saut de ligne codé sur un seul octet (0x0A).
En définitive :
63 + 2 (2 caractères accentués à et è) = 65
63 + 6 (6 sauts de ligne) = 69
Le module Pickle est extrêmement pratique pour sauvegarder dans un fichier des structures de données comme les listes (type list) ou les dictionnaires (type dict).
Un exemple de sauvegarde d'un dictionnaire :
| import pickle # création d'un dictionnaire departement = {36: 'Indre', 30: 'Gard', 75: 'Paris'} # enregistrement du dictionnaire dans un fichier Fichier = open('', 'wb') (departement, Fichier) # sérialisation Fichier.close() |
L'opération inverse est tout aussi simple :
import pickle
# récupération du dictionnaire
Fichier = open('', 'rb')
Dept = (Fichier) # désérialisation Fichier.close()
print(Dept)
print(Dept[36])
>>>
{75: 'Paris', 36: 'Indre', 30: 'Gard'}
Indre
Les fichiers suivants sont-ils de type binaire ou de type texte ?
§ Une photo au format JPEG
§ Une image au format PNG § Une image au format SVG
§ Un fichier audio au format MP3
§ Un document texte au format TXT
§ Une page web au format HTML
§ Un fichier exécutable (extension .exe)
§ Un document au format PDF
§ Un fichier compressé au format ZIP
§ Un script en langage Python (extension .py)
1) Créer un fichier texte contenant une suite aléatoire de chiffres.
On utilisera la fonction randint() du module random.
2) Avec un logiciel tel que 7-Zip, compresser le fichier avec différents algorithmes (zip, gzip, bzip2).
Le taux de compression (en %) est donné par la formule : 100×(taille initiale - taille après compression)/taille initiale
Comment expliquer ce taux de compression modeste (au mieux 57 %)?
Ecrire un ensemble de scripts qui gère une élection par vote électronique. On utilisera des fichiers pour stocker la liste électorale, les mots de passe, la liste des candidats et le résultat des votes.
Pour une sécurité optimale, le vote se fera sur un ordinateur seul (sans connexion réseau, sans connexion à Internet ).
Exemple d'interface :
>>>
Election des délégués de classe
| Actuellement, 18 élèves ont voté (sur 30) Identifiant ? martin Mot de passe ? L'authentification a réussi. Electeur : Martin Rémi Liste des candidats : Durand Yohan --> 0 Barot Pauline --> 1 Dupont Simon --> 2 Vote blanc --> 3 Quel est votre choix ? 1 Confirmer votre choix : 1 A voté ! Merci et bonne journée. >>> Résultat de l'élection des délégués de classe Nombre de votants : 30 / 30 Durand Yohan --> 5 voix (17.9 %) Barot Pauline --> 16 voix (57.1 %) |
Dupont Simon --> 7 voix (25.0 %)
Vote blanc --> 2 voix
Le format PGM (portable graymap file format) est utilisé pour des images en niveau de gris.
C'est un format d'image matricielle, sans compression, assez peu utilisé mais qui présente l'intérêt d'être facilement manipulable.
Commencez par copier sur votre Bureau une image en couleur de format quelconque (JPEG, PNG, BMP, GIF, PPM ). Par exemple :
Télécharger le fichier
Avec le logiciel de traitement d'images GIMP, nous allons convertir cette image dans le format PGM : Ouvrir le fichier avec GIMP
Fichier → Enregistrer sous
Sélectionner le type de fichier (selon l'extension) → Image PGM
Exporter
Formatage des données → Brut
Enregistrer
Renommez ce fichier :
Télécharger le fichier
Le script permet d'inverser les couleurs d'une image.
On obtient ainsi le "négatif" :
# script import imghdr, struct
| print("Inversion d'une image PGM en mode binaire à 256 niveaux de gris\n") NomFichierSource = '' NomFichierDestination = '' print('Fichier source :',NomFichierSource) print('Fichier destination :',NomFichierDestination) def Inversion(octet): # cette fonction fait une inversion du niveau de gris # 0 (noir) -> 255 (blanc) # 255 (blanc) -> 0 (noir) return 255-octet if (NomFichierSource)=='pgm': # test du format de l'image FichierSource = open(NomFichierSource,'rb') TailleFichier = len(()) print('\nTaille du fichier (en octets) :',TailleFichier) Largeur = int(input('Largeur de l\'image (en pixels) ? ')) Hauteur = int(input('Hauteur de l\'image (en pixels) ? ')) NbPixel = Largeur*Hauteur TailleEntete = TailleFichier - Largeur*Hauteur |
| (0) # extraction de l'en-tête # la variable Entete est une chaîne d'octets (type bytes) Entete = (TailleEntete) # extraction des données # Data est une liste de nombre entiers (type list) # la fonction int() retourne le contenu d'un octet sous forme d'un entier Data = [int(i) for i in ()] compréhension de listes FichierSource.close() if NbPixel == len(Data): print('Nombre de pixels :',Largeur*Hauteur) print("Nombre d'octets de données :",len(Data)) print("Taille de l'en-tête :",TailleEntete) FichierDestination = open(NomFichierDestination,'wb') # écriture de l'en-tête du fichier destination FichierDestination.write(Entete) # écriture des données du fichier destination for i in Data: |
#
| # conversion de type : int en bytes FichierDestination.write(('B',Inversion( i))) FichierDestination.close() print('Travail terminé !') else: print('Erreur dans la saisie des données !') else: print("Ce n'est pas une image PGM !") >>> Inversion d'une image PGM en mode binaire à 256 niveaux de gris Fichier source : Fichier destination : Taille du fichier (en octets) : 153654 Largeur de l'image (en pixels) ? 480 Hauteur de l'image (en pixels) ? 320 Nombre de pixels : 153600 Nombre d'octets de données : 153600 Taille de l'en-tête : 54 Travail terminé ! |
Le script crée le fichier dans le répertoire courant.
Affichons l'en-tête des fichiers image PGM :
>>> import binascii
>>> print(binascii.hexlify(Entete)) # contenu de l'en-tête en hexadécimal b'50350a232043524541544f523a2047494d5020504e4d20466 96c7465722056657273696f6e20312e310a343830203332300a 3235350a'
>>> print(Entete) # contenu de l'en-tête en chaîne de caractères b'P5\n# CREATOR: GIMP PNM Filter Version 1.1\n480 320\n255\n'
>>>
L'en-tête contient en particulier la largeur et la hauteur de l'image (480 pixels x 320 pixels) et le nombre 255 (soit 256 niveaux de gris).
La couleur d'un pixel est codée sur un octet.
On va du noir (0x00) au blanc (0xff) en passant par tous les niveaux de gris.
>>> print(Data[0],hex(Data[0])) # premier octet
: pixel en haut à gauche de l'image
153 0x99
>>> print(Data[1],hex(Data[1])) # deuxième octet : pixel à droite du précédent
142 0x8e
>>> print(hex(Data[479])) # 480ème octet : pixel en haut à droite
0xbf
>>> print(hex(Data[480])) # 481ème octet : pixel de la deuxième ligne à gauche
0x92
>>> print(hex(Data[153599])) # dernier octet : pixel en bas à droite de l'image (320ème ligne)
0x25
Avec un éditeur hexadécimal, observons le contenu du fichier :
et comparons avec le contenu du fichier :
Il suffit de faire :
Couleurs → Inverser
Cette librairie spécialisée de Python fournit des outils de traitement d'images.
Pour la petite histoire, Pillow est un fork de l'ancienne librairie PIL.
Dans Google Play, rechercher puis installer l'applicationQPython - Python .
Pillow n'est pas présente par défaut.
Il faut donc la télécharger et l'installer.
Le script suivant permet de convertir une photo en couleur au format JPEG en une image en niveau de gris au format PGM, puis de la transposer (retournement, miroir).
Les résultats sont affichés dans des fenêtres graphiques indépendantes et enregistrés dans des fichiers images :
| # Pillow 6.0.0 # importation du module Image de la librairie Pillow from PIL import Image # ouverture de l'image img = ('') # affichage de l'image () # affichage de la taille de l'image (en pixels) print() # conversion au format PPM (en couleur) et enregistrement de l'image ('','PPM') () # conversion en niveau de gris (pour obtenir le format PGM) img0 = img.convert('L')
# enregistrement dans le fichier ('') () # retournement de l'image img1 = img0.rotate(180) # affichage et enregistrement de l'image retournée |
| () ('') # miroir horizontal img2 = img0.transpose(Image.FLIP_LEFT_RIGHT) () ('') # miroir vertical img3 = img0.transpose(Image.FLIP_TOP_BOTTOM) () ('') >>> (480, 320) |
Le module ImageDraw de la librairie Pillow permet de créer des formes géométriques simples dans une image : ligne, cercle, rectangle, texte
Voici un script qui fabrique l'image d'un camembert 2D (au format PNG) :
| # script # Python 2.7 & Python 3 # Pillow 6.0.0 from PIL import Image,ImageDraw # création d'une image 400x400 (fond blanc) img = ("RGB",(400,400),"#FFFFFF") # création d'un objet Draw dessin = (img) # dessine un arc partiel et le remplit dessin.pieslice((50,50,350,350),0,60,fill="blue") dessin.pieslice((50,50,350,350),60,150,fill="gray") dessin.pieslice((50,50,350,350),150,360,fill="red") # dessine du texte ((50,20),"camembert 2D",fill="red") ("","PNG") () |
Exercice 10.1 ★ 1) Reprendre le script de manière à
réduire l'image initiale à deux couleurs (noir et blanc) en utilisant un seuil :
2) Faire la même chose avec le logiciel GIMP.
1) Reprendre le script de façon à retourner l'image (rotation à 180 degrés) :
2) Faire la même chose avec le logiciel GIMP.
1) Reprendre le script afin de faire une transformation miroir horizontal :
2) Faire la même chose avec le logiciel GIMP.
1) Reprendre le script afin de faire une transformation miroir vertical :
2) Faire la même chose avec le logiciel GIMP.
A l'aide de la méthode resize() du module Image de la librairie Pillow, redimensionner une image JPEG.
Par exemple :
| >>> Redimensionnement d'une image JPEG Nom de l'image originale ? Taille de l'image originale : (largeur, hauteur) = (1944, 2592) Nouvelle taille : Hauteur en pixels ? 800 Largeur en pixels : 600 Enregistrement de l'image redimensionnée Nom de l'image redimensionnée ? >>> |
1) A l'aide de la méthode getpixel() du module Image de la librairie Pillow, estimer le diamètre d'un disque blanc d'une image à fond noir. getpixel((x,y)) retourne la couleur du pixel de coordonnées (x,y).
Par exemple :
>>>
Nom du fichier ?
Largeur en pixels : 380
Hauteur en pixels : 250
Nombre de pixels (blanc) : 8820
Position du centre : x = 129.0 y = 100.0
Diamètre en pixels : 105.971565925
>>>
Ledébogueur est un outil utile au débutant car il aide à comprendre le fonctionnement d'un script existant.
Pour un professionnel, il permet le test et la mise au point d'un script en cours de développement (détection et élimination desbugs).
Il existe plusieurs outils de déboguage sous Python, notamment le module standard pdb (en ligne de commande).
Nous ne nous intéresserons qu'au débogueur de l'environnement IDLE (en mode graphique).
Commencer par télécharger le
Ce script affiche le carré des nombres entiers de 1 à 5.
Nous allons tester son bon fonctionnement avec le débogueur de l'environnement IDLE.
Ouvrir IDLE :
Démarrer → Programmes → Python → IDLE (Python GUI)
Puis lancer le débogueur : Debug → Debugger
Cocher les cases Source et Globals :
N.B. Les copies d'écran ont été réalisées avec Python 2.7, et cela reste valable avec Python 3.
Le débogueur possède 5 boutons de commande :
| Go |
§ : Exécution normale du programme jusqu'au prochain point d'arrêt.
| Step |
| Over |
§ : Exécution pas-à-pas (instruction par instruction)
§ : Exécution pas-à-pas du programme principal (le débogueur ne rentre pas dans les fonctions)
§ Out : Pour sortir de la fonction en cours § Quit : Termine le programme
Dans l'interpréteur intéractif (Python Shell), ouvrir le script : File → Open →
La fenêtre du code source s'ouvre.
Dans cette fenêtre : Run → Run Module (ou touche F5)
Pour faire du pas-à-pas grossier, cliquer sur le bouton Over du débogueur :
Noter que l'on peut observer le contenu des variables (actuellement a vaut 4).
Pour faire du pas-à-pas détaillé, cliquer sur le bouton Step du débogueur. Pour sortir immédiatement d'une fonction, utiliser le bouton Out (en particulier pour sortir du script qui gère la fonction print()).
Dans la fenêtre du code source, sur la ligne d'instruction considérée, faire un clic droit et choisir Set Breakpoint (la ligne est alors surlignée en jaune) :
Puis utiliser le bouton Go.
Exercice 11.1 A l'aide du débogueur, étudier la fonction récursive factorielle()qui retourne la factorielle d'un nombre entier :
def factorielle(x): if x < 2: return 1 else:
result = x*factorielle(x-1) return result
print(factorielle(5))
N.B. Une fonction récursive est une fonction qui s'appelle elle-même !
Exercice 11.2 A l'aide du débogueur, étudier lasuite de Conway dont le script est disponible ici :
>>>
0 1
1 11
2 21
3 1211
4 111221
5 312211
6 13112221
7 1113213211
8 31131211131221
9 13211311123113112211
10 11131221133112132113212221
L'extension Py2exe permet de convertir un script Python en un programme exécutable (uniquement pour le système d'exploitation Windows).
Ce programme exécutable (fichier avec l'extension .exe) peut ensuite être lancé sur un ordinateur où Python n'est pas installé.
Il faut un ordinateur avec Windows et Python déjà installé (attention :
Py2exe ne supporte pas la version 3 de Python).
Le programme d'installation de Py2exe est disponible ici :
Avec une machine 32 bits et Python version 2.7, vous devez utiliser le fichier suivant :
Une fois téléchargé, il suffit d'exécuter ce fichier pour installer Py2exe.
A titre d'exemple, voici le script d'un jeu de puissance 4 :
Télécharger et enregistrer ce script dans le répertoire où est installé Python (chez moi, c'est le répertoire C:\Python27).
Créer le script :
# from import setup import py2exe setup(windows=[""])
Enregistrer le script dans le répertoire courant de Python.
§ si vous voulez disposer de la console en plus de l'interface graphique
(GUI),
§ pour traiter plusieurs scripts en même temps, il suffit de compléter la liste :
Ouvrir l'interpréteur de commande de Windows (Démarrer → Exécuter → cmd)
Placez-vous dans le répertoire courant de Python (commande cd : change directory) :
> cd C:\Python27
puis lancer Py2exe :
> python py2exe
Dans le cadre du projet de la spécialité ISN (bac S), si vous êtes intéressés par la création de jeux vidéo en 2D, il existe le module Pygame de Python.
Attention : le choix de ce type de projet demande un investissement initial important, et cela ne doit pas empiéter sur les autres disciplines
Du point de vue technique, Pygame se base sur la bibliothèque.
De nombreux jeux sont disponibles et téléchargeables sur le site officiel de Pygame :
Il faut d'abord installer Python version 3.2 :
puis installer la version correspondante de Pygame :
Vous pouvez tester le bon fonctionnement en téléchargeant le jeu SpaceAce :
L'archive estici (à extraire).
Un bug à corriger : il faut renommer le fichier en Pour lancer le jeu, ouvrir et exécuter le script avec Python.
Vous noterez que le code source fait environ 300 lignes. Règle du jeu
Les applications et jeux en réseau se basent sur le modèle clients/serveur.
Au niveau de la programmation, la tâche est ardue car il faut avoir des connaissances en réseau (module socket) et en multithreading (module threading) :
- Un socket permet de connecter deux machines à travers un réseau. Ainsi, pour un jeu en réseau avec 10 joueurs (soit 10 clients et 1 serveur), il faut créer 10 sockets (chaque client est connecté au serveur). Dans le cas du réseau Internet, les sockets se servent du protocole IP (couche réseau) et du protocole TCP pour la couche transport (il existe aussi le protocole UDP qui est plus simple, plus rapide mais non fiable).
- Le multithreading est une technique qui permet d'exécuter plusieurs tâches (thread) en même temps et de manière indépendante dans un même processus.
Pour un jeu en réseau avec 10 joueurs, le serveur utilisera 10 threads pour communiquer individuellement avec chaque client.
Chaque thread gère donc le socket du client.
On retrouve le multithreading du côté de l'application cliente : pour traiter l'émission et la réception en parallèle, on utilise un thread pour parler au serveur, et un autre pour écouter le serveur.
Il s'agit d'un jeu multijoueurs.
On peut y jouer en réseau local (LAN) ou sur Internet.
Chaque joueur lance son application cliente pour se connecter au serveur. La première étape consiste à créer un pseudonyme, puis quand le nombre de joueurs est suffisant (3 dans l'exemple ci-dessous), la partie commence.
Le serveur envoie alors simultanément la première question à l'ensemble des joueurs : le but est d'y répondre correctement et le plus rapidement possible.
Quand tout le monde a répondu ou si la limite de temps est dépassée, on passe à la question suivante
Un classement est établi à partir d'un système de points.
Avant toute chose, il faut lancer le serveur.
Le port par défaut est 50026 et le nombre de joueurs est 3.
Mais on peut choisir pour le numéro de port une valeur arbitraire comprise entre 49152 et 65535, ainsi qu'un nombre quelconque de joueurs : il suffit de modifier ces paramètres dans le script.
Ici, on joue à trois en réseau local (chez vous, derrière votre box, par exemple).
Pour se connecter au serveur, il faut connaître son adresse IP (192.168.1.10) et le port qu'il utilise (50026).
Python étant multiplateforme, on peut mélanger les systèmes d'exploitation : Windows, Linux, Mac Dans cet exemple :
§ le serveur et un client tournent sur le même ordinateur sous Linux/Ubuntu (192.168.1.10)
§ un deuxième client sur un ordinateur sous Windows (192.168.1.11)
§ un troisième client sur un troisième ordinateur sous Linux/Ubuntu (192.168.1.13)
Finalement, c'est Ubuntu qui gagne devant Windows ;)
Cette application fonctionne mais est loin d'être parfaite : les pertes de connexion ne sont pas gérées, etc
Si vous avez testé cette application, cela m'intéresse d'avoir un retour de votre part.
§ serveur
§ client (mode graphique avec Tkinter)
§ client (mode console)
Ecrire l'application serveur et l'application cliente d'un jeu de morpion en réseau local (LAN) ou sur Internet (plus d'informations) :
Le cours de Gérard Swinnen, avec deux exemples concrets à essayer (un chat et un jeu de bombardes) :
§
§ livre de Brandon Rhodes et John Goerzen :
§ Foundations of Python Network Programming () La documentation officielle de Python :
§
§
Ce module pédagogique s'appuie sur l'écriture des lois de l'électricité pour résoudre un problème donné.
Ce n'est donc pas un logiciel de simulation.
pip install dc-electricity
Version française
English version
Une résistance de 100 Ω est alimentée par une tension de 5 volts.
Que vaut le courant dans la résistance ? Quelle est la puissance consommée ?
>>> from dcelectricity.dc_fr import *
>>> loi = Loi()
>>> U = Tension(5)
>>> R = Resistance(100)
>>> I = (v=U, r=R)
>>> I
Intensité du courant : 0.05 A (50.000000 mA)
>>> P = loi.Joule(r=R, i=I)
>>> P
Puissance : 0.25 W (250.000000 mW)
On peut aussi utiliser des expressions littérales.
Notez que si l'expresssion est "inattendue", vous aurez droit à un message d'erreur :
>>> I = U/R
>>> I
Intensité du courant : 0.05 A (50.000000 mA)
>>> I = R/U
TypeError
Pour la puissance :
>>> P = R*I*I
>>> P = U*(U/R)
>>> P = U*I
Que vaut la résistance équivalente à l'association en parallèle de 2 résistances 1 kΩ et 1,5 kΩ ?
>>> from dcelectricity.dc_fr import *
>>> loi = Loi()
>>> R1 = Resistance(1, 'k')
>>> R2 = Resistance(1.5, 'k')
>>> Req = loi.Rparallele(R1, R2)
>>> Req
Résistance : 600.000000 Ω
Voici une notation équivalente bien pratique :
>>> Req = R1//R2
>>> Req
Résistance : 600.000000 Ω
Avec les équations littérales :
>>> Req = 1/(1/R1+1/R2)
>>> Req = R1*(R2/(R1+R2))
Enfin, en passant par les conductances :
>>> G1 = 1/R1
>>> G2 = 1/R2
>>> Geq = G1 +G2
>>> Geq
Conductance : 0.00166667 S (1.666667 mS)
>>> Req = 1/Geq
>>> Req
Résistance : 600.000000 Ω
On s'intéresse au circuit électrique suivant :
Données :
E = 12 V ; R1 = 1 kΩ ; R2 = 2,7 kΩ et R3 = 1,8 kΩ
Télécharger les
Ce script calcule les courants I1, I2 et I3, les tensions U1 et U2 et fait un bilan de puissances.
>>> from dcelectricity.dc_fr import *
>>> E = Tension(12)
>>> E
Tension : 12.000000 V
>>> R1 = Resistance(1, 'k')
>>> R1
Résistance : 1000 Ω (1.000000 kΩ)
>>> R2 = Resistance(2.7, 'k')
>>> R3 = Resistance(1.8, 'k')
>>> R23 = R2//R3 # résistances en parallèle
>>> R23
Résistance : 1080 Ω (1.080000 kΩ)
>>> Req = R1 +R23 # résistances en série
>>> Req
Résistance : 2080 Ω (2.080000 kΩ)
>>> I1 = E/Req # Loi d'Ohm
>>> I1
Intensité du courant : 0.00576923 A (5.769231 mA)
>>> V1 = R1*I1 # Loi d'Ohm
>>> V1
Tension : 5.769231 V
>>> V2 = E -V1 # Loi des branches
>>> V2
Tension : 6.230769 V
>>> I2 = V2/R2 # Loi d'Ohm
>>> I2
Intensité du courant : 0.00230769 A (2.307692 mA)
>>> I3 = I1 -I2 # Loi des nœuds
>>> I3
Intensité du courant : 0.00346154 A (3.461538 mA)
Une autre approche :
>>> loi = Loi()
>>> # diviseur de tension
>>> V2 = loi.DiviseurTension(vtotal=E, r=R2//R3, r2=R1) >>> V2
Tension : 6.230769 V
>>> # Théorème de Millman
>>> masse = Tension(0)
>>> V2 = loi.Millman(v_r=[(E, R1), (masse, R2), (masse, R3)])
>>> V2
Tension : 6.230769 V
>>> (E/R1)/(1/R1 +1/R2 +1/R3)
Tension : 6.230769 V
| >>> V2/E 0.5192307692307693 >>> # diviseur de courant >>> I3 = loi.DiviseurCourant(itotal=I1, r=R3, r2=R2) >>> I3 Intensité du courant : 0.00346154 A (3.461538 mA) >>> I1*R2/(R2 +R3) Intensité du courant : 0.00346154 A (3.461538 mA) |
Puissances et loi de Joule
| >>> P = E*I1 # puissance fournie par la source E >>> P Puissance : 0.0692308 W (69.230769 mW) >>> P1 = loi.Joule(r=R1, i=I1) >>> P1 Puissance : 0.033284 W (33.284024 mW) >>> R1*I1*I1 Puissance : 0.033284 W (33.284024 mW) >>> loi.Joule(r=R1, v=V1) Puissance : 0.033284 W (33.284024 mW) >>> V1*(V1/R1) Puissance : 0.033284 W (33.284024 mW) >>> P2 = loi.Joule(r=R2, i=I2) >>> P2 Puissance : 0.0143787 W (14.378698 mW) >>> P3 = loi.Joule(r=R3, i=I3) Puissance : 0.021568 W (21.568047 mW) >>> P1 +P2 +P3 Puissance : 0.0692308 W (69.230769 mW) |
Le même circuit électrique mais avec une résistance R3 ajustable :
| Etude de l'évolution de U2 en fonction de R3 R3 = ? 0 Propriétés de R3 : Résistance : 0.000000 Ω Propriétés de U2 : Tension : 0.000000 V R3 = ? 100 Propriétés de R3 : Résistance : 100.000000 Ω Propriétés de U2 : Tension : 1.055375 V R3 = ? |
Télécharger les
etexemple2a_analyse_para
On utilise ici le module matplotlib pour faire de belles courbes :
Télécharger les
etexemple2b_analyse_para
On cherche la valeur de R3 qui donne U2 = 6,00 V. On utilise une méthode dichotomique :
Itération R3 (Ω) U2 (V)
1 5000.0
7.641509433962264
2 2500.0 6.7782426778242675
3 1250.0
5.5290102389078495
4 1875.0 6.303501945525291
5 1562.5
5.969049373618275
6 1718.75 6.146947223180407
7 1640.625
6.060929983965794
8 1601.5625
6.0157594420795215
9 1582.03125 5.992601726263872
10 1591.796875 6.004229291252643
11 1586.9140625 5.998427762523782
12 1589.35546875
6.001331580654524
13 1588.134765625
5.99988043623693
14 1588.7451171875 6.000606199456697
15 1588.43994140625 6.000243365618415
16 1588.287353515625
6.000061912872932
17 1588.2110595703125
5.99997117754154
Résultat : 1588.2110595703125 Ω
Télécharger les
Ce module gère les opérations arithmétiques de base (+, -, *, /) ainsi que // qui désigne deux résistances en parallèle.
La cohérence des unités est contrôlée :
>>> V3 = V1 -V2 +I3
TypeError
>>> I = I1 +0.5
TypeError
>>> I2 = Courant(0.5)
>>> I = I1 + I2
>>> I = 5*I2 -V1/R1 + I3
Le résultat d'une opération doit donner une grandeur dont l'unité est en volt, ampère, ohm, siemens, watt ou sans unité. Autrement, vous aurez une erreur :
>>> R1/V1 # Ω/V -> Erreur
TypeError
>>> R2*(R3/(R2 +R3)) # Ω*(Ω/Ω) -> Ω*() -> Ω
>>> R2*R3/(R2 +R3) # Ω*Ω -> Erreur
TypeError
>>> P = V1*(V1/R1) # V*(V/Ω) -> V*A -> W
>>> P = V1*V1/R1 # V*V -> Erreur
TypeError
>>> V1()**2/R1()
Ce module pédagogique s'appuie sur l'écriture des lois de l'électricité pour résoudre un problème donné.
Ce n'est donc pas un logiciel de simulation.
pip install dc-electricity
Version française
English version
Une résistance de 100 Ω est alimentée par une tension de 5 volts.
Que vaut le courant dans la résistance ?
Quelle est la puissance consommée ?
>>> from dcelectricity.dc_fr import *
>>> loi = Loi()
>>> U = Tension(5)
>>> R = Resistance(100)
>>> I = (v=U, r=R)
>>> I
Intensité du courant : 0.05 A (50.000000 mA)
>>> P = loi.Joule(r=R, i=I)
>>> P
Puissance : 0.25 W (250.000000 mW)
On peut aussi utiliser des expressions littérales.
Notez que si l'expresssion est "inattendue", vous aurez droit à un message d'erreur :
>>> I = U/R
>>> I
Intensité du courant : 0.05 A (50.000000 mA)
>>> I = R/U
TypeError
Pour la puissance :
>>> P = R*I*I
>>> P = U*(U/R)
>>> P = U*I
Que vaut la résistance équivalente à l'association en parallèle de 2 résistances 1 kΩ et 1,5 kΩ ?
>>> from dcelectricity.dc_fr import *
>>> loi = Loi()
>>> R1 = Resistance(1, 'k')
>>> R2 = Resistance(1.5, 'k')
>>> Req = loi.Rparallele(R1, R2)
>>> Req
Résistance : 600.000000 Ω
Voici une notation équivalente bien pratique :
>>> Req = R1//R2
>>> Req
Résistance : 600.000000 Ω
Avec les équations littérales :
>>> Req = 1/(1/R1+1/R2)
>>> Req = R1*(R2/(R1+R2))
Enfin, en passant par les conductances :
>>> G1 = 1/R1
>>> G2 = 1/R2
>>> Geq = G1 +G2
>>> Geq
Conductance : 0.00166667 S (1.666667 mS)
>>> Req = 1/Geq
>>> Req
Résistance : 600.000000 Ω
On s'intéresse au circuit électrique suivant :
Données :
E = 12 V ; R1 = 1 kΩ ; R2 = 2,7 kΩ et R3 = 1,8 kΩ Télécharger les
Ce script calcule les courants I1, I2 et I3, les tensions U1 et U2 et fait un bilan de puissances.
>>> from dcelectricity.dc_fr import *
>>> E = Tension(12)
>>> E
Tension : 12.000000 V
>>> R1 = Resistance(1, 'k')
>>> R1
Résistance : 1000 Ω (1.000000 kΩ)
>>> R2 = Resistance(2.7, 'k')
>>> R3 = Resistance(1.8, 'k')
>>> R23 = R2//R3 # résistances en parallèle
>>> R23
Résistance : 1080 Ω (1.080000 kΩ)
>>> Req = R1 +R23 # résistances en série
>>> Req
Résistance : 2080 Ω (2.080000 kΩ)
>>> I1 = E/Req # Loi d'Ohm
>>> I1
Intensité du courant : 0.00576923 A (5.769231 mA)
>>> V1 = R1*I1 # Loi d'Ohm
>>> V1
Tension : 5.769231 V
>>> V2 = E -V1 # Loi des branches
>>> V2
Tension : 6.230769 V
>>> I2 = V2/R2 # Loi d'Ohm
>>> I2
Intensité du courant : 0.00230769 A (2.307692 mA) >>> I3 = I1 -I2 # Loi des nœuds
>>> I3
Intensité du courant : 0.00346154 A (3.461538 mA)
Une autre approche :
| >>> loi = Loi() >>> # diviseur de tension >>> V2 = loi.DiviseurTension(vtotal=E, r=R2//R3, r2=R1) >>> V2 Tension : 6.230769 V >>> # Théorème de Millman >>> masse = Tension(0) >>> V2 = loi.Millman(v_r=[(E, R1), (masse, R2), (masse, R3)]) >>> V2 Tension : 6.230769 V >>> (E/R1)/(1/R1 +1/R2 +1/R3) Tension : 6.230769 V >>> V2/E 0.5192307692307693 >>> # diviseur de courant >>> I3 = loi.DiviseurCourant(itotal=I1, r=R3, r2=R2) >>> I3 Intensité du courant : 0.00346154 A (3.461538 mA) >>> I1*R2/(R2 +R3) Intensité du courant : 0.00346154 A (3.461538 mA) |
Puissances et loi de Joule
>>> P = E*I1 # puissance fournie par la source E
>>> P
Puissance : 0.0692308 W (69.230769 mW)
>>> P1 = loi.Joule(r=R1, i=I1)
>>> P1
Puissance : 0.033284 W (33.284024 mW) >>> R1*I1*I1
Puissance : 0.033284 W (33.284024 mW) >>> loi.Joule(r=R1, v=V1)
Puissance : 0.033284 W (33.284024 mW) >>> V1*(V1/R1)
Puissance : 0.033284 W (33.284024 mW)
>>> P2 = loi.Joule(r=R2, i=I2)
>>> P2
Puissance : 0.0143787 W (14.378698 mW)
>>> P3 = loi.Joule(r=R3, i=I3)
Puissance : 0.021568 W (21.568047 mW)
>>> P1 +P2 +P3
Puissance : 0.0692308 W (69.230769 mW)
Le même circuit électrique mais avec une résistance R3 ajustable :
| Etude de l'évolution de U2 en fonction de R3 R3 = ? 0 Propriétés de R3 : Résistance : 0.000000 Ω Propriétés de U2 : Tension : 0.000000 V R3 = ? 100 |
Propriétés de R3 :
Résistance : 100.000000 Ω Propriétés de U2 :
Tension : 1.055375 V
R3 = ?
Télécharger les
etexemple2a_analyse_para
On utilise ici le module matplotlib pour faire de belles courbes :
Télécharger les
etexemple2b_analyse_para
On cherche la valeur de R3 qui donne U2 = 6,00 V. On utilise une méthode dichotomique :
Itération R3 (Ω) U2 (V)
1 5000.0
7.641509433962264
2 2500.0 6.7782426778242675
3 1250.0
5.5290102389078495
4 1875.0 6.303501945525291
5 1562.5
5.969049373618275
6 1718.75 6.146947223180407
7 1640.625
6.060929983965794
8 1601.5625
6.0157594420795215
9 1582.03125 5.992601726263872
10 1591.796875 6.004229291252643
11 1586.9140625 5.998427762523782
12 1589.35546875
6.001331580654524
13 1588.134765625
5.99988043623693
14 1588.7451171875 6.000606199456697
15 1588.43994140625 6.000243365618415
16 1588.287353515625
6.000061912872932
17 1588.2110595703125
5.99997117754154
Résultat : 1588.2110595703125 Ω
Télécharger les
Ce module gère les opérations arithmétiques de base (+, -, *, /) ainsi que // qui désigne deux résistances en parallèle.
La cohérence des unités est contrôlée :
>>> V3 = V1 -V2 +I3
TypeError
>>> I = I1 +0.5
TypeError
>>> I2 = Courant(0.5)
>>> I = I1 + I2
>>> I = 5*I2 -V1/R1 + I3
Le résultat d'une opération doit donner une grandeur dont l'unité est en volt, ampère, ohm, siemens, watt ou sans unité. Autrement, vous aurez une erreur :
>>> R1/V1 # Ω/V -> Erreur
TypeError
>>> R2*(R3/(R2 +R3)) # Ω*(Ω/Ω) -> Ω*() -> Ω
>>> R2*R3/(R2 +R3) # Ω*Ω -> Erreur
TypeError
>>> P = V1*(V1/R1) # V*(V/Ω) -> V*A -> W
>>> P = V1*V1/R1 # V*V -> Erreur
TypeError
>>> V1()**2/R1()
