Informatique 1re année Pharmacie

Bloc	Contenu	Supports du cours
1. e-Santé	e-Health, DMI/DMP, interopérabilité, cybersécurité, cloud, Big Data, IA, blockchain, télémédecine	Cours 1 (Pr. El Handri), « Suite info »
2. Bases Python	print/input, variables, types, opérateurs, conditions, boucles, fonctions, try/except, regex	python part 1, Python.pdf, Python Programming, CODE PYTHON, TP0, TP1
3. Collections	str, list, tuple, set, dict, fichiers	python part 1, Notions (set/try/regex)
4. POO	classe, objet, __init__, self, héritage, polymorphisme, encapsulation	Programmation Orientée Objet, td poo, exercices Étudiants/Employés
5. NumPy & matrices	ndarray, slicing, linalg (det, inv, solve, rang), mineurs/cofacteurs	BIBLIOTHÈQUE NUMPY, TD numpy, TP2-TP3, TD matrices 1-4, TD 6
6. Pandas & EDA	Series/DataFrame, loc/iloc, filtres, groupby, NaN, merge, cut	partie pandas, TD Titanic, mini-projet Netflix, TP people.tsv

Bloc 1 · Cours théorique

Informatique appliquée à la santé et à la pharmacie

Ce bloc tombe surtout en QCM et en questions de définition. Ce qu'il faut retenir : les définitions (e-Health, m-Health, DMP…), les normes d'interopérabilité, le cadre légal, le modèle NIST du cloud et les 3V du Big Data.

Définitions

Les « informatiques » de santé

e-Health (e-Santé) : utilisation des technologies de l'information et de la communication (TIC) au service de la santé.
m-Health : la partie mobile de l'e-Santé (smartphones, applis, objets connectés).
Health Informatics : science de la gestion des données de santé (collecte, stockage, analyse, partage).
Pharmacy Informatics : son application au circuit du médicament (prescription → dispensation → suivi).

Exemples concrets

Ce que ça change à l'officine et à l'hôpital

e-prescription : ordonnance transmise électroniquement, signée, traçable, sans erreur de lecture.
CDSS (Clinical Decision Support System) : alertes d'interactions, de surdosage, aide au diagnostic (ex. IBM Watson).
LGP (logiciel de gestion de pharmacie) : stocks en temps réel, péremptions, facturation, tiers payant.
Robots de dispensation (ex. CHU Ibn Sina, 2022) et automates de préparation des doses.

Numériser, digitaliser, transformer

Numérisation

Passer un support papier → fichier (scanner une ordonnance). Le processus ne change pas.

→

Digitalisation

Utiliser le numérique pour refaire un processus (l'ordonnance est créée, envoyée et lue électroniquement).

La transformation digitale va plus loin : elle change l'organisation entière (nouveaux métiers, décisions guidées par les données, télé-pharmacie). Le cours parle aussi des « ères » 1.0 → 4.0 : informatisation administrative → dossiers numériques → connectivité/Internet → IA, IoT, Big Data.

Les dossiers du patient

Sigle	Signification	À retenir
DMI / DPI	Dossier Médical (Patient) Informatisé	Dossier tenu par un établissement (hôpital, clinique)
DMP	Dossier Médical Partagé	Dossier partagé entre professionnels et établissements, suit le patient
DPU	Dossier Patient Unique	Un seul dossier par patient au sein d'un réseau de soins
DP	Dossier Pharmaceutique	Historique des médicaments délivrés (en France : 4 mois) consulté à chaque dispensation → interactions, doublons, abus
PACS	Picture Archiving and Communication System	Archivage et transmission des images médicales (radio, scanner, IRM, écho)
SIH	Système d'Information Hospitalier	L'ensemble des logiciels de l'hôpital (admissions, DPI, pharmacie, labo…)

Masque les réponses ; clique sur une case pour la révéler.

Interopérabilité : parler la même langue

Deux logiciels de santé ne peuvent échanger des données que s'ils partagent un format (comment on transporte) et une terminologie (comment on nomme).

Norme	Type	Sert à…
HL7	Messagerie / format d'échange	Échanger des messages entre logiciels hospitaliers (admission, résultats…)
FHIR	Standard HL7 moderne (web, API)	Échanger des « ressources » (Patient, Medication…) via Internet, format JSON/XML
SNOMED CT	Terminologie clinique	Coder les diagnostics, symptômes, actes de façon universelle
LOINC	Terminologie biologique	Coder les analyses de laboratoire et observations

Maroc et international

Maroc

Projet de DMP national, hôpital Cheikh Khalifa (dossier informatisé), téléconsultation Tbib24, robotisation de la pharmacie du CHU Ibn Sina (2022).

France

SNDS (Système National des Données de Santé), Health Data Hub, DMP et Dossier Pharmaceutique.

Monde

EHR (Electronic Health Record) aux USA, plateformes cloud (AWS, Google Cloud, IBM Watson Health).

Cybersécurité et cadre légal

Lois

Loi 09-08 (Maroc) : protection des personnes physiques à l'égard du traitement des données à caractère personnel (contrôle : CNDP).
RGPD / GDPR (Union européenne).
HIPAA (États-Unis) : confidentialité des données de santé.

Menaces

Ransomware : chiffre les données et exige une rançon (CHU de Rouen, 2019).
Phishing : faux mail/site pour voler des identifiants.
Fuite de données : attaque de la CNSS (avril 2025).
Panne logicielle : mise à jour CrowdStrike (juillet 2024), hôpitaux paralysés dans le monde.

Cloud computing : le modèle NIST

Le cloud, c'est utiliser des ressources informatiques (stockage, calcul, logiciels) à distance, à la demande, comme on consomme l'électricité du réseau au lieu d'avoir son propre générateur (analogie du cours). Le cloud commercial naît avec Amazon Web Services en 2006.

Le NIST définit…	Contenu
5 caractéristiques	Libre-service à la demande · accès réseau large · mutualisation des ressources · élasticité rapide · service mesuré (on paie ce qu'on consomme)
3 modèles de service	IaaS (infrastructure : serveurs, stockage) · PaaS (plateforme pour développer) · SaaS (logiciel prêt à l'emploi, ex. Gmail, un LGP en ligne)
4 modèles de déploiement	Public · privé · communautaire · hybride

Big Data

Les 3V

Volume (quantité énorme), Variété (textes, images, signaux, génome), Vélocité (flux en temps réel). Le cloud fournit l'infrastructure ; le Big Data, c'est l'analyse de ces masses de données (épidémiologie, pharmacovigilance, données de vie réelle).

IoT

Objets connectés

Glucomètres en continu, tensiomètres, oxymètres, montres → télésurveillance à domicile, alertes précoces, moins d'hospitalisations.

Intelligence artificielle

Systèmes qui apprennent à partir de données pour reconnaître, prédire ou décider. En santé : lecture d'images par réseaux de neurones convolutifs (CNN), dépistage du cancer du sein (ex. BreastAI), rétinopathie diabétique, prévision des stocks.

Blockchain

Registre infalsifiable

Registre décentralisé et immuable : traçabilité du médicament (lutte contre la contrefaçon), consentement, essais cliniques.

Télémédecine

Téléconsultation : patient ↔ médecin à distance.
Téléexpertise : un professionnel demande l'avis d'un autre.
Télésurveillance : suivi à distance des données du patient.

Éthique

Confidentialité et consentement.
Biais des algorithmes (données non représentatives).
Validation humaine : l'IA aide, le professionnel décide et reste responsable.

Mémo : HL7 transporte, SNOMED nomme, LOINC mesure. NIST = 5-3-4 (caractéristiques, services, déploiements). Big Data = 3V.

Bloc 2 · Programmation

Les bases de Python

Compilé

Tout le code est traduit en langage machine avant l'exécution → fichier exécutable, très rapide (C, C++, Rust, Go).

Interprété

Le code est lu et exécuté au fur et à mesure par un interpréteur → souple, facile à tester (Python, JavaScript).

Python est en fait hybride : le code est d'abord compilé en bytecode (.pyc), puis ce bytecode est interprété par la machine virtuelle Python (PVM). Environnements vus en TP : Anaconda + Spyder (TP0) et Google Colab (notebook en ligne).

print() et input()

print(v1, v2, sep=" ", end="\n") affiche ; input("message") lit une saisie et renvoie toujours une chaîne (str). Pour calculer, on convertit : int() ou float(). Ici, les valeurs tapées au clavier se mettent dans la zone jaune Entrées, une par ligne.

Variables et types

Pas de déclaration : la variable est créée à la première affectation et son type est déduit de la valeur (typage dynamique). Un nom commence par une lettre ou _, ne contient que lettres, chiffres et _, et distingue majuscules et minuscules.

Type	Exemple	Description
`str`	`"Amoxicilline"`	Texte, non modifiable (immuable)
`int`	`500`	Entier positif ou négatif
`float`	`12.5`	Nombre décimal (à virgule flottante)
`complex`	`2 + 3j`	Nombre complexe
`bool`	`True`	Vrai / Faux, résultat d'une comparaison
`list`	`[1, 2, 2]`	Ordonnée, modifiable, doublons permis
`tuple`	`(1, 2)`	Ordonné, non modifiable
`range`	`range(2, 10, 2)`	Suite d'entiers générée à la demande (fin exclue)
`set`	`{1, 2}`	Non ordonné, sans doublons, pas d'index
`dict`	`{"nom": "Ali"}`	Paires clé → valeur, modifiable, clés uniques
`frozenset`	`frozenset([1, 2])`	Set non modifiable
`bytes / bytearray / memoryview`	`bytearray([65, 66])`	Octets (0-255) ; bytearray modifiable ; memoryview = vue sans copie

⚠ Erreurs dans les supports

CODE PYTHON.docx écrit « float : nombres entiers » → faux : float = nombres décimaux.
Même fichier : « tuple : liste (modifiable) » → faux : un tuple est immuable (c'est sa différence avec la liste).
Python.pdf (notes) : « une variable locale déclarée dans un bloc n'existe que dans ce bloc ». En Python, seules les fonctions (et classes/modules) créent une portée : une variable créée dans un if ou une boucle for reste accessible après.

Opérateurs

Opérateur	Exemple	Résultat
`/` division	`10 / 2`	`5.0` (toujours un float)
`//` division entière	`10 // 3`	`3`
`%` modulo (reste)	`10 % 3`	`1`
`**` puissance	`2 ** 3`	`8`
`+=` affectation	`x = 5; x += 2`	`7`
`==` / `!=`	`3 == 3.0`	`True`
`and / or / not`	`not (5 > 2 and 1 > 3)`	`True`
`in` appartenance	`"para" in "paracétamol"`	`True`
`is` identité	`[1] is [1]`	`False` (deux objets distincts, même si `==`)
`& \| ^` bit à bit	`6 & 3`	`2` (110 ET 011 = 010)

Conditions : if / elif / else

Le bloc est défini par l'indentation (4 espaces) après les deux-points. Python teste les conditions dans l'ordre et s'arrête à la première vraie.

Astuce : tester d'abord le cas invalide évite d'écrire 16 <= note <= 20 partout. Change la valeur dans « Entrées » (25, 9.5, 12…) et relance.

Boucles

for

Parcourt une séquence (liste, chaîne, range, dict…). range(2, 30, 3) → 2, 5, 8… (30 exclu).

while

Répète tant que la condition est vraie. Penser à faire évoluer la variable, sinon boucle infinie (bouton ■ Stop).

break / continue

break sort de la boucle ; continue passe directement au tour suivant.

else de boucle

Exécuté quand la boucle se termine normalement (pas exécuté si on sort par break).

Fonctions

def nom(paramètres): définit un bloc réutilisable ; return renvoie un résultat (sans return, la fonction renvoie None). Paramètres par défaut, arguments nommés, et lambda pour une petite fonction anonyme d'une ligne.

Erreurs : try / except

Expressions régulières (module re)

re.split(motif, texte) découpe ; re.sub(motif, remplacement, texte) remplace ; re.findall extrait tout ce qui correspond. Motifs utiles : \d chiffre, \d+ un ou plusieurs chiffres, \s espace, [,;] l'un des caractères.

Bloc 3 · Structures de données

Chaînes, listes, tuples, ensembles, dictionnaires

	list `[ ]`	tuple `( )`	set `{ }`	dict `{k: v}`
Ordonné / index	Oui, `l[0]`	Oui, `t[0]`	Non, pas d'index	Accès par clé `d["k"]` ; ordre d'insertion conservé
Modifiable	Oui	Non	On ajoute/retire, on ne modifie pas un élément	Oui
Doublons	Permis	Permis	Interdits (supprimés)	Clés uniques
Ajouter	`append, insert, extend`	Impossible (passer par `list()`)	`add, update`	`d["new"] = v`, `update`
Retirer	`remove(val), pop(i), del l[i]`	`del t` (tout le tuple)	`remove` (erreur si absent), `discard` (pas d'erreur), `pop`	`pop(k), del d[k], clear()`

⚠ À corriger dans « python part 1 » et CODE PYTHON

« set.pop() supprime le dernier élément » → un set n'a pas d'ordre : pop() retire un élément arbitraire.
« Un dictionnaire est une collection non ordonnée » → c'est vrai seulement avant Python 3.7 ; aujourd'hui, un dict conserve l'ordre d'insertion (mais on y accède toujours par clé, pas par position).
« You can convert the tuple into a list : tuple(list) » → c'est list(mon_tuple) qui convertit en liste ; tuple(...) fait l'inverse.
Fiche Notions : les exemples ont perdu leur indentation (le code ne tournerait pas) et re est utilisé sans import re.

Fichiers texte

with open("notes.txt", "r") as f: ouvre et ferme automatiquement le fichier. Modes : "r" lire, "w" écrire (écrase), "a" ajouter. Un fichier notes.txt d'exemple existe dans le dossier de travail de ce site.

Bloc 4 · Programmation orientée objet

Classes et objets

Au lieu de disperser des variables et des fonctions, la POO regroupe dans une même classe l'état (attributs) et le comportement (méthodes) d'un concept : un compte, un patient, un médicament.

Classe

Le plan, le moule : un nouveau type. Nom en PascalCase : class Medicament:

→

Objet (instance)

Un exemplaire concret, avec sa propre identité et son propre état : m = Medicament("Doliprane", 1000)

Instanciation : Python réserve la mémoire, lie l'objet à sa classe, appelle __init__, puis renvoie la référence.

__init__ (constructeur) initialise les attributs. Un objet ne doit jamais naître dans un état invalide → on valide dans __init__.

self = l'objet courant. m.afficher() équivaut à Medicament.afficher(m).

__str__ définit ce qu'affiche print(objet) (sinon <__main__.X object at 0x…>).

Héritage, redéfinition, polymorphisme

Héritage

class Enfant(Parent): récupère attributs et méthodes. Dans __init__, appeler super().__init__(...).

Redéfinition

(override) La classe fille réécrit une méthode du parent, sous le même nom.

Polymorphisme

Un même appel (e.calculer_salaire()) donne un comportement différent selon le type réel de l'objet. Le duck typing permet même cela sans héritage.

Encapsulation

Écriture	Convention	Accès depuis l'extérieur
`self.nom`	public	libre
`self._nom`	protégé (convention)	possible, mais « ne pas toucher »
`self.__nom`	privé	name mangling : renommé `_Classe__nom` → `obj.__nom` lève une AttributeError

On contrôle l'accès par des getters/setters, en Python de préférence avec @property (lecture) et @x.setter (écriture validée).

class Etudiant:
    def __init__(self, sid, nom, email):
        self.__id, self.__nom, self.__email = sid, nom, email
        self.__notes = []
    @property
    def student_id(self): return self.__id
    @property
    def nom(self): return self.__nom
    @property
    def notes(self): return list(self.__notes)      # copie : protège la liste
    def ajouter_note(self, note):
        if not 0 <= note <= 20:
            raise ValueError("note hors de [0, 20]")
        self.__notes.append(note)
    def calculer_moyenne(self):
        return sum(self.__notes) / len(self.__notes) if self.__notes else 0
    def afficher_infos(self):
        return f"{self.student_id} | {self.nom} | {self.calculer_moyenne():.2f}"

class EtudiantTempsNormal(Etudiant):
    pass                                             # même calcul que la mère

class EtudiantTempsAmenage(Etudiant):
    def __init__(self, sid, nom, email, bonus):
        super().__init__(sid, nom, email)
        self.__bonus = bonus
    def calculer_moyenne(self):                      # redéfinition
        return min(20, super().calculer_moyenne() + self.__bonus)

class Cours:
    def __init__(self, cid, nom):
        self.__id, self.__nom, self.__inscrits = cid, nom, []
    def rechercher_etudiant(self, sid):
        for e in self.__inscrits:
            if e.student_id == sid:
                return e
        return None
    def inscrire_etudiant(self, e):
        if self.rechercher_etudiant(e.student_id):
            print("Erreur : ID déjà inscrit →", e.student_id); return
        self.__inscrits.append(e)
    def calculer_moyenne_generale(self):
        m = [e.calculer_moyenne() for e in self.__inscrits]   # polymorphisme
        return sum(m) / len(m) if m else 0
    def afficher_inscrits(self):
        for e in self.__inscrits:
            print(e.afficher_infos())
        print(f"Moyenne générale : {self.calculer_moyenne_generale():.2f}")

a = EtudiantTempsNormal("E1", "Lina", "lina@um5.ac.ma"); a.ajouter_note(12); a.ajouter_note(15)
b = EtudiantTempsAmenage("E2", "Omar", "omar@um5.ac.ma", 2); b.ajouter_note(18); b.ajouter_note(19)
c = Cours("INF1", "Informatique")
c.inscrire_etudiant(a); c.inscrire_etudiant(b); c.inscrire_etudiant(a)
c.afficher_inscrits()
try:
    print(a.__notes)
except AttributeError as e:
    print("AttributeError :", e)

Les 3 relations à reconnaître : héritage « est un » (un EtudiantTempsAmenage est un Etudiant) · agrégation « contient » (un Cours contient des Etudiants qui existent sans lui) · association « utilise » (une Réservation relie un Client et une Chambre).

Bloc 5 · Calcul numérique

NumPy et les matrices

NumPy (Numerical Python) fournit l'objet ndarray : un tableau à N dimensions, de type homogène, beaucoup plus rapide qu'une liste, avec les opérations élément par élément et l'algèbre linéaire (np.linalg). On l'importe par convention avec import numpy as np.

Tableau	`.ndim`	`.shape`	Lecture
`np.array(46)`	0	`()`	Scalaire : pas de ligne ni de colonne
`np.array([1,2,3])`	1	`(3,)`	Vecteur de 3 éléments
`np.array([[1,2,3],[4,5,6]])`	2	`(2, 3)`	Matrice 2 lignes × 3 colonnes (toujours lignes, colonnes)
2 matrices 2×3 empilées	3	`(2, 2, 3)`	2 matrices de 2 lignes et 3 colonnes

Fonction	Rôle
`np.linalg.det(A)`	Déterminant (renvoie un float : 9.999999 au lieu de 10 → arrondir)
`np.linalg.inv(A)`	Inverse (LinAlgError si det = 0 : matrice singulière)
`np.linalg.solve(A, Y)`	Résout le système AX = Y (plus précis que inv(A) @ Y)
`np.linalg.matrix_rank(A)`	Rang = nombre de lignes (ou colonnes) linéairement indépendantes
`np.linalg.eig(A)` / `eigvals`	Valeurs (et vecteurs) propres
`np.linalg.norm(v)`	Norme (longueur) d'un vecteur ou d'une matrice
`np.delete(A, i, axis=0)`	Supprime la ligne i (axis=1 : la colonne) → sert à calculer les mineurs

Mineur, cofacteur, comatrice, inverse

Mineur M(i,j) = det de A privée de la ligne i et de la colonne j Cofacteur C(i,j) = (-1)^(i+j) × M(i,j) signes : + − + det(A) = Σ_j a(1,j) × C(1,j) (développement) − + − A⁻¹ = (1 / det A) × (comatrice)ᵀ + − +

Calculateur 3×3 : développement selon la 1re ligne

⚠ Pièges dans les supports NumPy

TD « Le module numpy » : np.concatanate(A, B) → orthographe et syntaxe correctes : np.concatenate((A, B)) (un seul argument : un tuple de tableaux).
td numpy, ex. 3 : « calculez l'inverse de [[1,2,3],[4,5,6],[7,8,9]] » → impossible : son déterminant vaut 0 (ligne 3 = 2×ligne 2 − ligne 1). NumPy lève LinAlgError: Singular matrix. La question « A = DU » n'a pas de solution générale ; la décomposition classique est A = LU (L triangulaire inférieure, U supérieure).
TP2/TP3 : « mineur A30 » n'a de sens qu'avec des indices Python (à partir de 0) ; en notation mathématique les indices commencent à 1. Précise toujours la convention.

Bloc 6 · Données tabulaires

Pandas et l'analyse exploratoire (EDA)

Series

Une colonne : valeurs + index. pd.Series([12, 15], index=["Ali", "Sara"])

⊂

DataFrame

Un tableau de plusieurs Series partageant le même index. Se crée depuis un dict ou un fichier : pd.read_csv()

Le fichier titanic.csv (891 passagers, Kaggle) est disponible ici. Ses colonnes commencent par une majuscule (Survived, Pclass, Sex, Age…) ; le TD les écrit en minuscules, donc on les renomme dès le chargement.

Écriture	Sélectionne…
`df["age"]`	Une colonne (Series)
`df[["name", "age"]]`	Plusieurs colonnes (DataFrame) : double crochet
`df.loc[5, "name"]`	Par étiquette (index 5, colonne name) ; borne de fin incluse dans `loc[0:3]`
`df.iloc[5, 3]`	Par position (6e ligne, 4e colonne) ; fin exclue dans `iloc[0:3]`
`df[(df.sex == "female") & (df.age < 18)]`	Filtre booléen : `&` (et), `\|` (ou), `~` (non), parenthèses obligatoires
`df.loc[df.age > 60, ["name", "pclass"]]`	Filtre + choix de colonnes en une seule fois

Nettoyage

isnull()/isna() détecte les NaN
dropna() supprime, fillna(v) remplace
drop_duplicates(), astype("category")
rename(columns={...}), replace()

Transformer

map() sur une Series (dict ou fonction)
apply() ligne par ligne ou colonne par colonne
.str.split / .str.strip / .str.extract
pd.to_datetime(), .dt.year

Combiner

pd.concat([a, b]) empile
pd.merge(a, b, on="cle", how="left") joint comme en SQL
a.join(b) joint sur l'index

Remodeler

groupby().agg(), pivot_table()
unstack(), set_index([...]) (MultiIndex)
explode() une ligne par élément d'une liste

⚠ Coquilles du cours « partie pandas »

pd.isull() → c'est pd.isnull() (ou pd.isna()).
applymap() est dépréciée depuis pandas 2.1 : on écrit maintenant df.map(fonction) pour appliquer une fonction à chaque case.

Entraînement

TD et TP corrigés

Essaie d'abord seul : vide le bloc, écris ta version, exécute. La correction proposée n'est qu'une solution possible.

TP0 · Calculs simples (vitesse d'élimination, stock, moyenne pondérée) TP0

TP1 · Exercices 3, 4 et 6 (âge, nombre magique, menu) TP1

TP2 / TP3 · Manipuler une matrice NumPy TP2-3

import numpy as np
A = np.array([[5, 3, 1, 6], [0, -2, 4, 0], [7, 6, 8, -7]])
print(A, "\ndimension :", A.shape, "| lignes :", A.shape[0], "| colonnes :", A.shape[1])
for i, ligne in enumerate(A):   print("ligne", i, ":", ligne)
for j in range(A.shape[1]):     print("colonne", j, ":", A[:, j])
print("1re ligne, 2e colonne :", A[0, 1], "| 2e ligne, 3e colonne :", A[1, 2])
A[A == -2] = 9
print(A)
print(np.where(A > 5, "Grand", "Petit"))

M = np.arange(1, 17).reshape(4, 4)
print(M.T, "\nsymétrique ?", np.array_equal(M, M.T))
X, Y = np.array([[1, 2], [3, 4]]), np.array([[0, 1], [1, 0]])
print(X + Y)
P, Q = np.array([[1, 2, 3], [4, 5, 6]]), np.array([[1, 0], [0, 1], [2, 2]])
print("A(2x3) @ B(3x2) =\n", P @ Q)

def mineur(m, i, j): return round(np.linalg.det(np.delete(np.delete(m, i, 0), j, 1)), 6)
def cofacteur(m, i, j): return (-1) ** (i + j) * mineur(m, i, j)
B = np.array([[2, 1, 3, 4], [1, 0, 2, 1], [4, 2, 1, 3], [3, 1, 0, 2]])
print("Mineur A12 (on retire la 1re ligne et la 2e colonne) :", mineur(B, 0, 1))
print("Indices Python : C22 =", cofacteur(B, 2, 2), "C31 =", cofacteur(B, 3, 1), "C30 =", cofacteur(B, 3, 0))

TD 1 matrices · somme, produit, transposée, rang TD1

Ex. 1 : A (1×3) et B (3×3) → A + B impossible (tailles différentes) ; AB possible (1×3)·(3×3) → 1×3. Règle : la somme exige la même taille ; le produit A(m×n)·B(n×p) exige colonnes de A = lignes de B.

Ex. 2 : Xᵀ (2×3) : chaque ligne = une enzyme, chaque colonne = un patient.

Ex. 3 : XᵀX (3×3) = sommes des produits entre biomarqueurs (diagonale = Σ des carrés) → co-variation des biomarqueurs. XXᵀ (4×4) = similarité entre patients : les patients 1, 2 et 4 ont exactement le même profil (14 partout).

Ex. 4-7 : rang(M) = 2 (ligne 2 = 2×ligne 1 : biomarqueur redondant) ; rang(A) = 1 (mesure répétée, pas d'information nouvelle) ; rang(B) = 2 (L3 = L1 + 2×L2) puis 3 avec la ligne (6, 8, 9) ; rang(C) = 1 (toutes les lignes sont proportionnelles : colonnes dépendantes).

TD 2 · Trace, matrices symétriques / antisymétriques TD2

Ex. 1 : Tr(C) = 2 + 3 = 5 ; C² = [[4, 5], [0, 9]] → Tr(C²) = 13 ; Tr(AB) = Tr(BA) = 1.

Ex. 2 : Sᵀ = S ✔ ; Aᵀ = −A ✔ (diagonale nulle). S + A et S − A ne sont ni symétriques ni antisymétriques (et (S+A)ᵀ = S − A).

Ex. 3 : (M + Mᵀ)/2 est symétrique car sa transposée donne (Mᵀ + M)/2 ; (M − Mᵀ)/2 est antisymétrique. Pour M = [[1, 3], [−1, 4]] : S = [[1, 1], [1, 4]], A = [[0, 2], [−2, 0]].

Ex. 4 : AAᵀ = [[21, 2], [2, 34]] (2×2) ; AᵀA = [[1, 4, −2], [4, 25, 7], [−2, 7, 29]] (3×3) — les deux sont symétriques.

TD 3 · Déterminants, mineurs, cofacteurs TD3

Exercice	Résultat	À retenir
1	det B = 1×4 − 2×3 = −2 ; après échange des lignes : +2	Échanger deux lignes change le signe
2	det = 0	L3 − L2 = L2 − L1 : lignes liées → matrice non inversible
3	det [[3, 1], [2, 4]] = 10	\|det\| = aire du parallélogramme construit sur u et v
4	det M = −4	\|det\| = 4 = volume du parallélépipède ; ≠ 0 → vecteurs indépendants
5	det B = 1 → ×3 ligne : 3 ; échange : −1 ; L3 + 2L1 : 1	Multiplier une ligne par k multiplie det par k ; ajouter un multiple d'une ligne ne change rien
6-8	M₁₁ = 13, M₂₃ = 10, M₃₂ = −8 ; C₁₁ = 13, C₂₃ = −10, C₃₂ = 8	Cofacteurs : [[13, −12, 20], [−4, 6, −10], [−7, 8, −10]], det A = 10
9	Cofacteurs de C : [[8, −1, −6], [4, 8, −3], [−1, −2, 5]], det = 17	Comatrice = transposée : [[8, 4, −1], [−1, 8, −2], [−6, −3, 5]]
10	C₁₁ = 28, C₂₂ = 14, C₃₃ = 8, C₁₂ = 0, C₂₃ = 0	Matrice triangulaire : det = produit de la diagonale = 56
11	C₁₂ = 5, C₂₁ = 0, C₂₃ = 0, C₃₂ = −2, det E = −9	Développer selon la ligne/colonne qui contient le plus de zéros (ici la colonne 2)

TD 4 · Matrices 4×4 : inverse par comatrice et par Gauss-Jordan TD4

Ex. 1 : det B = 10 ; cofacteurs de la 1re ligne : −3, −1, −1, 5 (vérifie : 2(−3) + 1(−1) + 3(−1) + 4(5) = 10 ✔). Ex. 2 : det C = −21 ≠ 0, donc C est inversible. Ex. 3 : mineur (L1, L3 ; C2, C4) = 1 ; mineur (L1, L2, L4 ; C1, C2, C3) = −12 ; mineur principal d'ordre 3 = 30.

import numpy as np
from fractions import Fraction as F

def gauss_jordan(M):
    n = len(M)
    A = [[F(x) for x in ligne] + [F(int(i == j)) for j in range(n)] for i, ligne in enumerate(M)]
    for c in range(n):
        p = next(r for r in range(c, n) if A[r][c] != 0)    # pivot non nul
        A[c], A[p] = A[p], A[c]
        piv = A[c][c]
        A[c] = [x / piv for x in A[c]]                     # pivot → 1
        for r in range(n):
            if r != c and A[r][c] != 0:
                k = A[r][c]
                A[r] = [a - k * b for a, b in zip(A[r], A[c])]
    return [ligne[n:] for ligne in A]

C = [[1, 2, 0, 1], [3, 1, 2, 0], [0, 4, 1, 2], [2, 0, 3, 1]]
inv = gauss_jordan(C)
for ligne in inv: print([str(x) for x in ligne])
print("C · C⁻¹ =\n", np.array(C) @ np.array(inv, dtype=float).round(12))
B = np.array([[2, 1, 3, 4], [1, 0, 2, 1], [4, 2, 1, 3], [3, 1, 0, 2]])
print("det B =", round(np.linalg.det(B)), "\nB⁻¹ =\n", np.linalg.inv(B).round(3))
A = np.array([[1, 2, 0, -1], [3, 0, 2, 4], [5, 1, -2, 0], [0, 3, 1, 2]])
print(round(np.linalg.det(A[np.ix_([0, 2], [1, 3])])), round(np.linalg.det(A[np.ix_([0, 1, 3], [0, 1, 2])])), round(np.linalg.det(A[:3, :3])))

TD 5 · Équilibrer une réaction chimique avec un système linéaire TD5

Idée : on cherche les coefficients x₁…xₙ. Pour chaque élément (Ca, C, O, H, Cl…), le nombre d'atomes à gauche = à droite → une équation linéaire homogène. Ex. CaCO₃ + HCl → CaCl₂ + H₂O + CO₂ : Ca : x₁ = x₃ ; C : x₁ = x₅ ; O : 3x₁ = x₄ + 2x₅ ; H : x₂ = 2x₄ ; Cl : x₂ = 2x₃. En fixant x₁ = 1 : CaCO₃ + 2 HCl → CaCl₂ + H₂O + CO₂.

import re
from fractions import Fraction as F
from math import lcm

def atomes(formule):
    d = {}
    for el, n in re.findall(r"([A-Z][a-z]?)(\d*)", formule):
        d[el] = d.get(el, 0) + int(n or 1)
    return d

def equilibrer(reactifs, produits):
    especes = reactifs + produits
    elements = sorted({e for f in especes for e in atomes(f)})
    # une ligne par élément ; réactifs comptés +, produits comptés −
    M = [[F(atomes(f).get(e, 0) * (1 if k < len(reactifs) else -1)) for k, f in enumerate(especes)] for e in elements]
    n = len(especes)
    # on fixe le dernier coefficient à 1 → système M' x = b
    A = [row[:-1] + [-row[-1]] for row in M]
    piv_cols, r = [], 0
    for c in range(n - 1):
        p = next((i for i in range(r, len(A)) if A[i][c] != 0), None)
        if p is None: continue
        A[r], A[p] = A[p], A[r]
        A[r] = [x / A[r][c] for x in A[r]]
        for i in range(len(A)):
            if i != r and A[i][c] != 0:
                A[i] = [a - A[i][c] * b for a, b in zip(A[i], A[r])]
        piv_cols.append(c); r += 1
    x = [F(0)] * (n - 1) + [F(1)]
    for i, c in enumerate(piv_cols): x[c] = A[i][-1]
    m = lcm(*[v.denominator for v in x])
    coefs = [int(v * m) for v in x]
    fmt = lambda fs, cs: " + ".join((f"{c} " if c != 1 else "") + f for f, c in zip(fs, cs))
    return fmt(reactifs, coefs[:len(reactifs)]) + " → " + fmt(produits, coefs[len(reactifs):])

print(equilibrer(["CaCO3", "HCl"], ["CaCl2", "H2O", "CO2"]))
print(equilibrer(["C2H6", "O2"], ["CO2", "H2O"]))
print(equilibrer(["KMnO4", "HCl"], ["KCl", "MnCl2", "H2O", "Cl2"]))
print(equilibrer(["NaOH", "H2SO4"], ["Na2SO4", "H2O"]))

TD 6 · Dosages et mélanges : systèmes linéaires TD6

Méthode : une inconnue par solution (ou médicament), une équation par substance. Les colonnes de la matrice sont les solutions, les lignes les substances : np.linalg.solve(A, cible).

⚠ Ce que révèle le calcul

Ex. 1 : 3,2 ml de solution 1 et 3,6 ml de solution 2 ✔.
Ex. 2 : la solution mathématique donne C = −0,31 L : impossible de verser un volume négatif. Avec ces trois solutions, les cibles 23/16/19 mmol ne sont pas atteignables (et additionner des mmol/L × L donne des mmol, pas des mmol/L : l'énoncé mélange quantité et concentration).
Ex. 3 : solution négative aussi (x₁ = −0,72 ; x₂ = −2,6) → prescription irréalisable avec ces médicaments. De plus l'énoncé donne des « mg par médicament » et demande des « ml » : il faut comprendre « mg/ml ».
Ex. 4 : solution positive (≈ 2,03 ; 4,28 ; 1,10), cohérente.

Moralité : toujours vérifier le sens physique d'une solution calculée.

TD numpy · Exercices 1 à 3 TD numpy

td poo · Exercice 1 : Compte et Banque td poo

class Compte:
    _compteur = 0                                   # attribut de classe
    def __init__(self, nom, solde=0):
        Compte._compteur += 1
        self.__numero = Compte._compteur            # attribué automatiquement
        self.__nom = nom
        self.__solde = solde
    @property
    def numero(self): return self.__numero
    @property
    def nom(self): return self.__nom               # pas de setter → non modifiable
    def consulter(self): return self.__solde
    def deposer(self, m):
        if m <= 0: raise ValueError("montant positif requis")
        self.__solde += m
    def retirer(self, m):
        if m > self.__solde: print("Solde insuffisant"); return False
        self.__solde -= m; return True
    def __str__(self): return f"N°{self.numero} {self.nom} : {self.__solde} DH"

class Banque:
    def __init__(self): self.__comptes = []
    def ajouter(self, c): self.__comptes.append(c)
    def obtenir(self, num): return next((c for c in self.__comptes if c.numero == num), None)
    def supprimer(self, num):
        c = self.obtenir(num)
        if c: self.__comptes.remove(c)
        return c is not None
    def __str__(self): return "\n".join(map(str, self.__comptes))

b = Banque()
for n, s in [("Ali", 500), ("Sara", 1200), ("Omar", 80)]: b.ajouter(Compte(n, s))
b.obtenir(2).retirer(200); b.obtenir(3).retirer(500)
b.supprimer(1); print(b)
try:
    b.obtenir(2).nom = "Pirate"
except AttributeError as e:
    print("AttributeError :", e)

TD POO · Gestion des employés (héritage, polymorphisme, agrégation) Employés

class Employe:
    def __init__(self, matricule, nom, salaire_base):
        self.__matricule, self.__nom, self.__base = matricule, nom, salaire_base
    @property
    def matricule(self): return self.__matricule
    @property
    def nom(self): return self.__nom
    @property
    def salaire_base(self): return self.__base
    def calculer_salaire(self): return self.__base
    def afficher(self): return f"{self.matricule} | {self.nom} | {self.calculer_salaire():.2f} DH"

class Permanent(Employe):
    def __init__(self, matricule, nom, base, prime):
        super().__init__(matricule, nom, base); self.__prime = prime
    def calculer_salaire(self): return self.salaire_base + self.__prime

class Temporaire(Employe):
    def __init__(self, matricule, nom, base, heures, tarif):
        super().__init__(matricule, nom, base); self.__h, self.__t = heures, tarif
    def calculer_salaire(self): return self.__h * self.__t

class Departement:
    def __init__(self, code, nom): self.code, self.nom, self.__emps = code, nom, []
    def chercher_employe(self, mat): return next((e for e in self.__emps if e.matricule == mat), None)
    def ajouter_employe(self, e):
        if self.chercher_employe(e.matricule): print("Refusé : matricule déjà utilisé"); return
        self.__emps.append(e)
    def supprimer_employe(self, mat):
        e = self.chercher_employe(mat)
        if e: self.__emps.remove(e)
        return e is not None
    def masse_salariale(self): return sum(e.calculer_salaire() for e in self.__emps)   # polymorphisme
    def afficher_tous(self):
        for e in self.__emps: print("  ", e.afficher())
        print(f"   Masse salariale : {self.masse_salariale():.2f} DH")

dep = Departement("PH", "Pharmacie hospitalière")
while True:
    print("\n1 Permanent  2 Temporaire  3 Afficher  4 Rechercher  5 Supprimer  6 Masse  0 Quitter")
    ch = input("Choix : ")
    if ch == "0": break
    elif ch in ("1", "2"):
        m, n, b = input("Matricule : "), input("Nom : "), float(input("Salaire de base : "))
        if ch == "1": dep.ajouter_employe(Permanent(m, n, b, float(input("Prime : "))))
        else: dep.ajouter_employe(Temporaire(m, n, b, int(input("Heures : ")), float(input("Tarif horaire : "))))
    elif ch == "3": dep.afficher_tous()
    elif ch == "4":
        e = dep.chercher_employe(input("Matricule : ")); print(e.afficher() if e else "Introuvable")
    elif ch == "5": print("Supprimé" if dep.supprimer_employe(input("Matricule : ")) else "Introuvable")
    elif ch == "6": print(dep.masse_salariale())

td poo · Exercice 3 : Abonnements (validation, propriétés read-only) td poo

class Abonnement:
    def __init__(self, numero, titulaire, tarif_base):
        if numero <= 0 or not titulaire.strip() or tarif_base <= 0:
            raise ValueError("données d'abonnement invalides")
        self.__numero, self.__titulaire = numero, titulaire
        self.__tarif_base = tarif_base
        self.__minutes, self.__data_go, self.__active = 0, 0.0, True
    numero = property(lambda self: self.__numero)
    titulaire = property(lambda self: self.__titulaire)
    minutes = property(lambda self: self.__minutes)
    data_go = property(lambda self: self.__data_go)
    @property
    def tarif_base(self): return self.__tarif_base
    @tarif_base.setter
    def tarif_base(self, v):
        if v <= 0: raise ValueError("tarif > 0 requis")
        self.__tarif_base = v
    def consommer(self, minutes=0, go=0.0):
        self.__minutes += minutes; self.__data_go += go
    def facture(self): return self.tarif_base

class ForfaitStandard(Abonnement):
    def facture(self):    # 0,50 DH/min au-delà de 120 min, 10 DH/Go au-delà de 5 Go
        return self.tarif_base + 0.5 * max(0, self.minutes - 120) + 10 * max(0, self.data_go - 5)

class ForfaitPremium(Abonnement):
    def facture(self):    # appels illimités, 5 DH/Go au-delà de 30 Go
        return self.tarif_base + 5 * max(0, self.data_go - 30)

abos = [ForfaitStandard(1, "Ali", 99), ForfaitPremium(2, "Sara", 249)]
abos[0].consommer(200, 7.5); abos[1].consommer(900, 34)
for a in abos: print(a.titulaire, type(a).__name__, a.facture(), "DH")
try: abos[0].tarif_base = -5
except ValueError as e: print("Refusé :", e)

Les tarifs de dépassement ne sont pas donnés dans l'énoncé : ceux-ci sont des exemples pour illustrer la redéfinition de facture().

TD Pandas · Titanic (13 questions) TD Titanic

Le fichier Kaggle n'a pas de doublons complets ; deux passagers n'ont pas de port d'embarquement → 889 lignes après nettoyage.

Examen 2025 · TP pandas sur people.tsv Examen

Le vrai people.tsv n'était pas fourni : le site utilise un fichier d'exemple aux valeurs fictives (mêmes colonnes : name, sex, size, age). Les réponses dépendront des données réelles le jour de l'examen ; c'est la méthode qui compte.

Mini-projet Netflix · la démarche sur un mini-échantillon EDA

Le fichier netflix_titles.csv (8 800 lignes) n'est pas fourni : voici les instructions clés du projet appliquées à un échantillon de 8 lignes inventées au même format. Le même code fonctionne sur le vrai fichier dans Colab.

import pandas as pd
from itertools import combinations
from collections import Counter
df = pd.DataFrame({
 "title": ["Ocean Run", "Atlas", "Le Pont", "Moon Kids", "Desert", "Fès Story", "Code Red", "Nuit"],
 "type": ["Movie", "TV Show", "Movie", "TV Show", "Movie", "Movie", "Movie", "TV Show"],
 "director": ["A. Lee", None, "C. Morel", None, "D. Diaz", "Y. Alaoui", "A. Lee", None],
 "cast": ["Ana, Bo, Cy", "Bo, Cy", "Dan, Eve", "Ana, Bo", "Cy, Dan", "Eve, Fay, Ana", "Ana, Bo, Cy", "Fay"],
 "country": ["United States", "United States, Canada", "France", "India", "Mexico, Spain", "Morocco, France", "United States", "France"],
 "date_added": ["September 25, 2021", "July 1, 2019", "January 5, 2020", "May 3, 2021", "March 8, 2019", "June 2, 2021", "April 9, 2020", "June 1, 2018"],
 "listed_in": ["Action, Thrillers", "Dramas", "Comedies, Dramas", "Kids' TV", "Dramas", "Documentaries", "Action", "Thrillers"],
 "duration": ["101 min", "2 Seasons", "95 min", "1 Season", "120 min", "88 min", "110 min", "3 Seasons"]})
scores = pd.DataFrame({"title": ["Ocean Run", "Atlas", "Le Pont", "Desert", "Fès Story", "Code Red"], "imdb_score": [6.8, 7.9, 7.1, 6.2, 8.3, 6.5]})

df["director"] = df["director"].fillna("Inconnu")
df["date_added"] = pd.to_datetime(df["date_added"].str.strip(), format="%B %d, %Y")
df["year_added"], df["month_added"] = df.date_added.dt.year, df.date_added.dt.month
df["country_main"] = df["country"].str.split(",").str[0]
df["genre"] = df["listed_in"].str.split(",").str[0]
df["duration_num"] = df["duration"].str.extract(r"(\d+)", expand=False).astype(int)
print(df["type"].value_counts(), df["country_main"].value_counts().idxmax(), df["year_added"].value_counts().idxmax())

df = df.merge(scores, on="title", how="left")                      # étape 9
df["imdb_score"] = df["imdb_score"].fillna(df["imdb_score"].median())
pays = df.assign(c=df["country"].str.split(", ")).explode("c")      # étape 10
print(pays["c"].value_counts().head(3))
print(df.pivot_table(values="imdb_score", index="year_added", columns="type", aggfunc="mean"))

paires = Counter()                                                  # étape 13
for liste in df.loc[df["country_main"] != "India", "cast"]:
    acteurs = sorted(a.strip() for a in liste.split(","))
    paires.update(combinations(acteurs, 2))
print(paires.most_common(3))

Les graphiques (matplotlib/seaborn) demandés aux étapes 6 et 12 ne sont pas disponibles dans cet exécuteur : fais-les dans Colab.

Ne pas tomber dedans

Pièges classiques

input() renvoie une chaîne. input("âge") + 1 → TypeError ; "5" * 2 → "55". Convertir avec int()/float().

= n'est pas ==. = affecte, == compare. if x = 3: → SyntaxError.

/ donne toujours un float (10 / 2 = 5.0) ; // la division entière ; % le reste.

Les index commencent à 0 et la borne de fin est exclue : range(1, 5) → 1, 2, 3, 4 ; l[1:3] → éléments 1 et 2. Exception : df.loc[0:3] inclut 3.

Tuple d'un seul élément : ("x") est une chaîne, ("x",) un tuple.

{} crée un dictionnaire vide, pas un set : le set vide s'écrit set().

remove vs discard sur un set : remove lève KeyError si l'élément est absent, discard non.

append vs extend : [1,2].append([3,4]) → [1, 2, [3, 4]] ; extend → [1, 2, 3, 4].

Oublier self dans une méthode → TypeError « takes 0 positional arguments but 1 was given ».

Oublier super().__init__() dans la classe fille → les attributs du parent n'existent pas.

A * B n'est pas le produit matriciel avec NumPy : c'est case par case. Produit matriciel : A @ B ou np.dot(A, B).

Filtre pandas : and/or → ValueError ; utiliser &, | et des parenthèses autour de chaque condition.

Une méthode pandas renvoie souvent une copie : df.dropna() seul ne change rien ; écrire df = df.dropna().

Cours : confondre HL7 (format d'échange) et SNOMED/LOINC (terminologies) ; confondre DMI (un établissement) et DMP (partagé).

Informatique appliquée & Python

Carte du module