AMU :: Polytech Biotech 3A :: JGB53D :: 2014/2015 :: Jacques van Helden, Denis Puthier, Nicolas Terrapon
[Retour à la table des matières]
Le langage de programmation Python a été développé par Guido van Rossum. Sa première version date de 1991. Python fonctionne sous Windows, Linux/Unix et Mac OS X. Le langage Python est sous licence open-source ce qui le rend utilisable gratuitement et distribuable même pour des applications commerciales. Python a été developpé afin de procurer un langage très lisible à la communauté. L'idée est de proposer un langage très proche du langage naturel et éloigné de certains langages dont le code peut rapidement devenir obscur ("obfuscating code"). Par ailleurs le but de python est de proposer un langage simple, standardisé dont l'une des devise est: "There should be one — and preferably only one — obvious way to do it".
Python est un langage puissant, assez facile d'apprentissage et qui propose une palette d'outils très large. Il peut être notamment utilisé pour:
[Retour à la table des matières]
Au fil de ce TD, nous allons présenter un certain nombre de structures de données. Ces structures (variables, listes, dictionnaires,...) permettent d'organiser l'information en mémoire et nous permettront, lors les TDs suivants, de réaliser des programmes s'appuyant sur celles-ci.
[Retour à la table des matières]
Dans le terminal, tapez la commande suivante qui devrait vous permettre de démarrer un interpréteur Python (ici pour la version 3 du langage python).
Le programme IPython est un interpréteur python, ce qui signifie qu'il comprendra les instructions Python que vous lui soumettez et qu'il les exécutera l'une après l'autre. Ceci permet de tester de simples commandes, sans nécessiter de les sauvegarder dans un fichier.
[Retour à la table des matières]
Comme premier contact avec un langage de programmation, la coutume est de créer un programme qui imprime à l'écran le message "Hello world". Nous ne dérogerons pas à l'usage.
Copiez l'instruction suivante dans l'interpréteur.
# On demande à python de dire "Hello world"
print("Hello world")
En informatique, les variables associent un nom (l'identifiant) à une valeur. Créer une variable est très simple, il suffira d'utiliser l'opérateur d'affectation '=' (aussi appelé opérateur d'assignation).
En Python, les variables sont typées, c'est-à-dire qu'une variable présentera des comportements différents en fonction des types d'information qu'elle contient (nombres entiers, nombres décimaux, chaînes de caractères, ...).
Copiez-collez les instructions suivantes dans iPython, ligne par ligne. Analysez les résulats et tentez de comprendre la façon dont l'interpréteur traite ces commandes. Certains résultats seront parfois un peu déroutants pour les débutants, mais leur logique sera discutée durant les TD, et l'usage du langage s'éclairera au fil de la progression du cours.
# Note: tout ce qui se trouve à droite du caractère '#'
# est un commentaire (non interprété par python)
# On affecte la valeur '2' à une variable qu'on appelle 'a'
a = 2
# Quel est la valeur contenue dans a ?
a
# Quel est le type de cette variable ?
type(a) # Réponse: int (integer). La variable contient un nombre entier.
# On affecte la valeur 2.0 à a
a = 2.0
# Quel est le type de cette variable ?
type(a) # float (float). Un nombre à virgule flottante (i.e un réel).
# On affecte la valeur 4 à b
b = 4
# Quel est la valeur de b ?
b
# c contient la somme des valeurs courantes de a et b
c = a + b
# Quelle est la valeur de c ? Quel est le type de c ?
c
type(c)
# Remémorons-nous les valeurs des variables (a, b, c)
print (a,b,c)
Dans l'exemple précédent, nous avons assigné des valeurs aux variables a (a=2.0) et b (b=4), puis assigné à la variable c le résultat d'un calcul (c=a+b). Conformément à nos attentes, la variable c contient le résultat de la somme de a et b.
Que ce passe-t-il si on change la valeur de b ?
b = 10
print(a,b,c) # expliquez
Le fait de changer la valeur de b n'a pas affecté le contenu de la variable c. En mathématique, quand on écrit une équation (par exemple c = a + b, la relation ainsi définie prend valeur de vérité pour l'ensemble des développements ultérieurs. Il en va autrement en programmation: l'assignation c=a+b a pour effet de créer ou modifier le contenu d'un espace de mémoire. Si l'on change ensuite le contenu d'une des variables impliquées dans la relation (b=10), la variable c n'a pas de raison de changer tant qu'on ne l'a pas ré-assignée.
# Re-calculer la somme des valeurs de a et b,
# et mettre à jour le contenu de la variable c
c = a + b
# la valeur de c correspond maintenant à la somme de a et b
print(a,b,c)
Ce type de notation permet notamment d'incrémenter le contenu d'une variable, en ajoutant une valeur (par exemple la constante 1) à son propre contenu.
d = 0
print(d)
d = d+1
print(d)
d = d+1
print(d)
d = d+1
print(d)
On constate, ici encore, la différence entre la formulation mathématique d'une équation et l'assignation d'une variable en programmation. En mathématiques, l'équation d=d+1 est fausse, puisqu'il est impossible qu'un nombre soit égal à la somme de sa valeur et du nombre 1. En informatique, l'instruction d=d+1 est parfaitement valide, elle indique qu'il faut incrémenter d'une unité le contenu de la variable d.
Les opérateurs mathématiques classiques peuvent être utilisés sur des entiers et flottants.
a = 4.0
type(a) # vérifions le type de la variable 'a'. Elle contient un nombre décimal
a/3
type(a*3)
# On peut donc utiliser IPython comme une calculatrice
3*(2+4)
Effectuez les exercices suivants:
Solution
i = 100 # on assigne 100 à i
type(i) # Le type de i (int)
j = 5.0 # j vaut 5.0
type(j) # j est un float.
k = i + j # k prend la somme
type(k) # k est un float
Copiez-collez les instructions suivantes dans IPython, ligne par ligne, et tentez d'interpréter le résultat.
# On peut affecter une chaîne de caractères à une variable
# Cette variable est alors de type "chaîne de caractères".
nom_de_fichier = "refGene"
type(nom_de_fichier) # str (string). Une chaîne de charactères.
# Que contient la variable nom_de_fichier ?
nom_de_fichier
Notez qu'en tapant simplement le nom de la variable comme ci-dessus, Python affiche son contenu entre guillemets simple ('apostrophes'), pour indiquer qu'il s'agit d'une chaîne de caractères.
On peut afficher le contenu de la variable en utilisant la fonction Python print(). Notez que cette fonction affiche le contenu sans l'entourer de guillemets.
# Imprimer le contenu de la variable nom_de_fichier
print(nom_de_fichier)
# Notez que la commande suivante produit une erreur.
nom_de_fichier = refGene
# Comment expliquez-vous cette erreur ?
Dans le cas ci-dessus, nous avons demandé à Python de copier le contenu d'une variable appelée refGene dans une autre variable appelée nom_de_fichier. Cependant il n'existe pas de variable nommée refGene (puisque nous n'en avons pas défini).
Ceci illustre un aspect important de la syntaxe: pour spécifier le contenu d'une chaîne de caractères, il faut entourer ce contenu de délimitateurs (guillemets simples ou doubles). Un mot sans délimitateurs sera interprété comme nom de variable, et non comme chaîne de caractère.
En Python, la concaténation de chaînes de caractères se fait très simplement au moyen de l'opérateur "+".
# On affecte la valeur ".txt" à une variable nommée 'extension'
extension = ".txt"
# Quel est le contenu de la variable extension ?
print(extension)
# Quel est son type ?
type(extension)
# On peut 'concaténer' des chaînes de caractères avec l'opérateur +
nom_complet = nom_de_fichier + extension
print(nom_complet)
# Attention on ne peut concaténer que des chaînes entre elle:
a = 2.0
type(a)
type(nom_de_fichier)
# Pour concaténer nom_de_fichier et la variable a, il faut
# convertir cette dernière en chaîne de caractère:
#nom_de_fichier + a # Quelle erreur est renvoyée ?
nom_de_fichier + str(a) # maintenant ça fonctionne
# La fonction str() utilisée ci-dessus a pour effet de
# convertir une variable en une chaîne de caractère.
str(27)
Notez que Python affiche '27', avec des guillements, pour indiquer qu'il s'agit d'une chaîne de caractères.
On peut répéter des chaines en les multipliant par un entier.
nom_de_fichier * 10
a = 3.0
type(a) # Et pourquoi pas un entier ? Expliquez.
nom_de_fichier * a # ne fonctionne pas car a n'est pas un entier.
nom_de_fichier * int(a) # en convertissant a en entier ça fonctionne
On peut aussi utiliser la fonction print() pour afficher le contenu d'une ou plusieurs variables.
print(c)
print(nom_complet)
# La commande print() peut traiter une liste de variables
x = 'alfred'
y = 'sarah'
z = 'mélanie'
print(x,y,z)
# La liste peut contenir des variables de types différents
print(c, nom_de_fichier, c, 2, 2.0)
Pour les textes sur plusieurs lignes, on utilisera une 'docstring', en marquant le début et la fin par des triplets de guillemets
phrase = """Ceci
est une phrase
sur plusieurs lignes
"""
print(phrase)
Effectuez les exercices suivants:
Solution
("TTG" * 3 + "AAA" ) * 100
Python permet d'effectuer un certain nombre de conversions entre types de variables (comme vu précédemment avec str()). Un certain nombre d'exemples sont montrés ci-dessous qui illustrent les comportements des fonctions de conversion en fonction des types qui sont entrés en paramètres.
Copiez collez les instructions suivantes une ligne après l'autre dans l'interpréteur.
####################################
### Coercition à partir d'un entier
####################################
a = 2
float(a) # Vaut 2.0
str(a) # Vaut '2' . Les guillemets indiquent que c'est une chaîne de caractères.
####################################
### Coercition à partir d'un réel
####################################
a=2.9
int(a) # Vaut 2. Seule la partie entière est préservée
str(a) # Vaut '2.9'. Les guillemets indiquent que c'est une chaîne de caractères.
#####################################################
### Coercition partir d'une chaîne de caractères
#####################################################
int("2") # Vaut 2. Fonctionne
float("2.9") # Vaut 2.9. Fonctionne
float("1.3e-3") # Vaut 0.0013. Fonctionne
# La coercition vers des nombres suppose une chaîne de caractères compatibble avec des nombres.
# int("A") # Erreur. Cette transformation est impossible.
# float("A") # Erreur. Cette transformation est impossible.
# Les deux instructions précédentes retournent des erreurs, car
# la chaîne de caractère "A" ne peut pas être interprétée comme
# un nombre.
#int("2.9") # Erreur : cette chaîne de caractère ne peut pas être convertie en entier
float("2.9") # Ici, ça marche
int(float("2.9")) # Ca fonctionne.
Le dernier exemple peut sembler étonnant: la conversion de "2.9" en entier ne fonctionne pas, mais la double coercition fonctionne parce que le résultat de la première conversion fournir une variable de type float, de de valeur 2.9, qui peut être convertie en variable entière (la coercicion de fload à int a pour effet de tronquer les décimales).
Une variable booléenne est une variable à deux états: vrai ou faux. En python une variable booléenne pourra prendre la valeur True ou False. Nous reviendrons sur ces variables dans les TD suivant lors de la présentation des structures conditionnelles.
Copiez collez les instructions suivantes une ligne après l'autre dans l'interpréteur.
d = True
c = False
# On peut ensuite effectuer des opérations logiques entre variables Booleennes
d
not d
not c
d and c
d or c
d and (not c)
Attention: certains noms sont réservés en Python. Cela signifie que vous ne pouvez pas les utiliser comme noms de variables. La liste des noms réservés peut être trouvée ici.
# La commande suivante ne fonctionnent pas, car elle utilise un mot réservé.
# les mots réservés (and, if, ...) ont un sens particulier en
# Python, on n'a donc pas le droit de les utiliser comme noms de
# variables.
and = "et"
[Retour à la table des matières]
Les variables dans python sont en fait des objets associés à des méthodes (nous reverrons cela en détail plus tard). Cela signifie que, suivant la classe de l'objet (e.g un entier, une chaîne de caractères, ...) un certain nombre de procédures spécifiques peuvent êtres appliquées en appelant la méthode correspondante.
Tapez le code suivant dans l'interpréteur python
dna="ATACTAGAATTCGATAGGTGGTAAAACCCG"
# De quoi s'agit-il ?
type(dna)
# Cherchons de l'aide sur la classe str (string)
# help(str)
# Tapez q pour quitter l'aide.
# Notez la variété de méthodes disponibles.
## Pour sortir de l'aide, tapez la touche 'q'
# Notez que les méthodes entourées de tirets soulignés
# ("__method__") doivent être utilisées comme indiqué.
#
# x.__len__() <==> len(x) signifie que l'on écrira
len(dna)
# et non pas
dna.__len__()
# qui bien que fonctionnelle est moins lisible.
# Toutes les autres méthodes (sans tirets soulignés) sont à
# utiliser en suffixant la variable d'un "." suivi du nom de la
# méthode.
# Exemple: convertir la séquence d'ADN en minuscules
dna.lower()
Consultez l'aide sur la classe str. En utilisant les méthodes disponibles, répondez au question suivantes:
len(dna)
dna.endswith("CCG")
dna.find("GAATTC") # On commence à compter à 1 ou à 0 ?
dna = dna.replace("GAATTC", "AGATCT") # Attention il faut 'écraser' la variable dna.
print(dna)
dna = dna.replace("AGATCT", ("GAATTC" + "AGATCT") * 3) # succession de ecoR1 et BglII
print(dna)
print(dna.lower())
[Retour à la table des matières]
Une liste peut être vue comme un tableau qui permet de stocker des objets.
############################
### Créer une liste vide ###
############################
ma_liste = list() # or ma_liste = []
len(ma_liste) # contient 0 éléments
################################################################################################
### Créer une liste contenant un ensemble d'éléments pré-définis (ici des symboles de gènes) ###
################################################################################################
liste_de_genes = ["CD3E", "CD4", "CD8", "CD5", "ZAP70", "ITK", "LAT","VAV1","CD3G","TCRA"]
liste_de_genes
##########################################################
### Extraire un sous ensemble par index.
##########################################################
# Notez qu'on commence à la position 0
liste_de_genes[0]
liste_de_genes[1]
# Indexer depuis la fin
liste_de_genes[-1]
liste_de_genes[-2]
# Prendre une 'tranche' (slice) de cette liste
# liste_de_genes[début:fin] # de début à fin-1
liste_de_genes[0:2]
liste_de_genes[0:5]
# Extraire les derniers éléments d'une liste
# liste_de_genes[début:] # de début jusqu'à la fin
liste_de_genes[1:]
liste_de_genes[5:]
# Extraire les premiers éléments d'une liste
# liste_de_genes[:fin] # De la première position jusqu'à fin-1
liste_de_genes[:4]
# Spécifier l'incrément (le "pas") d'un parcours de liste.
# liste_de_genes[début:fin:p] # de début à fin-1 par incrément de p
liste_de_genes[0:10:2]
liste_de_genes[0::2] # liste_de_genes[0:10:2]
liste_de_genes[::-1] # La liste à l'envers
########################################
### Changer les éléments d'une liste ###
########################################
liste_de_genes[5:] = ['CD52','SATB1']
print(liste_de_genes)
# Note: nous venons de changer la longueur de la liste, en
# remplaçant les 5 derniers éléments d'une liste de 10 éléments
# par une nouvelle liste de 2 éléments
len(liste_de_genes)
####################################################
### Notez qu'une chaîne de caractère peut être ###
### considérée comme une liste dont les élements ###
### ne peuvent être modifiés. ###
####################################################
dna[3:]
dna[::-1] # Qu'obtenez-vous en utilisant un incrément de -1?
dna[25:]= 'TTTTT' # que dit le message d'erreur ?
Comme tout objet, les listes ont un ensemble de méthodes associées. Copiez collez les instructions suivantes dans l'interpréteur IPython.
########################################
#### Get help about the class 'list' ###
########################################
# help(list)
# q pour quitter
########################################
### Quelques méthodes classiques ####
########################################
len(liste_de_genes) # Nombre d'éléments
liste_de_genes + liste_de_genes # Concaténer deux listes
'LAT' in liste_de_genes # Est-ce que cet élément est contenu dans ma liste
del liste_de_genes[5] # Déléter le 6ème élément ('ITK')
liste_de_genes*3 # Concaténer 3 fois la liste
liste_de_genes.append('BCL2') # Ajouter BCL2 à la fin de la liste
liste_de_genes
liste_de_genes.count('CD3E') # Compter le nombre d'occurrences de 'CD3E'
gene = liste_de_genes.pop(2) # Déléter et renvoyer le 3ème élément de la liste (CD8)
gene
liste_de_genes.sort() # Trier la liste
liste_de_genes.sort(reverse=True)
liste_de_genes.insert(2,'P53') # Insérer un élément avant une position donnée
liste_de_genes.remove('P53') # Delete a given object from the list
Consultez l'aide sur la classe str. En utilisant les méthodes disponibles, répondez au question suivantes:
ma_list = ["GAATTC", "AGATCT", "GGTGG"]
ma_list = ma_list * 10
ma_list.sort() # pas besoin d'assigner !
ma_chaine = "".join(ma_list)
print(ma_chaine)
Les tuples sont très proches des listes. Cependant une fois créés, ces objets ne peuvent pas être modifiés. Dans la syntaxe python, les listes sont déclarées en encadrant leurs éléments de crochets [ ], tandis que les tuples sont encadrés par des parenthèses ( ).
Copiez collez les instructions suivantes dans l'interpréteur IPython.
myTuple=('a','b')
myTuple[0]
myTuple[0]='c' # error. On ne peut pas le modifier !
[Retour à la table des matières]
Un dictionnaire est un tableau permettant de stocker des informations sous la forme clef -> valeur. Cet objet est extrêmement utile au même titre que la liste. Dans d'autres langages de programmation, le dictionnaire est aussi connnu sous le nom de hash, table de hachage ou encore tableau associatif.
Copiez collez les instructions suivantes dans l'interpréteur IPython.
#############################################
### Créer un dictionnaire vide liste vide ###
#############################################
codon2AA = {}
############################################################
### Créer un dictionnaire contenant des clefs et valeurs ###
############################################################
# Une partie du code génétique...
codon2AA = {"UUU":"PHE", "UCU":"SER", "CUU":"LEU","AAA":"LYS"}
############################################################
### Récupérer une valeur avec une clef ###
############################################################
codon2AA['CUU']
## Si la clé n'a pas été définie, Python émet un message d'erreur
codon2AA['ABSENT']
##########################################
### Ajouter une paire clef -> valeur ###
##########################################
codon2AA['ACA'] = "THR"
codon2AA['AUG'] = "START"
codon2AA
##########################################
### Déléter un éléments ###
##########################################
## del délète une paire clef valeur
del codon2AA["AUG"]
codon2AA
##########################################
### Tester si une clef existe ###
##########################################
'ACA' in codon2AA
if 'ACA' in codon2AA:
print("Oui")
[Retour à la table des matières]
Pour en savoir plus sur les structures de données en Python, vous pouvez consulter la documentation Python correspondante. Vous noterez notamment l'existence de Sets qui n'ont pas été traité ici et qui correspondent à des liste ordonnées non-redondante. Nous vous laissons les découvrir seuls à titre d'exercice.