Fonctions mathématique en Python

[dj_titeuf]

Bonsoir,

Je débute dans le langage Python, et je me suis procuré une liste d'exercices concernant ce langage, parmi laquelle deux fonctions me posent problèmes. A vrai dire, je ne sais vraiment pas comment faire. Voici les deux énoncés:

1°) Ecrire une fonction puissance(a,n) qui retourne .

def puissance(a,n):
   return a*a*a*...*a (n fois? comment l'écrire?)

2°) Ecrire une fonction plus_petit_entier(,) qui retourne le plus petit entier tel que .

[erik]

return a*a*a*...*a (n fois? comment l'écrire?)

Je ne connais pas spécialement python, mais j'imagine que comme dans tout langage évolué il y'a des instruction qui te permettent de faire des boucles.

Tu doit avoir des instruction 'for' et/ou 'while'

Et tu peux écrire quelque chose du genre

i=1
sol=1
Tant que i<n
.. sol=sol*a
.. i=i+1
Fin tant que

Pour le 2/ pareil tu fais une boucle
tant que a^k<n, j'augmente k de une unité

[dj_titeuf]

Merci de ta réponse erik!

Pour le point 1°), peut-être en ajoutant ceci:

def puissance(a,n):
   for i in range[1,n+1]
      A=a^i
   return A

Cependant, s'il s'avérait que ce soit correct, Python n'accepte pas, il me semble, le a^i (pour l'exposant). Du coup, je suis encore perdu ...

Quant au 2°), je ne vois toujours pas ..

[erik]

Réfléchi à ce que fait

def puissance(a,n):
   for i in range[1,n+1]
      S=a^i
   return S

(à chaque passage dans la boucle que vaut S ?)

et compare avec :

def puissance(a,n):
   for i in range[1,n+1]
      S=S*a
   return S

* : le symbole multiplier
(à chaque passage dans la boucle que vaut S ?)

[jepoirrier]

Bonjour,

Voilà ta première fonction : S est ton résultat et tu le construis au fur et à mesure en multipliant la base autant de fois qu'il le faut (l'exposant) ...

def puissance(base, exposant):
    S = 1
    for i in range(1, exposant+1):
        S = S * base
    return S

Apparemment, ton livre fait bien les chose puisqu'au-moins une des manières de réaliser ta seconde fonction, il faut utiliser la fonction puissance(...). Ici, j'emploie la force brute : je teste avec k allant croissant pour voir si cette expression dépasse la valeur de n.

def plus_petit_entier(a, n):
    S = 0
    iterateur = 0
    while S <= n:
        iterateur = iterateur + 1
        S = puissance(a, iterateur)
    return iterateur

Et, pour finir, une petite démonstration :

a = 3
e = 9
n = 400

print "a = %d; e = %d; n = %d" % (a, e, n)
print "a puissance e = %d" % (puissance(a, e))
sol = plus_petit_entier(a, n)
print "plus petit entier (a, n) = %d car" % sol
print "a puissance %d = %d" % (sol-1, puissance(a, sol-1))
print "a puissance %d = %d" % (sol, puissance(a, sol))

Donne le résultat suivant :

a = 3; e = 9; n = 400
a puissance e = 19683
plus petit entier (a, n) = 6 car
a puissance 5 = 243
a puissance 6 = 729

[dj_titeuf]

def puissance(a,n):
   for i in range[1,n+1]
      S=S*a
   return S

def puissance(base, exposant):
    S = 1
    for i in range(1, exposant+1):
        S = S * base
    return S

Tout d'abord, merci à tous les deux de votre aide.
Mais j'avoue ne pas très bien comprendre ce que réalise la fonction que vous avez écrite: pourquoi S=S*a à retourner? L'énoncé dit qu'il faut retourner . Or, dans ce que vous avez écrit, il me semble que n n'intervient pas! (Il n'y a même pas la variable locale i qui apparaît!) Pour moi, ce que vous avez écrit retourne a multiplié par .. je ne sais pas!

[erik]

Faudrait que tu te trouves un bouquin sur les bases de la programmation (fait un tour sur http://www.developpez.com/ )

Je te détaille ce que fait la boucle :
Bon au départ (avant d'entrer dans la boucle on initialise s à la valeur 1 :

S = 1

On entre pour la première fois dans la boucle :

for i in range(1, exposant+1):

maintenant i vaut 1 (c'est juste un compteur, on n'utilise pas cette valeur dans le calcul)
On demande au programme de multiplier S (qui vaut 1) par a (on obtient donc la valeur a) et on stocke la valeur obtenue dans la variable S :

S=S*a

Donc S vaut maintenant a et i vaut 1
On entre à nouveau dans la boucle (i vaut maintenant 2)
On demande au programme de multiplier S (qui vaut a) par a (on obtient donc la valeur a*a) et on stocke la valeur obtenue dans la variable S
Donc S vaut maintenant a*a et i vaut 2
On entre à nouveau dans la boucle (i vaut maintenant 3)
On demande au programme de multiplier S (qui vaut a*a) par a (on obtient donc la valeur a*a*a) et on stocke la valeur obtenue dans la variable S

Et comme on fait ça en tout n fois (c'est à ça que sert la variable i : à compter le nombre de fois ou on entre dans la boucle) à la fin S contient la valeur a*a*a*a*...*a (n fois)

[dj_titeuf]

def plus_petit_entier(a, n):
    S = 0
    iterateur = 0
    while S <= n:
        iterateur = iterateur + 1
        S = puissance(a, iterateur)
    return iterateur

A quoi correspond ce "iterateur"? Qu'est-ce que cela signifie?

[jepoirrier]

Un itérateur est, dans ce cas, une variable qui va varier de manière prédéterminée (ici, elle s'incrémente de 1 à chaque passage dans la boucle "while") et va être utilisé dans une boucle (par exemple).

Un autre exemple : tu dois afficher tous les entiers entre 1 et 100. Une solution pourrait être d'écrire 100 fois "print quelque chose" :

print "1"
print "2"
print "3"
# etc ...

Cette solution a 2 grands désavantages :
1. elle est fastidieuse à écrire
2. tu dois modifier beaucoup de choses si on te demande maintenant d'afficher tous les entiers entre 25 et 49

Une meilleure solution est d'écrire une boucle avec un itérateur (i dans le code ci-dessous). Tu initialises d'abord ton itérateur (à 1 ou à 25 ou à ...) et, ensuite, dans la boucle, tu "parcours" cet itérateur en l'incrémentant jusquà un maximum :

maximum = 100 # ou 49, ...
minimum = 1 # ou 25, ... (pas vraiment nécessaire)
i = minimum
while i <= maximum:
     print i
     i = i + 1

[overmind]

Juste un truc qui pourrait être utile:
en python, 5^3 s'écrit 5**3 .... (opérateur __pow__)

L'intérêt d'écrire:
def puissance(a,n):
b=a
for i in range (1,n):
b*= a
retrun b

est putôt réduit... (intérêt de la démonstration mis à part...)

[dj_titeuf]

Bonsoir,

Merci de vos précisions! En effet, l'itérateur est fort pratique selon les cas ... Concernant la notation **, je l'ignorais! Merci!

def plus_petit_entier(a, n):
    S = 0
    k = 0
    while S <= n:
        k = k + 1
        S = puissance(a, k)
    return iterateur

J'ai un peu de mal à comprendre comment tu as raisonné pour obtenir (rapidement?) le programme... Autant celui d'avant (pour retourner ) se comprenait rapidement, autant celui-ci... J'ai des difficultés. Comment as-tu pensé à tout cela? Ce qui m'a le plus embêté, c'est le . Pourquoi avoir choisi ça?

[overmind]

Ce code a au moins une faute (iterateur pas défini...) mais enfin bon...
Comprendre l'algorithmique de base est accessible à un gamin de deux ans, il suffit de:
1/ Comprendre ce qu'on veut faire
2/ Analyser et retranscrire les méthodes que l'on utilise dans la vie courante. (bon c'est là que le gamin de deux ans a du mal, si il faut retranscrire en C++...)

Comment tu ferais pour déterminer quel est le plus petit entier k tq a^k > n?
La méthode la plus simple est d'essayer avec k=0, de tester l'égalité, puis avec k=1, re tester, puis...
Ce qui donne en python:

k=0
while n>= a**k:
    k+=1

Autrement dit, tant que ça marche pas j'essaye avec k plus grand de 1. A la fin k a la bonne valeur. Ou alors a est nul et là on peut attendre assez longtemps... (penser à mettre un assert a!=0)


Le code de jepoirrier c'est le même principe, avec des rallongis dûs à l'utilisation d'une variable S et d'une fonction puissance "custom".

[dj_titeuf]

Ce code a au moins une faute (iterateur pas défini...) mais enfin bon...

Pas besoin de le définir il me semble avec Python ... non?

[overmind]

c'est juste le 'return iterateur', qui va donner une erreur puisqu'il n'y a pas de variable 'iterateur' de définie.

[dj_titeuf]

Erreur! Je voulais écrire "return k"!