Cours d'introduction au langage de programmation Python

N.B. Niveau : Terminale S, enseignement de spécialité ISN (Informatique et Sciences du Numérique)

Chapitre 4 - Les fonctions

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 F(DegreCelsius):
	print (DegreCelsius*9.0/5.0+32.0)

>>> F(100)
212.0
>>> F(37)
98.6
>>> x = 233
>>> F(x)
451.4

Rien ne vous oblige à définir des fonctions dans vos scripts, mais cela est tellement pratique qu'il serait bête de s'en passer !

L'instruction `def`

Syntaxe :

def NomDeLaFonction(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 TirageDe():
    """ Retourne un nombre entier aléatoire entre 1 et 6 """
    import random
    valeur = random.randint(1,6)
    return valeur

>>> print (TirageDe())
3
>>> print (TirageDe())
6
>>> a = TirageDe()
>>> print (a)
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 TirageDe():
    """ 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 :',TirageDe())

>>>
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 TirageDe2(valeurMin,valeurMax):
    """ Retourne un nombre entier aléatoire entre valeurMin et valeurMax """
    import random
    return random.randint(valeurMin,valeurMax)

# début du programme
for i in range(5):
    print (TirageDe2(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 TirageMultipleDe(NbTirage):
    """ Retourne une liste de nombres entiers aléatoires entre 1 et 6 """
    import random
    resultat = [random.randint(1,6) for i in range(NbTirage)]	# compréhension de listes (Cf. annexe)
    return resultat

# début du programme
print (TirageMultipleDe(10))

>>>
[4, 1, 3, 3, 2, 1, 6, 6, 2, 5]

>>> help(TirageMultipleDe)
Help on function TirageMultipleDe in module __main__:

TirageMultipleDe(NbTirage)
    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 impaire')
        return
    if (nombre % 2) == 0:
        print (nombre,'est paire')
        return

# début du programme
Parite(13)
Parite(24)

>>>
13 est impaire
24 est paire

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

La 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.

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 modifier le contenu d'une variable sans s'en rendre compte, surtout dans les gros programmes).

Exemple d'optimisation du programme permettant de compter le nombre de mentions :

import sqlite3

#  déclaration des variables

conn=sqlite3.connect("notes.db")
c = conn.cursor()
mentions={'refusés':[0,10],'admis':[10,12],'assez bien':[12,14],'bien':[14,16],'très bien':[16,20.1]}

# Fonction permettant de compter le nombre d'élèves compris dans l'encadrement souhaité

def compte(encadrement):
    global c
    min=str(encadrement[0])
    max=str(encadrement[1])
    i=0
    for ligne in c.execute('select * from notes where Note>='+ min+' and Note<'+ max):
        i+=1
    return(i)

# programme principal :

for mention in mentions:
    print (mention,':', compte(mentions[mention]))

Exercices

Exercice 4.1 ☆
1) Ecrire une fonction qui retourne la valeur de la fonction mathématique f(x)=27x³ -27x² -18x +8 :

>>> print f(0),f(1),f(0.5),f(0.25),f(0.375)
8.0 -10.0 -4.375 2.234375 -1.123046875

2) implanter la fonction f(x) dans le programme ci-dessous :

import matplotlib.pyplot as plt

xa=[]			#Liste qui contiendra les abscisses des coordonnées de la fonction 2*x
ya=[]			#Liste qui contiendra les abscisses des coordonnées de la fonction 2*x
x=-1	
while x<=2:
    xa.append(x)	# ajouter x dans la liste
    ya.append(2*x)	# ajouter 2*x dans la liste
    x+=0.1

plt.plot(xa,ya,)  	# Place les points sur le graphique

plt.show()		# Affiche le graphique

Exercice 4.2 ★

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.3 ★
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)

Exercice 4.4 ★ Ecrire une fonction qui retourne une grille de numéros du jeu Euro Millions.
On utilisera la fonction sample() du module random.

>>> print Loto()
[37, 23, 9, 11, 49, 2]
>>> print Loto()
[16, 32, 6, 30, 40, 6]

La recurcivité

Un algorithme est dit récursif s'il s'appelle lui-même

Exercice 4.5 ★ Ecrire la fonction correspondant à l'agorithme suivant :

Algorithme de la factorielle récurcive

fonction factorielle(n):

si n=1 ou 0 alors on retourne la valeur 1

sinon on retourne la valeur n*factorielle(n-1)

Exercice 4.6 ★★

Réaliser à l’aide d’une procédure récursive les dessins suivants :

un colimaçon	l'arbre binaire
On réduit la longueur du segment de 10 à chaque appel de la fonction si la longueur du segment est > 5	La première branche (de longueur 50) sera faite avant l'appel de la fonction. On choisi la longueur de la seconde branche et les branches suivantes seront divisée par 2

Vous utiliserez la module turtle qui mermet de dessiner des lignes ou des cercles

Exemple : taper le programme ci-dessous dans la console Pyton, cela permettra de suivre ce qui se passe au fur et à mesure.

>>> From turtle import* 
>>> forward(120)
>>> left(90)
>>> color('red')
>>> forward(80)

Liste des pricipales fonctions du module turtle :

• reset()	On efface tout et on recommence
• goto(x,y)	Aller à l'endroit de coordonnées x et y
• forward(distance)	Avancer d'une distance donnée
• backward(distance)	Reculer
• up()	Relever le crayon (pour pouvoir avancer sans dessiner)
• down()	Abaisser le crayon (pour pouvoir recommencer à dessiner)
• color(couleur)	Couleur peut être une chaîne prédéfinie ('red', 'blue', 'green', etc.)
• left(angle)	Tourner à gauche d'un angle donné (exprimé en degré)
• right(angle)	Tournerà droite
• width(épaisseur)	Choisir l'épaisseur du tracé
• write(texte)	texte doit être une chaîne de caractères délimitée avec des " ou des '
• setup(coordonnées)	Ex : setup(width=300,height=300,startx=0,starty=0)

Contenu sous licence CC BY-NC-SA 3.0
Fabrice Sincère ; version 1.3.5.29
Modifié et adapté par Pascal Hassenforder 31/10/2014