<< Exemple d'utilisation | PythonIndex | Les fonctions >>
Notions de base
Plan (hide)
1. Le résumé de l'épisode précédent et l'aguiche
![](https://litis.univ-lehavre.fr/~dolivier/PagePerso/uploads/Enseignement/NotionsDeBase/Kaa_01.jpg)
2. Un peu de calcul
python sait donc calculer. On peut lui demander à l'aide d'un programme, mais aussi au niveau de la console :
>>> 7 * 3.53 24.709999999999997
Aie confiance ....
Ana réveille toi, ce résultat ne te semble t-il pas un peu bizarre ? Non tu ne vois pas ! Alors essaye cela :
>>> 1/9 + 1/9 + 1/9 +1/9 +1/9 +1/9 +1/9 +1/9 +1/9 1.0000000000000002
"Mais Conda c'est n'importe quoi ! Cela fait 1."
Eh oui, la représentation de certain nombre en machine n'est pas exacte cela génère des petites erreurs. Il faut faire attention à cela, mais rassure toi, cela ne devrait pas nous poser de problème. Tu l'a sans doute remarqué le .
remplace notre ,
habituelle comme sur ta machine à calculer, c'est la notation anglo-saxonne. Les opérateurs sont notés également de la même façon :
Opérateur | Opération |
---|---|
+ | Addition |
- | Soustraction |
* | Multiplication |
/ | Division |
** | Puissance |
Il y a autre dont il faut se méfier c'est l'ordre des opérateurs. Lorsqu'on écrit 2 + 3 * 5
, quelle opération est faite en première ?
>>> 100 * 50 - 50 4950
python utilise la convention habituelle d'abord la multiplication puis l'addition. L'ordre dans lequel sont faîtes les opérations dépend d'une convention. SI on considère : les parenthèses, l'élévation à une puissance (exposant), la multiplication, la division, l'addition et la soustraction. Il suffit d'appliquer le mot magique PEMDAS.
- Les Parenthèses, elles sont les plus prioritaires. En cas de doute, n'hésite pas à en mettre.
>>> 100 * (50 - 50) 0
- Les Exposants ils sont évalués ensuite, avant les autres opérations.
>>> 3**1+1 4 >> 3*1**10 3
- Les Multiplications et les Divisions, qui ont la même priorité.
- Les Additions A et les Soustractions, qui ont la même priorité.
- On ajoute donc en plus une règle, si deux opérateurs ont la même priorité, l'évaluation est effectuée de la gauche vers la droite. Essaye de trouver le résultat de :
>> 7 - 4 + 3**(2 * 0) + 1
et vérifie ensuite.
3. Variables
Un ordinateur possède une mémoire pour stocker de l'information. Pour retrouver cette information afin de pouvoir l'utiliser (afficher, modifier, calculer ....), on donne un nom à l'emplacement où cela est stocké. La mémoire c'est un peu comme ton armoire Ana, il y a des boites sur lesquelles tu a écris par exemple cartes et dans lesquelles tu ranges les cartes postales que tu as reçus. La boite sert à stocker, elle a un contenu, et ce qu'il y écrit dessus à retrouver ce même contenu. Eh bien une variable elle a un nom, une valeur et un type. Tu as compris que la valeur c'est ce qui est stocké, pour le type je te vois venir c'est pas un pov'typ, cela fixe la nature de ce qui est stocké. Cela peut être un nombre entier, un nombre réel, une chaîne de caractère (un texte), une liste de nombres ... Je ne vais pas énumérer tout, ce serait trop long et je risque d'en oublier.
On indique à python que l'on va utiliser une variable en la déclarant et en l'initialisant. Initialiser une variable c'est lui donner une première valeur.
>>> x = 0 >>> x 0
On a déclaré et initialisé x
avec la valeur 0
. Tu peux maintenant interroger python en lui demandant le type (la nature) de x
.
>>> type(x) <class 'int'>
x
est donc de type int
, c'est comme cela qu'il note les nombres entiers.
Je peux te proposer d'autres exemples avec une chaîne de caractère, pour changer
>>> serpent = "Anaconda" >>> type(serpent) <class 'str'> >>> print(serpent) Anaconda >>>
Une chaîne de caractère se note soit entre guillemets "chaîne"
ou entre apostrophes 'chaîne'
et si jamais ta chaîne fait plus d'une ligne on utilise alors 3 apostrophes en début et 3 en fin.
>>> grandeChaine = '''Une chaîne sur 1 ligne 2 lignes, 3 lignes.''' >>> print(grandeChaine) Une chaîne sur 1 ligne 2 lignes, 3 lignes.
3.1 Comment choisir le nom de tes variables
Le nom doit être explicite, il doit te parler, x
c'est bien mais cela peut représenter n'importe quoi ! Il y a des règles pour donner un nom à une variable, ce sont les suivantes :
- Un nom de variable, on parle d'identificateur est une suite de lettres (a...z , A...Z) et de chiffres (0...9), qui doit toujours commencer par une lettre.
- Le caractère _ (souligné) est autorisé, les lettres accentuées sont autorisées si tu utilises python3, mais je te déconseille. De même attention avec le _ il y a des règles particulières quand il est au début ou à la fin.
- La casse (majuscule/minuscule) est importante. La variable
MAJUSCULE
ne'st pas la même queMajuscule
. On privilégie les identificateurs pour les variables en lettres minuscules. - Il existe des mots réservés qui sont utilisés par python et que tu ne peux pas utiliser pour donner un nom à tes variables.
and | assert | break | class | continue | def |
del | elif | else | except | exec | finally |
for | from | global | if | import | in |
is | lambda | not | or | pass | |
raise | return | try | while | yield |
3.2 Affectation
python est un langage impératif, cela veut dire que tu peux demander de modifier le contenu d'un emplacement en mémoire représenté par une variable. Cette opération de modification s'appelle l'affectation, et elle est représentée par le signe =
.
Il ne s'agit pas d'une égalité comme celle utilisée en mathématique. Par exemple ce n'est pas commutatif.
>> x = 7
Tu ne peux pas écrire :
>> 7 = x # Interdit, on tente de modifier une constante !
Imaginons que tu veilles savoir quelle est la température extérieure aujourd'hui en degré Kelvin (K) et que le thermomètre de la maison mesure cette température en degré Celsius (°C). Tu sais que le zéro absolu (0 K) à pour valeur 273,15 °C, on va donc pouvoir le température d'aujourd'hui en Kelvin à l'aide de python :
>>> zero_absolu = 273.15 >>> temperature_c = 12 # fait pas chaud aujourd'hui >>> temperature_k = zero_absolu + temperature_c >>> print(temperature_k) 285.15
La variable zero_absolu
a été créée, elle à un type flottant (<class 'float'>
) permettant de représenter un nombre réel et de ce fait un certain nombre d'opérations sont possibles/autorisées comme l’additionner avec un nombre entier, ce que l'on fait sur la troisième ligne. Elle est initilisée à la constante flottante (au nombre réel) 273.15 .
temperature_k = zero_absolu + temperature_c
crée une variable temperature_k
dont la valeur initiale est le résultat du calcul de la somme de la valeur de la variable zero_absolu
et temperature_c
et le type est celui de la nature du résultat donc un flottant (<class 'float'>
).
>>> type(zero_absolu) <class 'float'> >>> type(temperature_c) <class 'int'> >>> type(temperature_k) <class 'float'>
Pour te montrer l'influence du type maintenant essaye, la petite séquence d'instructions suivante :
>>> pere = "Conda" >>> fille = "Ana" >>> pere_et_fille = pere + fille >>> fille_et_pere = fille + pere >>> print(pere_et_fille, fille_et_pere) CondaAna AnaConda
Tu vois le +
que l'on a mis, à cause du type des variables pere
et fille
n'est pas une addition mais une concaténation (mise bout à bout) de deux chaînes de caractère.
Il y a d'autres formes d'affectation mais il ne m'a pas semblé indispensable de les développer. On les évoquera éventuellement au fur et à mesure.
4. Les instructions
![](https://litis.univ-lehavre.fr/~dolivier/PagePerso/uploads/Enseignement/NotionsDeBase/instruction.jpg)
Source : http://www.funnelinc.com/instructions Quand tu écris un programme tu cherches à ce que ton ordinateur effectue une série d'actions ou de traitements dans un certain ordre. La description de la suite des actions s'appelle un algorithme, cela ressemble aux recettes de cuisine, de ta mère. Pour écrire cet algorithme et pour qu'il soit compris par ton ordinateur tu utilise un langage, en l’occurrence python. Ce dernier utilise des instructions pour décrire les actions. Les instructions peuvent être conditionnelles ou répétitives (boucles).
Une dernière chose Ana, sauf mention explicite de ma part les instructions s'effectuent séquentiellement, c'est-à-dire les unes après les autres dans l'ordre où elles sont écrites. Il est possible de suivre différents chemins grâce aux instructions conditionnelles.
4.1 Ana des blocs et des blocs encore
Ca va Ana ? Non j'avais un peu peur. Bon alors continuons. Il existe des instructions simples, elles sont seules, il suffit de les réaliser pour effectuer le traitement, mais il existe également des instructions composées, elles sont constituées d'un ensemble d’instructions. En python cet ensemble d'instructions est regroupé dans un bloc qui délimite l'ensemble. Un bloc pour une instruction composée à toujours la même structure :
en tête :
C'est donc l'indentation (le décalage par rapport à la marge) qui détermine un bloc. Trichons un peu, supposons que je t'ai déjà parlé de l'instruction conditionnelle if
.
>>> a = 0 # instruction simple >>> b = 10 >>> if a !=0: # en tête du bloc x = -b/a # première instruction du bloc print("x =", x) # deuxième instruction du bloc else: print("Ana ! Depuis quand on divise par zéro ?") Ana ! Depuis quand on divise par zéro ?
Tu peux essayer avec a = 2
par exemple. Nous allons avoir l'occasion de voir cela de façon plus détaillée par la suite.
4.2 Les tests
Ce sont des instructions conditionnelles, si tu veux pouvoir commencer à écrire des programmes intéressants, il faut pouvoir faire des choix. Ces choix se font en fonction de conditions qui sont vraies ou fausses. Lorsque la condition sera vraie le programme fera quelque chose et lorsqu'elle sera fausse éventuellement rien ou autre chose.
if condition:
instruction suivante
Si la condition
est vraie python effectue le bloc d'instructions
et ensuite l'instruction suivante
si elle existe. Si la condition
est fausse python passe directement à l'instruction suivante
si elle existe.
Cela est souvent traduit par "Si cela est vrai Alors je fais cela".
>>>x = -6 >>> if (x < 0): # Les parenthèses ne sont pas obligatoire mais je préfère print ("x est négatif") x est négatif >>> >>> x = 0 >>> if (x < 0): print ("x est négatif") >>>
Parfois il est également nécessaire d'effectuer un traitement lorsque la condition est fausse. On parle alors de "Si alors sinon". Cela se traduit en python avec la structure d'instruction suivante :
if condition:
else:
instruction suivante
Si la condition
est vraie python effectue le bloc d'instructions
et ensuite l'instruction suivante
si elle existe. Si la condition
est fausse python effectue l'autre bloc d'instructions
et ensuite l'instruction suivante
si elle existe.
>>> x = 0 >>> if (x < 0): print ("x est négatif") else: print("x est positif ou nul") x est positif ou nul >>>
Il est bien évidemment possible de combiner des instructions if
entre-elles.
>>> x = 0 >>> if (x < 0): print ("x est négatif") else: if (x == 0): print("x est nul") else: print("x est positif") x est nul >>>
Il existe une forme condensée pour écrire cela :
>>> x = 0 if (x < 0): print ("x est négatif") elif(x == 0): print("x est nul") else: print("x est positif") x est nul >>>
Ana remarque bien le elif
qui replace le else: if (x == 0):
et également l'indentation.
Avant d'aller plus loin, je dois reconnaître que j'ai un peu triché. Je n'ai pas présenté les opérateurs de comparaison et pourtant j'en ai déjà utilisés.
Opérateur | Condition |
---|---|
x == y | x est-il égal à y ? |
x != y | x est-il différent de y ? |
x > y | x est-il plus grand que y ? |
x >= y | x est-il plus grand ou égal à y ? |
x < y | x est-il plus petit que y ? |
x <= y | x est-il plus petit ou égal à y ? |
Il y a également les opérateurs logiques. Mais avant il faut que je te parle d'un ensemble de deux valeurs, il s'agit de l'ensemble des booléens. Cet ensemble contient deux valeurs ce sont True
et False
. Le résultat d'une condition (expression conditionnelle) est soit True
, soit False
. Une branche des mathématiques appelée la logique travaille avec ces éléments et les booléens en sont les briques de base. On combine les booléens avec des connecteurs and
or
et la négation not
. Pour savoir si x
est compris entre 10 et 15, on peut écrire :
>>> x = 11 >>> if (x >=10 and x <=19): print("x est compris entre 10 et 15") x est compris entre 10 et 15
Quand nous aurons avancé je reviendrai aussi sur ces points, car python considère que tout ce qui n'est 0
, ''
, []
, ()
, {}
et None
est vrai enfin je veux dire True
.
Ana, je te propose de terminer sur un exemple. Supposons que nous voulions écrire tous les deux un petit programme qui calcule les solutions d'une équation du second degré de la forme : {$ ax^2 + bx + c = 0$}, avec {$ x $} l'inconnue et {$ a\neq 0, b , c $} les coefficients. Dans l'ensemble des réels, une telle équation admet deux solutions, une solution ou pas de solution. On détermine cela à l'aide du discriminant noté {$ \Delta = b^2 - 4ac$}. Si
- {$ \Delta < 0$} il n'y a pas de solution dans les réels.
- {$ \Delta > 0$} il y a deux racines : {$ x_1 = \frac{-b - \sqrt{\Delta}}{2a} \quad \text{et}\quad x_2 = \frac{-b + \sqrt{\Delta}}{2a} $}.
- {$ \Delta = 0$} une racine double {$ x_1 = x_2 = \frac{-b}{2a} $}
# -*- coding: utf-8 -*- Pour le plaisir des accents
from math import sqrt # Pour la racine carrée
a = float(input("Quelle est la valeur de a : ")) # input récupère l'information
b = float(input("Quelle est la valeur de b : ")) # saisie sous la forme d'une
c = float(input("Quelle est la valeur de c : ")) # chaîne de caractères. On
# transforme en flottant
if (a != 0):
delta =(b*b) - (4*a*c) # Calcul du discriminant
if (delta < 0):
print("Pas de solution dans les réels")
elif (delta > 0):
x1 =(-b + sqrt(delta))/(2*a)
x2 =(-b - sqrt(delta))/(2*a)
print("Deux racines : x1 =",x1, "et x2=",x2)
elif (delta ==0):
print("Une racine double x1=x2=", -b/2*a)
else:
print("Équation du premier degré")
Tu peux compléter en calculant la solution si elle existe, dans le cas d'une équation du premier degré.
4.3 Des boucles, il faut répéter
Les boucles servent à répéter plusieurs fois un même traitement. Ana maintenant tu vas m'écrire 8 fois à l'écran :
- 2 pythons de la pythonisse ont sucé du bois de réglisse.
Ils ne sont plus en Suisse que des piteux pitons d'alpiniste chez un droguiste.
- 3 pythons de la pythonisse ont sucé du bois de réglisse.
Ils ne sont plus en Suisse que des piteux pitons d'alpiniste chez un droguiste.
....
- 9 pythons de la pythonisse ont sucé du bois de réglisse.
Ils ne sont plus en Suisse que des piteux pitons d'alpiniste chez un droguiste.
L'idée qui vient est d'écrire le programme suivant :
# -*- coding: utf-8 -*- Pour le plaisir des accents
print("- 2 pythons de la pythonisse ont sucé du bois de réglisse.")
print("Ils ne sont plus en Suisse que des piteux pitons d'alpiniste chez un droguiste.")
print("- 3 pythons de la pythonisse ont sucé du bois de réglisse.")
print("Ils ne sont plus en Suisse que des piteux pitons d'alpiniste chez un droguiste.")
print("- 4 pythons de la pythonisse ont sucé du bois de réglisse.")
print("Ils ne sont plus en Suisse que des piteux pitons d'alpiniste chez un droguiste.")
print("- 5 pythons de la pythonisse ont sucé du bois de réglisse.")
print("Ils ne sont plus en Suisse que des piteux pitons d'alpiniste chez un droguiste.")
print("- 6 pythons de la pythonisse ont sucé du bois de réglisse.")
print("Ils ne sont plus en Suisse que des piteux pitons d'alpiniste chez un droguiste.")
print("- 7 pythons de la pythonisse ont sucé du bois de réglisse.")
print("Ils ne sont plus en Suisse que des piteux pitons d'alpiniste chez un droguiste.")
print("- 8 pythons de la pythonisse ont sucé du bois de réglisse.")
print("Ils ne sont plus en Suisse que des piteux pitons d'alpiniste chez un droguiste.")
print("- 9 pythons de la pythonisse ont sucé du bois de réglisse.")
print("Ils ne sont plus en Suisse que des piteux pitons d'alpiniste chez un droguiste.")
Imagine maintenant qu'il faille l'écrire 20 ou 30 fois. ^_^ C'est long fastidieux et pas très intéressant, heureusement qu'il existe le copier-coller. On va essayer de faire mieux.
Il existe deux sortes de boucles en python : les boucles while
et les boucles for
. Pour les premières les instructions sont répétés tant qu'une condition est vraie. Pour les secondes tant qu'il y a des éléments dans la séquence que l'on a fixée par avance.
Les boucles while
while condition:
instruction suivante
Cette boucle fonctionne de la façon suivante : tant que la condition
est vraie le bloc d'instructions est effectué. Quand la condition
est fausse on passe à l'instruction suivante
. La condition
est une expression booléenne True
ou False
. Si l'on revient à nos pythons de la phytonisse.
On va fixer le nombre_de_fois
où l'on fait le traitement, et à chaque fois qu'on le fait on va diminuer de 1 ce nombre. La boucle devra alors s’arrêter lorsque notre variable nombre_de_fois
vaudra 0.
# -*- coding: utf-8 -*- Pour le plaisir des accents
nombre_de_fois = 8
while nombre_de_fois != 0:
# Ce bloc est exécuté tant que nombre_de_fois ne vaut pas 0
print("- Des pythons de la pythonisse ont sucé du bois de réglisse.")
print("Ils ne sont plus en Suisse que des piteux pitons d'alpiniste chez un droguiste.")
nombre_de_fois = nombre_de_fois - 1 # Il faut le faire une fois de moins
"Mais Conda cela ne fait pas ce que tu as demandé". Tu as raison Ana, il manque le nombre de python. On va le rajouter :
# -*- coding: utf-8 -*- Pour le plaisir des accents
nombre_de_fois = 8
while nombre_de_fois != 0:
print("-",8 - nombre_de_fois + 2 ,"pythons de la pythonisse ont sucé du bois de réglisse.")
print("Ils ne sont plus en Suisse que des piteux pitons d'alpiniste chez un droguiste.")
nombre_de_fois = nombre_de_fois - 1
Tu te rappelles on avait déjà utilisé la tortue, on peut recommencer pour faire une jolie rosace, par exemple.
# -*- coding: utf-8 -*- Pour le plaisir des accents
from turtle import *
speed(100) # On demande à la tortue de se presser un peu
i = 0
while i<20:
up()
goto(0,0)
down()
setheading(i*18)
i = i + 1 # On incrémente i
circle(100) # Cercle de rayon 100
up()
exitonclick()
Les boucles for
La boucle for
est capable d'itérer sur tout objet susceptible d'être indicés. "QUOI" ! Euh oui, des trucs dans lequel on range des éléments et où on peut retrouver ces éléments à l'aide d'un indice. On demande par exemple le premier élément. Regarde une chaîne de caractère, je peux demander la deuxième lettre pour exemple
c'est x
. Le for
de python peut utiliser des chaînes, des listes, des tuples et d'autres objets encore. Bon d'accord le for
c'est un peu trop fort pour le moment, mais on peut se contenter d'en voir qu'une partie.
Une boucle for
commence par une première ligne dans laquelle on fixe la variable de boucle qui va prendre successivement la valeur des éléments contenus dans l'objet fourni et le bloc d'instructions associé est alors effectué.
for variable_de_boucle in objet_indiçable :
instruction suivante
Prenons un exemple :
>>> objet = "Exemple" >>> for var_boucle in objet: print(var_boucle) E x e m p l e
La variable var_boucle
prend la valeur du premier élément le caractère 'E'
. Le bloc d'instructions est ensuite exécuté. Puis la variable var_boucle
est mise à jour avec le deuxième caractère et le bloc d'instructions à nouveau exécuté...
Le bloc d'instructions est exécuté une dernière fois lorsqu'on arrive à la dernière lettre 'e'
.
Souvent ces boucles sont utilisées pour pouvoir effectuer des traitements un nombre de fois connu à l'avance et qui ne dépend donc pas d'une condition. Par exemple, le programme concernant les pythons de la phytonisse, nous voulons que le traitement se fasse 8 fois. Pour cela il faut générer un objet itérable de 8 valeurs comprise entre 2 et 8. La fonction range()
permet de réaliser cela.
range(x) # de 0 à x - 1 range(debut, fin) # de debut à fin - 1 range(debut, fin, pas) # debut, debut + pas, debut + 2 * pas < fin
# -*- coding: utf-8 -*- Pour le plaisir des accents
for i in range(2, 10):
print("-", i ,"pythons de la pythonisse ont sucé du bois de réglisse.")
print("Ils ne sont plus en Suisse que des piteux pitons d'alpiniste chez un droguiste.")
Rejouons avec la tortue, pour tracer sin(x)
# -*- coding: utf-8 -*- Pour le plaisir des accents
from turtle import *
from math import pi, sin
tracer(False) # Pour aller plus vite
echelle = 20 # Agrandissement
x = 0 ; y = sin(x) # On part de 0 et on calcul y
dx = 0.03
up() ; goto(x,y) ; down() # On se déplace en (x, y)
for i in range(700): # On trace la courbe en calculant 700 points
xs = x + dx ; ys = sin(xs) # le nouveau point on se déplace de dx sur x
goto(xs*echelle,ys*echelle) # On va au nouveau point
x = xs # Le nouveau point ....
y = ys # ... devient l'ancien
exitonclick()
Tu peux améliorer cela, en centrant par exemple la courbe et en traçant des axes.
5. Pour s'amuser (ou pas)
Je te propose de calculer la suite de Syracuse. C'est une conjecture mathématique, c'est donc une assertion (affirmation) mathématique dont on ne connaît pas encore la démonstration mais que l'on soupçonne d'être vraie. Elle s'énonce de la manière suivante : soit un nombre N entier strictement positif, s’il est pair, on le divise par 2 et N devient alors N/2, s’il est impair, on le multiplie par 3 et on ajoute 1 et N devient N*3 + 1. On répète cela et on construit une suite d'entiers positifs dont chacun ne dépend que de son prédécesseur. De façon plus formelle, pour {$ N \in \mathbb{N}^* $}
- {$ u_0 = N $}
- et pour tout entier {$n \geq 0 : u_{n+1} = \begin{cases} \dfrac{u_n}{2}& \mbox{si } u_n \mbox{ est pair}\\ 3u_n + 1 & \mbox{si } u_n \mbox{ est impair} \end{cases} $}
La conjecture affirme que, pour tout {$ N > 0 $} , il existe un indice n tel que {$ u_n = 1 $}.
Un petit programme python va nous permettre de vérifier que c'est vrai pour une valeur de {$N$}.
# -*- coding: utf-8 -*- Pour le plaisir des accents
print("Conjecture de Syracuse\n")
sortie = False
while not sortie:
nb = input("Entrez votre nombre entier : ")
if nb.isnumeric(): # On verifie que nb est un nombre sinon on arrête
nb = int(nb)
while nb != 1:
if nb % 2 == 0: # % représente le modulo (reste de la divison)
nb = nb / 2
print(int(nb))
else:
nb = (3 * nb) + 1
print(int(nb))
print("Encore une fois nous sommes arrivés à 1.")
else:
print("Au revoir !")
sortie = True
On peut s'amuser à tracer l'évolution de la suite de Syracuse avec la tortue. C'est pas encore terrible mais cela montre comment elle évolue.
# -*- coding: utf-8 -*- Pour le plaisir des accents
from turtle import *
print("Conjecture de Syracuse\n")
sortie = False
while not sortie:
x = 0
nb = input("Entrez votre nombre entier : ")
clear(); up()
if nb.isnumeric(): # On verifie que nb est un nombre sinon on arrête
nb = int(nb)
goto(x, nb); down()
while nb != 1:
if nb % 2 == 0: # % représente le modulo (reste de la divison)
nb = nb / 2
print(int(nb))
else:
nb = (3 * nb) + 1
print(int(nb))
goto(x * 6, nb * 2)
x = x + 1
print("Encore une fois nous sommes arrivés à 1.")
else:
print("Au revoir !")
sortie = True
Tu peux chercher à compléter le programme en déterminant :
- le temps de vol : c'est le plus petit indice {$ n $} tel que {$ u_n = 1 $} ;
- le temps de vol en altitude : c'est le plus petit indice {$ n $} tel que {$ u_{n+1} < u_0 $} ;
- l'altitude maximale : c'est la valeur maximale de la suite.
Examine donc le cas de 27. Le dernier record de temps de vol en 2013 a été obtenu pour 2.361.235.441.021.745.907.775 par le projet 3x+1@home, il est de 2284.
On peut par exemple se poser la question du nombre compris entre 1 et 1 000 000 qui détient le plus grand temps de vol ? Il est conseillé pour faire cela de réduire l'affichage.
# -*- coding: utf-8 -*- Pour le plaisir des accents
print("Recherche du nombre ayant le plus grand temps de vol entre 1 et 1 000 000")
temps_vol_maxi = 0
n = 0 # nb ayant le temps de vol le plus grand
for nb in range(2,1000001):
temps_vol = 0
nb_syracuse = nb
while nb_syracuse != 1:
if nb_syracuse % 2 == 0: # % représente le modulo (reste de la divison)
nb_syracuse = nb_syracuse / 2
else:
nb_syracuse = (3 * nb_syracuse) + 1
temps_vol = temps_vol + 1
# On est sortit de la boucle on regarde si le temps de vol
# obtenu pour nb est plus grand que celui de n
if temps_vol > temps_vol_maxi:
temps_vol_maxi = temps_vol
n = nb
print(n, temps_vol_maxi)
<< Exemple d'utilisation | PythonIndex | Les fonctions >>