Cours
Introduction à Python
4 h
6.9M
Chaque valeur en Python a un type. Les types de données sont une classification qui indique au compilateur ou à l'interpréteur comment vous souhaitez utiliser la donnée. Le type détermine les opérations possibles et la structure dans laquelle vous voulez stocker l'information. En data science, vous devrez souvent changer le type de vos données pour les rendre plus simples à manipuler.
Python propose de nombreux types de données. Vous en avez sans doute déjà utilisé : les entiers et les flottants pour les valeurs numériques, le booléen (bool) pour les valeurs vrai/faux et les chaînes de caractères pour l'alphanumérique. Vous pouvez aussi utiliser des listes, tuples, dictionnaires et ensembles, qui sont des structures de données permettant de stocker des collections de valeurs. Pour en savoir plus, consultez le cours de DataCamp Data Types in Python.
Pour exécuter facilement tous les exemples de ce tutoriel, vous pouvez créer gratuitement un workbook DataLab avec Python préinstallé et tous les extraits de code inclus.
Vérifier les types de données en Python
Avant de convertir des types, il est utile de les inspecter. Python fournit deux fonctions principales :
type(): renvoie le type d'une variable.isinstance(): vérifie si une variable appartient à un type donné.
a = 5.5
print(type(a)) # Output: <class 'float'>
print(isinstance(a, int)) # Output: False
print(isinstance(a, float)) # Output: TrueConversions de type implicites et explicites en Python
La conversion de type en Python peut se faire de deux façons : soit vous indiquez explicitement au compilateur de convertir un type en un autre, soit le compilateur le déduit et l'effectue automatiquement. Dans le premier cas, vous réalisez une conversion explicite ; dans le second, une conversion implicite.
Conversion de type implicite en Python
La conversion implicite, ou « coercition », se produit à la compilation ou à l'exécution et est gérée directement par Python. Voyons un exemple :
a_int = 1
b_float = 1.0
c_sum = a_int + b_float
print(c_sum)
print(type(c_sum)) 2.0
<class 'float'>Astuce : utilisez la fonction type() en Python pour vérifier le type d'un objet.
Apprenez Python à partir de zéro
Maîtrisez Python pour la science des données et acquérez des compétences recherchées.
Dans l'exemple, une valeur entière a_int a été additionnée à une valeur flottante b_float, et le résultat a été automatiquement converti en flottant c_sum sans intervention explicite de votre part. C'est une conversion implicite.
Pourquoi ne pas avoir converti le flottant en entier à la place ?
Cela tient au concept plus large de « promotion de type » en informatique. En bref, c'est un mécanisme de protection qui permet d'effectuer une opération dès que possible en convertissant vos données vers un supertype sans perte d'information.
Ainsi, la conversion d'un flottant en entier n'est pas réalisée, car elle supprimerait la partie fractionnaire et entraînerait une perte d'information.
Conversion de type explicite en Python
La conversion explicite, souvent appelée « cast », intervient lorsque vous transformez volontairement une valeur d'un type vers un autre. Vous contrôlez alors directement la conversion en précisant le type cible dans votre code. Elle est utile lorsque la conversion automatique (implicite) de Python ne correspond pas à vos besoins.
La syntaxe de base est :
target_data_type(expression)Par exemple, pour convertir un nombre flottant en entier :
int(3.14) # Converts 3.14 to 3Remarque : bien que très pratiques, les conversions explicites peuvent entraîner une perte d'information. Par exemple, convertir un flottant en entier supprime la partie décimale. Il est important d'en comprendre les implications pour éviter des résultats inattendus.
Voyons maintenant des conversions explicites courantes.
Structures de données primitives et non primitives en Python
Les structures de données primitives sont les briques de base de la manipulation de données et contiennent des valeurs simples. Python en propose quatre :
- Entiers
- Flottants
- Chaînes de caractères
- Booléens
Les structures non primitives ne stockent pas une seule valeur, mais une collection de valeurs sous divers formats. En Python, vous disposez notamment des :
- Listes
- Tuples
- Dictionnaires
- Ensembles
Pour approfondir, consultez le tutoriel Data Structures in Python.
Conversions pour les structures primitives
Conversions entre entiers et flottants en Python
Les entiers et les flottants représentent des nombres.
Pour convertir un entier en flottant, utilisez la fonction float(). Inversement, pour convertir un flottant en entier, utilisez int().
a_int = 3
b_int = 2
# Conversion explicite de int vers float
c_float_sum = float(a_int + b_int)
print(c_float_sum)5.0a_float = 3.3
b_float = 2.0# Conversion explicite de float vers 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.3Problèmes de précision des flottants et module Decimal
Les calculs en virgule flottante en Python peuvent mener à des imprécisions :
print(0.1 + 0.2) # Output: 0.30000000000000004Pour les éviter, utilisez le module Decimal :
from decimal import Decimal
print(Decimal('0.1') + Decimal('0.2')) # Output: 0.3Conversion de nombres réels en complexes
Vous pouvez convertir des entiers en nombres complexes avec complex(real,imag). Cette fonction prend deux nombres (parties réelle et imaginaire) et construit un complexe.
real = 2
imag = 5
print(complex(real, imag))(2+5j)Conversions de type avec les chaînes de caractères en Python
Une chaîne est une suite d'un ou plusieurs caractères (lettres, chiffres, symboles). Vous aurez souvent besoin de convertir des chaînes en nombres ou l'inverse.
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 produit un TypeError : le compilateur ne peut pas convertir implicitement un entier en chaîne.
Ce que le programme devrait faire peut vous sembler évident, mais le compilateur ne peut pas toujours le deviner. Il vous laisse donc indiquer clairement votre intention via un cast explicite. Voici comment convertir un entier en chaîne avec str() :
price_cake = 15
price_cookie = 6
total = price_cake + price_cookie
print("The total is: " + str(total) + "$")The total is: 21$Le principe est identique pour convertir un flottant en chaîne.
En Python, vous pouvez aussi convertir des chaînes en entiers ou en flottants lorsque c'est possible. Voyons ce que cela implique :
price_cake = '15'
price_cookie = '6'
# Concaténation de chaînes
total = price_cake + price_cookie
print("The total is: " + total + "$")
# Conversion explicite en entier
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 d'abord des chaînes. Pour calculer le total, il faut d'abord les convertir en entiers ; sinon, le compilateur réalisera une concaténation de chaînes plutôt qu'une addition numérique. Ensuite, pour afficher le résultat, vous devez convertir le total en chaîne afin de le concaténer au message.
Cet exemple illustre l'importance des conversions de type. Même sur un cas simple, leur utilité est évidente.
Remarque : vous avez remarqué l'expression « lorsque c'est possible » à propos de la conversion de chaînes en entiers ou en flottants ? En effet, il n'est pas toujours possible de convertir une chaîne en nombre pour effectuer des opérations numériques. Le compilateur le sait et lèvera une erreur si vous essayez. Voyez 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écapitulatif : conversions de types primitifs en Python
| Conversion | Fonction | Exemple | Sortie |
|---|---|---|---|
| Entier vers flottant | float() |
float(3) |
3.0 |
| Flottant vers entier | int() |
int(3.9) |
3 |
| Chaîne vers entier | int() |
int('123') |
123 |
| Entier vers chaîne | str() |
str(123) |
'123' |
Conversions pour les structures non primitives
Conversion vers tuples et listes en Python
Comme pour les entiers et les flottants, vous pouvez convertir des listes en tuples et inversement.
Rappel : les listes et les tuples servent à stocker des collections d'éléments homogènes. La différence : les tuples sont immuables, c'est-à-dire qu'une fois définis, vous ne pouvez ni supprimer, ni ajouter, ni modifier leurs valeurs.
Pourquoi convertir une liste en tuple ?
Parce que l'immuabilité des tuples permet des optimisations notables dans vos programmes.
Et pourquoi convertir un tuple en liste ?
Pour pouvoir modifier son contenu : convertissez en liste, faites vos changements, puis reconvertissez en tuple.
En Python, utilisez tuple() pour obtenir un tuple à partir d'une valeur donnée, et list() pour convertir un tuple en 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 en liste ou en tuple :
dessert = 'Cake'
# Convertir les caractères d'une chaîne en éléments d'un tuple
print(tuple(dessert))
# Convertir une chaîne en liste
dessert_list = list(dessert)
dessert_list.append('s')
print(dessert_list)('C', 'a', 'k', 'e')
['C', 'a', 'k', 'e', 's']Conversion vers dictionnaires et ensembles en Python
Vous pouvez utiliser 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}Comme pour les autres fonctions de conversion, il suffit d'appeler la fonction adaptée pour transformer n'importe quel type en dictionnaire ou en ensemble.
Utiliser les dataclasses pour des données structurées (Python 3.7+)
Plutôt que des dictionnaires ou des tuples, les dataclasses offrent un meilleur moyen de gérer des 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écapitulatif : conversions pour les structures non primitives
| Conversion | Fonction | Exemple | Sortie |
|---|---|---|---|
| Liste vers tuple | tuple() |
tuple([1, 2, 3]) |
(1, 2, 3) |
| Tuple vers liste | list() |
list(('a', 1)) |
['a', 1] |
| Chaîne vers liste | list() |
list('Cake') |
['C', 'a', 'k', 'e'] |
| Chaîne vers tuple | tuple() |
tuple('Cake') |
('C', 'a', 'k', 'e') |
| Tuple vers dictionnaire | dict() |
dict((('a', 1), ('b', 2))) |
{'a': 1, 'b': 2} |
| Liste vers ensemble | set() |
set([1, 2, 3, 4, 5]) |
{1, 2, 3, 4, 5} |
Unicode, binaire, octal et hexadécimal en Python
Un système de numération définit l'ensemble de symboles servant à représenter les valeurs numériques. Celui que vous utilisez au quotidien est le système décimal. Il utilise dix symboles : 0, 1, 2, 3, 4, 5, 6, 7, 8 et 9. Avec ces dix symboles, on peut représenter n'importe quelle quantité. Unicode, binaire, hexadécimal et octal désignent d'autres systèmes de numération.
Quand vous épuisez les symboles disponibles, vous passez au rang supérieur. En décimal, pour représenter une unité de plus que 9, vous écrivez 10, soit une dizaine et zéro unité. Dans d'autres systèmes, c'est différent. Par exemple, en binaire, qui n'utilise que 0 et 1, vous passez au rang suivant dès que vous manquez de symboles. On compte donc ainsi en binaire : 0, 1, 10, 11, 100, 101, etc.
Voyons certains de ces systèmes plus en détail.
Convertir du binaire en décimal en Python
Les entiers binaires sont notés en base 2. On n'y utilise que deux symboles : 0 et 1. En comptant à partir de zéro, vous manquez vite de symboles : 0, 1, ???
Il n'y a plus de symbole ; vous ne passez pas au chiffre 2, qui n'existe pas en binaire. À la place, vous utilisez des combinaisons de 1 et de 0. En binaire, 1000 vaut 8 en décimal. En binaire, on utilise des puissances de 2 ; 8 s'écrit donc (1(2^3)) + (0(2^2)) + (0(2^1)) + (0(2^0)) = 8. La position des 1 et des 0 détermine la puissance de 2.
Un exemple un peu plus complexe :
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))
= 79En Python, utilisez simplement bin() pour convertir une valeur décimale en sa représentation binaire.
Inversement, utilisez int() pour convertir un binaire en décimal. La fonction int() prend en second argument la base du nombre à convertir, 2 pour le binaire.
a = 79
# Base 2 (binaire)
bin_a = bin(a)
print(bin_a)
print(int(bin_a, 2)) # Base 2 (binaire)0b1001111
79Convertir de l'octal en décimal en Python
L'octal est un autre système, en base 8, avec huit symboles : 0, 1, 2, 3, 4, 5, 6 et 7. Après 7 vient 10, car 8 n'existe pas.
Comme en binaire on utilisait des puissances de 2, ici on utilise des puissances de 8.
Dans le système octal, 10 vaut 8 en décimal : (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))
= 79En Python, utilisez oct() pour convertir une valeur décimale en octal. Vous pouvez aussi utiliser int() avec la base 8.
a = 79
# Base 8 (octal)
oct_a = oct(a)
print(oct_a)
print(int(oct_a, 8))0o117
79Convertir de l'hexadécimal en décimal en Python
L'hexadécimal est un système en base 16. Contrairement au décimal, il utilise six symboles supplémentaires au-delà des chiffres.
Que se passe-t-il après 9 ?
On utilise des lettres. En hexadécimal, la liste des symboles est : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E et F.
En reprenant l'exemple précédent :
Hexadecimal Number = 4F
Decimal value = (4*(16^1)) + (F*(16^0))
= 79En Python, utilisez hex() pour convertir une valeur décimale en hexadécimal, ou int() avec la base 16 pour convertir l'inverse.
a = 79
# Base 16 (hexadécimal)
hex_a = hex(a)
print(hex_a)
print(int(hex_a, 16))0x4f
79Convertir un entier Unicode en caractère
La fonction Python chr() convertit des entiers Unicode en chaîne. Unicode est un codage universel des caractères pour afficher des textes dans de nombreuses langues.
Nous fournissons plusieurs entiers Unicode à chr() pour afficher « DATACAMP ». Vous pouvez aussi utiliser ord() pour convertir un caractère unique en 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 PRécapitulatif : conversions entre systèmes de numération en Python
| Conversion | Fonction | Exemple | Sortie |
|---|---|---|---|
| Décimal vers binaire | bin() |
bin(79) |
0b1001111 |
| Binaire vers décimal | int() |
int('1001111', 2) |
79 |
| Décimal vers octal | oct() |
oct(79) |
0o117 |
| Octal vers décimal | int() |
int('117', 8) |
79 |
| Décimal vers hexadécimal | hex() |
hex(79) |
0x4f |
| Hexadécimal vers décimal | int() |
int('4F', 16) |
79 |
| Unicode vers caractère | chr() |
chr(68) |
'D' |
| Caractère vers Unicode | ord() |
ord('D') |
68 |
Bravo !
Félicitations ! Vous avez découvert les conversions de types en Python, principalement via les fonctions natives. Cela vous aidera à manipuler des données variées avec plus de flexibilité dans vos programmes.
Nous proposons un excellent cours Intermediate Python for Data Science pour apprendre à tracer des graphiques avec matplotlib, travailler avec les dictionnaires et le fameux DataFrame pandas. Vous verrez aussi comment contrôler le flux de votre programme avec des boucles. Un cas pratique en fin de cours vous permettra d'appliquer vos acquis et de passer à l'action !
Projets Python pour tous les niveaux
Améliorez vos compétences en Python avec des projets de données du monde réel.
FAQs
Vous pouvez combiner join() et map() pour convertir chaque entier en chaîne puis les concaténer.
int_list = [1, 2, 3, 4]
result = ''.join(map(str, int_list))
print(result) # Output: '1234'
Un ValueError sera levé, indiquant que la chaîne n'est pas un entier valide.
int('abc') # Raises ValueError: invalid literal for int() with base 10: 'abc'
Oui, vous pouvez convertir un ensemble en liste avec la fonction list().
a_set = {1, 2, 3}
a_list = list(a_set)
print(a_list) # Output: [1, 2, 3]
Utilisez split() pour découper la chaîne et map() pour convertir chaque élément en entier.
numbers = "1 2 3 4"
int_list = list(map(int, numbers.split()))
print(int_list) # Output: [1, 2, 3, 4]
Vous pouvez utiliser la fonction type() pour vérifier le type d'une variable.
x = 5
print(type(x)) # Output: <class 'int'>
J'ai travaillé dans différents secteurs d'activité et j'ai porté plusieurs casquettes : développeur de logiciels, chercheur en apprentissage automatique, scientifique des données, chef de produit. Mais au fond, je suis un programmeur qui aime apprendre et partager ses connaissances !
Sujets
