République Démocratique

du Congo
Ministère de l’Enseignement Supérieur et Universitaire
Université de Lubumbashi
Faculté Polytechnique

Département de Sciences de base

TRAVAIL PRATIQUE DE GÉNIE LOGICIEL

22/07/2024
Présenté par : KAMBWANDJ MUTOMB OBED
PROMOTION : BAC 1 POLYTECHNIQUE

ANNEE-ACADEMIQUE : 2023-2024

CHAP: 1 MISE EN BOUCHE

Application direct au cours
1. Écrire un programme, qui définit 3 variables : une variable de type texte, une variable de type
nombre entier, une variable de type nombre décimal et qui affiche leur type.
#!/usr/bin/python3
# -*- coding: UTF-8 -*-
chaine=”ceci est une chaîne”
entier=12
decimal=15.0
print (type(chaine))
print (type(entier))
print (type(decima))
2. Affecter dans une même ligne les 3 variables précédemmen définies

APPLICATION RÉFLÉCHIE

3. Écrire un programme qui affiche le type du résultat des instructions suivantes :

4.Écrire un programme, qui donne la mesure de l’angle α d’un triangle rectangle, dont on saisit le
côté opposé et l’hypothénuse.
Rappel : sinφ = CoteOppose/Hypotenuse

CHAP: 2 CONDITIONS - ITÉRATION - RÉPÉTITION

APPLICATION DIRECT AU COURS

1. Écrire un programme min_max.py, qui demande de saisir 2 valeurs et qui affiche la plus
petite des 2 valeurs.

2. Écrire un script longeur_chaine.py, qui demande de saisir 2 chaînes de caractères et qui affiche la
plus grande des 2 chaînes (celle qui a le plus de caractères).

3.Écrire le script convertir.py, qui effectue une conversion euros en dollars.

— Le programme commencera par demander à l’utilisateur d’indiquer par un caractère ’E’ ou
’$’
la devise du montant qu’il va entrer.
— Puis le programme exécutera une action conditionnelle de la forme :

APPLICATION AVANCÉ
4.Écrire un programme qui affiche un joli sapin de Noël, dont la taille est donnée par
l’utilisateur.Exemple pour une taille de 12 lignes :
CHAP:3 UTILISATION D’UN MODULE “ TURTLE”
1.Écrire un programme carre.py qui trace un carré.
2. Écrire un programme, qui trace un triangle équilatéral (3 angles à 60°).

3.Écrire un programme, qui trace un hexagone (polygone à 6 côtés, angles interne à 120°).
APPLICATION RÉFLÉCHIE
4.Écrire un programme, qui trace un carré, puis un triangle.
Modifier ensuite votre programme pour dessiner n figures consécutives adjacentes.
#!/usr/bin/python3
# -*- coding: utf-8 -*-
from turtle import *
def dessine_carre(tortue, taille):
for _ in range(4):
tortue.forward(taille)
 tortue.right(90)
def dessine_triangle(tortue, taille):
for _ in range(3):
tortue.forward(taille)
tortue.right(120)
# Configuration de la fenêtre Turtle
setup(800, 600)
wn = Screen()
wn.bgcolor(”lightblue”)
wn.title(”Carré et Triangle”)
# Création de la tortue
tortue = Turtle()
tortue.shape(”turtle”)
tortue.color(”green”)
# Tracer un carré
dessine_carre(tortue, 100)
# Se déplacer pour tracer le triangle sans superposition
tortue.penup()
tortue.forward(150)
tortue.pendown()
# Tracer un triangle
dessine_triangle(tortue, 100)
# Attendre que l’utilisateur appuie sur Entrée pour fermer la fenêtre
wn.exitonclick()

CHAP:4 LES LISTES

APPLICATION DIRECT AU COURS
1.Écrire un programme liste_animaux.py, qui initialise la liste et qui affiche l’ensemble des
éléments.
#!/usr/bin/python3
# -*- coding: utf-8 -*-
# Initialisation de la liste des animaux
liste_animaux = [”lapin”, “chat”, “chien”, “chiot”, “dragon”, “ornithorynque”]
# Affichage des éléments de la liste
for animal in liste_animaux:
print(animal)

2.Afficher la liste de manière inversée.

3.Afficher la liste de manière triée.
4.Ajouter (append) l’élément troll dans la liste, puis supprimer l’ensemble des animaux
domestiques.
Afficher le résultat. Afin de réaliser la suppression, on créera une liste des animaux
domestiques.

APPLICATION RÉFLÉCHIE
5.Écrire un programme liste_chaine.py, qui donne le nombre de caractères de chaque élément
de laliste.
Exemple : lapin possède 5 caractères.

CHAP:5 FONCTIONS
APPLICATION DIRECT AU COURS
1.tortue_carre.py : écrire une fonction dessine_carre, qui fait tracer un carré de 50 pixels de
côté à la tortue.

2. Modifier le programme précédent de la façon suivante :

(a) la tortue dessine un carré
(b) la tortue tourne de 5°
(c) la tortue avance de 5 pixels
(d) la tortue dessine un carré
Et ceci 72 fois.
Nommer le tortue_carre_tournant.py
3.Modifier le programme précédent de manière à faire des lunettes …
#!/usr/bin/python3
import turtle
def dessine_carre(tortue):
for i in range(4):
tortue.forward(50)
tortue.right(90)
def deplace(tortue):
tortue.left(5)

tortue.forward(5)
# Configuration de la fenêtre
turtle.setup(800, 600) # Taille du canevas
wn = turtle.Screen()
wn.bgcolor(”lightblue”) # Couleur de fond de la fenêtre
wn.title(”Python Turtle”)
# Configuration de la tortue ‘vador’
vador = turtle.Turtle()
vador.up()
vador.goto(-200, 0)
vador.color(”black”)
vador.shape(”turtle”)
vador.speed(5)
vador.down()
# Configuration de la tortue ‘yoda’
yoda = turtle.Turtle()
yoda.up()
yoda.goto(200, 0)
yoda.color(”blue”)
yoda.shape(”turtle”)
yoda.speed(10)
yoda.down()
# Dessiner les carrés et déplacer les tortues 72 fois
for i in range(72):
dessine_carre(vador)
deplace(vador)
dessine_carre(yoda)
deplace(yoda)
# Garder la fenêtre ouverte jusqu’à ce que l’utilisateur la ferme
wn.exitonclick()

4.pair_impair.py : écrire 2 fonctions :

— pair (nbre), qui renvoie True, si le nombre est Pair
— impair (nbre), qui renvoie True, si le nombre est Impair
Le nombres sera demandé à l’utilisateur. Le résultat attendu est : “La fonction Pair retourne
True pour la valeur 2”
5.mini_maxi.py : écrire 2 fonctions :

— mini (a,b) qui renvoie le minimum entre a et b

— maxi (a,b) qui renvoie le maximum entre a et b
Les 2 nombres a et b seront demandés à l’utilisateur.
CHAP:6 MODULE OS
APPLICATION DIRECT AU COURS
1.Écrire un programme lire_fichier.py, qui lit le fichier loremipsum.txt et l’affiche.
2. temperature.py : Créer un fichier avec un mot par ligne à partir de la liste suivante :
“chaud”,”froid”,”tempéré”,”glacial”,”brûlant”.
3.temperature_add.py : Ajouter à ce fichier les équivalents anglais :
”hot”,”cold”,”moderate”,”icy”,”ardent”

4.Lister le contenu du répertoire courant.

APPLICATION RÉFLÉCHIE
5.dico.py : Lire le fichier dico.txt et en ressortir les palindromes. Aide

Z mot = mot.replace(”\n”, “”) permet de supprimer le retour à la ligne d’une chaîne.

CHAP: 8 LES EXPRESSIONS RÉGULIÈRES
Application directe du cours

1.Un nombre est composés d’une suite de chiffres. Vérifier que la chaîne saisie est bien celle
d’un nombre.

2. Une adresse IPv4 est composée de 4 nombres entre 0 et 255 séparés par des .. Vérifier que
la chaîne saisie est bien celle d’une adresse IP (Merci à Eric Martin pour m’avoir signalé une
erreur).
3.Une adresse mail est composée de caractères alphanumériques suivis de @ suivis d’un . et
d’un nom de domaine. Vérifier que la chaîne saisie est bien celle d’une adresse mail.

APPLICATION RÉFLÉCHIE
4. Modifier le code suivant pour rechercher le contenu de texte compris entre
<Erreur></Erreur> dans
le fichier vandamne.txt en ne prenant pas en compte les espaces inutiles.
APPLICATION ANVANCÉ

5. Analyser le fichier script.txt pour n’isoler que les commandes (entre crochets). On
conservera les crochets à l’affichage.
Puis, dans un second temps, l’erreur pour chaque commande, c’est à dire le 3ème champs
séparé
d’un | si le second champs est erreur. On affichera uniquement les errreurs différentes des
autres.
(a) Écrire un programme qui lit le fichier
(b) Isoler les différentes syntaxes à analyser
(c) Créer l’expression régulière ou les expressions régulières succeptibles de répondre au
problème.
(d) Tester votre expression sur un échantillon de lignes
(e) Intégrer votre expression régulière dans la lecture du fichier

#!/usr/bin/python3
# -*- coding: utf-8 -*-
import re
# Lecture de l’ensemble du texte
with open(”script.txt”, “r”, encoding=”utf-8”) as f:
scr = f.readlines()
# (a) Écrire un programme qui lit le fichier
# (b) Isoler les différentes syntaxes à analyser
# (c) Créer l’expression régulière ou les expressions régulières susceptibles de répondre au problème.
# Expression régulière pour isoler les commandes entre crochets
patt_commandes = re.compile(r’(\[.*?\])’)
# Expression régulière pour isoler les erreurs
patt_erreurs = re.compile(r’\[.*?\]\s*\|\s*error\s*\|\s*(.*)’)

# Liste des commandes trouvées

commandes = []

# Liste des erreurs trouvées

lst_erreurs = []

# (d) Tester votre expression sur un échantillon de lignes et (e) Intégrer votre expression régulière dans
la lecture du fichier
for phrase in scr:
# Match pour les commandes entre crochets
result_commandes = patt_commandes.search(phrase)
if result_commandes:
commandes.append(result_commandes.group(1))
 # Match pour les erreurs
result_erreurs = patt_erreurs.search(phrase)
if result_erreurs:
lst_erreurs.append(result_erreurs.group(1).strip())
# Affichage des commandes trouvées
print(”\nCommandes trouvées entre crochets :”)
for commande in commandes:
print(”Commande : “ + commande)
# Affichage des erreurs uniques
print(”\nListe des erreurs uniques :”)
i=1
for erreur in sorted(set(lst_erreurs)):
print(str(i) + “: “ + erreur)
i += 1

CHAP: 9 LA RÉCURSIVITÉ
APPLICATION DIRECT

1. Écrire une programme qui calcule la factorielle de n.

En mathématiques, la factorielle d’un entier naturel n est le produit des nombres entiers
strictement
positifs inférieurs ou égaux à n. La factorielle est notée!. 1
Exemple : 6! = 6 ∗ 5 ∗ 4 ∗ 3 ∗ 2 ∗ 1
La factorielle est utilisée pour dénombrer le nombre de permutations possibles de n éléments.

2. Écrire une programme qui calcule les n premiers éléments de la suite de fibbonacci.

La suite de Fibonacci est une suite d’entiers dans laquelle chaque terme est la somme des
deux
termes qui le précèdent. Elle commence généralement par les termes 0 et 1 (parfois 1 et 1) et
ses
premiers termes sont : 0, 1, 1, 2, 3, 5, 8, 13, 21, etc.
APPLICATION RÉFLÉCHIE
3. Division Euclidienne.
Tant qu’il nous reste dans a une quantité suffisante pour prendre b, on retranche b de a, c’est-
à-dire
qu’on prend une fois de plus b de a et donc le quotient augmente d’une unité. Lorsqu’on ne
peut plus retrancher b de a (parceque a < b) alors le reste de la division euclidienne est a.

4. Flocon de von Koch.

Le flocon de von Koch s’obtient en partant d’un segment que l’on partage en 3, la partie du
milieu
est remplacée par un triangle équilatéral comme ceci :
— Écrire une fonction ligne qui construit cet élément.
— Écrire une fonction triangle qui construit cet élément (équilatéral).

— Remplacer les forward de la fonction triangle par un tracé de triangle comme défini précédemment,
vous devriez obtenir :
APPLICATION AVANCÉ
5. La courbe du dragon se construit ainsi :
— Si t = 0, l’ordinateur doit dessiner une ligne. C’est la base (ou l’initiateur). La longueur a
peu d’im-
portance. On définit la longueur une fois avec s.
— Sinon, si t > 0 : Dragon(t) = Dragon (t−1) ↱
Dragon (t −1). C’est la règle de récursivité (ou le gé-
nérateur). L’ordinateur doit dessiner une courbe de dragon avec profondeur de récursion t−1.
Cela
donne :
— Dessiner Dragon (t−1)
— Tourner à gauche (90°)
— Dessiner Dragon (t−1)
Il y a un petit problème : on ne peut pas dessiner Dragon(t−1) exactement de la même façon
les deux
fois. En effet, le premier Dragon (t−1) est dessiné vers l’extérieur en partant du milieu de
Dragon(t).
Ensuite on tourne de 90°. Le deuxième Dragon(t−1) est dessiné à l’inverse du milieu de
Dragon(t)
vers l’extérieur. Pour que les deux Dragon(t−1) soit représentée de la même façon,
ledeuxième Dra-
gon(t−1) doit être dessiné en miroir. Cela veut dire que tous les angles (a) sont en miroir et (b)
doivent être dessinés dans l’ordre inverse.
L’astuce consiste à donner un signe qui indique le sens (vz = 1 veut dire « + », vz = −1 veut
dire
« − »). On dessine d’abord un Dragon (t−1) avec signe positif (vz = 1). Ensuite on tourne de
90° et
dessinons un Dragon (t−1) avec signe négatif (vz = −1).
— Dessiner Dragon (t −1) signe (+)
— Tourner à gauche (vz·90°)
— Dessiner Dragon (t−1) signe (−)
Écrire le programme.
Cette solution est l’adaptation non optimisée de la solution proposée par l’auteur de cet
exercice.

#!/usr/bin/python3
# -*- coding: UTF-8 -*-
# Courbe du dragon avec instructions Logo

from turtle import *

from math import sin, cos, radians

# ------------------------ commandes logo --------------------------

# Définition d’une fonction ligne

# Trace une ligne partant du point (x1,y1) au point (x2,y2)
def ligne(x1, y1, x2, y2):
up()
goto(x1, y1)
down()
goto(x2, y2)

def fpos(x0, y0):

# place la tortue en (x0; y0)
global x, y
x = x0
y = y0

def fcap(angle0):
global angle
# oriente la tortue dans une direction (en degrés)
angle = angle0

def av(d):
# avance en dessinant
global x, y
x2 = x + d * cos(radians(angle))
y2 = y + d * sin(radians(angle))
ligne(x, y, x2, y2)
x = x2
y = y2

def tg(a):
# tourne à gauche de a degrés
global angle
angle -= a

# -------------------------------------------------------------------
def dragon(t, vz):
if t == 0:
av(15)
else:
dragon(t - 1, 1)
tg(vz * 90)
dragon(t - 1, -1)

def dessiner():
fpos(0, 0)
fcap(0)
dragon(10, 1)
done()

setup(800, 800)
dessiner()
input(”Presser entrée pour quitter”)