Ctrl+K

Synthèse des acquis du semestre 1

11. Synthèse des acquis du semestre 1#

Ce document adapte ce support aux étudiants des licences Informatique-Mathématiques-LAS de l’UPVD. Il rappelle les notions acquises à la fin du semestre 1.

Python est un langage de programmation orienté objet (mais oublions le côté objet pour l’instant). Sa première version a été écrite en 1991 par Guido van Rossum – qui était un grand fan de Monty Python.

Ce mini-tutoriel est une introduction très basique et rapide à la syntaxe et aux règles du langage. Si vous voulez approfondir plus, des tutoriels bien faits existent sur le net, n’hésitez pas à les consulter.

Nous travaillerons avez l’environnement Jupyter Lab et l’interpréteur python3 (version 3.11). Ce cadre de travail est disponible sur les machines de l’UPVD mais aussi via la distribution anaconda qu’il est conseillé d’installer sur votre machine personnelle.

Les détails de ces installations sont précisées dans la section Travailler en python qui vous sera utile pour votre première utilisation.

Nous verrons plus loin comment utiliser les notebook jupyter qui permettent de rassembler dans un seul document du texte formaté (en markdown et LaTeX), du code python, les résultats de ses exécutions (courbes, graphiques, …), des images …

Commençons par une prise en main simple.

11.1. Python en mode calculatrice#

python3 est accessible directement dans un terminal : tapez python3 pour lancer l’interpréteur.

(Python) bash-3.2$  python3

Remarque.

Comme nous le verrons dans ce document, la forme du prompt de ce shell nous indique que l’exécution par le shell bash (ici 3.2) de la commande python3 s’effectue dans l’environnement virtuel ‘(Python)’.

La plus simple utilisation de Python est de l’utiliser comme une simple calculatrice. Vous pouvez essayer dans le terminal les calculs suivants.

>>> 2+6
8
>>> 10 - 12   # Les espaces sont optionnels
-2
>>> 13 + 2*4  # La priorité des opérations est comme d'habitude
21
>>> 21 / 4    # Attention ! En Python 2 cette instruction retourne 
5.25          # la partie  entière de la division. En Python 3 c'est  
              # une division flottante, même entre deux entiers
>>> 21 // 4   # Partie entière de la division
5
>>> 21 % 4    # Reste de la division
1
>>> 3 ** 4    # Opérateur puissance (3 à la puissance 4)
81
>>> 10 < 2 * 13  # Comparaison
True
>>> 10 < 4 or not 10 < 4  # Connecteurs booléens
True
>>> 1 < 2 == 1 + 1 < 3   # Comparaisons chaînées
True

11.1.1. Exercice#

Calculer dans un terminal, puis dans la cellule suivante de ce notebook:

  • \(5 \times (1293 - 390)\),

  • La partie entière ainsi que le reste de la division de 1234 par 7,

  • \(13^{13}\).

11.1.2. Exercice#

Reprendre ces calculs dans la cellule suivante de ce notebook.

11.2. Données et variables#

Pour pouvoir accéder aux données qu’un programme manipule on fait usage d’un nombre de variables de différents types. Une variable apparaît dans un langage de programmation sous son nom de variable, mais il ne s’agit de rien d’autre qu’une référence désignant l’adresse mémoire où sont stockées les données.

En Python il existe un nombre de règles simples sur les noms de variables qu’il faut respecter :

  • Seules les lettres a -> z, A -> Z, les chiffres 0-9 et le caractère ‘_’ sont autorisés.

  • Le nom d’une variable doit toujours commencer par une lettre.

  • La casse est significative. Par exemple vitesse, Vitesse et VITESSE désignent des variables différentes.

Une bonne habitude à prendre est d’écrire les noms de variables en minuscules y compris la première lettre. Il s’agit d’une convention qui est largement respectée. N’utilisez les majuscules qu’à l’intérieur du nom afin de faciliter la lisibilité. Par exemple : matriceDesCoefficients.

Le signe ‘=’ est utilisé afin d’affecter une valeur à une variable.

>>> n = 5
>>> message = 'Bonjour'
>>> pi = 3.14

Les deux constructions suivantes sont très spécifiques à Python. Elles simplifient certaines affectations (la seconde en particulier) mais elle cachent des mécanismes assez sophistiqués sur lesquels nous revenons dans le chapitre consacré aux aspects avancés des fonctions. Il est donc important de ne pas limiter la compréhension de ces constructions à leur seul aspect syntaxique.

On peut affecter une valeur à plusieurs variables simultanément.

>>> x = y = z = 1
>>> x
1
>>> y
1
>>> z
1

On peut aussi effectuer des affectations parallèles.

>>> x, y = 3.5, 7
>>> x
3.5
>>> y
7

Typage dynamique

En Python, contrairement à d’autres langages de programmation, il n’est pas nécessaire d’écrire des lignes de code spécifiques pour définir le type des variables avant de pouvoir les utiliser. Il suffit d’assigner une valeur à un nom de variable pour que celle-ci soit automatiquement créée avec le type qui correspond à la valeur fournie. On dit alors que Python est un langage à typage dynamique, contrairement aux langages à typage statique comme c’est le cas des langages C ou Java. De plus, les variables peuvent changer de type au gré des affectations. On peut vérifier ceci avec l’opérateur type. Nous y reviendrons au chapitre consacré aux fonctions.

>>> x = 3
>>> type(x)
<class 'int'>
>>> x = 3.5
>>> type(x)
<class 'float'>
>>> x = 'message'
>>> type(x)
<class 'str'>

Annotations de typage

Depuis des versions récentes du langages (\(\ge 3.9\)), il est très facile de “définir” le type des paramètres des fonctions et même des variables. “Définir” est entre guillemets car il ne s’agit que d’une annotation du type de la variable qui ne remet pas en question le typage dynamique de python. L’intérêt de ces annotations est de permettre un contrôle avant l’exécution d’éventuelles incohérences de typage. Par exemple, un paramètre de type entier utilisé par une chaîne de caractères. Ce contrôle est réalisé par des outils extérieurs au langage lui-même comme mypy.

Premières entrées-sorties

  • Fonction print(). Pour afficher une valeur à l’écran, il existe deux possibilités. Soit, on entre au clavier le nom de la variable et ensuite on appuie sur Enter (comme on a fait jusqu’à ici), soit on peut utiliser la fonction print().

>>> n = 3.5
>>> print(n)
3.5
>>> msg = 'Ça va ?'
>>> print(msg)
Ça va ?

Attention cependant à la différence entre print a (Python 2) et print(a) (Python 3).

On peut combiner texte et variables dans une même fonction print().

>>> poids = 3.67
>>> print("Le poids du nouveau-né est", poids, "kilos.")
Le poids du nouveau-né est 3.67 kilos.

11.2.1. Exercice#

Soient deux points de l’espace \(A\) et \(B\). Déclarez 4 variables \(x_A\), \(x_B\), \(y_A\) et \(y_B\) correspondant aux coordonnées réelles de ces deux points et affectez-leur des valeurs. Calculez la distance euclideienne entre \(A\) et \(B\), donnée par la formule \(\sqrt{(x_B - x_A)^2 + (y_B - y_A)^2}\), et affichez le résultat à l’écran sous la forme La distance entre \(A\) et \(B\) est : .

Attention ! Vous devez utiliser pour cet exercice la fonction math.sqrt(). Pour utiliser cette fonction, il faut d’abord importer le module math, avec l’instruction import math.

11.3. Contrôle du flux d’exécution#

11.4. Choix ou branchement#

Dans la plupart des programmes que vous allez écrire, vous aurez besoin d’utiliser des instructions qui permettront au programme de suivre des chemins différents selon les circonstances. Pour ceci il est nécessaire de disposer d’instructions capables de tester une certaine condition et de modifier le comportement du programme en conséquence.

L’instruction qui est sans doute la plus utile afin de permettre un tel comportement est l’instruction if. Son fonctionnement sous Python est très simple. Si la condition à droite du mot-clé if est vraie, alors le bloc d’instructions qui suit est exécuté.

>>> if age > 18 :
...     print("La personne peut voter.")

11.4.1. Indentation#

En Python, les instructions composées (comme c’est le cas de l’instruction if, mais aussi des instructions while, for et des fonctions que nous verrons plus tard) ont toujours la même structure : une ligne d’en-tête terminée par un deux-points, suivie d’un bloc d’instructions indenté sous la ligne d’en-tête. Toutes les instructions de ce bloc doivent être indentées exactement au même niveau. Une convention très respectée est d’utiliser un décalage de 4 espaces.

Avec une telle convention, il est inutile de marquer le début et la fin d’un bloc par des éléments du langage (comme des accolades { et } en C ou Java , ou les mots réservés begin et end dans certains autres langages).

Pour cette raison, en Python on n’est pas libre d’insérer des retours à la ligne partout – comme en C. Les retours à la ligne sont obligatoires à la fin d’une instruction, et permis à l’intérieur des parenthèses. En effet, ce code n’est pas correct :

if a < 1
    and b < 2:
    print('hello')

alors que celui-ci l’est :

if (a < 1
    and b < 2):
    print('hello')

On peut, si on le souhaite ajouter une instruction else pour exécuter un autre bloc si la condition est fausse :

>>> if age > 18:
...     print("La personne peut acheter de l'alcool.")
... else:
...     print("Trop jeune !")

Plutôt que d’emboîter des instructions if, on peut utiliser une instruction if suivie par une ou plusieurs instructions elif (raccourci de else if):

>>> if n == 0:
...     print("Le nombre est égal à zéro")
... elif n > 0:
...     print("Le nombre est positif")
... else:
...     print("Le nombre est négatif")

11.4.2. Exercices#

  1. Déclarez une variable et affectez lui un entier naturel. Testez en utilisant les instructions if et else si l’entier est pair ou impair et affichez le résultat.

  2. Déclarez trois variables a, b et c correspondant aux coefficients de l’équation quadratique \(ax^2 + bx + c = 0\). Calculez le discriminant \(\Delta = b^2 - 4ac\) de l’équation. Testez en utilisant les instructions if, elif et else la valeur du déterminant et calculez la ou les solutions de l’équation. Si le déterminant est négatif, affichez le message “L’équation n’a pas de solution réelle”.

11.4.3. Boucles ou répétitions#

Très souvent dans nos programmes nous avons besoin de répéter un certain nombre d’instructions plusieurs fois. Python, comme probablement tous les autres langages que vous connaissez, possède dans ce but les instructions while et for.

  • La boucle while permet d’itérer un bloc d’instructions tant qu’une condition reste vraie.

>>> a = 0
>>> while a < 10: # N'oubliez pas le deux-points !
...     print(a)   # N'oubliez pas l'indentation !
...     a += 2
... 
0
2
4
6
8

range Avant d’introduire l’instruction for parlons un peu de la fonction range(). Cette fonction peut nous être très utile lorsque on veut itérer sur une suite de nombres. Elle génère des progressions arithmétiques.

range(2, 10) # 2, 3, 4, 5, 6, 7, 8, 9
range(0, 15, 2) # 0, 2, 4, 6, 8, 10, 12, 14
range(10, -50, -10) # 10, 0, -10, -20, -30, -40

La boucle for est très utile lorsque on veut répéter un bloc d’instructions un nombre de fois connu à l’avance. Si on veut par exemple imprimer tous les nombres de 0 à 5, voici comment on peut le faire à l’aide de l’instruction for et de la de la fonction range.

>>> for i in range(6): # N'oubliez pas le deux-points !
...     print(i)        # N'oubliez pas l'indentation !
...
0
1
2
3
4
5

Comme on va le voir un peu plus tard, la boucle for peut être utilisée très facilement pour parcourir les éléments d’une liste.

11.4.4. Exercices#

  1. a. Initialisez deux entiers : a = 0 et b = 15. Ecrivez une boucle qui affiche et incrémente de 1 la valeur de a tant qu’elle reste inférieure à celle de b.

    b. Ecrivez ensuite une autre boucle qui décrémente la valeur de b et affiche sa valeur seulement si elle est impaire. Itérez tant que b est supérieur à 0.

  2. Affichez la somme des cubes de tous les multiples de 3 compris entre 0 et 99 inclus. Utilisez pour cela l’instruction for et la fonction range().

11.5. Fonctions#

11.5.1. Aspects classiques#

Pour créer une fonction en Python, on commence par le mot-clé def (définition). Il doit être suivi par le nom de la fonction, la liste des paramètres entre parenthèses et un deux-points ‘:’. Le corps de la fonction commence à la ligne suivante et doit être écrit avec un retrait de quelques espaces.

Voici une fonction qui imprime les n premiers termes de la suite Fibonacci.

def fibonacci(n):
    a, b = 0, 1
    for i in range(n):
        print(a, end=' ')
        a, b = b, a + b
    print(a)

fibonacci(20)

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765

Rmq. Cette première fonction n’est pas un “exemple parfait” car elle mélange des calculs et des entrées-sorties. Il est préférable de séparer calculs et entrées-sorties.

C’est bien mieux d’écrire une fonction qui nous renvoie quelque chose. Ceci se fait avec le mot-clé return. Voici une fonction qui renvoie la somme des carrés des entiers de 0 à n.

def sommeCarres(n):
     sum = 0
     for i in range(n):
         sum += i**2
     return sum

res = sommeCarres(20)
print(res)

2470

11.5.2. Fonctions avec annotations de types#

Comme déjà indiqué, il est possible d’introduire des annotations du type des paramètres des fonctions. D’abord les types de base comme int, float, str.

Depuis python 3.9, ces annotations incluent les types natifs génériques (c-a-d. les types paramétrables par d’autres types) comme list, dict, tuple, set, … ainsi que les structures de données du module collections.

Le module typing définit ces facilités et bien d’autres hors de notre propos ce semestre. Pour notre utilisation, les versions récentes de python dispensent de l’import de ce module. Voir plus de détails dans la PEP 484 ou la PEP 585.

Reprenons les fonctions précédentes avec ces annotations.

  • le paramètre n de la fonction fibonacci() est un entier int ; la syntaxe de l’annotation est n: int ;

  • cette fonction ne retourne “rien” ; la syntaxe de l’annotation est -> None (*).

  • La fonction sommeCarres(n: int) qui calcule et retourne un int sera complétée par -> int.

(*) : Par défaut, toute fonction python retourne la valeur None. Dans le contexte des annotations de type, None désigne type(None)).

def fibonacci(n: int) -> None:
    '''Cette fonction moche calcule et affiche les 
    n premiers termes de la suite de Fibonacci'''
    a, b = 0, 1
    for i in range(20):
        print(a, end=' ')
        a, b = b, a + b
    print(a)

from math import log, e
print(e)
help(log)

2.718281828459045
Help on built-in function log in module math:

log(...)
    log(x, [base=math.e])
    Return the logarithm of x to the given base.
    
    If the base not specified, returns the natural logarithm (base e) of x.

help(fibonacci)

Help on function fibonacci in module __main__:

fibonacci(n: int) -> None
    Cette fonction moche calcule et affiche les 
    n premiers termes de la suite de Fibonacci

fibonacci(10)

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765

  • la fonction sommesCarres() prend et retourne des paramètres de type int.

def sommeCarres(n: int) -> int:
    '''Calcule et retourne la somme des n premiers carrés'''
    sum = 0
    for i in range(n):
        sum += i**2
    return sum

s = sommeCarres(20)
print(s)

2470

La suite suppose la connaissance de la notion de liste présentée dans cette section.

Imaginons maintenant la fonction sommeListe() qui effectue la somme d’une liste de flottants.

Fabriquons une telle liste pour commencer

d = [0.0]
for i in range(5):
    d.append(d[-1] + 0.2)
    
print(d)

[0.0, 0.2, 0.4, 0.6000000000000001, 0.8, 1.0]

Exercice. Expliquer pourquoi la valeur 0.6 n’est pas calculée exactement.

Effectuons sa somme avec sommeListe().

def sommeListe(data: list[float]) -> float:
    s = 0.0
    for val in data:
        s = s + val
    return s

print(sommeListe(d))

3.0

Sommer une liste d’entiers, de flottants ou de complexes ne change pas notre algorithme. Les annotations permettent cependant de décrire ces cas grâce au mécanisme d’Union[] de types (à comprendre comme un ensemble de types possibles).

Le symbole classique | remplace la syntaxe Union[] depuis python 3.10.

def sommeListe2(data: list[int] | list[float] | list[complex]) \
  -> int | float | complex:
    s = 0
    for val in data:
        s = s + val
    return s

d_int = [i for i in range(10)]
d_cmplx = [complex(1, y) for y in range(1, 5)]
print(d_int, sommeListe2(d_int))
print(d_cmplx, sommeListe2(d_cmplx))

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 45
[(1+1j), (1+2j), (1+3j), (1+4j)] (4+10j)

11.5.3. Exercice#

Ecrivez une fonction tableDeMultiplication(base, fin) qui prend en paramètre un entier base et un entier fin et affiche à l’écran les fin premiers éléments de la table de multiplication de l’entier base. Compléter la définition des annotations nécessaires.

Par exemple :

>>> tableDeMultiplication(3, 10)
0 3 6 9 12 15 18 21 24 27

11.6. Listes#

Les listes sont des structures ordonnées de données. En Python, une liste est définie à l’aide des crochets.

nombres = [2, 5, 13, -35, 0]
fromages = ['roquefort', 'camembert', 'saint-nectaire', 'comté']

On peut accéder aux données d’une liste à l’aide de leur indice associé.

print(nombres[2])

13

print(fromages[0])

roquefort

print(fromages[-1])

comté

print(nombres[0:3])

[2, 5, 13]

Rmq. La tranche ainsi construite est aussi une liste.

type(nombres), type(nombres[0:3])

(list, list)

On peut accéder à la taille d’une liste à l’aide de la fonction len(). Elle renvoie le nombre d’éléments présents dans la liste.

print(len(nombres), nombres)

5 [2, 5, 13, -35, 0]

len(fromages)

4

Il existe plusieurs manières de créer une liste. Voici quelques unes :

  • Liste vide

liste1 = []

print(liste1)

[]

  • On peut créer une liste en indiquant à la création les éléments qu’elle doit contenir. Vous pouvez remarquer qu’une liste peut contenir des éléments ayant des types variés.

liste2 = ['ac/dc', 42, 3.14]

print(liste2)

['ac/dc', 42, 3.14]

  • Important. La syntaxe de compréhension de listes permet de générer une liste par une boucle. C’est la forme de création de liste à privilégier en python.

liste3 = [i for i in range(20)]

print(liste3)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

Exemple. Liste contenant le carré de tous les entiers de 0 à 9.

liste4 = [i ** 2 for i in range(10)]

print(liste4)

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

On peut parcourir une liste à l’aide d’une boucle for sur les indices des valeurs de la liste :

nombres = [9, 13, -2, 25, 31, 7, 4]
sum = 0
for i in range(len(nombres)):  # accès par indices aux valeurs de la liste
    sum += nombres[i]

print(sum)

87

Et plus directement (en python) à l’aide d’une boucle for sur les valeurs de la liste (on verra plus loin qu’une liste python est un itérable) :

nombres = [9, 13, -2, 25, 31, 7, 4]
sum = 0
for v in nombres:  # accès direct aux valeurs de la liste
     sum += v

print(sum)

87

où à l’aide d’une boucle while – pour un calcul qui n’a rien à voir avec les précédents.

i = 0
sum = 0
while i < len(nombres):
    sum += i
    i += 3

print(sum)

9

On peut tester si un élément est dans la liste à l’aide de l’instruction in. Cependant pour cette année, on utilisera cette facilité en ayant conscience de l’algorithme qui peut être caché derrière ce tout petit identifiant à deux lettres …

print(-2 in nombres) 

True

print(8 in nombres) 

False

Important

Le rappel sur les acquis du semestre 1 concernant les listes s’arrête volontairement ici. Autrement dit, je ne “connais pas” et je n’ai donc pas besoin, des méthodes append(), insert(), remove() … Je n’ai pas non plus écrit l1 = l2, c-a-d. l’affectation d’une liste dans une autre.

Nous étudierons ces aspects en temps utile, au chapitre sur les types composés.

Vous pouvez aussi trouver plus d’informations sur la page docs.python.org.

11.6.1. Exercice#

1#

Définissez la liste liste = [34, 0, -17, 5, 18, 9], puis effectuez les actions suivantes :

  • Triez et affichez la liste.

  • Ajoutez l’élément 15 à la fin de la liste et affichez la.

  • Renversez et affichez la liste.

  • Affichez l’indice de l’élément -17.

  • Enlevez l’élément 5 et affichez la liste.

  • Affichez la sous-liste du \(2^e\) au \(3^e\) élément.

  • Affichez la sous-liste du début au \(4^e\) élément.

  • Affichez la sous-liste du \(3^e\) élément à la fin de la liste.

  • Affichez l’avant dernier élément en utilisant un indiçage négatif.

2#

Modifier la fonction fibonacci(n) de la Section 5 afin qu’elle renvoie une liste avec les n premiers termes de la suite Fibonacci.

11.7. Exercices#

Vous êtes prêts maintenant à écrire par vous mêmes des programmes un peu plus longs et compliqués.

  • Le notebook est toujours pratique. Utilisez-le.

  • Le mode terminal lui ne l’est plus.

  • Une alternative est d’utiliser des scripts pour écrire, sauvegarder et modifier vos programmes.

Pour écrire un script, il suffit de créer un fichier dont le nom se termine par .py afin d’indiquer qu’il s’agit bien d’un script Python. Vous pouvez ensuite l’exécuter dans un terminal en écrivant

$ python3 script.py

ou dans l’environnement virtuel monPyhton que nous mettrons en place en TP :

$ (monPython) python script.py

11.7.1. Crible d’Eratosthène#

Le crible d’Eratosthène est un algorithme qui permet de trouver tous les nombres premiers qui sont inférieurs à un certain entier naturel \(N\). Cet algorithme est dû au mathématicien grec Eratosthène de Cyrène qui est également connu pour être la première personne à avoir mesuré le méridien terrestre.

L’idée du crible est très simple. On commence par écrire la liste de tous les nombres de \(2\) jusqu’à \(N\). Ensuite on barre (on enlève de la liste) tous les multiples de \(2\). On note ensuite le plus petit nombre non-barré de la liste, qui est donc le nombre 3, et on procède de façon similaire en enlevant tous ses multiples. On continue de la même façon jusqu’à atteindre le nombre \(N\). Les nombres qui restent à la fin sont exactement les nombres premiers plus petits ou égaux à \(N\).

Vous pouvez voir une jolie animation de l’exécution de l’algorithme sur la page wikipedia.

Remarque. En réalité, il suffit de tester uniquement les multiples des nombres de 2 à \(\sqrt{N}\), puisque un nombre composé plus petit ou égal à \(N\), a forcément un facteur plus petit ou égal à \(\sqrt{N}\).

Vous devez maintenant programmer le crible d’Eratosthène en Python. Ecrivez une fonction eratosthene(N) qui prend comme paramètre un entier naturel \(N\) et qui affiche à l’écran la liste de tous les nombres premiers plus petits ou égaux à \(N\). Il existe plusieurs façons de coder cet algorithme en Python, vous êtes libres de faire à votre propre guise.

11.7.2. Recherche dichotomique#

La recherche dichotomique est un algorithme très simple et efficace pour rechercher un élément dans une liste triée.

Imaginez par exemple que nous souhaitons retrouver le numéro de téléphone d’une personne dans un annuaire qui est trié par ordre alphabétique. La recherche séquentielle, c.-à-d. parcourir l’annuaire du début en comparant tous les noms avec celui dont on cherche le numéro de téléphone peut être très longue (surtout si le nom recherché se trouve à la fin de l’annuaire). Une approche bien plus efficace est d’ouvrir l’annuaire au milieu et commencer par regarder si le nom se trouve à cette page. Si ce n’est pas le cas, et si le nom dont on cherche se trouve plus loin, alors on recommence la recherche avec la deuxième moitié de l’annuaire. Si le nom se trouve avant, alors on recommence avec la première moitié.

On peut voir qu’avec cette approche, on réduit à chaque étape la taille de l’annuaire à parcourir de la moitié. Cet algorithme fait partie alors des algorithmes dits diviser pour régner et a une complexité logarithmique en la taille de la liste.

Pour cet exercice, on suppose que l’utilisateur possède une liste croissante de nombres et on lui fournit un nombre qu’on suppose être dans la liste. Le but est de retourner l’indice du nombre recherché dans la liste.

Si la liste fournie est [1,3,4,6,10,14,15] et l’élément qu’on cherche est 10, alors le programme doit retourner 4 (souvenez-vous que, dans une liste, les indices sont numérotés à partir de 0).

Ecrivez une fonction rechercheDichotomique(valeur, listeTriee) qui prend en entrée une liste triée de nombres et une valeur à rechercher dans la liste et renvoie l’indice de la liste correspondant à cette valeur.

Contents