TP programmation python

8.1. TP programmation python#

cours Méthodes numériques avancées master M2 Mécanique

%matplotlib inline
import sys,os
import numpy as np
import scipy as sp
import matplotlib
import matplotlib.pyplot as plt
from random import random
# initialisation
from validation.validation import info_etudiant, check_function, liste_functions, info_function
from IPython.display import display, Markdown, Latex
def printmd(string):
    display(Markdown(string))
# test si numero étudiant spécifier
try: NUMERO_ETUDIANT
except NameError: NUMERO_ETUDIANT = None 
if type(NUMERO_ETUDIANT) is not int :
    printmd("**ERREUR:** numéro d'étudiant non spécifié!!!")
    NOM,PRENOM,NUMERO_ETUDIANT = info_etudiant()
    #raise AssertionError("NUMERO_ETUDIANT non défini")
# parametres spécifiques
_uid_    = NUMERO_ETUDIANT
np.random.seed(_uid_)
printmd("**Etudiant {} {}  id={}**".format(NOM,PRENOM,NUMERO_ETUDIANT))
# recharge les modules
%load_ext autoreload

8.1.1. Consigne / JupyterLab#

L’objectif du TP est d’apprendre à programmer en Python sans utiliser l’interface graphique des notebooks !!!

C’est la méthode classique utilisée pour développer du code dans n’importe quel langage de programmation.

Elle nécessite :

  • un éditeur de texte

  • un interpréteur python

Nous allons utiliser l’éditeur de texte et l’interpréteur IPython de JupyterLab

Pour accéder à l’interface jupyerlab, entrée l’URL suivante dans le navigateur (ou cliquer sur le lien suivant)

  https://jupyter-exam.mecanique.univ-lyon1.fr/user/pxxxx/lab

où pxxxxx est votre numéro d’étudiant avec le premier chiffre remplacé par p (i.e. votre compte étudiant).

8.1.2. Utilisation du Notebook#

Pour ceux qui n’ont pas encore l’habitude de l’environnement Jupyter Lab, il est possible de résoudre les exercices dans le notebook, en se référent à la dernière section.

8.1.3. Sélection du répertoire de travail#

Dans la nouvelle interface JupyterLab, à gauche vous vous déplacez dans le répertoire du TP:

  • MGC2367MG1/TPI0_python ou MGC2367MG2/TPI0_python

C’est votre nouvel environnement de travail.

Avec cette interface, vous avez accès directement en ligne aux outils suivants (launcher)

  • les notebooks python

  • l’interpréteur python ipython

  • un éditeur de texte

  • un terminal Unix

8.1.3.1. Terminal#

  • permet d’executer des commandes unix avec un shell

  • exemple: utiliser les commandes Unix pour vous déplacer dans le répertoire de travail et lister les fichiers

    cd MGC2367MG1/TPI0_python
ls

8.1.3.2. Interpreteur Ipython#

  • permet d’executer des instructions en python ou un programme python dans un fichier

  • pour executer une série d’instruction, il faut taper sur les touches shift + entrée

8.1.3.3. Editeur de texte#

  • permet de rentrer du code python dans un fichier texte

8.1.3.4. Notebooks#

  • permet d’afficher / ou executer un notebook

  • exemple: parmis les fichiers du répertoire à gauche, vous retrouvez le notebook que vous pouvez ouvrir (fermer dans ce cas la fenêtre du notebook Jupyter) en cliquant simplement sur le nom du fichier notebook TP01_ipynb.

8.1.4. Méthode de travail#

Accéder à l’interface jupyterlab, en remplacant tree par lab dans l’URL

https://jupyterM2.mecanique.univ-lyon1.fr/user/pxxxx/lab

8.1.4.1. Consignes#

  • ouvrir un terminal et se déplacer dans le dossier du TP:

     cd MGC2367M/TPI0_python
 ls

8.1.4.2. Algorithme de réussite#

  1. editer le fichier python

    • éditer le fichier python mon_pge.py en cliquant dessus pour appeler l’éditeur

    • dans la fenetre d’édition, ouvrir un interpréteur ipython en cliquant une fois dans la fenetre

  2. boucle sur les exercices (pour chaque exercise i de 0 à n-1):

    1. programmation d’un exercise:

    • sur un papier, choisir un example pour comprendre ce qui est demandé, puis écrire l’algorithme.

    • pour chaque exercise i écrire la fonction funci() en spécifiant les arguments et la valeur de retour.

    • attention au type des arguments (tableaux d’entiers, réeel, …)

    1. vérification

    • à la fin du fichier dans la section :

      if __name__ == '__main__' :

      appeller la fonction funci() avec un jeux d’arguments pour vérifier son execution.

    • Puis dans la console ipython executer le programme avec :

      run mon_pge.py

    • ou dans un terminal

      pyhon3 mon_pge.py

      pour vérifier.

    • En cas d’erreur reboucler sur la programmation (phase A)

    1. validation si la vérification (phase B) est bonne

    • utiliser la fonction valide_exo pour passer les tests de validation:

    (uniquement si aucune erreur de syntaxe et si la phase de vérification est faîte)

       valide_exo  -m MGC2367M_TP1 exoxx funci

    en cas d’erreur reboucler sur A.

    1. passer à l’exercice suivant (aller en 2)

  3. finalisation

    • à la fin du TP, rendre le devoir en appuyant sur le bouton submit (dans l’onglet assignement)

S=['exo51', 'S50', 'S50', 'S60', 'S60', 'S70', 'S70', 'S80', 'S80', 'S90']
Func=['func','func1','func2','func3','func4','func5', 'func6', 'func7', 'func8','func9']
Exos=liste_functions(S,_uid_)
printmd("**Exercices à **")
print("nbre d'exercices = ",len(Exos))
Note_exos = [0]*len(Exos)
print(Exos)
print("Nom des fonctions à ecrire")
print(Func)
Note_exos = [0]*(len(Exos))

8.1.5. Exemple: ecrire une fonction tq#

  • exo51

Given integers n and k, return a numpy array of length n containing 0 1 2 … k-1 0 1 2 … k-1 …

  • func0

implementation dans une fonction nommée func0

# solution
def func0(n,k):
    """Given integers n and k, return a numpy array of length n containing 0 1 2 ... k-1 0 1 2 ... k-1 ..."""
### SOLUTION
    L = np.zeros(n,dtype=int)
    K = np.arange(k,dtype=int)
    for i in range(0,n,k):
        if (i+k) > n :
            L[i:n]   = K[0:n-i]
        else :
            L[i:i+k] = L[0:k]
    return L
### SOLUTION

8.1.5.1. test de verification func#

  • func0(7,3) renvoie

      [0 1 2 0 1 2 0]

  • func0(6,2) renvoie

      [0 1 0 1 0 1]

8.1.5.2. test de validation#

dans le terminal tapez la commande suivante

     test_exo mon_pge.py exo51 func

8.1.6. Liste des exos à valider#

Pour chaque exercice (i de 1 à 9)

  • écrire la fonction funci correspondant à l’exercice exoxx avec l’éditeur dans le fichier mon_pge.py

  • dans le terminal, tapez la commande

     test_exo mon_pge.py exoxx funci

printmd("**Exercices à valider**")
# definition des fonctions
for k in range(1,len(Exos)):
    printmd("**Exercise {} fonction à écrire {}**".format(Exos[k],Func[k]))
    info_function(Exos[k])

8.1.7. Résolution des exercices dans le notebook#

8.1.7.1. Exercise : écrire une fonction func1#

printmd("### Exercise : écrire une fonction func0 t.q.")
nom = Exos[1]
info_function(nom)

#rentrer votre code pour func1
### BEGIN SOLUTION
### END SOLUTION
print("Test de Verification: appel de la fonction")
### BEGIN SOLUTION
### END SOLUTION

# test de validation
assert(check_function(func1,Exos[1]))

8.1.7.2. Exercise : écrire une fonction func2#

printmd("### Exercise: écrire une fonction func2 t.q.")
nom = Exos[2]
info_function(nom)

#rentrer votre code pour func2
### BEGIN SOLUTION
### END SOLUTION
print("Test de Verification: appel de la fonction")
### BEGIN SOLUTION
### END SOLUTION

# test de validation
assert(check_function(func2,Exos[2]))

8.1.7.3. Exercise : écrire une fonction func3#

printmd("### Exercise: écrire une fonction func3 t.q.")
nom = Exos[3]
info_function(nom)

#rentrer votre code pour func3
### BEGIN SOLUTION
### END SOLUTION
print("Test de Verification: appel de la fonction")
### BEGIN SOLUTION
### END SOLUTION

# test de validation
assert(check_function(func3,Exos[3]))

8.1.7.4. Exercise : écrire une fonction func4#

printmd("### Exercise: écrire une fonction func4 t.q.")
nom = Exos[4]
info_function(nom)

#rentrer votre code pour func4
### BEGIN SOLUTION
### END SOLUTION
print("Test de Verification: appel de la fonction")
### BEGIN SOLUTION
### END SOLUTION

# test de validation
assert(check_function(func4,Exos[4]))

8.1.7.5. Exercise : écrire une fonction func5#

printmd("### Exercise: écrire une fonction func5 t.q.")
nom = Exos[5]
info_function(nom)

#rentrer votre code pour func5
### BEGIN SOLUTION
### END SOLUTION
print("Test de Verification: appel de la fonction")
### BEGIN SOLUTION
### END SOLUTION

# test de validation
assert(check_function(func5,Exos[5]))

8.1.7.6. Exercise : écrire une fonction func6#

printmd("### Exercise: écrire une fonction func6 t.q.")
nom = Exos[6]
info_function(nom)

#rentrer votre code pour func6
### BEGIN SOLUTION
### END SOLUTION
print("Test de Verification: appel de la fonction")
### BEGIN SOLUTION
### END SOLUTION

# test de validation
assert(check_function(func6,Exos[6]))

8.1.7.7. Exercise : écrire une fonction func7#

printmd("### Exercise: écrire une fonction func7 t.q.")
nom = Exos[7]
info_function(nom)

#rentrer votre code pour func7
### BEGIN SOLUTION
### END SOLUTION
print("Test de Verification: appel de la fonction")
### BEGIN SOLUTION
### END SOLUTION

# test de validation
assert(check_function(func7,Exos[7]))

8.1.7.8. Exercise : écrire une fonction func8#

printmd("### Exercise: écrire une fonction func8 t.q.")
nom = Exos[8]
info_function(nom)

#rentrer votre code pour func8
### BEGIN SOLUTION
### END SOLUTION
print("Test de Verification: appel de la fonction")
### BEGIN SOLUTION
### END SOLUTION

# test de validation
assert(check_function(func8,Exos[8]))

8.1.7.9. Exercise : écrire une fonction func9#

printmd("### Exercise: écrire une fonction func9 t.q.")
nom = Exos[9]
info_function(nom)

#rentrer votre code pour func9
### BEGIN SOLUTION
### END SOLUTION
print("Test de Verification: appel de la fonction")
### BEGIN SOLUTION
### END SOLUTION

# test de validation
assert(check_function(func9,Exos[9]))

8.1.8. FIN#
Contenu