logo site
Site WWW de Laurent Bloch
Slogan du site

ISSN 2271-3905
Cliquez ici si vous voulez visiter mon autre site, orienté vers des sujets moins techniques.

Pour recevoir (au plus une fois par semaine) les nouveautés de ce site, indiquez ici votre adresse électronique :

Python et Biopython
Article mis en ligne le 2 novembre 2019
dernière modification le 5 novembre 2019

par Laurent Bloch

Dans un article précédent je racontais comment j’avais été amené à écrire un manuel de Python à l’usage des biologistes désireux de devenir bioinformaticiens. L’attrait des biologistes pour Python est dans une large mesure suscité par l’existence de la bibliothèque de programmes Biopython, qui leur fournit effectivement des réponses à la plupart des problèmes informatiques qu’ils peuvent se poser. Mais la dextérité dans l’usage des programmes déjà faits proposés par Biopython suffit-elle à constituer une compétence de bioinformaticien ? Pour en avoir le cœur net j’ai entrepris d’explorer cette bibliothèque. C’est un bref récit de cette excursion que je vous propose ici.

 Premiers pas avec Biopython

 Installer la bibliothèque, vérifier son fonctionnement

Soit un système Linux avec Python installé. Pour avoir accès à Biopython (et tenter quelques essais préliminaires) il faut procéder ainsi, en utilisant l’instruction import :

  1. $ sudo apt install python-pip
  2. $ pip3 install biopython
  3. $ python3
  4. Python 3.7.3 (default, Oct  7 2019, 12:56:13)
  5. [GCC 8.3.0] on linux
  6. Type "help", "copyright", "credits" or "license" for more information.
  7. > import Bio
  8. > print(Bio.__version__)
  9. 1.74
  10. > from Bio.Seq import Seq
  11. > my_seq = Seq("AGTACACTGGT")
  12. > my_seq
  13. Seq('AGTACACTGGT')
  14. > my_seq.complement()
  15. Seq('TCATGTGACCA')
  16. > my_seq.reverse_complement()
  17. Seq('ACCAGTGTACT')

Télécharger

Ce premier exemple introduit l’objet Seq, qui fournit les mécanismes de base pour manipuler les textes de séquences biologiques et les fichiers qui les contiennent.

 Séquences biologiques

Les séquences biologiques (ADN, ARN, protéines) sont l’objet central de la bioinformatique. Ce sont des textes qui décrivent, sous forme codée, la séquence des nucléotides d’une molécule (ou partie de molécule) d’ADN (adénine codée A, cytosine codée C, guanine codée G ou thymine codée T, d’où l’alphabet ACGT), d’ARN (la thymine de l’ADN y est remplacée par l’uracile, d’où l’alphabet ACGU), ou pour une protéine la séquence de ses acides aminés. Le lecteur peu familier de la biologie moléculaire peut trouver une explication des évolutions récentes du séquençage génomique dans un article de Sacha Schutz.

Les séquences sont accessibles dans des banques de données, sous différents formats qui ajoutent à leur texte proprement dit de nombreuses autres informations : identifiants conventionnels tels qu’Accession Number, références bibliographiques de publications qui s’y rapportent, identité de l’organisme, etc. Les principales banques de données bioinformatiques sont GenBank et EMBL pour les séquences nucléotidiques, UniProt, SwissProt et TrEMBL pour les protéines. Les banques PDB, SCOP et CATH fournissent des informations de structure spatiale des protéines, nécessaires aux logiciels de modélisation moléculaire. PubMed est une banque de données bibliographiques.

Les logiciels de traitement des données de séquence les acceptent également sous différents formats. La routine du bioinformaticien consiste pour une grande part à extraire des données de séquences d’une banque, à les transformer pour les mettre au format attendu par le logiciel de traitement, puis à transformer le résultat obtenu pour le mettre au format d’un logiciel suivant, ou au format d’une base de données où on désire le stocker [1]. Ces opérations d’analyse syntaxique et de transformation sont désignées par le verbe anglais to parse, et l’on trouvera souvent l’anglicisme parser. Biopython fournit une grande variété de programmes pour effectuer ces opérations, pour les formats de données usuels en biologie moléculaire. Nous reprenons ci-dessous un exemple du manuel Biopython.

 Manipuler des séquences

 Analyse de séquences

L’opération paradigmatique de la biologie moléculaire informatique est l’alignement de séquences, décrit par cet article et celui-ci. Le logiciel le plus utilisé à cette fin est BLAST, mais il faut également citer ClustalW pour les alignements multiples, ainsi que FASTA. La plupart de ces logiciels d’analyse de séquences n’ont pas besoin de toutes les informations disponibles dans les banques, et utilisent un format de fichier très simple, dit « format FASTA » :

- la première ligne d’une séquence est une ligne de commentaires, avec en colonne 1 le caractère > suivi de l’identifiant de la séquence et d’un texte libre [2] ;
- une ou plusieurs lignes, longues d’au plus 120 caractères, pour le texte de la séquence proprement dite, codée selon la nomenclature IUPAC [3] ;
- éventuellement une ligne vide pour séparer cette séquence de la suivante.

Voici un fragment emprunté à une orchidée :

Nous pouvons analyser le fichier entier (qui contient plusieurs séquences) avec le programme Python suivant :

  1. import Bio
  2. from Bio import SeqIO
  3. for seq_record in SeqIO.parse("ls_orchid.fasta", "fasta"):
  4.     print(seq_record.id)
  5.     print(repr(seq_record.seq))
  6.     print(len(seq_record))

Télécharger

qui donnera le résultat suivant :

Nous pouvons aussi partir de la séquence telle qu’elle figure dans GenBank :

qui donnera la sortie suivante :

avec le Python suivant :

  1. from Bio import SeqIO
  2. for seq_record in SeqIO.parse("ls_orchid.gbk", "genbank"):
  3.     print(seq_record.id)
  4.     print(repr(seq_record.seq))
  5.     print(len(seq_record))

Télécharger

On remarque que le format de données de GenBank, comme celui de SwissProt, termine une séquence par une ligne //. Les informations fournies par GenBank sont plus riches que celles du format FASTA, ce qui permet au programme d’identifier l’alphabet IUPACAmbiguousDNA, ce qui est plus précis que SingleLetterAlphabet.

On trouvera une vaste collection d’exemples sur le site de Biopython, plus précisément dans le « livre de recettes ».

 Traduction de séquence

À titre d’exemple, voici la méthode de traduction de séquence d’ARN messager et son résultat :

Ligne de commande : ./ARN-traduc.py ARN-traduc.txt

  1. #!/usr/bin/env python3
  2. def  ARN_traduc(alphabet):
  3.     import sys
  4.     from Bio.Seq import Seq
  5.     from Bio.Alphabet import IUPAC
  6.     f_lire = open(sys.argv[1], mode ='r')
  7.     une_ligne = f_lire.readline()
  8.     messenger_rna = Seq(une_ligne, alphabet)
  9.     print(messenger_rna)
  10.     print(messenger_rna.translate())
  11.  
  12. from Bio.Alphabet import IUPAC
  13. ARN_traduc(IUPAC.unambiguous_rna)
  14.  
  15. # -> AUGGCCAUUGUAAUGGGCCGCUGAAAGGGUGCCCGAUAG
  16. # -> MAIVMGR*KGAR*

Télécharger

On peut aussi traduire directement à partir de l’ADN :

Ligne de commande : ./ADN-traduc.py ADN-traduc.txt

  1. #!/usr/bin/env python3
  2. def  ADN_traduc(alphabet):
  3.     import sys
  4.     from Bio.Seq import Seq
  5.     from Bio.Alphabet import IUPAC
  6.     f_lire = open(sys.argv[1], mode ='r')
  7.     une_ligne = f_lire.readline()
  8.     coding_dna = Seq(une_ligne, alphabet)
  9.     print(coding_dna)
  10.     print(coding_dna.translate())
  11.  
  12. from Bio.Alphabet import IUPAC
  13. ADN_traduc(IUPAC.unambiguous_dna)
  14.  
  15. # -> ATGGCCATTGTAATGGGCCGCTGAAAGGGTGCCCGATAG
  16. # -> MAIVMGR*KGAR*

Télécharger

On remarque dans la séquence, avant le codon STOP final un codon STOP interne, noté * dans le résultat.

Par défaut les tables de traduction de Biopython sont basées sur celles du NCBI, mais on peut choisir sa table, par exemple pour de l’ADN mitochondrial [4] ainsi :

  1. > coding_dna.translate(table="Vertebrate Mitochondrial")
  2. Seq('MAIVMGRWKGAR*', HasStopCodon(IUPACProtein(), '*'))
  3.  
  4. # ou, en utilisant le numéro de la table du NCBI désirée :
  5.  
  6. > coding_dna.translate(table=2)
  7. Seq('MAIVMGRWKGAR*', HasStopCodon(IUPACProtein(), '*'))

Télécharger

Pour éclairer les lecteurs qui ne seraient pas familiers du code génétique, voici la table de traduction standard du NCBI, et la table pour l’ADN mitochondrial. Les 64 combinaisons possibles de 3 nucléotides (43), appelées codons, servent à coder les 20 acides aminés (plus évidemment les nouveaux inventés par les chercheurs), c’est-à-dire que plusieurs codons peuvent coder pour le même acide aminé ; on dit que le code est dégénéré :

Le voici, à partir de l’ARN messager et avec les noms et abréviations des acides aminés (dont certains peuvent être basiques !). Admirez leurs jolis noms :

 Accéder en ligne aux banques de données

Ci-dessus nous avons travaillé avec des fichiers de séquences présents sur notre ordinateur, mais il serait bien plus commode d’interagir en ligne avec les banques, d’une part parce qu’elles sont volumineuses, d’autre part parce qu’ainsi nous serions certains d’accéder à la dernière version des données. Bien sûr il y a des inconvénients : passer par le réseau peut introduire des lenteurs et des coûts, et révéler à des observateurs extérieurs (par exemple les administrateurs des banques) l’objet et le déroulement de nos recherches, ce qui souvent n’est pas souhaitable.

À ce jour Biopython permet d’accéder, par des scripts Python, aux banques suivantes, et d’en extraire des données :

- Entrez (et PubMed) au NCBI [5] ;
- ExPASy ;
- SCOP (cf. la fonction Bio.SCOP.search()).

Par exemple, nous pouvons charger directement des séquences depuis le site du NCBI, ainsi :

  1. #!/usr/bin/env python3
  2. def FetchSeq(mydb, myrettype, myretmode, myid):
  3.     from Bio import Entrez
  4.     from Bio import SeqIO
  5.     Entrez.email = "lb@laurentbloch.org"
  6.     with Entrez.efetch(db=mydb, rettype=myrettype,\
  7.                        retmode=myretmode, id=myid) as handle:
  8.         seq_record = SeqIO.read(handle, "fasta")
  9.     print("%s with %i features"\
  10.           % (seq_record.id, len(seq_record.features)))
  11.  
  12. FetchSeq("nucleotide", "fasta", "text", "6273291")
  13. # -> AF191665.1 with 0 features

Télécharger

Pour en avoir plusieurs à la fois, en style GenBank :

  1. #!/usr/bin/env python3
  2. def FetchSeqMulti(mydb, myrettype, myretmode, myid):
  3.     from Bio import Entrez
  4.     from Bio import SeqIO
  5.     Entrez.email = "lb@laurentbloch.org"
  6.     with Entrez.efetch(db=mydb, rettype=myrettype,\
  7.                        retmode=myretmode, id=myid) as handle:
  8.         for seq_record in SeqIO.parse(handle, "gb"):
  9.             print("%s %s..." % (seq_record.id,\
  10.                                 seq_record.description[:50]))
  11.             print("Sequence length %i, %i features, from: %s"
  12.                   % (len(seq_record), len(seq_record.features),\
  13.                      seq_record.annotations["source"]))
  14.  
  15. FetchSeqMulti("nucleotide", "gb", "text",\
  16.               "6273291,6273290,6273289")

Télécharger

ce qui donne le résultat suivant :

 Avec des protéines

Essayons maintenant avec SwissProt.

  1. #!/usr/bin/env python3
  2. from Bio import ExPASy
  3. from Bio import SeqIO
  4. with ExPASy.get_sprot_raw("O23729") as handle:
  5.     seq_record = SeqIO.read(handle, "swiss")
  6. print(seq_record.id)
  7. print(seq_record.name)
  8. print(seq_record.description)
  9. print(repr(seq_record.seq))
  10. print("Length %i" % len(seq_record))
  11. print(seq_record.annotations["keywords"])

Télécharger

ce qui donne :

 Dictionnaire de séquences

Les dictionnaires de Python sont une structure de données commode, et Biopython procure une interface pour les utiliser. Reprenons notre fichier d’orchidées. Nous pouvons construire un dictionnaire en mémoire, ce qui convient pour un volume de données modéré, et permet de travailler confortablement, ainsi :

  1. #!/usr/bin/env python3
  2. from Bio import SeqIO
  3. orchid_dict = SeqIO.to_dict(SeqIO.parse("ls_orchid.gbk",\
  4.                                         "genbank"))
  5. print(len(orchid_dict))
  6. print(list(orchid_dict.keys()))
  7. print(list(orchid_dict.values()))

Télécharger

Voici le début des résultats :

 Autres fonctions

Biopython procure bien d’autres fonctions de manipulation de séquences, conversions de formats, recopie, écriture, etc., pour lesquelles nous ne saurions trop recommander la consultation du manuel.

 Calculer avec des séquences

 Alignements simples

Considérons ci-dessous un alignement de protéine (Phage_Coat_Gp8, PF05371) annoté au format PFAM, dit « de Stockholm », obtenu depuis une version ancienne de PFAM :

Pour y voir plus clair nous pouvons afficher uniquement l’alignement, ainsi :

ce qui nous donne :

 Alignements multiples

Pour lire des fichiers qui contiennent plusieurs alignements nous allons utiliser la fonction Bio.AlignIO.parse(). Soit par exemple un petit alignement au format PHYLIP [6] :

Si nous voulons construire un arbre phylogénétique avec les programmes disponibles dans PHYLIP, il faut commencer par effectuer un bootstrap (au sens statistique) de ces données, par ré-échantillonnage, c’est-à-dire création de « nouveaux échantillons » par tirage avec remise à partir de l’échantillon initial, ainsi (si notre alignement de départ est enregistré dans un fichier nommé alignement-multiple-1.phy, et le programme bootstrap-align.py) :

  1. #!/usr/bin/env python3
  2. import sys
  3. from Bio import Phylo
  4. from Bio import AlignIO
  5. from Bio.Phylo.Consensus import *
  6. def bootstrap_align(fichier, style):
  7.     msa = AlignIO.read(fichier, style)
  8.     msas = bootstrap(msa, 100)
  9.     for m in msas:
  10.         print(m)
  11.  
  12. fichier = sys.argv[1]
  13. style = sys.argv[2]
  14. bootstrap_align(fichier, style)

Télécharger

ce qui nous donnera le résultat suivant, avec la ligne de commande :

./bootstrap-align.py alignement-multiple-1.phy phylip

Si nous voulons en outre construire les arbres phylogénétiques qui s’en déduisent :

  1. #!/usr/bin/env python3
  2. import sys
  3. from Bio import Phylo
  4. from Bio import AlignIO
  5. from Bio.Phylo import TreeConstruction
  6. from Bio.Phylo.TreeConstruction import DistanceCalculator
  7. from Bio.Phylo.TreeConstruction import DistanceTreeConstructor
  8. from Bio.Phylo.Consensus import *
  9. def bootstrap_align_trees(fichier, style, matrice):
  10.     msa = AlignIO.read(fichier, style)
  11.     msas = bootstrap(msa, 100)
  12.     calculator = DistanceCalculator(matrice)
  13.     constructor = DistanceTreeConstructor(calculator)
  14.     trees = bootstrap_trees(msa, 100, constructor)
  15.     for tree in trees:
  16.         print(tree)
  17.         Phylo.draw_ascii(tree)
  18.  
  19. fichier = sys.argv[1]
  20. style = sys.argv[2]
  21. matrice = sys.argv[3]
  22. bootstrap_align_trees(fichier, style, matrice)

Télécharger

avec la ligne de commande :

./bootstrap-align-trees.py alignement-multiple-1.phy phylip blosum62

ce qui donnera le résultat suivant (limité aux deux premiers échantillons pour raison de mise en page) :

 Calcul d’alignements

La fonction Bio.Align.PairwiseAligner implémente les algorithmes d’alignement de séquences deux à deux par paire de Needleman-Wunsch, Smith-Waterman, Gotoh (trois états), et Waterman-Smith-Beyer (alignement local et global).

Pour l’utiliser nous allons créer un objet PairwiseAligner :

  1. > from Bio import Align
  2. > aligner = Align.PairwiseAligner()
  3. > seq1 = "GAACT"
  4. > seq2 = "GAT"
  5. > score = aligner.score(seq1, seq2)
  6. > score
  7. 3.0
  8. > alignments = aligner.align(seq1, seq2)
  9. > for alignment in alignments:
  10. ...     print(alignment)
  11. GAACT
  12. ||--|
  13. GA--T
  14. <BLANKLINE>
  15. GAACT
  16. |-|-|
  17. G-A-T
  18. <BLANKLINE>

Télécharger

Par défaut, la fonction calcule un alignement global de façon à obtenir le meilleur score possible sur toute la longueur des séquences. Mais il est possible, en sélectionnant le mode local, de chercher les sous-séquences qui donnent le score le plus élevé :

  1. > aligner.mode = 'local'
  2. > seq1 = "AGAACTC"
  3. > seq2 = "GAACT"
  4. > score = aligner.score(seq1, seq2)
  5. > score
  6. 5.0
  7. > alignments = aligner.align(seq1, seq2)
  8. > for alignment in alignments:
  9. ...     print(alignment)
  10. ...
  11. AGAACTC
  12. .|||||.
  13. .GAACT.
  14. <BLANKLINE>

Télécharger

 Modifier les scores de gap

La fonction d’alignement par paire de Biopython permet de modifier les scores de gap. Les détails figurent dans le manuel.

 BLAST et Biopython

BLAST est le logiciel de recherche heuristique le plus utilisé pour comparer des séquences biologiques. Il permet de chercher et d’évaluer des similitudes entre séquences, en leur attribuant un score de similarité probabiliste.

Un usage fréquent consiste à comparer une séquence-test à l’ensemble des séquences d’une banque (les séquences cibles), pour extraire celles dont le score de similarité est le meilleur. Par exemple, lorsqu’un chercheur découvre chez la souris un gène jusqu’alors inconnu, il va comparer la séquence de ce gène à l’ensemble des séquences du génome humain pour voir si un gène similaire n’existerait pas chez l’homme.

BLAST répond au même type de problème que l’algorithme de Needleman et Wunsch que nous avons étudié à l’article, mais il est beaucoup plus rapide, parce qu’alors que Needleman et Wunsch (ou les algorithmes de la même famille tels que Smith et Waterman) calculent des alignements sur toute la longueur des séquences, BLAST élimine de la recherche les régions les moins significatives, et applique aux seules régions significatives un calcul assez voisin de celui de Smith et Waterman. Les génomes des organismes eucaryotes (comme nous, humains, et nos cousins mammifères) sont constitués en majeure partie (98% pour l’homme) de régions « non significatives » pour l’analyse génétique, c’est-à-dire non codantes : il reste à établir un algorithme pour les caractériser. Schématiquement, BLAST effectue les opérations suivantes :

- Élimination de la séquence-test des régions de faible complexité ou répétitives.
- Établissement d’une liste des « mots » de la séquence-test : ces mots sont les groupes de n lettres qui apparaissent dans la séquence ; typiquement, on prendra n = 3 pour les protéines et n = 11 pour les séquences d’ADN.
- Identification, dans la liste de mots établie à l’étape précédente, de ceux qui obtiennent un score élevé en regard d’une matrice de substitution ; les matrices de substitution, par exemple BLOSUM sont établies en fonction de la probabilité de substitution d’un acide aminé à un autre (certains acides aminés ont des propriétés voisines, d’autres pas du tout).
- Construction d’un arbre de recherche pour les mots retenus à l’étape précédente.
- Recherche parmi les séquences cibles des occurrences des mots retenus.
- Extension des zones de texte ainsi repérées en « regardant » si, à droite et à gauche du mot d’occurrence exacte, les textes ne seraient pas similaires ; la zone ainsi élargie est nommée high-scoring segment pair (HSP).
- Conservation des HSP dont le score est supérieur à un seuil choisi.
- Évaluation de la pertinence statistique des scores, par une analyse de la distribution des scores d’alignement entre la séquence-test et l’ensemble des séquences cibles ; BLAST ajuste cette distribution à une fonction de densité théorique, ce qui lui permet de calculer la probabilité et l’espérance mathématique de trouver un alignement donnant un score donné parmi les cibles, uniquement du fait du hasard ; les paramètres de cette fonction de densité varient en fonction des compositions en nucléotides ou acides aminés de la séquence et de la banque analysée. L’espérance mathématique calculée pour chaque alignement est nommée e-value. Pour des alignements biologiquement pertinents, la e-value prend des valeurs infinitésimales (de 10-10 à 10-200), ce qui signifie qu’il est hautement improbable que le score d’alignement obtenu soit le fait du hasard.
- Tentatives de combiner plusieurs HSP pour construire un alignement plus long.
- Affichage des alignements locaux, selon Smith Waterman, de la séquence-test et de chacune des cibles.

Les variantes suivantes du programme sont disponibles, selon la nature de la séquence-test et des séquences cibles :

- ADN - ADN : blastn ;
- protéine - protéine : blastp ;
- ADN - protéine : blastx ;
- protéine - ADN : tblastn ;
- ADN traduit en séquence de protéine contre une base de données de séquences nucléotidiques traduites en séquences de protéines : tblastx.

Le code génétique fait correspondre à chaque codon de trois nucléotides un acide aminé : de ce fait, lorsque l’on compare une séquence d’ADN à une séquence de protéine, il faut effectuer trois comparaisons, en décalant d’un nucléotide à chaque fois le cadre de lecture\indexcadre de lecture. De plus, étant donnée la structure en double hélice de l’ADN, il est utile d’effectuer la même opération en sens inverse sur le brin complémentaire. Cette démarche est nommée traduction selon six cadres de lecture (six-frame translation). Une seule de ces six traductions sera éventuellement significative biologiquement (susceptible de correspondre à une traduction vers une protéine réelle).

La fonction qblast du module Bio.Blast.NCBIWWW permet d’invoquer en Python la version en ligne sur le site du NCBI de BLAST, qui attend les arguments suivants :

- la version du programme à utiliser : blastn, blastp, blastx, tblast ou tblastx ;
- la banque de données à interroger ;
- la séquence à comparer.

Par exemple, pour interroger la banque de données de nucléotides à propos d’une séquence dont vous connaissez l’identifiant dans la GenInfo integrated database, procéder ainsi :

  1. #!/usr/bin/env python3
  2. import sys
  3. from Bio.Blast import NCBIWWW
  4. from Bio.Blast import NCBIXML
  5. def Blast_sonde(blastversion, collection, gi):
  6.     result_handle = NCBIWWW.qblast(blastversion, collection, gi)
  7.     blast_record = NCBIXML.read(result_handle)
  8.     E_VALUE_THRESH = 0.04
  9.     for alignment in blast_record.alignments:
  10.         for hsp in alignment.hsps:
  11.             if hsp.expect < E_VALUE_THRESH:
  12.                 print("****Alignment****")
  13.                 print("sequence:", alignment.title)
  14.                 print("length:", alignment.length)
  15.                 print("e value:", hsp.expect)
  16.                 print(hsp.query[0:75] + "...")
  17.                 print(hsp.match[0:75] + "...")
  18.                 print(hsp.sbjct[0:75] + "...")
  19.  
  20. blastversion = sys.argv[1]
  21. collection = sys.argv[2]
  22. gi = sys.argv[3]
  23. Blast_sonde(blastversion, collection, gi)

Télécharger

avec la ligne de commande :

./BLAST-biopython.py blastn nt 8332116

donnera le résultat suivant (abrégé et tronqué à droite pour les besoins de la mise en page), dont vous trouverez une bonne explication dans le document Understanding the Output for a blastn Search de l’université Washington (Saint-Louis, Missouri) :

On remarque la programmation par objets et l’usage de la classe blast_record, qui fournit toutes les informations que l’on peut souhaiter obtenir d’une sortie de BLAST, comme les objets result_handle et alignment par exemple.

Wilson Leung a également écrit une brève introduction à BLAST. Ici encore nous renvoyons au manuel pour les détails.

 Que penser de Biopython ?

Nous n’avons donné ci-dessus qu’un survol rapide de quelques-unes des nombreuses possibilités de Biopython, qui permet au biologiste d’effectuer à peu près toutes les opérations informatiques dont il peut avoir besoin.

La chose dont il convient d’avoir conscience, c’est que Biopython donne un moyen d’accomplir ces opérations sans acquérir les connaissances qui font l’objet des chapitres précédents de ce livre, c’est-à-dire sans savoir « comment ça marche », comment se programment les algorithmes mis en œuvre ; ce défaut de connaissances peut être toléré pour un emploi de technicien qui travaille en routine, mais quiconque aspire aux fonctions d’ingénieur ou de chercheur, ou en un mot de bioinformaticien, ne saurait se dispenser de ces apprentissages, ne serait que pour utiliser Biopython en connaissance de cause.

Un autre point qui mérite attention : nous avons suggéré au lecteur qu’il était souhaitable, pour la qualité du logiciel, d’écrire des fonctions et de structurer ses programmes par appels de fonctions. Biopython, comme nous venons de le voir, par sa facilité d’usage, incline au style de programmation plus relâché des langages de script. Nous ne saurions trop encourager à la vigilance contre cette facilité à laquelle nous avons nous-même parfois cédé dans ce chapitre.