Nombres réels
En programmation, tous les nombres se distinguent, tout d'abord, en nombres entiers ( integer) et fractionnaires ( float ).
Pour déterminer le type de votre variable, Python a une fonction intégrée type() :
nom = "Ivan"
print(type(name)) #l'écran affichera <classe 'str'>
n=5
imprimer(type(n)) # <classe 'int'>
r=5.0
imprimer(type(r)) # <classe 'float'>
La valeur 5.0 est un nombre représenté sous forme décimale. En programmation, tous les nombres fractionnaires sont des nombres qui ont un point décimal dans leur notation. Ces nombres sont appelés nombres réels.
Un nombre réel est un nombre qui contient un point décimal. Les parties entières et fractionnaires sont séparées l'une de l'autre par un point, et non par une virgule comme en mathématiques.
Par exemple, les nombres\(1 \over 2\),\(\sqrt 2\) sont des nombres réels. int n'est pas suffisant pour stocker de tels nombres.
Python utilise le type de données float.
pour représenter les nombres réels.
Même si la partie fractionnaire du nombre est égale à zéro, comme dans la variable r dans l'exemple, le compilateur créera toujours une variable réelle en mémoire. Puisqu'il y a un point décimal dans la notation du nombre !. La virgule décimale, pour ainsi dire, est un signal pour le traducteur qu'il est nécessaire de créer une variable réelle.
Nombres très grands et très petits sont écrits en "virgule flottante" (dans le soi-disant format scientifique).
Au format scientifique, un nombre est représenté par une mantisse(partie significative du nombre) et un exposant. Lorsqu'ils sont écrits, la mantisse et l'exposant sont séparés l'un de l'autre par la lettre e (indiquant 10 dans une certaine mesure).
Par exemple, vous pouvez stocker la valeur de la charge d'un électron ( \(1.60217662 \times 10^{-19}\) C) dans un variable, s'écrivant sous la forme suivante ;
El = 1.60217662e-19
Presque tous les nombres réels ne peuvent pas être stockés dans la mémoire de l'ordinateur avec une précision parfaite, car un nombre limité de bits est alloué pour leur stockage.
Par conséquent, lors du calcul avec des nombres réels, les erreurs dues à l'inexactitude de la représentation s'accumulent. De plus, moins il y a d'espace alloué, plus cette erreur sera importante.
|
Entrez
Pour saisir un nombre réel à l'aide de la fonction input(), il est nécessaire de convertir la chaîne de caractères, qui est le résultat de la fonction input(), en un nombre réel en utilisant la fonction >float() :
x = float(input())
Si vous devez saisir plusieurs valeurs d'une ligne à la fois, nous utilisons la même méthode que pour les nombres entiers :
x, y = map(float, input().split())
Sortie
Lors de l'affichage des nombres réels, 16 décimales sont affichées par défaut. Ce format n'est pas toujours nécessaire. Si vous devez raccourcir le format de sortie, utilisez une sortie formatée ou des chaînes F.
Formater la sortie
Pour ce faire, appliquez la méthode format() à la chaîne que nous voulons afficher. Et à l'intérieur de la ligne, les formats sont écrits entre accolades après les deux-points. Les parenthèses de la fonction format() indiquent les noms des variables (ou constantes), dont les valeurs seront substituées dans la chaîne au lieu d'accolades dans le format spécifié. Le nombre de variables doit correspondre au nombre d'accolades. Cette méthode fonctionne en Python à partir de la version 3.
Exemple
| |
Explication |
Sortie d'écran |
x = 1 / 6
| |
|
print("{:f}".format(x))
format :f affiche 6 chiffres par défaut ; dans la partie fractionnaire |
0,166667
print("{:.3f}".format(x))
:.3 signifie sortir 3 caractères après le point |
0,167
print("{:12.4e}".format(x))
:12.4 - le premier chiffre (12) spécifie le nombre total de positions pour afficher le nombre (y compris le point) ;
deuxième nombre (4) - le nombre de chiffres dans la partie fractionnaire ;
format e - affiche le nombre au format scientifique. |
1.6667e-01
F-string
Une autre façon d'afficher une chaîne formatée consiste à utiliser des f-strings (f-string). Cette méthode est disponible en Python à partir de la version 3.6.
print(f"{x:f}")
print(f"{x:.3f}")
print(f"{x:12.4e}")
F-string est une chaîne générique commençant par f (ou F). Chaque fois que nous voulons insérer la valeur d'une variable dans une chaîne, nous devons ajouter nom de la variable entre accolades {}. À l'intérieur des accolades, vous pouvez spécifier une méthode de formatage similaire à la méthode fomat().
En plus de la méthode format() et des F-strings, vous pouvez utiliser d'autres méthodes pour formater la sortie. Nous obtenons le même résultat en écrivant les instructions de sortie comme suit :
print("%f" % (x))
imprimer("%.3f" % (x))
print("%12.4e" % (x))
Cette méthode de formatage imite la fonction printf() du langage C. La méthode est considérée comme obsolète, mais dans certains cas, elle est plus pratique. En dehors de cela, cette méthode est la seule (parmi celles répertoriées ici) qui fonctionne dans Python version 2.5 et inférieure.
|
Convertir un nombre réel en entier
Lors de la résolution de problèmes, il est souvent nécessaire d'arrondir les nombres réels aux valeurs entières les plus proches. Il y a deux fonctions pour cela.
A retenir !
- Fonction
int(x) - supprime la partie fractionnaire d'un nombre réel x.
- La fonction
round(x) - arrondit le nombre réel x à l'entier le plus proche (si la partie fractionnaire du nombre est 0,5, alors le nombre est arrondi à le nombre pair le plus proche).
Exemples
impression(entier(20.12345)) # 20
imprimer(rond(2.5)) # 2
imprimer(rond(3.5)) # 4
print(rond(-2.5)) # -2
print(round(-3.5)) # -4
|
|
|