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

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

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

# 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

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

# https://docs.python.org/3/tutorial/errors.html

import addition

class Error(Exception):

    """Classe de base d'exceptions"""

    pass

class ValueTooSmallError(Error):

    """Si la valeur est trop petite"""

    pass

if __name__ == "__main__":

    a, b = 1, 2

    try:

        if a < 0 or b < 0:

            raise ValueTooSmallError

        # assert addition(a, b) == 3

        # assert not addition(a, b) == 4

        # addition(a, "c")

        # raise EnvironmentError

    except AssertionError:

        print("test non validé")

    except TypeError:

        print("problème de typage")

    except ValueTooSmallError:

        print("valeur trop petite")

    except:

        print("erreur inconnue")

    finally:

        print("c'est la fin, toujours exécuté")

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

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

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)

from math import pi

s = "Python"

s.center(10)         # centrer sur 10 positions

print(s)

# Donne -->'  Python  '

s.center(10,"*")       # centrer sur 10 positions en complétant par des '*'

# Donne -->'**Python**'

print(s)

s = "Training"

s.ljust(12)           # justifier à gauche sur 12 positions} 

# Donne -->'Training    '

print(s)

s.ljust(12,":")

# Donne -->'Training::::'

s = "Programming"

s.rjust(15)

# Donne -->'    Programming'

s.rjust(15, "~")

# Donne -->'~~~~Programming'

account_number = "43447879"

account_number.zfill(12)

# Donne -->'000043447879'

# Même chose avec rjust : 

account_number.rjust(12,"0")

# Donne -->'000043447879'

s = 'Hello, world.'

str(s)

# Donne -->'Hello, world.'

repr(s)

# Donne --> "'Hello, world.'"

str(1/7)

# Donne --> '0.14285714285714285'

r=2

print("La surface pour un rayon {rayon:3d} sera {surface:8.3f}".format(surface=r*r*pi, rayon=r))

# Donne -->  'La surface pour un rayon   2 sera   12.566'

x = 10 * 3.25

y = 200 * 200

s = 'The value of x is ' + repr(x) + ', and y is ' + repr(y) + '...'

print(s)

# Donne --> The value of x is 32.5, and y is 40000...

# Le repr() d'un string ajoute des quotes et backslashes:

hello = 'hello, world\n'

str(hello)

# Donne --> 'hello world\n'

repr(hello)

# Donne --> 'hello, world\\n' %*  {\color{magenta}  noter le double slash}    *)

# L'argument d'appel de repr() peut être n'importe quel objet  Python :

repr((x, y, ('spam', 'eggs')))

# Donne -->"(32.5, 40000, ('spam', 'eggs'))"

for x in range(1, 11):

    print(repr(x).rjust(2), repr(x*x).rjust(3), repr(x*x*x).rjust(4))

# Donne -->

#  1   1    1

#  2   4    8 

#  3   9   27

#  4  16   64

#  5  25  125

#  6  36  216

#  7  49  343

#  8  64  512

#  9  81  729

# 10 100 1000

for x in range(1, 6):

    print(repr(x).rjust(2), end='#'*x+'\n')    # on ajoute x fois \# + \textbackslash n à la fin de chaque ligne}  *)

# Donne -->

#  1#

#  2##

#  3###

#  4####

#  5##### 

# 

 No newline at end of file

# 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

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

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

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

L = []

L.ap    

 No newline at end of file

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

def parite(a):

    """ Lire un entier au clavier et décider (et afficher) s'il est pair ou impair. """

    if (a%2 == 1):