biopython

Biopython : Biologie Moléculaire Computationnelle en Python

Vue d'ensemble

Biopython est un ensemble complet d'outils Python gratuits pour le calcul biologique. Il offre des fonctionnalités pour la manipulation de séquences, les entrées/sorties de fichiers, l'accès aux bases de données, la bio-informatique structurale, la phylogénétique et de nombreuses autres tâches bio-informatiques. La version actuelle est Biopython 1.87 (publiée le 30 mars 2026). Il prend en charge Python 3.10-3.14 et PyPy3.10, et nécessite NumPy. Biopython 1.87 traite également CVE-2025-68463 dans Bio.Entrez.Parser lors de l'analyse de fichiers non fiables, privilégiez donc la version 1.87+ pour les flux de travail qui analysent du XML Entrez fourni de l'extérieur.

Quand utiliser cette compétence

Utilisez cette compétence lorsque :

• Vous travaillez avec des séquences biologiques (ADN, ARN ou protéine)
• Vous lisez, écrivez ou convertissez des formats de fichiers biologiques (FASTA, GenBank, FASTQ, PDB, mmCIF, etc.)
• Vous accédez aux bases de données NCBI (GenBank, PubMed, Protein, Gene, etc.) via Entrez
• Vous exécutez des recherches BLAST ou analysez des résultats BLAST
• Vous effectuez des alignements de séquences (alignements par paires ou multiples)
• Vous analysez des structures protéiques à partir de fichiers PDB
• Vous créez, manipulez ou visualisez des arbres phylogénétiques
• Vous trouvez des motifs de séquence ou analysez des modèles de motifs
• Vous calculez des statistiques de séquence (contenu GC, poids moléculaire, température de fusion, etc.)
• Vous effectuez des tâches de bio-informatique structurale
• Vous travaillez avec des données de génétique des populations
• Toute autre tâche de biologie moléculaire computationnelle

Capacités de base

Biopython est organisé en sous-packages modulaires, chacun abordant des domaines spécifiques de la bio-informatique :

1. Manipulation de séquences - Bio.Seq et Bio.SeqIO pour la manipulation de séquences et les entrées/sorties de fichiers
2. Analyse d'alignement - Bio.Align et Bio.AlignIO pour les alignements de séquences par paires et multiples
3. Accès aux bases de données - Bio.Entrez pour l'accès programmatique aux bases de données NCBI
4. Opérations BLAST - Bio.Blast pour l'exécution et l'analyse de recherches BLAST
5. Bio-informatique structurale - Bio.PDB pour travailler avec des structures protéiques 3D
6. Phylogénétique - Bio.Phylo pour la manipulation et la visualisation d'arbres phylogénétiques
7. Fonctionnalités avancées - Motifs, génétique des populations, utilitaires de séquence, etc.

Installation et configuration

Installez la version stable actuelle de Biopython avec une version explicite pour la reproductibilité :

uv pip install "biopython==1.87"

Pour l'accès aux bases de données NCBI, définissez toujours votre adresse e-mail (obligatoire pour NCBI). Pour les logiciels réutilisables, définissez une valeur stable Entrez.tool et enregistrez l'outil/email auprès de NCBI. Pour des limites de taux plus élevées (10 requêtes/s au lieu de 3 requêtes/s), lisez uniquement NCBI_API_KEY à partir de l'environnement — ne codez pas en dur les clés et ne chargez pas de variables d'environnement non liées :

import os
from Bio import Entrez

Entrez.email = "[email protected]"  # obligatoire — utilisez votre véritable e-mail
Entrez.tool = "nom_de_votre_outil"  # facultatif mais recommandé pour les logiciels réutilisables

# Facultatif : inscrivez-vous sur https://www.ncbi.nlm.nih.gov/account/settings/
if api_key := os.environ.get("NCBI_API_KEY"):
    Entrez.api_key = api_key

Utilisation de cette compétence

Cette compétence fournit une documentation complète organisée par domaine fonctionnel. Lorsque vous travaillez sur une tâche, consultez la documentation de référence pertinente :

1. Manipulation de séquences (Bio.Seq & Bio.SeqIO)

Référence : references/sequence_io.md

Utilisez pour :

• Créer et manipuler des séquences biologiques
• Lire et écrire des fichiers de séquences (FASTA, GenBank, FASTQ, etc.)
• Convertir entre formats de fichiers
• Extraire des séquences de gros fichiers
• Traduction, transcription et complément inverse de séquences
• Travailler avec des objets SeqRecord

Exemple rapide :

from Bio import SeqIO

# Lire des séquences à partir d'un fichier FASTA
for record in SeqIO.parse("sequences.fasta", "fasta"):
    print(f"{record.id} : {len(record.seq)} pb")

# Convertir GenBank en FASTA
SeqIO.convert("input.gb", "genbank", "output.fasta", "fasta")

2. Analyse d'alignement (Bio.Align & Bio.AlignIO)

Référence : references/alignment.md

Utilisez pour :

• Alignement de séquences par paires (global et local)
• Lire et écrire des alignements de séquences multiples
• Utiliser des matrices de substitution (BLOSUM, PAM)
• Calculer des statistiques d'alignement
• Personnaliser les paramètres d'alignement

Exemple rapide :

from Bio import Align

# Alignement par paires
aligneur = Align.PairwiseAligner()
aligneur.mode = 'global'
alignements = aligneur.align("ACCGGT", "ACGGT")
print(alignements[0])

3. Accès aux bases de données (Bio.Entrez)

Référence : references/databases.md

Utilisez pour :

• Rechercher dans les bases de données NCBI (PubMed, GenBank, Protein, Gene, etc.)
• Télécharger des séquences et des enregistrements
• Récupérer des informations de publication
• Trouver des enregistrements connexes entre bases de données
• Téléchargement par lots avec limitation de débit appropriée

Exemple rapide :

from Bio import Entrez
Entrez.email = "[email protected]"

# Recherche PubMed
handle = Entrez.esearch(db="pubmed", term="biopython", retmax=10)
results = Entrez.read(handle)
handle.close()
print(f"{results['Count']} résultats trouvés")

4. Opérations BLAST (Bio.Blast)

Référence : references/blast.md

Utilisez pour :

• Exécuter des recherches BLAST via les services web NCBI
• Exécuter des recherches BLAST locales
• Analyser la sortie XML de BLAST
• Filtrer les résultats par valeur E ou identité
• Extraire les séquences des correspondances

Exemple rapide :

from Bio.Blast import NCBIWWW, NCBIXML

# Exécuter une recherche BLAST
result_handle = NCBIWWW.qblast("blastn", "nt", "ATCGATCGATCG")
blast_record = NCBIXML.read(result_handle)

# Afficher les meilleures correspondances
for alignment in blast_record.alignments[:5]:
    print(f"{alignment.title} : E-value={alignment.hsps[0].expect}")

5. Bio-informatique structurale (Bio.PDB)

Référence : references/structure.md

Utilisez pour :

• Analyser des fichiers de structure PDB et mmCIF
• Naviguer dans la hiérarchie des structures protéiques (SMCRA : Structure/Modèle/Chaîne/Résidu/Atome)
• Calculer des distances, des angles et des angles dièdres
• Attribution de structure secondaire (DSSP)
• Superposition de structures et calcul RMSD
• Extraire des séquences à partir de structures

Exemple rapide :

from Bio.PDB import PDBParser

# Analyser la structure
parser = PDBParser(QUIET=True)
structure = parser.get_structure("1crn", "1crn.pdb")

# Calculer la distance entre les carbones alpha
chain = structure[0]["A"]
distance = chain[10]["CA"] - chain[20]["CA"]
print(f"Distance : {distance:.2f} Å")

6. Phylogénétique (Bio.Phylo)

Référence : references/phylogenetics.md

Utilisez pour :

• Lire et écrire des arbres phylogénétiques (Newick, NEXUS, phyloXML)
• Construire des arbres à partir de matrices de distance ou d'alignements
• Manipulation d'arbres (élagage, réenracinement, échellement)
• Calculer des distances phylogénétiques
• Créer des arbres de consensus
• Visualiser des arbres

Exemple rapide :

from Bio import Phylo

# Lire et visualiser un arbre
arbre = Phylo.read("arbre.nwk", "newick")
Phylo.draw_ascii(arbre)

# Calculer une distance
distance = arbre.distance("Espèce_A", "Espèce_B")
print(f"Distance : {distance:.3f}")

7. Fonctionnalités avancées

Référence : references/advanced.md

Utilisez pour :

• Motifs de séquence (Bio.motifs) - Trouver et analyser des motifs
• Génétique des populations (Bio.PopGen) - Fichiers GenePop, calculs Fst, tests de Hardy-Weinberg
• Utilitaires de séquence (Bio.SeqUtils) - Contenu GC, température de fusion, poids moléculaire, analyse des protéines
• Analyse de restriction (Bio.Restriction) - Trouver des sites de restriction enzymatiques
• Regroupement (Bio.Cluster) - K-means et regroupement hiérarchique
• Diagrammes génomiques (GenomeDiagram) - Visualisation de caractéristiques génomiques

Exemple rapide :

from Bio.SeqUtils import gc_fraction, molecular_weight
from Bio.Seq import Seq

seq = Seq("ATCGATCGATCG")
print(f"Contenu GC : {gc_fraction(seq):.2%}")
print(f"Poids moléculaire : {molecular_weight(seq, seq_type='DNA'):.2f} g/mol")

Directives générales de flux de travail

Lecture de la documentation

Lorsqu'un utilisateur pose une question sur une tâche spécifique de Biopython :

1. Identifiez le module pertinent en fonction de la description de la tâche
2. Lisez le fichier de référence approprié à l'aide de l'outil Lire
3. Extrayez les modèles de code pertinents et adaptez-les aux besoins spécifiques de l'utilisateur
4. Combinez plusieurs modules lorsque la tâche l'exige

Exemples de modèles de recherche pour les fichiers de référence :

# Rechercher des informations sur des fonctions spécifiques
rg -n "SeqIO.parse" references/sequence_io.md

# Rechercher des exemples de tâches spécifiques
rg -n "BLAST" references/blast.md

# Rechercher des informations sur des concepts spécifiques
rg -n "alignement" references/alignment.md

Écrire du code Biopython

Suivez ces principes lors de l'écriture de code Biopython :

1. Importez les modules explicitement

   from Bio import SeqIO, Entrez
   from Bio.Seq import Seq
   

2. Définissez l'e-mail Entrez lors de l'utilisation des bases de données NCBI ; chargez uniquement NCBI_API_KEY de l'environnement si présente

   import os
   from Bio import Entrez
   
   Entrez.email = "[email protected]"
   Entrez.tool = "nom_de_votre_outil"
   if api_key := os.environ.get("NCBI_API_KEY"):
       Entrez.api_key = api_key
   

3. Utilisez les formats de fichiers appropriés - Vérifiez quel format convient le mieux à la tâche

   # Formats courants : "fasta", "genbank", "fastq", "clustal", "phylip"
   

4. Traitez les fichiers correctement - Fermez les handles après utilisation ou utilisez des gestionnaires de contexte

   with open("fichier.fasta") as handle:
       enregistrements = SeqIO.parse(handle, "fasta")
   

5. Utilisez des itérateurs pour les gros fichiers - Évitez de tout charger en mémoire

   for enregistrement in SeqIO.parse("gros_fichier.fasta", "fasta"):
       # Traiter un enregistrement à la fois
   

6. Gérez les erreurs avec élégance - Les opérations réseau et l'analyse de fichiers peuvent échouer

   from urllib.error import HTTPError
   
   try:
       handle = Entrez.efetch(db="nucleotide", id=accession)
   except HTTPError as e:
       print(f"Erreur : {e}")
   

Modèles courants

Modèle 1 : Récupérer une séquence de GenBank

from Bio import Entrez, SeqIO

Entrez.email = "[email protected]"

# Récupérer la séquence
handle = Entrez.efetch(db="nucleotide", id="EU490707", rettype="gb", retmode="text")
enregistrement = SeqIO.read(handle, "genbank")
handle.close()

print(f"Description : {enregistrement.description}")
print(f"Longueur de la séquence : {len(enregistrement.seq)}")

Modèle 2 : Pipeline d'analyse de séquence

from Bio import SeqIO
from Bio.SeqUtils import gc_fraction

for enregistrement in SeqIO.parse("sequences.fasta", "fasta"):
    # Calculer les statistiques
    gc = gc_fraction(enregistrement.seq)
    longueur = len(enregistrement.seq)

    # Trouver les ORF, traduire, etc.
    proteine = enregistrement.seq.translate()

    print(f"{enregistrement.id} : {longueur} pb, GC={gc:.2%}")

Modèle 3 : BLAST et récupération des meilleures correspondances

from Bio.Blast import NCBIWWW, NCBIXML
from Bio import Entrez, SeqIO

Entrez.email = "[email protected]"

# Exécuter BLAST
result_handle = NCBIWWW.qblast("blastn", "nt", sequence)
blast_record = NCBIXML.read(result_handle)

# Obtenir les accessions des meilleures correspondances
accessions = [aln.accession for aln in blast_record.alignments[:5]]

# Récupérer les séquences
for acc in accessions:
    handle = Entrez.efetch(db="nucleotide", id=acc, rettype="fasta", retmode="text")
    enregistrement = SeqIO.read(handle, "fasta")
    handle.close()
    print(f">{enregistrement.description}")

Modèle 4 : Construire un arbre phylogénétique à partir de séquences

from Bio import AlignIO, Phylo
from Bio.Phylo.TreeConstruction import DistanceCalculator, DistanceTreeConstructor

# Lire l'alignement
alignment = AlignIO.read("alignment.fasta", "fasta")

# Calculer les distances
calculateur = DistanceCalculator("identity")
dm = calculateur.get_distance(alignment)

# Construire l'arbre
constructeur = DistanceTreeConstructor()
arbre = constructeur.nj(dm)

# Visualiser
Phylo.draw_ascii(arbre)

Meilleures pratiques

1. Lisez toujours la documentation de référence pertinente avant d'écrire du code
2. Utilisez grep pour rechercher dans les fichiers de référence des fonctions ou exemples spécifiques
3. Validez les formats de fichiers avant de les analyser
4. Gérez les données manquantes avec élégance - Tous les enregistrements n'ont pas tous les champs
5. Mettez en cache les données téléchargées - Ne téléchargez pas les mêmes séquences à plusieurs reprises
6. Respectez les limites de débit de NCBI - Utilisez des clés API, des valeurs d'outil/email enregistrées pour les logiciels réutilisables, et l'historique/le traitement par lots d'Entrez pour les grands travaux
7. Testez avec de petits ensembles de données avant de traiter de gros fichiers
8. Maintenez Biopython à jour pour bénéficier des dernières fonctionnalités et corrections de bugs
9. Utilisez des tables de codes génétiques appropriées pour la traduction
10. Documentez les paramètres d'analyse pour la reproductibilité

Résolution des problèmes courants

Problème : "No handlers could be found for logger 'Bio.Entrez'"

Solution : Ce n'est qu'un avertissement. Définissez Entrez.email pour le supprimer.

Problème : "HTTP Error 400" de NCBI

Solution : Vérifiez que les ID/accessions sont valides et correctement formatés.

Problème : "ValueError: EOF" lors de l'analyse de fichiers

Solution : Vérifiez que le format du fichier correspond à la chaîne de format spécifiée.

Problème : L'alignement échoue avec "sequences are not the same length"

Solution : Assurez-vous que les séquences sont alignées avant d'utiliser AlignIO ou MultipleSeqAlignment.

Problème : Les recherches BLAST sont lentes

Solution : Utilisez BLAST local pour les recherches à grande échelle, ou mettez en cache les résultats.

Problème : Avertissements de l'analyseur PDB

Solution : Utilisez PDBParser(QUIET=True) pour supprimer les avertissements, ou examinez la qualité de la structure.

Problème : ImportError pour Bio.HMM, Bio.MarkovModel ou Bio.Application

Solution : Ces modules ont été supprimés dans Biopython 1.86. Utilisez hmmlearn pour les HMM et le module subprocess de la bibliothèque standard au lieu des wrappers CLI de Bio.Application.

Problème : PairwiseAligner renvoie moins d'alignements après la mise à niveau vers 1.86+

Solution : Le score de pénalité par défaut est passé de 0 à -1 dans la version 1.86, éliminant ainsi les alignements triviaux. Définissez aligneur.gap_score = 0 pour restaurer l'ancien comportement si nécessaire (voir references/alignment.md).

Ressources supplémentaires

• Documentation officielle : https://biopython.org/docs/latest/
• Tutoriel : https://biopython.org/docs/latest/Tutorial/
• Cookbook : https://biopython.org/docs/latest/Tutorial/ (exemples avancés)
• GitHub : https://github.com/biopython/biopython
• R...

[Ceci est une traduction du contenu original. Le contenu original a pu être tronqué.]