Nombres en Python – Python réel

By | septembre 16, 2020

Formation Python

Vous n’avez pas besoin d’être un expert en mathématiques pour bien programmer. La vérité est que peu de programmeurs ont besoin d'en savoir plus que l'algèbre de base. Bien entendu, la quantité de mathématiques que vous devez savoir dépend de l’application sur laquelle vous travaillez. En général, le niveau de mathématiques requis pour être programmeur est inférieur à ce à quoi vous pourriez vous attendre. Bien que les mathématiques et la programmation informatique ne soient pas aussi corrélées que certains pourraient le croire, Nombres font partie intégrante de tout langage de programmation, et Python ne fait pas exception.

Dans ce didacticiel, vous apprendrez à:

  • Créer entiers et nombres à virgule flottante
  • Numéros ronds à un nombre donné de décimales
  • Formater et afficher les nombres dans cordes

Commençons!

Entiers et nombres à virgule flottante

Python a trois types de données numériques intégrés: les entiers, les nombres à virgule flottante et les nombres complexes. Dans cette section, vous découvrirez les entiers et les nombres à virgule flottante, qui sont les deux types de nombres les plus couramment utilisés. Vous en apprendrez davantage sur les nombres complexes dans une section ultérieure.

Entiers

Une entier est un nombre entier sans décimales. Par exemple, 1 est un entier, mais 1.0 n'est pas. Le nom du type de données entier est int, que vous pouvez voir avec type():

>>>

>>> type(1)

Vous pouvez créer un entier en tapant le nombre souhaité. Par exemple, ce qui suit affecte l'entier 25 à la variable num:

Lorsque vous créez un entier comme celui-ci, la valeur 25 s'appelle un entier littéral car l'entier est littéralement tapé dans le code.

Vous savez peut-être déjà comment convertir une chaîne contenant un entier en nombre en utilisant int (). Par exemple, ce qui suit convertit la chaîne "25" à l'entier 25:

int ("25") n'est pas un littéral entier car la valeur entière est créée à partir d'une chaîne.

Lorsque vous écrivez de grands nombres à la main, vous regroupez généralement les chiffres en groupes de trois séparés par une virgule ou un point décimal. Le nombre 1 000 000 est beaucoup plus facile à lire que 1000000.

En Python, vous ne pouvez pas utiliser de virgules pour regrouper les chiffres dans des littéraux entiers, mais vous pouvez utiliser des traits de soulignement (_). Les deux méthodes suivantes sont valides pour représenter le nombre un million sous forme de littéral entier:

>>>

>>> 1000000
1000000

>>> 1_000_000
1000000

Il n'y a pas de limite à la taille d'un entier, ce qui peut être surprenant étant donné que les ordinateurs ont une quantité limitée de mémoire. Essayez de saisir le plus grand nombre que vous puissiez imaginer dans la fenêtre interactive d'IDLE. Python peut le gérer sans problème!

Nombres à virgule flottante

UNE nombre à virgule flottante, ou flotte pour faire court, est un nombre avec une décimale. 1.0 est un nombre à virgule flottante, tel quel -2,75. Le nom du type de données à virgule flottante est flotte:

>>>

>>> type(1.0)

Comme les entiers, les flottants peuvent être créés à partir de littéraux à virgule flottante ou en convertissant une chaîne en flottant avec flotte():

>>>

>>> flotte("1,25")
1,25

Il existe trois façons de représenter un littéral à virgule flottante. Chacun des éléments suivants crée un littéral à virgule flottante avec une valeur d'un million:

>>>

>>> 1000000,0
1000000,0

>>> 1_000_000.0
1000000,0

>>> 1e6
1000000,0

Les deux premières méthodes sont similaires aux deux techniques de création de littéraux entiers. La troisième approche utilise Notation E pour créer un littéral float.

Pour écrire un littéral flottant en notation E, tapez un nombre suivi de la lettre e puis un autre numéro. Python prend le nombre à gauche de la e et le multiplie par dix élevé à la puissance du nombre après le e. Alors 1e6 équivaut à 1 × 10⁶.

Python utilise également la notation E pour afficher de grands nombres à virgule flottante:

>>>

>>> 200000000000000000.0
2e + 17

Le flotteur 200000000000000000.0 s'affiche comme 2e + 17. le + le signe indique que l'exposant 17 est un nombre positif. Vous pouvez également utiliser des nombres négatifs comme exposant:

Le littéral 1e-4 est interprété comme dix élevé au pouvoir -4, qui est 1/10000, ou 0,0001.

Contrairement aux entiers, les flottants ont une taille maximale. Le nombre maximum à virgule flottante dépend de votre système, mais quelque chose comme 2e400 devrait être bien au-delà des capacités de la plupart des machines. 2e400 est de 2 × 10⁴⁰⁰, ce qui est bien plus que le nombre total d'atomes dans l'univers!

Lorsque vous atteignez le nombre maximal à virgule flottante, Python renvoie une valeur flottante spéciale, inf:

inf signifie l'infini, et cela signifie simplement que le nombre que vous avez essayé de créer dépasse la valeur en virgule flottante maximale autorisée sur votre ordinateur. Le type de inf est toujours flotte:

>>>

>>> n = 2e400
>>> n
inf
>>> type(n)

Python utilise également -inf, qui signifie l'infini négatif et représente un nombre à virgule flottante négatif qui est au-delà du nombre minimal à virgule flottante autorisé sur votre ordinateur:

Vous ne rencontrerez probablement pas inf et -inf très souvent en tant que programmeur, sauf si vous travaillez régulièrement avec des nombres extrêmement importants.

Vérifie ta compréhension

Développez le bloc ci-dessous pour vérifier votre compréhension:

Ecrire un programme qui crée deux variables, num1 et num2. Tous les deux num1 et num2 doit recevoir le littéral entier 25000000, un écrit avec des traits de soulignement et un sans. Impression num1 et num2 sur deux lignes distinctes.

Vous pouvez développer le bloc ci-dessous pour voir une solution:

Tout d'abord, attribuez la valeur 25000000 à num1 sans aucun trait de soulignement:

Ensuite, sur une nouvelle ligne, attribuez la valeur 25_000_000 à la variable num2:

Imprimez les deux variables sur des lignes séparées en passant chaque variable à des appels séparés de impression():

Dans la sortie, vous pouvez voir que les deux nombres sont identiques:

Bien que les deux variables reçoivent la valeur 25000000, l'écriture de la valeur en utilisant des traits de soulignement pour regrouper les chiffres permet à un humain de déterminer rapidement ce qu'est le nombre beaucoup plus facilement. Plus besoin de plisser les yeux sur l'écran et d'essayer de compter les zéros!

Lorsque vous êtes prêt, vous pouvez passer à la section suivante.

Opérateurs et expressions arithmétiques

Dans cette section, vous apprendrez à faire de l'arithmétique de base, comme l'addition, la soustraction, la multiplication et la division, avec des nombres en Python. En cours de route, vous apprendrez quelques conventions pour écrire des expressions mathématiques dans le code.

Une addition

L'addition est effectuée avec le + opérateur:

Les deux chiffres de chaque côté de la + les opérateurs sont appelés opérandes. Dans l'exemple ci-dessus, les deux opérandes sont des entiers, mais il n'est pas nécessaire que les opérandes soient du même type.

Vous pouvez ajouter un int à un flotte sans problème:

Notez que le résultat de 1,0 + 2 est 3.0, qui est un flotte. À tout moment flotte est ajouté à un nombre, le résultat en est un autre flotte. L'ajout de deux entiers ensemble entraîne toujours un int.

Soustraction

Pour soustraire deux nombres, il suffit de mettre un - opérateur entre eux:

>>>

>>> 1 - 1
0

>>> 5,0 - 3
2.0

Tout comme l'ajout de deux entiers, la soustraction de deux entiers aboutit toujours à un int. Chaque fois que l'un des opérandes est un flotte, le résultat est aussi un flotte.

le - L'opérateur est également utilisé pour désigner les nombres négatifs:

Vous pouvez soustraire un nombre négatif d'un autre nombre, mais comme vous pouvez le voir ci-dessous, cela peut parfois sembler déroutant:

>>>

>>> 1 - -3
4

>>> 1 -3
4

>>> 1- -3
4

>>> 1-3
4

Parmi les quatre exemples ci-dessus, le premier est le plus conforme à PEP 8. Cela dit, vous pouvez entourer -3 avec des parenthèses pour rendre encore plus clair que le second - est en train de modifier 3:

L'utilisation de parenthèses est une bonne idée car cela rend votre code plus explicite. Les ordinateurs exécutent du code, mais les humains lisent le code. Tout ce que vous pouvez faire pour rendre votre code plus facile à lire et à comprendre est une bonne chose.

Multiplication

Pour multiplier deux nombres, utilisez le * opérateur:

>>>

>>> 3 * 3
9

>>> 2 * 8,0
16,0

Le type de nombre que vous obtenez de la multiplication suit les mêmes règles que l'addition et la soustraction. La multiplication de deux entiers entraîne un int, et multiplier un nombre par un flotte résulte en un flotte.

Division

le / L'opérateur est utilisé pour diviser deux nombres:

>>>

>>> 9 / 3
3.0

>>> 5,0 / 2
2,5

Contrairement à l'addition, la soustraction et la multiplication, la division avec le / L'opérateur renvoie toujours un flotte. Si vous voulez vous assurer d'obtenir un entier après avoir divisé deux nombres, vous pouvez utiliser int () pour convertir le résultat:

Garde en tête que int () supprime toute partie fractionnaire du nombre:

5,0 / 2 renvoie le nombre à virgule flottante 2,5, et int (2,5) renvoie l'entier 2 avec le .5 supprimé.

Division entière

Si vous écrivez int (5,0 / 2) vous semble un peu long, Python fournit un opérateur de deuxième division appelé le division entière opérateur (//), également connu sous le nom de division de plancher opérateur:

>>>

>>> 9 // 3
3

>>> 5,0 // 2
2.0

>>> -3 // 2
-2

le // L'opérateur divise d'abord le nombre de gauche par le nombre de droite, puis l'arrondit à un entier. Cela peut ne pas donner la valeur attendue lorsque l'un des nombres est négatif.

Par exemple, -3 // 2 Retour -2. Première, -3 est divisé par 2 obtenir -1,5. ensuite -1,5 est arrondi à -2. D'autre part, 3 // 2 Retour 1 parce que les deux nombres sont positifs.

L'exemple ci-dessus illustre également que // renvoie un nombre à virgule flottante lorsque l'un des opérandes est un flotte. C'est pourquoi 9 // 3 renvoie l'entier 3, et 5,0 // 2 renvoie le flotte 2.0.

Voyons ce qui se passe lorsque vous essayez de diviser un nombre par 0:

>>>

>>> 1 / 0
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
ZeroDivisionError: division par zéro

Python vous donne un ZeroDivisionError, vous faisant savoir que vous venez d'essayer de briser une règle fondamentale de l'univers.

Exposants

Vous pouvez élever un nombre à une puissance en utilisant le ** opérateur:

>>>

>>> 2 ** 2
4

>>> 2 ** 3
8

>>> 2 ** 4
16

Les exposants ne doivent pas nécessairement être des entiers. Ils peuvent également être des flotteurs:

>>>

>>> 3 ** 1,5
5,196152422706632

>>> 9 ** 0,5
3.0

Élever un nombre à la puissance de 0,5 équivaut à prendre la racine carrée, mais notez que même si la racine carrée de 9 est un entier, Python renvoie le flotte 3.0.

Pour les opérandes positifs, le ** opérateur renvoie un int si les deux opérandes sont des entiers et un flotte si l'un des opérandes est un nombre à virgule flottante.

Vous pouvez également élever des nombres à des puissances négatives:

>>>

>>> 2 ** -1
0,5

>>> 2 ** -2
0,25

Élever un nombre à une puissance négative équivaut à diviser 1 par le nombre élevé à la puissance positive. Alors, 2 ** -1 est le même que 1 / (2 ** 1), qui est le même que 1/2, ou 0,5. De même, 2 ** -2 est le même que 1 / (2 ** 2), qui est le même que 1/4, ou 0,25.

L'opérateur de module

le % opérateur, ou le module, renvoie le reste de la division de l'opérande gauche par l'opérande droit:

>>>

>>> 5 % 3
2

>>> 20 % 7
6

>>> 16 % 8
0

3 se divise 5 une fois avec un reste de 2, alors 5% 3 est 2. De même, 7 se divise 20 deux fois avec un reste de 6. Dans le dernier exemple, 16 est divisible par 8, alors 16% 8 est 0. À tout moment le nombre à gauche de % est divisible par le nombre à droite, le résultat est 0.

L'une des utilisations les plus courantes de % consiste à déterminer si un nombre est divisible par un autre. Par exemple, un nombre n est même si et seulement si n% 2 est 0. Qu'est-ce que tu penses dix Retour? Essayons-le:

>>>

>>> 1 % 0
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
ZeroDivisionError: division entière ou modulo par zéro

Cela a du sens car dix donne le reste de la division 1 par 0. Mais tu ne peux pas diviser 1 par 0, donc Python lève un ZeroDivisionError.

Les choses deviennent un peu délicates lorsque vous utilisez le % opérateur avec des nombres négatifs:

>>>

>>> 5 % -3
-1

>>> -5 % 3
1

>>> -5 % -3
-2

Bien que potentiellement choquants à première vue, ces résultats sont le produit d'un comportement bien défini en Python. Pour calculer le reste r de diviser un nombre X par un nombre y, Python utilise l'équation r = x - (y * (x // y)).

Par exemple, pour trouver 5% -3, Python trouve d'abord (5 // -3). Puisque 5 / -3 est à propos -1,67, cela signifie 5 // -3 est -2. Maintenant, Python multiplie cela par -3 obtenir 6. Enfin, Python soustrait 6 de 5 obtenir -1.

Expressions arithmétiques

Vous pouvez combiner des opérateurs pour former des expressions complexes. Une expression est une combinaison de nombres, d'opérateurs et de parenthèses que Python peut calculer, ou évaluer, pour renvoyer une valeur.

Voici quelques exemples d'expressions arithmétiques:

>>>

>>> 2*3 - 1
5

>>> 4/2 + 2**3
10,0

>>> -1 + (-3*2 + 4)
-3

Les règles d'évaluation des expressions sont les mêmes que celles de l'arithmétique courante. À l'école, vous avez probablement appris ces règles sous le nom ordre des opérations.

le *, /, //, et % les opérateurs ont tous égal priorité, ou priorité, dans une expression, et chacun d'eux a une priorité plus élevée que le + et - les opérateurs. C'est pourquoi 2 * 3 - 1 Retour 5 et pas 4. 2 * 3 est évalué en premier, car * a une priorité plus élevée que le - opérateur.

Vous remarquerez peut-être que les expressions de l'exemple précédent ne suivent pas la règle pour placer un espace de chaque côté de tous les opérateurs. PEP 8 dit ce qui suit à propos des espaces dans les expressions complexes:

Si des opérateurs avec des priorités différentes sont utilisés, envisagez d'ajouter des espaces autour des opérateurs avec la (les) priorité (s) la plus basse. Utilisez votre propre jugement; cependant, n'utilisez jamais plus d'un espace et ayez toujours la même quantité d'espaces blancs des deux côtés d'un opérateur binaire. (La source)

Une autre bonne pratique consiste à utiliser des parenthèses pour indiquer l’ordre dans lequel les opérations doivent être effectuées, même si les parenthèses ne sont pas nécessaires. Par exemple, (2 * 3) - 1 est potentiellement plus clair que 2 * 3 – 1.

Faites vous mentir Python

Qu'est-ce que tu penses 0,1 + 0,2 est? La réponse est 0,3, droite? Voyons ce que Python en dit. Essayez ceci dans la fenêtre interactive:

>>>

>>> 0,1 + 0,2
0,30000000000000004

Eh bien, c’est. . . presque droite. Que diable se passe-t-il ici? Est-ce un bogue en Python?

Non, ce n’est pas un bug! C'est un erreur de représentation en virgule flottante, et cela n'a rien à voir avec Python. Il est lié à la façon dont les nombres à virgule flottante sont stockés dans la mémoire d’un ordinateur.

Le nombre 0,1 peut être représenté comme la fraction 1/10. Le nombre 0,1 et sa fraction 1/10 sont représentations décimales, ou représentations en base 10. Les ordinateurs, cependant, stockent les nombres à virgule flottante dans une représentation en base 2, plus communément appelée représentation binaire.

Lorsqu'il est représenté en binaire, quelque chose de familier mais peut-être inattendu arrive au nombre décimal 0,1. La fraction 1/3 n'a pas de représentation décimale finie. C'est, 1/3 = 0,3333 ... avec une infinité de 3s après la virgule décimale. La même chose arrive à la fraction 1/10 en binaire.

La représentation binaire de 1/10 est la fraction suivante qui se répète à l'infini:

0,00011001100110011001100110011 ...

Les ordinateurs ont une mémoire finie, donc le nombre 0,1 doit être stocké comme une approximation et non comme sa vraie valeur. L'approximation qui est stockée est légèrement supérieure à la valeur réelle et ressemble à ceci:

0,1000000000000000055511151231257827021181583404541015625

Vous avez peut-être remarqué, cependant, que lorsqu'on vous a demandé d'imprimer 0,1, Imprimés Python 0,1 et non la valeur approximative ci-dessus:

Python ne coupe pas simplement les chiffres de la représentation binaire pour 0,1. Ce qui se passe réellement est un peu plus subtil.

Parce que l'approximation de 0,1 en binaire est juste cela – une approximation – il est tout à fait possible que plusieurs nombres décimaux aient la même approximation binaire.

Par exemple, les deux 0,1 et 0.10000000000000001 ont la même approximation binaire. Python imprime le nombre décimal le plus court qui partage l'approximation.

Ceci explique pourquoi, dans le premier exemple de cette section, 0,1 + 0,2 n'est pas égal 0,3. Python ajoute les approximations binaires pour 0,1 et 0,2, ce qui donne un nombre qui est ne pas l'approximation binaire pour 0,3.

Si tout cela commence à vous faire tourner la tête, ne vous inquiétez pas! À moins que vous n'écriviez des programmes pour la finance ou le calcul scientifique, vous n'avez pas à vous soucier de l'imprécision de l'arithmétique à virgule flottante.

Fonctions mathématiques et méthodes numériques

Python a quelques fonctions intégrées que vous pouvez utiliser pour travailler avec des nombres. Dans cette section, vous découvrirez trois des plus courants:

  1. rond(), pour arrondir les nombres à un certain nombre de décimales
  2. abdos(), pour obtenir la valeur absolue d'un nombre
  3. pow (), pour élever un nombre à une certaine puissance

Vous découvrirez également une méthode que vous pouvez utiliser avec des nombres à virgule flottante pour vérifier s'ils ont une valeur entière.

Nombres ronds avec rond()

Vous pouvez utiliser rond() pour arrondir un nombre à l'entier le plus proche:

>>>

>>> rond(2,3)
2

>>> rond(2,7)
3

rond() a un comportement inattendu lorsque le nombre se termine par .5:

>>>

>>> rond(2,5)
2

>>> rond(3,5)
4

2,5 est arrondi à 2, et 3,5 est arrondi à 4. La plupart des gens s'attendent à un nombre qui se termine par .5 pour être arrondi, alors regardons de plus près ce qui se passe ici.

Python 3 arrondit les nombres selon une stratégie appelée arrondir les liens à pair. UNE attacher est tout nombre dont le dernier chiffre est cinq. 2,5 et 3,1415 sont des liens, mais 1,37 n'est pas.

Lorsque vous arrondissez les liens à pair, vous regardez d'abord le chiffre une décimale à gauche du dernier chiffre de la cravate. Si ce chiffre est pair, arrondissez vers le bas. Si le chiffre est impair, vous arrondissez. C'est pourquoi 2,5 arrondit à 2 et 3,5 arrondit à 4.

Vous pouvez arrondir un nombre à un nombre donné de décimales en passant un deuxième argument à rond():

>>>

>>> rond(3,14159, 3)
3,142

>>> rond(2,71828, 2)
2,72

Le nombre 3,14159 est arrondi à trois décimales pour obtenir 3,142, et le nombre 2,71828 est arrondi à deux décimales pour obtenir 2,72.

Le deuxième argument de rond() Doit être un entier. Si ce n'est pas le cas, Python déclenche un Erreur-type:

>>>

>>> rond(2,65, 1,4)
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
    rond(2,65, 1,4)
Erreur-type: L'objet 'float' ne peut pas être interprété comme un entier

quelquefois rond() n’a pas la bonne réponse:

>>>

>>> # Valeur attendue: 2,68
>>> rond(2,675, 2)
2,67

2,675 est une égalité car elle se situe exactement à mi-chemin entre les nombres 2,67 et 2,68. Puisque Python arrondit les liens au nombre pair le plus proche, vous vous attendez à rond (2.675, 2) rendre 2,68, mais ça revient 2,67 au lieu. Cette erreur est le résultat d'une erreur de représentation en virgule flottante, pas d'un bogue dans rond().

Gérer les nombres à virgule flottante peut être frustrant, mais cette frustration n’est pas spécifique à Python. Tous les langages qui implémentent la norme à virgule flottante IEEE ont les mêmes problèmes, y compris C / C ++, Java et JavaScript.

Dans la plupart des cas, cependant, les petites erreurs rencontrées avec les nombres à virgule flottante sont négligeables, et les résultats de rond() sont parfaitement utiles.

Trouvez la valeur absolue avec abdos()

le valeur absolue d'un certain nombre n est juste n si n est positif et –n si n est négatif. Par exemple, la valeur absolue de 3 est 3, tandis que la valeur absolue de -5 est 5.

Pour obtenir la valeur absolue d'un nombre en Python, vous utilisez abdos():

>>>

>>> abdos(3)
3

>>> abdos(-5,0)
5,0

abdos() renvoie toujours un nombre positif du même type que son argument. Autrement dit, la valeur absolue d'un entier est toujours un entier positif et la valeur absolue d'un float est toujours un float positif.

Élevez-vous au pouvoir avec pow ()

Auparavant, vous avez appris à élever un nombre à une puissance en utilisant le ** opérateur. Vous pouvez aussi utiliser pow () pour obtenir le même résultat.

pow () prend deux arguments. Le premier argument est le base, ou le nombre à élever à une puissance, et le deuxième argument est le exposant, ou la puissance à laquelle le nombre doit être élevé.

Par exemple, les utilisations suivantes pow () augmenter 2 à l'exposant 3:

Tout comme avec **, l'exposant dans pow () peut être négatif:

Alors, quelle est la différence entre ** et pow ()?

le pow () La fonction accepte un troisième argument facultatif qui calcule le premier nombre élevé à la puissance du deuxième nombre, puis prend le modulo par rapport au troisième nombre. En d'autres termes, pow (x, y, z) est équivalent à (x ** y)% z.

Voici un exemple dans lequel x = 2, y = 3, et z = 2:

Première, 2 est élevé au pouvoir 3 obtenir 8. ensuite 8% 2 est calculé, ce qui est 0 car 2 se divise 8 sans reste.

Vérifiez si un flotteur est intégral

Vous connaissez peut-être les méthodes de chaîne comme .inférieur(), .plus haut(), et .trouver(). Les entiers et les nombres à virgule flottante ont également des méthodes.

Les méthodes numériques ne sont pas utilisées très souvent, mais il y en a une qui peut être utile. Les nombres à virgule flottante ont un .is_integer () méthode qui retourne Vrai si le nombre est intégral– ce qui signifie qu'il n'a pas de partie fractionnaire – et renvoie autrement Faux:

>>>

>>> num = 2,5
>>> num.is_integer()
Faux

>>> num = 2.0
>>> num.is_integer()
Vrai

Une utilisation pour .is_integer () sert à valider l'entrée utilisateur. Par exemple, si vous écrivez une application de commande en ligne pour une pizzeria, vous voudrez vérifier que la quantité de pizzas que le client entre est un nombre entier.

le rond(), abdos(), et pow () les fonctions sont des fonctions intégrées, ce qui signifie que vous n’avez rien à importer pour les utiliser. Mais ces trois fonctions effleurent à peine la surface de toutes les fonctions disponibles pour travailler avec des nombres en Python.

Pour encore plus de plaisir en mathématiques, consultez le module mathématique Python: tout ce que vous devez savoir!

Vérifie ta compréhension

Développez le bloc ci-dessous pour vérifier votre compréhension:

Écrivez un programme qui demande à l'utilisateur de saisir un nombre, puis affiche ce nombre arrondi à deux décimales. Lorsqu'il est exécuté, votre programme doit ressembler à ceci:

Entrez un nombre: 5.432
5,432 arrondi à 2 décimales est 5,43

Vous pouvez développer le bloc ci-dessous pour voir une solution:

Pour obtenir l'entrée d'un utilisateur, transmettez l'invite à contribution():

user_input = contribution("Entrez un numéro:")

Notez l'espace à la fin de la chaîne d'invite. Cela garantit qu'il y a un espace entre le texte saisi par l'utilisateur lorsqu'il commence à taper et les deux-points dans l'invite.

La valeur renvoyée par contribution() est une chaîne, vous devez donc la convertir en flottant avant de pouvoir arrondir le nombre:

Gardez à l'esprit que le code ci-dessus suppose que la chaîne user_input contient vraiment une valeur numérique et aucun autre type de texte.

Maintenant vous pouvez utiliser rond() pour arrondir la valeur à deux décimales:

nombre_arrondi = rond(num, 2)

Rappelez-vous, le premier argument pour rond() doit être le nombre à arrondir. Le deuxième argument est le nombre de décimales à arrondir.

Enfin, vous pouvez imprimer la sortie en insérant nombre_arrondi dans une f-string:

impression(F"num    arrondi à 2 décimales est nombre_arrondi")

rond() est un excellent moyen d'arrondir les valeurs, mais si vous n'arrondissez que les valeurs pour les afficher, vous pouvez envisager d'utiliser les techniques décrites dans la section suivante.

Lorsque vous êtes prêt, vous pouvez passer à la section suivante.

Nombres complexes

Python est l'un des rares langages de programmation à fournir une prise en charge intégrée des nombres complexes. Bien que les nombres complexes ne sortent pas souvent des domaines de l’informatique scientifique et de l’infographie, leur prise en charge par Python est l’une de ses forces.

Si vous avez déjà suivi un cours de calcul précalcul ou d'algèbre de niveau supérieur, vous vous souviendrez peut-être qu'un nombre complexe est un nombre avec deux composants distincts: a réel partie et un imaginaire partie.

Pour créer un nombre complexe en Python, il suffit d'écrire la partie réelle, puis un signe plus, puis la partie imaginaire avec la lettre j à la fin:

Lorsque vous inspectez la valeur de n, vous remarquerez que Python encapsule le nombre entre parenthèses:

Cette convention permet d'éliminer toute confusion selon laquelle la sortie affichée peut représenter une chaîne ou une expression mathématique.

Les nombres imaginaires ont deux propriétés, .réel et .imag, qui renvoient respectivement les composantes réelle et imaginaire du nombre:

>>>

>>> n.réel
1.0

>>> n.imag
2.0

Notez que Python renvoie à la fois les composants réels et imaginaires sous forme de flottants, même s'ils ont été spécifiés sous forme d'entiers.

Les nombres complexes ont également un .conjuguer() méthode qui renvoie le conjugué complexe du nombre:

>>>

>>> n.conjuguer()
(1-2j)

Pour tout nombre complexe, son conjuguer est le nombre complexe avec la même partie réelle et une partie imaginaire identique en valeur absolue mais avec le signe opposé. Donc dans ce cas, le conjugué complexe de 1 + 2j est 1 - 2j.

Sauf pour l'opérateur de division d'étage (//), tous les opérateurs arithmétiques qui fonctionnent avec des flottants et des entiers fonctionneront également avec des nombres complexes. Comme il ne s’agit pas d’un didacticiel de mathématiques avancé, nous ne parlerons pas des mécanismes de l’arithmétique complexe. Au lieu de cela, voici quelques exemples d'utilisation de nombres complexes avec des opérateurs arithmétiques:

>>>

>>> une = 1 + 2j
>>> b = 3 - 4j

>>> une + b
(4-2j)

>>> une - b
(-2 + 6j)

>>> une * b
(11 + 2j)

>>> une ** b
(932.1391946432212 + 95.9465336603415j)

>>> une / b
(-0,2 + 0,4 j)

>>> une // b
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
Erreur-type: ne peut pas prendre la parole sur un nombre complexe.

Fait intéressant, bien que cela ne soit pas surprenant d'un point de vue mathématique, int et flotte les objets ont aussi .réel et .imag propriétés ainsi que les .conjuguer() méthode:

>>>

>>> X = 42
>>> X.réel
42
>>> X.imag
0
>>> X.conjuguer()
42

>>> y = 3.14
>>> y.réel
3.14
>>> y.imag
0,0
>>> y.conjuguer()
3.14

Pour les flottants et les entiers, .réel et .conjuguer() renvoie toujours le numéro lui-même, et .imag revient toujours 0. Une chose à noter, cependant, est que n. réel et n.imag renvoie un entier si n est un entier et un flottant si n est un flotteur.

Maintenant que vous avez vu les bases des nombres complexes, vous vous demandez peut-être quand vous auriez besoin de les utiliser. Si vous apprenez Python pour le développement Web, la science des données ou la programmation à usage général, la vérité est que vous pouvez jamais besoin d'utiliser des nombres complexes.

Par contre, les nombres complexes sont importants dans des domaines tels que l'informatique scientifique et l'infographie. Si jamais vous travaillez dans ces domaines, vous trouverez peut-être utile la prise en charge intégrée de Python pour les nombres complexes.

Conclusion: les nombres en Python

Dans ce didacticiel, vous avez tout appris sur l'utilisation des nombres en Python. Vous avez vu qu'il existe deux types de nombres de base – les entiers et les nombres à virgule flottante – et que Python a également un support intégré pour les nombres complexes.

Dans ce didacticiel, vous avez appris:

  • Comment faire de l'arithmétique de base avec des nombres à l'aide de Python opérateurs aritmétiques
  • Comment écrire expressions arithmétiques en utilisant les meilleures pratiques PEP 8
  • Quoi nombres à virgule flottante sont et pourquoi ils ne sont pas toujours précis à 100%
  • Comment nombres ronds avec rond()
  • Quoi nombres complexes sont et comment ils sont pris en charge dans Python

Quel que soit votre niveau de confort avec les nombres et les mathématiques, vous êtes maintenant prêt à effectuer toutes sortes de calculs dans votre code Python. Vous pouvez utiliser ces connaissances pour résoudre un large éventail de problèmes que vous rencontrerez dans votre carrière de programmeur.

Lectures complémentaires

Pour plus d'informations sur les nombres et les mathématiques en Python, consultez ces ressources: