Fonctions intégrées de Python 3 pour travailler avec des nombres

Introduction

Python 3 est livré avec de nombreuses fonctions intégrées que vous pouvez facilement utiliser dans n'importe quel programme sur lequel vous travaillez. Certaines fonctions vous permettent de convertir des types de données, et d'autres sont spécifiques à un certain type, comme les chaînes.

Ce tutoriel passera en revue quelques-unes des fonctions intégrées qui peuvent être utilisées avec les types de données numériques en Python 3. Nous allons examiner les fonctions suivantes :

• abs() pour la valeur absolue
• divmod() pour trouver simultanément un quotient et un reste
• pow() pour élever un nombre à une certaine puissance
• round() pour arrondir un nombre à un certain nombre de décimales.
• sum() pour calculer la somme des éléments dans un type de données itérable

Devenir familier avec ces méthodes peut vous donner plus de flexibilité lors de la programmation, afin que vous puissiez prendre des décisions éclairées en décidant quels opérateurs et fonctions utiliser. Nous allons passer en revue certaines de ces fonctions avec des exemples tout au long de ce tutoriel.

Conditions préalables

Vous devez avoir Python 3 installé et un environnement de programmation configuré sur votre ordinateur ou serveur. Si vous n'avez pas d'environnement de programmation configuré, vous pouvez consulter les guides d'installation et de configuration pour un environnement de programmation local ou pour un environnement de programmation sur votre serveur, approprié à votre système d'exploitation (Ubuntu, CentOS, Debian, etc.).

Valeur Absolue

La fonction intégrée abs() renverra la valeur absolue d'un nombre que vous lui passerez. En mathématiques, la valeur absolue fait référence à la distance qu'un nombre a sur la droite numérique par rapport à 0. La valeur absolue ne prend pas en compte dans quelle direction depuis zéro se trouve le nombre, ce qui signifie que les nombres négatifs seront représentés par des nombres positifs.

Pour donner quelques exemples, la valeur absolue de 15 est 15, la valeur absolue de -74 est 74 et la valeur absolue de 0 est 0.

La valeur absolue est un concept important pour le calcul et l'analyse réelle, mais elle a aussi du sens quand nous pensons à des situations quotidiennes comme la distance parcourue. Par exemple, si nous essayons d'atteindre un endroit distant de 58 miles mais que nous parcourons 93 miles à la place, nous avons dépassé notre destination initiale. Si nous voulons maintenant calculer combien de miles restent à parcourir pour atteindre la destination prévue, nous obtiendrons un nombre négatif, mais nous ne pouvons pas parcourir de miles négatifs.

Utilisons abs() pour résoudre ce problème :

miles_from_origin = 58	# Miles destination is from origin
miles_travelled = 93	# Miles travelled from origin to destination (too many)

Calculate how many miles destination is from current location:
miles_to_go = miles_from_origin - miles_travelled	

print(miles_to_go)		# Print how many miles left (a negative number)
print(abs(miles_to_go))	# Use absolute value to account for negative number

-35
35

Dans la sortie, nous voyons que si nous n'utilisons pas la fonction abs(), dans ce cas, nous avons un nombre négatif, -35. Bien que nous puissions être dans une situation où miles_travelled est inférieur à miles_from_origin, l'inclusion de la fonction abs() prend en compte la possibilité d'un nombre négatif.

Avec un nombre négatif, abs() renverra un nombre positif car les valeurs absolues sont toujours des nombres positifs ou zéro.

Passons en revue l'utilisation de abs() avec un nombre positif et zéro :

print(abs(89.9))
print(abs(0))

89.9
0

Nous sommes le plus susceptibles d'utiliser abs() avec une variable qui peut être positive ou négative dans un cas où nous recherchons uniquement un nombre positif. Pour tenir compte d'une entrée ou d'un résultat négatif, nous utiliserons abs() pour modifier ce qui est renvoyé afin d'obtenir un nombre positif.

Trouver le quotient et le reste dans une seule fonction

Parce que la division entière (qui renvoie un quotient) et la division modulo (qui renvoie un reste) sont étroitement liées, il peut être utile d'utiliser une fonction qui combine les deux opérations à la fois.

La fonction intégrée divmod() de Python combine les deux, retournant d'abord le quotient issu de la division entière, puis le reste.

Parce que divmod() travaillera avec deux nombres, nous devons lui passer deux nombres.

divmod(a,b)

Avec cette fonction, nous effectuons essentiellement ce qui suit :

a // b
a & b

Disons que nous avons écrit un livre de 80 000 mots. Avec notre éditeur, nous avons la possibilité d'avoir soit 300 soit 250 mots par page, et nous aimerions avoir une idée du nombre de pages que nous aurions dans chaque cas. Avec divmod(), nous pouvons voir immédiatement combien de pages nous aurions et combien de mots seraient reportés sur une page supplémentaire.

words = 80000		# How many words in our book
per_page_A = 300	# Option A, 300 words per page
per_page_B = 250	# Option B, 25- words per page

print(divmod(words,per_page_A))	# Calculate Option A
print(divmod(words,per_page_B))	# Calculate Option B

(266, 200)
(320, 0)

Dans l'Option A, nous aurons 266 pages remplies de mots et 200 mots restants (⅔ d'une page) pour un total de 267 pages, et dans l'Option B, nous aurons un livre de 320 pages bien rond. Si nous voulons être respectueux de l'environnement, nous pouvons choisir l'Option A, mais si nous voulons avoir l'air plus impressionnants avec un livre de plus grande taille, nous pouvons choisir l'Option B.

Parce que la fonction divmod() peut prendre à la fois des entiers et des flottants, passons également à un exemple qui utilise des flottants :

a = 985.5
b = 115.25

print(divmod(a,b))

(8.0, 63.5)

Dans cet exemple, 8,0 est le quotient entier de 985,5 divisé par 115,25, et 63,5 est le reste.

Gardez à l'esprit que vous pouvez utiliser l'opérateur de division entière // et l'opérateur modulo % pour vérifier ce que divmod() a fait :

print(a//b)
print(a%b)

8.0
63.5

Lors de l'utilisation de la fonction divmod() en Python, nous obtenons à la fois le nombre entier de fois que la division a lieu et le reste.

Pouvoir

En Python, vous pouvez utiliser l'opérateur ** pour élever un nombre à une puissance, ou vous pouvez utiliser la fonction intégrée pow() qui prend deux nombres en entrée.

Pour voir comment fonctionne la fonction pow(), imaginons que nous faisons des recherches sur des bactéries et que nous voulons savoir combien de bactéries nous aurons à la fin de la journée si nous commençons avec 1. Les bactéries en question doublent chaque heure, nous allons donc calculer 2 (doublage) à la puissance du nombre total d'heures (24 dans notre cas).

hours = 24
total_bacteria = pow(2,hours)

print(total_bacteria)

16777216

Nous avons passé deux entiers à la fonction pow() et déterminé qu'à la fin de cette période de 24 heures, nous aurons plus de 16 millions de bactéries.

En mathématiques, si nous voulons calculer 3 à la puissance de 3, cela s'écrit généralement comme ceci :

3³

Le calcul que nous sommes en train de compléter est 3 x 3 x 3, ce qui est égal à 27.

Pour calculer 3³ en Python, nous taperions pow(3,3).

La fonction pow() peut prendre à la fois des entiers et des flottants, et constitue une alternative à l'utilisation de l'opérateur ** lorsque vous souhaitez élever des nombres à une certaine puissance.

Arrondi des nombres

Être capable de rapidement et facilement arrondir des nombres devient important lorsque vous travaillez avec des nombres à virgule flottante qui ont beaucoup de décimales. La fonction intégrée de Python round() prend en entrée deux nombres, l'un à arrondir et l'autre qui spécifie le nombre de décimales à inclure.

Nous allons utiliser cette fonction pour prendre un flottant avec plus de 10 décimales et utiliser la fonction round() pour réduire les décimales à 4 :

i = 17.34989436516001
print(round(i,4))

17.3499

Dans l'exemple ci-dessus, le nombre à virgule flottante 17.34989436516001 est arrondi à 17.3499 car nous avons spécifié que le nombre de décimales devait être limité à 4.

Notez également que la fonction round() arrondit les nombres vers le haut, donc au lieu de fournir 17.3498 comme sortie, elle a fourni 17.3499 car le chiffre suivant le 8 décimal est le chiffre 9. Tout nombre suivi du chiffre 5 ou supérieur sera arrondi au nombre entier suivant.

Décomposons la syntaxe de round() :

round(number to round,number of decimal places)

Dans la vie quotidienne, arrondir des nombres arrive souvent, surtout lorsqu'on travaille avec de l'argent ; nous ne pouvons pas répartir un sou équitablement entre plusieurs amis.

Passons en revue un exemple de programme qui peut calculer un pourboire. Ici, nous fournirons des chiffres, mais nous pourrions réécrire le programme pour intégrer des nombres fournis par l'utilisateur. Dans cet exemple, 3 amis sont allés dans un restaurant et souhaitent partager une facture de 87,93 $équitablement, tout en ajoutant un pourboire de 20 %.

bill = 87.93				# Total bill
tip = 0.2					# 20% tip
split = 3					# Number of people splitting the bill

total = bill + (bill * tip)	# Calculate the total bill

each_pay = total / split	# Calculate what each person pays

print(each_pay)				# What each person pays before rounded

print(round(each_pay,2))	# Round the number — we can’t split pennies

35.172000000000004
35.17

Dans ce programme, nous demandons d'abord le résultat du nombre après avoir calculé la facture totale plus le pourboire divisé par 3, ce qui donne un nombre avec beaucoup de décimales : 35.172000000000004. Comme ce nombre n'a pas de sens en tant que montant monétaire, nous utilisons la fonction round() et limitons les décimales à 2, afin de pouvoir fournir un résultat sur lequel les 3 amis peuvent réellement travailler : 35.17.

Si vous préférez arrondir à un nombre n'ayant que 0 comme valeur décimale, vous pouvez le faire en utilisant 0 comme deuxième paramètre dans la fonction round() :

round(345.9874590348545304636,0)

Cela s'évaluerait à 346.0.

Vous pouvez également passer des entiers dans round() sans recevoir d'erreur, au cas où vous recevriez une entrée utilisateur sous forme d'entier plutôt que de flottant. Lorsqu'un entier est passé comme premier paramètre, un entier sera renvoyé.

Calculer une somme

La fonction sum() est utilisée pour calculer les sommes des types de données numériques composés, y compris les listes, les tuples et les dictionnaires.

Nous pouvons passer une liste à la fonction sum() pour additionner tous les éléments de la liste ensemble dans l'ordre de gauche à droite :

some_floats = [1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9]
print(sum(some_floats))

49.5

Cela fonctionnera de manière similaire avec des tuples et des dictionnaires :

print(sum((8,16,64,512)))	# Calculate sum of numbers in tuple
print(sum({-10: 'x', -20: 'y', -30: 'z'}))	# Calculate sum of numbers in dictionary 

600	# Sum of numbers in tuple
-60	# Sum of numbers in dictionary

La fonction sum() peut prendre jusqu'à 2 arguments, donc vous pouvez ajouter un nombre supplémentaire sous forme d'entier ou de flottant pour l'ajouter aux nombres qui constituent l'argument à la première position :

some_floats = [1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9]

print(sum(some_floats, 0.5))
print(sum({-10: 'x', -20: 'y', -30: 'z'},60))

50.0
0

Lorsque vous n'incluez pas un deuxième argument, la fonction sum() par défaut additionne 0 au type de données itérable composé.

Conclusion

Ce tutoriel a couvert certaines méthodes intégrées que vous pouvez utiliser avec des types de données numériques dans le langage de programmation Python.

Pour en savoir plus sur le travail avec les nombres, vous pouvez lire « Comment faire des mathématiques en Python 3 avec des opérateurs », et pour en savoir plus sur les listes, jetez un œil à « Comprendre les listes en Python 3. »