README.md

 # INF-TC1
 
+## Installation
+
+* La distribution Anaconda offre cet avantage en étant multi-plateformes (Windows, Mac, Linux) et disposant de tous les outils dont vous aurez besoin en Informatique au cours du semestre (interpréteur Python, éditeur Spyder, divers modules). Vous obtiendrez la dernière version sur ce site : https://www.anaconda.com/download/
+
+* Nous vous demandons donc de l’installer sur vos ordinateurs et de vérifier son fonctionnement (l’exécution d’un code simple devrait suffire) avant votre première séance de TD.
+
+* Concerant l'éditeur de code Python, vous pouvez utiliser Spyder inclu dans Anaconda, mais vous pouvez aussi télécharger et installer Microsoft Code qui est une excellente alternative : https://code.visualstudio.com/download
+
+
+## Aides en informatique
+
+* Des [transparents d'aide](aide-informatique.pdf)
+* Une vidéo de présentation de ces transparents https://replay.ec-lyon.fr/video/0920-aides-en-informatique/ 
+
+## Livres
+
+Les livres suivants sont disponibles sous forme de pdf et couvrent les points abordés en cours et en TD :
+
+- [Think Python](books/thinkpython2.pdf), 2nd edition, par Allen B. Downey
+- [Python for Everybody](books/pythonlearn.pdf), par Charles Severance
+- [Problem Solving with Algorithms and Data Structures using Python](books/problemsolving.pdf), par Brad Miller et David Ranum
+- [ODS Pyhon](books/ods-python.pdf), par Pat Morin ([url](https://opendatastructures.org/ods-python/))
+
+Autres ressources :
+
+- https://en.wikibooks.org/wiki/Algorithms/
+- [computer science books](https://freecomputerbooks.com/compscAlgorithmBooks.html)
\ No newline at end of file

TD01/code/addition.py

-def addition(a, b):
-    return a + b
-
-def addition_inf(*argv):
-    res = 0
-    for arg in argv:  
-        res += arg
-    return res
-
-if __name__=="__main__": 
-    assert addition(1, 2) == 3
-    assert not addition(1, 2) == 2
-
-    assert addition_inf(1, 1, 1) == 3
-    assert not addition_inf(1, 1, 1) == 2
-
-    assert addition_inf(1, 1, 1) == addition(1, 2)
\ No newline at end of file

TD01/code/chaines-valide.py

-def valide(seq):
-    """Retourne True si séquence ADN."""
-    ret = len(seq) != 0
-    for c in seq:
-        ret = (ret and True) if (c in "atgc") else False
-    return ret
-
-if __name__=="__main__": 
-    assert valide("atgc")
-    assert not valide("atgcz")

TD01/code/commentaires.py

-# Un commentaire court commence par un # et se limite à la fin de la ligne
-
-"""
-On peut aussi créer un commentaire long = une zone de 
-commentaires  sur plusieurs lignes placées
-entre une paire de triple-guillements dont le second suit :
-"""
-
-# Remarques : 
-# Un ';' à la fin d'une ligne rend la ligne muette (pas d'affichage des résultats). 
-# Il permet également de placer plusieurs expressions sur la même ligne.
-
-# Si vous placez un commentaire immédiatement après la signature d'une fonction} 
-# (ou une méthode, une classe, etc.) entre un couple de  """, 
-# votre commentaire (appelé docstring) devient accessible avec help
\ No newline at end of file

TD01/code/comprehension.py

-S = [x**2 for x in range(10)]
-V = [2**i for i in range(13)]
-M = [x for x in S if x % 2 == 0]
-
-print(S); print(V); print(M)
-# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
-# [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096]
-# [0, 4, 16, 36, 64]
-
-
-S = {x**2 for x in range(10)}           # {} au lieu de [] : on veut un ensemble
-print(S)
-# {0, 1, 4, 9, 16, 25, 36, 49, 64, 81}
-type(S)
-#set
-
-V = (2**i for i in range(13))
-print(V)
-# <generator object <genexpr> at 0x7f7bb55edc18>
-
-type(V)
-# generator
-
-# On peut mieux comprendre les listes en compréhension à travers leurs fonctions équivalentes
-S = []
-for i in range(10):
-    S.append(i*2)
-
-# Et 
-S = [i*2 for i in range(10)]
-
-S
-# [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
-
-[c for c in "foobar"]
-
-# Donne ['f', 'o', 'o', 'b', 'a', 'r']
\ No newline at end of file

TD01/code/dict.py

-# Trois fonctions importantes sur les dicts  : keys(), values() et items()
-
-a = dict(one=1, two=2, three=3)
-b = {'one': 1, 'two': 2, 'three': 3}
-c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
-d = dict([('two', 2), ('one', 1), ('three', 3)])
-e = dict({'three': 3, 'one': 1, 'two': 2})
-a == b == c == d == e
-# True
-
-capitals = {'Iowa':'DesMoines','Wisconsin':'Madison'}
-print(capitals['Iowa'])
-# DesMoines
-
-capitals['Utah']='SaltLakeCity'
-print(capitals)
-# {'Iowa': 'DesMoines', 'Utah': 'SaltLakeCity', 'Wisconsin': 'Madison'}
-
-capitals['California']='Sacramento'
-print(len(capitals))
-# 4
-
-for k in capitals:
-    print(capitals[k]," is the capital of ", k)
-# DesMoines  is the capital of  Iowa
-# SaltLakeCity  is the capital of  Utah
-# Madison  is the capital of  Wisconsin
-# Sacramento  is the capital of  California
-
-phone_ext={'david':1410, 'brad':1137}
-phone_ext
-# {'brad': 1137, 'david': 1410}
-
-phone_ext.keys()                    # Renvoie les clés de phone_ext
-# dict_keys(['brad', 'david'])
-
-list(phone_ext.keys())
-# ['brad', 'david']
-
-"brad" in phone_ext
-# True
-
-1137 in phone_ext
-# False                             # 1137 n'est pas une clé
-
-phone_ext.values()                  # Renvoie les valeurs de phone_ext
-# dict_values([1137, 1410])
-
-list(phone_ext.values())
-# [1137, 1410]
-
-phone_ext.items()
-# dict_items([('brad', 1137), ('david',1410)])
-
-phone_ext.get("kent")
-# Rien !    La clé n'y est pas.
-
-phone_ext.get("kent","NO ENTRY")    # Si on veut récupérer la réponse en cas d'absence de la clé.
-'NO ENTRY'
-
-del phone_ext["david"]
-phone_ext
\ No newline at end of file

TD01/code/division.py

-def division(x, y):
-    return x / y
-
-if __name__=="__main__": 
-    try:
-        r = division(2, 1)
-        # division(2, 0)
-        # division("2", "1")
-    except ZeroDivisionError:
-        print("Division par zero !")
-    else:
-        print("Le résultat est", r)
-    finally:
-        print("Clause finale")
-

TD01/code/fibo-comp.py

-def fibo1(f2, f1, i):
-    if i > 0:
-        return fibo1(f1, f2+f1, i-1)
-    else:
-        return f2
-
-
-def fibo2(f2, f1, i):
-    while i > 0:
-        f2, f1, i = f1, f2+f1, i-1
-    return f2
-
-print(fibo1(6))
-print(fibo2(6))
\ No newline at end of file

TD01/code/fibo-mem.py

-def fib(n, lookup): 
-  
-    # Cas d'arrêt
-    if n == 0 or n == 1 : 
-        lookup[n] = n 
-  
-    # On calcule la valeur si pas déjà calculée
-    if lookup[n] is None: 
-        lookup[n] = fib(n-1 , lookup)  + fib(n-2 , lookup)  
-  
-    # On renvoie la n-eme valeur
-    return lookup[n] 
-  
-def main(): 
-    n = 6 
-    max = 100
-    # Initialise la table de cache
-    lookup = [None]*(max)
-    print("Le nombre de fibonacci est ", fib(n, lookup))
-    # Le nombre de fibonacci est  8
-
-if __name__=="__main__": 
-    main() 
\ No newline at end of file

TD01/code/file.py

-class File():
-    def __init__(self, values = []):
-        self.__values = []
-        for v in values:
-            self.ajoute(v)
-
-    def ajoute(self, v):
-        self.__values.append(v)
-        return v
-
-    def supprime(self):
-        v = self.__values.pop(0)
-        return v
-
-    def renvoie(self, critere = lambda x : True):
-        for v in self.__values:
-            if critere(v):
-                return v
-        return False
-
-    def affiche(self):
-        for v in self.__values:
-            print(v)
-
-    def taille(self): 
-        return len(self.__values)
-
-if __name__ == "__main__":
-    f = File()
-    for d in [1, 2, 3]:
-        f.ajoute(d)

TD01/code/graphe-sim.py

-# Par exemple pour Fool et Sage vous devez renvoyez le résultat suivant :
-# 
-# FOOL
-# POOL
-# POLL
-# POLE
-# PALE
-# SALE
-# SAGE
-# 
-# SOLUTION:
-
-graph = {'A': ['B', 'C'],
-  'B': ['C', 'D'],
-  'C': ['D'],
-  'D': ['C'],
-  'E': ['F'],
-  'F': ['C']
-}
-
-class Graphe(dict):
-    def __init__(self, liens, noeuds):
-        for v in liens:
-            self[v] = set()
-        for e in noeuds:
-            self.ajout_noeud(e)
-
-    def ajout_lien(self, lien):
-        self[lien[0]].add(lien[1])
-        self[lien[1]].add(lien[0])
-
-    def ajout_noeud(self, noeud):
-        self[noeud] = set()
-
-def simGraphe(mots):
-    d = {}
-    g = Graphe(mots, [])
-
-    for mot in mots:
-        for i in range(len(mot)):
-            groupe = mot[:i] + '_' + mot[i+1:]
-            if groupe in d:
-                d[groupe].append(mot)
-            else:
-                d[groupe] = [mot]
-
-    for groupe in d.keys():
-        for mot1 in d[groupe]:
-            for mot2 in d[groupe]:
-                if mot1 != mot2:
-                    g.ajout_lien([mot1, mot2])
-    return g
-
-def chemin(graphe, source, destination, visite=None):
-
-    if source == destination:
-        return [destination]
-    else:
-        visite = visite or set()
-        for s in graphe[source]:
-                if s not in visite:
-                    visite.add(s)
-                    print("trace:", source + " > " + s)
-                    sous_chemin = chemin(graphe, s, destination, visite)
-                    if sous_chemin is not None:
-                        return [source] + sous_chemin
-
-print(chemin(simGraphe(["AA", "AB", "BC", "AC", "DD"]), "AA", "BC"))
-
-# ['AA', 'AB', 'AC', 'BC']
\ No newline at end of file

TD01/code/graphe_dico.py

-G = {
-    'A' : ['B','C', 'F'],
-    'B' : ['D', 'E'],
-    'C' : ['F'],
-    'D' : ['G'],
-    'E' : ['F'],
-    'F' : ['G', 'H'],
-    'G' : ['H'],
-    'H' : []
-}
-
-v = set()
-
-def traitement(v, G, n):
-    if n not in v:
-        v.add(n)
-        print(n)
-        for m in G[n]:
-            traitement(v, G, m)
-
-if __name__ == '__main__':
-    traitement(v, G, 'A')
-
-    if len(v) > 0:
-        print("Que se passe-t-il ?")

TD01/code/liste-liee.py

-class Node:
-    def __init__(self, data = None, next = None):
-        self.data = data
-        self.next = next
-
-class LinkedList:
-    def __init__(self):
-        self.head = None
-
-    def listprint(self):
-        printval = self.head
-        while printval is not None:
-            print(printval.dataval)
-            printval = printval.nextval
-    
-    def push(self, n):
-        if self.head is None:
-            self.head = Node(n)
-        else:
-            node = self.head
-            while node.next is not None:
-                node = node.next
-            node.next = Node(n)
-
-    def detectLoop(self):
-        s = set() 
-        temp = self.head 
-        while (temp):
-            if (temp in s): 
-                return True
-            s.add(temp) 
-            temp = temp.next
-        return False
\ No newline at end of file

TD01/code/listes-liee-boucle.py

-from liste_liee import *
-
-ll = liste_liee() # Ajout de données
-ll.push(20) 
-ll.push(4) 
-ll.push(15) 
-ll.push(10)
-   
-# Création d'une boucle
-ll.head.next.next.next.next = ll.head; 
-  
-if( ll.detectLoop()): 
-    print ("Il y a une boucle !") 
-else : 
-    print ("Pas de boucle ! ") 
\ No newline at end of file

TD01/code/moyenne.py

-# Calcul de la moyenne de deux entiers  
-
-a=input('Donner la valeur de a : ')
-b=input('Donner la valeur de b : ')
-print('la moyenne = ', (int(a) + int(b))/2)  # int(a) : conversion de 'a' en entier
-
-# Une seconde méthode : on convertit en lisant les valeurs en int
-a=int(input('Donner la valeur de a : '))
-b=int(input('Donner la valeur de b : '))
-print('la moyenne = ', (a+b)/2) 

TD01/code/parite.py

-def parite(a):
-    """ Lire un entier au clavier et décider (et afficher) s'il est pair ou impair. """
-    if (a%2 == 1):
-        print(a, " est impair")
-    else :
-        print(a, " est pair")
-
-if __name__=="__main__": 
-
-    while True:
-        try:
-            a = int(input('Donner un entier  positif : '))
-            parite(a)
-            break
-        except ValueError:
-            print("Ce n'est pas un nombre valide.. ré-essayer !")
-   
-    
\ No newline at end of file

TD01/code/pile.py

-class Pile():
-    def __init__(self, values = []):
-        self.__values = []
-        for v in values:
-            self.ajoute(v)
-
-    def ajoute(self, v):
-        self.__values.append(v)
-        return v
-
-    def supprime(self):
-        v = self.__values.pop()
-        return v
-
-    def affiche(self):
-        for v in self.__values:
-            print(v)
-
-    def taille(self): 
-        return len(self.__values)
-
-if __name__ == "__main__":
-    p = Pile()
-    for d in [1, 2, 3]:
-        p.ajoute(d)

TD01/code/racines.py

-from math import sqrt;
-
-def trinome(a, b, c):
-    """ Résolution équation quadratique """
-    delta = b**2 - 4*a*c
-    if delta > 0.0:
-        assert(a != 0)      
-        racine_delta = sqrt(delta)
-        return (2, (-b-racine_delta)/(2*a), (-b+racine_delta)/(2*a))
-    elif delta < 0.0: return (0,)
-    else: 
-        assert(a != 0)     
-        return (1, (-b/(2*a)))
-    
-if __name__ == "__main__":
-    print(trinome(1.0, -3.0, 2.0))
-    print(trinome(1.0, -2.0, 1.0))
-    print(trinome(1.0, 1.0, 1.0))  
\ No newline at end of file