Types de Nombres et Opérations en Python

Introduction

Dans ce laboratoire, vous acquerrez une compréhension fondamentale des types de nombres et des opérations en Python. Nous explorerons les caractéristiques des types de nombres entiers (integer), booléens (boolean), à virgule flottante (floating-point) et complexes (complex), y compris leur immuabilité (immutability) et comment vérifier leurs types et adresses mémoire. Grâce à des exercices pratiques, vous apprendrez à convertir entre différents types de nombres et à effectuer des opérations arithmétiques de base, consolidant ainsi votre connaissance des capacités numériques de Python.

Explorer les Types Entier et Booléen

Dans cette étape, nous allons explorer les types de données entier (int) et booléen (bool) en Python. Les entiers sont des nombres entiers, tels que 10, -5 ou 0. Les booléens représentent l'une des deux valeurs : True ou False, et sont un sous-type des entiers.

Un concept important en Python est l'immuabilité (immutability). Les types numériques sont immuables, ce qui signifie qu'une fois qu'un objet numérique est créé, sa valeur ne peut pas être modifiée. Si vous réaffectez une variable à un nouveau nombre, elle pointera vers un nouvel objet en mémoire. Nous pouvons le vérifier à l'aide de la fonction intégrée id(), qui renvoie l'adresse mémoire unique d'un objet, et de la fonction type(), qui affiche son type de données.

L'environnement de laboratoire a déjà créé un fichier pour vous. Dans l'explorateur de fichiers du WebIDE à gauche, ouvrez le fichier ~/project/number_types.py. Ajoutez-y le code suivant :

## Demonstrate immutability of integers
a = 5
print(f"Initial value of a: {a}")
print(f"Type of a: {type(a)}")
print(f"ID of a: {id(a)}")

## Reassign 'a' to a new value
a = 6
print(f"\nNew value of a: {a}")
print(f"New ID of a: {id(a)}")

## Demonstrate boolean type
print("\n--- Boolean Types ---")
is_true = True
is_false = False
print(f"Value of is_true: {is_true}, Type: {type(is_true)}")
print(f"Value of is_false: {is_false}, Type: {type(is_false)}")

## Booleans behave like integers (1 and 0) in arithmetic
print(f"\nTrue + 5: {True + 5}")
print(f"False * 3: {False * 3}")

Après avoir ajouté le code, enregistrez le fichier. Pour exécuter le script, ouvrez le terminal intégré dans le WebIDE et exécutez la commande suivante :

python ~/project/number_types.py

Vous devriez voir une sortie similaire à ce qui suit. Notez que les adresses mémoire (ID) seront différentes sur votre système.

Initial value of a: 5
Type of a: <class 'int'>
ID of a: <memory_address_1>

New value of a: 6
New ID of a: <memory_address_2>

--- Boolean Types ---
Value of is_true: True, Type: <class 'bool'>
Value of is_false: False, Type: <class 'bool'>

True + 5: 6
False * 3: 0

La sortie montre que lorsque a a été réaffecté de 5 à 6, son ID a changé, confirmant qu'un nouvel objet entier a été créé. Elle démontre également que True est traité comme 1 et False comme 0 dans les calculs.

Travailler avec les Nombres à Virgule Flottante

Dans cette étape, nous allons travailler avec les nombres à virgule flottante (float), qui représentent les nombres réels avec un point décimal. Un problème courant avec les flottants est leur précision limitée, car ils sont stockés au format binaire. Cela peut parfois entraîner de petites imprécisions dans les calculs.

Explorons ce comportement. Ouvrez à nouveau ~/project/number_types.py et ajoutez le code suivant à la fin du fichier. Ce code démontrera le problème de précision et introduira deux façons de le gérer : la fonction round() pour un arrondi simple et le module decimal pour l'arithmétique de haute précision.

## Demonstrate floating-point numbers and precision
print("\n--- Floating-Point Numbers ---")
result = 1.1 + 2.2
print(f"1.1 + 2.2 = {result}")

## Using round() for approximation
print(f"round(result, 1) = {round(result, 1)}")

## Using the decimal module for accurate calculations
from decimal import Decimal

## Pass numbers as strings to Decimal to avoid initial float inaccuracy
d1 = Decimal('1.1')
d2 = Decimal('2.2')
decimal_result = d1 + d2
print(f"Decimal('1.1') + Decimal('2.2') = {decimal_result}")

Enregistrez le fichier et exécutez à nouveau le script depuis le terminal :

python ~/project/number_types.py

Votre sortie inclura maintenant la section suivante :

--- Floating-Point Numbers ---
1.1 + 2.2 = 3.3000000000000003
round(result, 1) = 3.3
Decimal('1.1') + Decimal('2.2') = 3.3

Comme vous pouvez le constater, l'addition standard en virgule flottante 1.1 + 2.2 ne donne pas exactement 3.3. Bien que round() puisse aider à formater la sortie, le module decimal offre un moyen d'effectuer des calculs avec la représentation décimale exacte, fournissant ainsi la réponse précise.

Introduction aux Nombres Complexes

Python prend en charge nativement les nombres complexes, qui sont essentiels dans de nombreux domaines scientifiques et techniques. Un nombre complexe possède une partie réelle et une partie imaginaire, écrit sous la forme a + bj, où j représente l'unité imaginaire.

Vous pouvez créer des nombres complexes en utilisant cette notation ou avec le constructeur complex(real, imag). Les parties réelle et imaginaire sont accessibles via les attributs .real et .imag.

Continuez à modifier le fichier ~/project/number_types.py. Ajoutez le code suivant à la fin pour explorer les nombres complexes :

## Demonstrate complex numbers
print("\n--- Complex Numbers ---")
c1 = 3 + 4j
print(f"Complex number c1: {c1}")
print(f"Type of c1: {type(c1)}")
print(f"Real part of c1: {c1.real}")
print(f"Imaginary part of c1: {c1.imag}")

## Creating a complex number with the constructor
c2 = complex(5, -2)
print(f"\nComplex number c2: {c2}")
print(f"Real part of c2: {c2.real}")
print(f"Imaginary part of c2: {c2.imag}")

Enregistrez le fichier et exécutez à nouveau le script depuis le terminal :

python ~/project/number_types.py

La nouvelle sortie sera :

--- Complex Numbers ---
Complex number c1: (3+4j)
Type of c1: <class 'complex'>
Real part of c1: 3.0
Imaginary part of c1: 4.0

Complex number c2: (5-2j)
Real part of c2: 5.0
Imaginary part of c2: -2.0

Notez que les parties réelle et imaginaire sont stockées sous forme de nombres à virgule flottante, même si vous les définissez avec des entiers.

Convertir entre les Types de Nombres

Python fournit des fonctions intégrées pour convertir entre différents types numériques, tels que int(), float() et complex(). Ceci est connu sous le nom de transtypage (type casting).

• int(x) : Convertit x en un entier. Lors de la conversion d'un flottant, il tronque la partie décimale, il n'arrondit pas.
• float(x) : Convertit x en un nombre à virgule flottante.
• complex(real, imag) : Crée un nombre complexe.

Faisons des exercices de conversion de type. Ajoutez le code suivant à la fin de votre script ~/project/number_types.py :

## Demonstrate type conversion
print("\n--- Type Conversion ---")

## Convert float to int (truncation)
float_num = 9.9
int_num = int(float_num)
print(f"float_num = {float_num}")
print(f"int(float_num) = {int_num}")

## Convert int to float
int_val = 10
float_val = float(int_val)
print(f"\nint_val = {int_val}")
print(f"float(int_val) = {float_val}")

## Convert string to number
str_num = "123.45"
converted_float = float(str_num)
converted_int = int(float(str_num)) ## Must convert to float first
print(f"\nstr_num = '{str_num}'")
print(f"float(str_num) = {converted_float}")
print(f"int(float(str_num)) = {converted_int}")

Enregistrez le fichier et exécutez à nouveau le script :

python ~/project/number_types.py

La sortie inclura maintenant cette section :

--- Type Conversion ---
float_num = 9.9
int(float_num) = 9

int_val = 10
float(int_val) = 10.0

str_num = '123.45'
float(str_num) = 123.45
int(float(str_num)) = 123

Cette sortie montre clairement comment int() tronque la décimale de 9.9 à 9. Elle illustre également le processus en deux étapes nécessaire pour convertir une chaîne de caractères contenant une décimale en un entier.

Effectuer des Opérations Arithmétiques de Base

Python prend en charge toutes les opérations arithmétiques standard. Lorsque vous effectuez une opération avec des opérandes de types numériques différents (par exemple, un int et un float), Python "élargit" automatiquement le résultat vers le type le plus général. La hiérarchie est int -> float -> complex.

Voici les opérateurs courants :

• + (Addition)
• - (Soustraction)
• * (Multiplication)
• / (Division - résulte toujours en un flottant)
• // (Division entière ou division par plancher - divise et arrondit à l'entier inférieur)
• % (Modulo - retourne le reste d'une division)
• ** (Exposant)

Pour conclure notre exploration, ajoutons une dernière section au fichier ~/project/number_types.py pour pratiquer ces opérations.

## Demonstrate basic arithmetic operations
print("\n--- Basic Arithmetic Operations ---")
a = 10
b = 3

print(f"{a} + {b} = {a + b}")
print(f"{a} - {b} = {a - b}")
print(f"{a} * {b} = {a * b}")
print(f"{a} / {b} = {a / b}")
print(f"{a} // {b} = {a // b}")
print(f"{a} % {b} = {a % b}")
print(f"{a} ** {b} = {a ** b}")

## Demonstrate mixed-type operations
print("\n--- Mixed-Type Operations ---")
int_op = 5
float_op = 2.5
result_mixed = int_op * float_op
print(f"{int_op} (int) * {float_op} (float) = {result_mixed} ({type(result_mixed)})")

Enregistrez le fichier et exécutez le script complet :

python ~/project/number_types.py

La sortie finale inclura :

--- Basic Arithmetic Operations ---
10 + 3 = 13
10 - 3 = 7
10 * 3 = 30
10 / 3 = 3.3333333333333335
10 // 3 = 3
10 % 3 = 1
10 ** 3 = 1000

--- Mixed-Type Operations ---
5 (int) * 2.5 (float) = 12.5 (<class 'float'>)

Cette sortie confirme le comportement de chaque opérateur. Notez que la division standard / produit un flottant, tandis que la division entière // produit un entier. L'opération de type mixte entre un entier et un flottant donne un flottant, comme prévu.

Résumé

Dans ce laboratoire, vous avez acquis une base solide dans les types de données numériques de Python. Vous avez découvert les entiers (integers), les booléens (booleans), les flottants (floats) et les nombres complexes (complex numbers). Vous avez exploré le concept d'immuabilité et utilisé les fonctions id() et type() pour inspecter les objets. Vous vous êtes exercé à gérer les problèmes de précision des virgules flottantes avec le module decimal, à convertir entre différents types numériques en utilisant int(), float() et complex(), et à effectuer une gamme d'opérations arithmétiques. Ces connaissances sont cruciales pour toute tâche de programmation ou d'analyse de données ultérieure en Python.