Nombres en Python – Python réel

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:

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

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

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.

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:

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:

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

nombre_arrondi = rond(num, 2)

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

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