Fonctions

Analyses de fonctions

Fonctions sans argument

Que renvoient les fonctions suivantes ?

(donner une réponse avant de tester avec un interpréteur Python)

def ma_fonction1():
   a = 2
   b = 3
   return a+b

def ma_fonction2():
   a = 2
   b = 3
   return a+b
   return a-b

def ma_fonction3():
   a = 2
   b = 3
   print(a + b)

Lesquelles de ces déclarations de fonctions provoquent une erreur ? et pourquoi ?

def ma_fonction4()
   print("Bravo !")
def ma_fonction4():
   print("Bravo !")
def ma fonction4():
   print("Bravo !")
def ma_fonction4():
print("Bravo !")
def ma_fonction4():
   print("Bravo !')
def ma_fonction4(c): 
   print("Bravo !")

 

Fonctions à un seul argument

Que s’affiche-t-il lors de l’exécution des scripts suivants ?

(donner une réponse avant de tester avec un interpréteur Python)

x = 5
def isn1(x):
   return x**2
print(isn1(2), x)

a = 5
def isn2(x):
   return a+x
print(isn2(2), a)

a = 5
def isn3(x):
   a = 2
   return a+x
print(isn3(2), a)

a = 5
def isn4(x):
   a += 1
   return a+x
print(isn4(2), a)

a = 5
def isn5(x):
   global a
   a += 1
   return a+x
print(isn5(2), a)

a = 5
def isn6(x):
   global a
   a = 2
   return a+x
print(isn6(3), a)

 

Fonctions à plusieurs arguments

Que s’affiche-t-il lors de l’exécution des scripts suivants ?

(donner une réponse avant de tester avec un interpréteur Python)

def multi1(x, y):
   return x**y
print(multi1(2, 3))

def multi2(x, a = 6):
   return a+x
print(multi2(2, 3))

def multi3(x, a = 6):
   return a+x
print(multi3(2))

def multi4(x, a = 6, b = 3):
   return a*x + b
print(multi4(2, 3, -3))

def multi5(x, a = 6, b = 3):
   return a*x + b
print(multi5(2, b = 3, a = -3))

a = 5
def multi6(x, a = 6, b = 3):
   a = 4 + a
   return a*x + b 
print(multi6(2, b = 3))

 

 

 


Fonctions mathématiques

Fonctions simples

Implémenter en Python les fonctions mathématiques suivantes :

  • \(aire:r \rightarrow \pi r^2\)
  • \(f:x \rightarrow e^{-x}\)
  • \(dB:g \rightarrow 20 \log{(g)}\)

Tester ces fonctions :

  • aire(16)  : 804.247719318987
  • f(54)  : 3.532628572200807e-24
  • dB(21)  : 26.444385894678387

Rappel : les opérateurs en Python
module math

[reveal_link heading= »%image%  Correction » id= »id1″]

[reveal heading= »noheading » id= »id1″]

from math import *

def aire(r):
    return pi*r**2 
print(aire(16))

def f(x):
    return exp(-x) 
print(f(54))

def dB(g):
    return 20*log10(g)
print(dB(21))

[/reveal]

 

Fonctions avec paramètres

Implémenter en Python les fonctions mathématiques suivantes :

  • \(p2:x \rightarrow ax^2+bx+c\)
  • \(eln:x \rightarrow e^{i -j\ln{x}}\)

Tester ces fonctions :

  • p2(-1.5, 1, 2, -4)  : -4.75
  • eln(8.1, 2, -1)  : 59.85135440133828

[reveal_link heading= »%image%  Correction » id= »id2″]

[reveal heading= »noheading » id= »id2″]

from math import *

def p2(x, a, b, c):
    return a*x**2+b*x+c
print(p2(-1.5, 1, 2, -4))

def eln(x, i, j):
    return exp(i-j*log(x))
print(eln(8.1, 2, -1))

[/reveal]

 

Généralisation

Connaissances supplémentaires requises : dictionnaires

  • Écrire en Python une fonction \(g_1:x \rightarrow g_1(x)\) , quelle que soit l’expression de \(g_1(x)\).

par exemple : g1(3, « 3*x+2/x »)  doit renvoyer 9.666666666666666

  • En déduire une fonction g2()  admettant en plus des paramètres.

par exemple : g2(3, « a*x+b/x », 3, 2)  doit également renvoyer 9.666666666666666

Cette fonction n’est pas encore universelle ! Les noms des paramètres doivent parfaitement coïncider avec ceux de l’expression, et il doit y en avoir autant.

  • Écrire une fonction qui en guise de paramètres d’une expression mathématique, accepte un dictionnaire :

def g3(x, expression, **parametres):
   ...

Les **  ici permettent de déclarer à la fonction les couples clef:valeur  d’un dictionnaire comme une série d’arguments avec mot clef (keyword argument) (voir les fonctions). Ces deux déclarations sont équivalentes :

def h1(p = 1, q = 2):
   return eval('p+q')
print(h1(p = 4, q = 6))
def h2(**d):
   locals().update(d)
   return eval('p+q')
print(h2(p = 4, q = 6))

la fonction locals()  renvoie toutes les variables locales de la fonction sous forme d’un dictionnaire

par exemple : g3(-2, « i*x-sqrt(k*x)/(h-x**2) », i = 1, k = -8, h = 5)  doit renvoyer -6

[reveal_link heading= »%image%  Correction » id= »id3″]

[reveal heading= »noheading » id= »id3″]

from math import *

def g3(x, expression, **d):
    locals().update(d)
    return eval(expression)
print(g3(-2, "i*x-sqrt(k*x)/(h-x**2)", i = 1, k = -8, h = 5))

[/reveal]

Tables de multiplication

Connaissances supplémentaires requises : boucles

  • Écrire une fonction table(n)  qui affiche la table de multiplication par n , sous la forme « i x n = j » .

par exemple, table(7)  doit afficher :

1 x 7 = 7
2 x 7 = 14
3 x 7 = 21
4 x 7 = 28
5 x 7 = 35
6 x 7 = 42
7 x 7 = 49
8 x 7 = 56
9 x 7 = 63
10 x 7 = 70

 

  • Écrire une fonction table2(n, debut, fin, pas)  qui affiche la table de multiplication par n  depuis dedut  (« n x debut » ) jusqu’à fin  (« n x fin » ) en incrémentant de la valeur pas .

par exemple, table2(7, 2, 13, 2)  doit afficher :

2 x 7 = 14
4 x 7 = 28
6 x 7 = 42
8 x 7 = 56
10 x 7 = 70
12 x 7 = 84

[reveal_link heading= »%image%  Correction » id= »id4″]

[reveal heading= »noheading » id= »id4″]

def table(n):
    for i in range(10):
        print(i+1, 'x', n, '=', (i+1)*n)
table(7)

def table2(n, debut, fin, pas):
    i = debut
    while i <= fin:
        print(i, 'x', n, '=', i*n)
        i += pas
table2(7, 2, 13, 2)

[/reveal]

Une fonction comme argument

Connaissances supplémentaires requises : boucles

  • Écrire une fonction evaluer(fct, b_inf, b_sup, n_eval)  qui afficher n_eval  résultats de la fonction fct(x)  pour x  variant de b_inf  à b_sup .

par exemple, soit la fonction :

def f(x):
    return 5*x**3 + 3*x - 1

dans ce cas, evaluer(f, 3, 7, 10)  doit afficher :

f(3.00) = 143.000
f(3.40) = 205.720
f(3.80) = 284.760
f(4.20) = 382.040
f(4.60) = 499.480
f(5.00) = 639.000
f(5.40) = 802.520
f(5.80) = 991.960
f(6.20) = 1209.240
f(6.60) = 1456.280

  • Modifier la fonction en evaluer2()  pour qu’elle retourne une liste de tuple (x, fct(x)) .

dans ce cas, evaluer2(f, 3, 7, 10)  doit retourner : [(3, 143), (3.4, 205.72), (3.8, 284.76), (4.2, 382.04), (4.6, 499.48), (5.0, 639.0), (5.4, 802.52), (5.8, 991.96), (6.2, 1209.24), (6.6, 1456.28)] 

[reveal_link heading= »%image%  Correction » id= »id5″]

[reveal heading= »noheading » id= »id5″]

def f(x):
    return 5*x**3 + 3*x - 1

def evaluer(fct, b_inf, b_sup, n_eval):
    h = (b_sup - b_inf) / n_eval
    x = b_inf
    while x <= b_sup:
        y = fct(x)
        print("f({:.2f}) = {:.3f}".format(x, y))
        x += h

evaluer(f, 3, 7, 10)

def evaluer2(fct, b_inf, b_sup, n_eval):
    h = (b_sup - b_inf) / n_eval
    x = b_inf
    liste = []
    while x <= b_sup:
        liste.append((round(x,3), round(fct(x),3)))
        x += h
    return liste

print(evaluer2(f, 3, 7, 10))

[/reveal]

Racines

Connaissances supplémentaires requises : structures conditionnelles

  • Écrire une fonction racines(a, b, c)  qui renvoie les racines (si elles existent !) du polynôme de la forme : \(ax^2+bx+c\).

 


e (constante de Néper)

Connaissances supplémentaires requises : boucles

Écrire une fonction e(n)  qui estime la valeur de la constante mathématique \(e\) en utilisant la formule :
\(e=\lim\limits_{n \to \inf}\sum_{i=0}^{n}{\frac{1}{i!}}\)
avec n  le nombre d’itérations de calcul.

Rappel : la fonction Python pour \(x \rightarrow x!\) est factorial()  (module math )

[reveal_link heading= »%image%  Correction » id= »id7″]

[reveal heading= »noheading » id= »id7″]

def e(n):
   e = 0.0
   for i in range(n):
      e += 1.0/factorial(i)
   return e
print(e(100))

[/reveal]

 


 Lancé de dés

  • Écrire une fonction qui permet de lancer des dès. On souhaite pouvoir définir :

    • le nombre de dès à lancer
    • le nombre de faces des dès (par défaut on lance des dès à 6 faces)

Le résultat du lancé devra être affiché sous la forme « 5 4 1 »

  •  Écrire une autre fonction permettant d’afficher la valeur de la face d’un dés faces sous la forme :

•
 •
  •

Ou encore :

• •
 • 
• •

 


Nombres romains

  • Écrire une fonction romains(n)  qui convertit un entier n  en écriture romaine.

par exemple romains(1515)  doit renvoyer la chaîne de caractères : « MDXV »

 

[reveal_link heading= »%image%  Correction » id= »id8″]

[reveal heading= »noheading » id= »id8″]

def romains(n):
    ...

[/reveal]

 



Widget not in any sidebars

Vous aimerez aussi...

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

*

code