Nous avons déjà vu beaucoup de fonctions : print(), type(), len(), input(), range()...
Ce sont des fonctions pré-définies (built-in functions).
Nous avons aussi la possibilité de créer nos propres fonctions !
Intérêt des fonctions
Une fonction est une portion de code que l'on peut appeler au besoin (c'est une sorte de sous-programme).
L'utilisation des fonctions évite des redondances dans le code : on obtient ainsi des programmes plus courts et plus lisibles.
Par exemple, nous avons besoin de convertir à plusieurs reprises des degrés Celsius en degrés Fahrenheit :
>>> print(100.0*9.0/5.0 + 32.0) 212.0 >>> print(37.0*9.0/5.0 + 32.0) 98.6 >>> print(233.0*9.0/5.0 + 32.0) 451.4
La même chose en utilisant une fonction :
>>> def fahrenheit(degre_celsius): """ Conversion degré Celsius en degré Fahrenheit """ print(degre_celsius*9.0/5.0 + 32.0) >>> fahrenheit(100) 212.0 >>> fahrenheit(37) 98.6 >>> temperature = 233 >>> fahrenheit(temperature) 451.4
Rien ne vous oblige à définir des fonctions dans vos scripts, mais cela est tellement pratique qu'il serait improductif de s'en passer !
L'instruction def
Syntaxe
def nom_de_la_fonction(parametre1, parametre2, parametre3, ...): """ Documentation qu'on peut écrire sur plusieurs lignes """ # docstring entouré de 3 guillemets (ou apostrophes) bloc d'instructions # attention à l'indentation return resultat # la fonction retourne le contenu de la variable resultat
Exemple n°1
# script Fonction1.py def mapremierefonction(): # cette fonction n'a pas de paramètre """ Cette fonction affiche 'Bonjour' """ print("Bonjour") return # cette fonction ne retourne rien ('None') # l'instruction return est ici facultative
Une fois la fonction définie, nous pouvons l'appeler :
>>> mapremierefonction() # ne pas oublier les parenthèses () Bonjour
L'accès à la documentation se fait avec la fonction pré-définie help() :
>>> help(mapremierefonction) # affichage de la documentation Help on function mapremierefonction in module __main__: mapremierefonction() Cette fonction affiche 'Bonjour'
Exemple n°2
La fonction suivante simule le comportement d'un dé à 6 faces.
Pour cela, on utilise la fonction randint() du module random.
# script Fonction2.py def tirage_de(): """ Retourne un nombre entier aléatoire entre 1 et 6 """ import random valeur = random.randint(1, 6) return valeur
>>> print(tirage_de()) 3 >>> print(tirage_de()) 6 >>> resultat = tirage_de() >>> print(resultat) 1
Exemple n°3
# script Fonction3.py # définition des fonctions def info(): """ Informations """ print("Touche q pour quitter") print("Touche Enter pour continuer") def tirage_de(): """ Retourne un nombre entier aléatoire entre 1 et 6 """ import random valeur = random.randint(1, 6) return valeur # début du programme info() while True: choix = input() if choix == 'q': break print("Tirage :", tirage_de())
>>> Touche q pour quitter Touche Enter pour continuer Tirage : 5 Tirage : 6 q >>>
Exemple n°4
Une fonction avec deux paramètres :
# script Fonction4.py # définition de fonction def tirage_de2(valeur_min, valeur_max): """ Retourne un nombre entier aléatoire entre valeur_min et valeur_max """ import random return random.randint(valeur_min, valeur_max) # début du programme for i in range(5): print(tirage_de2(1, 10)) # appel de la fonction avec les arguments 1 et 10
>>> 6 7 1 10 2 >>>
Exemple n°5
Une fonction qui retourne une liste :
# script Fonction5.py # définition de fonction def tirage_multiple_de(nombretirage): """ Retourne une liste de nombres entiers aléatoires entre 1 et 6 """ import random resultat = [random.randint(1, 6) for i in range(nombretirage)] # compréhension de listes (Cf. annexe) return resultat # début du programme print(tirage_multiple_de(10))
>>> [4, 1, 3, 3, 2, 1, 6, 6, 2, 5]
>>> help(tirage_multiple_de) Help on function tirage_multiple_de in module __main__: tirage_multiple_de(nombretirage) Retourne une liste de nombres entiers aléatoires entre 1 et 6
Exemple n°6
Une fonction qui affiche la parité d'un nombre entier.
Il peut y avoir plusieurs instructions return dans une fonction.
L'instruction return provoque le retour immédiat de la fonction.
# script Fonction6.py # définition de fonction def parite(nombre): """ Affiche la parité d'un nombre entier """ if nombre%2 == 1: # L'opérateur % donne le reste d'une division print(nombre, 'est impair') return if nombre%2 == 0: print(nombre, 'est pair') return
>>> parite(13) 13 est impair >>> parite(24) 24 est pair
Portée de variables : variables globales et locales
La portée d'une variable est l'endroit du programme où on peut accéder à la variable.
Observons le script suivant :
a = 10 # variable globale au programme def mafonction(): a = 20 # variable locale à la fonction print(a) return
>>> print(a) # nous sommmes dans l'espace global du programme 10 >>> mafonction() # nous sommes dans l'espace local de la fonction 20 >>> print(a) # de retour dans l'espace global 10
Nous avons deux variables différentes qui portent le même nom a
Une variable a de valeur 20 est créée dans la fonction : c'est une variable locale à la fonction.
Elle est détruite dès que l'on sort de la fonction.
global
L'instruction global rend une variable globale :
a = 10 # variable globale def mafonction(): global a # la variable est maintenant globale a = 20 print(a) return
>>> print(a) 10 >>> mafonction() 20 >>> print(a) 20
Remarque : il est préférable d'éviter l'utilisation de l'instruction global car c'est une source d'erreurs (on peut ainsi modifier le contenu d'une variable globale en croyant agir sur une variable locale).
La sagesse recommande donc de suivre la règle suivante :
- ne jamais affecter dans un bloc de code local une variable de même nom qu'une variable globale
Annexe : la compréhension de listes
La compréhension de listes est une structure syntaxique disponible dans un certain nombre de langages de programmation, dont Python.
C'est une manière de créer efficacement des listes.
Revenons sur l'exemple vu dans le script Fonction5.py :
resultat = [random.randint(1, 6) for i in range(10)]
>>> print(resultat) [3, 1, 5, 6, 4, 2, 1, 1, 3, 1]
Autre exemple : liste de carrés
carres = [i*i for i in range(11)]
>>> print(carres) [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
La compréhension de listes évite donc d'écrire le code "classique" suivant :
carres = []
for i in range(11):
carres.append(i*i)
Exercices
Exercice 4.1 ☆
1) Ecrire une fonction carre() qui retourne le carré d'un nombre :
>>> print(carre(11.11111)) 123.4567654321
2) Avec une boucle while et la fonction carre(), écrire un script qui affiche le carré des nombres entiers de 1 à 100 :
>>> 1² = 1 2² = 4 3² = 9 ... 99² = 9801 100² = 10000 Fin du programme
Exercice 4.2 ☆
1) Ecrire une fonction qui retourne l'aire de la surface d'un disque de rayon R.
Exemple :
>>> print(airedisque(2.5)) 19.6349540849
2) Ajouter un paramètre qui précise l'unité de mesure :
>>> print(airedisque2(4.2, 'cm')) 55.4176944093 cm²
Exercice 4.3 ★
1) Ecrire une fonction qui retourne la factorielle d'un nombre entier N.
On rappelle que : N ! = 1×2×...×(N-1)×N
Exemple :
>>> print(factorielle(50)) 30414093201713378043612608166064768844377641568960512000000000000
2) Comparez avec le résultat de la fonction factorial() du module math.
Exercice 4.4 ★
1) A l'aide de la fonction randint() du module random, écrire une fonction qui retourne un mot de passe de longueur N (chiffres, lettres minuscules ou majuscules).
On donne :chaine = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
>>> print(password(10)) mHVeC5rs8P >>> print(password(6)) PYthoN
2) Reprendre la question 1) avec la fonction choice() du module random.
Pour obtenir de l'aide sur cette fonction :
>>> import random >>> help(random.choice)
3) Quel est le nombre de combinaisons possibles ?
4) Quelle durée faut-il pour casser le mot de passe avec un logiciel capable de générer 1 million de combinaisons par seconde ?
Lien utile : www.exhaustif.com/Generateur-de-mot-de-passe-en.html
Exercice 4.5 ★ Ecrire une fonction qui retourne une carte (au hasard) d'un jeu de Poker à 52 cartes.
On utilisera la fonction choice() ou randint() du module random.
On donne :ListeCarte = ['2s','2h','2d','2c','3s','3h','3d','3c','4s','4h','4d','4c','5s','5h','5d','5c', '6s','6h','6d','6c','7s','7h','7d','7c','8s','8h','8d','8c','9s','9h','9d','9c', 'Ts','Th','Td','Tc','Js','Jh','Jd','Jc','Qs','Qh','Qd','Qc','Ks','Kh','Kd','Kc','As','Ah','Ad','Ac']
>>> print(tiragecarte()) 7s >>> print(tiragecarte()) Kd
Exercice 4.6 ★★
1) Ecrire une fonction qui retourne une liste de N cartes différentes d'un jeu de Poker à 52 cartes.
Noter qu'une fonction peut appeler une fonction : on peut donc réutiliser la fonction tiragecarte()de l'exercice précédent.
Exemple :
>>> print(tirage_n_carte(2)) ['As', 'Ah'] >>> print(tirage_n_carte(25)) ['Jc', 'Jh', 'Tc', '2d', '3h', 'Qc', '8d', '7c', 'As', 'Td', '8h', '9c', 'Ad', 'Qh', 'Kc', '6s', '5h', 'Qd', 'Kh', '9h', '5d', 'Js', 'Ks', '5c', 'Th']
2) Simplifier le script avec la fonction shuffle() ou sample() du module random.
Exercice 4.7 ★ Ecrire une fonction qui retourne une grille de numéros du jeu Euro Millions.
On utilisera la fonction sample() du module random.
>>> print(euromillions()) [37, 23, 9, 11, 49, 2, 11] >>> print(euromillions()) [16, 32, 8, 30, 40, 6, 4]
Source :
http://fsincere.free.fr/isn/python/cours_python_ch4.php