Annuler
connectez vous
autre en post-bac
- Ensemble et application Partie II
- Équations différentielles : un Cours complet avec des exemples
- Un best-of d'exos de probabilités (après le bac)
- Espaces vectoriels et Applications linéaires - supérieur
- Généralités sur les matrices, applications linéaires, changement de base, rang d'une matrice - supérieur
Inscription / Connexion Nouveau Sujet
Accueil l'île des mathématiques Forum de mathématiquesListe de tous les forums de mathématiques SupérieurOn parle exclusivement de maths, pour le supérieur principalement, les BTS, IUT, prépas... Maths sup AutreTopics traitant de autre [tout]Lister tous les topics de mathématiques
Niveau Maths sup
Fibonacci en Python
Posté par Watwat
Bonjour a tous,
Je travaille sur un programme python dont le but est de retourner dans une liste les termes de la suite de Fibonacci (avec F_0 = 0 et F_1 = 1)
Voici quelques scripts :
def fibo(N):
if N == 0:
return [0]
elif N == 1:
return [0,1]
else :
liste = [0,1]
for i in range(2,N+1):
liste.append(fibo(i-1)+fibo(i-2))
return liste
def fibo(N):
if N == 0:
return [0]
elif N == 1:
return [0,1]
else :
liste = [0,1]
for i in range(2,N+1):
liste+=(fibo(i-1)+fibo(i-2))
return liste
Le premier script me revoie des listes de listes avec uniquement des 0 et des 1, le second m'indique une erreur de concaténation..
Pouvez-vous m'aider?
Merci d'avance,
Wat
Pour allonger ta liste dans le cas N>1, il ne faut bien sûr pas faire appel à fibo !
Tu ajoutes à la liste en cours la somme du dernier et de l'avant dernier élément de cette liste.
bonjour : )
Réfléchis à ce que tu fais :
fibo() te renvoie une liste de nombres.
En faisant fibo(i-1) + fibo(i-2) dans ton premier code tu obtiens une nouvelle liste qui est la concaténation de fibo(i-1) avec fibo(i-2).
Puis en faisant liste.append(fibo(i-1) + fibo(i-2)) tu fais quelque chose de pire en ajoutant à la fin de liste non pas un nombre mais une liste de nombres.
Il est donc normal que tu te retrouves à la fin avec une liste de liste de 0 et 1.
Dans ton deuxième code maintenant, c'est le même chose sauf que :
tu concatènes liste avec fibo(i-1) + fibo(i-2) à chaque itération.
A nouveau tu tombes sur une liste de 0 et 1.
Bonjour, tout d'abord merci pour vos réponses.
Avez-vous à ce compte-ci une recommandation ou une correction à me suggérer?
Wat
Réfléchis à ce qu'on t'a écrit. Tu pourras corriger toi-même.
J'ai donné une indication assez explicite, il me semble.
J'ai essayé autre chose :
def fibo1(N):
if N == 0:
return [0]
elif N == 1:
return [0,1]
else:
a,b=0,1 #a,b valeurs de départ
c = [] #initialisation de la liste comprenant les termes de la suite
for i in range (0,N):
c += [a+b]
a = b
b = c[i]
return c
fibo1(5) me retourne [1, 2, 3, 5, 8,]
Je devrai pourtant trouver [0,1,1,2,3] sauf erreur de ma part. J'en déduis que j'ai un problème d'indice, n'est-ce pas?
?
Pourquoi n'essaies-tu pas, avec une feuille de brouillon, de suivre ton algorithme pas à pas, N = 0, N = 1, N = 2, ....
Tu verras bien où est le problème, il est bien clair.
Oui, maintenant corrige ton code.
Tes précédents codes auraient fonctionnés si tu avais suivi l'indication de Recomic35,
Citation :
Tu ajoutes à la liste en cours la somme du dernier et de l'avant dernier élément de cette liste.
Tu ajoutes à la liste en cours la somme du dernier et de l'avant dernier élément de cette liste.
Voici ma correction :
def fibo(N):
if N == 0:
return [0]
elif N == 1:
return [0,1]
else:
a,b=0,1
c = [a,b]
for i in range (0,N):
c += [a+b]
a = b
b = c[i+2]
return c
Après vérification sur internet les termes retournés semblent correspondre avec ceux que je trouve.
Merci pour vos aides!
Ton programme n'est toujours pas bon.
fibo(0) = [0], ok
fibo(1) = [0 , 1], ok
fibo(2) = [0 , 1 , 1 , 2], non ok
J'ai trop l'impression que tu écris au hasard.
Le problème est ton range, prends range(0 , N - 1) et tu auras un code qui fonctionne.
J'ai regardé avec la fonction len le nombre de termes de la liste trouvée. Pour avoir exactement 100 termes il me faudrait même range(0,N - 2) apparemment.
On dirait que mdr_non se mélange les pinceaux dans la suite de Fibonacci
Le code donne le résultat correct. Mais il est assez dégueulasse.
def fibo(N):
if N == 0:
return [0]
elif N == 1:
return [0,1]
else :
liste = [0,1]
for i in range(2,N+1):
liste+=[liste[-1]+liste[-2]]
return listeA toi de t'adapter avec ton énoncé.
Si tu veux que N soit le nombre de termes retournés alors ne traite pas le cas fibo(0), fibo(0) devrait renvoyer une liste vide, débute à N = 1.
Avec ton code actuel, fibo(N) renvoie les N + 1 premiers termes de la suite, pour N >= 0.
Donc mettre (N - 2) ne changerait rien.
Et si tu veux aller un peu plus loin, tu devrais traiter le cas N entier négatif.
OK, mdr_non ne se mélange pas les pinceaux, son objection porte sur la longueur de la suite produite.
Quand je dis mettre (N - 2) ne changerait rien je voulais dire que ton code reste incohérent pour N = 0 et N = 1.
***
Recomic35
Citation :
On dirait que mdr_non se mélange les pinceaux dans la suite de Fibonacci
Non je ne pense, j'explique dans mon précédent message et même dans le message d'avant ce qu'il y avait de mauvais.On dirait que mdr_non se mélange les pinceaux dans la suite de Fibonacci
J'ai réussi à corriger le tout. Merci pour vos indications.
Pour aller plus comme mdr_non me le suggère, il me suffi d'ajouter un "if N<0: return "erreur" ou quelque chose du style.
Autrement, le sujet propose d'enregistrer cette liste dans un fichier texte. Aucun problème pour cela, mon script fonctionne. Cela dit, exécutions après exécutions le fichier texte ne ressemble plus à grand chose. J'aimerai donc dans cette mesure effacer le contenu du fichier avant d'y entrer la liste trouvée précédemment.
De plus, sauriez-vous comment, par exécution du script, ouvrir dans une fenêtre windows (..) le fichier texte dans lequel j'aurai entré la liste?
def fibo(N):
if N == 0:
return [0]
elseif N == 1:
return [0,1]
else
a=0 // correspond à (n-2)
b=1 // correspond à (n-1)
c=1 // correspond à (n)
Liste=[0,1]
TANT QUE c <= N
Liste.append(c)
a = b
b = c
c = a+b
FINTANTQUE
endif
return Liste
L'utilisation de a, b, c permet de minimiser l'accès à la liste et de faire appel à une fonction imbriqué qui consomme énormément de ressources.
Quelle fonction imbriquée ?
Pourquoi ce c <= N ? Il est demandé la liste des N+1 premiers termes de Fibonacci, pas la liste de ceux inférieurs ou égaux à N.
Razes,
Ton code ne va pas à cause de la condition donnée au "tant que", c ne représente pas un compteur mais un terme de la suite.
S'il s'agissait d'optimisation, append() ne serait pas plus adapté que extend().
Pour aller encore plus loin dans l'optimisation l'opérateur += serait à utiliser car l'utilisation de extend() provoque un appel de fonction.
Mais ce ne sont pas des choses à penser.
Watwat,
Tu sais que tu as une documentation n'est-ce pas ?
Il y a différents mode d'ouverture de fichier, utilise le bon mode pour qu'à l'ouverture le fichier soit vidé.
Pour ouvrir un fichier avec un programme associé, 
.
Citation :
Quelle fonction imbriquée ?
Quelle fonction imbriquée ?
Je parlais de la fonction imbriquée fibo
Citation :
def fibo(N):
if N == 0:
return [0]
elif N == 1:
return [0,1]
else :
liste = [0,1]
for i in range(2,N+1):
liste+=(fibo(i-1)+fibo(i-2))
return liste
def fibo(N):
if N == 0:
return [0]
elif N == 1:
return [0,1]
else :
liste = [0,1]
for i in range(2,N+1):
liste+=(fibo(i-1)+fibo(i-2))
return liste
mdr_non @ 12-06-2016 à 19:08
Razes,
Ton code ne va pas à cause de la condition donnée au "tant que", c ne représente pas un compteur mais un terme de la suite.
S'il s'agissait d'optimisation, append() ne serait pas plus adapté que extend().
Pour aller encore plus loin dans l'optimisation l'opérateur += serait à utiliser car l'utilisation de extend() provoque un appel de fonction.
Mais ce ne sont pas des choses à penser.
Razes,
Ton code ne va pas à cause de la condition donnée au "tant que", c ne représente pas un compteur mais un terme de la suite.
S'il s'agissait d'optimisation, append() ne serait pas plus adapté que extend().
Pour aller encore plus loin dans l'optimisation l'opérateur += serait à utiliser car l'utilisation de extend() provoque un appel de fonction.
Mais ce ne sont pas des choses à penser.
Je pensais qu'on cherche les termes de la suite de Fibonacci inférieurs ou égaux à N.
Là désolé, mais c'est la fonction append() qui ajoute un terme en queue de liste. Ce n'est pas la peine d'utiliser extend(). Tu peux vérifier la doc python.
Citation :
Là désolé, mais c'est la fonction append() qui ajoute un terme en queue de liste. Ce n'est pas la peine d'utiliser extend(). Tu peux vérifier la doc python.
?
Là désolé, mais c'est la fonction append() qui ajoute un terme en queue de liste. Ce n'est pas la peine d'utiliser extend(). Tu peux vérifier la doc python.
append() et extend() font la même action. Tu peux vérifier la doc python.
L'un fait mieux que l'autre dans certaines situations, tu peux t'écrire des programmes et tester.
Bonsoir.
Je propose le code suivant :
def generer_fibonacci(arg_n_max) :
n_max = arg_n_max
n = 1
F_n_moins_2 = 0
F_n_moins_1 = 1
# generation en cours ?
while True :
F_n = F_n_moins_1 + F_n_moins_2
yield F_n
F_n_moins_2 = F_n_moins_1
F_n_moins_1 = F_n
if n >= n_max :
break
n += 1
# effacement de l'ecran
os.system('cls')
# entrees des valeurs
N_max = int(raw_input("\n N ? "))
# generation par iteration
for f in generer_fibonacci(N_max) :
print " ", f
En version avec une liste a remplir :
def generer_fibonacci(arg_n_max) :
n_max = arg_n_max
n = 1
F_n_moins_2 = 0
F_n = F_n_moins_2
yield F_n
F_n_moins_1 = 1
F_n = F_n_moins_1
yield F_n
# generation en cours ?
while True :
F_n = F_n_moins_1 + F_n_moins_2
yield F_n
F_n_moins_2 = F_n_moins_1
F_n_moins_1 = F_n
if n >= n_max :
break
n += 1
# effacement de l'ecran
os.system('cls')
# liste vide
liste = []
# entrees des valeurs
N_max = int(raw_input("\n > N ? "))
# generation des permutations par iteration
for f in generer_fibonacci(N_max) :
print " ", f
liste.append(f)
print " liste : ", liste, "\n"
bbomaths,
Ton code fait la même faute que celui de Watwat à 12-06-16 à 18:05.
Ton print est mal écrit.
def fibo(N):
if N == 0:
return [0]
elseif N == 1:
return [0,1]
else
i=1
a=0 // correspond à (n-2)
b=1 // correspond à (n-1)
c=1 // correspond à (n)
Liste=[0,1]
while i <= N
Liste.append(c)
i+=1
a = b
b = c
c = a+b
endif
return Liste
Razes @ 12-06-2016 à 19:42
Je parlais de la fonction imbriquée fibo
Citation :
Quelle fonction imbriquée ?
Quelle fonction imbriquée ?
Je parlais de la fonction imbriquée fibo
M'enfin, Razes, il ne faut pas raconter de salades !! Il n'y a de fonction imbriquée que dans le code erroné de Watwat. Il n'y en a bien sûr pas dans le code correct que j'ai écrit.
C'est de ça que je parlais "la fonction fibo" il suffisait de lire la citation qui suivait, Je n'ai pas parlé de ton code. Par la même occasion je ne raconte pas de salades.
En cette occurrence, si.
Citation :
L'utilisation de a, b, c permet de minimiser l'accès à la liste et de faire appel à une fonction imbriqué qui consomme énormément de ressources.
L'utilisation de a, b, c permet de minimiser l'accès à la liste et de faire appel à une fonction imbriqué qui consomme énormément de ressources.
Ce n'est pas vrai. Le code écrit correctement, sans a,b,c ne fait appel à aucune fonction imbriquée.
Si tu avais lu les premiers messages du fil, tu aurais bien vu que "l'imbrication" ne venait que d'une erreur de Watwat.
@Recomic35
Je t'ai dis que je parlais pas de ton code, a, b, c figurent aussi dans le code de Watwat. Si j'ai une critique vis à vis de ton code, je te l'aurais dit et ma tête ne sera pas coupé pour autant.
Dernière version pour être conforme à ce qui était demandé :
def generer_fibonacci(arg_n_max) :
liste = []
n = 0
liste.append(0)
n += 1
if n == arg_n_max :
return liste
liste.append(1)
n += 1
if n == arg_n_max :
return liste
while n < arg_n_max :
liste.append(liste[-1] + liste[-2])
n += 1
return liste
# effacement de l'ecran
os.system('cls')
# entrees des valeurs
N_max = int(raw_input("\n N ? "))
# generation
liste_fibo = generer_fibonacci(N_max)
print " liste_fibo : ", liste_fibo, "\n"
Pourr suvegarder dan un fichier :
# ouverture du fichier de log en ecriture
fichier_log_id = open(fichier_log, 'w')
# ouverture du fichier de log en ajout
fichier_log_id = open(fichier_log, 'a')
# ecriture de ligne
fichier_log_id.write(ligne + "\n")
# fermeture du fichier de log
fichier_log_id.flush()
os.fsync(fichier_log_id.fileno())
fichier_log_id.close()
Recomic35 @ 12-06-2016 à 18:47
On dirait que mdr_non se mélange les pinceaux dans la suite de Fibonacci
Le code donne le résultat correct. Mais il est assez dégueulasse.
On dirait que mdr_non se mélange les pinceaux dans la suite de Fibonacci
Le code donne le résultat correct. Mais il est assez dégueulasse.
def fibo(N):
if N == 0:
return [0]
elif N == 1:
return [0,1]
else :
liste = [0,1]
for i in range(2,N+1):
liste+=[liste[-1]+liste[-2]]
return liste@Recomic35
Ton code était bon à part l'instruction liste+=[liste[-1]+liste[-2]] qui n'était pas correcte et qui doit être remplacée par liste.append([liste[-1]+liste[-2]])
Recomic35, bonsoir.
Si N est le nombre de termes à calculer, il y a un élément de trop dans la liste affichée.
Amicalement, bbomaths