Exercices Corrigés de Python

    Programmation 1    Variables : notion de type et de valeur d’une variable, types simples.    Démonstration :    >>> a = 3  >>> print(a)  3  >>> print(type(a))    >>>   >>> a = 3.14  >>> print(a)  3.14  >>> print(type(a))    >>>   >>> b = a  >>> print(b)  3.14  >>> a = 4  >>> print(b)  3.14        >>> s = 'abc'  >>> print(s)  abc  >>> print(type(s))    >>>   >>> s = "abc"  >>> print(s)  abc  >>> print(type(s))    >>>   1 

>>> print(s[0])  a  >>> print(s[1])  b  >>> print(len(s))  3  >>>   >>> l = ['a', 'b', 'c']  >>> print(l)  ['a', 'b', 'c']  >>> print(type(l))    >>>   >>> print(l[0])  a  >>> print(l[1])  b  >>> print(len(l))  3    Questions :  x = 3  x = 4  que vaut x ?  4    a = 4  b = a  a = 5  que vaut b ?  4    b = 2  a = b  b = b + 1  a = a  b = a  que vaut b ?  2      Exercice : inverser le contenu de deux variables  2 

  >>> a  4  >>> b  3.14  >>> tmp = a  >>> a = b  >>> b = tmp  >>> a  3.14  >>> b  4      Expressions et instructions simples : affectation, opérateurs usuels, distinction entre  expression et instruction.    Une expression s’évalue et a une valeur  Une valeur a un type    >>> a=2  >>> a = 2  >>> b = a + 3  >>> b  5  >>> "bon" + "jour"  'bonjour'  >>> b + max([4, 2, 8, 5, 7])  13    Une instruction n’a pas de valeur  C’est une commande qui est exécutée    >>> a = 2 # est une instruction  >>> b = (a = 2) # on ne peut pas mettre son résultat dans une  variable    File "", line 1      b = (a = 2) # on ne peut pas mettre son résultat dans une  variable             ^  SyntaxError: invalid syntax  3 

>>> print(a) # est une instruction  2  >>> type(print(a)) # print(a) n'a pas de valeur ni de type    File "", line 1      type(print(a)) # print(a) n'a pas de valeur ni de type               ^  SyntaxError: invalid syntax    Exercice : différencier les expressions des instructions  a = 2, a == 2, l = [1,2,3], l = l + l, if a > 0:, a = b = 3, a­b >= 0, x/2 if x%2==0 else 3*x+1    Instructions conditionnelles : expressions booléennes et opérateurs logiques simples,  instruction if. Variantes avec alternative (else).     Exercice : écrire les termes de la suite de Syracuse.  Partant d’un entier positif, on le divise par 2 s’il est pair et on le multiplie par 3 et on ajoute 1  sinon.      Instructions itératives : boucles for, boucles conditionnelles while.     Fonctions : notion de fonction (au sens informatique), définition dans le langage utilisé,  paramètres (ou arguments) et résultats, portée des variables.     def f(x): return x + 1  f(3), f(f(3))  def g(x): x = x      Manipulation de quelques structures de données : chaînes de caractères (création, accès  à un caractère, concaténation), listes (création, ajout d’un élément, suppression d’un élément,  accès à un élément, extraction d’une partie de liste), tableaux à une ou plusieurs dimensions.    Fichiers : notion de chemin d’accès, lecture et écriture de données numériques ou de type  chaîne de caractères depuis ou vers un fichier.       Algorithmique 1    Exercice : recherche dans une liste  Ecrire une fonction indice qui prend un élément et une liste en paramètre et qui retourne le  premier indice de l’élément si celui­ci apparaît dans la liste.  4 

  # ­*­ coding: utf­8 ­*­    def indice(x, liste):      """ Retourne la premiere position de x dans la liste.        Args:      x: l'element cherché      liste: la liste dans lequel x est cherché        Returns:      l'indice de la premiere occurrence de x sur liste        Raises:      ValueError si l'élément n'est pas présent        >>> indice(5, [2, 1, 0, 3, 3, 5, 1])      5        >>> indice(0, [2, 1, 0, 3, 3, 5, 1])      2        >>> indice(2, [2, 1, 0, 3, 3, 5, 1])      0        >>> indice(3, [2, 1, 0, 3, 3, 5, 1])      3        >>> indice(9, [2, 1, 0, 3, 3, 5, 1])      Traceback (most recent call last):          ...      ValueError: non trouve        """          index=0      for e in liste:          if x==e:              return index          index = index + 1      raise ValueError("non trouve")  5 

  if __name__ == "__main__":      import doctest      doctest.testmod()     Exercice : recherche du maximum dans une liste de nombres      # ­*­ coding: utf­8 ­*­    def recherche_max(liste):      """ Retourne l'élément maximum d'une liste d'entiers.        Args:      liste: la liste d'entiers        Returns:      l'élément maximal        >>> recherche_max([2, 1, 0, 3, 3, 5, 1])      5        >>> recherche_max([3, ­4, 7, ­12, 100, 52])      100        >>> recherche_max([­3, ­7, ­12, ­53])      ­3        >>> recherche_max([])      Traceback (most recent call last):          ...      ValueError: liste vide      """          if len(liste)>0:          max=liste[0]          for e in liste:              if e>max:                  max = e          return max  6 

    else:          raise ValueError("liste vide")    if __name__ == "__main__":      import doctest      doctest.testmod()      Exercice : calcul de la moyenne et de la variance.       # ­*­ coding: utf­8 ­*­    def moyenne(liste):      """ Retourne la moyenne des éléments d'une liste.        Args:      liste: la liste d'éléments        Returns:      la moyenne        >>> moyenne([1,2,3,4,5,6])      3.5        >>> moyenne([­3,­2,­1,1,2,3])      0.0          >>> moyenne([­3,­2,­1,1.0,2,3])      0.0          >>> moyenne([])      Traceback (most recent call last):          ...      ValueError: liste vide      """          if len(liste)>0:          return sum(liste)/float(len(liste))      else:          raise ValueError("liste vide")  7 

  def variance(liste):      """ Retourne la variance des éléments d'une liste.        Args:      liste: la liste d'éléments        Returns:      la variance          >>> variance([1,2,3,4,5,6]) == sum( (3.5­i)**2 for i in  range(1,6+1))/6      True          >>> variance([])      Traceback (most recent call last):          ...      ValueError: liste vide      """          if len(liste)>0:          moy = moyenne(liste)          somme = 0.0          for x in liste:              somme = somme + (x­moy)**2          return somme/len(liste)      else:          raise ValueError("liste vide")      if __name__ == "__main__":      import doctest      doctest.testmod()      Exercice : recherche par dichotomie dans un tableau trié.      # ­*­ coding: utf­8 ­*­    def est_dans(x, liste):  8 

    """ Retourne vrai si x est dans la liste.        Args:      x: l'element cherché      liste: la liste triée dans lequel x est cherché        Returns:      vrai si x est dans liste      faux sinon          >>> est_dans(0, [0, 1, 1, 2, 3, 3, 5])      True          >>> est_dans(1, [0, 1, 1, 2, 3, 3, 5])      True        >>> est_dans(2, [0, 1, 1, 2, 3, 3, 5])      True          >>> est_dans(3, [0, 1, 1, 2, 3, 3, 5])      True          >>> est_dans(4, [0, 1, 1, 2, 3, 3, 5])      False          >>> est_dans(5, [0, 1, 1, 2, 3, 3, 5])      True        >>> est_dans(5, [])      False      """        bi = 0      bs = len(liste) ­ 1          while bi epsilon:          pivot = (bi+bs)/2.0          if abs(f(pivot)) = 0 :              bi = pivot          else:              bs = pivot          raise ValueError("pas de solution")    if __name__ == "__main__":      import doctest      doctest.testmod()      Exercice : méthodes des rectangles et des trapèzes pour le calcul approché d’une intégrale sur  un segment.         Exercice : recherche d’un mot dans une chaîne de caractères.  On utilisera pour cela un algorithme naïf. Mais on peut imaginer l’étude des algorithmes de  Knuth­Morris­Pratt, ou Rabin­Karp par exemple.      # ­*­ coding: utf­8 ­*­    def est_prefix(mot, chaine):      """ Retourne vrai si mot est prefix de chaine.        Args:      mot: le mot cherché      chaine: la chaine laquelle mot est cherché (en tête)        Returns:      vrai si mot est prefix de chaine      faux sinon          >>> est_prefix('a', 'abc')      True          >>> est_prefix('b', 'abc')      False  11 

        >>> est_prefix('ab', 'abc')      True          >>> est_prefix('abc', 'abc')      True          >>> est_prefix('bc', 'abc')      False          >>> est_prefix('', '')      True        >>> est_prefix('', 'abc')      True          >>> est_prefix('a', '')      False      """          if len(mot) > len(chaine):          return False          for i in xrange(len(mot)):          if mot[i] != chaine[i]:              return False      return True    def est_sous_chaine(mot, chaine):      """ Retourne vrai si mot apparait dans chaine.        Args:      mot: le mot cherché      chaine: la chaine dans laquelle mot est cherché        Returns:      vrai si mot est dans chaine      faux sinon          >>> est_sous_chaine('a', 'abc')      True      12 

    >>> est_sous_chaine('b', 'abc')      True          >>> est_sous_chaine('bb', 'abbc')      True          >>> est_sous_chaine('bc', 'abc')      True          >>> est_sous_chaine('', '')      True        >>> est_sous_chaine('abc', '')      False      """          # on veut aller de 0 à len(chaine)­len(mot) inclus      for i in xrange(0,len(chaine)­len(mot)+1):          if est_prefix(mot,chaine[i:]):              return True      return False    if __name__ == "__main__":      import doctest      doctest.testmod()    Exercice : étant donné un tableau d’entiers, retourner un tableau commençant avec les entiers  pairs et se terminant avec les entiers impairs    # ­*­ coding: utf­8 ­*­    def pair_a_gauche(t):      """ Retourne un tableau où les élments pairs sont à gauche.        Args:      t: le tableau à classer        Returns:      un tableau où les éléments pairs sont à gauche        >>> pair_a_gauche([1,2,3,4,5])  13 

    [2, 4, 5, 3, 1]          >>> pair_a_gauche([2,3,4,5,6,7])      [2, 4, 6, 7, 5, 3]          >>> pair_a_gauche([])      []          """      res = list(t)      x=0      y=len(t)­1      for a in t:          if a%2 == 0:              res[x]=a              x=x+1          else:              res[y]=a              y=y­1        return res      if __name__ == "__main__":      import doctest      doctest.testmod()    Exercice : même exercice en utilisant des compréhensions de liste      # ­*­ coding: utf­8 ­*­    def pair_a_gauche_comprehension(t):      """ Retourne un tableau où les éléments pairs sont à gauche.        Args:      t: le tableau à classer        Returns:      un tableau où les éléments pairs sont à gauche        >>> pair_a_gauche_comprehension([1,2,3,4,5])      [2, 4, 1, 3, 5]  14 

      >>> pair_a_gauche_comprehension([2,3,4,5,6,7])      [2, 4, 6, 3, 5, 7]        >>> pair_a_gauche_comprehension([])      []        """      return [x for x in t if x % 2 == 0] + [x for x in t if x % 2 ==  1]      if __name__ == "__main__":      import doctest      doctest.testmod()             

 

15 

Algorithmique 2    Piles    Exercice: Ecrire une fonction qui permet de savoir si une expression de parenthèse est  correcte. Exemple (()), ()(), ()(()), … Contre­exemple )()(, ((), ())), …              Récursivité    Exercice: Comptez le nombre de mots (sur ‘(‘ et ‘)’ ) de longueur n bien parenthésés.    Exercice: Etant donnée une chaîne de caractères comme “debarbouiller”, calculez la longueur  de la plus longue sous­suite croissante contenue dans ce mot. Par exemple “abill” a une  longueur 5. L’ordre des lettres est a t[j+1]:              (t[j],t[j+1]) = (t[j+1],t[j])  return t      Exercice: Tri par insertion. On trouve le plus petit élément de la liste, et on le permute avec le  premier élément de la liste, on continue avec le deuxième plus petit mis à la place du deuxième,  etc jusqu’à la fin de la liste.    def triinsertion(t):  """  Tri d'une liste  Args:  t: liste à trier  Returns  t ( triée )  >>> tribulle([1, 4, 2, 8, 3])  [1, 2, 3, 4, 8]  >>> tribulle([5, 3, 4, 4])  [3, 4, 4, 5]  >>> tribulle([9, 8, 7, 6, 5, 4, 3, 2, 1])  [1, 2, 3, 4, 5, 6, 7, 8, 9]  """  for i in range(len(t)­1):      (minimum,min_index) = (sys.maxint,0)      for j in range(i,len(t)):          if minimum > t[j]:              (minimum,min_index) = (t[j],j)  17 

    (t[min_index],t[i]) = (t[i],t[min_index])  return t      Exercice: Trouver l’élément médian d’une liste L donnée en argument. On rappelle qu’il s’agit de  l’élément x tel que la moitié des éléments de T est plus petit que x, l’autre étant plus grande.    def median(t):  """  Calcule l'élément médian  d'une liste  Args:  t: la liste  Returns:  l'élément médian  Raises:  IndexError si t est vide  >>> median([1, 5, 3, 3, 5,  9])  5  >>> median([1, 4, 3, 5, 5])  4  """      t.sort()      return t[len(t)/2]           

 

18 

Programmation 2    Classes et objets    TD compte bancaire      Interfaces graphiques    Bases de données    Exercice : compte bancaire 

  L'objectif de ce TD est de s'exercer à la spécification et à la programmation de classes  élémentaires. En particulier, il s'agit à partir d'un énoncé d'identifier et de définir les  caractéristiques d'une classe modélisant un concept donné. [TD inspiré d’un exercice proposé  par Philippe Genoud, Université de Grenoble]    "Cahier des charges"  Il s'agit de définir une classe Python CompteSimple permettant de modéliser des comptes  bancaires.   La somme d'argent disponible sur un compte, appelée solde,  est exprimée en Euros. Le  solde est un nombre décimal positif, nul ou négatif. On dit que le compte est à découvert lorsque  son solde est négatif.  En aucun cas le découvert d'un compte ne peut être supérieur à une valeur fixée, appelée  decouvert_autorise. Par exemple pour un compte dont le découvert maximal autorisé est  2000 €, le solde ne pourra jamais être inférieur à ­2000 €. Le découvert maximal autorisé peut  varier d'un compte à un autre, il est fixé arbitrairement par la banque à la création du compte et  peut être ensuite révisé selon les modifications des revenus du titulaire du compte.  Créditer un compte consiste à ajouter un montant positif au solde du compte.  Débiter un compte consiste à retirer un montant positif au solde du compte. Le solde résultant  ne doit en aucun cas être inférieur au découvert maximal autorisé pour ce compte.  Lors d'une opération de retrait, un compte ne peut être débité d'un montant supérieur à une  valeur désignée sous le terme de debit_maximal autorisé. Comme le découvert maximal  autorisé, le débit maximal autorisé peut varier d'un compte à un autre et est fixé arbitrairement  par la banque à la création du compte. Il peut être ensuite révisé selon les modifications des  revenus du titulaire du compte.  Effectuer un virement consiste à débiter un compte au profit d'un autre compte qui sera  crédité du montant du débit.  Lors de la création d'un compte, en l'absence de dépôt initial le solde est fixé à 0 €. Les valeurs  par défaut pour le découvert maximal autorisé et le débit maximal autorisé sont respectivement  de 0 € et 500 €.   19 

  Travail demandé :  A partir du "cahier des charges" précédent élaborer une spécification de la classe Python  modélisant un compte bancaire.  ● quelles sont les méthodes proposées par la classe ?  ● quelles sont les variables d’instances nécessaires ?  ● quelle est la signature du constructeur de classe ?  Réaliser une implantation en prenant soin de documenter le comportement du constructeur et  des différentes méthodes.    Scénario de test :  ● créer un compte c1 ayant 1000 € comme dépot initial  ● afficher le solde de ce compte. Le résultat doit être de la forme    1000 €  ● débiter 50 € de ce compte et afficher le solde courant  ● créer un compte c2  ● transférer 200 € du compte c1 vers le compte c2. Afficher le solde des deux comptes  ● transférer 2000 € du compte c1 vers le compte c2. Afficher le solde des deux comptes      "Cahier des charges" (suite)  Un compte bancaire est associé à un client titulaire du compte, ce client est décrit par son  nom ainsi que par la liste des comptes qu’il possède. Toutes les informations relatives à un  client doivent pouvoir être affichées (nom du client, liste de ses comptes et soldes respectifs) 

Travail demandé  ● réaliser une implantation en langage Python de la classe Client (constructeur prenant en  paramètre le nom du client ainsi que la liste des comptes associés)  ● la classe client devra permettre d’afficher la situation financière d’un client. Par exemple :  Client: A  Compte 1 : 0 €  Compte 2 : 300 €    ●  créer 2 clients (A et B). Le premier possède 2 comptes (le compte c1 créé  précédemment et un nouveau compte initialisé à 50 €) et le second un seul compte (le  compte c2 créé précédemment).   affichez la situation financière de ces clients. L’affichage doit être de la forme  *** situation initiale  Client: A  Compte 1 : 750 €  Compte 2 : 50 €  Client: B  20 

Compte 1 : 200 €  Modifier la classe Client de sorte que chaque client ait un numéro de client unique.  Modifier la méthode qui affiche la situation financière d’une client de sorte que le numéro  apparaisse.      # ­*­ coding: utf­8 ­*­    class CompteSimple:      def __init__(self, depot_initial = 0.0, decouvert = 0.0, debit  = 500.0):         self.solde = depot_initial         self.decouvert_autorise = decouvert         self.debit_maximal = debit        def __str__(self):          """          Returns:          une chaine représentant le solde du compte              >>> c1 = CompteSimple(200); print(c1)          200 €              """          return str(self.solde) + " €"        def credit(self, montant):          """          Args:          montant: le montant positif à créditer              >>> c1 = CompteSimple(200); c1.credit(100); print(c1)          300 €              >>> c1 = CompteSimple(200); c1.credit(­100); print(c1)          Traceback (most recent call last):          ...          ValueError: montant negatif          """          if montant