termes d'une suite

Bonjour Je suis débutant en Python et j’ai un problème sur ce programme: Suite: U(n+1)=1/2*U(n)+2, U0=3 Déterminer les 5 premiers termes et leur somme

k=5 u=3 s=0 for i in range(0,k): u=1/2*u+2 print(u) s=s+u print("somme=",s)

Si je remplace 1/2 par 0.5 ça marche sinon et bien ça ne marche pas ! Pourquoi ?

Voici les résultats:

Merci pour des réponses.

Je me permets de reformater le code afin qu’il soit lisible :

u=3
s=0
for i in range(0,k):
    u=1/2*u+2
    print(u)
    s=s+u
    print("somme=",s)

Alors c’est étrange car sur un interpréteur Python 3 les deux se comportent de la même façon, par le biais des priorités opératoires. Et je ne vois pas comment il est possible que 1/2 * u + 2 donne constamment 2 (une fois avec u = 0 initialement, ok, mais sinon, sauf si la variable est mal mise à jour…).

Mais en fait tu sembles utiliser Python 2, donc voit plutôt le message d’entwanne ↓ (et passe à Python 3 si possible !)

Salut,

Pense à mettre ton code en forme avec des balises ```python et ```.

J’imagine que l’erreur qui se produit est que 1/2 s’évalue à 0 et non à 0.5 parce que tu utilises Python 2, où l’opérateur / réalise une division entière.

Une solution serait d’écrire 1./2, mais je te conseille plutôt de passer à Python 3, sachant que Python 2 ne sera plus maintenue à partir de l’année prochaine.

J’imagine que l’erreur qui se produit est que 1/2 s’évalue à 0 et non à 0.5 parce que tu utilises Python 2, où l’opérateur / réalise une division entière.

Mon dieu, Python 2… On est tellement proche de la fin de vie que je n’y avais même pas pensé Bien vu

En plus j’aurais pu y penser ne serais-ce qu’avec l’affichage de print

Salut,

Une autre solution si vraiment tu dois rester en Python 2, c’est d’ajouter

from __future__ import division

en début de fichier pour utiliser la définition non entière de la division.

Bonjour et merci pour vos messages. J’ai installé Python 33 et ça marche !

Par contre je n’ai pas eu de notification par courriel pour vos messages ? Et pourtant elle est activée (en haut à gauche ).

Python 3.3 tu veux dire ? Si tu peux prends plutôt le 3.6 ou 3.7, Python 3.3 étant dépréciée depuis deux ans.

Bonjour Il y a tellement des versions pour windows: 86x, 86x-64 bits etc.. J’ai le windows 10. Peux-tu m’indiquer la dernière version de Python qui convient au windows 10 ? Merci d’avance

Les x86 concernent le type de processeur, tu n’as normalement pas à t’en occuper, mais j’admets que la page des téléchargements n’a pas l’air très claire.

Dans le doute prends toujours la version « Windows x86–64 executable installer » de la dernière version en date de l’interpréteur (3.7.4 ici) : https://www.python.org/ftp/python/3.7.4/python-3.7.4-amd64.exe

Bonjour J’ai installé python 3.7 et ça marche. Voici un programme qui doit marcher mais il n’affiche pas la factorielle de 10. Il affiche juste " factorielle de 10" et "fin"

print("factorielle de 10")

n=10

def fact(n):

if n==0:

return(1)

else:

    return(n*fact(n-1))

print("fin")

Tu définies ta fonction factoriel, mais tu ne l’appelles jamais.

Voici le programme que j’ai trouvé dans un livre de première générale (nouveau programme)

def fact(n):

if n==0:

return(1)

else:

return(n*fact(n-1))

Mais n*fact(n-1) n’est pas un appel à fact()?

Salut,

S’il te plait fais un effort de mise en page de tes codes en les encadrants de backticks comme ceci

````python
# ton code
````

Pour ton problème, l’appel à fact est situé dans sa définition, mais tu n’appelles jamais la fonction dans le corps du programme, et tu n’affiches pas non plus le résultat obtenu. Tu devrais avoir un fact(10) quelque part.

Si, mais pour appeler ça, il faut avoir fit appel à fact une première fois. Reprenons ton programme, ligne à ligne :

print("factorielle de 10")
n=10
def fact(n):
    if n==0:
        return(1)
    else:
         return(n*fact(n-1))
print("fin")

• Ligne 1 : affiche "factorielle de 10"
• Ligne 2 : n vaut maintenant 10
• Ligne 3, nous allons définir une fonction nommée fact, qui prendra un argument nommé n. Autrement dit, lorsque plus tard, tu ferra fact(52), cela lancera le code de la fonction.
• Ligne 4 à 7 : code de la fonction. On ira ici lorsque la fonction sera appelé. Là, tout de suite, tu n’a aucune raison d’aller ici.
• Ligne 8 : affiche "fin".

Si maintenant tu ajoutes entre la ligne 7 et 8 le code fact(n), voilà ce qu’il va se passer :

• n vaut 10, donc fact(n) se transforme en fact(10)
• on appelle fact, donc on va ligne 4
• on test si n (la n de la fonction, pas celui défini au dessus !) vaut 0. Non.
• sinon, donc là, on rentre
• on renvoie 10*fact(10–1)
• on appelé fact avec comme argument 9. Dans le code de la fonction, n vaut 9.
• on test si n vaut 0. Non.
• sinon, donc là, on rentre
• on renvoie 9*fact(9–1)
• on appelé fact avec comme argument 8. Dans le code de la fonction, n vaut 8.
• Et ainsi de suite…
• Finalement, la dernière fonction renvoie 1, donc l’avant dernière 2 (2x1), celle d’avant 6 (3x2), 24 (4x6)… et finalement 3628800.

Note que cette valeur n’est jamais affiché. Car tu as demandé à ce que ce soit calculé, pas affiché.

Un programme fait ce qu’on lui demande. Tu définis une fonction ? OK. Tu ne l’as pas appelée pour autant. Tu calcules une valeur ? OK. Tu ne l’affiches pas pour autant.

En espérant que ce soit plus clair.

Oui ça marche !

Je trouve que ce n’est pas évident cette histoire de limiter une boucle etc… avec les ":" au

début et rien à la fin. En C on met des accolades et tout de suite on voit le début et la fin.

Je ne critique pas le python mais ce n’est pas évident !

Je ne maitrise pas la mise en forme pour l’instant, donc j’ai collé l’image de mon texte.

Là tu vois le début et la fin avec les niveaux d’indentation à l’intérieur de tes blocs.

Là tu vois le début et la fin avec les niveaux d’indentation à l’intérieur de tes blocs.

Cela veut dire qu’un bloc commence par ":" et se finit par l’instruction qui est la plus à droite si j’ose dire.

exemple:

for…. :

    .......

    .......:

            .....

            ......

              .....fin

Pas vraiment. En fait, tout ce qui est indenté sous une ligne se terminant par : se trouve dans le bloc, donc le bloc se termine juste avant la première ligne qui n’est plus décalée.

Car il peut y avoir des sous-blocs au milieu, pas forcément à la fin, par exemple :

for i in range(21):
    if i % 2 == 0:
        print("Nombre pair")
    print(i)

Dans ce code, le bloc ouvert par for ligne 1 se termine ligne 4, alors que ce n’est pas l’instruction la plus à droite Le bloc ouvert par if ligne 2 se termine lui ligne 3, car la ligne 4 se re-décale vers la gauche par rapport à la ligne 3.

J’espère que c’est plus clair