Contenu de la leçon¶

1. Procédure
2. Fonction en Python
3. Passage des arguments
4. Exemples de procédures et fonctions
5. Paramètres optionnels d’une fonction
6. Méthodes et classes, fonctions de bibliothéque
7. Programmation structurée
8. Exercice

Procédure¶

procédure: algorithme avec des paramètres d’entrée (données) et des paramètres de sortie (résultat)

Algorithme MaFonction(liste de paramètres)
    variables locales
    instructions
    retour (liste de valeurs)

# utilisation
val = MaFonction(param1,param2,..)

Fonction en Python¶

implémentation d’une procédure = function (C, Python) , subroutine (Fortran)

# définition
def MaFonction(liste arguments):
    instructions
    ....
    return (liste de valeurs)
# utilisation
(val1, val2, ..) = MaFonction(arg1, arg2, ...) 

Passage des arguments¶

on affecte aux arguments de la fonction la valeur des paramètres d’appel:

def MaFonction(a1, a2, a3):
    ....
    return (v1, v2)

(V1, V2) = MaFonction(A1, A2, A3)

• lors de l’appel, on a a1=A1 a2=A2 a3=A3

• valeur de retour = liste

  • lors du retour, V1=v1, V2=v2

**Exemple Python**(visualisation avec [http://www.pythontutor.com])

Passage des arguments¶

• pour les variables scalaires: valeur = valeur de la variable

  • la variable n’est donc pas modifiée

• pour les listes et tableaux: valeur = adresse des données

  • on peut donc modifier la valeur d’une liste ou tableau en argument
  • mais à condition de ne pas faire de réaffectation **Exemple Initialisation de liste (tableau) : version 1**

**Initialisation de liste (tableau): version 2**

Exemples de procédures et de fonctions¶

Algorithme d’Euclide: calcul du PGCD de 2 entiers¶

# Calcul du PGCD
# paramètres d'entrée: 2 entiers positifs a et b
# en sortie: PGCD de a et b
#
Algorithme PGCD(a,b)
    tant que a # b 
        si a>b alors a = a-b 
        sinon b = b - a 
    retour a
#

Programme Python¶

Algorithme: calcul de la somme d’une série¶

$$ S_n = \sum_{i=1}^n \frac{1}{i^2} \mbox{ et } \lim_{n\rightarrow\infty} S_n = \frac{\pi^2}{6}$$

# calcul de la somme Sn et de l'Écart par rapport à la limite
# entrée: n entier   sortie: somme, écart par rapport à limite
Algorithme Somme(n)
    S=0.
    pour i de 1 a n
        S = S + 1./i**2
    err = S - (pi**2/6.)
    retour S,err

Programme Python¶

Paramètres optionnels d’une fonction¶

• En Python possibilité de définir des paramètres optionnels avec une valeur par défaut
• Nommage des paramètres (ordre indifférent)
• Très utilisés dans les fonctions des bibliothèques

    # Déclaration
    def MaFonction(par, par1=valdef1, par2=valdef2)

    # Appel
    MaFonction(val)
    MaFonction(val, par1=val1)
    MaFonction(val, par2=val2, par1=val1)

Exemple: algorithme de Héron pour calculer une racine carrée¶

Pour calculer une approximation $u$ de $\sqrt{a}$, on note que si $u\approx\sqrt(a)$ alors $a/u\approx\sqrt(a)$ et donc $\frac{u + a/u}{2}$ est sans doute une meilleur approximation de $\sqrt{a}$.
On peut vérifier que cette méthode babylonienne est en fait un cas particulier de la méthode de Newton pour calculer la racine de $f(x)=u^2-a$

Algorithme¶

  Algorithme Heron(a)
      u = a/2
      eps = 1.e-6
      tant que |u**2 - a| > eps
          u = (u + a/u)/2
      fin tantque
      retour u

Programme Python¶

Fonction Lambda¶

• permet de définir des mini-fonctions (à la Lisp)
• utile pour des fonctions simples (mais pas obligatoire!!)

    F = lambda args : expression(args)

Méthodes, classes et fonctions de bibliothéque¶

Définition¶

classe = type de structure de données définissant des données + fonctions pour manipuler ces données

méthode = fonction associée à une classe pour manipuler les données de la classe

objet = instance de classe = variable [données + méthodes]

sous Python toute variable (list, string, real, int) est un objet et possède des méthodes (p.e pour l’afficher)

Syntaxe d’utilisation d’une méthode sous Python¶

pour un objet A avec un methode func1

A.func1(arg1,arg2,...)

équivalent à

func1(A,arg1,arg2,..)

Exemple en Python¶

Aide sous Ipython¶

Sous Ipython, pour avoir la liste des méthodes associées à un objet A

A. <tab>   # liste des methodes
A.meth?    # aide sur la methode meth

Fonctions d’une bibliothéque¶

espace de nom = nom de la bibliothéque bibli

import bibli

nom de la fonction func dans la bibliothéque

bibli.func
bibli.sous_bibli.func

simplification du nommage

import bibli as bib
import bibli.sous_bibli as sbib

importation d’une fonction

from bibli import func

Programmation structurée¶

principe: “Divide and Conquer”

découpage du problème en une suite de problèmes plus simples

Analyse algorithmique “Top-Down design”¶

Principes de l’analyse top down¶

• on découpe le problème en une série de sous-problèmes plus simples (si possible indépendant)
• on spécifie ce qui doit résolu dans chacun des sous-problèmes sans forcément dire comment
• puis on itère au niveau des sous problèmes.

Programmation “Botton-up programming”¶

• on part des sous-problèmes élémentaires que l’on programme sous forme de fonctions (ou procédures)
• on valide les fonctions
• puis on réitère en remontant dans l’arbre jusqu’au programme principal

règles réutiliser les fonctions déjà écrites et validées (bibliothèques): principe du moindre effort !

Exemple: simuler l’alunissage de Neil Amstrong (Apollo 11)¶

• basé sur une simulation d’alunissage du module lunaire écrit en basic en 1969, puis popularisé en 1979 sur ATARI (Lunar Lander).

jeu “Lunar Lander”:¶

Poser le module lunaire (LEM) sur la lune en arrivant avec une vitesse quasiment nulle. Pour cela on dispose de rétro-fusées permettant de ralentir la chute du LEM.

• On contrôle manuellement ces rétro-fusées en sélectionnant une poussée (de 0 à 9), correspondant à l’éjection de carburant avec un débit $Qe$ variable et une vitesse $Ue$ fixe.
• Mais on dispose d’une quantité limitée de carburant que l’on doit utiliser avec modération pour pouvoir atterrir en douceur.

modèle physique:¶

Le LEM, de masse initiale $M0$, est soumis à la gravité $g$ de la lune et à la poussée des rétro-fusées, correspondant à l’éjection d’un débit de fuel $Qe$ à un vitesse $Ve$ .

modèle mathématique:¶

Equation du mouvement: $$ \frac{d^2 Z}{dt^2} = -g + \frac{Qe*Ue}{M0-Qe*t}$$

en intégrant sur la durée d’une commande $T$ $\rightarrow$ vitesse $V$ $$ V = V0 + g*T + Ue * \ln{(1 - \frac{Qe*T}{M0})} $$ La masse du LEM $M$ diminue $$M = M0 -Qe*T$$ Approximation par DL car $X=\frac{Qe*T}{M0} \ll 1$ $$ V = V0 + g*T - Ue*(X + \frac{X^2}{2} + \frac{X^3}{3} + \frac{X^4}{4} + \frac{X^5}{5})$$ d’où l’altitude $Z$ $$ Z = Z0 - V0*T - g \frac{T^2}{2} + Ue*T*(\frac{X}{2} + \frac{X^2}{6} + \frac{X^3}{12} + \frac{X^4}{20} + \frac{X^5}{30})$$ expression utilisée dans les premiers programmes en BASIC.

cas particuliers¶

1. Si le fuel est épuisé ($Qe=0$), le LEM atteins la surface lunaire au bout d’un temps $T$ solution de l’équation du 2nd degré: $$ 0 = Z0 - V0*T -g \frac{T^2}{2}$$ soit $T = (-V0 + \sqrt{V0^2 + 2 g Z0})/g$

2. Près de la surface, $T$ trop grand $\rightarrow$ prédiction $Z0 < 0$

   • calcul $T$ donnant l’altitude $Z=0$, solution d’une équation du 6ième degré.
   • calcul par approximations successives en utilisant un DL de $Z(t)$
     1. estimation $T0$ de $T$ $$ T0 = \frac{-V0 + \sqrt{V0^2 + 2 (g-\frac{Ue*Qe}{M0}) Z0}}{g-\frac{Ue*Qe}{M0}} $$
     2. recalcule $V0$ et $Z0$, puis recommence.

Algorithme: analyse top-down¶

problème global¶

sous-probleme Lecture_cde¶

sous-problème VitesseAltitude¶

applications des formules mathématiques de l’analyse précédente

$$ V = V0 + g*T - Ue*(X + \frac{X^2}{2} + \frac{X^3}{3} + \frac{X^4}{4} + \frac{X^5}{5})$$$$ Z = Z0 - V0*T - g \frac{T^2}{2} + Ue*T*(\frac{X}{2} + \frac{X^2}{6} + \frac{X^3}{12} + \frac{X^4}{20} + \frac{X^5}{30})$$

sous-probleme Alunissage¶

Programmation Python bottom up¶

Fonction Lecture_Cde¶

Fonction VitesseAltitude¶

Fonction Alunissage¶

Programme principal¶

Exercice: simulation d’un lancer de balle¶

Modèle physique:¶

Modèle mathématique:¶

Ce modèle admet une solution analytique simple pour la position $x_0$

$$ x_0 = \frac{ 2 V_0^2 \sin{\alpha} \cos{\alpha}}{g} $$

Objectif du programme¶

Écrire un programme Python qui simule le jeux angry birds en mode texte. On pose un bloc à une distance $L$ du joueur, qui doit envoyer une balle pour le démolir (i.e. atteindre $L$ avec une précision donnée).

Le joueur choisit 2 paramètres à valeurs discrètes:

• l’angle $\alpha$ (de 1 à 8 pour un angle de 10 à 45 degré par pas de 5)
• la vitesse initiale $V_0$ (de 1 à 5 par pas 1).

Le joueur a 3 essais, et pour chaque essai, le programme indique la distance atteinte par la balle par rapport au bloc visé.

Bibliographie¶

• Programme originel “Lunar Lander” en Basic sur ATARI:

  “Lunar Lander basic programme”

• Les classes sous Python

  “Classes sous Python”,
  chapitre du livre “Apprendre à programmer avec Python”

• Livre sur Python

  (en téléchargement gratuit) “Apprendre à programmer avec Python” de Gérard Swinnen

Fin de la leçon¶