Introduction à la Programmation Python - UVT Master BADS

Ce laboratoire d’initiation à la programmation Python couvre plusieurs concepts fondamentaux : les dictionnaires et ensembles, la gestion des fichiers, la programmation orientée objet avec les classes, ainsi que la gestion des exceptions. Il s’adresse aux étudiants souhaitant acquérir des compétences pratiques en Python, avec des exemples concrets et des manipulations à réaliser au terminal ou dans un environnement de développement Python.

Objectifs

• Comprendre et manipuler les dictionnaires et ensembles en Python.
• Lire, écrire et gérer des fichiers texte, binaires et CSV.
• Créer et utiliser des classes, attributs, méthodes, constructeurs, destructeurs et héritage.
• Gérer les exceptions avec try-except, else, finally et créer ses propres classes d’exception.

Prérequis et installation

• Python installé (version compatible avec les modules standard comme pickle).
• Connaissances de base en programmation Python (variables, boucles, fonctions).
• Un éditeur de texte ou un environnement de développement Python (IDLE, VSCode, PyCharm, etc.).

Manipulation des dictionnaires et ensembles

Les dictionnaires sont des collections clé-valeur modifiables, où la clé est un type immuable (chaîne, nombre, tuple immuable). Un dictionnaire est itérable sur ses clés, mais sans ordre garanti.

Déclarez un dictionnaire vide et ajoutez des paires clé-valeur :

dico = {}
dico['computer'] = 'ordinateur'
dico['mouse'] = 'souris'
dico['keyboard'] = 'clavier'
print(dico)
print(dico['mouse'])  # affiche souris

Notez que les dictionnaires ne sont pas des séquences : les opérations comme la concaténation ou l’extraction d’éléments contigus ne sont pas possibles. Par exemple :

print(dico[1:3])  # provoque KeyError: slice(1, 3, None)

Pour supprimer une paire clé-valeur, utilisez :

del(dico['mouse'])

Pour mettre à jour ou ajouter des éléments :

dico.update(livre=70)
dico.update({'C++': 24})

Pour parcourir un dictionnaire, préférez la méthode items() :

for clef, valeur in dico.items():
    print(clef, valeur)

Les ensembles (sets)

Un set est une collection non ordonnée, sans index, sans doublons. Il existe deux types : set (modifiable) et frozenset (immuable).

Déclarez un set avec des accolades :

s = {"anas", "lamia", "amine", "aziz"}
print(s)  # ordre aléatoire

Ou en convertissant une liste :

s2 = set(["lamia", (1,2,3), 7.56])
print(s2)

Quelques méthodes utiles :

• set.add(element) : ajoute un élément.
• set.update(autre_set) : ajoute tous les éléments d’un autre set.
• set.remove(element) : supprime un élément, lève une exception si absent.
• set.discard(element) : supprime un élément sans lever d’exception si absent.

Exemple :

s = {"amine", "anas", "aziz"}
s.add("lamia")
print(s)

s = {"amine", "ahmed", "Mohamed"}
s2 = {1, 2, 3}
s.update(s2)
print("s =", s)
print("s2 =", s2)

s.remove("ahmed")
print(s)

Opérations mathématiques sur sets :

• Différence : s3 = s1 - s2
• Union : s3 = s1 | s2
• Intersection : s3 = s1 & s2

Exemple :

s1 = {"amine", "aziz", "anas", "ahmed"}
s2 = {"amine", "anas"}
s3 = s1 - s2
print("s3 =", s3)

s1 = {"Python", "php"}
s2 = {"java", "html", "php"}
s3 = s1 | s2
print("s3 =", s3)

s1 = {"Python", "php"}
s2 = {"java", "php"}
s3 = s1 & s2
print("s3 =", s3)

Les frozensets

Les frozensets sont des sets immuables, utilisables comme clés de dictionnaire.

Déclaration :

s = {1, 2, 3}
fr_s = frozenset(s)
print(type(fr_s))  # <class 'frozenset'>

Le constructeur frozenset() accepte aussi une liste ou un tuple.

Gestion des fichiers

Fichiers texte

Pour ouvrir un fichier, utilisez open() avec un mode :

• 'r' : lecture (par défaut)
• 'w' : écriture (efface le contenu)
• 'a' : ajout à la fin

Exemple d’ouverture :

file_n = open("utilisateur", 'r')

Pour écrire dans un fichier :

file_n.write(prenom + '\n')

Pour lire :

• read() : lit tout le contenu en une chaîne.
• readline() : lit une ligne, sans le caractère de fin de ligne.
• readlines() : lit toutes les lignes et retourne une liste.

Exemple lecture ligne par ligne :

file_n = open("utilisateur", 'r')
name = file_n.readline()
file_n.close()
print("Le contenu du fichier est: {} \n".format(name))

Exemple lecture et écriture avec modification :

file_n = open("utilisateur", 'r')
name = file_n.readlines()
file_n.close()

file_n = open("utilisateur", 'w')
for i in name:
    file_n.write(i.lower())
file_n.close()

Utilisation recommandée avec with :

with open("utilisateur", 'r') as file_n:
    name = file_n.readlines()

with open("utilisateur", 'w') as file_n:
    for i in name:
        file_n.write(i.upper())

Fichiers binaires

Les fichiers binaires sont lus octet par octet. Les modes d’ouverture sont :

• 'rb' : lecture binaire
• 'wb' : écriture binaire (efface contenu)
• 'ab' : ajout binaire

Sérialisation avec pickle

Le module pickle permet de sauvegarder et restaurer n’importe quel objet Python.

Pour sérialiser un objet :

import pickle

# création d'un dictionnaire
departement = {36:'info', 30:'GRH', 75:'compt'}

# enregistrement dans un fichier binaire
Fichier = open('data.txt', 'wb')
pickle.dump(departement, Fichier)
Fichier.close()

Pour désérialiser :

import pickle

Fichier = open('data.txt', 'rb')
Dept = pickle.load(Fichier)
Fichier.close()

print(Dept)       # affiche {36: 'info', 30: 'GRH', 75: 'compt'}
print(Dept[36])   # affiche info

Gestion des fichiers CSV

Le format CSV est un fichier texte tabulaire où les valeurs sont séparées par des points-virgules ou tabulations. La première ligne est l’en-tête.

On peut lire et écrire des CSV en utilisant les classes DictReader et DictWriter pour manipuler les données sous forme de dictionnaires.

Programmation orientée objet : les classes

Déclaration et instanciation

Une classe se déclare avec :

class NomClasse:
    pass  # corps vide

Instanciation :

obj = NomClasse()

Attributs et méthodes

Les attributs sont des variables associées à la classe. Les méthodes sont des fonctions avec un premier paramètre self représentant l’instance.

Exemple :

class Point:
    def deplace(self, dx, dy):
        self.x = self.x + dx
        self.y = self.y + dy

p = Point()
p.x = 1
p.y = 2
p.deplace(2, 2)
print("p : x =", p.x, "y =", p.y)

Constructeur et destructeur

Le constructeur __init__ initialise l’objet :

class Point:
    def __init__(self):
        self.x = 0
        self.y = 0

a = Point()
print("a : x =", a.x, "y =", a.y)
a.x = 1
a.y = 2
print("a : x =", a.x, "y =", a.y)

Exemple avec paramètres :

class Compte:
    """gestion d'un compte bancaire"""
    def __init__(self, nom, numero, valeur):
        self.nom = nom
        self.numero = numero
        self.solde = valeur

    def afficherSolde(self):
        print("Le solde vaut :", self.solde)

monCompte = Compte("pro", 777, 10000)
monCompte.afficherSolde()

Le destructeur __del__ est appelé automatiquement quand un objet n’est plus référencé :

class NomDeLaClasse:
    def __init__(self, para1, para2, ...):
        ...
    def __del__(self):
        ...

Attributs privés

Pour protéger un attribut, préfixez son nom par deux underscores __. Ces attributs ne sont pas accessibles directement depuis l’extérieur. Il faut créer des méthodes pour y accéder ou les modifier.

Exemple :

class Point:
    def __init__(self, x, y):
        self.__x = x
        self.__y = y

    def deplace(self, dx, dy):
        self.__x = self.__x + dx
        self.__y = self.__y + dy

    def affiche(self):
        print("abscisse =", self.__x, "ordonnee =", self.__y)

a = Point(2, 4)
a.affiche()
a.deplace(1, 3)
a.affiche()

Héritage

Une classe fille hérite d’une classe mère :

class ClasseMere:
    ...

class ClasseFille(ClasseMere):
    ...

Constructeur de la classe fille :

class ClasseFille(ClasseMere):
    def __init__(self, para1, para2, ...):
        ClasseMere.__init__(self, para1, ...)
        ...

Ou avec super() :

class ClasseFille(ClasseMere):
    def __init__(self, para1, para2, ...):
        super().__init__(para1, ...)
        ...

Héritage multiple

Une classe peut hériter de plusieurs classes mères :

class Mere1:
    ...

class Mere2:
    ...

class ClasseFille(Mere1, Mere2):
    ...

Exemple :

class Carnivore:
    def __init__(self, p):
        self._poidsViande = p
    def devorer(self):
        print("Je mange", self._poidsViande, "kilos de steack par jour")

class Herbivore:
    def __init__(self, p):
        self._poidsHerbe = p
    def brouter(self):
        print("Je mange", self._poidsHerbe, "kilos de gazon par jour")

class Omnivore(Carnivore, Herbivore):
    def __init__(self, pv, ph, h):
        Carnivore.__init__(self, pv)
        Herbivore.__init__(self, ph)
        self.__humain = h

teddy = Omnivore(10, 5, False)
teddy.devorer()
teddy.brouter()

Gestion des exceptions

Les exceptions permettent de gérer les erreurs potentielles dans le code.

Instruction try-except

Syntaxe :

try:
    # code pouvant générer une exception
except:
    # code exécuté si une exception survient

Si aucune exception, seul le bloc try est exécuté. Sinon, le bloc except est exécuté. Si l’exception n’est pas gérée, le programme s’arrête.

Clause else

Le bloc else s’exécute uniquement si aucune exception n’a été levée :

def division(a, b):
    try:
        d = a / b
    except ZeroDivisionError:
        print("Division par zero !")
    else:
        print("Résultat : ", d)

Clause finally

Le bloc finally s’exécute toujours, qu’une exception soit levée ou non.

Définir ses propres exceptions

Pour créer une exception personnalisée, créez une classe dérivée d’une classe d’exception existante :

class AucunChiffre(Exception):
    pass

def conversion(s):
    # conversion d'une chaîne en entier
    if not s.isdigit():
        raise AucunChiffre(s)
    return int(s)

try:
    s = "123a"
    print(s, " = ", conversion(s))
except AucunChiffre as exc:
    print(AucunChiffre.__doc__, " : ", exc)

Résultats attendus

• Manipulation correcte des dictionnaires et sets, avec affichage des éléments et opérations mathématiques sur sets.
• Lecture et écriture de fichiers texte avec modification des contenus (exemple passage en majuscules ou minuscules).
• Sérialisation et désérialisation d’objets Python avec pickle, vérification des données restaurées.
• Création et utilisation de classes avec attributs, méthodes, constructeurs, et gestion des attributs privés.
• Utilisation de l’héritage simple et multiple avec appels corrects aux constructeurs.
• Gestion des exceptions avec try-except, else, finally, et levée d’exceptions personnalisées.

Pièges courants

• Confondre les dictionnaires avec des séquences : les opérations de slicing ne fonctionnent pas.
• Oublier de fermer un fichier après ouverture, ou ne pas utiliser with open() pour une gestion sûre.
• Utiliser set.remove() sans vérifier que l’élément existe, ce qui lève une exception.
• Ne pas initialiser les attributs dans le constructeur, ce qui peut causer des erreurs d’attribut manquant.
• Accéder directement à des attributs privés (préfixés par __) depuis l’extérieur de la classe.
• Oublier d’appeler le constructeur de la classe mère dans une classe fille héritée.
• Ne pas gérer les exceptions spécifiques dans un bloc except, ce qui peut masquer des erreurs.
• Ne pas lever ou attraper correctement ses propres exceptions personnalisées.