Eléments de base du langage Python et des 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 au NCBI

 

5. L'interface Python tutor

6. Les expressions régulières

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

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

9. Liens Internet et références bibliographiques

 

1. Introduction

1. Commandes pour afficher la version de Python :
Python 2, taper : python --version
Python 3, taper : python3 --version

Les différences de syntaxe entre Python version 2 et Python version 3 : voir le document différences Python V2 vs. Python V3.

Exemple : print "toto" (Python v.2) versus print ("toto")

2. Pour exécuter un script Python sous Unix (terminal):

  • écrire 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

3. L'environnement IDLE

  • IDLE signifie "Integrated DeveLopment Environment" qui correspond à 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".

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
  • printToto => 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()

Les bibliothèques

import sys
import cgitb cgitb.enable()
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(parametre1, parametre2, parametre3, parametreN, ...) :
   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 2.7) :

def table_de_multiplication(max):
  multiplicateur = input("choisissez un multiplicateur : ")
  max = input("choisissez un nombre maximum a multiplier : ")
  compteur = 0           # initialisation du compteur a 0
  while compteur < max:   # tant que compteur est strictement inferieur a la valeur de la variable max
    print(compteur + 1),"*",(multiplicateur), "=" ,(compteur + 1) * (multiplicateur) # attention a la syntaxe
    compteur += 1      # on incremente compteur de 1 a chaque tour de boucle
table_de_multiplication(max)  # appel 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 (Package Bio) : Collection of modules for dealing with biological data in Python.
  • BioSQL (Package BioSQL) : 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 de 2 et les auteurs de 2 publications dans Pubmed dont l'idenifiant 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 chaine au format XML - les methodes "read" et "parse" necessitent xml
retmode=json : renvoie une chaine au format JSON (JavaScript Object Notation) plus lisible qu'un fichier XML
retmax=5 : renvoie 5 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 (meme "loufoque")
parametresRecherche = Entrez.esearch(db='pubmed',retmax='5',datetype='PDAT',retmode='xml',term = motCle

On genere l'URL suivante pour la requete au NCBI : https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi?db=pubmed&retmax=5&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 de recherche d'articles dans PubMed sur la base de mots clé.

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 2.7 :

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 = raw_input("sequence a analyser : ")  	     # utilisateur entre sa sequence
nucleotide = raw_input("nucleotide a denombrer : ")   # utilisateur entre le nucleotide choisi
n = denombre(sequence,nucleotide) 					 # appel de la fonction
 					 # n = nombre de fois que le nucleotide choisi est trouve dans la sequence
print '%s apparait %s fois dans %s' % (nucleotide, n, sequence)   # % versus format()

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.

Retour haut de page

6. Les expressions régulières

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

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

Expression régulières fonction
. tous les caractères sauf \n (retour chariot)
* 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 ou les lettres X,Y et Z
[a-z]
[^a-z]
les lettres 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
Il existe beaucoup d'autres expressions régulières.

Expressions régulières très puissantes

a. Recherche en avant

q(?=u) : expression régulière pour rechercher le caractère "q" suivi d'un "u". C'est une recherche "positive en avant" ("positive lookahead").
q(?!u) : expression régulière pour rechercher le caractère "q" non suivi d'un "u". C'est une recherche "négative en avant" ("negative lookahead").

Les caractères "q" et "u" peuvent être remplacés par une expression complexe.

b. Recherche en arrière

(?<=text) : expression régulière pour rechercher le caractère "q" précédé d'un "u". C'est une recherche "positive en arrière" ("positive lookbehind").
(?< !text) : expression régulière pour rechercher le caractère "q" non précédé d'un "u". C'est une recherche "négative en arrière" ("negative lookbehind").

Attention : les caractères "q" et "u" ne peuvent pas être remplacés par une expression complexe.

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

Voir un développement.

Exemples de combinaisons d'expressions régulières

  • recherche tous les chiffres et les caractères d'espacement : r'[\d\s]'
  • recherche de nombre(s) hexadécimal/aux, n'importe où dans une phrase : r'(0x[0-9ABCDEF]+)[\s,.:] | (0x[0-9ABCDEF]+)$'
    syntaxe : ce(s) nombre(s) (0x[0-9ABCDEF]), qui peu(ven)t être présent(s) 1 à n fois (+), 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. Exemple :

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

Test 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

b. Quelques méthodes liées aux expressions régulières (appelées motif)

re est le module Python dédié aux expression régulières : import re

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.

La méthode "search()" renvoie une instance "MatchObject" qui peut ètre utilisée avec la méthode "search()".

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

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

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)
===> Résultat : ['rapidement', 'aimablement', 'videmment']

Exemple 2 :
import re
fichierLu = open('fichier.txt', 'r')
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 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 = raw_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 = raw_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

But des scripts scripts (Python v. 2.7) via une page web
Afficher les identités entre 2 séquences AffichageIdentite ----------
- Dénombrement d'un nucléotide dans une séquence
- Entrer une sequence et la nettoyer / ouvrir et lire un fichier / liste et dictionnaire / calcul / affichages

Voir ci-dessus

Dénombrement nucléotide
- Utilisation de "def" et "while"
- Données saisies par l'utilisateur
TableMultiplication ----------
- Calcul de l'hydrophobicité moyenne d'un peptide
- Entrer une sequence et la nettoyer / liste et dictionnaire/ affichage du décours du calcul/ écrire et lire un fichier
Hydrophobicite
+ fichier hydrophobicite.txt
Hydrophobicité peptide
Calcul de l'hydrophobicité moyenne d'un peptide avec Python tutor (script modifié à coller tel quel dans une fenêtre "Visualize" de Python tutor). CollerDansPyTutor ----------
- Utilisation de "def" et "while" - Données saisies par l'utilisateur
- import re / from Bio import SeqIO
RegexpMotif
+ fichier test.fa
----------
Recherche d'articles dans PubMed - NCBI (via Entrez et les outils Eutils) sur la base de mots clé Entrez Recherche PUBMED
- Interrogation PDB - Recherche position des cystéines impliquées dans un pont disulfure
- Lecture - ecriture dans un fichier
RecupPosPonts
Exemples RegExp Ponts
Ponts disulfure PDB
Interrogation PDB - calcul du barycentre des carbones alpha des acides aminés Barycentre Calcul du barycentre

Retour haut de page

8. 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.

 

9. Liens Internet et références bibliographiques

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

Informations sur les modules

Python 3 (2017) Cordeau, B. & Pointal, L. - ISBN 978-2-10-076636-9 - 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

Cours de Python - Biochimie - bioinformatique (Jussieu)

TP - Programmation Python pour la BIOInfo

Expressions régulières (P. Vanier)

Aller au site

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

Article

Article

Retour haut de page

Valid XHTML 1.0 Transitional