Numériques Python, conversion de type et opérations mathématiques

Dans cet article, vous découvrirez différents nombres utilisés en Python, comment convertir un type de données en un autre, ainsi que les opérations mathématiques supportées par Python.

Type de données numériques en Python

Python prend en charge les entiers, les nombres à virgule flottante et les nombres complexes. Ils sont définis en tant que int, float et complex dans les types de données Python.

Les entiers et les nombres à virgule flottante sont séparés par un point décimal.5est un entier, tandis que5.0 est un nombre à virgule flottante.

Les nombres complexes sont écrits sous forme de + yj, oùxest le partie réelle,yest l'imaginaire.

Nous pouvons utiliser la fonction type() pour déterminer de quel type appartient une variable ou une valeur, et nous pouvons utiliser la fonction isinstance() pour vérifier si elle appartient à un type spécifique.

a =　5
# Sortie: <class 'int'>
print(type(a))
# Sortie: <class 'float'>
print(type(5.0))
# Sortie: (8+3j)
c =　5　+　3j
print(c　+　3)
# Output: True
print(isinstance(c, complex))

Bien que les entiers puissent être de longueur arbitraire, les nombres à virgule flottante ne peuvent être précis que jusqu'à15petits décimales (le16bits inexactes).

Nous traitons quotidiennement des nombres décimaux (base10) qui doit être utilisé par les programmeurs informatiques (généralement les programmeurs embarqués).2) système de numération en base16) et octal (base8) système de numération.

Dans Python, nous pouvons ajouter un préfixe devant un nombre pour représenter ces nombres. Le tableau suivant liste ces préfixes.

Voici quelques exemples

# Output:　107
print(0b1101011)
# Output:　253　(251　+　2)
print(0xFB　+　0b10)
# Output:　13
print(0o15)

Lors de l'exécution de ce programme, la sortie est :

107
253
13

Conversion de type de données

Nous pouvons convertir un nombre en un autre type de nombre. Cela s'appelle également conversion forcée.

Si l'un des opérandes est un nombre à virgule flottante, les opérations d'addition, de soustraction, etc. converteront implicitement (automatiquement) l'entier en virgule flottante.

>>>　1　+　2.0
3.0

Nous pouvons voir ci-dessus1（entier）est converti en1.0 (float) pour une addition, le résultat étant également un nombre à virgule flottante.

Nous pouvons également utiliser des fonctions intégrées telles que int(), float() et complex() pour effectuer des conversions explicites entre types. Ces fonctions peuvent même convertirchaîneconversion.

>>> int(2.3)
2
>>> int(-2.8)
-2
>>> float(5)
5.0
>>> complex('3+5j')
(3+5j)

Lors de la conversion de float en entier, le nombre est tronqué (l'entier le plus proche de zéro).

Python décimal

La classe intégrée float de Python effectue certains calculs qui peuvent nous surprendre. Nous savons tous1.1et2.2La somme est3.3Mais Python semble ne pas être d'accord.

>>> (1.1　+　2.2) ==　3.3
False

Pourquoi cela se passe-t-il ?

En fait, les nombres flottants sont implémentés sous forme de fractions binaires dans le matériel informatique, car les ordinateurs ne comprennent que le binaire (0 et1）。Pour cette raison, nous savons que la plupart des nombres décimaux ne peuvent pas être stockés de manière précise dans nos ordinateurs.

Laissons-nous donner un exemple. Nous ne pouvons pas représenter la fraction1/3représenté comme un nombre décimal. Cela donnera 0.33333333 ...d'une longueur infinie, nous ne pouvons que le faire approximativement.

Le décimal décimal original 0.1Cela entraînerait une fraction binaire 0.000 de longueur infinie.110011001100110011 ...et nos ordinateurs ne stockent qu'un nombre limité de nombres binaires.

Cela ne fera que s'approcher de 0.1，mais ne peuvent jamais être égaux. C'est donc une limitation de l'hardware informatique et non une erreur dans Python.

>>>　1.1　+　2.2
3.3000000000000003

Pour surmonter ce problème, nous pouvons utiliser le module décimal fourni avec Python. La précision des nombres flottants peut atteindre un maximum de15decimales, tandis que le module décimal a une précision configurable par l'utilisateur.

import decimal
# Sortie: 0.1
print(0.1)
# Sortie: Decimal('0.1000000000000000055511151231257827021181583404541015625')
print(decimal.Decimal(0.1))

Lorsque nous devons effectuer des calculs décimaux comme à l'école, nous utiliserons ce module.

Il conserve également le sens. Nous savons que,25.50 kilogrammes sont plus25.5Les kilogrammes sont plus précis, car ils ont deux décimales au lieu d'une.

from decimal import Decimal as D
# Sortie: Decimal('3.3')
print(D('1.1')　+　D('2.2))
# Sortie: Decimal('3.000')
print(D('1.2')　*　D('2.50'))

Notez les zéros finals de l'exemple précédent.

Nous pourrions demander pourquoi ne pas toujours utiliser Decimal plutôt que float ? La principale raison est l'efficacité. Les opérations en virgule flottante doivent être plus rapides que les opérations décimales.

Quand utiliser Decimal plutôt que float ?

Dans les cas suivants, nous utilisons généralement le décimal.

• Lorsque nous réalisons des applications financières nécessitant une représentation décimale précise.

• Quand nous devons spécifier le niveau de précision nécessaire.

• Quand nous voulons réaliser l'idée de décimales valides.

• Quand nous voulons effectuer des opérations comme à l'école

Fraction Python

Python fournit des opérations sur les décimaux via son module fractions.

Les décimaux ont un numérateur et un dénominateur, tous deux sont des entiers. Le module prend en charge les algorithmes de nombres rationnels.

Nous pouvons créer des objets Fraction de plusieurs manières.

import fractions
# Output:　3/2
print(fractions.Fraction(1.5))
# Output:　5
print(fractions.Fraction(5))
# Output:　1/3
print(fractions.Fraction(1,3))

Lorsque nous créons des fractions à partir de float, nous pourrions obtenir des résultats anormaux. Cela est dû à l'expression imparfaite du nombre flottant binaire discuté dans la section précédente.

Heureusement, les décimaux nous permettent d'utiliser des exemples de chaînes de caractères. C'est l'option privilégiée lorsque nous utilisons des nombres décimaux.

import fractions
# Used as float
# Output:　2476979795053773/2251799813685248
print(fractions.Fraction(1.1))
# Used as string
# Output:　11/10
print(fractions.Fraction('1.1))

This data type supports all basic operations. Here are some examples.

from fractions import Fraction as F
# Output:　2/3
print(F(1,3)　+　F(1,3))
# Output:　6/5
print(1　/　F(5,6))
# Output: False
print(F(-3,10) > 0)
# Output: True
print(F(-3,10) < 0)

Python Math

Python provides similar modules, such as math and random, which can perform different mathematical operations, such as trigonometric functions, logarithms, probability, and statistics, etc.

import math
# Output:　3.141592653589793
print(math.pi)
# Output:　-1.0
print(math.cos(math.pi))
# Output:　22026.465794806718
print(math.exp(10))
# Output:　3.0
print(math.log10(1000))
# Output:　1.1752011936438014
print(math.sinh(1))
# Output:　720
print(math.factorial(6))

This isIn the Python math moduleComplete list of functions and properties available.

import random
# Output:　16
print(random.randrange(10,20))
x = ['a', 'b', 'c', 'd', 'e']
# Get a random option
print(random.choice(x))
# Shuffle the order of x list
random.shuffle(x)
# Print the output after shuffling the order of x
print(x)
# Print random element
print(random.random())

Output results (random results):

19
c
['e', 'a', 'd', 'c', 'b']
0.707947055817621

This isIn the Python random moduleComplete list of functions and properties available.