Boucles bornées en Python

Definition

Une boucle bornée est un système d’instructions qui permet de répéter un certain nombre de fois toute une série d’opérations.

La syntaxe d’une boucle bornée, en langage algorithmique peut s’écrire:

Pour i allant de 0 a n-1
Faire:
   instruction 1
   instruction 2
FinPour

En python, la syntaxe correspondante est:

for i in range(n):
  instruction 1
  instruction 2

On peut représenter ce script avec des modules à assembler:

Remarques

Construction de la boucle bornée

• Le bloc d’instruction sera executé n fois. Celui-ci peut contenir une ou plusieurs instructions, du moment qu’elles sont bien positionnées dans le bloc.
• En Python, le bloc est identifié par une indentation: un retrait par rapport au bord gauche, comprenant 2 espaces (ou 4).
• Pour sortir du bloc, on élimine l’indentation (on revient sur le bord gauche)

• La fonction range(n) renvoie la liste des entiers de 0 à n-1. C’est un principe général en informatique, on commence toujours à compter à partir de 0, et il faut donc s’arrêter à n-1 pour effectuer n fois la boucle.
• Pour chaque itération, le variant i prend une nouvelle valeur de l’ensemble {0,1,2,... n-1}, et peut être utilisé dans le bloc d’instructions.
• On peut choisir n’importe quel nom pour le variant, pas seulement i.
• Contrairement à la boucle non bornée while, le programmeur ne s’occupe pas de faire varier i à chaque itération. Cela ce fait tout seul.

Boucle bornée et non bornée

Pour la boucle bornée for, il n’est pas necessaire d’ajouter une instruction dans le bloc pour que le variant change de valeur à chaque itération. Cela se fait tout seul, à chaque fois que le programme revient sur l’instruction for.

Exemples

• Exemple 1: afficher le variant de boucle i

for i in range(3):
  print(i)
# affiche
0
1
2

Remarque: la fonction range(3) va créer une liste itérable constituée des valeurs 0, 1, 2. Ce sont les valeurs prises successivement par le variant i dans for i in range(3)

• Exemple 2: Ce variant peut être utilisé pour une formule arithmétique, à l’intérieur de la boucle:

for i in range(3):
  x = i**2 + 1
  print(x)
# affiche
1
2
5

Exercices:

1. Sélection des valeurs paires

for i in range(4):
    if i % 2 == 0:
        print(i)

Le programme affiche les valeurs:
0
2

Construire le programme équivalent, utilisant l’instruction while, à l’aide de blocs python:

2. Table de 7

a. Réaliser un programme qui affiche (fonction print) les 4 premières valeurs de la table de 7 (avec for puis while)

b. Compléter le tableau:

3. Division euclidienne

On rappelle que l’utilisation d’une boucle bornée for nécessite de connaitre le nombre d’itérations (for .. in range(n)). Si ce nombre d’itérations n’est pas connu, il faudra utiliser une boucle while.

Le quotient de la division de a par b est égal au nombre de fois N qu’il faut soustraire b à a jusqu’à ce que l’on ait a < b.

a. D’après cet énoncé, va t-on utiliser une boucle bornée, ou bien un boucle non bornée?

b. Compléter le script de la division euclidienne de a par b

a = int(input('entrer la valeur de a :'))
b = int(input('entrer la valeur de b :'))
N = 0
...
...
...
print(a)

c. Quel est le quotient entier de la division de 2024 par 7?

Les fonctions en python

Généralités

fonctions natives du langage

Tous les langages de programmation fournissent un large ensemble de fonctions prêtes à être utilisées. Nous avons déjà rencontré diverses fonctions prédéfinies, de la librairie standart : print, input, range.

Tester dans un notebook, ou en console les fonctions natives suivantes:

bin(129)

int('0b10000001',2)

Dans ces 2 exemples, on a utilisé un ou plusieurs arguments, positionnés entre les parenthèses.

• pour bin(129), c’est l’argument 129 qui est passé à la fonction, afin que celle-ci réalise la conversion de 129 en binaire.
• pour int('0b10000001',2), ce sont 2 arguments qui sont passés à la fonction int: Le binaire ‘0b10000001’, ainsi que l’argument 2 précisant qu’il s’agit d’un code binaire à convertir en entier.

Remarquer que ces arguments sont séparés par une virgule.

fonctions programmées

Les fonctions permettent de rendre le script plus efficace, plus facile à lire et à vérifier. Un bonne pratique est de faire régulierement du remaniement de son code : C’est à dire ré-écrire les parties du programme qui fonctionnent et les mettre dans une fonction ou un module. Cela evite aussi les répétitions. On remplace alors le code par un appel à une fonction.

Définition : Une fonction est un bloc de code auquel on donne un nom en vue de le reutiliser. L’appel de son nom exécute tout le bloc de code que cette fonction contient.

Pour créer une fonction, il faut la definir avec le mot clé def, suivi du nom de la fonction, d’une paire de parenthèses suivies de :.

Return

La fonction peut retourner une valeur. Celle-ci est alors mise après le mot clé return.

Exemple:

def salut():
  """Accueillir tout le monde"""
  return 'bonjour tout le monde'

On appelle cette fonction à l’aide de son nom, suivi des parenthèses :

salut()
# retourne (et affiche) 'bonjour tout le monde'

Souvent, cette donnée retournée doit être affectée à une variable:

message = salut()
print(message)
# affiche: bonjour tout le monde

Travaux pratiques: fonction sans paramètre

Un cours sur les fonctions se trouve à la page suivante: Lien

• Question a: Ecrire une fonction appelée etoiles en python qui écrit une série de 5 symboles *, séparés chacun par un espace:

* * * * * 

Appeler (exécuter) la fonction: faire suivre le nom de la fonction par des parenthèses ():

> etoiles()

Pour afficher la ligne, faire: print(etoiles())

utiliser une boucle bornée pour répéter 5 fois l’appel de la fonction et afficher l’image suivante:

* * * * * 
* * * * * 
* * * * * 
* * * * * 
* * * * * 

• Question b: Sur document-reponse: Recopier le script utilisé

Fonction avec paramètres

Principe

Souvent, la fonction calcule sur un ou plusieurs paramètres qui lui sont passés lors de l’appel de la fonction.

Pour prévoir ceci, il faudra définir un ou plusieurs paramètres lors de la constuction de la fonction.

Par exemple, si l’on souhaite améliorer la fonction salut et personnaliser le message:

def salut(nom):
  """Accueillir chacun par son nom"""
  return 'bonjour '+ nom

Tester cette fonction avec les prenoms successifs de John, Paul, Ringo et George.

Vous devrez afficher en console:

bonjour John
bonjour Paul
bonjour Ringo
bonjour George

ex1: Recopier le script sur votre feuille réponse.

Attention, lors de l’appel de la fonction, il devra y avoir autant d’arguments que de paramètres définis (donc un seul pour ce dernier exemple).

TP: ASCII-art

On cherche à realiser des figures en à partir de caractères, comme vu dans le paragraphe precedent.

ex2: Utilisez la fonction etoiles pour que celle-ci utilise un paramètre (nb). Ce paramètre definit le nombre d’espaces entre les 2 symboles * de la ligne. La ligne n’affiche que 2 symboles *.

Par exemple, etoiles(5) retourne * * avec 5 espaces:

def etoiles(nb):
    return '*' + nb*' ' + '*'

ex3: afficher la figure suivante (un seul espace à chaque ligne entre 2 etoiles)?

for i in range(..):
  print(etoile(..))

# resultat
* *
* *
* *
* *

ex4: Vous appelerez ensuite cette fonction avec des arguments judicieusement choisis, afin de dessiner les figures suivantes:

figure 1:

for i in range(..):
  print(etoile(..))

# resultat
**
* *
*  *
*   *
*    *

figure 2:

*    *
*   *
*  *
* *
**

figure 3:

**
* *
*  *
*   *
*    *
*    *
*   *
*  *
* *
**

Astuce: avez vous fait en sorte d’utiliser au maximum des boucles bornées avec un variant de boucle?

ex5: modifier la fonction ainsi que le programme pour afficher maintenant un sapin de Noel:

      **
     *  *
    *    *
   *      *
  *        *
      **
      **

Fonctions utiles pour calculer

Loi de Descartes

On propose de programmer les fonctions qui seront utiles pour aider au calcul de l’angle de refraction r lors de la traversée d’un rayon à la surface d’un dioptre.

L’angle r est donné par la relation:

$$n_1\times sin(i_1) = n_2\times sin(i_2)$$

Où i est l’angle d’incidence, n1 et n2 sont les indices de refraction des milieux traversés.

Fonction degrès - radians

Python manipule les angles en radians pour les fonctions trigonometriques.

Commençont par programmer la fonction qui transforme les angles de degrès en radians:

def fonc1(angle):
    radian = angle * 3.14/180
    return radian

On peut alors tester la fonction:

>>> fonc1(90)
...

Le résultat manque de précision à cause de la valeur utilisée pour PI. Il faut alors importer le module math pour avoir la valeur precise de PI

Importer ce module. Et afficher en console la valeur de PI:

import math
math.pi

Puis modifier la fonction fonc1 en fonc2:

def fonc1(angle):
    radian = angle * math.pi/180

Fonctions sin et asin du module math

Le module math apporte aussi les fonctions trigonométriques sin et son inverse asin.

Tester ces fonctions pour quelques valeurs:

• math.sin(1.57)

• math.sin(math.pi/2)

• math.asin(1)

Fonction à plusieurs paramètres

On cherche maintenant à écrire la fonction qui permettra de calculer l’angle r selon la relation:

$$r = asin(\tfrac{n_1\times sin(i_1)}{n_2})$$

On definira une fonction appelée angleRefraction, qui aura cette fois 3 parametres i1, n1, n2. Ces 3 paramètres seront écrits entre parenthèses, séparés par une virgule:

def angleRefraction(i1,n1,n2):
    radian = fonc1(i1)
    r = math.asin(...           ...)
    return r * 180 / math.pi

Compléter les pointillés ...

Tester votre fonction: avec un angle d’incidence de 30°, des indices de refraction n1=1 et n2=1.5, on doit avoir r = 19.47°.

ex 7: Recopier le script de la fonction angleRefraction, ainsi que l’instruction utilisée pour résoudre l’exercice.

Compléments

• Un cours sur les fonctions se trouve à la page suivante: Lien