TP7

TP7/Programmation.py

+import random
+def liste_alea(n:int):
+    """ construit une liste de longueur n contenant les entiers 0 à n-1 mélangés.
+
+    Précondition : 
+    Exemple(s) :
+    $$$ 
+
+    """
+    liste = []
+    for i in range(n):
+        random.shuffle(liste)
+    return liste
\ No newline at end of file

TP7/analyse_tris.csv

+taille;"tri séléction";"tri insertion"
+  0;    0.00;    0.00
+  1;    0.00;    0.00
+  2;    1.00;    1.00
+  3;    3.00;    2.62
+  4;    6.00;    5.10
+  5;   10.00;    8.02
+  6;   15.00;   11.40
+  7;   21.00;   14.78
+  8;   28.00;   19.96
+  9;   36.00;   24.26
+ 10;   45.00;   31.36
+ 11;   55.00;   34.54
+ 12;   66.00;   40.96
+ 13;   78.00;   50.68
+ 14;   91.00;   58.32
+ 15;  105.00;   63.40
+ 16;  120.00;   73.12
+ 17;  136.00;   84.06
+ 18;  153.00;   88.58
+ 19;  171.00;  100.44
+ 20;  190.00;  110.10
+ 21;  210.00;  123.20
+ 22;  231.00;  133.14
+ 23;  253.00;  143.52
+ 24;  276.00;  160.06
+ 25;  300.00;  170.20
+ 26;  325.00;  186.12
+ 27;  351.00;  190.36
+ 28;  378.00;  208.68
+ 29;  406.00;  226.66
+ 30;  435.00;  243.20
+ 31;  465.00;  259.12
+ 32;  496.00;  283.90
+ 33;  528.00;  288.96
+ 34;  561.00;  299.08
+ 35;  595.00;  330.98
+ 36;  630.00;  356.10
+ 37;  666.00;  363.70
+ 38;  703.00;  380.54
+ 39;  741.00;  398.56
+ 40;  780.00;  424.50
+ 41;  820.00;  441.66
+ 42;  861.00;  461.96
+ 43;  903.00;  489.20
+ 44;  946.00;  503.46
+ 45;  990.00;  533.84
+ 46; 1035.00;  560.26
+ 47; 1081.00;  581.06
+ 48; 1128.00;  598.06
+ 49; 1176.00;  621.06
+ 50; 1225.00;  647.76
+ 51; 1275.00;  679.84
+ 52; 1326.00;  715.44
+ 53; 1378.00;  749.22
+ 54; 1431.00;  761.62
+ 55; 1485.00;  793.10
+ 56; 1540.00;  820.64
+ 57; 1596.00;  850.42
+ 58; 1653.00;  865.78
+ 59; 1711.00;  915.00
+ 60; 1770.00;  949.64
+ 61; 1830.00;  968.24
+ 62; 1891.00;  987.44
+ 63; 1953.00; 1024.90
+ 64; 2016.00; 1053.60
+ 65; 2080.00; 1117.52
+ 66; 2145.00; 1139.84
+ 67; 2211.00; 1180.08
+ 68; 2278.00; 1198.26
+ 69; 2346.00; 1249.24
+ 70; 2415.00; 1278.72
+ 71; 2485.00; 1306.58
+ 72; 2556.00; 1346.76
+ 73; 2628.00; 1395.90
+ 74; 2701.00; 1430.10
+ 75; 2775.00; 1465.12
+ 76; 2850.00; 1504.02
+ 77; 2926.00; 1533.18
+ 78; 3003.00; 1609.40
+ 79; 3081.00; 1638.20
+ 80; 3160.00; 1643.76
+ 81; 3240.00; 1711.34
+ 82; 3321.00; 1751.14
+ 83; 3403.00; 1802.22
+ 84; 3486.00; 1807.82
+ 85; 3570.00; 1855.54
+ 86; 3655.00; 1921.14
+ 87; 3741.00; 1966.06
+ 88; 3828.00; 2008.44
+ 89; 3916.00; 2027.48
+ 90; 4005.00; 2123.72
+ 91; 4095.00; 2120.92
+ 92; 4186.00; 2206.72
+ 93; 4278.00; 2249.56
+ 94; 4371.00; 2275.64
+ 95; 4465.00; 2305.58
+ 96; 4560.00; 2349.10
+ 97; 4656.00; 2442.44
+ 98; 4753.00; 2474.24
+ 99; 4851.00; 2530.82
+100; 4950.00; 2581.98

TP7/analyse_tris.py

+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+"""
+:mod:`analyse_tris` module
+:author: FIL - Faculté des Sciences et Technologies - Univ. Lille <http://portail.fil.univ-lille1.fr>_
+:date: janvier 2017
+:dernières révisions: février 2018, février 2019
+
+Analyse empirique des tris
+
+"""
+from random import shuffle
+from typing import Callable
+from compare import compare
+from ap_decorators import count
+from tris import *
+
+################################################
+#  ANALYSE EMPIRIQUE DES TRIS                  #
+################################################
+
+# ajout d'un compteur à la fonction compare
+compare = count(compare)
+
+def analyser_tri(tri: Callable[[list[T], Callable[[T, T], int]], NoneType],
+                 nbre_essais: int,
+                 taille: int) -> float:
+    """
+    renvoie: le nombre moyen de comparaisons effectuées par l'algo tri
+         pour trier des listes de taille t, la moyenne étant calculée
+         sur n listes aléatoires.
+    précondition: n > 0, t >= 0, la fonc
+    """
+    res = 0
+    for i in range(nbre_essais):
+        compare.counter = 0
+        l = [k for k in range(taille)]
+        shuffle(l)
+        tri(l, compare)
+        res += compare.counter
+    return res / nbre_essais
+
+
+if (__name__ == '__main__'):
+    from matplotlib import pyplot as plt
+    
+    # Calcul de nombres moyens de comparaison pour des listes
+    # de tailles comprises entre 0 et TAILLE_MAX
+    NB_ESSAIS = 50
+    TAILLE_MAX = 100
+    c_select = [0.0] * (TAILLE_MAX + 1)
+    c_insert = [0.0] * (TAILLE_MAX + 1)
+    
+    for t in range(TAILLE_MAX + 1):
+        c_select[t] = analyser_tri(tri_select, 1, t)
+        # inutile de moyenner pour le tri par sélection
+        c_insert[t] = analyser_tri(tri_insert, NB_ESSAIS, t)
+
+    # Sauvegarde des données calculées dans un fichier au format CSV
+    prem_ligne = 'taille;"tri séléction";"tri insertion"\n'
+    ligne = '{:3d};{:8.2f};{:8.2f}\n'
+    with open('analyse_tris.csv', 'wt', encoding='utf8') as sortie:
+        sortie.write(prem_ligne)
+        for t in range(TAILLE_MAX + 1):
+            sortie.write(ligne.format(t,
+                                      c_select[t],
+                                      c_insert[t]))
+
+    # Représentation graphique
+    plt.plot(list(range(TAILLE_MAX + 1)), c_select, 'b.', label='Tri sélection')
+    plt.plot(list(range(TAILLE_MAX + 1)), c_insert, 'r.', label='Tri insertion')
+    plt.title('Tris : nbre de comparaisons')
+    plt.legend()
+    plt.xlabel('n = taille des listes')
+    plt.ylabel('c(n) = nbre de comparaisons')
+    plt.savefig('tris_nbcomp.png')
+    plt.show()
+

TP7/analyse_tris2.py

+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+"""
+:mod:`analyse_tris` module
+:author: FIL - Faculté des Sciences et Technologies - Univ. Lille <http://portail.fil.univ-lille1.fr>_
+:date: janvier 2017
+:dernières révisions: février 2018, février 2019
+
+Analyse empirique des tris
+
+"""
+from random import shuffle
+from typing import Callable
+from compare import compare
+from ap_decorators import count
+from tris import *
+
+################################################
+#  ANALYSE EMPIRIQUE DES TRIS                  #
+################################################
+
+# ajout d'un compteur à la fonction compare
+compare = count(compare)
+
+def analyser_tri(tri: Callable[[list[T], Callable[[T, T], int]], NoneType],
+                 nbre_essais: int,
+                 taille: int) -> float:
+    """
+    renvoie: le nombre moyen de comparaisons effectuées par l'algo tri
+         pour trier des listes de taille t, la moyenne étant calculée
+         sur n listes aléatoires.
+    précondition: n > 0, t >= 0, la fonc
+    """
+    res = 0
+    for i in range(nbre_essais):
+        compare.counter = 0
+        l = [k for k in range(taille)]
+        shuffle(l)
+        tri(l, compare)
+        res += compare.counter
+    return res / nbre_essais
+
+
+if (__name__ == '__main__'):
+    from matplotlib import pyplot as plt
+    
+    # Calcul de nombres moyens de comparaison pour des listes
+    # de tailles comprises entre 0 et TAILLE_MAX
+    NB_ESSAIS = 50
+    TAILLE_MAX = 100
+    c_select = [0.0] * (TAILLE_MAX + 1)
+    c_insert = [0.0] * (TAILLE_MAX + 1)
+    c_sort =  [0.0] * (TAILLE_MAX + 1)
+    for t in range(TAILLE_MAX + 1):
+        c_select[t] = analyser_tri(tri_select, 1, t)
+        # inutile de moyenner pour le tri par sélection
+        c_insert[t] = analyser_tri(tri_insert, NB_ESSAIS, t)
+        c_sort[t] = analyser_tri(tri_sort, NB_ESSAIS, t)
+        
+
+    # Sauvegarde des données calculées dans un fichier au format CSV
+    prem_ligne = 'taille;"tri séléction";"tri insertion"\n'
+    ligne = '{:3d};{:8.2f};{:8.2f}\n'
+    with open('analyse_tris.csv', 'wt', encoding='utf8') as sortie:
+        sortie.write(prem_ligne)
+        for t in range(TAILLE_MAX + 1):
+            sortie.write(ligne.format(t,
+                                      c_select[t],
+                                      c_insert[t],
+                                      c_sort[t]))
+
+    # Représentation graphique
+    plt.plot(list(range(TAILLE_MAX + 1)), c_select, 'b.', label='Tri sélection')
+    plt.plot(list(range(TAILLE_MAX + 1)), c_insert, 'r.', label='Tri insertion')
+    plt.plot(list(range(TAILLE_MAX + 1)), c_sort, 'y.', label='Tri sort')
+    plt.title('Tris : nbre de comparaisons')
+    plt.legend()
+    plt.xlabel('n = taille des listes')
+    plt.ylabel('c(n) = nbre de comparaisons')
+    plt.savefig('tris_nbcomp.png')
+    plt.show()
+
+

TP7/ap_decorators.py

+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+"""
+:module: ap_decorators  
+:author: FIL - Faculté des Sciences et Technologies -  Univ. Lille <http://portail.fil.univ-lille1.fr>_
+:date: 2018, september
+
+"""
+
+from functools import wraps
+
+
+def trace(fct):
+    '''
+    Decorator for tracing every call to fct.
+    Recursive calls are indented.
+
+    :Example:
+
+    >>> @trace
+    ... def fact(n):
+    ...     if n == 0:
+    ...         return 1
+    ...     else:
+    ...         return n * fact(n - 1)
+    
+    >>> fact(5)
+     -> fact((5,), {})
+    ... -> fact((4,), {})
+    ...... -> fact((3,), {})
+    ......... -> fact((2,), {})
+    ............ -> fact((1,), {})
+    ............... -> fact((0,), {})
+    ............... <- 1
+    ............ <- 1
+    ......... <- 2
+    ...... <- 6
+    ... <- 24
+    <- 120
+    120
+    '''
+    @wraps(fct)
+    def wrapper(*args, **kwargs):
+        dots = '...' * wrapper.__depth
+        print('{:s} -> {:s}{:s}'.format(dots, wrapper.__name__, repr((args, kwargs))))
+        wrapper.__depth += 1
+        y = fct(*args, **kwargs)
+        wrapper.__depth -= 1
+        print('{:s} <- {:s}'.format(dots, repr(y)))
+        return y
+    wrapper.__depth = 0
+    return wrapper
+
+def count(fct):
+    '''
+    decorator for counting  calls to  function fct
+    
+    :Example:
+
+    >>> @count
+    ... def fact(n):
+    ...     if n == 0:
+    ...         return 1
+    ...     else:
+    ...         return n * fact(n - 1)
+    
+    >>> fact.counter
+    0
+    >>> fact(5)
+    120
+    >>> fact.counter
+    6
+    '''
+    @wraps(fct) 
+    def wrapper(*args, **kwargs):
+        y = fct(*args, **kwargs)
+        wrapper.counter += 1
+        return y
+    wrapper.counter = 0
+    return wrapper
+
+
+def memoize(fct):
+    '''
+    decorator for memoizing computed values of  function fct
+    
+    :Example:
+
+    >>> @count
+    ... @memoize
+    ... def fact(n):
+    ...     if n == 0:
+    ...         return 1
+    ...     else:
+    ...         return n * fact(n - 1)
+    
+    >>> fact.counter
+    0
+    >>> fact(5)
+    120
+    >>> fact.counter
+    6
+    >>> fact.counter = 0
+    >>> fact(5)
+    120
+    >>> fact.counter
+    1
+    '''
+    cache = dict()
+    @wraps(fct)
+    def wrapper(*args, **kwargs):
+        key = repr((args, kwargs))
+        if key in cache:
+            return cache[key]
+        else:
+            y = fct(*args, **kwargs)
+            cache[key] = y
+            return y
+    return wrapper
+
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod(optionflags=doctest.NORMALIZE_WHITESPACE | doctest.ELLIPSIS, verbose=False)
+    
+    
+
+
+
+
+
+
+

TP7/apl1test.py

+import thonnycontrib
+from thonnycontrib.backend.evaluator import Evaluator
+import thonnycontrib.backend.l1test_backend
+from thonny.plugins.cpython_backend.cp_back import MainCPythonBackend
+import thonnycontrib.backend.doctest_parser 
+from thonnycontrib.backend.doctest_parser import ExampleWithExpected, ExampleWithoutExpected
+import thonnycontrib.backend.ast_parser
+from thonnycontrib.backend.ast_parser import L1DocTest
+import thonnycontrib.backend.verdicts
+from thonnycontrib.backend.verdicts.ExceptionVerdict import ExceptionVerdict 
+
+import inspect
+import tempfile
+import os
+import sys
+        
+class MockBackend(MainCPythonBackend):
+    """
+    Fake backend.
+    """
+    def __init__(self):
+        ...
+
+    def send_message(self, msg) -> None:
+        ...
+
+# register backend
+thonnycontrib.backend.l1test_backend.BACKEND = MockBackend()
+
+def l1test_to_org(filename: str, source: str=""):
+    """
+    Return an org abstract of the tests presents in `filename` file.
+    """
+    abstract = {'total': 0,
+                'success': 0,
+                'failures': 0,
+                'errors': 0,
+                'empty': 0}
+
+    if source == "":
+        with open(filename, 'rt') as fin:
+            source = fin.read()
+    evaluator = Evaluator(filename=filename,
+                          source=source)
+    tests = evaluator.evaluate()
+    n = len(tests)
+    abstract['total'] = n
+    res = ""
+    for test in tests:
+        examples = test.get_examples()
+        res_examples = ""
+        nb_test, nb_test_ok = 0, 0
+        empty = True
+        for example in examples:
+            verdict = test.get_verdict_from_example(example)
+            if isinstance(example, ExampleWithExpected):
+                nb_test += 1
+                if verdict.isSuccess():
+                    nb_test_ok += 1
+                    abstract['success'] += 1
+                else:
+                    abstract['failures'] += 1
+                empty = False
+            if isinstance(verdict, ExceptionVerdict):
+                abstract['errors'] += 1
+                empty = False
+            res_examples += f"** {verdict}\n\n"
+            if not verdict.isSuccess():
+                res_examples += f"   {verdict.get_details()}\n\n"
+        if not empty: 
+            res += f"* {test.get_name()} ~ {nb_test_ok}/{nb_test} réussis\n\n"
+        else:
+            abstract['empty'] += 1
+            res += f"* {test.get_name()}\n\n Aucun test trouvé !\n\n"
+        res += res_examples
+    res = f"Tests exécutés : {abstract['total']}\nSuccès: {abstract['success']}, \
+Echecs: {abstract['failures']}, Erreurs: {abstract['errors']}, \
+Vide: {abstract['empty']}\n\n" + res
+    return res
+
+
+def testmod(modulename: str):
+    """
+    mimic the doctest.testmod function
+    for `modulename` module
+    """
+    print(l1test_to_org(modulename))
+
+

TP7/compare.py

+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+"""
+:mod:`compare` module
+:author: FIL - FST - Univ. Lille <http://portail.fil.univ-lille1.fr>_
+:date: 2016, january
+:dernière révision: février 2018
+
+Fonction de comparaison 
+pour l'analyse des algos de recherche et de tri
+
+"""
+from typing import TypeVar
+
+
+T = TypeVar('T')
+def compare(x: T, y: T) -> int:
+    """
+    renvoie:
+      - -1 si x < y
+      - 0 si x == y
+      - 1 si x > y
+    précondition: x et y doivent être d'un type pour lequel les opérateurs de comparaison <, <=, ==
+         peuvent s'appliquer
+    exemples:
+
+    $$$ compare(1, 3)
+    -1
+    $$$ compare(3, 1)
+    1
+    $$$ compare(3, 3)
+    0
+    """
+    if x == y:
+        return 0
+    elif x > y:
+        return 1
+    else:
+        return -1
+
+if (__name__ == '__main__'):
+    import apl1test
+    apl1test.testmod('compare.py')

TP7/tris.py

+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+"""
+:mod:`tris` module
+:author: FIL - Faculté des Sciences et Technologies -
+         Univ. Lille <http://portail.fil.univ-lille1.fr>_
+:date: 2015, january
+:dernière révision: février 2018
+
+
+Tris de listes
+
+- tri par sélection
+- tri par insertion
+
+"""
+from types import NoneType
+from typing import Callable, TypeVar
+from compare import compare
+from functools import cmp_to_key
+
+T = TypeVar('T')
+
+def est_trie(liste: list[T], comp: Callable[[T, T], int] = compare) -> bool:
+    """
+    renvoir True si et seulement si liste est triée selon l'ordre défini par comp
+
+    précondition: les éléments de liste doivent être comparables selon comp
+
+    exemples:
+
+    $$$ est_trie([1, 2, 3, 4])
+    True
+    $$$ est_trie([1, 2, 4, 3])
+    False
+    $$$ est_trie([])
+    True
+    """
+    i = 0
+    res = True
+    while res and i < len(liste) - 1:
+        res = comp(liste[i], liste[i+1]) <= 0
+        i += 1
+    return res
+    # ou plus simplement
+    # return all(comp(liste[i], liste[i+1]) <= 0 for i in range(len(liste)-1))
+
+
+################################################
+#  TRI PAR SELECTION                           #
+################################################
+
+def echanger(liste: list[T], i: int, j: int) -> NoneType:
+    """
+    échange les éléments d'indice i et j de liste.
+
+    précondition: 0 <= i,j < len(liste)
+
+    exemples:
+
+    $$$ l1 =  [3, 1, 4, 9, 5, 1, 2]
+    $$$ l2 = l1.copy()
+    $$$ echanger(l2, 3, 5)
+    $$$ (l1[3], l1[5]) == (l2[5], l2[3])
+    True
+    """
+    liste[i], liste[j] = liste[j], liste[i]
+
+
+def select_min(liste: list[T], a: int, b: int, comp: Callable[[T, T], int]=compare) -> int:
+    """
+    renvoie l'indice du minimum dans la tranche liste[a:b]
+    précondition: 0 <= a < b <= long(liste),
+         éléments de liste comparables avec comp
+    exemples:
+
+    $$$ select_min([1, 2, 3, 4, 5, 6, 7, 0], 0, 8)
+    7
+    $$$ select_min([1, 2, 3, 4, 5, 6, 7, 0], 1, 7)
+    1
+    """
+    ind_min = a
+    # l'indice du plus petit élément de la tranche liste[a:a+1] est ind_min
+    for i in range(a + 1, b):
+        # supposons que l'indice du plus petit élément de la
+        # tranche liste[a:i] est ind_min
+        if comp(liste[i], liste[ind_min]) == -1:
+            ind_min = i
+        # alors l'indice du plus petit élément de la tranche liste[a:i+1]
+        # est ind_min
+    # à l'issue de l'itération l'indice du plus petit élément de la tranche
+    # liste[a:b] est ind_min
+    return ind_min
+
+
+def tri_select(liste: list[T], comp: Callable[[T, T], int] = compare) -> NoneType:
+    """
+    modifie la liste liste en triant ses éléments selon l'ordre défini par comp
+          Algorithme du tri par sélection du minimum
+    précondition: liste liste homogène d'éléments comparables selon comp
+    exemples:
+
+    $$$ liste = [3, 1, 4, 1, 5, 9, 2]
+    $$$ tri_select(liste)
+    $$$ liste == [1, 1, 2, 3, 4, 5, 9]
+    True
+    $$$ from random import randrange
+    $$$ l1 = [randrange(1000) for k in range(randrange(100))]
+    $$$ l2 = l1.copy()
+    $$$ tri_select(l2)
+    $$$ est_trie(l2)
+    True
+    $$$ all(l1.count(elt) == l2.count(elt) for elt in l1)
+    True
+    $$$ all(l1.count(elt) == l2.count(elt) for elt in l2)
+    True
+    """
+    n = len(liste)
+    # la tranche liste[0:1] est triée
+    for i in range(n - 1):
+        # supposons la tranche liste[0:i+1] triée
+        ind_min = select_min(liste, i, n, comp=comp)
+        echanger(liste, i, ind_min)
+        # alors la tranche liste[0:i+1] est triée
+    # à l'issue de l'itération la tranche liste[0:n] est triée
+
+
+################################################
+#  TRI PAR INSERTION                           #
+################################################
+
+def inserer(liste: list[T], i: int, comp: Callable[[T, T], int] = compare) -> NoneType:
+    """
+    insère l'élément liste[i] à sa place dans la tranche
+    liste[0:i+1] de sorte que cette tranche soit triée
+    si liste[0:i] l'est auparavant
+
+    précondition: 0 <= i < long(liste)
+         éléments de liste comparables par comp
+    exemples:
+
+    $$$ liste = [1, 2, 4, 5, 3, 7, 6]
+    $$$ inserer(liste, 4)
+    $$$ liste == [1, 2, 3, 4, 5, 7, 6]
+    True
+    $$$ inserer(liste, 5)
+    $$$ liste == [1, 2, 3, 4, 5, 7, 6]
+    True
+    $$$ inserer(liste, 6)
+    $$$ liste == [1, 2, 3, 4, 5, 6, 7]
+    True
+    """
+    aux = liste[i]
+    k = i
+    while k >= 1 and comp(aux, liste[k - 1]) == -1:
+        liste[k] = liste[k - 1]
+        k = k - 1
+    liste[k] = aux
+
+
+def tri_insert(liste: list[T], comp: Callable[[T, T], int] = compare) -> NoneType:
+    """
+    modifie la liste liste en triant ses éléments selon l'ordre défini par comp Algorithme du tri par insertion
+    précondition: liste liste homogène d'éléments comparables selon comp
+    exemples:
+
+    $$$ liste = [3, 1, 4, 1, 5, 9, 2]
+    $$$ tri_insert(liste)
+    $$$ liste == [1, 1, 2, 3, 4, 5, 9]
+    True
+    $$$ from random import randrange
+    $$$ l1 = [randrange(1000) for k in range(randrange(100))]
+    $$$ l2 = l1.copy()
+    $$$ tri_insert(l2)
+    $$$ est_trie(l2)
+    True
+    $$$ all(l1.count(elt) == l2.count(elt) for elt in l1)
+    True
+    $$$ all(l1.count(elt) == l2.count(elt) for elt in l2)
+    True
+    """
+    n = len(liste)
+    # la tranche liste[0:1] est triée
+    for i in range(1, n):
+        # supposons la tranche liste[0:i] triée
+        inserer(liste, i, comp=comp)
+        # alors la tranche liste[0:i+1] est triée
+    # à l'issue de l'itération la tranche liste[0:n] est triée
+
+
+if (__name__ == '__main__'):
+    import apl1test
+    apl1test.testmod('tris.py')
+    
+
+def tri_sort(liste: list[T], cmp: Callable[[T, T], int] = compare) -> NoneType:
+    """à_remplacer_par_ce_que_fait_la_fonction
+
+    Précondition : 
+    Exemple(s) :
+    $$$ 
+
+    """
+    liste.sort(key=cmp_to_key(cmp))
+    
\ No newline at end of file