Python 3 Python

Programmation impérative

Langage de programmation développé par le néerlandais Guido van Tossum en 1991.

Python est libre et fonctionne sur les principaux OS : Windows, macOS, Linux.
Il permet différents paradigmes de programmation ( impératif, fonctionnel, orienté objet )
Des modules spécialisés dans des domaines les plus divers sont disponibles.
Une littérature conséquente existe sur le net ( cours, tuto, forum, ... )

Cours L'environnement de développement intégré

Structures de données : - Types de base : bool - int - float - str
- Types construits : tuple - liste - dictionnaire - itérable
Structures de contrôle : if - while - for
Listes en compréhension
Fonctions : - Définition et appel
- Portée d'une variable
- Nombre quelconque d'arguments
Expressions régulières
Bonnes pratiques - Lisibilité
- Gestion des erreurs
TD Trame NMEA
Reconstitution d'une partie d'échec
Traitement de l'image
- Image matricielle sans compression
- Permutation - de pixels ( photomaton )
- des couleurs
- Fondu enchaîné
- Matrice de convolution
Stéganographie
Récursivité - Ensemble de Mendelbrot
- Triangles de Sierpinski
- Arbre fractal
Compression sans perte - Algorithme LZW

Organisation : Durée 8h : séance 1 : 2h cours + 1h TD Lundi 15-11-2021 13h30

séance 2 : 3h TD Mercredi 24-11-2021 13h30
séance 3 : 2h TD Vendredi 3-12-2021 8h30

Lieu Lycée Marc Bloch ( salle 2 )

Formateur Yves Poirey [email protected]

 IDLE
« Integrated DeveLopment Environment »
( environnement de développement intégré )

Thonny

Site : https://thonny.org/ Download version 3.x for Windows

NB N'oubliez pas de choisir la langue durant le premier lancement de Thonny

Options

Editeur

à décocher Permettre la complétion du code ...

Permettre la complétion du code ...

Gérer les paquets

Rechercher un paquet sur Py

Sélectionner l'interpréteur

Le même interpréteur qui exécute Thonny ( par defaut )

MicroPython (ESP32)

Fichier Edition Affichage Exécuter Device Outils Aide

rien.py structure
Terminal
abc
from turtle import * # Importation du module 'turtle'

def abc():
pass

print("bonjour ",end=' ')

print("tout le monde")
for x in range(4):
forward(100) # Tracé d'un trait de 100 pixels de long.
left(90) # Rotation à gauche de 90°
done()

>>>

Console
Structures de données
Types de base Les différents types : int, float, str, bool.
Le typage des données est dynamique : Il n'est pas déclaré mais défini ( ou redéfini ) par l'intéprèteur.
La fonction type() renvoie le type d'un objet.

ex. a,c = 6,2 # 2 int print(type ( a+c)) <class 'int'>

b = 4.1 # float print(type(a/c)) <class 'float'>
print(type(a//c)) <class 'int'>
print(type(b+a)) <class 'float'>
bool : Valeurs : True, False
Opérateurs logiques : not, and, or, xor ( listés par priorité )
Evaluation d'une expression : de gauche à droite jusqu'à la vérité.
True or --- non évaluée

numériques Opérations : + ; - ; * ; / ; // ( division entière) ; % ( modulo) ; ** (puissance)

( int et float ) Comparaisons : == ; != ; < ; > ; <= ; >=
NB : Ne jamais tester l'égalité entre deux floats

str opérateurs : concaténation +

répétition *
print("ab"+"c") => "abc"
print(2 * "ab" ) => "abab"
}print(3*"="+"salut"+2*"=")
=> "===salut=="
comparaison ( ordre lexicographique ) => "ab"< "c"
[1, ('aa', 'ab')] < [1, ('abc', 'a'), -1]
Délimiteurs '---' ; "----" ;
""" ---""" accepte des sauts de ligne
Caractères spéciaux L'échappement : \ modifie l'interprétation du caractère suivant :
\n est un saut de ligne
\t est une tabulation
\' est un « ' », mais il ne ferme pas la chaîne de caractères
\" est un « " », mais il ne ferme pas la chaîne de caractères
\\ est un « \ »

Méthodes mise en forme : s.lower() s.upper() s.title() s.capitalize()

sur string s='oui'.center(8,"-") #=> --oui---
s='oui'.rjust(8,"-") #=> -----oui
analyse : s.count("sous-chaîne")
s.isalpha() s.isdigit() s.isalnum() s.isnumeric()

traitement depuis une liste : L=[ "un" , "tableau" , "de mots" ]

Separateur="-"
s=Separateur.join(L) # => "un-tableau-de mots"
vers une liste s="un-ensemble-de mots"
L=s.split("-") #=> ['un', 'ensemble', 'de mots']
suppression des extrémités ( "\n", "\t", " " par défaut )
"\n\t oui... \n\n\n".strip()" #=> "oui..."
"\n\t oui... \n\n\n".strip("i.\n\t o") #=> "u"
remplacement s="blabla".replace("bla" , "ri") #=> riri
Formatage a = -3
champs
b = 5.009 arguments
c=9
s = "oui {1:^+7.2f} et {0:>7.1f} et {2:o}".format(a,b,c) # => oui +5.01 et -3.0 et 11
f : float 7 7
index de l'argument o : octal
Nombre signé Nb décimales
Alignements
Taille du champ

Date import datetime %A Nom du jour %H Heure (de 00 à 23)

import locale %B Nom du mois %M Minute (entre 00 et 59)
%d Jour du mois %S Seconde (de 00 à 59)
locale.setlocale(locale.LC_TIME,'') %Y Année
currDate = datetime.datetime.now()
Mess= '{:%A le %d %B de l\'an de grâce %Y à %H:%M:%S}'.format(currDate)
print(Mess)
Types construits : collection d'éléments

tuple création T = ( 2, 'a', 5 ) ou T= 2, 'a', 5

accès à un élément T[0] => 2
T[-1] => 5
non modifiable ( non mutable )
généralement utilisé pour les renvois de fonctions

list création L = [ 2, 'a', 5,[1.2]]

accès à un élément L[0] => 2

L[-3] => 'a'

slice ( tranche ) print(L[1:]) => ['a', 5, [1.2]]

print(L[1:3]) => ['a', 5 ]
print(L[:3]) => [2, 'a', 5]

test d'appartenance 2 in L => True L = [ 2, 'a', 5,6]

modification L[0]=6 L3=L
suppression del L[0], del L[1:3] , del L[:] L2 = L[:] L => [3, 'a', 5, 6]
copie L2 = L[:]
NB L3=L => double référence sur L } L[0]=3 L2 => [2, 'a', 5, 6]
L3 => [3, 'a', 5, 6]
Méthodes
.append (élément) ajoute un élément à la fin de la liste L
.extend (L2) ajoute les éléments de L2 à la fin de la liste 3
L3 'a'
ou L=L+L2
5
.insert (index,élément) 6
.remove (élément) supprime la 1ère occurrence
.index (élément) renvoie l'index de la 1ère occurrence L2 2
.count (élément) renvoie le nombre d'occurrences 'a'
.pop (index= -1) renvoie l'élément indexé puis le supprime de la liste 5
.reverse () inverse les éléments d'une liste 6
.sort () trie la liste dans l'ordre croissant .sort (reverse = True)
.copy () renvoie une copie de la liste
.clear () vide la liste

Liste de listes ( tableau )

clés
dict collection de valeurs référencées par leur clé D = { 'a':2, 'b':3 , 'c':5 }
valeurs
création dictionnaire vide D={} ou D=dict()
D={'a':2 , 'b':3 , 'c':5 }
accès D['a'] => 2
D.items() # => [('a', 2), ('b', 3), ('c', 5)]
D.get('b', None) # => 3
D.get('e', None) # => None
modification D['a'] = 1
ajout D['d'] = 6
test d'appartenance 'b' in D.keys() # => True
5 in D.values()) # => True
suppression del D['b']
Tranche (slice) L = list(D.items()) # => L = [('a', 2), ('b', 3), ('c', 5)]
D2 = dict(L[0: 2]) # => D2 = {'a': 2, 'b': 3}

itérable ( tuple, list, dict, str ) méthodes communes

longueur len(I)
max, min max(I) min(I)
somme sum(I) si les éléments s'y prêtent.
test d'appartenance élément in I
Structures de contrôle
Une condition est une expression booléenne.
Nb : Une structure vide, None et le nombre 0 ont comme valeur booléenne False : bool('') = bool(None) = False
les autres expressions sont interprétées comme True : bool('salut') = bool(3)=bool([False]) = True

if if condition: if condition1: Res = "oui" if condition else "non"

BlocOui BlocOui1
else: elif condition2:
BlocNon BlocOui2
else:
BlocNon2

while while condition:

BlocW

Debut=2
for Exclu = 4 Debut=2 Exclu = 10
for Nb in range(Exclu): Exclu = 4 Pas = 3
print(Nb) => 0 1 2 3 for Nb in range( Debut, Exclu ): for Nb in range( Debut, Exclu, Pas ):
print(Nb) => 2 3 print(Nb) => 2 5 8

S = "abc" I = "abcde" I = "abcde"

for Car in S : for Car in I: for Car in I:
print( Car ) => a b c if Car in "ce": if Car in "ce":
continue # passe à l'itération break # fin du for
L = ['a', 3, 'z'] # suivante print(Car) => a b
for El in L: print(Car) => a b d
D = {'a': 2, 'b': 5}
print( Car ) => 'a' 3 'z'
for Key, Value in D.items():
... print(Key, Value) => 'a' 2
'b' 5
Liste en compréhension
[<Expression> for <Element> in <Iterable> if <Condition>]
L = [ Nb*3 for Nb in range(5) if Nb%2 == 0 ] => [0, 6, 12]

création répétition condition

d'un élément optionnelle

[<ExpressionOui> if <Condition> else <ExpressionNon> for <Element> in <Iterable>]

Imbrications de boucles
[ <Expression> for <Element_a> in <iterable_a> (optional if <Condition_a>) boucle principale
for <Element_b> in <Iterable_b> (optional if <Condition_b>)
... and so on ...]
multiplications = [i*n for i in range(1,4) for n in range(3)] #=> multiplications = [0,1,2,0,2,4,0,3,6]
matrix = [ [1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12] ]
flatten = [n for row in matrix for n in row] # => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
transpose = [[row[n] for row in matrix] for n in range(4)] # => [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
 Nom de la fonction ( verbe à l'infinitif )
Les fonctions Paramètres
Arguments par défaut
Définition et appel
def Ajouter(a=1, b=2): Définition d'une fonction
Somme=a+b
return Somme Valeur de retour
Appels de la fonction
print( Ajouter(4,5) ) # => 9
print( Ajouter(4) ) # => 6
print( Ajouter(b=8) ) # => 9
Passages des arguments

Portée d'une variable Variable circonscrite

def F2(L1):
à la fonction
L1[0]=3 Passage
def F1( a ): return L par
Deux variables a=5 Passage référence
distinctes qui n'ont return L=[1,2,3,4]
4 par F2(L)
aucune raison valeur L
a=4 print(L) #=> [3,2,3,4] 3
de porter L1
F1( a ) 2
le même nom L et L1 sont deux références 3
print( a ) #=> 4 à la même liste 4

Nombre Le packing et l'unpacking transforment une succession d'arguments, nommés (*args)

quelconque ou non (**kwargs ) en liste/tuple (*args) ou dictionnaire (**kwargs ) et vice-versa.
d'arguments L'utlisation des termes args (arguments) et kwargs (keyword arguments) ne sont pas
obligatoires, il s'agit d'une convention de nommage qu'il est recommandée de respecter.
def Mafontion( Empaquetage d'éléments dans un itérable ): *Itérable_Elements_non_nommés
----
Mafontion( éléments ) **Itérable_Elements_nommés (dico)

*args
def traitement(a_remplacer, remplacant, *args):
# empaquetage dans un tuple for idx, fichier in enumerate(args):
def MaFonction(*args): content = ""
print(args) # => (1,2) with open(fichier, 'r') as fichier_only:
#=================== for line in fichier_only.readlines():
MaFonction(1,2) line = line.replace(a_remplacer, remplacant)
content += line
def MaFonction(a,b): with open(fichier, 'w') as fichier_only:
print(a,b) # => 1 2 fichier_only.write(content)
#=================== #=====================================
rec=[1, 2] traitement('riri', 'fifi', 'fich1.txt')
# dépaquetage de la liste liste_fichiers=['fich3.txt', 'fich4.txt', 'fich5.txt']
MaFonction(*rec) traitement('fifi', 'loulou', *liste_fichiers)

**kwargs def MaFonction(msg, **kwargs):

C=kwargs.get('C', None)
# empaquetage dans un dico V=kwargs.get('V', None)
def MaFonction5(**kwargs): if (C and V):
print(kwargs) # => {'A': 0, 'B': 1} print(msg,C,V)
#=================== elif (V and not(C)):
MaFonction5(A=0,B=1) print(msg,V)
elif (not(V) and C):
def MaFonction6(A=0,B=0): print(msg,C)
print(A,B) #=> 8 3
else:
#=================== print(msg,'vide')
rec={'A':8, 'B':3} #===================
# dépaquetage du dico MaFonction('VC : ', V=3, C=2) #=> VC : 2 3
MaFonction6(**rec) MaFonction('V : ', V=3) #=> V : 3
MaFonction('C : ', C=2) #=> C : 2
MaFonction('rien') #=> rien vide
Expressions régulières : détection d'un motif dans un texte
import re
Match = bool(re.search(Regex, Texte))
print(Match)

où Regex est une expression régulière définie à partir du formalisme suivant :

[] délimiteur d'une classe de caractères : [abcd] n'importe qu'el caractère parmi la classe.
dans une classe les méta-caractères sont inactifs
- plage : [a-d] de 'a' à 'd'
^ placé en début = complément d'une classe: [^ab] ni 'a' ni 'b'
\ échappement d'un méta-caractère ou séquence
\d caractère numérique ; <=> [0-9]
\D caractère non numérique ; <=> [^0-9]
\s caractère « blanc » ; <=> [ \t\n\r\f\v]
\S caractère autre que « blanc » ; <=> [^ \t\n\r\f\v]
\w caractère alphanumérique ; <=> [a-zA-Z0-9_]
\W caractère non-alphanumérique ; <=> [^a-zA-Z0-9_]
* le caractère précédent peut être présent zéro, une ou plusieurs fois
cha*t => cht, chat, chaat, ... c[ha]*t => ct, cht, chht, cat, caat, chat, chaht, ...
+ le caractère précédent doit être présent une ou plusieurs fois
? le caractère précédent peut être présent zéro ou une fois
{m,n} le caractère précédent doit être présent au moins m fois et au plus n fois
| ou
^ début de ligne
\A début de chaîne
$ fin de ligne
\Z fin de chaîne
\b limite de mot
\B hors limite de mot

ex. @mail Regex= r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'

Ca commence par
Un ou plusieurs caractères
alphanumériques ou '.','_','%','+','-'
suivi(s) de '@'
puis d'un ou plusieurs
caractères alphanumériques
puis un '.'
et ça fini par
d'au moins 2
lettres

ex. @IPv4
Regex= r'(\b25[0-5]|\b2[0-4][0-9]|\b[01]?[0-9][0-9]?)(\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}\b'
1 parmi 1 parmi
25 [0-5] 25 [0-5]

1 parmi 1 parmi 1 parmi 1 parmi

2 [0-4] [0-9] . 2 [0-4] [0-9]

1 parmi 1 parmi 1 parmi 1 parmi 1 parmi 1 parmi 2x

[0-1] [0-9] [0-9] [0-1] [0-9] [0-9]
Bonnes pratiques

# coding: utf8
""" Spécifications : - argument(s) en entrée : - [type ] ; Description ; ex. :
- ...
- description du traitement :
- donnée(s) renvoyée(s) : - [type ] ; Description ; ex. :
- ...
Auteur : @Mail :
Date : 20/03/2018 Copyright : "copyleft" """
#=========================== Importation des modules ==========

# import module_interne
# import module_interne_2
# import module_externe
#=========================== Définition des fonctions ==========
Fonctions :
def Fonction1(): - Eviter les répétions de lignes de code
''' docstring ''' - Découper le programme de façon logique
pass ( Analyse fonctionnelle descendante )
#---------------------------------------- - Lisibilité
def Fonction2(): - Réinvestissement
''' docstring ''' - Séparer les interfaces du traitement
pass - Attention aux effets de bord
#----------------------------------------
def SaisirEntier(invite):
''' Spé : - Description : Attente d'un entier saisi par le client docstrings:
- pré-condition : str - invite client documentation
- post-condition : int accessible par
Auteur : Yves ''' help(SaisirEntier) :
Nommage des objets
Saisie=False
(donnez du sens ) Ne jamais
while not Saisie:
try: faire confiance
Reponse=int(input(invite)) à un utilisateur
Saisie=True
except:
print("Erreur de saisie; Veillez entrer un nombre entier")
nom du module return Reponse
durant l'exécution #=========================== Programme principal ============
du programme
if __name__ == '__main__': # Si le programme n'est pas appelé,

print( "\n"+" Début du programme ".center(50, '=')) # Séparateur à l'exécution

print ("{:<15} {:>1} {:>4} ".format("MaVariable","=", str("xxx"))) # Affichage avec tabulation
Instructions utilisées
lors d'une exécution
directe du module Commentaires
orientés système
( utilisateur du pgm )

L'assertion: Vérification d'une hypothèse avant que le programme ne produise une erreur.
assert condition, "message" ex. assert a==0," valeur nulle interdite"
Ce mécanisme de détection d'erreur, est une aide au développement
et ne doit pas faire partie du code fonctionnel du programme.
Si 'assert' détecte une erreur, le programme doit être modifié.
 TP - Exploitation d'une trame NMEA

Ressources : - logiciels - module 'Folium' à installer sur Thonny

- RelevesGPS.txt
- tuto - https://docs.python.org/fr/3/tutorial/
- https://fr.wikipedia.org/wiki/NMEA_0183

1) Analyse d'un programme : Depuis une trame GPS jusqu'à un tracé de parcours sur une carte

Ressources spécifiques : fichier - FoliumTrajet.py

Préliminaires : Structure d'une trame 'GGA'

Avec un éditeur de texte, ouvrez le fichier 'RelevesGPS.txt';

Il contient quelques relevés GPS d'un circuit à Strasbourg.
Identifiez les différents champs de cette trame.
Ouvrez puis exécutez le fichier 'FoliumTrajet.py'.
Un fichier 'Parcours.html' vient d'être généré; Ouvrez-le.

Analyse du programme :

Suivre le flux des différents traitements depuis le fichier '.txt' jusqu'au fichier '.html'
A chaque étape, affichez le contenu et le type des différentes structures de données.
print(Structure," ",type(Structure)).
Consignez ces observations en commentaires dans le programme.

2) Amélioration du programme .

Ressources spécifiques : fichiers à compléter - FoliumTrajet2.py

- GPS_Perso.py
- Math_Perso.py
- Folium_Perso.py

Voici quelques remarques qui conduisent à repenser le programme précédant.

1) En résumé, le programme analyse une trame GPS et confectionne une carte.

Dans une logique de modularité et de ré-investissement, les fonctions propres à la trame GPS
( Extraction et conversion des données ) devraient être rédigées dans une bibliothèque spécifique
aux manipulations de trames GPS: GPS_Perso.py.
Ces fonctions seront importées dans le programme principal 'FoliumTrajet2.py'.

D'un point de vue plus général, une fonction peut :

- soit découler d'une analyse descendante d'un énoncé,
- soit appartenir à un autre domaine. Ainsi, la fonction :
- 'centrer' renvoie l'isobarycentre d'un polygone
- 'longueur' renvoie le périmètre d'un polygone
- le calcul de la 'Distance' dans la fonction 'longueur' est une distance sphérique
Ces trois fonctions appartiennent au domaine des mathématiques
et à ce titre, devraient être consignées dans une bibliothèque spécifique 'Math_Perso'
Et toujours dans cette logique, une bibliothèque 'Folium_Perso' pourrait être envisagée.

2) Le fichier 'RelevesGPS.txt' contient des trames GPS de type 'GGA' mais un autre type est également
très répandu: les trames 'RMC'. (v. https://fr.wikipedia.org/wiki/NMEA_0183 )
La bibliothèque 'GPS_Perso.py' devra prendre en compte les deux types de trame.

3) Les récepteurs GPS captent fréquemment des trames non valides qu'il convient
d'identifier et de supprimer.

Complétez les espaces laissés vides(--- ) dans les différents modules

Structure d'un fichier .fen

Position des pièces vue du côté des blancs de la rangée 8 à la rangée 1. Reconstitution d'une partie d'échec
Le contenu de chaque rangée est décrit de la colonne 'a' à la colonne 'h'.
Nom des pièces : - 'R' ou 'r' : rook (tour),
- 'N' ou 'n' : knight (cavalier),
- 'B' ou 'b' : bishop (fou), 1 -Déterminez le code des
- 'Q' ou 'q' : queen (dame), positions des pièces
- 'K' ou 'k' : king (roi)
- 'P' ou 'p' : pawn (pion).
Couleur des pièces : - majuscules (« KQRBNP ») => blanc
- minuscules (« kqrbnp ») => noir.
Les nombres représentent le nombre de cases vides.
Une barre oblique « / » sépare les rangées.
Commentaires
rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1

Couleur qui joue: « w » = blancs jouent, « b » = noirs.

Possibilité(s) de roque:
« - » : aucun des adversaires ne peut roquer
« K »: les blancs peuvent du côté roi (petit roque),
« Q »: les blancs peuvent du côté dame (grand roque),
« k » : les noirs peuvent du côté roi Editez le programme "echec.py" et exécutez le.
« q » : les noirs peuvent du côté dame.
2 - Etude de la fonction"Afficher";
Prise en passant: S'il n'y en a pas, alors inscrire « - ».
Si un pion vient juste de se déplacer de 2 pas, On suppose que les paramètres de cette fonction sont :
alors c'est la position « derrière » le pion. caractère= "b", Abscisse=4 et Ordonnee=5.

Nombre de demi-coups depuis la dernière capture ou Déterminez :

le dernier mouvement de pion. Cela permet de savoir a) la valeur de NrPiece =
si la partie est nulle selon la règle des 50 coups.
b) Le nom de l'image qui sera affichée :
Nb de coups complets. Incrémenté après les noirs.
c) L'emplacement prévu pour cette image
https://fr.wikipedia.org/wiki/Notation_Forsyth-Edwards

3 - Etude de la fonction 'Ouvrir' L'instruction 'askopenfilename' permet la navigation dans l'arborescence d'un ordinateur et la sélection d'un fichier.
Mais que renvoie-t-elle ?
Dans la ligne de code "fichier = open(filename, "r") " que représente le paramètre 'r' ?
Dans le code "partie=fichier.readlines()", quelle est le type de 'partie' ?

4 - Etude de la fonction "Traiter":

1 def traitement(Coup): On suppose que le paramètre de cette fonction:

2 Abscisse=1 "coup" = 8/5k2/pR6/r4p1p/2pB2P1/2Pb3P/1P3P1K/8 w - - 0 38
3 Ordonnee=0
4 NrCaractere=0 La ligne '6' introduit la répétition d'un bloc d'instructions
5 caractere=Coup[NrCaractere]
6 while caractere!=" ": - Combien de fois ce bloc sera-t-il répété ?
7 if caractere in ["r","n","b","q","k","p","P","R","N","B","Q","K"]:
8 affiche_piece(caractere,Abscisse,Ordonnee) - Ce bloc s'étale de la ligne 7 à la ligne ...
9 Abscisse=Abscisse+1
10 else:
NrCaractere Caractère N° de lignes parcourues AbscisseOrdonnee
11 if caractere=="/":
12 Ordonnee=Ordonnee+1 0 8 6-7-10-11-14-15-16-17 9 0
13 Abscisse=1 1 6
14 else: 3 6
15 Abscisse=Abscisse+int(caractere) 5 6
16 NrCaractere=NrCaractere+1 17 6
17 caractere=Coup[NrCaractere] 37 6

5 - Modifiez le programme a) Le numéro de coup en cours.

pour qu'il affiche : - Création d'un label => LabelNrCoup = Label(tk, text = NrCoup, fg = 'red',font=("Helvetica", 16))
- Implantation => LabelNrCoup.grid(row=11, column=11)
- Rafraîchissement => LabelNrCoup.configure(text=NouvelleValeur)

b) Les pièces prisonnières => Utilisation d'un dictionnaire

DicoPiecesRestantes={"r":2,"n":2, ... }

Bilan: Cette activité s'est appuyée sur plusieurs notions :

- l'utilisation de listes, de dictionnaires, de structures ( 'while', 'if - else' , 'for' )

- Interface utilisateur sous tkinter
- La lecture du contenu d'un fichier.

Copiez le programme dans un traitement de texte puis, respectant les couleurs,

surlignez les codes qui exploitent les structures de données : Listes
Dictionnaires
 Traitement de l'image

Ressources Images: Logiciels :

voiture.png Notepad++ http://pillow.readthedocs.io/en/3.1.x/reference/Image.html
lancelot.jpg Hxd Editeur hexadécimal
rose.jpg GIMP 2.8.18 Convertisseur de formats
Python 3.x

Image matricielle sans compression Spécifications de la trame d'un fichier (.pbm, .pgm et .ppm)
"ascii"
codage
"brut" MaxVal Codage des pixels
P1 P4 PBM Portable BitMap monochrome (1 bit per pixel)
P2 P5 PGM Portable GreyMap 65536
P3 P6 PPM Portable PixMap 65536 triplet RougeVertBleu
Procédure magic
number TABs 09
A partir du logiciel 'GIMP', ouvrez le fichier 'voiture.png' LFs 0A
En-tête
et exportez le au format 'pgm' VT 0B
( Fichier  Export as  'voiture.pgm'  Formatage 'brut' des données ) 1 octet FF 0C
Fermez 'GIMP'. Whitespace CRs 0D
Space 20 décimal ASCII
En ouvrant ce fichier 'voiture.pgm' avec 'HxD' vous devriez obtenir séparées par
la figure 'voiture.pgm sous HxD'. un ou des
Width Matrice des pixels, WhiteSpace
Height de gauche à droite en hexa :
A partir de ce fichier et en vous appuyant sur les spécifications
Maxval et du haut en bas. si MaxVal < 256
de la trame du fichier,
- identifiez le 'magic number' : ASCII characters Codage : alors 1 octet
- en déduire - l'extension du fichier in decimal sinon 2 octets
- le type de codage
- identifiez la taille de l'image - hauteur : un "#" introduit des commentaires qui ne sont pas traités
- largeur : et qui finissent par un retour chariot ou saut de ligne.

Recherchez sur le net la table des codes ASCII puis en tenant compte voiture.pgm sous HxD
de la signification du code '0A', réécrivez l'en-tête du fichier.
Adresses Contenus Contenu
[hexadécimal] [hexadécimal] [en caractères ASCII]
.............................................................................................
00000000 50 35 0A 23 20 43 52 45 41 54 4F 52 3A 20 47 49 P5.# CREATOR: GI
............................................................................................. 00000010 4D 50 20 50 4E 4D 20 46 69 6C 74 65 72 20 56 65 MP PNM Filter Ve
............................................................................................. 00000020 72 73 69 6F 6E 20 31 2E 31 0A 31 36 20 31 36 0A rsion 1.1.16 16.
............................................................................................. 00000030 32 35 35 0A FF FF FF FF FF FF FF FF FF FF FF FF 255.ÿÿÿÿÿÿÿÿÿÿÿÿ
............................................................................................. 00000040 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ
00000050 FF FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 ÿÿÿÿÿÿÿÿÿÿ......
00000060 00 00 00 FF FF FF FF FF FF FF 00 FF FF 00 FF FF ...ÿÿÿÿÿÿÿ.ÿÿ.ÿÿ
Quelle est la taille en octets de - cet en-tête ? 00000070 FF FF 00 FF FF FF FF FF FF FF 00 FF FF 00 FF FF ÿÿ.ÿÿÿÿÿÿÿ.ÿÿ.ÿÿ
- de la matrice des pixels ? 00000080 FF FF 00 FF FF FF FF FF FF FF 00 FF FF 00 FF FF ÿÿ.ÿÿÿÿÿÿÿ.ÿÿ.ÿÿ
Sous Windows, déterminez la taille de ce fichier; Justifiez cette taille. 00000090 FF FF 00 FF FF FF FF FF FF FF 00 FF FF 00 FF FF ÿÿ.ÿÿÿÿÿÿÿ.ÿÿ.ÿÿ
000000A0 FF FF 00 FF FF 00 00 00 00 00 00 00 00 00 00 00 ÿÿ.ÿÿ...........
Exprimez cette taille en hexadécimal puis commentez l'adresse du dernier 000000B0 00 00 00 FF FF 00 FF FF FF FF FF FF FF FF FF FF ...ÿÿ.ÿÿÿÿÿÿÿÿÿÿ
pixel. 000000C0 FF FF 00 FF FF 00 FF FF FF FF FF FF FF FF FF FF ÿÿ.ÿÿ.ÿÿÿÿÿÿÿÿÿÿ
Niveau de gris Code 000000D0 FF FF 00 FF FF 00 FF FF FF FF FF FF FF FF FF FF ÿÿ.ÿÿ.ÿÿÿÿÿÿÿÿÿÿ
Le niveau de gris des pixels est codé en Blanc Noir 000000E0 FF FF 00 FF FF 00 00 00 00 00 00 00 00 00 00 00 ÿÿ.ÿÿ...........
hexadécimal. 100% 0% FF 000000F0 00 00 00 FF FF FF FF 00 00 00 FF FF FF FF FF 00 ...ÿÿÿÿ...ÿÿÿÿÿ.
0% 100% 00 00000100 00 00 FF FF FF FF FF FF 00 FF FF FF FF FF FF FF ..ÿÿÿÿÿÿ.ÿÿÿÿÿÿÿ
Complétez la table de correspondance 00000110 00 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF .ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ
ci-contre. 50% 50%
00000120 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ
75% 25% 00000130 FF FF FF FF ÿÿÿÿ

Permutation de pixels
( ou photomaton ) Commençons par la fin Visualisez l'image " lancelot.jpg" puis, avec IDLE de python, éditez
le fichiez "Permutation des pixels.py" et exécutez le puis observez
l'apparition progressive des fichiers "iteration1" , ... , "itération8". Visualisez-les.

Etude des permutations.

Principe Dans une image de taille (8x8), où se déplace le pixel de coordonnées:
Image de dimension L x H avec 'L' et 'H' paires; a) (1,1)  ( , ) d) (1,3)  ( , )
b) (1,2)  ( , ) e) (1,5)  ( , )
- Déplacement '' du pixel de coordonnées (i,j) c) (2,1)  ( , ) f) (1,j )  ( , ) avec 'j' impaire
(i,j)  ( (i,L) , (j,H) ) complétez la zone grisée de la figure 'Principe'
 x/2 si 'x' est paire
Sur la dernière étape de l'exemple , calculez les coordonnées
avec (x,T) =
a) du pixel rouge (zone grisée)
 T/2 + (x-1)/2 si 'x' est impaire b) de la prochaine position du pixel bleu.
Quelle serait la période si la taille de l'image était de
- Période est le ppcm(p,k) où 'k' et 'p' sont a) 10x16
p
les plus petits entiers / : L-1 divise 2 - 1 b) 256x256
k
L=8 & : H-1' divise 2 - 1
Etude du programme "Permutation des pixels.py".
5 Exemple Ln 3 PIL (Python Imaging Library) : bibliothèque de manipulation des images
3
7 Quel test est effectué sur la variable 'Largeur' ?
Détermination de la période 6 à 11 Justifiez la nécessité d'ajuster la dimension de l'image
NB. : H=L=8 => p=k=n 33 L'image initiale est scindée en fonction des couleurs en 3 images monochromes
(2,3) (5,3) 35 à 37 Extraction sous forme de liste des pixels de chacune des ces images monochromes.
n
n
1 2 3 13 à 26 Retrouvez dans le code de cette fonction, la définition du déplacement ''
(2,6) (5,6) 2 -1 1 3 17 Commentez cette ligne; Voir doc. sur python
1
7 7 7 42 à 52 Combien de fois ce bloc va-t-il être répété ? pourquoi tant de fois ?
(1,3) (6,3)
( , ) p=k=3 43;46;49 Les listes des pixels permutés écrasent les contenus des 3 images monochromes.
(1,5) Période = ppcm(3;3) = 3 51 Création d'une image polychrome à partir de la fusion des 3 images monochromes
52 Sauvegarde de cette image.
Permutation de pixels ( suite )
def CalculerPeriode(w,h):
Amélioration du programme. Modifiez le programme pour que l'utilisateur puisse choisir l'image à traiter.
Quelques pistes : - Choisir le fichier image => fonction 'askopenfilename' k = CalculerPK(h) }
p = CalculerPK(w) à développer

du module 'tkFileDialog' return ppcm(p,k)

de la bibliothèque tkInter
- Enlever l'extension de ce nom => méthode 'split' de python voir méthode d'Euler
- Déterminer la période des transformations => NbIterations = CalculerPeriode(w,h)

Permutation Permutez les couleurs de l'image 'rose.jpg'; Les valeurs des composantes du rouge deviendront les valeurs pour le vert;
des couleurs Celles du vert deviendront celles du bleu et celles du bleu deviendront celles du rouge.

Fondu A partir de deux images de même dimension et qui se partagent de préférence le même cadrage,
enchaîné réalisez en 10 étapes, un fondu enchaîné de l'une vers l'autre.

Matrice de si le pixel ai,j ki-1,j-1 ki-1,j ki-1,j+1 Sous GIMP, ouvrir l'image 'rose.jpg' Détection Accen- filtre Proposez une matrice
convolution n'est pas au ki,j-1 ki,j ki,j+1 puis dans le menu 'Filtre'  'Générique' des bords tuation de Sobel qui décale l'image d'un
bord de l'image, ki+1,j-1 ki+1,j ki+1,j+1  'Matrice de convolution'. 0 1 0 0 -0.5 0 -1 0 1 pixel vers la droite
Tester les matrices ci-contre. 1 -4 1 -0.5 3 -0.5 -2 0 2
ai-1,j-1 ai-1,j ai-1,j+1 (i+1,j+1)

ai,j-1 ai,j ai,j+1

ai+1,j-1 ai+1,j ai+1,j+1
ai,j(t+1) = a mn .k
(m,n)=(i-1,j-1)
mn
0 1 0 0 -0.5 0 -1 0 0

Stéganographie Ou cacher une information dans un support, par exemple des images Blablabla Message à
Le codage des pixels s'effectue généralement sur une échelle camoufler
allant de 0 à 255; c'est-à-dire sur 8 bits. ex.: 136  1 0 0 0 1 0 0 0 Codes ASCII
des caractères 42 6C 61 62 6C 61 62 6C 61
Les bits les plus à droite ont un faible impact sur l'image quasi
indécelable à l'oeil; Ils peuvent donc être utilisés pour dissimuler 0 1 0 0 0 0 1 0 0 1 1 0 1 1 0 0 0 1 1 ...
des informations. Cette technique, appelée tatouage est utilisée
notamment pour protéger des images par copyright.
... 10000100 1 0010010
Cette technique permet également
128 144
de cacher une image dans une autre. Image
... Codage
Un programme, permutant les quartets 1 0 0 0 1 0 1 0 1 0 0 1 1 0 1 1 ... dissimulant
pixels
( 4 bits ) de poids forts et de poids le message
faibles, permettra la visualisation 138 155
... Image
de l'une ou de l'autre image.
Pixels ...
Perte des 4 bits
... de poids faibles

Images fractales Les objets fractals sont des structures

-2 -1  0.5 zn -1+j
0.24+0.646j
invariantes par changement d'échelle zn , c  C 1 3

Ensemble de Ensemble des points 'c' pour lesquels zn+1 = zn 2 + c 2

Mandelbrot la suite 'zn' tend vers l'infini (ex |zn|>2 ). z0 = 0  1
0 NbItérations
durée 1 2 3 5 8
Editez le fichiez "Mandelbrot.py" et exécutez le.
de vie
Au bout de quelques secondes,apparaît une image fracale.
-1
Modifiez le programme pour que la zone affichée soit limitée par
les coins de coordonnées (-0.2,1.1) et (-0.1,1.0).
Proposez une interface graphique - choisir la zone à afficher ( filtrez la saisie - être renseigné sur le temps d'attente
qui permet à l'utilisateur de : pour rester dans les limites de l'images ) ( barre de progression et le temps restant).
- choisir la largeur de l'image - interrompre le programme.
Dernier triangle dessiné
Triangles de
Sierpinski Le tracé de cette figure s'appuie sur une triangle((0,0),(4,2),(0,4), 1 ):
fonction récursive ( qui s'appele elle-même). if(1>0):
triangle((0,0),(8,4),(0,8),2): DessinerTriangle((0,0),(4,2),(0,4))
triangle(A,B,C,n): if(2>0):
if(n>0): triangle((0,0),(2,1),(0,2), 0 )
DessinerTriangle((0,0),(8,4),(0,8))
DessinerTriangle(A,B,C) triangle((2,1),(4,2),(2,3), 0 )
triangle((0,0),(4,2),(0,4),1)
triangle(A,Milieu(A,B),Milieu(A,C),n-1) triangle((0,2),(2,3),(0,4), 0 )
triangle((4,2),(8,4),(4,6),1)
triangle(Milieu(A,B),B,Milieu(B,C),n-1)
triangle((0,4),(4,6),(0,8),1)
triangle(Milieu(A,C),Milieu(B,C),C,n-1) triangle((0,0),(2,1),(0,2), 0):
triangle((..,..),(..,..),(..,..),2): if(0>0):
if(2>0): Pas exécuté Pas de
1) Appliquez cet algorithme à l'exemple suivant DessinerTriangle((..,..),(..,..),(..,..)) => fin tracé
tout en complétant le tracé dans le repère triangle((8,4),(12,6),(8,8),1)
( en-bas à droite) .
triangle((..,..),(..,..),(..;..),..)
2) Editez puis lancez le fichier 'Sierpinski.py'. (16,8)
triangle((..,..),(..,..),(..,..),..)
triangle((0,0),(16,8),(0,16),3): triangle((..,..),(..,..),(..,..),..): 12
if(3>0): if(2>0):
DessinerTriangle((0,0),(16,8),(0,16)) DessinerTriangle((..,..),(..,..),(..,..)) 8
triangle((0,0),(8,4),(0,8),2) triangle((..,..),(..,..),(..,..),..)
triangle((..,..),(..,..),(..,..),2) triangle((..,..),(..,..),(..,..),..) 4
triangle((..,..),(..,..),(..,..),2) triangle((..,..),(..,..),(..,..),..)
(0,0) 4 8 12 (0,16)
Arbre fractal Le tracé de cet arbre se fait de manière récursive: import pygame
Il commence par le dessin d'un segment qui est défini from math import *
par son point de départ, sa longueur et son angle ( orientation ).
Tant que la profondeur n'est pas atteinte, à chaque pygame.init()
extrémité de segment démarrent deux nouveaux segments. window = pygame.display.set_mode((600, 600))
pygame.display.set_caption("Fractal Tree")
screen = pygame.display.get_surface()
1) Editez le fichier 'arbre fractal.py' puis complétez K= 10
les fonctions 'segment' et 'Arbre'. VariationAngleDroit = +15
VariationAngleGauche = -15
2) Modifiez le programme pour que l'arbre se penche, (Xfin,Yfin)
comme s'il était exposé au vent.

3) Utilisation de la fonction 'randrange' du module 'random'

pour introduire des aléas :
} def segment(Xdeb, Ydeb, Angle, Longueur):
"Trace le segment et renvoie les coordonnées de l'extémité."
Xfin =
Yfin =
a) dans les longueurs des segments Angle pygame.draw.line(screen, (255,255,255), (Xdeb,Ydeb), (Xfin, Yfin), 2)
b) dans les angles. x return
(Xdeb,Ydeb)
y def Arbre(Xinit, Yinit, Angle, Profondeur):
if Profondeur>0:
Longueur = Profondeur*K
Xterm,Yterm = segment(Xinit, Yinit, Angle, Longueur)
Arbre(
Arbre(

def input(event):
if event.type == pygame.QUIT:
exit(0)

Arbre(300, 550, -90, 5)

pygame.display.flip()

while True:
input(pygame.event.wait())s

Compression sans perte

L’entropie de Shannon Quantité d’information I(E) liée à l’apparition d'un événement E
de probabilité d’apparition p(E) : I(E) = -log2 [P(E)]

Etant donnée une source 'X' produisant des symboles 'x i' choisis dans un ensemble fini avec une probabilité respective p(xi),
quel est le nombre minimal de bits nécessaires pour transmettre l’information que c’est le symbole 'x i0' qui a été produite. n > H(X) = -  p(xi).log2 p(xi)
i
L’entropie d’une source discrète est donc la quantité moyenne d’information par symbole et est exprimée en bits par symbole.
Elle définit une borne inférieure sur le nombre moyen 'n' de bits nécessaires pour coder une source donnée.
Elle mesure l’incertitude dans la production d'unr source: l’entropie d’une source 'X' produisant 'N' symboles distincts est
- maximale, égale à log2N , si tous les symboles sont équiprobables
- minimale, égale à 0, si l’un des symboles est de probabilité 1 .
Supposons que l’on souhaite coder une image couleur ( 3x8 bits par pixel soit X = 224 valeurs distinctes) de 4 mégapixels (n = 4x2 20 pixels).
n n 20
Le nombre d'images possibles est N = X . L'entropie H(X ) de cette source est < log2 N = 24*4*2
20
Il est donc possible de coder ces images en moins de 24*4*2 bits en moyenne. Ceci suppose cependant de connaître la distribution de probabilités de la source
qui est inconnue. Il va donc falloir procéder sans connaître cette distribution.

Dictionnaire
Algorithme LZW (Lempel-Ziv-Welch) 24 caractères ASCII = 192 bits
T 'T' O TO 256
Chaine = Nul; TOBEORNOTTOBEORTOBEORNOT
O 'O' B OB 257
tant que (lecture d'un caractère Car ) faire 1 caractère Ascii => 8 bits
B 'B' E BE 258
si (Chaine + Car existe dans le dictionnaire) alors
E 'E' O EO 259
Chaine = Chaine + Car ;
O 'O' R OR 260
sinon
R 'R' N RN 261 16 codes de 9 bits => 144 bits
ajouter Chaine + Car au dictionnaire;
N 'N' O NO 262 T,O,B,E,O,R,N,O,T,256,258,260,265,259,261,263
écrire le code de Chaine;
O 'O' T OT 263
Chaine = Car ; 9 bits
T 'T' T TT 264
fin si
TO 256 B TOB 265
fin tant que 1) Sous python, proposez un programme de compression LZW sur 10bits
BE 258 O BEO 266
écrire le code de Chaine; 2) Utilisez votre programme pour compresser le fichier "Le Meunier,
OR 260 T ORT 267
NB: - Le symbole '+' représente la concaténation TOB 265 E TOBE 268 son Fils et l’Âne.txt"
- Le dictionnaire construit dynamiquement EO 259 R EOR 269 3) Déterminez le taux de compression obtenu.
d'après les motifs rencontrés. RN 261 O RNO 270 4) Rédigez un message de quelques lignes que vous compresserez et
[0;255] => codes Ascii OT 263 que vous donnerez à votre voisin pour qu'il le décompresse.