Programmation Python

1. Qu’est-ce que Python ?

• Python est un langage de programmation créé en 1989 par Guido van Rossum, nommé d’après la série télévisée Monty Python’s Flying Circus.
• La version actuelle est Python 3 (3.11 depuis octobre 2022). La version 2 est obsolète.
• Organisme officiel : Python Software Foundation.
• Caractéristiques clés :
  • Multiplateforme : fonctionne sur Windows, Mac OS X, Linux, Android, iOS, Raspberry Pi, supercalculateurs.
  • Gratuit et libre d’installation.
  • Langage de haut niveau : facile à apprendre sans connaissances approfondies en informatique.
  • Langage interprété : pas besoin de compilation.
  • Orienté objet : modélisation d’entités réelles (molécules, protéines, etc.).
  • Simple à prendre en main.
  • Langage le plus utilisé au monde (classements TIOBE, IEEE Spectrum).
  • Très utilisé en bioinformatique, chimie-informatique et analyse de données.

2. Conseils pour l’apprentissage de Python

• Apprendre Python demande du temps et de la pratique régulière.
• Nécessite uniquement un ordinateur et une connexion internet.
• Python est patient et toujours disponible, idéal pour expérimenter et corriger ses erreurs.

3. Conseils pour installer et configurer Python

• Installer Python 3 sur Windows, Mac OS X ou Linux.
• Recommandation : installer Miniconda, qui inclut Python 3 et le gestionnaire de paquets conda.
• Conda facilite l’installation de modules utiles (NumPy, scipy, matplotlib, pandas, Biopython, Jupyter Lab).
• Choix d’un éditeur de texte adapté :
  • Débutants : Notepad++ (Windows), BBEdit ou CotEditor (Mac), gedit (Linux).
  • Autres possibles : Visual Studio Code, Sublime Text, emacs, vim, geany.
• Ne pas utiliser de traitements de texte (Word, LibreOffice Writer) pour coder.

4. Notations utilisées

• Les commandes et instructions Python sont indiquées dans une police spécifique.
• Les programmes longs sont numérotés ligne par ligne.
• La notation [...] indique une coupure arbitraire dans un contenu trop long.

5. Introduction au shell

• Un shell est un interpréteur de commandes interactif pour communiquer avec l’ordinateur.
• Le shell sert à lancer l’interpréteur Python.
• L’invite de commande du shell est représentée par $ (sans taper ce symbole).
• Exemples d’invites de shell :
  • Windows : PS C:\Users\pierre>
  • Mac OS X : iMac-de-pierre:Downloads$
  • Linux : pierre@jeera:~$

6. Premier contact avec Python

• Python est un langage interprété : chaque ligne est exécutée immédiatement.

• Lancer l’interpréteur Python dans le shell avec la commande python.

• L’invite de l’interpréteur Python est >>>.

• Exemple d’utilisation interactive :

  >>> print("Hello world!")
  Hello world!
  >>> 1 + 1
  2
  

• Pour quitter l’interpréteur : exit() ou Ctrl+D (Linux/Mac), Ctrl+Z puis Entrée (Windows).

• Les longues lignes de code peuvent être coupées avec un \ (backslash) suivi d’un retour à la ligne.

7. Premier programme

• Pour exécuter plusieurs instructions, on écrit un script Python dans un fichier .py.

• Exemple minimal :

  print("Hello world!")
  

• Exécuter un script dans le shell avec : python nom_du_fichier.py.

8. Commentaires

• Le caractère # introduit un commentaire : tout ce qui suit sur la ligne est ignoré par Python.

• Les commentaires expliquent le code en langage humain.

• Exemple :

  # Ceci est un commentaire
  print("Hello world!")
  

9. Notion de bloc d’instructions et d’indentation

• Un bloc d’instructions est un groupe de lignes indentées (décalées vers la droite).
• L’indentation (recommandée : 4 espaces) délimite les blocs en Python.
• Exemple (pseudo-code) : pour chaque base d’une séquence, afficher la base et compter, puis afficher le total après la boucle.
• L’indentation doit être homogène (espaces ou tabulations, pas les deux mélangés).

10. Autres ressources

• Livres recommandés en français :
  • Apprendre à programmer avec Python 3 de Gérard Swinnen (gratuit en ligne).
  • Apprendre à programmer en Python avec PyZo et Jupyter Notebook de Bob Cordeau et Laurent Pointal.
  • Apprenez à programmer en Python de Vincent Legoff (OpenClassrooms).
• Site officiel : python.org avec documentation et index des modules.

À retenir : Python est un langage interprété, simple, multiplateforme et orienté objet, idéal pour la bioinformatique et l’analyse de données, avec une forte communauté et de nombreuses ressources pour apprendre.

1. Définition et création

• Variable : zone mémoire stockant une valeur, identifiée par un nom pour le programmeur.
• En Python, déclaration et initialisation se font simultanément : x = 2.
• Python est un langage à typage dynamique : il déduit automatiquement le type de la variable.
• L’opérateur = est un opérateur d’affectation qui assigne la valeur de droite à la variable de gauche.
• L’opérateur = écrase la valeur précédente si la variable existe déjà.

En Python, taper le nom d’une variable dans l’interpréteur affiche sa valeur, mais pas dans un script.

2. Types de variables

• Les chaînes doivent être entourées de guillemets simples, doubles ou triples.
• Le séparateur décimal est le point (3.14), pas la virgule.
• Python est sensible à la casse : test, Test et TEST sont des variables différentes.

3. Nommage des variables

• Autorisé : lettres (a-z, A-Z), chiffres (0-9), underscore (_).
• Interdit : espaces, début par un chiffre, mots réservés (ex. print, for).
• Recommandé : noms explicites, éviter les noms à une lettre sauf cas particuliers.
• Sensible à la casse.

4. Écriture scientifique

• Notation : $a \times 10^b$ s’écrit aeb en Python.
• Exemple :

  1e6   # 1 × 10^6 = 1000000.0 (float)
  3.12e-3  # 3.12 × 10^-3 = 0.00312
  

• L’utilisation de l’underscore _ permet de séparer les chiffres pour la lisibilité :
  6.022_140_76e23 ou 8_094_752_749.

5. Opérations

a) Opérations sur nombres

• Mélanger int et float produit un float.
• Parenthèses permettent de gérer la priorité des opérations.
• Opérateurs combinés :
  i += 1 équivaut à i = i + 1 (incrémentation).
  Similairement -=, *=, /=.

b) Opérations sur chaînes de caractères

• + : concaténation (assemblage de chaînes).
  "Salut" + " Python" → "Salut Python"
• * : duplication (répétition).
  "Salut" * 3 → "SalutSalutSalut"

Attention : + et * ont des comportements différents selon le type (numérique ou chaîne).

c) Opérations illicites

• Multiplier une chaîne par un float ou additionner une chaîne et un entier provoque une erreur TypeError.

6. Fonction type()

• Permet de connaître le type d’une variable :

  type(2)    # <class 'int'>
  type(2.0)  # <class 'float'>
  type('2')  # <class 'str'>
  type(True) # <class 'bool'>
  

• Python distingue strictement 2 (int), 2.0 (float) et '2' (str).

7. Conversion de types (casting)

• Fonctions principales : int(), float(), str().
• Exemples :

  str(3)       # '3'
  int('456')   # 456
  float('3.1416') # 3.1416
  

• Utile pour convertir entre chaînes et nombres, notamment lors de la lecture/écriture de fichiers.

8. Vocabulaire et syntaxe

• En Python, une variable est aussi appelée un objet.
• Une fonction est appelée avec des parenthèses, ex. type(x).
• L’argument est ce qu’on passe à la fonction entre parenthèses.
• Une fonction effectue une action et peut renvoyer un résultat.

9. Fonctions min() et max()

• min() renvoie la plus petite valeur parmi plusieurs arguments.
• max() renvoie la plus grande valeur.
• Exemples :

  min(1, -2, 4)   # -2
  max(2.4, 3.14)  # 3.14
  

• Ces fonctions prennent au moins deux arguments.

À retenir :
Une variable en Python est un nom lié à une valeur stockée en mémoire, avec un type dynamique. L’opérateur = affecte une valeur à une variable, écrasant l’ancienne si elle existe. Les types principaux sont int, float, str et bool. Les opérations arithmétiques et sur chaînes ont des opérateurs spécifiques, et la fonction type() permet d’identifier le type d’une variable. Les conversions entre types se font facilement avec int(), float(), et str().

1. La fonction print()

• print() affiche son argument suivi d’un retour à la ligne par défaut.
• Pour supprimer ce retour à la ligne, utiliser l’argument par mot-clé end :

  print("Hello world!", end="")
  

• Affichage de plusieurs éléments avec des virgules ajoute un espace entre eux.
  Exemple :

  print(nom, "a", x, "ans")
  

• Modifier le séparateur avec l’argument sep :

  print(nom, "a", x, "ans", sep="-")
  

• Pour concaténer deux chaînes sans espace, utiliser soit l’opérateur +, soit sep="" dans print.

2. Messages d’erreur

• Les messages d’erreur (ou Traceback) indiquent :
  1. Le type d’erreur (ex : SyntaxError, ZeroDivisionError, ValueError).
  2. La description précise de l’erreur.
  3. La ligne du script où l’erreur a été détectée.
• Lire les messages d’erreur du bas vers le haut pour comprendre la cause.
• Utiliser une version récente de Python (≥ 3.10) pour des messages plus clairs.

À retenir : Le message d’erreur indique toujours la nature et la localisation précise du problème.

3. Écriture formatée et f-strings

a) Définitions

• Écriture formatée : afficher des variables avec un format précis (ex : nombre de décimales, alignement).
• f-string (formatted string literals) : chaîne de caractères précédée de f qui permet d’insérer des variables ou expressions entre accolades {}.

b) Utilisation basique des f-strings

• Syntaxe :

  print(f"{nom} a {x} ans")
  

• Sans le f, les accolades sont affichées telles quelles.
• On peut utiliser plusieurs fois la même variable dans une f-string.
• Les expressions et valeurs littérales sont aussi valides dans les accolades.

c) Spécification de format

• Syntaxe générale :

  f"{variable:format_spec}"
  

• Pour un float avec 2 décimales :

  f"{prop_GC:.2f}"
  

• Pour un entier :

  f"{nb_G:d}"
  

• Alignement et largeur :

  Symbole	Description	Exemple	Résultat
  >	Alignement à droite	f"{10:>6d}"	" 10"
  <	Alignement à gauche	f"{10:<6d}"	"10 "
  ^	Centré	f"{10:^6d}"	" 10 "

• Remplissage avec un caractère :

  f"{10:*^6d}"  # "**10**"
  

• Pour les chaînes de caractères, utiliser s :

  f"{'HN':>4s}"
  

• Combinaison largeur et décimales pour float :

  f"{perc_GC:7.3f}"
  

d) Autres détails

• Pour afficher des accolades littérales dans une f-string, doubler les accolades :

  f"{{}}"
  

• Une f-string vide {} sans expression provoque une erreur de syntaxe.
• Une f-string est évaluée avant d’être affichée par print.

e) Expressions dans les f-strings

• Les f-strings acceptent des expressions Python dans les accolades :

  print(f"5 * 5 = {5 * 5}")
  print(f"min(1, -2, 4) = {min(1, -2, 4)}")
  print(f"Type de 2 : {type(2)}")
  

4. Écriture scientifique

• Notation scientifique avec e dans les f-strings :

  f"{1_000_000_000:e}"  # '1.000000e+09'
  

• Précision du nombre de chiffres après la virgule :

  f"{avogadro_number:.3e}"
  

• Exemple avec Avogadro :

  Format	Résultat
  .0e	6e+23
  .3e	6.022e+23
  .6e	6.022141e+23

À retenir :

• print() affiche avec retour à la ligne par défaut, modifiable avec end.
• sep modifie le séparateur entre plusieurs arguments dans print.
• f-strings permettent d’insérer variables et expressions dans des chaînes avec formatage précis.
• Les erreurs Python sont détaillées dans les Tracebacks, à lire du bas vers le haut.
• L’écriture scientifique est accessible via les f-strings avec le format e.

1. Définition

• Une liste est une structure de données contenant une collection ordonnée d’objets Python, pouvant être de types différents.
• Elle est définie par des crochets [] avec des éléments séparés par des virgules.
• Exemple : animaux = ["girafe", "tigre", "singe", "souris"]

2. Accès par indice

• Les éléments d’une liste sont accessibles par leur indice (position), commençant à 0 jusqu’à n−1 pour une liste de taille $n$.
• Exemple : animaux[0] renvoie "girafe".
• Accéder à un indice hors limites provoque une erreur IndexError.

3. Opérations sur les listes

• Pour créer une liste vide : liste = []

4. Indiçage négatif

• Les indices négatifs comptent à partir de la fin :
  • -1 correspond au dernier élément
  • -2 à l’avant-dernier, etc.
• Exemple :
  • animaux[-1] → "souris"
  • animaux[-4] → "girafe" (équivalent à animaux[0])

5. Tranches (slicing)

• Syntaxe : liste[m:n] récupère les éléments de l’indice $m$ inclus à $n$ exclu.
• Par défaut, si $m$ ou $n$ sont omis, la tranche prend respectivement depuis le début ou jusqu’à la fin.
• On peut aussi spécifier un pas : liste[m:n:p] prend un élément sur $p$.
• Exemples :
  • animaux[0:2] → ["girafe", "tigre"]
  • animaux[1:-1] → ["tigre", "singe"]
  • x[::2] → éléments d’indice pair

6. Fonction len()

• len(liste) retourne le nombre d’éléments dans la liste.
• Exemple :
  • len(["girafe", "tigre", "singe", "souris"]) → 4

7. Fonctions range() et list()

• range(n) génère une séquence d’entiers de 0 à $n-1$.
• list(range(n)) convertit cette séquence en liste.
• Exemple :
  • list(range(10)) → [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

À retenir : Une liste est une séquence ordonnée et mutable d’objets accessibles par indices positifs ou négatifs, avec de nombreuses opérations natives pour manipuler facilement ses éléments.

1. Boucles for

• But : Répéter un bloc d’instructions pour chaque élément d’une séquence (liste, chaîne, etc.).
• Syntaxe :

  for variable in séquence:
      bloc d’instructions
  

• Variable d’itération : prend successivement chaque valeur de la séquence.
• Le bloc d’instructions est délimité par l’indentation (4 espaces recommandés).
• Exemple :

  animaux = ["girafe", "tigre", "singe", "souris"]
  for animal in animaux:
      print(animal)
  

• La variable d’itération conserve sa dernière valeur après la boucle.

2. Fonction range()

• Génère une séquence d’entiers, utilisée souvent dans les boucles for.
• Syntaxe : range([début,] fin[, pas])
  • début (optionnel, défaut 0)
  • fin (exclu)
  • pas (optionnel, défaut 1)
• Exemples :
  • range(5) → 0,1,2,3,4
  • range(15, 20) → 15,16,17,18,19
  • range(0, 1000, 200) → 0,200,400,600,800
  • range(10, 0, -1) → 10,9,8,...,1
• range() est un objet itérable efficace en mémoire (ne crée pas une liste complète).
• Pour obtenir une liste, utiliser list(range(...)).

3. Itération sur éléments vs indices

• Pour obtenir indices et éléments simultanément :

  for i, animal in enumerate(animaux):
      print(f"L'animal {i} est un(e) {animal}")
  

4. Comparaisons (introduction)

• Les comparaisons permettent de tester des conditions (ex. : égalité, inégalité).
• Elles seront détaillées dans la suite du chapitre.

À retenir : La boucle for itère efficacement sur des objets itérables comme les listes ou les objets range(). Utilisez l’itération directe sur les éléments quand possible, et enumerate() pour accéder simultanément aux indices et éléments.

1. Définition des tests

• Un test permet à Python de prendre une décision en évaluant une condition avec l’instruction if.
• Syntaxe :

  if condition:
      bloc d’instructions indenté
  

• Le bloc s’exécute uniquement si la condition est vraie (True).

2. Tests à plusieurs cas : if, elif, else

• if teste une condition.
• elif teste une autre condition si la précédente est fausse.
• else s’exécute si toutes les conditions précédentes sont fausses.
• Exemple :

  if x == 1:
      ...
  elif x == 2:
      ...
  else:
      ...
  

3. Importance de l’indentation

• L’indentation délimite le bloc d’instructions dépendant d’un test.
• Une mauvaise indentation modifie la portée des instructions et donc le comportement du programme.
• Exemple :
  • Instruction indentée dans le bloc if → s’exécute seulement si la condition est vraie.
  • Instruction non indentée → s’exécute toujours.

4. Tests multiples avec opérateurs booléens

• Exemples :

  if x == 2 and y == 2:
      print("le test est vrai")
  if not (x == 2):
      print("x n'est pas 2")
  

5. Instructions break et continue

• break : interrompt immédiatement la boucle en cours (for ou while).
• continue : saute le reste du corps de la boucle et passe à l’itération suivante.
• Exemple break :

  for i in range(5):
      if i > 2:
          break
      print(i)  # affiche 0,1,2
  

• Exemple continue :

  for i in range(5):
      if i == 2:
          continue
      print(i)  # affiche 0,1,3,4
  

6. Tests de valeur sur des floats

• Ne jamais tester l’égalité stricte avec == sur des floats à cause des imprécisions de représentation.
• Exemple problématique :

  (3 - 2.7) == 0.3  # False car 3-2.7 ≈ 0.2999999999999998
  

• Bonnes pratiques pour tester l’égalité approchée avec une tolérance delta :
  • Encadrement :
    $0.3 - \delta < var < 0.3 + \delta$
  • Valeur absolue :

    abs(var - 0.3) < delta
    

• Depuis Python 3.5, utiliser la fonction math.isclose() :

  import math
  math.isclose(var, 0.3, abs_tol=1e-5)
  

• Conseil : privilégier math.isclose() pour la lisibilité et la précision.

À retenir
Pour comparer des floats, ne jamais utiliser == mais une comparaison avec une tolérance (ex. math.isclose()).

7. Résumé des opérateurs de comparaison

• Pour les chaînes de caractères, les comparaisons utilisent l’ordre ASCII (ordre alphabétique).
• Comparaison lexicographique caractère par caractère.

8. Exemple d’utilisation des tests

x = 2
if x == 2:
    print("Le test est vrai !")
else:
    print("Le test est faux !")

9. Tests imbriqués et multiples conditions

• On peut imbriquer plusieurs if ou utiliser and/or pour combiner les conditions.
• Exemple équivalent :

  if x == 2 and y == 2:
      print("le test est vrai")
  

  ou

  if x == 2:
      if y == 2:
          print("le test est vrai")
  

10. Bonnes pratiques

• Soigner l’indentation pour éviter les erreurs de portée.
• Utiliser and, or, not pour combiner les conditions.
• Pour les floats, éviter == strict, préférer math.isclose().

11. Récapitulatif opérateurs booléens

1. Lecture dans un fichier

• Ouvrir un fichier : open("nom_fichier", "r") ouvre un fichier en mode lecture ("r"). Le fichier doit être dans le répertoire courant ou préciser son chemin.
• Objet fichier : l'ouverture retourne un objet fichier, manipulable avec des méthodes.
• Lire toutes les lignes : f.readlines() renvoie une liste de chaînes, chaque élément correspondant à une ligne (avec le caractère spécial \n de fin de ligne).
• Fermer un fichier : f.close() ferme le fichier, après quoi toute opération de lecture/écriture échoue.
• Bloc with : with open(...) as f: ouvre un fichier et le ferme automatiquement à la fin du bloc, même en cas d'erreur.

a) Méthodes de lecture

À retenir : privilégier l'itération directe sur l'objet fichier pour lire ligne par ligne.

2. Écriture dans un fichier

• Ouvrir en écriture : open("nom_fichier", "w") ouvre un fichier en mode écriture (écrase le contenu existant).
• Écrire dans un fichier : f.write(chaine) écrit une chaîne dans le fichier. Il faut gérer explicitement les retours à la ligne (\n).
• Bloc with : assure la fermeture automatique du fichier.

Exemple d’écriture avec retour à la ligne :

with open("fichier.txt", "w") as f:
    for ligne in liste:
        f.write(f"{ligne}\n")

3. Ouvrir plusieurs fichiers simultanément

Syntaxe compacte avec with :

with open("fichier1.txt", "r") as f1, open("fichier2.txt", "w") as f2:
    for ligne in f1:
        f2.write("* " + ligne)

4. Retours à la ligne sous Unix et Windows

• Unix (Linux, Mac OS X) utilise \n (line feed).
• Windows utilise \r\n (carriage return + line feed).
• Python 3 gère automatiquement ces différences et normalise les retours à la ligne en \n.

5. Conversion de types avec les fichiers

• Les méthodes de lecture renvoient toujours des chaînes de caractères.
• Pour manipuler des nombres, il faut convertir explicitement avec int(), float(), etc.
• Pour écrire des nombres, convertir en chaîne avec str() ou utiliser l’écriture formatée.

6. Résumé des modes d'ouverture

7. Exercices clés

1. Moyenne des notes : lire un fichier de notes (une note par ligne), convertir en float, calculer et afficher la moyenne avec 2 décimales.
2. Admis ou recalé : lire les notes, écrire dans un nouveau fichier chaque note suivie de "admis" (≥10) ou "recalé" (<10), avec une décimale.
3. Spirale : calculer des coordonnées cartésiennes d’une spirale, écrire dans un fichier avec formatage précis, puis visualiser avec matplotlib.

À retenir : la gestion des fichiers en Python repose sur l'ouverture avec open(), la lecture/écriture via des méthodes adaptées, et la fermeture automatique avec with pour éviter les erreurs et fuites de ressources.

1. Dictionnaires

• Définition : Un dictionnaire est une collection d’objets accessibles via des clés (souvent des chaînes de caractères), et non par des indices comme dans les listes.
• Syntaxe :
  • Dictionnaire vide : dico = {}
  • Ajout d’une clé/valeur : dico["clé"] = valeur
  • Initialisation multiple : dico = {"nom": "singe", "poids": 70}
• Accès aux valeurs : dico["clé"] renvoie la valeur associée à la clé.
• Ordre : Depuis Python 3.7, l’ordre d’insertion est conservé lors de l’affichage et l’itération, mais on accède toujours par clé, pas par position.

• Avantage : Les dictionnaires rendent le code plus lisible en utilisant des noms explicites comme clés plutôt que des indices numériques.

• Liste de dictionnaires : Permet de gérer des structures complexes, par exemple une liste d’animaux où chaque animal est un dictionnaire.

2. Tuples

• Définition : Les tuples sont des séquences immuables (non modifiables) d’objets, similaires aux listes mais avec des parenthèses () au lieu de crochets [].
• Syntaxe :
  • Création : t = (1, 2, 3) ou sans parenthèses t = 1, 2, 3 (parenthèses recommandées pour la clarté)
  • Tuple à un élément : t = (2,) (la virgule est obligatoire)
• Immuabilité : On ne peut pas modifier un élément d’un tuple (TypeError si tentative). Pour ajouter un élément, il faut créer un nouveau tuple :
  t = t + (4,)
• Opérations :
  • Concatenation : (1,2) + (3,4) → (1,2,3,4)
  • Répétition : (1,2) * 3 → (1,2,1,2,1,2)
• Conversion : tuple(objet itérable) transforme une séquence en tuple (ex : tuple([1,2,3]) → (1,2,3)).

3. Affectation multiple et désempaquetage

• Permet d’affecter plusieurs variables en une seule instruction :

  x, y, z = 1, 2, 3
  

• Le nombre de variables doit correspondre au nombre d’éléments.
• Utilisé aussi pour désempaqueter un tuple :

  t = (1, 2, 3)
  x, y, z = t
  

• Syntaxe plus élégante et lisible que d’affecter un par un.

4. Itérations sur plusieurs valeurs simultanément

• Certaines fonctions/méthodes renvoient des tuples, permettant d’itérer sur plusieurs valeurs à la fois :
  • enumerate(liste) renvoie des tuples (indice, élément)
  • dico.items() renvoie des tuples (clé, valeur)
• Exemple :

  for i, val in enumerate([75, -75, 0]):
      print(i, val)
  for cle, val in dico.items():
      print(cle, val)
  

• On peut aussi itérer sur des listes de tuples avec plusieurs éléments :

  liste = [(5,6,7), (6,7,8), (7,8,9)]
  for x, y, z in liste:
      print(x, y, z)
  

5. Fonction divmod()

• Calcule quotient et reste d’une division entière en une seule opération :

  quotient, reste = divmod(numérateur, dénominateur)
  

• Exemple :

  divmod(754, 60) → (12, 34)  # 754 secondes = 12 minutes et 34 secondes
  

• Utile pour convertir des durées (secondes → minutes/secondes, jours → années/mois/jours, etc.).

À retenir :

• Les dictionnaires associent des clés à des valeurs et permettent un accès explicite et rapide aux données.
• Les tuples sont des séquences immuables, utiles pour stocker des données fixes et pour l’affectation multiple.
• La fonction divmod() facilite le calcul simultané du quotient et du reste d’une division entière.

1. Définition des modules

• Modules : programmes Python contenant des fonctions réutilisables, aussi appelés bibliothèques.
• Python propose plus de 300 modules standards, couvrant de nombreux domaines.
• Toujours vérifier si une fonctionnalité existe déjà dans un module avant de la coder.

2. Importation de modules

• Syntaxe classique :

  import module
  module.fonction()
  

• Exemple :

  import random
  random.randint(0, 10)
  

• Importer une fonction spécifique :

  from random import randint
  randint(0, 10)
  

• Importer toutes les fonctions d’un module :

  from random import *
  

  À éviter en pratique pour éviter les conflits de noms.

• Alias pour un module :

  import random as rand
  rand.randint(1, 10)
  

• Supprimer un module chargé :

  del random
  

La syntaxe module.fonction() indique la provenance de la fonction, ce n’est pas une méthode liée à un objet.

3. Obtenir de l’aide sur les modules

• Utiliser help() pour obtenir la documentation d’un module ou d’une fonction :

  import random
  help(random)
  help(random.randint)
  

• Naviguer dans l’aide avec les flèches, quitter avec Q, rechercher avec /texte.
• Pour lister toutes les fonctions et variables d’un module :

  dir(random)
  

4. Modules courants à connaître

5. Module random : génération de nombres aléatoires

• Fonctions principales :

  • random.randint(a, b) : entier aléatoire entre a et b inclus.
  • random.uniform(a, b) : float aléatoire entre a et b.
  • random.shuffle(liste) : mélange aléatoire d’une liste.
  • random.choice(liste) : tire un élément aléatoire dans une liste.
  • random.choices(liste, k=n) : tire n éléments avec remise.

• Graine aléatoire (seed) :
  Permet de reproduire une même séquence pseudo-aléatoire.

  random.seed(42)
  

• Distribution des tirages :

  • random.random() : float uniforme entre 0 et 1.
  • random.gauss(mu, sigma) : tirage selon une distribution gaussienne.

6. Module sys : passage d’arguments en ligne de commande

• sys.argv : liste des arguments passés au script, avec le nom du script en sys.argv[0].
• Exemple d’utilisation :

  import sys
  print(sys.argv)
  

• Vérification du nombre d’arguments :

  if len(sys.argv) != 2:
      sys.exit("ERREUR : il faut exactement un argument.")
  

• Fonction sys.exit(message) : quitte le script en affichant un message.
• Exemple pratique : script qui compte les lignes d’un fichier passé en argument.

7. Module pathlib : gestion des fichiers et répertoires

• Import classique :

  from pathlib import Path
  

• Méthodes clés :

  • Path("fichier").exists() : vérifie si un fichier existe.
  • Path().cwd() : chemin du répertoire courant.
  • Path().cwd().name : nom du répertoire courant.
  • Path().cwd().parent : répertoire parent.
  • Path().iterdir() : itère sur le contenu du répertoire courant.
  • Path().glob("**/*.py") : recherche récursive de fichiers .py.

• Exemple pour vérifier l’existence d’un fichier :

  if not Path("toto.pdb").exists():
      sys.exit("le fichier est absent")
  

8. Exercices types (extraits)

• Afficher racines carrées de 10 à 20 avec 3 décimales (module math.sqrt).
• Calculer cosinus de $\pi/2$ avec math.cos et math.pi.
• Comparer des sommes de racines carrées à $e$ et $\pi$ avec précision donnée.
• Afficher chemin et contenu du répertoire courant, compter fichiers et dossiers.
• Afficher nombres 1 à 10 avec pause d’une seconde (time.sleep).
• Générer séquence aléatoire de chiffres (1 à 4) avec random.randint.
• Script belote : tirer 8 cartes aléatoires sans remise, calculer total points.
• Générer séquence ADN aléatoire avec random.choice ou random.choices.
• Script ADN aléatoire avec argument longueur, vérification d’argument.
• Améliorer script compteur de lignes avec vérification d’existence fichier.
• Estimer $\pi$ par méthode Monte Carlo avec tirages aléatoires dans un carré.

À retenir : Les modules Python sont des outils essentiels pour réutiliser du code, accéder à des fonctions spécialisées et interagir avec le système ou l’utilisateur. Leur maîtrise facilite la programmation efficace et robuste.

1. Principe et généralités

• Fonction : bloc de code réutilisable qui prend des arguments, effectue une tâche, et renvoie éventuellement un résultat.
• Avantages : réutilisation, modularité, lisibilité.
• Exemple : len([0,1,2]) renvoie la longueur de la liste (ici 3).
• Une fonction peut ne rien renvoyer (retourne None par défaut).
• Le programme principal est le code exécuté hors des fonctions, d'où on appelle les fonctions.

Une fonction est une « boîte noire » : on utilise ses entrées/sorties sans connaître son algorithme interne.

2. Définition

• Syntaxe pour définir une fonction :

  def nom_fonction(arguments):
      bloc_instructions
      return valeur_renvoyée  # facultatif
  

• Le corps de la fonction est indenté.
• Exemple :

  def carre(x):
      return x**2
  

• La valeur renvoyée peut être stockée dans une variable.

3. Passage d’arguments

• Une fonction peut prendre 0, 1 ou plusieurs arguments.
• Python est à typage dynamique : le type des arguments est reconnu à l’exécution.
• Exemple de fonction polymorphe :

  def fois(x, y):
      return x * y
  

  fonctionne avec entiers, floats, chaînes, listes.
• Attention : il est préférable que les arguments aient un type cohérent.

4. Renvoi de résultats

• Une fonction peut renvoyer plusieurs valeurs sous forme d’un tuple ou d’une liste.
• Exemple :

  def carre_cube(x):
      return x**2, x**3  # renvoie un tuple
  

• On peut récupérer plusieurs valeurs simultanément :

  z1, z2 = carre_cube(3)
  

• Une fonction peut aussi renvoyer un booléen (ex. est_pair(x)).

5. Arguments positionnels et arguments par mot-clé

• Exemple d’arguments par défaut :

  def fct(x=1):
      return x
  

• Lors d’un appel, les arguments positionnels doivent toujours précéder les arguments par mot-clé.
• Omettre un argument positionnel obligatoire provoque une erreur.

6. Variables locales et variables globales

• Variable locale : créée dans une fonction, existe uniquement pendant l’exécution de la fonction.
• Variable globale : créée dans le programme principal, accessible partout.
• Lorsqu’une fonction est appelée :
  • Un cadre local est créé pour ses variables locales.
  • Les variables globales restent accessibles mais ne sont pas modifiées sauf déclaration explicite.
• À la fin de la fonction, le cadre local est détruit, les variables locales disparaissent.

7. Principe DRY (Don’t Repeat Yourself)

• Les fonctions évitent la duplication de code, facilitant la maintenance et la correction.
• Exemple : corriger une formule dans une fonction unique évite de modifier plusieurs fois le même code.
• Favorise la modularité et la clarté du programme.

8. Exercices types (à pratiquer)

• Carré et factorielle : définir carre(x) et calc_factorielle(n).
• Puissance : fonction calc_puissance(x, y) renvoyant $x^y$.
• Pyramide : fonction gen_pyramide(N) renvoyant une chaîne représentant une pyramide de N lignes.
• Nombres premiers : fonction est_premier(n) renvoyant True si n est premier.
• Séquence complémentaire ADN : fonction seq_comp(liste) renvoyant la séquence complémentaire.
• Distance 3D : fonction calc_distance_3D() calculant la distance euclidienne entre deux points.
• Distribution et statistiques : générer des listes aléatoires et calculer min, max, moyenne.
• Distance à l’origine 2D : fonction calc_dist2ori() calculant la distance entre points et origine.

Le site Python Tutor est recommandé pour visualiser l’exécution des fonctions et comprendre la portée des variables.

1. Chaînes de caractères et listes

• Une chaîne de caractères est une séquence immuable de caractères, similaire à une liste mais non modifiable.
• On peut accéder aux caractères par indice et utiliser la notation par tranches :
  $s[i:j:k]$ extrait une sous-chaîne de l'indice $i$ à $j-1$ avec un pas $k$.
• Tentative de modification d’un caractère provoque une erreur TypeError.

2. Caractères spéciaux

• Les caractères spéciaux s’écrivent avec un backslash :
  • \n : saut de ligne
  • \t : tabulation
  • \' ou \" : guillemets simples ou doubles échappés
• Les guillemets triples """...""" permettent d’écrire des chaînes sur plusieurs lignes en conservant le formatage.
• Les caractères spéciaux sont interprétés uniquement avec la fonction print().

3. Préfixes de chaîne de caractères (string prefixes)

• Le préfixe doit être collé à la chaîne, sans espace.
• Les f-strings permettent d’insérer des variables directement dans la chaîne.

4. Méthodes courantes des chaînes de caractères

.split() découpe une chaîne en champs selon un séparateur, par défaut tout espace blanc (espace, tabulation, saut de ligne).

5. Extraction et conversion de valeurs numériques

• Pour extraire des nombres dans une chaîne, on utilise .split() puis conversion avec float() ou int() :

  nb1, nb2, _ = chaine.split()
  somme = float(nb1) + float(nb2)
  

• La fonction map() permet d’appliquer une fonction à tous les éléments d’un itérable :

  list(map(int, "1 2 3".split()))  # [1, 2, 3]
  

6. Test d’appartenance

• L’opérateur in teste si une chaîne est contenue dans une autre :

  "abc" in "abcdef"  # True
  

• not in teste l’absence.

7. Conversion liste → chaîne

• La méthode .join() convertit une liste de chaînes en une seule chaîne, avec un séparateur :

  "-".join(["a", "b", "c"])  # "a-b-c"
  

• Tous les éléments doivent être des chaînes, sinon TypeError.

8. Method chaining (chaînage de méthodes)

• On peut enchaîner plusieurs méthodes sur une chaîne, car elles renvoient une nouvelle chaîne :

  message.title().replace("Salut", "Bonjour").split()
  

• Pour plus de lisibilité, on peut découper sur plusieurs lignes avec \ ou parenthèses.

9. Résumé des points clés

Les chaînes de caractères sont des objets riches en méthodes utiles pour manipuler et analyser du texte efficacement.

1. Méthodes associées aux listes

Les listes en Python possèdent plusieurs méthodes permettant de les manipuler efficacement. Une méthode est une fonction attachée à un objet, appelée avec la syntaxe objet.méthode().

a) .append()

• Ajoute un élément à la fin d’une liste.
• Plus concise et lisible que l’opération liste = liste + [élément].

b) .insert()

• Insère un élément à un indice donné : liste.insert(indice, élément).

c) del

• Instruction générale (pas une méthode) pour supprimer un élément à un indice donné : del liste[indice].
• Ne prend pas de parenthèses.

d) .remove()

• Supprime la première occurrence d’une valeur dans la liste.
• Si plusieurs occurrences, appeler .remove() autant de fois que nécessaire.

e) .sort()

• Trie la liste en place (modifie la liste directement) du plus petit au plus grand.
• Argument optionnel reverse=True pour trier du plus grand au plus petit.

f) sorted()

• Fonction qui renvoie une nouvelle liste triée sans modifier la liste d’origine.
• Accepte aussi l’argument reverse=True.

g) .reverse()

• Inverse l’ordre des éléments en place.

h) .count()

• Compte le nombre d’occurrences d’un élément dans la liste.

2. Particularités des méthodes associées aux listes

À retenir : Les méthodes qui modifient la liste le font en place et ne renvoient rien (None). Il ne faut pas écrire var = liste.méthode() pour ces méthodes, car var vaudra None.

3. Résumé des méthodes clés

Exemple d’utilisation :

liste = [3, 1, 2]
liste.append(5)       # [3, 1, 2, 5]
liste.insert(1, 10)   # [3, 10, 1, 2, 5]
liste.remove(1)       # [3, 10, 2, 5]
liste.sort()          # [2, 3, 5, 10]
print(liste.count(3)) # 1
liste.reverse()       # [10, 5, 3, 2]

Note : Pour connaître le détail d’une méthode, utiliser help(liste.methode) en Python. Par exemple, .reverse() modifie la liste in place, ce qui signifie qu’elle ne renvoie rien mais modifie directement la liste.

1. Appel d’une fonction dans une fonction

• Une fonction peut appeler une autre fonction, ou s’appeler elle-même (fonction récursive).
• Les variables locales d’une fonction restent en mémoire tant que la fonction n’a pas terminé son exécution.
• Exemple compact pour tester si un nombre est pair :

  def est_pair(x):
      return x % 2 == 0
  

2. Fonctions récursives

• Une fonction récursive s’appelle elle-même pour résoudre un problème par décomposition.
• Exemple : factorielle définie par
  $n! = n \times (n-1)!$ avec $1! = 1$
  Code Python :

  def calc_factorielle(nb):
      if nb == 1:
          return 1
      else:
          return nb * calc_factorielle(nb - 1)
  

• Les appels récursifs forment une pile d’exécution qui se dépile au retour.

3. Portée des variables (scope)

• Variables locales ne sont pas visibles hors de la fonction.
• Variables globales sont visibles dans le module principal et fonctions, mais ne peuvent pas être modifiées sans global.
• Exemple d’erreur sans global :

  def f():
      x = x + 1  # Erreur UnboundLocalError
  

4. Portée des listes et passage par référence

• Les listes sont des objets mutables : passer une liste à une fonction permet de la modifier in place.
• Exemple :

  def modifie(l):
      l[0] = -1
  
  lst = [1, 2, 3]
  modifie(lst)
  print(lst)  # [-1, 2, 3]
  

• La variable locale dans la fonction et la variable globale pointent vers le même objet liste.
• Pour éviter la modification, passer une copie de la liste :

  ma_fonction(liste[:])  # ou list(liste)
  

5. Règle LGI (Locale, Globale, Interne)

• Lorsqu’une variable est appelée, Python cherche dans l’ordre :
  1. Locale
  2. Globale
  3. Interne (built-in)
• Exemple :

  x = -15
  def f():
      x = 4
      print(x)  # Affiche 4 (locale prioritaire)
  f()
  print(x)  # Affiche -15 (globale)
  

6. Recommandations

• Évitez les variables globales : elles rendent le code difficile à maintenir et à réutiliser.
• Passez les variables explicitement en argument aux fonctions.
• Pour les fonctions modifiant une liste, faites-les retourner la liste modifiée et réaffectez-la :

  def ajoute_un(liste):
      for i in range(len(liste)):
          liste[i] += 1
      return liste
  
  liste_notes = [10, 8, 16]
  liste_notes = ajoute_un(liste_notes)
  

• Indiquez clairement dans la documentation si une fonction modifie une liste in place.
• Décomposez votre programme en fonctions simples, réutilisables et testables.

7. Points clés à retenir

Une fonction peut appeler une autre fonction ou s’appeler elle-même (récursion), les variables locales sont visibles uniquement dans la fonction, les variables globales sont visibles partout mais ne peuvent être modifiées sans global, et les listes passées en argument sont modifiables dans la fonction sauf si on passe une copie.

Pour éviter les effets de bord, évitez les variables globales et préférez passer explicitement les variables aux fonctions, en retournant les résultats modifiés.

8. Exercices proposés (extraits)

• Créer une fonction récursive calculant la factorielle.
• Tester la portée des variables locales et globales.
• Écrire une fonction qui modifie une liste passée en argument et observer l’effet.
• Utiliser la règle LGI pour comprendre la résolution des noms de variables.

1. Généralités sur les conteneurs

• Conteneur : objet Python contenant une collection d’objets (ex. listes, chaînes, dictionnaires, tuples, range).
• Tous les conteneurs supportent :
  • Le test d’appartenance avec in.
  • La fonction len() pour la taille.
• Propriétés générales :
  • Ordonné : éléments dans un ordre précis.
  • Indexable : accès par indice ou tranche.
  • Itérable : on peut faire une boucle dessus.
• Objet séquentiel (séquence) : conteneur itérable, ordonné et indexable (listes, chaînes, range, tuples).
• Mutabilité :
  • Modifiable : listes, dictionnaires.
  • Non modifiable (immuable) : chaînes, tuples, range, entiers, floats, booléens.
• Identifiant : entier unique constant pendant la vie de l’objet, accessible via id().
• Exemple d’immutabilité : réaffecter une variable crée un nouvel objet avec un nouvel identifiant.
• Hachabilité : un objet est hachable s’il a une valeur de hachage via hash().
  • Liée à l’immutabilité.
  • Objets hachables : chaînes, entiers, floats, booléens, range, tuples (si éléments hachables), frozensets.
  • Objets non hachables : listes, sets, dictionnaires.

2. Conteneurs de type range

• Ordonnés, indexables, itérables, hachables, non modifiables.
• Exemple : range(3) → éléments 0,1,2.
• Modification d’un élément provoque une erreur.

3. Dictionnaires : propriétés avancées

• Clés doivent être hachables (ex. chaînes, entiers, floats, tuples hachables).
• Accès rapide via valeur de hachage.
• Suppression d’une paire clé/valeur : del dico[clé].
• Tri par clés : sorted(dico) trie les clés.
• Tri par valeurs : sorted(dico, key=dico.get) trie les clés selon valeurs.
• min(dico, key=dico.get) et max(dico, key=dico.get) donnent la clé associée à la valeur minimale/maximale.
• Fonction dict() convertit un séquence d’objets séquentiels de deux éléments en dictionnaire.
• Combinaison puissante : dict(zip(liste_clés, liste_valeurs)).

4. Tuples

• Séquences immuables, itérables, ordonnées, indexables.
• Immutabilité : modification d’un élément provoque une erreur.
• Pour modifier, il faut créer un nouveau tuple.
• Affectation multiple possible : x, y = ma_fonction().
• Utilisation de _ pour ignorer certaines valeurs lors d’une affectation multiple.
• Tuples contenant des listes sont modifiables via les listes internes (car listes sont mutables), mais le tuple reste immuable (pas de changement d’identifiant).
• Tuples sont hachables seulement si tous leurs éléments sont hachables.
• Fonction tuple() convertit un objet itérable en tuple.

5. Sets et frozensets

• set : conteneur modifiable, non ordonné, non indexable, éléments uniques.
• Création : {4,5,5,12} → {4,5,12}.
• Contient uniquement objets hachables.
• Méthodes principales :
  • .add(elem) ajoute un élément (pas de doublons).
  • .discard(elem) supprime un élément sans erreur si absent.
• Opérations ensemblistes :
  • Union : set1 | set2 ou set1.union(set2).
  • Intersection : set1 & set2 ou set1.intersection(set2).
  • Différence : set1.difference(set2).
• Utilité : éliminer doublons, compter occurrences, opérations ensemblistes.
• frozenset : version immuable et hachable de set.
  • Pas de méthodes de modification.
  • Possède méthodes d’union, intersection, etc.

6. Récapitulatif des propriétés des conteneurs

*Tuple hachable uniquement si tous ses éléments sont hachables.

7. Copie de conteneurs

• Copie par référence pour listes, dictionnaires, sets (modification d’une copie modifie l’original).
• Chaînes de caractères sont une exception (immutables).
• Attention lors de la copie pour éviter effets de bord.

8. Compréhensions

• Dictionnaires de compréhension : {clé: val*2 for clé, val in dico.items()}.
• Sets de compréhension : {i**2 for i in range(10)}.
• Permettent de créer rapidement des conteneurs à partir d’itérables.

9. Module collections

• Contient des conteneurs avancés :
  • OrderedDict : dictionnaire ordonné (avant Python 3.7).
  • defaultdict : dictionnaire avec valeur par défaut pour clés absentes.
  • Counter : compteur d’éléments d’un itérable, se comporte comme dictionnaire avec valeur 0 pour clés absentes.
  • namedtuple : tuple nommé (voir chapitre 24).

Un objet Python est un conteneur si il contient une collection d’objets et supporte in et len(). Les conteneurs peuvent être ordonnés, indexables, itérables, modifiables ou non, et hachables ou non. Les propriétés clés à retenir sont la mutabilité et la hachabilité, qui conditionnent leur usage dans les dictionnaires et sets.

1. Pourquoi créer ses propres modules ?

• Un module regroupe un ensemble de fonctions (et constantes) réutilisables dans plusieurs programmes.
• Permet d’éviter la duplication de code et facilite la maintenance.
• Les modules sont souvent thématiques (ex : analyse de séquences biologiques, gestion de fichiers).

2. Création d’un module

• Un module Python est un fichier .py contenant des fonctions et/ou constantes.
• Exemple minimal de module message.py :

"""Module inutile qui affiche des messages."""

DATE = "2024-01-05"

def bonjour(nom):
    """Dit Bonjour."""
    return f"Bonjour {nom}"

def ciao(nom):
    """Dit Ciao."""
    return f"Ciao {nom}"

def hello(nom):
    """Dit Hello."""
    return f"Hello {nom}"

• Les docstrings (chaînes entre triple guillemets) documentent le module et ses fonctions.
• Par convention, les constantes sont en MAJUSCULES.

3. Utilisation de son propre module

• Le fichier .py doit être dans le répertoire courant ou dans un dossier listé dans la variable d’environnement PYTHONPATH.
• Pour ajouter un chemin à PYTHONPATH :

• Vérification de PYTHONPATH :

• Importer le module sans extension .py :

import message

• Utilisation des fonctions et constantes :

message.hello("Joe")    # 'Hello Joe'
message.ciao("Bill")    # 'Ciao Bill'
message.bonjour("Monsieur")  # 'Bonjour Monsieur'
message.DATE            # '2024-01-05'

• Lors du premier import, Python crée un dossier __pycache__ contenant un fichier .pyc (bytecode précompilé).

4. Les docstrings

• Les docstrings sont des chaînes de documentation placées en début de module et de fonction.
• Elles expliquent le rôle du module/fonction et facilitent la compréhension et l’utilisation du code.
• Elles sont accessibles via la fonction help() ou l’attribut .__doc__.

Créer un module consiste à écrire un fichier .py avec des fonctions et constantes, documentées par des docstrings, puis à l’importer pour réutiliser ce code dans plusieurs programmes.

1. Docstrings et aide intégrée

• Docstrings : chaînes de documentation placées en début de modules, fonctions, classes ou méthodes.
• Permettent d’afficher une aide via la fonction help().
• Diffèrent des commentaires : docstrings sont destinées aux utilisateurs, commentaires aux développeurs.
• Une bonne docstring de fonction doit contenir :
  • Ce que fait la fonction,
  • Ses arguments,
  • Ce qu’elle renvoie.

2. Visibilité des fonctions dans un module

• Fonctions d’un même module peuvent s’appeler entre elles.
• Fonctions d’un module peuvent appeler celles d’un autre module importé via import module.
• Appel d’une fonction d’un autre module : module.fonction().

3. Modules vs scripts

• Un module sans programme principal n’exécute rien à l’import.
• Pour qu’un script puisse être utilisé comme module ou script, utiliser la condition :

if __name__ == "__main__":
    # code exécuté seulement si script lancé directement

4. PEP et code pythonique

• PEP (Python Enhancement Proposal) : propositions d’amélioration du langage et recommandations.
• PEP 8 : guide de style incontournable pour écrire un code Python lisible.
• Code pythonique : code respectant les règles et usages recommandés par la communauté Python.

1. Pour finir : la PEP 20 (Zen of Python)

• Accessible via import this.
• Principes clés :
  • Beautiful is better than ugly.
  • Explicit is better than implicit.
  • Simple is better than complex.
  • Readability counts.
  • There should be one—and preferably only one—obvious way to do it.
  • Namespaces are one honking great idea—let's do more of those!

À retenir : Le code Python doit être lisible, explicite, simple et organisé selon les conventions de la communauté pour faciliter sa maintenance et sa compréhension.

1. Expressions régulières (regex) : définition et syntaxe

• Expression régulière : suite de caractères décrivant un fragment de texte, appelée aussi motif ou pattern.
• Composée de :
  • Caractères normaux (ex. lettres, chiffres)
  • Métacaractères (ex. ^, $, ., *, +, ?, {n,m}, |, [], \), qui ont une signification spéciale.

Caractères spéciaux raccourcis :

Les métacaractères + et * sont avides (greedy) : ils capturent le maximum possible.

2. Le module re en Python

a) Fonction search(motif, chaine)

• Recherche la première occurrence du motif regex dans la chaîne.
• Renvoie un objet SRE_Match si trouvé, sinon None.
• Exemple :

import re
re.search("tigre", "girafe tigre singe")  # objet SRE_Match

b) Fonctions match() et fullmatch()

Exemple :

re.match("tigre", "tigre singe")    # match
re.fullmatch("tigre", "tigre")     # fullmatch

Pour simuler match() avec search(), utilisez ^ en début de motif. Pour fullmatch(), utilisez ^motif$.

c) Compilation d'expressions régulières

• re.compile(motif) crée un objet regex compilé, plus efficace pour réutilisation.
• Utilisation : regex = re.compile("^tigre"), puis regex.search(chaine).

d) Groupes dans les regex

• Parenthèses () créent des groupes capturés.
• Exemple : ([0-9]+)\.([0-9]+) capture un nombre décimal.
• Méthodes sur l'objet SRE_Match :
  • .group(0) : correspondance complète
  • .group(1), .group(2), ... : groupes capturés
  • .start(), .end() : indices de début et fin de la correspondance

e) Méthode findall()

• Renvoie une liste de toutes les correspondances dans la chaîne.
• Si groupes capturés, renvoie une liste de tuples.
• Exemple :

regex = re.compile("([0-9]+)\.([0-9]+)")
regex.findall("pi vaut 3.14 et e vaut 2.72")  # [('3', '14'), ('2', '72')]

f) Méthode sub()

• Remplace toutes les occurrences du motif dans une chaîne par une autre chaîne.
• Syntaxe : regex.sub(remplacement, chaine, count=n) (optionnel count limite le nombre de remplacements).
• Utilisation des groupes capturés dans la chaîne de remplacement avec \\1, \\2, etc.
• Exemple :

regex = re.compile("([0-9]+)\.([0-9]+)")
regex.sub("approximativement \\1", "pi vaut 3.14 et e vaut 2.72")
# 'pi vaut approximativement 3 et e vaut approximativement 2'

En Python, il faut doubler le backslash \\ pour référencer un groupe capturé dans la chaîne de remplacement.

3. Vocabulaire utile

• Matcher (to match) : dire qu'une regex "fonctionne" sur une chaîne, c'est qu'elle correspond ou est retrouvée.
• Parsing : analyse syntaxique, extraction d'informations dans des fichiers via regex.

4. Ressources en ligne recommandées

• RegexOne : tutoriel interactif
• RegExr et ExtendsClass : visualisation des correspondances
• pythex.org : testeur simple dédié à Python
• Regular-Expressions.info : documentation exhaustive

À retenir : Les expressions régulières sont un outil puissant pour extraire et manipuler du texte, notamment en bioinformatique pour le parsing de fichiers complexes. Le module re de Python offre des fonctions essentielles (search, match, fullmatch, compile, findall, sub) pour exploiter ces motifs efficacement.

1. Notebooks Jupyter

• Notebooks Jupyter : documents interactifs combinant texte (Markdown), images, formules, tableaux, graphiques et code exécutable.
• Supportent près de 40 langages, initialement Julia, Python, R.
• Cellule : unité de base, contient soit du texte Markdown, soit du code exécutable.

2. Installation

• Avec Miniconda :

  conda install -c conda-forge -y jupyterlab
  

• Installe JupyterLab, un environnement complet.

3. JupyterLab

• Interface web accessible via la commande :

  jupyter lab
  

• Offre un navigateur de fichiers, un lanceur d’outils (notebooks, terminaux, éditeurs).
• Permet d’organiser plusieurs documents et terminaux dans une même interface.

4. Création et utilisation d’un notebook

• Créer un notebook via le bouton Python 3 dans le Launcher.
• Renommer le notebook en cliquant sur Untitled.ipynb.
• Extension des fichiers : .ipynb.
• Exécution d’une cellule :
  • Menu Run > Run Selected Cells
  • Bouton ▶️
  • Raccourci Ctrl + Entrée
• Numérotation à gauche indique l’ordre d’exécution (ex : [1]).
• Ajouter une cellule :
  • Bouton +
  • Icône dans la cellule
  • Raccourci Alt + Entrée (exécute et crée une nouvelle cellule)
• Variables et fonctions définies dans une cellule sont accessibles dans les suivantes.
• Recommandation : redémarrer et exécuter toutes les cellules régulièrement via
  Kernel > Restart Kernel and Run All Cells pour éviter les confusions d’état.

5. Format Markdown dans les cellules

• Permet d’écrire du texte formaté (titres, gras, italique, liens, images, formules).
• Passer une cellule en mode Markdown via le menu déroulant (par défaut Code).
• Markdown est simple et rapide pour structurer du texte.
• Exemple d’usage : rédaction de cours, documentation.

6. Graphiques dans les notebooks

• Intégration facile de graphiques avec la bibliothèque matplotlib.
• %matplotlib inline permet d’afficher les graphiques dans le notebook (souvent automatique dans les versions récentes).

7. Magic commands

• Commandes spéciales commençant par % (ligne) ou %% (cellule) pour fonctionnalités avancées.

• Exemple :

  %%timeit
  for x in liste:
      pass
  

8. Lancement de commandes Unix

• Préfixer une commande par ! pour l’exécuter dans le shell depuis un notebook.
• Exemple :

  !ls
  

  affiche le contenu du répertoire courant.

À retenir : Un notebook Jupyter combine code, texte et graphiques dans un environnement interactif, facilitant l’analyse de données et la documentation. Les magic commands et le lancement de commandes Unix enrichissent son usage.

1. Installation et chargement de Biopython

• Biopython n’est pas inclus dans Python de base.
• Installation recommandée avec Miniconda :
  $ conda install -c conda-forge biopython
• Chargement du module :
  import Bio
  Attention : le nom du module est Bio (avec un B majuscule).

2. Manipulation de séquences avec Biopython

• Import de la classe Seq :
  from Bio.Seq import Seq
• Création d’une séquence ADN :
  ADN = Seq("ATATCGGCTATAGCATGC") (type Seq)
• Opérations sur séquences ADN :

3. Interrogation de la base PubMed avec Biopython

• Sous-module utilisé : Bio.Entrez
• Obligatoire : définir l’email utilisateur
  Entrez.email = "votremail@provider.fr"
• Recherche d’articles (exemple "transferrin") :

  req = Entrez.esearch(db="pubmed", term="transferrin")
  res = Entrez.read(req)
  

• Résultat res contient plusieurs clés importantes :

• Pour augmenter le nombre d’articles retournés, utiliser retmax dans esearch.

4. Récupération des métadonnées d’un article PubMed

• Exemple avec PMID = "22294463" :

  req_sum = Entrez.esummary(db="pubmed", id="22294463")
  res_sum = Entrez.read(req_sum)
  

• res_sum[0] est un dictionnaire avec clés utiles :

5. Récupération du résumé d’un article PubMed

• Utilisation de Entrez.efetch() :

  req_fetch = Entrez.efetch(db="pubmed", id="22294463", rettype="abstract", retmode="text")
  print(req_fetch.read())
  

• Le résumé est renvoyé en texte brut, avec \n pour les retours à la ligne.

6. Exercices clés

a) Calcul du pourcentage de GC dans des séquences FASTA

• Pourcentage GC d’une séquence : $$\text{pourcentage GC} = \frac{\text{nombre de G} + \text{nombre de C}}{\text{longueur de la séquence}} \times 100$$
• Stocker les résultats dans un dictionnaire : clés = identifiants des gènes, valeurs = pourcentage GC.
• Afficher :
  • Nombre total de gènes
  • Identifiant et valeur du gène avec le plus haut %GC
  • Identifiant et valeur du gène avec le plus bas %GC

b) Analyse bibliographique sur PubMed avec Biopython

1. Requête simple : compter les articles sur "barstar" avec Entrez.esearch().
2. Récupération d’un article précis (ex : PMID 29701945) avec Entrez.esummary() : afficher titre, DOI, journal, date.
3. Récupération du résumé avec Entrez.efetch().
4. Distribution des années de publication :
   • Récupérer tous les PMIDs avec retmax augmenté.
   • Pour chaque PMID, récupérer la date de publication avec Entrez.esummary().
   • Extraire l’année et compter le nombre d’articles par année dans un dictionnaire.
   • Trier les années et préparer deux listes : années (x), nombre d’articles (y).
5. Visualisation avec matplotlib :

   import matplotlib.pyplot as plt
   fig, ax = plt.subplots()
   ax.bar(x, y)
   ax.set_xlabel("Années")
   ax.set_ylabel("Nombre de publications")
   ax.set_title("Distribution des publications mentionnant la barstar")
   fig.savefig("distribution_barstar_annee.png")
   

À retenir : Biopython permet de manipuler facilement des séquences biologiques et d’interroger des bases de données comme PubMed, facilitant ainsi l’analyse bioinformatique et bibliographique automatisée.

1. Installation et chargement

• Installation via Miniconda :

  conda install -c conda-forge numpy
  

• Chargement du module :

  import numpy as np
  

2. Objets array

• Un array est un tableau multidimensionnel homogène (mêmes types d’éléments).
• Création :

  np.array([1, 2, 3])  # à partir d’une liste, tuple ou range
  

• Conversion automatique des types :
  • mélange int et float → float
  • mélange int et str → str
• Fonction arange() : similaire à range() mais retourne un array et accepte float.
  Exemple :

  np.arange(10)       # array([0, 1, ..., 9])
  np.arange(10.0)     # array([0., 1., ..., 9.])
  np.arange(10, 0, -1) # array([10, 9, ..., 1])
  

3. Dimensions et attributs

• Un array 1D = vecteur, 2D = matrice, nD = tenseur.

4. Redimensionnement

• Méthode .reshape(new_shape) : retourne un nouvel array avec la forme demandée, compatible en nombre d’éléments.
• Méthode .resize(new_shape, refcheck=False) : modifie en place, ajoute des zéros ou tronque si nécessaire.
• Fonction np.resize(array, new_shape) : retourne un nouvel array, répète les données si besoin.

5. Affichage

• Affichage direct dans Jupyter montre array([...]) avec crochets et virgules.
• Avec print(), les crochets et virgules disparaissent, ce qui peut prêter à confusion avec les listes.

6. Opérations vectorielles élément par élément

• Les opérations sur array s’appliquent élément par élément :

  v = np.arange(4)  # array([0,1,2,3])
  v + 1            # array([1,2,3,4])
  v * 2            # array([0,2,4,6])
  v * v            # array([0,1,4,9])
  

• Pas besoin de boucles explicites.

7. Indexation et slicing

• Pour un array 1D :

  a[1]      # élément d’indice 1
  a[5:]     # tranche à partir de l’indice 5
  a[::2]    # éléments avec pas 2
  

• Pour un array 2D (matrice) :
  • a[i, :] : ligne i
  • a[:, j] : colonne j
  • a[i, j] : élément ligne i, colonne j
• Si un seul indice est donné sur un 2D, on récupère la ligne correspondante.

8. Copie d’array

• Affectation simple copie par référence :

  b = a
  b[2] = -300  # modifie aussi a
  

• Pour créer une copie indépendante :

  b = np.array(a)           # copie distincte
  import copy
  c = copy.deepcopy(a)      # copie profonde
  

9. Construction automatique de matrices

10. Chargement et sauvegarde de fichiers

• Lecture :

  np.loadtxt("fichier.dat")
  

  • Fichier texte avec lignes et colonnes numériques homogènes.
  • Convertit en array 2D de floats.
  • Arguments utiles : delimiter, skiprows, usecols.
• Écriture :

  np.savetxt("out.dat", array)
  

  • Par défaut écrit en float, notation scientifique.
  • Options pour changer format, séparateurs.

11. Concaténation d’arrays

• Pour concaténer des arrays 1D :

  np.concatenate((a1, a2))
  

• Pour concaténer des arrays 2D, préciser l’axe :
  • axis=0 concatène par lignes (ajoute des lignes)
  • axis=1 concatène par colonnes (ajoute des colonnes)
• Exemple :

  np.concatenate((a1, a2), axis=0)  # concat lignes
  np.concatenate((a1, a2), axis=1)  # concat colonnes
  

12. Algèbre linéaire

• Tri des valeurs propres par ordre décroissant :

  idx = eigvals.argsort()[::-1]
  eigvals = eigvals[idx]
  eigvecs = eigvecs[:, idx]
  

13. Parcours et affectation

• Itération sur les lignes d’un array 2D :

  for row in a:
      print(row)  # row est un array 1D
  

• Itération sur les colonnes :

  for col in a.T:
      print(col)
  

• Affectation multiple sur lignes :

  a1, a2, a3 = a
  

• Affectation multiple sur colonnes :

  c1, c2, c3 = a.T
  

14. Masques booléens

• Un masque booléen est un array de booléens utilisé pour sélectionner/modifier des éléments d’un array.
• Création d’un array booléen par comparaison :

  mask = (a > 5)
  

• Sélection d’éléments :

  a[a > 5]  # renvoie un array 1D des éléments > 5
  

• Modification conditionnelle :

  a[a > 5] = -1
  

• Combinaison de conditions avec & (ET) et | (OU) :

  a[(a > 3) & (a % 2 == 0)] = 0
  

• Attention :
  • Utiliser des parenthèses autour de chaque condition.
  • & et | s’appliquent aux arrays, pas and/or.

15. Conseils d’utilisation

• Documenter soigneusement les arrays (contenu, dimension).
• Utiliser np.concatenate() pour concaténer de gros arrays, pas pour ajouter ligne par ligne.

À retenir : Le module NumPy est la base du calcul scientifique en Python, offrant des structures et opérations optimisées pour les données numériques multidimensionnelles.

1. Installation et import

• Installation via conda (Miniconda) :

  conda install -c conda-forge matplotlib
  

• Import standard :

  import matplotlib.pyplot as plt
  

  On importe le sous-module pyplot avec l’alias plt (convention).

2. Représentation en nuage de points (scatter plot)

Données fictives : concentration (mg/L) en fonction du temps (h).

Code essentiel :

fig, ax = plt.subplots()                      # création figure et axe
ax.scatter(temps, concentration, marker="o", color="blue")  # nuage de points
ax.set_xlabel("Temps (h)")                    # légende axe x
ax.set_ylabel("Concentration (mg/L)")        # légende axe y
ax.set_title("Concentration de produit en fonction du temps")  # titre
plt.show()                                   # affichage graphique

• .scatter(x, y, marker, color) : trace un nuage de points.
• .set_xlabel(), .set_ylabel(), .set_title() : ajout de labels et titre.
• plt.show() : affiche le graphique (indispensable hors notebook Jupyter).

3. Structure du graphique avec matplotlib

À retenir : Le sous-module pyplot de matplotlib, importé sous l’alias plt, est la base pour créer et personnaliser des graphiques en Python.

1. Installation et importation

• pandas : module pour l’analyse et manipulation de données tabulaires.
• Installation via conda :
  $ conda install -c conda-forge pandas
• Import conventionnel :
  import pandas as pd

2. Series

• Objet 1D indexé, similaire à un vecteur avec étiquettes.
• Création :
  s = pd.Series([10, 20, 30, 40], index=['a', 'b', 'c', 'd'])
• Accès par étiquette : s["a"]
• Accès par position : s.iloc[0]
• Sélection multiple : s[["b", "d"]] ou s.iloc[[1, 3]]
• Modification/ajout : s["c"] = 300, s["z"] = 50
• Filtrage avec conditions booléennes :
  s[s > 30], combinaisons avec & (ET), | (OU)

3. Dataframes

• Tableau 2D avec étiquettes pour lignes et colonnes.
• Création à partir de liste de lignes :

  df = pd.DataFrame(columns=["a", "b", "c", "d"],
                    index=["chat", "singe", "souris"],
                    data=[np.arange(10,14), np.arange(20,24), np.arange(30,34)])
  

• Création à partir d’un dictionnaire de colonnes :

  data = {"a": np.arange(10,40,10), "b": np.arange(11,40,10), "c": np.arange(12,40,10), "d": np.arange(13,40,10)}
  df = pd.DataFrame(data)
  df.index = ["chat", "singe", "souris"]
  

• Propriétés clés :
  • df.shape : dimensions (lignes, colonnes)
  • df.columns : noms des colonnes (modifiable)
  • df.head(n) : premières lignes (par défaut 5)

4. Sélections dans Dataframes

5. Combinaison de Dataframes

• pd.concat([df1, df2], axis=1) : concatène horizontalement en alignant sur les index.
• join="inner" : conserve uniquement les index communs.
• Valeurs manquantes indiquées par NaN.

6. Opérations vectorielles

• Éviter les boucles sur les lignes (.iterrows()) pour modifier un DataFrame, car lent.
• Privilégier les opérations sur colonnes entières :
  df["d"] = df["a"] * df["b"] + df["c"]
• Gain de temps significatif (exemple : 200x plus rapide).

7. Exemple concret : analyse de données kinases

• Chargement CSV :
  df = pd.read_csv("kinases.csv", index_col="Entry")
• Exploration :
  • df.shape : (1442, 5)
  • df.dtypes : types des colonnes
  • df.info() : résumé avec non-null counts et mémoire utilisée
• Recherche valeurs manquantes :
  df.isna().sum()
  → Colonne PDB contient 954 NaN.
• Conversion de colonnes en dates :
  df["Creation date"] = pd.to_datetime(df["Creation date"])
• Statistiques descriptives :
  df.describe() pour colonnes numériques
  df["Organism"].value_counts() pour décompte par catégorie
• Statistiques par groupe :
  df.groupby("Organism")[["Length", "Mass"]].mean()
df.pivot_table(index="Organism", values=["Length", "Mass"], aggfunc=["min", "max"])
• Visualisation :
  • Nuage de points masse vs taille :
    df.plot(kind="scatter", x="Length", y="Mass")
  • Régression linéaire avec scipy.stats.linregress pour modéliser la relation.
• Analyse temporelle :
  • Dates min/max par organisme avec pivot_table
  • Comptage par année avec .value_counts().resample("YE").sum()
  • Tri et affichage des années avec le plus de kinases référencées.
• Transformation de colonnes :
  • Compter structures 3D dans PDB (séparées par ;) avec fonction personnalisée et .apply()
  • Tri par nombre de structures 3D.

À retenir : pandas facilite la manipulation, l’analyse et la visualisation de données tabulaires grâce à ses objets Series et Dataframes, ses méthodes de sélection puissantes, ses opérations vectorielles rapides et son intégration avec matplotlib et scipy pour l’analyse statistique.

1. Programmation orientée objet (POO) : notions clés

• Objet : entité regroupant des attributs (données) et des méthodes (fonctions agissant sur ces données).
• Classe : modèle ou moule servant à créer des objets (instances).
• Instance : objet concret créé à partir d’une classe.
• En Python, tout est objet : les types int, float, str, list, etc. sont des instances de classes correspondantes.

2. Avantages de la POO

• Encapsulation : chaque objet possède son propre espace de noms, isolant ses attributs et méthodes.
• Réutilisabilité : code plus compact et modulaire.
• Concepts avancés :
  • Polymorphisme : redéfinition du comportement des opérateurs ou méthodes selon le type d’objet.
  • Héritage : création d’une classe dérivée à partir d’une classe existante, avec ajout ou modification de fonctionnalités.

3. Terminologie essentielle

La POO structure le code en regroupant données et comportements dans des objets, facilitant la maintenance et l’évolution des programmes.

4. Remarque

La maîtrise de la POO demande de la pratique et une bonne compréhension des concepts. Des langages comme UML aident à formaliser la conception orientée objet.

1. Construction d’une classe

• Une classe est un modèle définissant un type d'objet avec ses attributs (données) et ses méthodes (fonctions).
• En Python, une classe se déclare avec le mot-clé class suivi du nom de la classe en CamelCase.
• La méthode spéciale __init__(self, ...) est le constructeur qui initialise les attributs lors de la création d’une instance.
• self représente l’instance courante et permet d’accéder à ses attributs et méthodes.

2. Exemple minimal de classe

class Personne:
    def __init__(self, nom, age):
        self.nom = nom
        self.age = age

• Ici, Personne a deux attributs : nom et age.
• Pour créer une instance : p = Personne("Alice", 30).

3. Concepts clés de la POO

4. Bonnes pratiques pour les classes en Python

• Nommer les classes en CamelCase (ex : MaClasse).
• Utiliser self comme premier paramètre des méthodes d’instance.
• Préférer des méthodes courtes et claires.
• Documenter les classes et méthodes avec des docstrings.
• Éviter les attributs publics modifiables directement, préférer des méthodes d’accès (getters/setters) si besoin.
• Utiliser l’héritage avec modération pour ne pas complexifier inutilement la hiérarchie.

5. À retenir

Une classe est un plan pour créer des objets, regroupant données et comportements, facilitant la modélisation et la réutilisation du code en programmation orientée objet.

1. Fenêtres graphiques et Tkinter

a) Introduction à Tkinter

• Tkinter est le module standard de Python pour créer des interfaces graphiques (GUI).
• Il permet de créer des fenêtres, d’y placer des widgets (boutons, labels, champs de saisie, etc.) et de gérer les interactions utilisateur.

2. Concepts clés de Tkinter

3. Création d’une fenêtre simple avec Tkinter

import tkinter as tk

fenetre = tk.Tk()               # Création de la fenêtre principale
fenetre.title("Ma fenêtre")     # Titre de la fenêtre
fenetre.geometry("300x200")     # Taille de la fenêtre (largeur x hauteur)

label = tk.Label(fenetre, text="Bonjour Tkinter !")  # Création d’un label
label.pack()                   # Placement du label dans la fenêtre

fenetre.mainloop()             # Lancement de la boucle d’événements

• Tk() crée la fenêtre principale.
• Label est un widget affichant du texte.
• pack() place le widget dans la fenêtre.
• mainloop() lance la boucle d’événements, indispensable pour que la fenêtre reste affichée.

4. Gestion des événements

• Les widgets peuvent réagir aux actions utilisateur via des callbacks (fonctions liées à un événement).
• Exemple : bouton qui affiche un message lorsqu’on clique dessus.

def clic_bouton():
    print("Bouton cliqué !")

bouton = tk.Button(fenetre, text="Cliquez-moi", command=clic_bouton)
bouton.pack()

• L’argument command du bouton reçoit une fonction à appeler lors du clic.

5. Organisation des widgets

6. Exemple d’une classe Tkinter

• Pour structurer une application Tkinter, on crée souvent une classe qui hérite de tk.Tk ou tk.Frame.
• Cela permet d’encapsuler la création des widgets et la gestion des événements.

import tkinter as tk

class Application(tk.Tk):
    def __init__(self):
        super().__init__()
        self.title("Application Tkinter")
        self.geometry("300x200")
        self.creer_widgets()

    def creer_widgets(self):
        self.label = tk.Label(self, text="Bonjour !")
        self.label.pack()
        self.bouton = tk.Button(self, text="Quitter", command=self.destroy)
        self.bouton.pack()

if __name__ == "__main__":
    app = Application()
    app.mainloop()

• self.destroy ferme la fenêtre.
• La méthode creer_widgets organise la création et le placement des widgets.

7. Résumé des bonnes pratiques

• Encapsuler la fenêtre et les widgets dans une classe pour faciliter la maintenance.
• Utiliser mainloop() pour lancer la boucle d’événements.
• Utiliser les méthodes pack(), grid() ou place() selon le besoin de positionnement.
• Associer les événements utilisateur à des fonctions via l’argument command ou les bindings d’événements.
• Éviter les variables globales en stockant les widgets et données dans la classe.

À retenir : Tkinter permet de créer des interfaces graphiques en Python en combinant une fenêtre principale, des widgets, et une boucle d’événements. La programmation orientée objet facilite la gestion et la modularité des interfaces.

1. Héritage en Python

• Héritage : une classe fille hérite des propriétés et méthodes d’une classe mère. En Python, l’héritage peut être multiple.
• Syntaxe :

  class Fille(Mere1, Mere2):
      pass
  

• Une instance de la classe fille est aussi une instance de la classe mère :

  isinstance(fille, Mere) == True
  

• Redéfinition de méthode (overriding) : si une méthode est définie dans la classe fille avec le même nom que dans la mère, celle de la fille est prioritaire.
• Python ne supporte pas la surcharge de fonction (plusieurs définitions selon le nombre/type d’arguments).

2. Ordre de résolution des noms (MRO)

• Lors d’un appel d’attribut ou méthode, Python cherche dans :
  1. La classe fille
  2. La première classe mère et ses ancêtres
  3. La deuxième classe mère et ses ancêtres
  4. …
• La classe interne object est la classe ancêtre implicite de toutes les classes Python.

3. Composition

• Composition : une classe contient des instances d’autres classes (relation has a).
• Plus flexible que l’héritage car les classes sont faiblement couplées.
• Exemple : une classe Citron contient une instance de la classe Pulpe.
• Choix entre héritage (is a) et composition (has a) selon la relation logique entre classes.

4. Attributs de classe vs attributs d’instance

• Exemple de modification masquée :

  citron1.saveur = "sucrée"  # crée un attribut d’instance, n’écrase pas l’attribut de classe
  del citron1.saveur         # supprime l’attribut d’instance, revient à l’attribut de classe
  

5. Contrôle d’accès aux attributs : getters, setters et property

• Python est permissif : on peut accéder/modifier directement les attributs d’instance.
• Getters et setters classiques (méthodes .get_x(), .set_x()) sont lourds et non pythonique.
• Classe property : permet de garder la syntaxe simple instance.attribut tout en contrôlant accès, modification et suppression via des méthodes.
• Syntaxe classique :

  attribut = property(fget=get_attribut, fset=set_attribut, fdel=del_attribut)
  

• Syntaxe pythonique avec décorateurs :

  @property
  def attribut(self):
      return self._attribut
  
  @attribut.setter
  def attribut(self, valeur):
      # contrôle
      self._attribut = valeur
  
  @attribut.deleter
  def attribut(self):
      del self._attribut
  

• L’attribut réel est stocké dans une variable privée _attribut (underscore).

6. Attributs publics et non publics

• Python ne possède pas d’attributs privés stricts, mais une convention :
  • _attribut : non public, à ne pas utiliser en dehors de la classe
  • __attribut : déclenche le name mangling (renommage interne pour éviter conflits en héritage)
• Le name mangling transforme self.__attribut en self._NomClasse__attribut.
• Cette convention n’empêche pas l’accès ou la modification, c’est un avertissement aux utilisateurs.

7. Docstrings dans les classes

• Les classes, méthodes et fonctions peuvent contenir des docstrings pour documenter leur usage.
• Accessible via help(instance) ou instance.__doc__.
• Important pour la maintenance et l’utilisation correcte des classes.

8. Bonnes pratiques pour les classes

• Ne pas utiliser d’attributs de classe modifiables (listes, dictionnaires) car partagés entre instances.
• Initialiser les attributs modifiables dans __init__ (attributs d’instance).
• Utiliser property avec parcimonie, uniquement pour contrôler les attributs sensibles.
• Documenter clairement les attributs et méthodes avec des docstrings.
• Pour stocker des données simples non modifiables, préférer les namedtuple.
• Pour des conteneurs modifiables avec moins de code, utiliser les dataclasses (Python 3.7+).

9. namedtuple

• Conteneur immuable avec accès aux éléments par nom :

  from collections import namedtuple
  Citron = namedtuple("Citron", "masse couleur saveur forme")
  c = Citron(10, "jaune", "acide", "ellipsoide")
  print(c.masse)  # 10
  

• Immuable : modification impossible, mais on peut créer une nouvelle instance avec _replace().

10. dataclasses

• Classes simplifiées pour conteneurs modifiables avec génération automatique de __init__, __repr__, etc.

  from dataclasses import dataclass, field
  
  @dataclass
  class Citron:
      humidite: int
      couleur: str = "jaune"
      saveur: str = "acide"
      masse: int = 100
      pepins: list = field(default_factory=list)
  

• Permet d’éviter les erreurs liées aux valeurs par défaut mutables.

À retenir :

• L’héritage permet de réutiliser et spécialiser des classes, la composition favorise la flexibilité.
• Les attributs de classe sont partagés, les attributs d’instance sont propres à chaque objet.
• Utilisez property pour contrôler l’accès aux attributs tout en gardant une syntaxe simple.
• Respectez les conventions d’attributs non publics (_ et __) pour la clarté du code.
• Documentez vos classes avec des docstrings pour faciliter leur utilisation et maintenance.

1. Mini-projets en Python

2. Description des projets

a) Mots anglais dans le protéome humain

• Objectif : Vérifier si des mots anglais courants apparaissent dans les séquences du protéome humain (ensemble des protéines humaines).

• Données fournies :

  • english-common-words.txt : liste des 3 000 mots anglais les plus fréquents, un mot par ligne.
  • human-proteome.fasta : séquences du protéome humain au format FASTA (format texte standard pour séquences biologiques).

• Remarques :

  • Le fichier FASTA est volumineux.
  • Le fichier provient de la base UniProt.
  • Le format FASTA contient des séquences d'acides aminés précédées d'une ligne d'en-tête commençant par >.

• Conseil : Se référer aux explications sur le format FASTA et aux exemples de code fournis pour manipuler ces fichiers efficacement.

À retenir : Ce projet permet de manipuler des fichiers texte volumineux, d'extraire et de comparer des chaînes de caractères, tout en s'initiant à la bioinformatique avec Python.

1. Formats de données en biologie essentiels

a) Format FASTA

• Usage : Stockage de séquences d’ADN, ARN ou protéines.

• Structure :

  • Première ligne : commence par > suivie d’une description (ligne d’en-tête).
  • Lignes suivantes : séquence répartie sur plusieurs lignes (max 60-80 caractères par ligne).

• Multifasta : fichier contenant plusieurs séquences FASTA successives.

• Extensions courantes : .fasta, .fas, .fna, .faa, .seq.

• Exemple :

  >sp|P01308|INS_HUMAN Insulin OS=Homo sapiens OX=9606 GN=INS PE=1 SV=1
  MALWMRLLPLLALLALWGPDPAAAFVNQHLCGSHLVEALYLVCGERGFFYTPKTRREAED
  LQVGQVELGGGPGAGSLQPLALEGSLQKRGIVEQCCTSICSLYQLENYCN
  

• Manipulation Python : lecture ligne par ligne, identification des lignes d’en-tête (>), stockage dans dictionnaire {id: séquence}.

b) Format GenBank

• Usage : banque de séquences nucléiques avec annotations complètes.
• Structure :
  • En-tête (LOCUS, DEFINITION, ACCESSION, VERSION, SOURCE, ORGANISM, etc.).
  • Section FEATURES décrivant gènes, CDS, peptides signal, etc.
  • Séquence nucléotidique entre les balises ORIGIN et //.
• Notation des gènes :
  • Sens direct : gene 58..272 ou gene <2480..>2707.
  • Sens complémentaire (antisens) : gene complement(55979..56935).
  • < indique un gène partiel 5’, > un gène partiel 3’.
• Extraction séquence : lire entre ORIGIN et //, supprimer chiffres et espaces.
• Manipulation Python : lecture ligne par ligne, extraction des gènes et positions, extraction de la séquence complète, construction de la séquence complémentaire inverse.

c) Format PDB (Protein Data Bank)

• Usage : structures tridimensionnelles de biomolécules (protéines, ADN, ARN).
• Structure :
  • En-tête : informations lisibles (nom, date, méthode expérimentale, chaînes, etc.).
  • Coordonnées atomiques : lignes commençant par ATOM ou HETATM avec coordonnées x, y, z.
• Hiérarchie : structure > modèle > chaîne > résidu > atome.
• Exemple d’extraction : coordonnées des carbones α (CA) des résidus.
• Manipulation Python : lecture ligne par ligne, extraction par tranches de chaîne, conversion en float/int, utilisation possible de Biopython.

d) Formats XML, CSV et TSV

• XML :

  • Format hiérarchique à balises <balise>contenu</balise>.
  • Permet de stocker des données complexes (ex : fichiers UniProt).
  • Manipulation avec lxml.etree en Python.
  • Exemple : extraction des noms de gènes et séquences dans un fichier UniProt XML.

• CSV (Comma-Separated Values) :

  • Données tabulaires, valeurs séparées par des virgules.
  • Première ligne : en-tête (noms des colonnes).
  • Manipulation avec module csv en Python (csv.DictReader pour lecture, csv.DictWriter pour écriture).

• TSV (Tab-Separated Values) :

  • Similaire au CSV, mais valeurs séparées par tabulations (\t).
  • Lecture/écriture avec csv en précisant delimiter="\t".

2. Projet GenBank2FASTA (conversion GenBank → FASTA)

• Objectif : convertir un fichier GenBank (ex : chromosome I de Saccharomyces cerevisiae) en fichiers FASTA pour chaque gène.
• Étapes clés :
  1. Lire le fichier GenBank en liste de lignes.
  2. Extraire le nom de l’organisme (ligne contenant ORGANISM).
  3. Identifier les gènes (lignes commençant par gene), distinguer sens/antisens.
  4. Extraire la séquence complète entre ORIGIN et //.
  5. Construire la séquence complémentaire inverse pour les gènes antisens.
  6. Écrire chaque gène dans un fichier FASTA avec un en-tête >organisme|numéro-gène|début|fin|sens/antisens.
• Remarques :
  • Ignorer les symboles < et > dans les positions.
  • La séquence complémentaire inverse remplace a↔t, c↔g puis inverse la chaîne.
  • La séquence FASTA est écrite sur des lignes de 80 caractères max.
• Variantes :
  • Sans expressions régulières : extraction par manipulation de chaînes.
  • Avec expressions régulières : extraction plus compacte et robuste.

3. Projet : Recherche de mots anglais dans le protéome humain

• Objectif : détecter la présence de mots anglais dans les séquences protéiques humaines.
• Données :
  • Liste de mots anglais fréquents (fichier english-common-words.txt).
  • Protéome humain au format FASTA (human-proteome.fasta).
• Étapes :
  1. Lire et filtrer les mots (≥ 3 lettres, en majuscules).
  2. Lire les séquences protéiques dans un dictionnaire {id: séquence}.
  3. Chercher chaque mot dans les séquences, compter dans combien de séquences il apparaît.
  4. Afficher les mots trouvés et leur nombre d’occurrences.
  5. Trouver le mot le plus fréquent et calculer son pourcentage d’apparition dans le protéome.
  6. Optionnel : compter le nombre total d’occurrences de chaque mot dans toutes les séquences.

4. Simulation d’un pendule simple

• Modèle physique :

  • Pendule : masse ponctuelle suspendue à un pivot par une tige rigide sans masse.
  • Hypothèses : pas de frottement, gravité uniforme.

• Équation différentielle :

  $$\frac{d^2 \theta}{dt^2} + \frac{g}{L} \sin(\theta) = 0$$

  où $\theta$ est l’angle entre la verticale et la tige, $g$ la gravité, $L$ la longueur de la tige.

• Méthode de résolution numérique : méthode semi-implicite d’Euler

  • Calcul de l’accélération angulaire :

    $$a_\theta(t) = -\frac{g}{L} \sin(\theta(t))$$

  • Mise à jour de la vitesse angulaire :

    $$v_\theta(t + \delta t) = v_\theta(t) + a_\theta(t) \times \delta t$$

  • Mise à jour de l’angle :

    $$\theta(t + \delta t) = \theta(t) + v_\theta(t + \delta t) \times \delta t$$

• Paramètres usuels :

  • $L = 1$ m, $g = 9.8$ m/s², $\delta t = 0.05$ s.
  • Conditions initiales : angle initial $\theta = \pi/4$ rad (45°), vitesse angulaire initiale nulle.

• Visualisation avec Tkinter :

  • Utilisation d’un Canvas 400×400 pixels.

  • Conversion de $\theta$ en coordonnées cartésiennes :

    $$x = L \sin(\theta), \quad y = -L \cos(\theta)$$

  • Conversion en coordonnées canvas (centre en (200, 200), facteur 100 pixels/mètre) :

    $$x_c = 200 + 100 \times x, \quad y_c = 200 - 100 \times y$$

• Gestion du mouvement :

  • Boutons Démarrer, Arrêter, Quitter.
  • Drapeau is_moving pour contrôler l’animation.
  • Méthode move() appelée périodiquement (toutes les 20 ms) pour mettre à jour la position.

À retenir :
Le format FASTA stocke des séquences avec une ligne d’en-tête > suivie de la séquence sur plusieurs lignes.
Le format GenBank contient des annotations détaillées et la séquence entre ORIGIN et //.
La simulation d’un pendule simple repose sur la résolution numérique de l’équation différentielle $\frac{d^2 \theta}{dt^2} + \frac{g}{L} \sin(\theta) = 0$ par la méthode semi-implicite d’Euler.

1. Installation de Python avec Miniconda

• Miniconda est une distribution légère de Python incluant le gestionnaire de paquets conda, compatible Windows, Mac OS X et Linux.
• Anaconda est une distribution complète, plus lourde (plusieurs Go), incluant de nombreux paquets.
• Pip est le gestionnaire de paquets Python standard depuis la version 3.4, mais conda est recommandé pour gérer les environnements et paquets en bioinformatique.

Recommandation : Installer Miniconda pour bénéficier d’un gestionnaire efficace, sans nécessiter de droits administrateur.

2. Installation de Miniconda selon le système

3. Vérification de l’installation

• Ouvrir un shell (bash, PowerShell, etc.) : l’invite doit afficher (base) indiquant l’activation de l’environnement conda de base.

• Tester Python :

  $ python
  Python 3.12.4 | packaged by Anaconda, Inc.
  >>> exit()
  

• Tester conda :

  $ conda
  usage: conda [-h] [-v] [-V] COMMAND ...
  

4. Désinstallation de Miniconda

5. Installation des modules complémentaires avec conda

• Modules recommandés : numpy, pandas, matplotlib, scipy, biopython, jupyterlab.

• Commande d’installation commune à tous les OS :

  $ conda install numpy pandas matplotlib scipy biopython jupyterlab
  

• Confirmer avec y puis attendre la fin de l’installation.

6. Test des modules installés

• Lancer Python puis importer les modules :

  import numpy
  import scipy
  import Bio
  import matplotlib
  import pandas
  

• Aucun message d’erreur signifie que l’installation est réussie.

• Tester Jupyter Lab :

  $ jupyter lab
  

  Cela ouvre Jupyter dans le navigateur par défaut.

7. Utilisation de pip avec conda

• pip est intégré dans Miniconda et peut être utilisé pour installer des paquets absents de conda.

• Toujours activer l’environnement conda avant d’utiliser pip :

  $ conda activate base
  $ pip install nom_du_paquet
  

• Préférer conda pour l’installation des paquets classiques.

8. Choix et configuration d’un éditeur de texte

9. Se positionner dans le bon répertoire dans le shell

• Commandes Unix de base : cd (changer de répertoire), pwd (afficher répertoire courant), ls (lister fichiers).
• Astuces pratiques :
  • Linux : clic droit dans Nautilus > "Ouvrir dans un terminal".
  • Windows : taper powershell dans la barre d’adresse de l’explorateur ou Shift + clic droit > "Ouvrir la fenêtre PowerShell ici".

10. Exécution d’un script Python

• Placer le script dans un répertoire.

• Ouvrir un shell dans ce répertoire.

• Lancer le script avec :

  $ python nom_du_script.py
  

11. Alternatives à l’installation locale

• Utiliser des interpréteurs Python en ligne (ex. repl.it, Tutorials Point, Python Tutor).
• Applications mobiles : Pydroid 3 (Android), Pythonista 3 (iOS, payant).
• Limitations possibles : installation de modules, gestion des fichiers.