Les fonctions dans Python

Les fonctions dans Python

Définition 1.
Une fonction est un mini-programme issue d’une bibliothèque ou défini “sur place” dans le programme en cours. Une fonction utilise ou non une ou plusieurs variables $a_1$, $a_2$,… appelés les paramètres ou les arguments de la fonction, comme suit :

def nomDeLaFonction(liste de paramètres) :
$\qquad$ Bloc d’instructions
$\qquad$ $\ldots$
$\qquad$ Calcul du résultat $y$ à afficher
$\qquad$ return $y$

Le contenu de la définition est entièrement décalé par un alinéa, une tabulation, équivalente à 4 espaces.
Le résultat de la fonction est renvoyé par l’instruction return $y$. Ce résultat peut être une valeur numérique, une chaîne de caractère ou une liste de valeurs.
Une fonction peut être utilisée pour définir ou utiliser une autre fonction.

Exemples

Exercice n°1.
Créer une fonction f() qui, pour tout réel $x$ donné, permet de calculer et d’afficher le double de son carré, augmenté de 1. Autrement dit : $f(x)=2x^2+1$.

La fonction carre() est définie par :

def f(x) $\qquad$ $\qquad$ # IN : x un float (décimal). OUT : image de x par f
$\qquad$ y=2*x**2+1 $\qquad$ # Calculer le carré et l’affecter à y
$\qquad$ return y $\qquad$ # Afficher le résultat.

>>> f(9)
163


Exercice n°2.
Créer une fonction g() définie par morceaux, pour tout réel $x$ donné, on a : $$g(x)=\left\{\begin{array}{ll}
2x+3 & \text{si } x<0\\ x^2+3 & \text{si } 0\leqslant x<2\\ x-7 & \text{si } x\geqslant2\\ \end{array}\right.$$
La fonction $g$ est-elle continue sur $\R$ ?

La fonction g() est définie par morceaux. On doit donc utiliser des instructions conditionnelles. Si, SinonSi et Sinon. Autrement dit : if, elif et else.

def g(x) : $\qquad$ $\qquad$ # IN : x un float (décimal). OUT : image de x par g
$\qquad$ if x<0 :
$\qquad$ $\qquad$ return 2*x+3
$\qquad$ elif x<2 : $\qquad$ $\qquad$ # Ici, on a déjà x>=0.
$\qquad$ $\qquad$ return x^2+3
$\qquad$ else :
$\qquad$ $\qquad$ return x+5

>>> g(-5)
-7

>>> g(1)
4

>>> g(9)
14


Exercice n°3.
Créer une fonction Delta() pour calculer le discriminant d’une équation du second degré de coefficients a,b,c.

On doit d’abord s’assurer qu’il s’agit bien d’une équation du second degré, donc que le coefficient ” a ” est non nul.

def Delta(a,b,c) $\qquad$ # IN : a,b,c trois float (décimaux). OUT : image de (a,b,c) par Delta
$\qquad$ if a==0 :
$\qquad$ $\qquad$ print(“Entrez un triplet valable pour une équation du second degré avec a non nul”)
$\qquad$ else :
$\qquad$ $\qquad$ d= b**2-4*a*c $\qquad$ # Calculer le Delta
$\qquad$ return print(“Delta=”,d) $\quad$ # Afficher le résultat.

>>> Delta(1,-4,3)
4

>>> Delta(0,5,2)
Entrez un triplet valable pour une équation du second degré avec a non nul


Exercice n°4.
Créer une fonction Somme(n) qui calcule la somme des $n$ premiers nombres entiers non nuls.

On crée une séquence d’indices de 1 à $n$, avec la fonction range() ; et un accumulateur (un panier) $S$ pour y mettre la somme des termes consécutifs.

def Somme(n) : $\qquad$ $\qquad$ # IN : x un int (entier). OUT : image de n par Somme()
$\qquad$ if n==int(n) : $\qquad$ $\qquad$ # On test si $n$ est un entier
$\qquad$ $\qquad$ S=0 $\qquad$ $\qquad$ $\quad$ # On initialise S
$\qquad$ $\qquad$ for k in range(1,n+1) : $\qquad$ # 1=début, n+1 valeur finale exclue
$\qquad$ $\qquad$ $\quad$ S=S+k $\qquad$ $\qquad$ # Calculer la nouvelle valeur de S
$\qquad$ $\qquad$ return print(“S=”,S) $\qquad$ # Afficher le résultat.
$\qquad$ else :
$\qquad$ $\qquad$ return print(“Entrez un nombre entier naturel n”) $\qquad$ # Afficher le commentaire.

>>> Somme(100)
5050

>>> Somme(50.25)
Entrez un nombre entier naturel n


Exercice n°5.
Créer une fonction Liste_des_termes(n) qui donne la liste des termes d’une suite explicite ($u_n$) définie par : $u_n=n^2+1$

def liste_des_termes(N) : $\qquad$ $\qquad$ # IN : N un int (entier). OUT : Une liste, image de N
$\qquad$ u=0
$\qquad$ L=[$\,$]
$\qquad$ for i in range(1,N+1) :
$\qquad$ $\qquad$ u=i**2+1 $\qquad$ $\quad$ # Calculer la nouvelle valeur de u
$\qquad$ $\qquad$ L.append(u) $\qquad$ # Rajouter la nouvelle valeur de u à la Liste
$\qquad$ return L $\qquad$ $\qquad$ # Afficher le résultat.

>>> liste_des_termes(10)
[2, 5, 10, 17, 26, 37, 50, 65, 82, 101]


Exercice n°6.
Créer une fonction Liste_des_termes(n) qui donne la liste des termes d’une suite récurrente ($u_n$) définie par : $u_0=1$ $u_n=\sqrt{4u_n+3}$

Pour utiliser la fonction mathématique sqrt(), il faut l’importer à partir du module math avec l’instruction : from math import sqrt, ou utiliser aussi l’instruction from math import *.

from math import sqrt
def liste_des_termes(N) : $\qquad$ $\qquad$ # IN : N un int (entier). OUT : Une liste, image de N
$\qquad$ L=[$\,$]
$\qquad$ u=1
$\qquad$ for i in range(1,N+1) :
$\qquad$ $\qquad$ u=sqrt(4*u+3)
$\qquad$ $\qquad$ L.append(u) $\qquad$ # Rajouter la nouvelle valeur de u à la Liste
$\qquad$ return L $\qquad$ $\qquad$ # Afficher le résultat.

>>> liste_des_termes(10)
… à refaire


Exercice n°7.
Créer une fonction Liste_des_termes(n) qui donne la liste des termes d’une suite récurrente ($u_n$) définie par : $u_0=1$ $u_n=\sqrt{4u_n+3}$

5°) On considère la suite explicite $(u_n)$ définie par $u_n=1.085^n$. On démontre que cette suite est strictement croissante et non majorée. Donc, elle tend vers $+\infty$ lorsque $n$ tend vers $+\infty$.
Créer une fonction seuil(n) qui donne le premier nombre entier $n$ pour lequel : $u_n>p$ . Calculer seuil(10).

def seuil(p) : $\qquad$ $\qquad$ # IN : x un float (décimal). OUT : Un entier, image de p
$\qquad$ n=0
$\qquad$ u=0
$\qquad$ while u < p :
$\qquad$ $\qquad$ n =n+1
$\qquad$ $\qquad$ u = 1.085**n $\qquad$ # Calculer la nouvelle valeur de u
$\qquad$ return(n) $\qquad$ $\qquad$ # Afficher le résultat.

>>> seuil(10)
29


Exercice n°8.
On considère la suite récurrente $(u_n)$ définie par : $u_0=1$ $u_{n+1}=0.95u_n+0.25$.
1°) Créer une fonction seuil(p) qui, pour tout réel p donné, permet de déterminer le plus petit rang N à partir duquel tous les termes de la suite ($u_n$) sont supérieurs à $p$.
2°) Calculer seuil(4.99).

1°) Dans le problème a priori, nous devions déjà démontrer ou conjecturer que cette suite est strictement croissante et converge vers 5.

def seuil(p) : $\qquad$ $\qquad$ # IN : x un float (décimal). OUT : Un entier, image de p
$\qquad$ n=0
$\qquad$ u=1
$\qquad$ while u < p : $\qquad$ $\qquad$ $\qquad$ #Tant_que u < p : Test non borné
$\qquad$ $\qquad$ n =n+1 $\qquad$ $\qquad$ $\qquad$ #Incrémenter n, augmenter n de 1
$\qquad$ $\qquad$ u = 0.95*u+0.25 $\qquad$ #Calculer la nouvelle valeur de u
$\qquad$ return(n) $\qquad$ $\qquad$ $\qquad$ #Afficher le résultat.

>>> seuil(4.99)
117