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

introduction

Python 3 comprend 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 convert de types de données, et d’autres sont spécifiques à un certain type, comme strings.

Ce didacticiel présente quelques fonctions intégrées pouvant être utilisées avec des types de données numériques dans Python 3. Nous allons passer en revue les fonctions suivantes:

  • + abs () + pour la valeur absolue

  • + divmod () + pour trouver un quotient et le reste simultanément

  • + pow () + pour élever un nombre à un certain pouvoir

  • + round () + pour arrondir un nombre à une certaine décimale

  • + sum () + pour calculer la somme des éléments d’un type de données itérable

Se familiariser avec ces méthodes peut vous donner plus de flexibilité lors de la programmation, ce qui vous permet de prendre des décisions éclairées lorsque vous choisissez les opérateurs et les fonctions à utiliser. Nous allons passer en revue certaines de ces fonctions avec des exemples tout au long de ce tutoriel.

Valeur absolue

La fonction intégrée + abs () + renverra la valeur absolue d’un nombre que vous lui passerez. En mathématiques, * valeur absolue * désigne la distance à laquelle un nombre se trouve sur la droite numérique à partir de 0. La valeur absolue ne prend pas en considération la direction à partir de laquelle 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 également un sens lorsque nous pensons à des situations quotidiennes comme la distance parcourue. Par exemple, si nous essayons d’obtenir un lieu éloigné de 58 km mais que nous parcourons 150 km, nous avons dépassé notre destination initiale. Si nous voulons calculer maintenant le nombre de kilomètres restant à parcourir pour atteindre la destination voulue, nous nous retrouverons avec un nombre négatif, mais nous ne pouvons pas parcourir des kilomètres négatifs.

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

destination_miles.py

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
Output-35
35

Dans le résultat, nous voyons que si nous n’utilisons pas la fonction + abs () +, nous avons dans cet exemple un nombre négatif, + -35 +. Bien que nous soyons peut-être dans une position où + miles_travelled + est inférieur à + ​​miles_from_origin +, 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 utilisant + abs () + avec un nombre positif et zéro:

print(abs(89.9))
print(abs(0))
Output89.9
0

Il est plus probable que nous utilisions + abs () + avec une variable qui peut être positive ou négative dans un cas où nous recherchons uniquement un nombre positif. Pour prendre en compte une entrée ou un résultat négatif, nous utiliserons + abs () + pour modifier le nombre retourné.

Trouver le quotient et le reste en une seule fonction

Étant donné que la division de plancher (qui renvoie un quotient) et la division modulo (qui renvoie un reste) sont étroitement liées, il peut être utile d’utiliser une fonction combinant les deux opérations en même temps.

La fonction intégrée Python + divmod () + combine les deux, renvoyant d’abord le quotient qui provient de la division de l’étage, 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 les opérations suivantes:

a // b
a & b

Disons que nous avons écrit un livre de 80 000 mots. Avec notre éditeur, nous avons le choix entre 300 ou 250 mots par page. 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 renversés sur une page supplémentaire.

words_per_page.py

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
Output(266, 200)
(320, 0)

Dans l’option A, nous aurons 266 pages de mots et 200 mots restants (de page), pour un total de 267 pages, et dans l’option B, nous aurons un livre de 320 pages. Si nous voulons être soucieux de l’environnement, nous pouvons choisir l’option A, mais si nous voulons paraître plus impressionnant avec un livre plus grand, nous pouvons choisir l’option B.

Comme la fonction + divmod () + peut prendre à la fois des entiers et des flottants, passons également à un exemple utilisant les flottants:

a = 985.5
b = 115.25

print(divmod(a,b))
Output(8.0, 63.5)

Dans cet exemple, "+ 8.0 " est le quotient plancher de 985.5 divisé par 115.25, et " 63.5 +" est le reste.

N’oubliez pas que vous pouvez utiliser l’opérateur de division d’étage + // + et l’opérateur modulo +% + pour vérifier ce que + divmod () + a fait:

print(a//b)
print(a%b)
Output8.0
63.5

Lorsque vous utilisez la fonction + divmod () + en Python. nous obtenons à la fois le nombre total de fois où la division a eu lieu et le reste renvoyé.

Puissance

En Python, vous pouvez utiliser le l’opérateur + ** + à augmentez un nombre d’un exposant, ou vous pouvez utiliser la fonction intégrée + pow () + qui prend deux nombres.

Pour voir comment fonctionne la fonction + pow () +, disons que nous menons des recherches sur les bactéries et que nous voulons savoir combien de bactéries nous aurons à la fin de la journée si nous commençons par 1. Les bactéries avec lesquelles nous travaillons doublent toutes les heures. Nous allons donc calculer 2 (doubler) la puissance du nombre total d’heures (24 dans notre cas).

bactéries.py

hours = 24
total_bacteria = pow(2,hours)

print(total_bacteria)
Output16777216

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

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

Le calcul que nous complétons est 3 x 3 x 3, ce qui équivaut à 27.

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

La fonction + pow () + prend à la fois des entiers et des flottants, et offre une alternative à l’utilisation de l’opérateur + ** + lorsque vous avez l’intention d’augmenter les nombres à une certaine puissance.

Chiffres arrondis

Il est important de pouvoir arrondir rapidement et facilement les nombres arrondis lorsque vous travaillez avec des flotteurs comportant beaucoup de décimales. La fonction Python intégrée + round () + prend deux nombres, l’un devant être arrondi et l’autre indiquant le nombre de décimales à inclure.

Nous allons utiliser la fonction pour prendre un float 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))
Output17.3499

Dans l’exemple ci-dessus, le flottant + 17.34989436516001 + est arrondi à + ​​17.3499 + car nous avons spécifié que le nombre de décimales doit être limité à 4.

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

Décomposons la syntaxe de + round () +:

round(,)

Dans la vie de tous les jours, il est fréquent d’arrondir les chiffres, surtout lorsque l’on travaille avec de l’argent. nous ne pouvons pas partager un sou de façon égale entre plusieurs amis.

Examinons un exemple de programme simple permettant de calculer un pourboire. Ici, nous fournirons des chiffres, mais nous pourrions réécrire le programme pour y ajouter des chiffres fournis par les utilisateurs. Dans cet exemple, 3 amis sont allés au restaurant et voulaient fractionner une facture de 87,93 $ de manière égale, en ajoutant un pourboire de 20%.

bill_split.py

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
Output35.172000000000004
35.17

Dans ce programme, nous demandons d’abord la sortie 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 chiffre monétaire, nous utilisons la fonction + round () + et limitons le nombre de décimales à 2, afin de pouvoir fournir un résultat avec lequel les 3 amis peuvent réellement travailler: `+ 35.17 + `.

Si vous préférez arrondir à un nombre avec seulement 0 comme valeur décimale, vous pouvez le faire en utilisant 0 comme deuxième paramètre de la fonction + round () +:

round(345.9874590348545304636,0)

Cela serait évalué à + ​​346.0 +.

Vous pouvez également passer des entiers dans + round () + sans recevoir d’erreur, au cas où vous recevriez une entrée utilisateur sous la forme d’un entier plutôt que d’un float. Lorsqu’un entier est passé en tant que premier paramètre, un entier est renvoyé.

Calculer une somme

La fonction + sum () + est utilisée pour calculer les sommes de types de données composés numériques, notamment lists, https: //www.digitalocean.com/community/tutorials/understanding-tuples-in-python-3[tuples], et https://www.digitalocean.com/community/tutorials/understanding-dictionaries-in-python-3 [ dictionnaires].

Nous pouvons passer une liste à la fonction + sum () + pour additionner tous les éléments de la liste 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))
Output49.5

Cela fonctionnera de la même manière avec les tuples et les 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
Output600 # Sum of numbers in tuple
-60 # Sum of numbers in dictionary

La fonction + sum () + peut prendre jusqu’à 2 arguments, vous pouvez donc ajouter un nombre supplémentaire sous forme entière ou flottante à ajouter aux nombres constituant 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))
Output50.0
0

Lorsque vous n’incluez pas de second argument, la fonction + sum () + ajoute par défaut 0 au type de données composé itérable.

Conclusion

Ce didacticiel couvre 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 l’utilisation des nombres, vous pouvez lire «https://www.digitalocean.com/community/tutorials/how-to-do-math-in-python-3-with-operators[Comment faire des maths en Python 3 avec les opérateurs] ”, et pour en savoir plus sur les listes, consultez“ Comprendre les listes dans Python 3. ”