Semaine 7 - 420-SN1 - supplément

LES FONCTIONS

des travailleurs qui travaillent pour vous

Nous, les fonctions, on travaille pour vous

print()

input()

len()

round()

abs()

max()

Il existe plusieurs fonctions dites natives qu'on peut utiliser en les appelant, tout simplement. Personne ne vous a montré le code de print : vous l'appelez, il fait le travail.

Comment appelle-t-on un travailleur ?

Par son nom

On dit simplement son nom : round, len, max... suivi de parenthèses.

Avec un baluchon

On n'oublie pas de lui donner du matériel à travailler : des données, entre les parenthèses.

3.14159, 2 →

round(3.14159, 2)

Appel avec valeur

nomDeLaFonction(3)

Nous avons utilisé le nom de la fonction.

Nous lui avons passé une donnée en paramètre : son baluchon.

-10 →

abs(-10)

Appel avec plusieurs paramètres

nomDeLaFonction(0, 0, x, y)

Nous lui avons passé 4 paramètres : 2 valeurs et 2 variables. On sépare les paramètres par des virgules.

2, 5 →

max(2, 5)

Les travailleurs de Python

import random random.random() # sans baluchon

import math math.pow(2, 4) abs(-10) max(2, 5) math.floor(2.5) math.radians(90)

C'est la fonction qui a déjà décidé son nombre de paramètres. Il faut regarder la doc :

docs.python.org/fr/3/library/math.html

abs et max sont natives ; pow, floor et radians sont rangées dans le module math, qu'on importe d'abord.

Le ballon tombe à la poubelle

import math math.pow(2, 4) # 16.0... et le ballon tombe abs(-10) # 10... et le ballon tombe max(2, 5) # 5... et le ballon tombe math.floor(2.5) # 2... et le ballon tombe math.radians(90) # 1.5707963267948966... et le ballon tombe

16.0 ↓

C'est bien beau d'appeler des fonctions et de faire travailler les travailleurs. Mais si on laisse cela comme cela, c'est comme laisser le résultat du travail en plan, ne pas le cueillir.

pow()

abs()

max()

floor()

radians()

MERCI DE NE PAS GASPILLER NOTRE TRAVAIL !!!

Retour échappé = ballon perdu

On attrape le ballon

import math puissanceDeDeux : float = math.pow(2, 4) valeurAbsolue : int = abs(-10) maximum : int = max(2, 5) plancher : int = math.floor(2.5) radian : float = math.radians(90)

16.0 10 5 2 1.5707963267948966

↓ return

puissanceDeDeux

Lorsque la fonction s'est exécutée, son appel est comme remplacé par son résultat, qu'on attrape dans une variable ou qu'on utilise autrement : print(abs(-10)).

Dans l'ordre

PARAMÈTRE

x : int = calculerCube(variable)

On lui tend le baluchon : la valeur de variable (3).

EXÉCUTION

x : int = calculerCube(3)

Tout le code de la fonction s'exécute avec ce 3.

RETOUR

x : int = 27

Il relance le ballon : l'appel est remplacé par le résultat.

RÉCEPTION

x contient 27

On attrape le ballon dans une variable prévue à cet effet.

Le cycle appel - exécution - réception

def calculerCube(chiffre : int) -> int: print(chiffre) return chiffre * chiffre * chiffre temps : int = 7 r : int = calculerCube(temps) print(r)

temps verse son contenu dans le baluchon : c'est comme si chiffre : int = 7 était déclarée juste dans la fonction.

7 343

Le 7 vient du print(chiffre) ; le 343 est le ballon attrapé dans r.

Appel ou embauche ?

L'appel

C'est l'utilisation d'une fonction existante : on fait travailler un travailleur déjà embauché.

resultat : int = calculerCube(5)

L'implémentation

C'est quand on invente une nouvelle fonction avec un nouveau nom : on embauche. C'est là qu'on écrit son code.

def calculerCube(chiffre : int) -> int: cube : int = chiffre * chiffre * chiffre return cube

def : on l'embauche et on lui donne un nom

On commence par le mot-clé def.
Un nouveau nom, pas déjà utilisé, qui commence par un verbe et une minuscule.
Toujours des parenthèses (son baluchon), puis un deux-points.
Son code s'écrit en retrait : en Python, l'indentation remplace les accolades.

def calculerDouble(nombre : float) -> float: return nombre * 2

direBonjour() : les bras croisés

def direBonjour() -> None: print("Bonjour")

Ce code n'est jamais exécuté. Pourquoi ?

def direBonjour() -> None: print("Bonjour") direBonjour()

Bonjour

Personne ne l'avait appelé ! On l'appelle à partir du programme principal.

Tester à mesure = le plus important

On doit appeler la fonction dès que son squelette est fonctionnel, AVANT d'écrire le code dedans.

def calculerMoyenne(notes : list[float]) -> float: pass # le squelette : on remplira plus tard print(calculerMoyenne([72.0, 85.0, 90.0]))

None

pass ne fait rien : le ballon est vide (None), mais l'appel fonctionne. Le nom, les parenthèses et le baluchon sont bons : on peut écrire le calcul.

afficherCarre() : un baluchon, pas de ballon

def afficherCarre(chiffre : int) -> None: carre : int = chiffre * chiffre print(f"Le carré est {carre}") afficherCarre(3)

Le carré est 9

3 ↓

Le carré est affiché, mais pas retourné : le programme principal ne peut plus s'en servir.

calculerCube() : un baluchon ET un ballon

def calculerCube(chiffre : int) -> int: cube : int = chiffre * chiffre * chiffre return cube resultat : int = calculerCube(5) print(f"Cube de 5 est {resultat}")

Cube de 5 est 125

5 ↓

↓ 125

Son baluchon reste sur le chantier

def calculerCube(chiffre : int) -> int: return chiffre * chiffre * chiffre temps : int = 7 r : int = calculerCube(temps) print(chiffre)

NameError: name 'chiffre' is not defined

temps est copié dans chiffre le temps du travail ; ensuite chiffre disparaît.

def calculerCube(chiffre : int) -> int: print(temps) # lit temps, du dehors return chiffre * chiffre * chiffre temps : int = 7 r : int = calculerCube(2)

En Java, c'était une erreur. Python lit la variable du dehors : la fonction dépend d'un nom qu'elle ne contrôle pas. On lui tend plutôt un baluchon.

Quand embaucher un travailleur ?

Le même travail revient

Quand le même algorithme est réutilisé plus d'une fois, surtout si ce n'est pas en boucle : du code répété, ou qui se ressemble avec de petites différences.

Le code mérite un titre

Quand on a assez de code pour vouloir lui donner un titre : le nom de la fonction.

Permet d'écrire le code une seule fois, économise du temps de travail, met de l'ordre dans le code et le documente
Coûte un petit peu de temps d'exécution

Préparer la factorisation

1. Repérer les redondances

2. Ce qui est pareil

3. Ce qui est différent

4. Le différent en variables

temperatureMatin : float = 12.0 print(temperatureMatin * 9 / 5 + 32) temperatureMidi : float = 21.5 print(temperatureMidi * 9 / 5 + 32) temperatureSoir : float = 16.0 print(temperatureSoir * 9 / 5 + 32)

def convertirEnFahrenheit(celsius : float) -> float: return celsius * 9 / 5 + 32 print(convertirEnFahrenheit(12.0)) print(convertirEnFahrenheit(21.5)) print(convertirEnFahrenheit(16.0))

Ce qui différait (12.0, 21.5, 16.0) devient le baluchon celsius. Les deux programmes affichent la même chose : 53.6, 70.7, 60.8.

AU TRAVAIL !

On l'appelle par son nom, on lui tend son baluchon, on attrape son ballon