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.

En effet je ne rentre pas les premières valeurs dans la liste..

Oui, maintenant corrige ton code.

Tes précédents codes auraient fonctionnés si tu avais suivi l'indication de Recomic35,

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 liste

A 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

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.

Merci pour vos indications!

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é, .

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

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.

@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()

bref, le sujet de Watwat n'était pas Contonconton...

N'importe quoi, Razes. Décidément, ce n'est pas ta soirée :

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

bbomaths,
Il semblerait que tu n'aies pas bien lu tout le fil de la discussion.

@Recomic35
Décidément, tu vois comment tu réagis?

Je réagis aux affirmations fausses. Evite d'en faire, je n'aurai pas à réagir.