Compare revisions

# 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

import sys

class Noeud:

    def __init__(self, v, c = []):

        self.v = v

        self.c = c

def parcours_affiche(arbre):

    for c in arbre.c:

        parcours_affiche(c)

    print(arbre.v)

def parcours_recherche(arbre, valeur):

    if arbre is None:

        return False

    stack = arbre.c

    if valeur > arbre.v:

        return False

    if valeur == arbre.v:

        return True

    prev = sys.maxsize

    while len(stack) > 0:

        children = stack.pop(0)

        if valeur == children.v:

            return True

        if valeur > prev and valeur < children.v:

            stack = children.c

            prev = stack[0].v

        else:

            prev = children.v

    return False

if __name__=="__main__": 

    racine = Noeud(13, [Noeud(4, [Noeud(1), Noeud(2), Noeud(3)]), Noeud(8, \

    [Noeud(5), Noeud(6), Noeud(7)]),  Noeud(12, [Noeud(9), Noeud(10), Noeud(11)])])

    print(parcours_affiche(racine))

    # renvoie False pour un arbre vide

    parcours_recherche(None, -1)

    # 11 est dans l'arbre

    assert parcours_recherche(racine, 11) == True

    # 12 n'est pas dans l'arbre

    assert parcours_recherche(racine, 12) == False

 No newline at end of file

class Noeud:

    def __init__(self, v, c = []):

        self.v = v

        self.c = c

def parcours(n):

    stack = []

    stack.append(n)

    r = []

    while len(stack) > 0:

        current = stack.pop(0)

        r.append(current.v)

        for v in current.c:

            stack.append(v)

    return r

if __name__=="__main__": 

    print(parcours(Noeud(1,                         \

                    [                               \

                        Noeud(2, [                  \

                            Noeud(4), Noeud(5)      \

                        ]),                         \

                        Noeud(3)                    \

                    ]                               \

                )                                   \

    ))

    # [1, 2, 3, 4, 5]

    print(parcours(Noeud(5, [Noeud(4, [Noeud(2), Noeud(1)]), Noeud(3)])))

    # [5, 4, 3, 1, 2]

    print(parcours(Noeud(5, [Noeud(1), Noeud(2), Noeud(3), Noeud(4)])))

    # [5, 1, 2, 3, 4]

    print(parcours(Noeud(1, [Noeud(5), Noeud(4), Noeud(3), Noeud(2)])))

    # [1, 5, 4, 3, 2]

class Noeud:

    def __init__(self, v, c = []):

        self.v = v

        self.c = c

def parcour_largeur(n):

    stack = []

    stack.append(n)

    while len(stack) > 0:

        current = stack.pop(0)

        for s in current.c:

            stack.append(s)

        print(current.v)

def parcour_largeur(n):

    stack = []

    stack.append(n)

    while len(stack) > 0:

        current = stack.pop(0)

        for s in current.c:

            stack.append(s)

        print(current.v)

def parcour_profondeur(n):

    stack = []

    stack.append(n)

    while len(stack) > 0:

        current = stack.pop()

        for s in reversed(current.c):

            stack.append(s)

        print(current.v)

def parcour_profondeur_rec(n):

    if len(n.c) > 0:

        parcour_profondeur_rec(n.c[0])

    print(n.v)

    if len(n.c) > 1:

        parcour_profondeur_rec(n.c[1])

def parcour_profondeur_rec_dic(n, A):

    if len(A[n]) > 0:

        parcour_profondeur_rec_dic(A[n][0], A)

    print(n)

    if len(A[n]) > 1:

        parcour_profondeur_rec_dic(A[n][1], A)

racine = Noeud("chien", [Noeud("petit", [Noeud("le")]), Noeud("et", [Noeud("jaune"), Noeud("noir")])])

parcour_profondeur_rec(racine)

A = {"chien": ["petit", "et"],

    "petit": ["le"],

    "le": [],

    "et": ["jaune", "noir"],

    "jaune": [],

    "noir": []

}

parcour_profondeur_rec_dic("chien", A)

print(A.keys())

 No newline at end of file

import sys

class Noeud:

    def __init__(self, v, c = []):

        self.v = v

        self.c = c

def parcours_affiche(arbre):

    for c in arbre.c:

        parcours_affiche(c)

    print(arbre.v)

def parcours_recherche(arbre, valeur):

    if arbre is None:

        return False

    stack = arbre.c

    if valeur > arbre.v:

        return False

    if valeur == arbre.v:

        return True

    prev = sys.maxsize

    while len(stack) > 0:

        children = stack.pop(0)

        if valeur == children.v:

            return True

        if valeur > prev and valeur < children.v:

            stack = children.c

            prev = stack[0].v

        else:

            prev = children.v

    return False    

if __name__=="__main__": 

    racine = Noeud(13, [Noeud(4, [Noeud(1), Noeud(2), Noeud(3)]), Noeud(8, \

    [Noeud(5), Noeud(6), Noeud(7)]),  Noeud(12, [Noeud(9), Noeud(10), Noeud(11)])])

    print(parcours_affiche(racine))

    # renvoie False pour un arbre vide

    parcours_recherche(None, -1)

    # 11 est dans l'arbre

    assert parcours_recherche(racine, 11) == True

    # 12 n'est pas dans l'arbre

    assert parcours_recherche(racine, 12) == False

 No newline at end of file

import collections

class graph:

    def __init__(self,gdict=None):

        if gdict is None:

            gdict = {}

        self.gdict = gdict

def bfs(graph, startnode):

    seen, queue = set([startnode]), collections.deque([startnode])

    while queue:

        vertex = queue.popleft()

        marked(vertex)

        for node in graph[vertex]:

            if node not in seen:

                seen.add(node)

                queue.append(node)

def marked(n):

    print(n)

tree = { "a" : set(["b","c"]),

                "b" : set(["e", "d"]),

                "c" : set(["f"]),

                "f" : set(["i"]),

                "e" : set(["g", "h"]),

                "d" : set(), "i" : set(), "g" : set(), "h" : set() 

                }

bfs(tree, "a")

 No newline at end of file

import collections

class graph:

    def __init__(self,gdict=None):

        if gdict is None:

            gdict = {}

        self.gdict = gdict

def bfs(graph, startnode):

# Track the visited and unvisited nodes using queue

        seen, queue = set([startnode]), collections.deque([startnode])

        while queue:

            vertex = queue.popleft()

            marked(vertex)

            for node in graph[vertex]:

                if node not in seen:

                    seen.add(node)

                    queue.append(node)

def marked(n):

    print(n)

if __name__=="__main__": 

    gdict = { "a" : set(["b","c"]),

                    "b" : set(["a", "d"]),

                    "c" : set(["a", "d"]),

                    "d" : set(["e"]),

                    "e" : set(["a"])

                    }

    bfs(gdict, "a")

 No newline at end of file

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")

# 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

carres = []

for x in range(10):

    if x % 2:

        carres.append(x * x)

list(map(lambda x: x * x,  filter(lambda x: x % 2, range(10))))

[x * x for x in range(10) if x % 2]

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

def dfs(graph, start):

    visited, stack = set(), [start]

    while stack:

        vertex = stack.pop()

        if vertex not in visited:

            visited.add(vertex)

            stack.extend(graph[vertex] - visited)

    return visited

graph = {'A': set(['B', 'C']),

         'B': set(['A', 'D', 'E']),

         'C': set(['A', 'F']),

         'D': set(['B']),

         'E': set(['B', 'F']),

         'F': set(['C', 'E'])}

dfs(graph, 'A') # {'E', 'D', 'F', 'A', 'C', 'B'}

 No newline at end of file

# 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