diff --git "a/Python/Corrig\303\251s/controle.py" "b/Python/Corrig\303\251s/controle.py"
new file mode 100644
index 0000000000000000000000000000000000000000..15d7524097ed21b02bf2261675b418abc6bbadbe
--- /dev/null
+++ "b/Python/Corrig\303\251s/controle.py"
@@ -0,0 +1,66 @@
+# -*- coding: latin-1 -*-
+'''
+Created on 12 juin 2014
+
+@author: sderozier & oinizan
+'''
+
+# Dictionnaire
+sequences = {
+"A.KE.Q23-CXC-CG" :
+"ATGGACCCGGTAGATCCTAACCTAGAGCCCTGGAATCACCCGGGAAGTCAGCCTACAACTGCTTGCAACAAATGTTACTGTAAAAAGTGTTGTTATCATTGTCAAGTTTGCTTTTTGAACAAAGGCTTAGGCATCTCCTATGGCAGGAAGAAGCGGAGACAGCGACGAGGAGCTCCTCAGAGCAGTAAGGATCATCAAAATTCTATACAAAAGCAGCCCATACCCCAAACCCAAGGGGTCTCGACAGGCCCGAAAGAATCGAAGAAGAAGATGGAGAGCAAGGCAGAGGCAGATCGATTCGATTAG",
+"A.SE.SE6594" :
+"ATGGATCCAGTAGATCCTAACCTAGAGCCTTGGAACCATCCGGGGAGTCAGCCTTCAACTGCTTGTAACAAGTGTTACTGTAAAATATGTTGCTATCATTGCCCAGTTTGCTTTTTGAACAAAGGCTTAGGCATCTCCTATGGCAGGAAGAAGCGGACCCGGCGACGAGGAGCTCCTCAAAGCAATAAGGATCATCAAAATCCTATATCAAAGCAGCCCATACCCCAAACCCAGGGGGACTCGACAGGCCCGGAAGAATCGAAGAAGAAGGTGGAGAGCAAGGCAGAGACAGATCGATTCGATTAG",
+"A.SE.SE7253" :
+"ATGGATCCGGTAGATCCTAACTTAGAGCCCTGGAACCACCCGGGAAGTCAGCCTACAACTCCTTGTAGCAAGTGTTACTGTAAAAAGTGTTGCTATCATTGCATAGTTTGCTTTCAGAACAAAGGCTTAGGCATCTCCTATGGCAGGAAGAAGCGGAGACAGCGACGAAGAACTCCTCAGAGCAGTAAGGATCATCAAAATCCTATACCAAAGCAGCCCATACCCCAGACCCAAGGGGTCTCGACAGGCCCAGAAGAATCGAAGAAGAAGGTGGAGAGCAAGGCAGAGGCAGATCGATTCGATTAG",
+"A.SE.SE7535" :
+"ATCGACCCGGTAGATCCTAACCTAGAGCCCTGGAATCATCCGGGAAGTCAGCCTACAACTGCTTGTAACAAGTGCTATTGTAAAAAGTGTTGCTATCATTGTCAAGCTTGCTTTTTGAACAAAGGCTTAGGCATCTCCTATGGCAGGAAGAAGCGGAAACAGCGACGAGGAGCTCCTCAGAGCAATAAGGATCATCAAAATCCTATACAACAGCAGTCCATACCCCAAACCCAAGGGATCCCGACAGGCCCGGAAGAATCGAAGAAGAAGGTGGAGAGCAAGGCAGAGACAGATCGATTCGATTAG",
+}
+
+# A.KE.Q23-CXC-CG
+# Sequence
+seq23 = sequences["A.KE.Q23-CXC-CG"]
+# Longueur
+len23 = len(seq23)
+# 1er codon
+codon1_23 = seq23[:3]
+# Dernier codon
+codont_23 = seq23[(len23-((len23%3)-3)):(len23-(len23%3))]
+
+# A.SE.SE7535
+# Sequence
+seq7535 = sequences["A.SE.SE7535"]
+# Longueur
+len7535 = len(seq7535)
+# 1er codon
+codon1_7535 = seq7535[:3]
+# Dernier codon
+codont_7535 = seq7535[(len7535-((len7535%3)-3)):(len7535-(len7535%3))]
+
+# TESTS
+# Sequences
+if seq23 == seq7535 :
+ print ("Les sequences sont identiques !")
+else :
+ print ("Les deux sequences sont differentes !")
+# Longueurs
+if len23 == len7535 :
+ print ("Les deux sequences sont de meme longueur !")
+else :
+ print ("Les deux sequences n'ont pas la meme longueur !")
+# 1er codon = ATG
+if codon1_7535 == "ATG" :
+ print ("Le 1er codon est bien une methionine !")
+else :
+ print ("Le 1er codon n'est pas une methionine !")
+
+if codon1_23 == "ATG" and codon1_7535 == "ATG" :
+ print ("Les deux codons sont bien des methionines !")
+else :
+ print ("Les deux codons ou l'un des deux codons n'est pas une methionine !")
+
+# Dernier codon = TAA, TGA, TAG
+if codont_7535 == "TAA" or codont_7535 == "TGA" or codont_7535 == "TAG" :
+ print ("Le dernier codon est bien un codon stop !")
+else :
+ print ('Le dernier codon n\'est pas un codon stop !')
diff --git "a/Python/Corrig\303\251s/dictionnaire.py" "b/Python/Corrig\303\251s/dictionnaire.py"
new file mode 100644
index 0000000000000000000000000000000000000000..827ab605d12abfe2e194ccc576afd18a8cd41075
--- /dev/null
+++ "b/Python/Corrig\303\251s/dictionnaire.py"
@@ -0,0 +1,54 @@
+# -*- coding: latin-1 -*-
+'''
+Created on 12 juin 2014
+
+@author: sderozier & oinizan
+'''
+from variable import length
+
+# Dictionnaire
+sequences = {
+"A.KE.Q23-CXC-CG" :
+"ATGGACCCGGTAGATCCTAACCTAGAGCCCTGGAATCACCCGGGAAGTCAGCCTACAACTGCTTGCAACAAATGTTACTGTAAAAAGTGTTGTTATCATTGTCAAGTTTGCTTTTTGAACAAAGGCTTAGGCATCTCCTATGGCAGGAAGAAGCGGAGACAGCGACGAGGAGCTCCTCAGAGCAGTAAGGATCATCAAAATTCTATACAAAAGCAGCCCATACCCCAAACCCAAGGGGTCTCGACAGGCCCGAAAGAATCGAAGAAGAAGATGGAGAGCAAGGCAGAGGCAGATCGATTCGATTAG",
+"A.SE.SE6594" :
+"ATGGATCCAGTAGATCCTAACCTAGAGCCTTGGAACCATCCGGGGAGTCAGCCTTCAACTGCTTGTAACAAGTGTTACTGTAAAATATGTTGCTATCATTGCCCAGTTTGCTTTTTGAACAAAGGCTTAGGCATCTCCTATGGCAGGAAGAAGCGGACCCGGCGACGAGGAGCTCCTCAAAGCAATAAGGATCATCAAAATCCTATATCAAAGCAGCCCATACCCCAAACCCAGGGGGACTCGACAGGCCCGGAAGAATCGAAGAAGAAGGTGGAGAGCAAGGCAGAGACAGATCGATTCGATTAG",
+"A.SE.SE7253" :
+"ATGGATCCGGTAGATCCTAACTTAGAGCCCTGGAACCACCCGGGAAGTCAGCCTACAACTCCTTGTAGCAAGTGTTACTGTAAAAAGTGTTGCTATCATTGCATAGTTTGCTTTCAGAACAAAGGCTTAGGCATCTCCTATGGCAGGAAGAAGCGGAGACAGCGACGAAGAACTCCTCAGAGCAGTAAGGATCATCAAAATCCTATACCAAAGCAGCCCATACCCCAGACCCAAGGGGTCTCGACAGGCCCAGAAGAATCGAAGAAGAAGGTGGAGAGCAAGGCAGAGGCAGATCGATTCGATTAG",
+"A.SE.SE7535" :
+"ATGGACCCGGTAGATCCTAACCTAGAGCCCTGGAATCATCCGGGAAGTCAGCCTACAACTGCTTGTAACAAGTGCTATTGTAAAAAGTGTTGCTATCATTGTCAAGCTTGCTTTTTGAACAAAGGCTTAGGCATCTCCTATGGCAGGAAGAAGCGGAAACAGCGACGAGGAGCTCCTCAGAGCAATAAGGATCATCAAAATCCTATACAACAGCAGTCCATACCCCAAACCCAAGGGATCCCGACAGGCCCGGAAGAATCGAAGAAGAAGGTGGAGAGCAAGGCAGAGACAGATCGATTCGATTAG",
+}
+
+# Sequence A.SE.SE6594
+print "Sequence de A.SE.SE6594 : ", sequences["A.SE.SE6594"]
+
+# Tous les noms des sequences
+listeCles = sequences.keys()
+print "Liste des cles : ", listeCles
+
+# Toutes les sequences
+listeValues = sequences.values()
+print "Liste des valeurs : ", listeValues
+
+# Toutes les noms des sequences ordonnes
+listeClesSort = sorted(listeCles)
+print "Liste des cles ordonnees avec sorted : ", listeClesSort
+listeCles.sort()
+print "Liste des cles ordonnees avec sort() : ", listeCles
+
+# Longueur de la sequence A.SE.SE7253
+seq7253 = sequences["A.SE.SE7253"]
+length7253 = len(seq7253)
+print "Longueur de A.SE.SE7253 : ", length7253
+
+# 1er codon de A.SE.SE7253
+codon1 = seq7253[:3]
+print "1er codon : ", codon1
+
+# Dernier codon de A.SE.SE7253
+# Quel est l'indice de fin du dernier paquet de 3=> len(seq7253)-(len(seq7253)%3
+# Quel est l'indice de début du dernier paquet de 3=> (len(seq7253)-(len(seq7253)%3-3
+
+codont = seq7253[(len(seq7253)-(len(seq7253)%3)-3):(len(seq7253)-(len(seq7253)%3))]
+print "Dernier codon : ", codont
+
+print type(listeCles)
diff --git "a/Python/Corrig\303\251s/liste.py" "b/Python/Corrig\303\251s/liste.py"
new file mode 100644
index 0000000000000000000000000000000000000000..4a28de641caaf3b50926508d77e54c5154e213c8
--- /dev/null
+++ "b/Python/Corrig\303\251s/liste.py"
@@ -0,0 +1,30 @@
+# -*- coding: latin-1 -*-
+'''
+Created on 12 juin 2014
+
+@author: sderozier & oinizan
+'''
+
+# Sequence
+sequence = "atg ccc AAA AAC Cat GGa Taa"
+print ("Sequence : ", sequence)
+
+# Sequence en lettres majuscules
+sequpper = sequence.upper()
+print ("Sequence en lettres majuscules : ", sequpper)
+
+# Passage en liste
+seqliste = sequpper.split() # seqliste = sequence.split(" ")
+print ("SeqListe : ", seqliste)
+
+# Longueur de la sequence
+length = len(seqliste) * 3
+print ("Longueur de la sequence : ", length)
+
+# 1er codon
+codon1 = seqliste[0]
+print ("1er codon : ", codon1)
+
+# Dernier codon
+codont = seqliste[len(seqliste)-1]
+print ("Dernier codon : ", codont)
diff --git "a/Python/Corrig\303\251s/nom-prenom.py" "b/Python/Corrig\303\251s/nom-prenom.py"
new file mode 100644
index 0000000000000000000000000000000000000000..3c16854389dd97423d4112d8256f99d29045ec2d
--- /dev/null
+++ "b/Python/Corrig\303\251s/nom-prenom.py"
@@ -0,0 +1,9 @@
+# -*- coding: latin-1 -*-
+'''
+Created on 13 mars 2019
+
+@author: oinizan
+'''
+
+import sys
+print ("Je m'appelle", sys.argv[1], sys.argv[2])
diff --git "a/Python/Corrig\303\251s/revcomp.py" "b/Python/Corrig\303\251s/revcomp.py"
new file mode 100644
index 0000000000000000000000000000000000000000..e8539bc8c527782dfcd7c16ff603f5b5068ea4de
--- /dev/null
+++ "b/Python/Corrig\303\251s/revcomp.py"
@@ -0,0 +1,39 @@
+# -*- coding: latin-1 -*-
+'''
+Created on 12 juin 2014
+
+@author: sderozier & oinizan
+'''
+
+def reverse(seq) :
+# return seq[::-1]
+
+ rev = ""
+
+ for i in range(len(seq)) :
+
+ rev += seq[len(seq)-1-i]
+
+ return rev
+
+def complement(seq) :
+
+ comp = ""
+
+ for nucleotide in seq :
+
+ nucleotides = {"A" : "T", "T" : "A", "G" : "C", "C" : "G"}
+
+ comp += nucleotides[nucleotide]
+
+ return comp
+
+# Sequence initiale
+sequence = "ATGATGCAGCT"
+print ("Sequence initiale : ", sequence)
+
+seqreverse = reverse(sequence)
+print ("Sequence reversee : ", seqreverse)
+
+seqcomplement = complement(seqreverse)
+print ("Sequence finale : ", seqcomplement)
diff --git "a/Python/Corrig\303\251s/traduction.py" "b/Python/Corrig\303\251s/traduction.py"
new file mode 100644
index 0000000000000000000000000000000000000000..3be460d9a3b8ece4fdc09e144063d7801316971a
--- /dev/null
+++ "b/Python/Corrig\303\251s/traduction.py"
@@ -0,0 +1,49 @@
+# -*- coding: latin-1 -*-
+'''
+Created on 13 juin 2014
+
+@author: sderozier & oinizan
+'''
+
+def traduction(sequence):
+
+ # Dictionnaire contenant le code genetique
+ code_genetique = {
+ "GCT":"A","GCC":"A","GCA":"A","GCG":"A",
+ "TTA":"L","TTG":"L","CTT":"L","CTC":"L",
+ "CTA":"L","CTG":"L","CGT":"R","CGC":"R",
+ "CGA":"R","CGG":"R","AGA":"R","AGG":"R",
+ "AAA":"K","AAG":"K","AAT":"N","AAC":"N",
+ "ATG":"M","GAT":"D","GAC":"D","TTT":"F",
+ "TTC":"F","TGT":"C","TGC":"C","CCT":"P",
+ "CCC":"P","CCA":"P","CCG":"P","CAA":"Q",
+ "CAG":"Q","TCT":"S","TCC":"S","TCA":"S",
+ "TCG":"S","AGT":"S","AGC":"S","GAA":"E",
+ "GAG":"E","ACT":"T","ACC":"T","ACA":"T",
+ "ACG":"T","GGT":"G","GGC":"G","GGA":"G",
+ "GGG":"G","TGG":"W","CAT":"H","CAC":"H",
+ "TAT":"Y","TAC":"Y","ATT":"I","ATC":"I",
+ "ATA":"I","GTT":"V","GTC":"V","GTA":"V",
+ "GTG":"V","TAG":"*","TGA":"*","TAA":"*"}
+
+ length = len(sequence)
+ print ("Longueur Seq : ", length)
+
+ protein = ""
+
+ for i in range(0, length, 3):
+
+ codon = sequence[i:i+3]
+
+ if ( len(codon) == 3 ):
+
+ protein += code_genetique[sequence[i:i+3]]
+
+ else:
+
+ print ("Ma sequence n'est pas complete !")
+
+ return protein
+
+sequence = "ATGACCATGATTACGAATTCCCGGGGATCCGTCGACCTGCAGC"
+print (traduction(sequence))
diff --git a/Python/Supports/05-listes.html b/Python/Supports/05-listes.html
deleted file mode 100755
index 132548d0752e76131d509f021825080b3c2b86e1..0000000000000000000000000000000000000000
--- a/Python/Supports/05-listes.html
+++ /dev/null
@@ -1,45 +0,0 @@
-<!DOCTYPE html>
-<html>
- <head>
- <title>Title</title>
- <meta charset="utf-8">
- <style>
- @import url(https://fonts.googleapis.com/css?family=Yanone+Kaffeesatz);
- @import url(https://fonts.googleapis.com/css?family=Droid+Serif:400,700,400italic);
- @import url(https://fonts.googleapis.com/css?family=Ubuntu+Mono:400,700,400italic);
-
- body { font-family: 'Droid Serif'; }
- h1, h2, h3 {
- font-family: 'Yanone Kaffeesatz';
- font-weight: normal;
- }
- .remark-code, .remark-inline-code { font-family: 'Ubuntu Mono'; }
- </style>
- </head>
- <body>
- <textarea id="source">
-
-class: center, middle
-# Listes
----
-# Listes
-
-Syntaxe
-
----
-# Accès aux valeurs
-
----
-# Fonctions range() & list()
-
----
-# Liste de liste (?)
-
- </textarea>
- <script src="https://remarkjs.com/downloads/remark-latest.min.js">
- </script>
- <script>
- var slideshow = remark.create();
- </script>
- </body>
-</html>
diff --git a/Python/Supports/05-listes_tuples.html b/Python/Supports/05-listes_tuples.html
new file mode 100755
index 0000000000000000000000000000000000000000..6279b074c5f3e11f1eb768eeae540b013c25a64e
--- /dev/null
+++ b/Python/Supports/05-listes_tuples.html
@@ -0,0 +1,251 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <title>Title</title>
+ <meta charset="utf-8">
+ <style>
+ @import url(https://fonts.googleapis.com/css?family=Yanone+Kaffeesatz);
+ @import url(https://fonts.googleapis.com/css?family=Droid+Serif:400,700,400italic);
+ @import url(https://fonts.googleapis.com/css?family=Ubuntu+Mono:400,700,400italic);
+
+ body { font-family: 'Droid Serif'; }
+ h1, h2, h3 {
+ font-family: 'Yanone Kaffeesatz';
+ font-weight: normal;
+ }
+ .remark-code, .remark-inline-code { font-family: 'Ubuntu Mono'; }
+ </style>
+ </head>
+ <body>
+ <textarea id="source">
+
+class: center, middle
+# Listes
+---
+# Listes
+Selon vous, qu'est-ce qu'une liste ?
+
+---
+# Listes
+
+* Une liste est une structure pour stocker des chiffres, des nombres, des caractères, des chaînes de caractères, ... sous la forme de tableaux.
+
+```python
+>>> alphabet=['A','B','C','D','E','F','G','H','I','J']
+>>> alphabet
+['A','B','C','D','E','F','G','H','I','J']
+```
+* Les éléments de la liste sont accessibles par des indices.
+* 'A' est à l'indice 0, 'B' est à l'indice 1, ..., 'J' est à l'indice 9.
+
+```python
+>>> alphabet[5]
+'F' # et non pas 'E'
+>>> alphabet[-1]
+'J' # dernier élément
+```
+
+---
+# Listes
+* Accès à plusieurs éléments de la liste:
+
+```python
+>>> alphabet[0:3]
+['A', 'B', 'C'] # on obtient une sous liste, attention au dernier indice
+```
+
+* Retrait/Insertion à une position donnée:
+```python
+>>> seq = ['seq1','seq2','seq3']
+>>> seq.pop(0) # rertait à la position 0
+'seq1'
+>>> seq # pop modifie la liste
+['seq2', 'seq3']
+>>> seq.insert(0,'seq1')
+>>> seq
+['seq1', 'seq2', 'seq3']
+```
+
+* Suppression d'un élément donné:
+```python
+>>> seq.remove('seq3')
+>>> seq
+['seq1', 'seq2']
+```
+
+---
+# Listes
+* Ajout d'un élément en fin de liste:
+```python
+>>> seq.append('seq4')
+>>> seq
+['seq1', 'seq2', 'seq4']
+```
+
+* Concaténation de listes:
+```python
+>>> seq1 = ['seq1']
+>>> seq2 = ['seq2']
+>>> seq = seq1 + seq2
+>>> seq
+['seq1', 'seq2']
+```
+
+* Récupération de l'indice:
+```python
+>>> lettres = ['a','b','c']
+>>> lettres.index('b')
+1
+```
+---
+# Listes
+* Nombre d'occurences:
+```python
+>>> lettres=['a','b','c','b','b','a']
+>>> lettres.count('b')
+3
+>>> lettres.count('a')
+2
+```
+
+* Inverser une liste:
+```python
+>>> seq = ['a','b','c']
+>>> seq.reverse()
+['c','b','a']
+```
+
+* Duplication d'une liste:
+```python
+>>> seq = ['seq1','seq2']
+>>> seq*2
+>>> seq
+['seq1','seq2','seq1','seq2']
+```
+
+---
+# Listes
+* Trier dans l'ordre ASCII:
+```python
+>>> seq = ['c','b','a']
+>>> seq.sort() # sort() ne renvoie rien, trie la liste "sur place"
+>>> seq
+['a','b','c']
+>>> seq = ['c','b','a']
+>>> seq2 = sorted(seq) # pour ne pas modifier la liste il faut utiliser sorted()
+>>> seq2
+['a','b','c']
+>>> seq
+['c','b','a']
+```
+
+* Transformer une chaîne de caractère en liste grâce à un séparateur:
+```python
+>>> sequence = 'a*b*c*d*e*f'
+>>> sequence.split('*')
+['a', 'b', 'c', 'd', 'e', 'f']
+```
+
+---
+#Listes
+* Nombre d'éléments dans une liste:
+```python
+>>> sequence=['a', 'b', 'c', 'd', 'e', 'f']
+>>> len(sequence)
+6
+```
+
+---
+# Listes
+* La fonction range() renvoie une liste avec les indices:
+```python
+>>> liste=range(5)
+range(0, 5)# équivaut à [0,1,2,3,4]
+```
+
+* Appliquée à la longueur d'une liste renvoie les indices de la liste:
+```python
+>>> liste=['a','b','c','d','e']
+>>> range(len(liste))
+range(0, 5)# équivaut à [0,1,2,3,4]
+```
+
+* Utile pour le parcours de liste:
+```python
+>>> for i in range(len(liste)):print("",liste[i])
+...
+ a
+ b
+ c
+ d
+ e
+```
+
+---
+# Listes
+* Ecriture plus directe pour un parcours de liste:
+```python
+>>> for i in liste:print("",i)
+...
+ a
+ b
+ c
+ d
+ e
+```
+
+* La méthode list() prend un itérable et en fait une liste:
+```python
+>>> chaine = "abcd"
+>>> list(chaine)
+['a','b','c','d']
+```
+
+---
+# Tuples
+
+* Un tuple est une liste non modifiable.
+
+* Il n'existe dons pas de méthodes pour ajouter/enlever des éléments dans un tuple.
+* L'accès aux valeurs par l'indice ainsi que l'interrogation du tuple est possible.
+
+* Exemple:
+
+```python
+>>> t = (1,2,3)
+>>> t
+(1, 2, 3)
+>>> t[1] # accès aux valeurs
+2
+>>> 2 in t # interroger le tuple
+True
+```
+
+---
+# Tuples ou Listes ?
+
+* Les tuples sont plus rapides que les listes.
+
+* Si vous souhaitez parcourrir un ensemble fixe de données utilisez, un tuple.
+* Utile aussi pour protéger votre code en écriture.
+
+* Source:
+https://python.developpez.com/cours/DiveIntoPython/php/frdiveintopython/native_data_types/tuples.php
+
+---
+# Travaux Pratiques
+
+<div align = "justify">Créer un programme Python nommé <b>liste.py</b> permettant de manipuler une liste générée à partir de la chaîne de caractères <b> atg ccc AAA AAC Cat GGa Taaa </b> et d'afficher les informations suivantes en <i>25 minutes d'autonomie</i> :</div>
+
+* la <b>séquence</b> en <b>lettres majuscules</b> uniquement,
+* la <b>longueur</b> de la séquence,
+* le <b>premier codon</b>,
+* le <b>dernier codon</b>.
+ </textarea>
+ <script src="https://remarkjs.com/downloads/remark-latest.min.js">
+ </script>
+ <script>
+ var slideshow = remark.create();
+ </script>
+ </body>
+</html>
diff --git a/Python/Supports/06-dicos.html b/Python/Supports/06-dicos.html
new file mode 100755
index 0000000000000000000000000000000000000000..92195da91967be4f1db6c7933a17f66964333320
--- /dev/null
+++ b/Python/Supports/06-dicos.html
@@ -0,0 +1,103 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <title>Title</title>
+ <meta charset="utf-8">
+ <style>
+ @import url(https://fonts.googleapis.com/css?family=Yanone+Kaffeesatz);
+ @import url(https://fonts.googleapis.com/css?family=Droid+Serif:400,700,400italic);
+ @import url(https://fonts.googleapis.com/css?family=Ubuntu+Mono:400,700,400italic);
+
+ body { font-family: 'Droid Serif'; }
+ h1, h2, h3 {
+ font-family: 'Yanone Kaffeesatz';
+ font-weight: normal;
+ }
+ .remark-code, .remark-inline-code { font-family: 'Ubuntu Mono'; }
+ </style>
+ </head>
+ <body>
+ <textarea id="source">
+
+class: center, middle
+# Dictionnaires
+
+---
+# Dictionnaires
+Selon vous qu'est ce qu'un dictionnaire ?
+
+---
+# Dictionnaires
+
+* Un dictionnaire est une structure pour stocker des chiffres, des nombres, des caractères, des chaînes de caractères, ...
+* Les éléments stockés seront retrouvés à partir d'une clé.
+* La clé doit être unique.
+* La recherche d'une valeur se fait à partir d'une clé et non l'inverse.
+
+---
+# Dictionnaires
+
+* Opérateur d'affectation:
+
+```python
+>>> sequences = {'seq1':'ATGC', 'seq2':'TGCC'}
+>>> sequences
+{'seq1': 'ATGC', 'seq2': 'TGCC'}
+```
+
+* Liste des clés:
+```python
+>>> sequences.keys()
+dict_keys(['seq1', 'seq2'])
+```
+
+* Liste des valeurs:
+```python
+>>> sequences.values()
+dict_values(['ATGC', 'TGCC'])
+```
+
+* Accéder à une valeur donnée:
+```python
+>>> sequences['seq2']
+'TGCC'
+```
+
+---
+# Dictionnaires
+* Ajout d'un couple clé/valeur:
+```python
+>>> sequences['seq3'] = 'GCTT'#si la clé existe déjà , la valeur est remplacée
+```
+
+* Suppression d'un couple clé valeur:
+```python
+>>> sequences = {'seq1':'ATGC', 'seq2':'TGCC'}
+>>> del sequences['seq2']
+>>> sequences
+{'seq1': 'ATGC'}
+>>> sequences.pop('seq1') # pop() renvoie directement la valeur
+'ATGC'
+>>> sequences
+{}
+```
+
+---
+# Travaux Pratiques
+<div align = "justify">Créer un programme Python nommé <b>dictionnaire.py</b> permettant de manipuler un dictionnaire et d'afficher les informations suivantes en <i>25 minutes d'autonomie</i> :</div>
+
+* la <b>séquence</b> qui a pour nom <b>A.SE.SE6594</b>,
+* la <b>liste de tous les noms des séquences</b> (sans les recopier),
+* la <b>liste de toutes les séquences</b> (sans les recopier),
+* le <b>liste de tous les noms de séquences rangés par ordre alphabétique</b>,
+* la <b>longueur de la séquence "A.SE.SE7253"</b>,
+* le <b>1er codon et le 2ème codon de cette séquence</b>.
+
+ </textarea>
+ <script src="https://remarkjs.com/downloads/remark-latest.min.js">
+ </script>
+ <script>
+ var slideshow = remark.create();
+ </script>
+ </body>
+</html>
diff --git a/Python/Supports/06-dicos_tuples.html b/Python/Supports/06-dicos_tuples.html
deleted file mode 100755
index 8c1a0effed2de33fdbc8d7bbbab1b183b6e7177b..0000000000000000000000000000000000000000
--- a/Python/Supports/06-dicos_tuples.html
+++ /dev/null
@@ -1,46 +0,0 @@
-<!DOCTYPE html>
-<html>
- <head>
- <title>Title</title>
- <meta charset="utf-8">
- <style>
- @import url(https://fonts.googleapis.com/css?family=Yanone+Kaffeesatz);
- @import url(https://fonts.googleapis.com/css?family=Droid+Serif:400,700,400italic);
- @import url(https://fonts.googleapis.com/css?family=Ubuntu+Mono:400,700,400italic);
-
- body { font-family: 'Droid Serif'; }
- h1, h2, h3 {
- font-family: 'Yanone Kaffeesatz';
- font-weight: normal;
- }
- .remark-code, .remark-inline-code { font-family: 'Ubuntu Mono'; }
- </style>
- </head>
- <body>
- <textarea id="source">
-
-class: center, middle
-# Dictionnaires & Tuples
----
-
-# Dictionnaires
-
-* clé unique
-* keys() et values()
-* liste de dictionnaire (?)
----
-
-# Tuples
-
-* Listes non modifiables
-
-* Exemple(s)
-
- </textarea>
- <script src="https://remarkjs.com/downloads/remark-latest.min.js">
- </script>
- <script>
- var slideshow = remark.create();
- </script>
- </body>
-</html>
diff --git a/Python/Supports/07-controle.html b/Python/Supports/07-controle.html
index 8badeb4b479f5434c7916024ee6f30c268c30f09..929654be2c93a5156787d63cc019522bfe71e0e2 100755
--- a/Python/Supports/07-controle.html
+++ b/Python/Supports/07-controle.html
@@ -20,15 +20,68 @@
<textarea id="source">
class: center, middle
-# Structures de controles
+# Structures de contrôle
+
+---
+# Structures de contrôle
+
+* Selon vous toutes les données sont elles à traiter ?
+
+
---
-# Structure
+# Structure de contrôle
+
+* La syntaxe:
+```python
+if condition1: # attention à l'indentation
+ action1
+elif condition2:
+ action2
+else:
+ action3
+```
+
+* Exemple:
+```python
+>>> length = 10
+>>> seuil = 15
+>>> if length <= seuil:
+... print ("la valeur est inférieure ou égale au seuil fixé")
+... else:
+... print ("la valeur est supérieure au seuil fixé")
+...
+la valeur est inférieure ou égale au seuil fixé
+```
---
# Tests multiples
+* Tester plusieurs conditions en même temps avec des booléens.
+
+* La syntaxe:
+```python
+>>> x = 2
+>>> y = 2
+>>> if x == 2 or y == 2:
+... print ("le test est vrai")
+...
+le test est vrai
+```
+
---
-# Break & Continue
+# Travaux Pratiques
+<div align = "justify">Créer un programme Python nommé <b>controle.py</b> permettant de manipuler le contenu d'un dictionnaire avec des strcutures de contrôle et d'afficher les informations suivantes en <i>25 minutes d'autonomie</i> :</div>
+
+
+* les <b>séquences</b> qui ont pour nom <b>A.KE.Q23-CXC-CG</b> et <b>A.SE.SE7535</b>,
+* la <b>longueur</b> des 2 séquences précédentes,
+* les <b>premiers codons</b> des 2 séquences précédentes,
+* les <b>derniers codons</b> des 2 séquences précédentes,
+* <b>si</b> les séquences sont identiques,
+* <b>si</b> les séquences sont de même longeur,
+* <b>si</b> les premiers codons des 2 séquences précédentes sont bien une <b>méthionine (ATG)</b>,
+* <b>si</b> les <b>derniers codons</b> des 2 séquences précédentes sont bien <b>un codon stop (TAA,TGA ou TAG)</b>.
+
</textarea>
<script src="https://remarkjs.com/downloads/remark-latest.min.js">
diff --git a/Python/Supports/10-use_modules.html b/Python/Supports/10-use_modules.html
index e3fd54b78f4d03fb888e0abf6ba785ed0db5cfb9..3e8706eec69b10bd59abaf7a4979e45c8b23b965 100755
--- a/Python/Supports/10-use_modules.html
+++ b/Python/Supports/10-use_modules.html
@@ -21,14 +21,108 @@
class: center, middle
# Utilisation de modules
+---
+# Modules
+
+* Les modules sont des programmes Python qui contiennent des fonctions* que l'on est amené à utiliser souvent.
+* Vous avez accès à une documentation exhaustive sur le site python: https://docs.python.org/3/py-modindex.html
+* L'instruction import permet d'importer l'ensemble des fonctions (ou sous modules) du module:
+
+```python
+>>> import os # toutes les fonctions/sous modules du modules os sont disponibles
+>>> os.path # par exemple le sous module path
+<module 'posixpath' from '/usr/lib/python3.4/posixpath.py'>
+```
+
+* Avec le mot clé from il est possible d'importer directement la fonction/sous module:
+```python
+>>> from os import path
+>>> path # ici pas de prefix os
+<module 'posixpath' from '/usr/lib/python3.4/posixpath.py'>
+```
+
+* Obtenir de l'aide sur un module:
+```python
+>>> help(os)
+>>> help(os.path)
+```
+
---
# Module os
+* Interaction avec le système d'exploitation.
+
+```python
+>>> fullname='/home/maiage/sderozier/scripts/test.py'
+>>> import os
+>>> help(os.path.dirname)
+Help on function dirname in module posixpath:
+
+dirname(p)
+ Returns the directory component of a pathname
+(END)
+>>> os.path.dirname(fullname)
+'/home/maiage/sderozier/scripts'
+```
+
+```python
+>>> help(os.path.basename)
+Help on function basename in module posixpath:
+
+basename(p)
+ Returns the final component of a pathname
+(END)
+>>>os.path.basename(fullpath)
+'test.py'
+```
+
+---
+
+# Module os
+
+```python
+>>>help(os.path.abspath)
+Help on function abspath in module posixpath:
+
+abspath(path)
+ Return an absolute path.
+(END)
+>>> currentdir=os.path.abspath('.')
+>>> currentdir
+'/home/oinizan/FORMATION-PYTHON-2018/CORRIGES'
+>>> os.listdir(currentdir) # listdir() du module os
+['liste.py', 'traduction.py', 'revcomp.py', 'dictionnaire.py', 'controle.py']
+```
+
---
# Module sys
+* La fonction argv du module sys permet de récupérer les arguments passés <i>en ligne de commande</i> au sein d'une liste.
+
+```python
+1 # script test.py
+2 import sys
+3 print (sys.argv)
+```
+
+```python
+python3 test.py alpha beta gamma
+['test.py', 'alpha', 'beta', 'gamma']
+```
+
+---
+# Travaux Pratiques
+<div align = "justify">Créer un programme Python faisant appel au module sys permettant d'afficher les informations demandées <i>20 minutes d'autonomie</i> :</div>
+
+* <i>je m'appelle Prénom Nom</i>
+
+<div>Le prénom et le nom doivent être passés en argument du programme et récupérés au sein de celui-ci afin d'effectuer l'affichage.</div>
+
+
+
+
</textarea>
<script src="https://remarkjs.com/downloads/remark-latest.min.js">
</script>
diff --git a/Python/Supports/11-fonctions.html b/Python/Supports/11-fonctions.html
index 6780cbfb300f0cf3c1f006020484d3d3b3a04213..ec46a740b7f9159534f13466be0a9135f4023898 100755
--- a/Python/Supports/11-fonctions.html
+++ b/Python/Supports/11-fonctions.html
@@ -22,18 +22,180 @@
class: center, middle
# Fonctions
---
+# Fonctions
+
+* Une fonction permet de répéter une instruction plusieurs fois sans avoir à réécrire la totalité du code.
+
+* Syntaxe:
+```python
+def fonction(param1,param2): # attention à l'indentation
+ instruction1
+ instruction2
+ return resultat1, resultat2
+```
+
+---
+
+# Fonctions
-# Structure
+* Exemple:
+```python
+>>> def pluriel(param):
+... param = param + "s"
+... return param
+...
+>>> mots=pluriel("sequence")
+>>> mots
+'sequences'
+```
---
# Passage d'arguments
+* Vous n'êtes pas tenu de préciser le type (entiers, réels, chaîne de caractère,...) d'arguments lors de l'appel de la fonction:
+```python
+>>> def fois(x,y):
+... return x*y
+...
+>>> fois(2,3)
+6
+>>> fois(3.1415,5.23)
+16.430045000000003
+>>> fois(2,5.23)
+10.46
+>>> fois('to',2)
+'toto'
+```
+
+* L'opérateur '*' reconnait plusieurs types, la fonction 'fois' peut donc effectuer des tâches différentes.
+
---
-# Variables globales et locales
+# Passage d'arguments
+
+* Les fonctions sont capables de renvoyer plusieurs valeurs à la fois.
+
+* On peut dès lors effectuer des affectations multiples.
+
+```python
+>>> def carre_cube(x):
+... return x**2,x**3 # renvoi d'un tuple
+...
+>>> carre_cube(2)
+(4, 8)
+>>> z1,z2=carre_cube(2) # affectation multiple
+>>> z1
+4
+>>> z2
+8
+```
+
+---
+
+# Passage d'arguments
+
+* Renvoi de plusieurs valeurs à la fois avec une liste:
+
+```python
+>>> def carre_cube2(x):
+... return [x**2,x**3]
+...
+>>> carre_cube2(3)
+[9, 27]
+>>> z1,z2 = carre_cube2(3)
+>>> z1
+9
+>>> z2
+27
+```
+
+---
+
+# Passage d'arguments
+
+* Les fonctions peuvent avoir un nombre d'argument variables.
+
+```python
+>>> str="Python débutant: 1er mars, Python avancé: 1er avril"
+>>> str.replace("Python","Perl") # replace 2 arguments
+'Perl débutant: 1er mars, Perl avancé: 1er avril'
+```
+
+```python
+>>> str="Python débutant: 1er mars, Python avancé: 1er avril"
+>>> str.replace("Python","Perl",1) # replace 3 arguments
+'Perl débutant: 1er mars, Python avancé: 1er avril'
+```
+
+* Pour avoir un nombre d'argument variables, il faut définir des arguments facultatifs:
+
+```python
+>>> def fct(x,y,z=1): # un argument facultatif avec une valeur par défaut
+... if z!=1:
+... ...
+... return ...
+```
+
+---
+# Travaux pratiques
+
+<div align = "justify">Créez un programme Python contenant deux fonctions permettant de "reverse complémenter" une séquence en 25 minutes d'autonomie:</div>
+
+* création d'une <b>fonction</b> avec <b>un paramètre</b> et <b>une instruction</b> pour <b>inverser</b> la <b>séquence</b>,
+* création d'une <b>fonction</b> avec <b>un paramètre</b> et <b>une instruction</b> pour <b>complémenter</b> la <b>séquence</b>,
+* <b>retour</b> du <b>résultat</b> et <b>affichage</b> de celui-ci.
+
+---
+# Travaux pratiques
+<div align = "justify">Créez un programme Python contenant une fonction permettant de traduire une séquence en 25 minutes d'autonomie:</div>
+
+* création d'une <b>fonction</b> avec <b>un paramètre</b> et <b>une instruction</b> pour <b>traduire</b> la <b>séquence</b>,
+* <b>retour</b> du <b>résultat</b> et <b>affichage</b> de celui-ci.
+
+
+---
+# Code génétique
+
+```python
+code_genetique = {
+"GCT":"A","GCC":"A","GCA":"A","GCG":"A",
+"TTA":"L","TTG":"L","CTT":"L","CTC":"L",
+"CTA":"L","CTG":"L","CGT":"R","CGC":"R",
+"CGA":"R","CGG":"R","AGA":"R","AGG":"R",
+"AAA":"K","AAG":"K","AAT":"N","AAC":"N",
+"ATG":"M","GAT":"D","GAC":"D","TTT":"F",
+"TTC":"F","TGT":"C","TGC":"C","CCT":"P",
+"CCC":"P","CCA":"P","CCG":"P","CAA":"Q",
+"CAG":"Q","TCT":"S","TCC":"S","TCA":"S",
+"TCG":"S","AGT":"S","AGC":"S","GAA":"E",
+"GAG":"E","ACT":"T","ACC":"T","ACA":"T",
+"ACG":"T","GGT":"G","GGC":"G","GGA":"G",
+"GGG":"G","TGG":"W","CAT":"H","CAC":"H",
+"TAT":"Y","TAC":"Y","ATT":"I","ATC":"I",
+"ATA":"I","GTT":"V","GTC":"V","GTA":"V",
+"GTG":"V","TAG":"*","TGA":"*","TAA":"*"}
+```
+
+---
+# Travaux pratiques
+
+* Variables globales et locales:
+
+
+<div align = "justify">Allez sur <b>Python Tutor</b> http://pythontutor.com/visualize.html. Ecrivez d'abord une fonction carre(x) qui renvoie x au carré. Ecrivez en dessous un programme principal qui appelle carre() avec la valeur 5 en paramètre. Suivez l'éxécution pour distinguer les variables globales des variables locales.</div>
+
+```python
+>>> def carre(x):
+... return x**2
+...
+>>> # programme principal
+...
+>>> z=5
+>>> resultat=carre(5)
+>>> print(resultat)
+```
-Python Tutor : http://pythontutor.com/visualize.html
</textarea>
<script src="https://remarkjs.com/downloads/remark-latest.min.js">
diff --git a/Python/Supports/13-erreurs.html b/Python/Supports/13-erreurs.html
index a5937349660726bc09ebaf04567d43d50b106221..03f591acbd124c1e1ba4a3a4d5effe614967eb8c 100755
--- a/Python/Supports/13-erreurs.html
+++ b/Python/Supports/13-erreurs.html
@@ -23,11 +23,121 @@ class: center, middle
# Gestion des erreurs
---
-# ToDo
+# Exceptions
+
+* En Python les exceptions sont un ensemble de directives et mots-clés dédié à la gestion des erreurs.
+* Une exception est un comportement non attendu du programme:
+
+```python
+1 # script erreur.py
+2 x =int(input("Entrez un nombre: "))
+3 print 10/x
+```
+
+```python
+python erreur.py
+Entrez un nombre: 10
+1
+```
+
+```python
+python erreur.py
+Entrez un nombre: 0
+Traceback (most recent call last):
+ File "erreur.py", line 2, in <module>
+ print (10/x)
+ZeroDivisionError: integer division or modulo by zero
+```
+
+* Python nous a renvoyé un ZeroDivisionError
---
-# ToDo
+# Exceptions
+
+* Des directives/mots-clés qui nous permmettent d'<i>attraper</i> ces erreurs.
+* Try ... except
+```python
+1 try:
+2 x =int(input("Entrez un nombre: "))
+3 print (10/x)
+4
+5 except ZeroDivisionError:
+6 print ("ERREUR, division par zéro impossible")
+```
+
+```python
+python erreur.py
+Entrez un nombre: 0
+ERREUR, division par zéro impossible
+```
+
+---
+
+# Exceptions
+
+* D'autres types d'erreurs sont possibles:
+````python
+python erreur.py
+Entrez un nombre: a
+Traceback (most recent call last):
+ File "erreur.py", line 3, in <module>
+ x =int(input("Entrez un nombre: "))
+ File "<string>", line 1, in <module>
+NameError: name 'a' is not defined
+````
+
+* Pour attraper des exceptions que l'on ne sait/veut pas qualifier:
+```python
+1 try:
+2 x =int(input("Entrez un nombre: "))
+3 print (10/x)
+4
+5 except ZeroDivisionError:
+6 print ("ERREUR, division par zéro impossible")
+7
+8 except Exception:
+9 print ("Une erreur est survenue")
+```
+
+---
+
+# Exceptions
+
+* try ... except ... else
+* le bloc else pour la suite normale du programme
+ ```python
+1 try:
+2 x =int(input("Entrez un nombre: "))
+3 div = (10/x)
+4
+5 except ZeroDivisionError:
+6 print ("ERREUR, division par zéro impossible")
+7
+8 except Exception:
+9 print ("Une erreur est survenue")
+10
+11 else:
+12 div ... # ici la suite normale du programme
+```
+
+---
+
+# Exceptions
+
+* TODO finally
+* Les exceptions disponibles en Python: https://docs.python.org/3/library/exceptions.html
+* TODO raise
+
+---
+# Travaux Pratiques
+<div align = "justify">Créer un script Python nommé <b>capteur_temperature.py</b> qui calcule la moyenne d'une série de températures avec les caractéristiques suivantes (<i>25 minutes d'autonomie</i>) :</div>
+
+* Les températures sont enregistrées sous forme d'une <b>liste</b> d'entiers.
+* Une <b>fonction</b> read_tmp() lit une valeur de t°, déclenche une <b>exception</b> si la valeur lue est supérieure à 20°C et <b>retourne</b> simplement la valeur sinon.
+* Un programme principal qui moyenne les valeurs inférieures à 20°c et qui indique le nombre de valeurs supérieures à 20°C.
+
+
</textarea>
<script src="https://remarkjs.com/downloads/remark-latest.min.js">