Biopython - Biopython
 | |
| Auteur(s) original(aux) | Chapman B, Chang J |
|---|---|
| Première version | 2000 |
| Version stable | 1,79 / 3 juin 2021
|
| Dépôt | https://github.com/biopython/biopython |
| Écrit en | Python et C |
| Plate-forme | Multiplateforme |
| Taper | Bioinformatique |
| Licence | Licence Biopython |
| Site Internet | biopython |
Le projet Biopython est une collection open source d' outils Python non commerciaux pour la biologie computationnelle et la bioinformatique , créée par une association internationale de développeurs. Il contient des classes pour représenter des séquences biologiques et des annotations de séquences , et il est capable de lire et d'écrire dans une variété de formats de fichiers. Il permet également un moyen programmatique d'accéder aux bases de données en ligne d'informations biologiques , telles que celles du NCBI . Des modules séparés étendent les capacités de Biopython à l' alignement de séquences , à la structure des protéines , à la génétique des populations , à la phylogénétique , aux motifs de séquences et à l'apprentissage automatique . Biopython est l'un des nombreux projets Bio* conçus pour réduire la duplication de code en biologie computationnelle .
Histoire
Le développement de Biopython a commencé en 1999 et a été publié pour la première fois en juillet 2000. Il a été développé au cours d'une période similaire et avec des objectifs analogues à d'autres projets qui ont ajouté des capacités bioinformatiques à leurs langages de programmation respectifs, notamment BioPerl , BioRuby et BioJava . Les premiers développeurs du projet comprenaient Jeff Chang, Andrew Dalke et Brad Chapman, bien que plus de 100 personnes aient contribué à ce jour. En 2007, un projet Python similaire , à savoir PyCogent , a été créé.
La portée initiale de Biopython impliquait l'accès, l'indexation et le traitement des fichiers de séquences biologiques. Bien qu'il s'agisse toujours d'un objectif majeur, au cours des années suivantes, des modules supplémentaires ont étendu ses fonctionnalités pour couvrir des domaines supplémentaires de la biologie (voir Principales fonctionnalités et exemples ).
Depuis la version 1.77, Biopython ne prend plus en charge Python 2.
Concevoir
Dans la mesure du possible, Biopython suit les conventions utilisées par le langage de programmation Python pour faciliter la tâche des utilisateurs familiers avec Python. Par exemple, Seqet les SeqRecordobjets peuvent être manipulés via slicing , d'une manière similaire aux chaînes et listes de Python. Il est également conçu pour être fonctionnellement similaire à d'autres projets Bio*, tels que BioPerl.
Biopython est capable de lire et d'écrire les formats de fichiers les plus courants pour chacun de ses domaines fonctionnels, et sa licence est permissive et compatible avec la plupart des autres licences logicielles, ce qui permet à Biopython d'être utilisé dans une variété de projets logiciels.
Fonctionnalités clés et exemples
Séquences
Un concept de base dans Biopython est la séquence biologique, et cela est représenté par la Seqclasse. Un Seqobjet Biopython est similaire à une chaîne Python à bien des égards : il prend en charge la notation de tranche Python, peut être concaténé avec d'autres séquences et est immuable. De plus, il inclut des méthodes spécifiques à la séquence et spécifie l'alphabet biologique particulier utilisé.
>>> # This script creates a DNA sequence and performs some typical manipulations
>>> from Bio.Seq import Seq
>>> dna_sequence = Seq('AGGCTTCTCGTA', IUPAC.unambiguous_dna)
>>> dna_sequence
Seq('AGGCTTCTCGTA', IUPACUnambiguousDNA())
>>> dna_sequence[2:7]
Seq('GCTTC', IUPACUnambiguousDNA())
>>> dna_sequence.reverse_complement()
Seq('TACGAGAAGCCT', IUPACUnambiguousDNA())
>>> rna_sequence = dna_sequence.transcribe()
>>> rna_sequence
Seq('AGGCUUCUCGUA', IUPACUnambiguousRNA())
>>> rna_sequence.translate()
Seq('RLLV', IUPACProtein())
Annotation de séquence
La SeqRecordclasse décrit des séquences, ainsi que des informations telles que le nom, la description et les caractéristiques sous forme d' SeqFeatureobjets. Chaque SeqFeatureobjet spécifie le type de l'entité et son emplacement. Les types d'entités peuvent être « gene », « CDS » (séquence codante), « repeat_region », « mobile_element » ou autres, et la position des entités dans la séquence peut être exacte ou approximative.
>>> # This script loads an annotated sequence from file and views some of its contents.
>>> from Bio import SeqIO
>>> seq_record = SeqIO.read('pTC2.gb', 'genbank')
>>> seq_record.name
'NC_019375'
>>> seq_record.description
'Providencia stuartii plasmid pTC2, complete sequence.'
>>> seq_record.features[14]
SeqFeature(FeatureLocation(ExactPosition(4516), ExactPosition(5336), strand=1), type='mobile_element')
>>> seq_record.seq
Seq('GGATTGAATATAACCGACGTGACTGTTACATTTAGGTGGCTAAACCCGTCAAGC...GCC', IUPACAmbiguousDNA())
Entrée et sortie
Biopython peut lire et écrire dans un certain nombre de formats de séquences courants, notamment FASTA , FASTQ , GenBank, Clustal, PHYLIP et NEXUS . Lors de la lecture de fichiers, les informations descriptives du fichier sont utilisées pour renseigner les membres des classes Biopython, telles que SeqRecord. Cela permet aux enregistrements d'un format de fichier d'être convertis en d'autres.
Les fichiers de séquences très volumineux peuvent dépasser les ressources mémoire d'un ordinateur, c'est pourquoi Biopython propose diverses options pour accéder aux enregistrements dans des fichiers volumineux. Ils peuvent être chargés entièrement en mémoire dans des structures de données Python, telles que des listes ou des dictionnaires , offrant un accès rapide au détriment de l'utilisation de la mémoire. Alternativement, les fichiers peuvent être lus à partir du disque selon les besoins, avec des performances plus lentes mais des besoins en mémoire inférieurs.
>>> # This script loads a file containing multiple sequences and saves each one in a different format.
>>> from Bio import SeqIO
>>> genomes = SeqIO.parse('salmonella.gb', 'genbank')
>>> for genome in genomes:
... SeqIO.write(genome, genome.id + '.fasta', 'fasta')
Accéder aux bases de données en ligne
Grâce au module Bio.Entrez, les utilisateurs de Biopython peuvent télécharger des données biologiques à partir des bases de données NCBI. Chacune des fonctions fournies par le moteur de recherche Entrez est disponible via les fonctions de ce module, y compris la recherche et le téléchargement d'enregistrements.
>>> # This script downloads genomes from the NCBI Nucleotide database and saves them in a FASTA file.
>>> from Bio import Entrez
>>> from Bio import SeqIO
>>> output_file = open('all_records.fasta', "w")
>>> Entrez.email = 'my_email@example.com'
>>> records_to_download = ['FO834906.1', 'FO203501.1']
>>> for record_id in records_to_download:
... handle = Entrez.efetch(db='nucleotide', id=record_id, rettype='gb')
... seqRecord = SeqIO.read(handle, format='gb')
... handle.close()
... output_file.write(seqRecord.format('fasta'))
Phylogénie
Le module Bio.Phylo fournit des outils pour travailler et visualiser les arbres phylogénétiques . Une variété de formats de fichiers sont pris en charge pour la lecture et l'écriture, notamment Newick , NEXUS et phyloXML . Les manipulations d'arborescence et les traversées courantes sont prises en charge via les objets Treeet Clade. Les exemples incluent la conversion et l'assemblage de fichiers d'arbre, l'extraction de sous-ensembles d'un arbre, la modification de la racine d'un arbre et l'analyse des caractéristiques des branches telles que la longueur ou le score.
Les arbres enracinés peuvent être dessinés en ASCII ou en utilisant matplotlib (voir Figure 1), et la bibliothèque Graphviz peut être utilisée pour créer des mises en page non enracinées (voir Figure 2).
Diagrammes du génome
Le module GenomeDiagram fournit des méthodes de visualisation des séquences dans Biopython. Les séquences peuvent être dessinées sous une forme linéaire ou circulaire (voir Figure 3), et de nombreux formats de sortie sont pris en charge, notamment PDF et PNG . Les diagrammes sont créés en créant des pistes, puis en ajoutant des fonctions de séquence à ces pistes. En parcourant les caractéristiques d'une séquence et en utilisant leurs attributs pour décider si et comment ils sont ajoutés aux pistes du diagramme, on peut exercer un grand contrôle sur l'apparence du diagramme final. Des liens croisés peuvent être tracés entre différentes pistes, ce qui permet de comparer plusieurs séquences dans un seul diagramme.
Structure macromoléculaire
Le module Bio.PDB peut charger des structures moléculaires à partir de fichiers PDB et mmCIF , et a été ajouté à Biopython en 2003. L' Structureobjet est au cœur de ce module, et il organise la structure macromoléculaire de manière hiérarchique : les Structureobjets contiennent des Modelobjets qui contiennent des Chainobjets qui contiennent des Residueobjets qui contiennent des Atomobjets. Les résidus et atomes désordonnés ont leurs propres classes, DisorderedResidueet DisorderedAtom, qui décrivent leurs positions incertaines.
En utilisant Bio.PDB, on peut naviguer à travers les composants individuels d'un fichier de structure macromoléculaire, comme l'examen de chaque atome d'une protéine. Des analyses courantes peuvent être effectuées, telles que la mesure de distances ou d'angles, la comparaison des résidus et le calcul de la profondeur des résidus.
Génétique des populations
Le module Bio.PopGen ajoute la prise en charge de Biopython pour Genepop, un progiciel d'analyse statistique de la génétique des populations. Cela permet d'analyser l' équilibre de Hardy-Weinberg , le déséquilibre de liaison et d'autres caractéristiques des fréquences alléliques d'une population .
Ce module peut également réaliser des simulations génétiques des populations en utilisant la théorie de la coalescence avec le programme fastsimcoal2.
Wrappers pour les outils de ligne de commande
De nombreux modules de Biopython contiennent des enveloppes de ligne de commande pour les outils couramment utilisés, permettant à ces outils d'être utilisés à partir de Biopython. Ces wrappers incluent BLAST , Clustal , PhyML , EMBOSS et SAMtools . Les utilisateurs peuvent sous-classer une classe wrapper générique pour ajouter la prise en charge de tout autre outil de ligne de commande.