Programmation Impérative Fonctions et Python+

Différence Entre Programme et Fonction
Programme
Programmation Impérative
Fonctions et Python+
un fichier .py entier
exécuté depuis bash, avec python lefichier.py p1 p2 p3 …
des paramètres dont la valeur est tapée dans le terminal
des paramètres accessibles avec la liste sys.argv
des paramètres forcément chaînes de caractères
interrompu par exit()
Fonction
définie dans une partie d'un fichier .py
appelée n'importe où en python, avec la_fonction(p1,p2,p3)
des paramètres dont la valeur est calculée à l'appel de la fonction
des paramètres qui sont des valeurs/objets python
des paramètres accessibles avec leurs noms
des paramètres de n'importe quel type
interrompue par return
une valeur de retour (ou None )
5 / 35 − Rémi Emonet − Programmation Impérative Fonctions et Python+
Programmation Impérative 7 : Plan
Rappel sur les Fonctions en Python
Fonctions et Programmes
Fonctions Comme Outils d'Abstraction
Paramètres par Défauts
Autres Éléments en Python
Programme Sans Fonctions
1
2
3
4
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
6 / 35 − Rémi Emonet − Programmation Impérative Fonctions et Python+
planetes = [ # x, y,
masse,
nom
[0, 0,
5.9736E24, "terre"],
[3.844E6, 0, 7.3477E22, "lune"]
G = 6.6742E-11 * 1E-6 # N km2 kg-2
]
1 def info_bob(bob, bobm):
2
for pl in planetes:
3
dx = pl[0] - bob[0]
4
dy = pl[1] - bob[1]
5
d = (dx * dx + dy * dy)**0.5
6
print("Bob est a", d, "km du centre de", pl[3])
7
8
somme_forces = [0, 0]
9
for pl in planetes:
10
dx = pl[0] - bob[0]
11
dy = pl[1] - bob[1]
12
d = (dx * dx + dy * dy)**0.5
13
u = [dx / d, dy / d] # vecteur unitaire
14
df = [-G * bobm * pl[2] / d / d * u[0],
15
-G * bobm * pl[2] / d / d * u[1]]
16
somme_forces = [somme_forces[0] + df[0],
17
somme_forces[1] + df[1]]
18
19
print("Somme des forces sur Bob :", somme_forces, "newtons")
20
21 info_bob([0, 6378.137], 100)
22 info_bob([6378.137, 0], 100)
9 / 35 − Rémi Emonet − Programmation Impérative Fonctions et Python+
]
bob = [0, 6378.137] # km
bobm = 100 # kg
for pl in planetes:
dx = pl[0] - bob[0]
dy = pl[1] - bob[1]
d = (dx * dx + dy * dy)**0.5
print("Bob est a", d, "km du centre de", pl[3])
somme_forces = [0, 0]
for pl in planetes:
dx = pl[0] - bob[0]
dy = pl[1] - bob[1]
d = (dx * dx + dy * dy)**0.5
u = [dx / d, dy / d] # vecteur unitaire
df = [-G * bobm * pl[2] / d / d * u[0],
-G * bobm * pl[2] / d / d * u[1]]
somme_forces = [somme_forces[0] + df[0],
somme_forces[1] + df[1]]
print("Somme des forces sur Bob :", somme_forces, "newtons")
8 / 35 − Rémi Emonet − Programmation Impérative Fonctions et Python+
Fonctions : Répétitions Contrôlées
1
2
3
4
planetes = [ # x, y,
masse,
nom
[0, 0,
5.9736E24, "terre"],
[3.844E6, 0, 7.3477E22, "lune"]
G = 6.6742E-11 * 1E-6 # N km2 kg-2
Fonctions : Ne Pas Se Répéter
1
2
3
4
planetes = [ # x, y,
masse,
nom
[0, 0,
5.9736E24, "terre"],
[3.844E6, 0, 7.3477E22, "lune"]
G = 6.6742E-11 * 1E-6 # N km2 kg-2
]
1 def dist(a, b):
2
dx = b[0] - a[0]
3
dy = b[1] - a[1]
4
return ( dx**2 + dy**2 )**0.5
5
6 def info_bob(bob, bobm):
7
for pl in planetes:
8
d = dist(pl, bob)
9
print("Bob est a", d, "km du centre de", pl[3])
10
11
somme_forces = [0, 0]
12
for pl in planetes:
13
d = dist(pl, bob)
14
u = [ (pl[0] - bob[0]) / d, (pl[1] - bob[1]) / d]
15
df = [-G * bobm * pl[2] / d / d * u[0],
16
-G * bobm * pl[2] / d / d * u[1]]
17
somme_forces = [somme_forces[0] + df[0],
18
somme_forces[1] + df[1]]
19
20
print("Somme des forces sur Bob :", somme_forces, "newtons")
21
22 info_bob([0, 6378.137], 100)
10 / 35 − Rémi Emonet − Programmation Impérative Fonctions et Python+
Fonctions : Meilleures Abstractions
1
2
3
4
planetes = [ # x, y,
masse,
nom
[0, 0,
5.9736E24, "terre"],
[3.844E6, 0, 7.3477E22, "lune"]
G = 6.6742E-11 * 1E-6 # N km2 kg-2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
]
def vec_mad(m, a, b = [0,0]): # retourne m*a + b (en 2d)
return [ m*a[0]+b[0], m*a[1]+b[1] ]
def dist(a, b):
d = vec_mad(-1, a, b)
return ( d[0]**2 + d[1]**2 )**0.5
def info_bob(bob, bobm):
for pl in planetes:
d = dist(pl, bob)
print("Bob est a", d, "km du centre de", pl[3])
somme_forces = [0, 0]
for pl in planetes:
d = dist(pl, bob)
u = vec_mad(-1, bob, pl) # pl - bob
u = vec_mad(1/d, u)
# u / d
df = vec_mad(-G * bobm * pl[2] / d / d, u)
somme_forces = vec_mad(1, somme_forces, df)
Programmation Impérative 7 : Plan
Rappel sur les Fonctions en Python
Fonctions et Programmes
Fonctions Comme Outils d'Abstraction
Paramètres par Défauts
Autres Éléments en Python
print("Somme des forces sur Bob :", somme_forces, "newtons")
info_bob([0, 6378.137], 100)
11 / 35 − Rémi Emonet − Programmation Impérative Fonctions et Python+
25 / 35 − Rémi Emonet − Programmation Impérative Fonctions et Python+
Valeurs de Paramètres par Défaut
Paramètres Nommés (culture)
But
But
rendre certains paramètres optionnels
leurs donner des valeurs par défaut
Exemples
1
2
3
4
5
6
7
def puissance(a, b=2):
return a**b
1
2
3
4
5
6
7
def somme(a, b, c=0, d=0):
return a+b+c+d
# utilisation de la fonction
print( puissance(10, 2) ) # 100
print( puissance(10, 3) ) # 1000
print( puissance(10) )
# 100
# utilisation de
print( somme(10,
print( somme(10,
print( somme(10,
la
2)
2,
2,
fonction
)
# 12
5) )
# 17
5, 100) ) # 117
ne fournir de valeur que pour certains paramètres
garder les autres paramètres par défaut
ne pas être limité aux derniers paramètres par défaut
Exemple
1 def puissance(a=-1, b=2):
2
"retourne a puissance b, avec a=-1 et b=2 par défaut"
3
return a**b
Comment l'appeler en ne passant que b ?
1 print( puissance(b=10) ) # 1
Déjà vu avec print
1 print("hello", "world", sep="!!!")
# hello!!!world
Note : on ne peut omettre que le(s) dernier(s) paramètre(s)
26 / 35 − Rémi Emonet − Programmation Impérative Fonctions et Python+
27 / 35 − Rémi Emonet − Programmation Impérative Fonctions et Python+
Programmation Impérative 7 : Plan
Bonnes Pratiques
Rappel sur les Fonctions en Python
Fonctions et Programmes
Fonctions Comme Outils d'Abstraction
Paramètres par Défauts
Autres Éléments en Python
Toujours
bien nommer les variables
tester vos fonctions avec différentes entrées
tester vos programmes avec différentes entrées
ajouter des variables intermédiaires
éviter les expressions trop longues
éviter de répéter des expressions récurrentes
lire les messages d'erreur
Dans un programme
mettre les import au départ
ne pas abuser de from .... import * (l'étoile)
mettre les définitions de fonctions ensuite
mettre le corps du programme à la fin
Dans une fonction
bien nommer la fonction
bien nommer les paramètres
ne pas oublier le return (si besoin)
éviter d'accéder à des variables globales
28 / 35 − Rémi Emonet − Programmation Impérative Fonctions et Python+
29 / 35 − Rémi Emonet − Programmation Impérative Fonctions et Python+
Boucle et Court-Circuit continue
Compréhension de Listes (culture)
Rappel : break
Cas d'utilisation
on veut parcourir une liste
calculer une valeur pour chaque élément
et remplir une nouvelle liste
interrompt une boucle
Instruction continue
passe à l'itération suivante de la boucle
Exemple : qu'affiche le programme suivant ?
1 for i in range(100):
2
if i % 3 == 1:
3
continue
4
if i == 8:
5
break
6
print(i)
0, 2, 3, 5, 6
Version « classique »
1 premiers = [2, 3, 5, 7, 11]
2 carres = []
3 for n in premiers:
4
carres.append(n*n)
Compréhension de liste
1 premiers = [2, 3, 5, 7, 11, 13]
2 carres = [n*n for n in premiers]
et avec i == 7 à la place de i == 8 ?
Compréhension de liste avec condition
1 def premier(n):
2
...
3 carres = [n*n for n in range(15) if premier(n)]
30 / 35 − Rémi Emonet − Programmation Impérative Fonctions et Python+
31 / 35 − Rémi Emonet − Programmation Impérative Fonctions et Python+
Dictionnaires (culture)
Tuples, n-uplets (culture)
Dictionnaire = conteneur associatif
Motivation : paire, triplet, quadruplet
associe une valeur (de type quelconque) à une clé
exemple:
grouper des valeurs ensemble
comme une liste, mais non-mutable (constant)
utilisable aussi avec for , len() , ...
"lundi" -> "semaine"
"mardi" -> "semaine"
...
"dimanche" -> "week-end"
Définition de dictionnaire
1 dico = {"lundi": "semaine", "mardi": "semaine",
2
"dimanche": "week-end"}
Accès à un dictionnaire
1 print(dico["mardi"])
2 #
dico["jamais"] # <- erreur, clé non existante
Notation : comme un liste mais avec des parenthèses
1
2
3
Dé-construction de tuples (et de listes)
1
2
3
4
a,b = ("hello", 12345)
print(a) # hello
a,b = (b,a)
print(a) # 12345
Pour retourner plusieurs valeurs
Ajout à un dictionnaire
1 dico["LUNDI"] = "semaine"
tup = ("hello", 12345, "poum")
print(tup[0]) # hello
print(tup[1]) # 12345
1
2
3
def nimp(): return ("hello", 12345)
a,b = nimp()
32 / 35 − Rémi Emonet − Programmation Impérative Fonctions et Python+
33 / 35 − Rémi Emonet − Programmation Impérative Fonctions et Python+
Gestion d'Erreur (culture)
Motivation
ne pas s'interrompre abruptement en cas d'erreur
gérer les erreurs « d'entrées utilisateur »
Exemple typique
input() renvoie une chaîne de caractères
la valeur doit être convertie si on veut un nombre
(ou, autre exemple, on attend uniquement "oui" ou "non")
1
2
3
4
nb_str = input("Entrez un nombre : ") # ex: '5'
msg = input("Entrez un message : ") # ex: 'Poum Tchak'
nb = int(nb_str) # erreur si nb_str ne représente pas un entier
print(nb * msg)
Gestion d'erreur avec try / except
1
2
3
4
5
6
7
8
nb_str = input("Entrez un nombre : ")
msg = input("Entrez un message : ")
try: # essayer d'exécuter le code ci-dessous
nb = int(nb_str)
except: # s'il y a eu une erreur
print("Hum... ", nb_str, " pas entier ?")
exit()
print(nb * msg)
34 / 35 − Rémi Emonet − Programmation Impérative Fonctions et Python+
Points Clés
Rappel de définition de fonction en python
Différence entre programme et fonction
Fonction comme outil d'abstraction
Paramètres optionnels et valeurs par défaut
Instruction continue
Compréhension de listes
Dictionnaires
Tuples (n-uplets)
Gestion d'erreur avec try / except
35 / 35 − Rémi Emonet − Programmation Impérative Fonctions et Python+