Conversion des types de données en Python : Un guide avec des exemples

Dans l'exemple, une valeur entière a_int a été ajoutée à une valeur flottante b_float, et le résultat a été automatiquement converti en une valeur flottante c_sum sans que vous ayez à le dire au compilateur. Il s'agit de la conversion implicite des données.

Pourquoi la valeur flottante n'a-t-elle pas été convertie en entier ?

Ceci est dû à un concept plus large de promotion de type en informatique. En termes simples, il s'agit d'un mécanisme de défense du compilateur qui vous permet d'effectuer des opérations chaque fois que cela est possible en convertissant vos données dans un supertype différent sans perdre d'informations.

Cela signifie que la conversion de flottant en entier n'est pas effectuée, car le compilateur devrait alors supprimer la partie fractionnaire, ce qui entraînerait une perte d'informations.

Conversion explicite des types de données en Python

La conversion explicite de type de données, souvent appelée "moulage de type", se produit lorsque vous convertissez délibérément une valeur d'un type de données à un autre. Cette approche vous donne un contrôle direct sur la conversion, puisque vous spécifiez explicitement le type de données cible dans votre code. Elle est couramment utilisée lorsque la conversion automatique (implicite) fournie par Python ne répond pas à vos besoins.

La syntaxe de la conversion explicite est la suivante :

target_data_type(expression)

Par exemple, si vous voulez convertir un nombre à virgule flottante en un nombre entier, vous devez écrire :

int(3.14)  # Converts 3.14 to 3

Note : Bien que les conversions explicites soient très utiles, elles peuvent entraîner une perte d'informations. Par exemple, la conversion d'un nombre à virgule flottante en un nombre entier ne tient pas compte de sa partie fractionnaire. Il est important de comprendre ces conséquences afin d'éviter des résultats inattendus dans vos programmes.

Examinons quelques conversions de types de données explicites couramment utilisées.

Structures de données primitives et non primitives en Python

Les structures de données primitives sont les éléments de base de la manipulation des données et contiennent des valeurs de données pures et simples. Python dispose de quatre types de variables primitives :

• Entiers
• Flotteur
• Cordes
• Booléen

Les structures de données non primitives ne stockent pas seulement une valeur, mais plutôt une collection de valeurs dans différents formats. En Python, vous disposez des structures de données non primitives suivantes :

• Listes
• Tuples
• Dictionnaires
• Jeux

Vous pouvez en apprendre davantage à leur sujet grâce au tutoriel de DataCamp sur les structures de données en Python.

Conversions de structures de données primitives

Conversions d'entiers et de flottants en Python

Les entiers et les flottants sont des types de données qui traitent des nombres.

Pour convertir un nombre entier en un nombre flottant, utilisez la fonction float() de Python. De même, si vous souhaitez convertir un nombre flottant en nombre entier, vous pouvez utiliser la fonction int().

a_int = 3
b_int = 2

# Explicit type conversion from int to float
c_float_sum = float(a_int + b_int)
print(c_float_sum)

5.0

a_float = 3.3
b_float = 2.0

# Explicit type conversion from float to int
c_int_sum = int(a_float + b_float)
print(c_int_sum)

c_float_sum = a_float + b_float
print(c_float_sum)

5
5.3

Les problèmes de précision des flottants et la Decimal module

L'arithmétique en virgule flottante dans Python peut entraîner des problèmes de précision :

print(0.1 + 0.2)  # Output: 0.30000000000000004

Pour éviter cela, utilisez le module Decimal:

from decimal import Decimal

print(Decimal('0.1') + Decimal('0.2'))  # Output: 0.3

Conversion des types de données réels en types de données complexes en Python

Vous pouvez convertir des nombres entiers en nombres complexes en utilisant complex(real,imag). Il nécessite deux nombres entiers (réels et imaginaires) et convertit les nombres réels en nombres complexes.

real = 2
imag = 5
print(complex(real, imag))

(2+5j)

Conversion des types de données Python avec les chaînes de caractères

Une chaîne de caractères est un ensemble d'un ou plusieurs caractères (lettres, chiffres, symboles). Il se peut que vous deviez convertir assez souvent des chaînes de caractères en nombres ou des nombres en chaînes de caractères.

price_cake = 15
price_cookie = 6
total = price_cake + price_cookie
print("The total is: " + total  + "$")

 
---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-12-54bd76b9b4bd> in <module>()
      2 price_cookie = 6
      3 total = price_cake + price_cookie
----> 4 print("The total is: " + total  + "$")


TypeError: Can't convert 'int' object to str implicitly

L'exemple ci-dessus donne un TypeError, indiquant que le compilateur ne peut pas convertir implicitement une valeur entière en une chaîne de caractères.

Ce que le programme doit faire ici peut vous sembler intuitif. Cependant, le compilateur n'en est pas toujours sûr, et il fournit donc un mécanisme de moulage explicite des types afin que vous puissiez indiquer clairement ce que vous voulez. Voici comment vous pouvez convertir un entier en chaîne de caractères en Python à l'aide de la fonction str():

price_cake = 15
price_cookie = 6
total = price_cake + price_cookie
print("The total is: " + str(total)  + "$")

The total is: 21$

Cela fonctionne de la même manière lorsque vous convertissez des valeurs flottantes en chaînes de caractères.

En Python, vous pouvez également convertir les chaînes de caractères en valeurs entières et flottantes lorsque cela est possible. Voyons ce que cela signifie :

price_cake = '15'
price_cookie = '6'

# String concatenation
total = price_cake + price_cookie
print("The total is: " + total + "$")

# Explicit type conversion to integer
total = int(price_cake) + int(price_cookie)
print("The total is: " + str(total)  + "$")

The total is: 156$
The total is: 21$

Décomposons le code.

price_cake et price_cookie sont initialement des chaînes de caractères. Ensuite, vous devez trouver le total, ce qui signifie qu'ils doivent d'abord être convertis en leurs valeurs entières correspondantes. Sinon, le compilateur supposera que l'opération que vous souhaitez effectuer est une concaténation de chaînes de caractères plutôt qu'une addition numérique. Vous devez ensuite placer cette valeur dans la chaîne d'affichage finale et, par conséquent, convertir le total en chaîne pour le concaténer avec le reste du message d'affichage.

Nous espérons que cet exemple vous aidera à comprendre l'importance des conversions de types de données. Bien qu'il s'agisse d'un tout petit exemple de conversion de type de données, vous pouvez déjà voir à quel point cela peut être utile.

Note: avez-vous remarqué le "chaque fois que possible" lors de la conversion d'une chaîne de caractères en nombres entiers ou flottants ? En effet, il n'est pas toujours possible de convertir des chaînes de caractères en nombres et de leur appliquer des opérations numériques. Le compilateur en est conscient et vous donnera donc une erreur si vous essayez de le faire. Consultez l'exemple ci-dessous :

price_cake = 'fifteen'
price_cookie = 'six'
total = int(price_cake) + int(price_cookie)

---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

<ipython-input-25-80591b8accda> in <module>()
      1 price_cake = 'fifteen'
      2 price_cookie = 'six'
----> 3 total = int(price_cake) + int(price_cookie)


ValueError: invalid literal for int() with base 10: 'fifteen'

Résumé : Conversions de types de données primitives en Python

Conversions de structures de données non primitives

Conversion des types Python en tuples et en listes

Comme pour les entiers et les flottants, vous pouvez également convertir des listes en tuples et des tuples en listes.

Vous vous souvenez de ce que sont les tuples et les listes ? Les listes et les tuples en Python permettent de stocker une collection d'éléments homogènes. La différence entre les tuples et les listes est que les tuples sont immuables, ce qui signifie qu'une fois définis, vous ne pouvez pas supprimer, ajouter ou modifier les valeurs qu'ils contiennent.

Pourquoi convertir des listes en tuples ?

En effet, les tuples sont des types de données immuables qui permettent d'optimiser considérablement les programmes que vous créez.

Et pourquoi convertir des tuples en listes ?

Vous souhaitez peut-être apporter des modifications au tuple initial. Vous pouvez donc les convertir en listes, effectuer la modification, puis les reconvertir en tuples.

En Python, vous pouvez utiliser la fonction tuple() pour renvoyer une version tuple de la valeur qui lui a été transmise, et de la même manière la fonction list() pour convertir un tuple en une liste :

a_tuple = ('a', 1) ,('f', 2), ('g', 3)
b_list = [1,2,3,4,5]

print(tuple(b_list))
print(list(a_tuple))

(1, 2, 3, 4, 5)
[('a', 1), ('f', 2), ('g', 3)]

De même, voici comment convertir une chaîne de caractères en liste ou en tuple en Python :

dessert = 'Cake'

# Convert the characters in a string to individual items in a tuple
print(tuple(dessert))

# Convert a string into a list
dessert_list = list(dessert)
dessert_list.append('s')
print(dessert_list)

('C', 'a', 'k', 'e')
['C', 'a', 'k', 'e', 's']

Conversion de types Python vers des dictionnaires et des ensembles

Vous pouvez utiliser la fonction dict() pour convertir un tuple en dictionnaire et set() pour convertir une liste en ensemble. 

print(dict(a_tuple))
print(set(b_list))

{'a': 1, 'f': 2, 'g': 3}
{1, 2, 3, 4, 5}

Plus simple que les autres fonctions de conversion, il vous suffit de fournir un nom de fonction pour convertir n'importe quel type de données en dictionnaires et en ensembles.

L'utilisation dataclasses pour les données structurées (Python 3.7+)

Au lieu d'utiliser des dictionnaires ou des tuples, dataclasses offre une meilleure façon de traiter les données structurées.

from dataclasses import dataclass

@dataclass
class Product:
    name: str
    price: float
    in_stock: bool

item = Product("Laptop", 799.99, True)
print(item)  # Output: Product(name='Laptop', price=799.99, in_stock=True)

Résumé : Conversions de structures de données non primitives en Python

Entiers Unicode, binaires, octaux et hexadécimaux en Python

Les systèmes de numération font référence au nombre de symboles ou de caractères représentant une valeur numérique. Le système de numération que vous utilisez généralement tous les jours est appelé décimal. Dans le système décimal, vous utilisez dix symboles différents : 0, 1, 2, 3, 4, 5, 6, 7, 8 et 9. Avec ces dix symboles, vous pouvez représenter n'importe quelle quantité. Unicode, binaire, hexadécimal et octal font référence à des systèmes de numération différents.

Vous passez au chiffre suivant lorsque vous n'avez plus de symboles. Dans le système décimal, pour représenter un chiffre supérieur à 9, vous utilisez 10, ce qui signifie une unité de dix et zéro unité de un. Il en va différemment dans d'autres systèmes de numération. Par exemple, si vous considérez un système binaire qui n'utilise que deux symboles, 0 et 1, vous devez passer au chiffre suivant lorsque vous n'avez plus de symboles. Voici donc comment vous allez compter en binaire : 0, 1, 10, 11, 100, 101, etc.

Dans les sections suivantes, nous examinerons plus en détail certains systèmes de numération.

Convertir le binaire en décimal en Python

Les nombres entiers binaires sont les nombres représentés en base deux. Cela signifie que dans le système binaire, il n'y a que deux symboles utilisés pour représenter les nombres : 0 et 1. Lorsque vous comptez à partir de zéro en binaire, vous manquez plus rapidement de symboles : 0, 1, ???

De plus, il n'y a plus de symboles. Vous ne passez pas au chiffre 2 parce que 2 n'existe pas en binaire. Au lieu de cela, vous utilisez une combinaison spéciale de 1 et de 0. Dans un système binaire, 1000 est égal à 8 en décimal. En binaire, vous utilisez des puissances de deux, ce qui signifie que 8 est en gros : (1(2^3)) + (0(2^2)) + (0(2^1)) + (0(2^0))= 8. La position du 1 et du 0 définit la puissance à laquelle le 2 doit être porté.

Voyons cela avec un exemple plus complexe pour que ce soit plus clair :

Binary Number = 1001111
Decimal value = (1*(2^6)) + (0*(2^5)) + (0*(2^4)) + (1*(2^3)) + (1*(2^2)) + (1*(2^1)) + (1*(2^0))
              = 79

En Python, vous pouvez simplement utiliser la fonction bin() pour convertir une valeur décimale en sa valeur binaire correspondante.

De même, la fonction int() permet de convertir une valeur binaire en valeur décimale. La fonction int() prend comme deuxième argument la base du nombre à convertir, qui est 2 dans le cas des nombres binaires.

a = 79

# Base 2(binary)
bin_a = bin(a)
print(bin_a)
print(int(bin_a, 2)) #Base 2(binary)

0b1001111
79

Convertir l'octal en décimal en Python

L'octal est un autre système de numération comportant moins de symboles que le système décimal conventionnel. Elle est en base huit, ce qui signifie que huit symboles sont utilisés pour représenter toutes les quantités. Il s'agit de 0, 1, 2, 3, 4, 5, 6 et 7. Après 7, il y a 10 puisque 8 n'existe pas.

Tout comme vous avez utilisé les puissances de deux en binaire pour déterminer la valeur d'un nombre, vous utiliserez les puissances de 8 puisqu'il s'agit de la base huit.

Dans un système binaire, 10 est égal à 8 en octal. Voyons cela en détail : (1(8^1)) + (0(8^0))= 8.

Un exemple plus complexe :

Octal Number = 117
Decimal value = (1*(8^2)) + (1*(8^1)) + (7*(8^0))
              = 79

En Python, vous pouvez utiliser la fonction oct() pour convertir une valeur décimale en sa valeur octale correspondante. Vous pouvez également utiliser la fonction int() et la base correcte, qui est 8 pour le système numérique octal.

a = 79

# Base 8(octal)
oct_a = oct(a)
print(oct_a)
print(int(oct_a, 8))

0o117
79

Convertir l'hexadécimal en décimal en Python

L'hexadécimal est un système de numération en base 16. Contrairement au binaire et à l'octal, il utilise six symboles supplémentaires en plus des nombres trouvés dans le système numérique décimal.

Mais qu'est-ce qui vient après le 9 ?

Lorsque des symboles supplémentaires dépassant les valeurs numériques normales sont nécessaires, des lettres sont utilisées. Ainsi, en hexadécimal, la liste totale des symboles utilisés est la suivante : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E et F.

Reprenons le même exemple que précédemment :

Hexadecimal Number = 4F
Decimal value = (4*(16^1)) + (F*(16^0))
              = 79

En Python, vous pouvez utiliser la fonction hex() pour convertir une valeur décimale en sa valeur hexadécimale correspondante, ou la fonction int() en base 16 pour le système de numération hexadécimal.

a = 79

# Base 16(hexadecimal)
hex_a = hex(a)
print(hex_a)
print(int(hex_a, 16))

0x4f
79

Convertir Unicode en caractères

Python chr() convertit les entiers unicode en chaîne de caractères. Unicode est un codage de caractères universellement accepté pour afficher les textes écrits de diverses langues.

Nous avons fourni divers entiers Unicode à la fonction chr() pour afficher "DATACAMP". Vous pouvez également utiliser ord() pour convertir un seul caractère en un entier Unicode. 

print(
    chr(68),
    chr(65),
    chr(84),
    chr(65),
    chr(67),
    chr(65),
    chr(77),
    chr(80),
)

D A T A C A M P

Résumé : Conversions de systèmes de numération en Python

Vous avez réussi !

Félicitations ! Vous avez appris les conversions de types de données en Python, principalement à l'aide de méthodes intégrées. Cela vous aidera certainement à travailler avec différents types de données, vous offrant ainsi plus de flexibilité lors de l'écriture de vos programmes.

Nous avons un excellent cours sur Python intermédiaire pour la science des données où vous pouvez apprendre à tracer vos données à l'aide de matplotlib, et à travailler avec des dictionnaires et le fameux DataFrame de pandas. Vous verrez également comment vous pouvez contrôler le flux de votre programme à l'aide de boucles. Une étude de cas est également prévue à la fin du cours pour vous permettre d'appliquer tout ce que vous avez appris et de mettre vos connaissances en pratique !