Eléments de base du langage Python et de quelques modules BioPython appliqués aux données biologiques
Flux RSS

 

1. Introduction

2. Quelques éléments de base

3. Les modules BioPython

4. L'interrogation d'une base de données - Les outils "E-Utils" de Entrez (NCBI)

5. L'interface Python tutor

 

6. Les expressions régulières ou motifs

7. Détail d'un script de recherche de motif - expression régulière

8. Scripts divers

9. Notions de base d'objet, de classe et d'attribut

10. Liens Internet et références bibliographiques

 

Thèmes abordés et supports pour la séance de travaux dirigés


1. Introduction

a. Pour exécuter un script Python :

  • Ecrire comme première ligne du script : #!/usr/bin/env python. Cette ligne permet au système Unix de trouver le logiciel à utiliser pour interpréter la suite du fichier.
  • Les caractères #! s'appelle "shebang" (cet en-tête indique au système d'exploitation Unix que le fichier est un script).
  • On exécute ensuite le script "toto.py" avec la commande : python toto.py

b. L'environnement IDLE

  • IDLE ("Integrated DeveLopment Environment") est un environnement de développement intégré (EDI). Il existe un très grand nombre d'EDI.
  • IDLE contient un certain nombre d'outils d'aide au développement de programmes en Python.
  • En particulier tkinter ("Tool kit interface") : c'est une bibliothèque graphique libre qui permet de crééer des interfaces graphiques.
  • Voir un tutoriel : "Créer des graphiques scientifiques avec python".

Quelques différences Python 2 versus Python 3

Caractéristique Python 2 Python 3
Version de Python

Obsolète (dernière version 2.7)
C'est cependant encore le code de nombreux scripts non modifiés.

Python 3 a été publié en 2008
Dernière version Python 3.12

Commande pour afficher la version de Python python --version python3 --version
Mot-clé "print" instruction - pas de parenthèse [exemple : print "toto" ] fonction - parenthèses [exemple : print ("toto") ]
Stockage des chaînes en ASCII par défaut en UNICODE par défaut
Division d'entiers la division de 2 entiers donne un entier (exemple : 5/2 -> 2) la division de 2 entiers donne un chiffre à virgule (exemple : 5/2 -> 2,5)
Exceptions entourées de notations entre parenthèses
(Rétro)compatibilité Python 2 peut être porté vers Python 3 pas compatible avec Python 2
Voir le document différences Python V2 vs. Python V3

Retour haut de page

2. Quelques éléments de base

Les mots-clés réservés en Python ne peuvent pas être utilisés comme nom de variable.

and del from none true as elif global nonlocal try assert else if not while
break except import or with class false in pass yield continue finally is raise
def for lambda return

 

L'indentation : les blocs de code (fonctions, instructions, boucles, ...) sont délimités par une indentation (décalage du texte d'un ou plusieurs espace(s) ou tabulation(s)). L'indentation indique le début d'un bloc et la désindendation la fin de ce bloc.

def fonction(n):
  print 'n =', n
  if n > 1:
    return n * fonction(n - 1)
  else:
    print 'fin'
    return 1     

L'indentation nécessite 4 espaces selon la PEP8. Les espaces sont préferés aux tabulations.

Le code situé après le caractère # (dièse) est igoré : il s'agit de commentaires .

Les commentaires sont très importants pour bien décrire et comprendre un script.

Exception : la commande #!/usr/bin/env python (voir ci-dessus) n'est pas interprétée comme un commentaire.

Indentation - suite : tester les 2 scripts suivants et expliquer la différence de résultats :

nucleotides = ['A','T','G','C']
for N in nucleotides:
   if N == 'A':
      print "la variable N"
   print "a pour valeur", N
 
nucleotides = ['A','T','G','C']
for N in nucleotides:
   if N == 'A':
      print "la variable N"
      print "a pour valeur", N

Le symbole deux points : est également un délimiteur en Python. Il indique au langage qu'il doit attendre un bloc d'instructions :

instruction 1:
   instruction2
   instruction3

Les instructions for, while (boucles) et if (conditions) doivent se terminer par le symbole deux-points :

liste = ['mot1','mot2','mot3']
for i in liste:
   print i    #commentaire : indentation de cette instruction 

Interaction avec l'utilisateur

  • print() : permet d'écrire ou d'afficher un résultat à l'écran. La virgule est utilisée comme séparateur.
  • input() : permet à l'utilisateur de saisir des données au clavier. Cette commande renvoie toujours du texte : il est nécessaire de transtyper en entier ("int") ou en réel ("float") lors de la saisie de valeurs numériques.
  • raw_input() : renvoie une chaîne de caractères / il est nécessaire de la transtyper en entier ("int") ou en réel ("float") si un nombre est demandé.

L'espace est le séparateur d'instructions :

  • print (Toto) => correct
  • print(Toto) => renvoie le message d'erreur "NameError: name 'printToto' is not defined"

Quelques messages d'erreurs

Traceback (most recent call last):
SyntaxError: invalid syntax
IndentationError: expected an indented block

Lecture

r : ouverture en lecture (READ).
w, ouverture en écriture (WRITE). A chaque ouverture le contenu du fichier est écrasé. Si le fichier n'existe pas, il est créé.
a : ouverture en mode addition à la fin du fichier (APPEND). Si le fichier n'existe pas, il est créé.
b : ouverture en mode binaire (BINARY).
t : ouverture en mode texte (TEXT).
x : crée un nouveau fichier et l'ouvre pour écriture

La méthode read() lit l'ensemble du contenu d'un fichier et renvoie une chaîne de caractères unique.

Ecriture

fichier = open("data.txt", "a")
fichier.write("Je m'appelle Toto")
fichier.close()

Lecture - suite

La méthode readline() (sans "s") :

  • lit une ligne d'un fichier et renvoie une chaîne de caractères
  • chaque nouvel appel de "readline()" renvoie la ligne suivante
  • cette méthode associée à une boucle "while" permet de lire un fichier ligne par ligne

La méthode readlines() (avec un "s") renvoie une liste avec toutes les lignes du fichier lu.

Exemple : on applique la méthode "readlines()" sur l'objet "LireLesLignes"

LireLesLignes = open('Fichier.fasta', mode = 'r')
LireLesLignes.readlines()
LireLesLignes.close()

Exemple d'importation de bibliothèques

import sys
import re
from Bio import Entrez

bioinformatique bioinformatics langage python Python module bibliotheque biopython from import programmation programming software script sequence fasta protein ADN DNA motif genomique proteomique transcriptomique metabolomique genomics transcriptomics proteomics Seq SeqIO Entrez commande Unix matplot numpy tkinter biochimej

Source : Datacamp

Retour haut de page

Créer une fonction

def nom_fonction(parametre 1, parametre 2, parametre 3, ..., parametre n) :
   Bloc d'instructions

La syntaxe :

  • def (mot-clé / abréviation de « define ») : début de la construction de la fonction.
  • Le nom de la fonction : ne doit pas être une variable déjà instanciée.
  • La liste des paramètres (entre parenthèses) fournis lors de l'appel de la fonction : ils sont séparés par des virgules et les parenthèses sont obligatoires même si la fonction n'attend pas de paramètre.
  • Les deux points : fermeture de la ligne de définition de la fonction.

Exemple (Python version 3.6) :

def table_de_multiplication(max):
  multiplicateur = input("choisissez un multiplicateur : ")
  m = int(multiplicateur)    #Evite : Type Error: < not supported between instances of int and str
  max = input("choisissez un nombre maximum a multiplier : ")
  n = int(max)
  compteur = 0               # initialisation du compteur a 0
  while compteur < n:        # tant que compteur est strictement inferieur a la valeur de la variable max
    print((compteur + 1),"*",(m), "=" ,(compteur + 1) * (m))      # attention aux parentheses pour print en 3.6
    compteur += 1      # on incremente compteur de 1 a chaque tour de boucle 
table_de_multiplication(max)  # appel de la fonction

Execution du script

a. Coller les lignes suivantes dans l'interpréteur Python (attention à l'indentation)

def table_de_multiplication(max):
  multiplicateur = input("choisissez un multiplicateur : ")
  max = input("choisissez un nombre maximum a multiplier : ")
  compteur = 0           # le compteur
  while compteur < max:   # Tant que compteur est strictement inferieur a la valeur de la variable max
    print(compteur + 1),"*",(multiplicateur), "=" ,(compteur + 1) * (multiplicateur)
    compteur += 1      # On incremente compteur de 1 a chaque tour de boucle

b. Taper 2 fois sur la touche "Entrer". On obtient :

>>> def table_de_multiplication(max):
  ...  multiplicateur = input("choisissez un multiplicateur : ")
  ...  max = input("choisissez un nombre maximum a multiplier : ")
  ...  compteur = 0           # le compteur
  ...  while compteur < max:   # Tant que compteur est strictement inferieur a la valeur de la variable max
  ...    print(compteur + 1),"*",(multiplicateur), "=" ,(compteur + 1) * (multiplicateur)
  ...    compteur += 1      # On incremente compteur de 1 a chaque tour de boucle
  ...
>>> 

Retour haut de page

3. Les modules BioPython

BioPython fournit des fonctions et des procédures pour traiter et analyser des données biologiques avec le langage Python.

Les scripts sont rassemblés sous forme de modules (et sous-modules) ou d'ensembles de script ("package") :

  • Bio (Bio package) : Collection of modules for dealing with biological data in Python.
  • BioSQL (BioSQL package) : Storing and retrieve biological sequences in a BioSQL relational database.
Exemples de modules de la collection "Bio" pour la manipulation de séquences d'acides aminés et de nucléotides
Nom du module (et lien internet) But Syntaxe pour l'import Exemples de classes Exemples de fonctions
Bio.AlignIO (Package AlignIO) Multiple sequence alignment input/output as alignment objects. The Bio.AlignIO interface is deliberately very similar to Bio.SeqIO. from Bio import AlignIO ----- -----
Bio.Alphabet (Package Alphabet) Alphabets used in Seq objects etc to declare sequence type and letters.

from Bio.Alphabet import IUPAC

from Bio.Alphabet import generic_dna, generic_protein

Alphabet, SingleLetterAlphabet, ProteinAlphabet, NucleotideAlphabet _consensus_alphabet(alphabets)
Bio.Entrez (Package Entrez) Provides code to access NCBI over the WWW. from Bio import Entrez ----- esearch(db, term, **keywds)
esummary(**keywds)
einfo(**keywds)

Exemple de script qui renvoie le titre et les auteurs de 2 publications dans Pubmed dont les identifiants sont "27297221" et "22615859" :

from Bio import Entrez
Entrez.email = "imele@toto.mars"
requete = Entrez.einfo()
enregistrement = Entrez.read(requete)
requete.close()
requete = Entrez.esummary(db="pubmed", id="27297221,22615859", retmode="xml")
ListEnregistrements = Entrez.parse(requete)
for enregistrement in ListEnregistrements:
     print "Titre de l'article :", (enregistrement['Title'])
     print "Auteurs :", (enregistrement['AuthorList'])
Bio.SearchIO (Package SearchIO) Biopython interface for sequence search program outputs. from Bio import SearchIO ----- parse, read, to_dict, index, index_db, write, convert
Bio.Seq (Module Seq) Provide objects to represent biological sequences with alphabets. from Bio.Seq import Seq Seq, UnknownSeq, MutableSeq transcribe(dna)
translate(sequence, table='Standard', stop_symbol='*', to_stop=False, cds=False, gap=None)
reverse_complement(sequence)
complement(sequence)
Voir un complément sur Seq.

Bio.SeqIO (Package SeqIO)

Sequence input/output as SeqRecord objects. from Bio import SeqIO ----- convert(in_file, in_format, out_file, out_format, alphabet=None)
parse(handle, format, alphabet=None)
read(handle, format, alphabet=None)
write(sequences, handle, format)

Voir un complément sur SeqIO.

Exemple de script avec un fichier "Fichier.fasta" disponible :

from Bio import SeqIO
for record in SeqIO.parse("Fichier.fasta", "fasta"):
   print(record.id)

Autre forme de ce script avec "with" et "handle":

from Bio import SeqIO
with open("Fichier.fasta", "rU") as handle:
   for record in SeqIO.parse(handle, "fasta"):
      print(record.id)
Bio.SeqUtils (Package SeqUtils) Miscellaneous functions for dealing with sequences. from Bio.SeqUtils import GC ----- GC(seq)
nt_search(seq, subseq)
six_frame_translations(seq, genetic_code=1)
Bio.motifs (Package motifs) Tools for sequence motif analysis. from Bio import motifs Instances, Motif create(instances, alphabet=None)
parse(handle, format)
read(handle, format)
write(motifs, format)
Bio.pairwise2 (Module pairwise2) Pairwise sequence alignment using a dynamic programming algorithm. from Bio import pairwise2 identity_match, dictionary_match, affine_penalty _align(sequenceA, sequenceB, match_fn, gap_A_fn, gap_B_fn, ...)
_make_score_matrix_generic(sequenceA, sequenceB, ...)
_recover_alignments(sequenceA, sequenceB, ...)

Exemple de script qui aligne 2 séquences de nucléotides :

from Bio import pairwise2
from Bio.pairwise2 import format_alignment
alignments = pairwise2.align.globalxx("ACCGT", "ACG")
print(format_alignment(*alignments[0]))

Retour haut de page

4. L'interrogation d'une base de données - Les outils E-Utils de Entrez au NCBI

Voir la syntaxe de tous les parametres des fonctions "esearch", "esummary", "efetch", "epost", "elink" et autres de Eutils - NCBI.

L'URL de base est : https://eutils.ncbi.nlm.nih.gov/entrez/eutils/

Quelques exemples de parametres additionnels :
db=pubmed : recherche effectuee dans la base de donnees PubMed / Autres exemples : db=nucleotide ou db=structure ou db=taxonomy
db=protein&term=16000:60000[molecular+weight] : recherche dans la base de donnees "Protein" de proteines de masses molaires entre 16 kDa et 60 kDa
retmode=xml : renvoie une chaîne au format XML - les methodes "read" et "parse" necessitent xml
retmode=json : renvoie une chaîne au format JSON (JavaScript Object Notation) plus lisible qu'un fichier XML
retmax=10 : renvoie 10 resultats
datetype : les parametres usuels de dates sont "mdat" (modification date), "pdat" (publication date) et "edat" (Entrez date)
term="la requete" => la requete entree dans l'URL directement ou via un formulaire
field => limite la recherche au champ spécifié
remarque : retmode, retmax, rettype, datetype, field, ... sont optionnels

motCle = raw_input ("Entrez votre mot cle : ") 		# "motCle" est renvoye dans la fonction "rechercheBiblio()"
def rechercheBiblio(motCle):       					# Definition de la fonction "rechercheBiblio()"
Entrez.email = 'adress.mail@toto.com' # Le NCBI exige une adresse e-mail
parametresRecherche = Entrez.esearch(db='pubmed',retmax='10',datetype='PDAT',retmode='xml',term = motCle

On genere l'URL suivante pour la requête au NCBI : https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi?db=pubmed&retmax=10&datetype=PDAT&retmode=xml&term=motCle

Abréviations et syntaxe de quelques champs de fichiers GenBank ou GenPep :
[ACCN] : Accession / [ALL] : All Fields / [AUTH] : Author / [GPRJ] : BioProject / [ECNO] : EC/RN Number / [FKEY] : Feature key
[GENE] : Gene Name / [JOUR] : Journal / [KYWD] : Keyword / [MLWT] : Molecular Weight / [ORGN] : Organism
[PROT] : Protein Name / [SLEN] : Sequence Length / [SUBS] : Substance Name / [WORD] : Text Word / [TITL] : Title / [UID] : UID

Liste des UIDs : Entrez Unique Identifiers for selected databases

Voir un exemple de script Python 3.8 de recherche d'articles dans PubMed sur la base de mots clé. Il nécessite l'installation du module Bio de BioPython.

Retour haut de page

5. L'interface WEB Python tutor

Aller à "Python tutor". Coller le texte du script ci-dessous dans la fenêtre de l'interface : attention au respect de l'indentation de ce texte.

Script Python version 3.6 :

def denombre(sequence,nucleotide):  		# definition de la fonction denombre
    compteur_nucleotide = 0                     # compteur du nucleotide choisi
    for nucleotide_lu in sequence:
        if nucleotide_lu == nucleotide:
            compteur_nucleotide += 1
    return compteur_nucleotide	
sequence = input("sequence a analyser : ")  	       
nucleotide = input("nucleotide a denombrer : ")     # input et non raw_input
n = denombre(sequence,nucleotide) 				   
print ('%s apparait %s fois dans %s' % (nucleotide, n, sequence))   # doubler les parentheses

Cliquer sur "Visualize Execution".
Dans la nouvelle fenêtre :

  • Cliquer sur "Forward" => execute la première ligne.
  • Taper la séquence à analyser dans la fenêtre qui s'ouvre puis cliquer sur "Submit".
  • Taper le nucléotide à rechercher dans la fenêtre qui s'ouvre puis cliquer sur "Submit".
  • Cliquer sur "Forward" jusqu'à la fin de l'exécution du script.

Examiner le script modifié : les lettres de la séquence entrée par l'utilisateur sont changées en majuscules et tous les caractères autres que A, T, G ou C sont supprimés par une méthode utilsant une expression régulière.

Retour haut de page

6. Les expressions régulières ou motifs ou expressions rationnelles

Elles nécessitent le module re avec la commande : import re

Elles sont construites et sont décryptées de gauche à droite. La chaîne de caractères qui compose une expression régulière s'appelle un motif.

Les raw string : la syntaxe des motifs peut inclure l'anti-slash qui doit être lui-même échappé. La notation devient lourde et complexe. On évite cet inconvénient en préfixant les motifs par la lettre "r". Exemple : '[\\d\\s]' devient r'[\d\s]'

a. Syntaxe et signification de quelques expression régulières

Expression régulières fonction - caractère(s) recherché(s) et position
. tous les caractères sauf \n (retour chariot)
remarque : pour désigner le caractère point ".", il faut un caractère d'échapement et l'on écrit l'expression \.
* l'expression régulière qui précède est répétée 0 à n fois
+ l'expression régulière qui précède est répétée 1 à n fois => exemple : 0x[0-9ABCDEF]+
expreg1 | expreg2 l'opérateur | ("pipe") correspond à "ou" => on recherche l'expression régulière 1 ou l'expression régulière 2
[abc] ou [XYZ] les lettres a, b et c (minuscules) dans cet ordre ou les lettres X,Y et Z (majuscules) dans cet ordre
[a-z]
[^a-z]
les lettres minuscules de a à z = ensemble de l'alphabet
tous les caractères sauf [a-z]
{n,m}
{n,}
{,m}
l'expression régulière qui précède est retrouvée de au moins n fois à au plus m fois
l'expression régulière qui précède est retrouvée au moins n fois
l'expression régulière qui précède est retrouvée au plus m fois
\w
\W
tous les caractères alphanumériques (unicode), chiffres et _ (caractère souligné) - équivalent à la classe [a-zA-Z0-9_]
tous les caractères non alphanumériques (caractères non recherchés par) \w) - équivalent à la classe [^a-zA-Z0-9_]
\s
\S
tous les caractères d'espacement (espace, tabulation, retour chariot, ...) - équivalent à la classe [ \t\n\r\f\v]
tous les caractères qui ne sont pas caractères d'espacement (caractères non recherchés par \s) - équivalent à la classe [^ \t\n\r\f\v]
[0-9] ou \d
[^0-9] ou \D
tous les chiffres
tous les caractères qui ne sont pas des chiffres (caractères non recherchés par \d)
^ ou \A caractère au début de la chaîne de caractères ou de la ligne
$ ou \Z caractère à la fin de la chaîne de caractères ou de la ligne
\b
\B
caractère vide au début ou à la fin d'un mot
caractère vide sauf au début ou à la fin d'un mot
\n retour chariot
\t tabulation
Syntaxes des expressions régulières et opérations en Python 3.

Retour haut de page

b. Compléments sur les métacaractères ou caractères spéciaux

Les métacaractères sont : . ^ $ * + ? { } [ ] \ | ( )

Le métacaractère [ ] définit une classe de caractères. Le tiret (exemple [0-9]) traduit l'intervalle de la classe.
Il existe des classes pré-définies. Exemples : [[:alpha:]] désigne n'importe quelle lettre; [[:digit:]] désigne n'importe quel chiffre; [[:blank:]] désigne espace ou tabulation.

Le métacaractère ^ a 2 significations tout à fait différentes :
^motif : la chaîne de caractères recherchée commence par le motif considéré
[^motif] : la chaîne de caractères recherchée ne contient pas les caractères contenus dans le motif

Le métacaractère $ : l'expression motif$ signifie que la chaîne de caractères recherchée se termine par le motif

Le métacaractère ? : l'expression motif? signifie 0 ou 1 occurrence du motif
Le métacaractère * : l'expression motif* signifie 0, 1 ou n occurrences du motif
Le métacaractère + : l'expression motif+ signifie 1 ou n occurrences du motif

Quelques exemples
^[a-z]*$ chaîne vide ou qui contient un ensemble de lettres minuscules. Elle se traduit par : commence par une lettre (^[a-z]) puis d'autre(s) (*) lettre(s) jusqu'à la fin ($).
-?[A-Z] une lettre majuscule (^[A-Z]) éventuellement (?) précédée (signe - écrit avant le métacaractère ?) du signe moins.
^[ a-z]*$ attention : il y a un espace entre le crochet ouvrant et la lettre "a". il s'agit donc d'une chaîne de caractères constituée de lettres minuscules séparées par un ou plusieurs espaces.
les métacaractères * et + renvoient la plus longue chaîne de caractères possible la recherche du motif 1* dans la chaîne "xyz111E" renvoie "111".
"et / ou" : + et | ("pipe") (xy)+ signifie xy ou xyxy ou xyxyxy ou ...
x+y+ signifie n fois x suivis de n fois y
(x|y)+ signifie une chaîne constituée de n fois x et/ou y

Exemples de combinaisons d'expressions régulières

  • r'[\d\s]' : recherche tous les chiffres et les caractères d'espacement
  • r'(0x[0-9ABCDEF]+)[\s,.:] | (0x[0-9ABCDEF]+)$' : recherche de nombre(s) hexadécimal(aux) n'importe où dans une phrase.
    Explication de la syntaxe : le(s) nombre(s) (0x[0-9ABCDEF]) peut(ven)t être présent(s) 1 à n fois (+) et se termine(nt) par un espace ([\s,.:]) ou ( | ) se situe(nt) à la fin de la chaîne de caractères ($).

Afin d'en simplifier la lecture, on peut écrire une expression régulière complexe sur plusieurs lignes avec 3 apostrophes ('multiline string') en début et fin :

expresionComplexe = re.compile(r'''(
(\d{3}|\(\d{3}\))?
(\s|-|\.)?
\d{3}
)''')

Test sur les expressions régulières : aller à la page "Les expressions régulières en python" et faire le test "TRUE" / "FALSE" proposé.

Retour haut de page

c. Expressions régulières puissantes

α. Recherche en avant

texte(?=motif) : expression régulière qui vérifie que le texte est suivi du motif avant de sélectionner ce texte. C'est une recherche "positive en avant" ("positive lookahead").

texte(?!motif) : expression régulière qui vérifie que le texte n'est pas suivi du motif avant de sélectionner ce texte. C'est une recherche "négative en avant" ("negative lookahead").

Le texte et le motif peuvent être une expression complexe.

Exemple : l'expression Isaac(?=Asimov) récupère "Isaac" seulement si il est suivi de "Asimov".

 

β. Recherche en arrière

(?<=motif)texte : expression régulière qui vérifie que le texte est précédé du motif avant de sélectionner ce texte. C'est une recherche "positive en arrière" ("positive lookbehind").

(?< !motif)texte : expression régulière qui vérifie que le texte n'est pas précédé du motif avant de sélectionner ce texte. C'est une recherche "négative en arrière" ("negative lookbehind").

Attention : le texte et le motif ne peuvent pas être une expression complexe.

Exemple 1 : l'expression (?<!a)b reconnait un "b" non précédé d'un "a". Cette expression ne reconnait donc pas le "b" de "table" mais reconnait le "b" (et seulement le "b") de "banane".

Exemple 2 : 
import re
m = re.search("(?<=abc)def", "abcdef")
m.group(0)
'def'
Voir un développement.

Retour haut de page

d. Quelques méthodes liées aux expressions régulières ou motifs

  • Le module re est dédié aux expressions régulières qu'on appelle aussi motif ("pattern").
  • La syntaxe pour invoquer ce module est : import re
  • Voir le code source de re.

Les méthodes "match()" et "search()" renvoient "None" si aucune correspondance n'est trouvée.

Si une correspondance est trouvée, elles renvoient une instance "MatchObject" qui contient les informations sur la correspondance : son début et sa fin, la sous-chaine avec laquelle elle correspond,...

La méthode "match()" recherche une correspondance au début de la chaîne de caractères.
Dans l'exemple ci-contre, le résultat est stocké dans la variable "correspondance".

Attention à la syntaxe (apostrophe, virgule de séparation, parenthèses).

correspondance = re.match('motif','chaîne de caractères dans laquelle rechercher le motif')

La méthode "search()" recherche une correspondance dans toute la chaîne de caractères et/ou dans la première ligne du texte.

L'option "re.MULTILINE" (= re.M) permet de chercher dans toutes les lignes.

correspondance = re.search('motif','chaîne de caractères dans laquelle rechercher le motif')

Exemple :
>>> import re
>>> chaîne = 'element1 element2 element13'
>>> re.search('element1',chaîne)
<_sre.SRE_Match object at 0x1055fcac0>
>>> if re.search('element1',chaîne):
      print 'element1 est present dans chaîne'
...
=> Résultat : element1 est present dans chaîne

La méthode "sub()" remplace toutes les occurrences du motif par un autre motif.

La méthode "sub()" renvoie la chaîne de caractères modifiée.

correspondance = re.sub('motif','motif de remplacement','chaîne de caractères dans laquelle rechercher l'expression')

Exemples :
resultat = re.sub(r'toto', '', texte) => élimine le motif "toto"
resultat = re.sub(r'toto', 'titi', texte) => remplace le motif "toto" par le motif "titi"
resultat = re.sub(r'\s+', '\s', texte) => élimine les espaces doubles
resultat = re.sub(r'toto(est grand)toto', '\1', texte) => remplace une chaîne de caractères par une partie d'elle-même

La méthode "compile()"

Il peut être avantageux en terme de mémoire et de temps de conserver une version compilée du motif.

Par exemple, déclaration et compilation une seule fois au démarrage d'un serveur => ces opérations ne sont pas refaites à chaque requête.

La méthode "compile()" renvoie un objet de type expression régulière ("<_sre.SRE_Pattern object at 0x1055fcac0>") qui peut ètre utilisée avec les méthodes "search()" ou "findall()".

Exemple 1 :
import re
texte = "Un porc-épic epique ou épique qui se pique avec l'as de pique."
correspondance = re.compile(r'pique')
correspondance.findall(texte)
=> Résultat : ['pique', 'pique', 'pique', 'pique']

Exemple 2 :
import re
texte = "Un porc-épic epique ou épique qui se pique avec l'as de pique."
correspondance = re.compile(r"\w*\Bpique\w*|\w*pique\B\w*")
correspondance.findall(texte)
=> Résultat : ['epique'] / le mot "épique" (avec l'accent) n'est pas comptabilisé.

Application

recherche 'positive et négative en avant'

recherche 'positive et négative en arrière'

correspondance = re.compile(r'(?!pique)e')
=> Résultat : ['e', 'e', 'e', 'e', 'e', 'e', 'e', 'e']

correspondance = re.compile(r'(?<=pique)e')
=> Résultat : []

correspondance = re.compile(r'(?<!pique)é')
=> Résultat : ['\xc3\xa9', '\xc3\xa9'] à cause de l'accent sur le "é".

La méthode "findall()"renvoie les éléments qui correspondent sous forme d'une liste.

 

La méthode "findall()" peut-être appliquée à un fichier.

Exemple 1 :
import re
texte = "Il vint rapidement et aisément dans un carosse aimablement prêté et évidemment beau."
correspondance = re.findall(r"\w+ment", texte)
print correspondance
=> Résultat : ['rapidement', 'aimablement', 'videmment']

Exemple 2 :
import re
fichierLu = open('fichier.txt', 'r') # (Il faut un fichier !)
listeOccurences = re.findall(r'motif a trouver', fichierLu.read())

La méthode "split()"découpe - sépare la chaîne de caractères selon le motif.

 

Elle renvoie les éléments qui correspondent sous forme d'une liste.

correspondance = re.split('motif','chaîne de caractères dans laquelle rechercher l'expression')

Exemple 1 :
correspondance = re.split('\W+', 'Mots, mots, mots.')
=> Résultat : ['Mots', 'mots', 'mots', '']

Exemple 2 :
correspondance = re.split('(\W+)', 'Mots, mots, mots.')
=> Résultat : ['Mots', ', ', 'mots', ', ', 'mots', '.', '']

Voir l'ensemble des méthodes à base d'expressions régulières (ou rationnelles) - Python version 3.6.

Retour haut de page

7. Détail d'un script de recherche de motif - expression régulière

# !/usr/bin/env python
# -*-coding:Utf-8 -*
import sys
import re
from Bio import SeqIO
# Le systeme SeqIO retourne des objects de type "SeqRecord"
def LectureFichier(FichierTraite):
    try :
        OuvertureFichier = open(FichierTraite, 'r')
    except IOError :
        print ("Erreur d'ouverture de fichier"),FichierTraite
        sys.exit()
# 1ere partie : FONCTION lecture de fichier
# Test ouverture du fichier et instruction de sortie si erreur
# la variable "FichierTraite" designe n'importe quel fichier que l'on desire ouvrir
# Attention à l'indentation (espace)
    indice = 0
    for ChaqueSequence in SeqIO.parse(FichierTraite, 'fasta'):
        indice = indice+1
        print ("Sequence numero"), indice
        print(ChaqueSequence.format("fasta"))
# 2eme partie : "parsing" des differents items qui commencent par ">" du fichier a lire
# Si fichier GenBank (par exemple) => remplacer ".fa" par ".gbk" et "fasta" par "genbank"
#.format() est une methode qui convertit l'objet "SeqRecord" en une chaîne en utilisant l'une des options de sortie de Bio.SeqIO
# Attention à l'indentation (espace)
    PremiereLigneFichier = OuvertureFichier.readline().strip() # 3eme partie : Decoupage des lignes du fichier lu
# la methode "readline()" lit une ligne a la fois => en l'occurence la 1ere ligne : ">Texte informatif"
# cette methode n'est appelee qu'une fois donc seule la 1ere ligne est traitee /
# la methode readline() renvoie une chaîne DE CARACTERES
# la methode "strip()" enleve "\n" de fin de ligne
    Sequence = '' # initialise la variable chaîne de caractere "sequence" qui est vide au depart
    for ligne in OuvertureFichier.readlines(): # methode "readlines()" : attention au "s" cette fois / cette methode lit toutes les lignes ("for")
# a partir de la 2eme ligne puisque readline() precedent a place le curseur sur la 2eme ligne
# la methode readlines() renvoie une LISTE
    ligne.strip()
    Sequence = Sequence + ligne.strip()
return(PremiereLigneFichier, Sequence)
OuvertureFichier.close()
# la methode "strip()" enleve "\n" de fin de chaque ligne en cours
# concatene la ligne en cours avec la precedente => la variable sequence ajoute chaque nouvelle ligne lue
# renvoie 2 variables : la variable PremiereLigneFichier et la variable Sequence
# Attention a l'indentation sinon "NameError: name 'OuvertureFichier' is not defined
def RechercheMotif(Motif, ChainAtraiter): # FONCTION recherche du motif
# "Motif" est le nom generique de la variable specifique passee en 1er parametre lors de l'appel de la fonction "RechercheMotif"
# "ChainAtraiter" est le nom generique de la variable specifique passee en 2e parametre lors de l'appel de la fonction "RechercheMotif" (dans le cas present la variable "sequence")
    MotifTransforme = re.compile(Motif)
    MotifTrouve = re.finditer(MotifTransforme, ChainAtraiter)
# la methode "compile" : transforme en veritable expression reguliere
# la methode "finditer" : recherche toutes les occurences du motif considere de gauche a droite et enregistre les positions de ce motif
# ces positions sont renvoyees par la suite avec les methodes "start()" et "end()" ci-dessous
    for position in MotifTrouve:
        print position.start(),"-",position.end()," : ", position.group()
return MotifTrouve
# Exemple de positions de debut et de fin d'un motif trouve => 2 - 6 : HLGH et la methode "group()" renvoie le motif trouve
# attention : "print position" est indente 2 fois
# attention : indenter le "return"
FichierTraite = input("Nom du fichier de sequence : ")
(PremiereLigneFichier, Sequence) = LectureFichier(FichierTraite)
# Entree des donnes a traiter : fichier a lire et motif recherche
print ("Resultat intermediaire")
print ("Variable Premiere ligne du fichier : "), PremiereLigneFichier
print ("Variable Sequence : "), Sequence
print ("Longueur de la sequence : "), len(Sequence)
# Divers affichages
ExprREGUL = input("Expression reguliere / exemple : GA[ATGC]{3}AC : ") # Saisir une expression reguliere au clavier
print ("Resultat final")
ResExpRegul = RechercheMotif(ExprREGUL, Sequence)
# Affichage des resultats
# prend comme parametre de la fonction "RechercheMotif" : Motif = ExprREGUL et ChainAtraiter = Sequence

Retour haut de page

8. Scripts divers

But des scripts scripts (Python v. 2.7) via une page web
Afficher les identités entre 2 séquences Affichage identite -----
Utilisation de "def" et "while" / Données saisies par l'utilisateur Table multiplication -----
Dénombrement des nucléotides dans une séquence et calcul du Tm
Entrer une sequence et la nettoyer / ouvrir et lire un fichier / liste et dictionnaire / affichages
Description de l'utilisation de Python tutor

Dénombrement Python 2
Dénombrement Python 3

Dénombrement - Tm

Recherche d'articles dans PubMed - NCBI (via Entrez et les outils Eutils) sur la base de mots clés
Module "from Bio import Entrez" / module "urllib.request"
Entrez (NCBI) Recherche PUBMED
Utilisation de "def" et "while" - Données saisies par l'utilisateur
Module "re" / module "from Bio import SeqIO"
Reg_Exp Motif
Fichier test.fa
-----
Calcul de l'hydrophobicité moyenne d'un peptide - dictionnaire et liste - récurrence Hydrophobicité -----
Calcul de l'hydrophobicité moyenne d'un peptide - fichier de valeurs externe
Entrer une sequence et la nettoyer / liste et dictionnaire/ affichage du décours du calcul/ écrire et lire un fichier
Hydrophobicité
Fichier hydrophobicite.txt
Hydrophobicité moyenne
Profil d'hydrophobicité affiché avec une fenêtre de taille n = 7 ou variable.
Bibliothèques SeqIO, pylab et numpy.
Voir le cours : "Bionformatique : analyse et prédiction des structures des protéines".

Profil hydrophobicité (fenêtre)
Fichier test P11229.fa

Profil hydrophobicité
Interrogation de la base de données NCBI - Récupération des informations GenPept : outils Eutils
Classe et objet / liste et dictionnaire
Bibliothèques BioPython, pylab et numpy.
Voir le cours : "Relation structure - fonction des protéines".

-----

Propriétés physico-chimiques d'une protéine

Structure des protéines scripts (Python v. 2.7) via une page web
Génération d'une URL (module "urllib.request") - Interrogation de la base de données PDB
Recherche de la position des cystéines impliquées dans un pont disulfure
Lecture - écriture dans un fichier
Positions Ponts Python 2
Positions Ponts Python 3
Ponts disulfure PDB
Interrogation de la base de données PDB (structure des protéines)
Calcul du barycentre des carbones alpha des acides aminés
Barycentre Calcul du barycentre
Classe et objet - bibliothèques BioPython, pylab et numpy.
Voir le cours : "Les acides aminés et la structure primaire des protéines".

-----

Diagramme de Ramachandran

Interrogation de la base de données PDB (structure des protéines)

Calcul des distances entre les carbones alpha de 2 chaînes polypeptidiques

Calcul et représentation des aires de contacts entre 2 chaînes polypeptidiques

Module "Bio.PDB.PDBParser"

Distance - contacts

Fichier test 2NBT

Distance - contacts
bioinformatique bioinformatics langage python Python module bibliotheque biopython from import programmation programming software script sequence fasta protein ADN DNA motif genomique proteomique transcriptomique metabolomique genomics transcriptomics proteomics Seq SeqIO Entrez commande Unix matplot numpy tkinter biochimej
Interrogation de la base de données Pfam (domaines des protéines)
Récupération d'un fichier HMM ("Hidden Markov models")

HMM Python 2
HMM Python 3

Recherche d'un profil HMM
Interrogation de la base de données PDB
Calcul du RMSD entre 2 structures de protéines : module "Bio.PDB.Superimposer()"
----- Superposition structures

Enzymologie (voir le cours "Effets de paramètres physico-chimiques sur l'activité enzymatique")

Bibliothèques MatplotLib et numpy

Variation de la vitesse d'une réaction enzymatique en fonction de la température et du temps d'incubation.

Graphique ci-contre tracé avec les valeurs : ΔGcat = 50 kJ.mol-1 ; ΔGinact = 96 kJ.mol-1 ; [E]0 = 10-5 M.

vitesse = f(température, temps)

Enzyme equation kinetics cinetique activite enzymatique rate constant catalytic vitesse reaction Vmax KM active site actif stationary equilibrium temperature ionisation biochimej

Variation d'énergie libre de Gibbs du processus de dénaturation d'une enzyme en fonction de la température et de la pression.

Graphique ci-contre tracé avec les valeurs : Δα = - 1 mL.K-1.mol-1; Δβ = 0,65 mL.MPa-1.mol-1; ΔCp = 5,7 kJ.K-1.mol-1; ΔV0 = -8 mL.mol-1; ΔS0 = 0,28 kJ.mol-1; ΔG0 = 10,8 kJ.mol-1; T0 = 310 K; P0 = 0,1 Mpa.

VEL Gibbs = f(température, pression)

Enzyme equation kinetics cinetique activite enzymatique rate constant catalytic vitesse reaction Vmax KM active site actif stationary equilibrium pression pressure activation volume etat transition state biochimej
CinEnz (non opérationnel)
KEGG (non opérationnel)

Retour haut de page

9. Notions de base d'objet, de classe et d'attribut

Définition de Cordeau, B. & Pointal, L. dans l'ouvrage "Python 3" (2017) :
La méthodologie objet est centrée sur les données.
Le programmeur conçoit des "fabriques" (les classes) qui produisent des "composants" (les objets) qui contiennent des données (les attributs) et des actions (les méthodes).
Les classes dérivent (notion d'héritage et de polymorphisme) de classes de base dans une construction hiérarchique

Les objets : le langage Python est un langage orienté objet :

  • une variable, un module, une fonction, ... tous sont des objets
  • on peut considérer chaque variable comme un objet sur lequel on peut appliquer des méthodes
  • un attribut est une variable contenue dans un objet

Les attributs : ce sont les variables qui caractérisent un objet.
Exemple : une personne est caractérisée par son nom, son prénom, son âge ... Ce sont là 3 attributs.

Les classes : selon la PEP 8 ("Python Enhancement Proposals") de Python, il est préférable d'utiliser la convention "Camel Case" pour le choix du nom d'une classe :

  • cette convention n'utilise pas le signe souligné "_" pour séparer les mots de ce nom
  • il est préférable d'écrire en majuscule chaque lettre de début d'un mot. Exemple : "MaClasse"
  • il s'agit d'une convention, rien n'est imposé.

Pour définir une classe, on emploie le mot-clé "class" selon la syntaxe : "class NomDeLaClasse:" (les 2 points font partie de la syntaxe).

Une classe définit des attributs et des méthodes. Exemple : la classe « Personne » permet de créer des objets qui sont des « individus ».

  • La classe Personne peut définir un attribut « taille », un attribut « âge », … Ces attributs correspondent aux caractéristiques d'un individu.
  • La classe Personne peut définir la méthode « parler( ) ». Une méthode correspond à une action : dans cet exemple, l'action « parler » est effectuée par un individu.

Une autre classe « Oiseau » peut définir la méthode « voler( ) ».

  • La classe Personne ne peut pas définir la méthode voler( ) car un individu ne peut pas voler.
  • De même, la classe Oiseau peut avoir un attribut « altitude » mais pas la classe Personne.

Les instances de classe : un objet est une instance de classe.

Chaque objet a des attributs qui lui sont propres. Il peut exister plusieurs objets pour une même classe, c'est-à-dire plusieurs instances de la même classe.

Exemple, dans la classe Personne, il existe des individus qui sont des instances distinctes :

  • l'individu Jean a les attributs grand et souriant : c'est une instance de la classe Personne et aussi un objet.
  • l'individu Hélène a les attributs gracieuse et brune : c'est une autre instance de la classe Personne et aussi un objet.

 

10. Liens Internet et références bibliographiques

The Python Tutorial : différentes versions sont décrites

Informations sur les modules Python

"Un petit tuteur sur les Expressions Régulières" - G. Hunault

"Python 3" (2017) Cordeau, B. & Pointal, L. - ISBN 978-2-10-076636-9 - Editions DUNOD

"Informatique avec Python" (2018) Beury J.N. - ISBN 978-2-10-076901-8 - Editions DUNOD

"Introduction au machine learning" (2018) Azencott C.A. - ISBN 978-2-10-078080-8 - Editions DUNOD

"Programmation en Python pour les sciences de la vie" (2019) Fuchs P. & Poulain P. - EAN 978-2-10-079602-1 - Editions DUNOD

PeptideBuilder : bibliothèque pour générer des peptides modèles
FragBuilder : bibliothèque pour des calculs de chimie quantique avec des peptides modèles
ProDy : ensemble de scripts ("free and open-source Python package") pour l'étude de la dynamique structurale des protéines
COBRApy : reconstruction métabolique à l'échelle d'un génome sur la base de modèles sous contraintes

TP - Programmation Python pour la BIOInfo

Expressions régulières (P. Vanier)

Aller au site

PDF

Ebrahim et al. (2013) "COBRApy: COnstraints-Based Reconstruction and Analysis for Python" BMC Syst. Biol. 7, 74

La bioinformatique avec Biopython Olivier Dameron, Gregory Farrant

Shajii et al. (2021) "A Python-based programming language for high-performance computational genomics" Nat. Biotechnol. 39, 1062 - 1064

Article

Article

Article

Retour haut de page

Valid XHTML 1.0 Transitional