Nombres Python, conversion de type et mathématiques

Numéros Python, conversion de type et mathématiques

Dans cet article, vous découvrirez les différents nombres utilisés dans Python, comment convertir d'un type de données à l'autre et les opérations mathématiques prises en charge dans Python.

Type de données numérique en Python

Python prend en charge les nombres entiers, les nombres à virgule flottante et les nombres complexes. Ils sont définis comme int , float , et complex classes en Python.

Les entiers et les virgules flottantes sont séparés par la présence ou l'absence d'un point décimal. Par exemple, 5 est un entier alors que 5,0 est un nombre à virgule flottante.

Les nombres complexes s'écrivent sous la forme x + yj , où x est la partie réelle et y est la partie imaginaire.

Nous pouvons utiliser le type() fonction pour savoir à quelle classe appartient une variable ou une valeur et isinstance() fonction pour vérifier s'il appartient à une classe particulière.

Prenons un exemple :

a = 5

print(type(a))

print(type(5.0))

c = 5 + 3j
print(c + 3)

print(isinstance(c, complex))

Lorsque nous exécutons le programme ci-dessus, nous obtenons la sortie suivante :

<class 'int'>
<class 'float'>
(8+3j)
True

Alors que les nombres entiers peuvent être de n'importe quelle longueur, un nombre à virgule flottante n'est précis que jusqu'à 15 décimales (la 16ème est inexacte).

Les nombres que nous traitons chaque jour sont du système décimal (base 10). Mais les programmeurs informatiques (généralement les programmeurs embarqués) doivent travailler avec des systèmes de numération binaire (base 2), hexadécimal (base 16) et octal (base 8).

En Python, nous pouvons représenter ces nombres en plaçant de manière appropriée un préfixe avant ce nombre. Le tableau suivant répertorie ces préfixes.

Système de numération	Préfixe
Binaire	'0b' ou '0B'
Octal	'0o' ou '0O'
Hexadécimal	'0x' ou '0X'

Voici quelques exemples

# Output: 107
print(0b1101011)

# Output: 253 (251 + 2)
print(0xFB + 0b10)

# Output: 13
print(0o15)

Lorsque vous exécutez le programme, la sortie sera :

107
253
13

Conversion de types

Nous pouvons convertir un type de nombre en un autre. Ceci est également connu sous le nom de coercition.

Des opérations comme l'addition, la soustraction forcent l'entier à flotter implicitement (automatiquement), si l'un des opérandes est flottant.

>>> 1 + 2.0
3.0

Nous pouvons voir ci-dessus que 1 (entier) est converti en 1.0 (flottant) pour l'addition et le résultat est également un nombre à virgule flottante.

Nous pouvons également utiliser des fonctions intégrées comme int() , float() et complex() pour convertir entre les types explicitement. Ces fonctions peuvent même convertir à partir de chaînes.

>>> 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é (les parties décimales sont supprimées).

Python Décimal

La classe flottante intégrée de Python effectue des calculs qui pourraient nous étonner. Nous savons tous que la somme de 1.1 et 2.2 est 3.3, mais Python semble être en désaccord.

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

Que se passe-t-il ?

Il s'avère que les nombres à virgule flottante sont implémentés dans le matériel informatique sous forme de fractions binaires car l'ordinateur ne comprend que le binaire (0 et 1). Pour cette raison, la plupart des fractions décimales que nous connaissons ne peuvent pas être stockées avec précision dans notre ordinateur.

Prenons un exemple. Nous ne pouvons pas représenter la fraction 1/3 sous la forme d'un nombre décimal. Cela donnera 0,33333333... ce qui est infiniment long, et nous ne pouvons qu'en faire une approximation.

Il s'avère que la fraction décimale 0,1 se traduira par une fraction binaire infiniment longue de 0,000110011001100110011... et notre ordinateur n'en stocke qu'un nombre fini.

Cela ne sera qu'approximatif de 0,1 mais ne sera jamais égal. Par conséquent, il s'agit de la limitation de notre matériel informatique et non d'une erreur de Python.

>>> 1.1 + 2.2
3.3000000000000003

Pour surmonter ce problème, nous pouvons utiliser le module décimal fourni avec Python. Alors que les nombres à virgule flottante ont une précision jusqu'à 15 décimales, le module décimal a une précision réglable par l'utilisateur.

Voyons la différence :

import decimal

print(0.1)

print(decimal.Decimal(0.1))

Sortie

0.1
0.1000000000000000055511151231257827021181583404541015625

Ce module est utilisé lorsque nous voulons effectuer des calculs décimaux comme nous l'avons appris à l'école.

Il préserve également la signification. Nous savons que 25,50 kg est plus précis que 25,5 kg car il a deux décimales significatives par rapport à une.

from decimal import Decimal as D

print(D('1.1') + D('2.2'))

print(D('1.2') * D('2.50'))

Sortie

3.3
3.000

Remarquez les zéros de fin dans l'exemple ci-dessus.

Nous pourrions demander, pourquoi ne pas implémenter Decimal à chaque fois, au lieu de flotter ? La principale raison est l'efficacité. Les opérations en virgule flottante sont effectuées doivent être plus rapides que Decimal opérations.

Quand utiliser Decimal au lieu de float ?

Nous utilisons généralement Decimal dans les cas suivants.

Lorsque nous créons des applications financières nécessitant une représentation décimale exacte.
Lorsque nous voulons contrôler le niveau de précision requis.
Lorsque nous souhaitons mettre en œuvre la notion de décimales significatives.

Fraction Python

Python fournit des opérations impliquant des nombres fractionnaires via son fractions module.

Une fraction a un numérateur et un dénominateur, qui sont tous deux des nombres entiers. Ce module prend en charge l'arithmétique des nombres rationnels.

Nous pouvons créer des objets Fraction de différentes manières. Jetons-y un coup d'œil.

import fractions

print(fractions.Fraction(1.5))

print(fractions.Fraction(5))

print(fractions.Fraction(1,3))

Sortie

3/2
5
1/3

Lors de la création de Fraction à partir de float , nous pourrions obtenir des résultats inhabituels. Cela est dû à la représentation binaire imparfaite des nombres à virgule flottante, comme indiqué dans la section précédente.

Heureusement, Fraction nous permet également d'instancier avec une chaîne. Il s'agit de l'option préférée lors de l'utilisation de nombres décimaux.

import fractions

# As float
# Output: 2476979795053773/2251799813685248
print(fractions.Fraction(1.1))

# As string
# Output: 11/10
print(fractions.Fraction('1.1'))

Sortie

2476979795053773/2251799813685248
11/10

Ce type de données prend en charge toutes les opérations de base. Voici quelques exemples.

from fractions import Fraction as F

print(F(1, 3) + F(1, 3))

print(1 / F(5, 6))

print(F(-3, 10) > 0)

print(F(-3, 10) < 0)

Sortie

2/3
6/5
False
True

Mathématiques Python

Python propose des modules comme math et random pour effectuer différentes mathématiques comme la trigonométrie, les logarithmes, les probabilités et les statistiques, etc.

import math

print(math.pi)

print(math.cos(math.pi))

print(math.exp(10))

print(math.log10(1000))

print(math.sinh(1))

print(math.factorial(6))

Sortie

3.141592653589793
-1.0
22026.465794806718
3.0
1.1752011936438014
720

Voici la liste complète des fonctions et attributs disponibles dans le module mathématique Python.

import random

print(random.randrange(10, 20))

x = ['a', 'b', 'c', 'd', 'e']

# Get random choice
print(random.choice(x))

# Shuffle x
random.shuffle(x)

# Print the shuffled x
print(x)

# Print random element
print(random.random())

Lorsque nous exécutons le programme ci-dessus, nous obtenons la sortie comme suit. (Les valeurs peuvent être différentes en raison du comportement aléatoire)

18
e
['c', 'e', 'd', 'b', 'a']
0.5682821194654443

Voici la liste complète des fonctions et attributs disponibles dans le module aléatoire Python.

Paquet Python Liste Python

Python