Conversion de types Python : convertir entre les types de données

Le casting (aussi appelé conversion de type) est le processus de conversion d'une valeur d'un type de données vers un autre. Python le prend en charge grâce à un ensemble de fonctions constructeur intégrées — int(), float(), str(), bool(), list(), tuple(), set(), et bien d'autres. Savoir quand et comment effectuer un casting est essentiel pour écrire des programmes Python corrects et flexibles.

Ce chapitre couvre :

• La différence entre le casting implicite et explicite
• Toutes les principales fonctions de casting intégrées avec des exemples fonctionnels
• Les conversions de base numérique (hex, oct, bin, et retour)
• Les conversions de types de collections (list, tuple, set)
• Les règles truthy/falsy des boolean et leurs pièges lors du casting
• Les erreurs courantes (TypeError, ValueError) et comment les éviter

Casting implicite vs explicite

Python distingue deux types de conversion de type.

Casting implicite

Le casting implicite se produit automatiquement lorsque Python doit réconcilier deux types compatibles dans une expression. Aucun appel de fonction n'est requis — Python promeut le type « plus étroit » pour éviter toute perte de données.

Le cas le plus courant est le mélange d'entiers et de flottants dans une opération arithmétique. Python convertit toujours l'entier en flottant afin que le résultat capture la partie décimale :

Python ne convertit pas implicitement entre des types non liés tels que les string et les nombres. Tenter "10" + 5 lève une TypeError. Pour ces cas, vous avez besoin d'un casting explicite.

Casting explicite

Le casting explicite consiste à appeler une fonction constructeur pour convertir une valeur soi-même :

Le reste de ce chapitre couvre en détail chaque fonction de casting explicite importante.

Casting numérique : int(), float(), complex()

int() — Convertir en entier

int() accepte des entiers, des flottants, des boolean et des string numériques. Lors de la conversion d'un flottant, il tronque (supprime la partie décimale) plutôt que d'arrondir :

# float → int  (truncates, does NOT round)
print(int(10.9))   # 10
print(int(-10.9))  # -10

# string → int
print(int("42"))   # 42

# bool → int
print(int(True))   # 1
print(int(False))  # 0

Notez que int(-10.9) retourne -10, et non -11. Python tronque vers zéro, et non vers moins l'infini (ce serait math.floor()).

float() — Convertir en flottant

float() accepte des entiers, des boolean et des string numériques (y compris "inf" et "nan") :

print(float(10))      # 10.0
print(float("3.14"))  # 3.14
print(float(True))    # 1.0
print(float("inf"))   # inf

complex() — Convertir en nombre complexe

complex() construit un nombre complexe à partir de parties réelle et imaginaire, ou à partir d'une string :

print(complex(3, 4))    # (3+4j)
print(complex("3+4j"))  # (3+4j)

Casting de string : str()

str() convertit presque n'importe quel objet Python en sa représentation sous forme de string. C'est utile pour la concaténation et lors de la construction de sorties :

age = 30
message = "I am " + str(age) + " years old."
print(message)  # I am 30 years old.

print(str(3.14))   # '3.14'
print(str(True))   # 'True'
print(str(None))   # 'None'

Pour formater des nombres à l'intérieur de string, consultez le chapitre Python f-strings pour une approche plus ergonomique.

Casting boolean : bool() et valeurs truthy/falsy

bool() convertit n'importe quelle valeur en True ou False en utilisant les règles truthy/falsy de Python. Mémoriser quelles valeurs sont falsy est important car les conditions dans les instructions if et les boucles while reposent implicitement sur les mêmes règles.

Valeurs falsy — toutes ces valeurs sont évaluées à False :

print(bool(0))      # False  — zero integer
print(bool(0.0))    # False  — zero float
print(bool(""))     # False  — empty string
print(bool([]))     # False  — empty list
print(bool(None))   # False  — None

Valeurs truthy — tout le reste est évalué à True :

print(bool(1))      # True
print(bool(-1))     # True  — any non-zero number
print(bool("a"))    # True
print(bool([0]))    # True  — a list with one element

Piège courant : caster une string en bool retourne toujours True sauf si la string est vide — même bool("False") vaut True. Pour vérifier si une string représente un boolean falsy, vous devez la comparer explicitement :

# This is WRONG — bool("False") is True!
user_input = "False"
print(bool(user_input))              # True  (non-empty string)

# Correct approach: compare the string
print(user_input.lower() == "true")  # False

Conversions de base numérique

Analyser des entiers dans d'autres bases avec int()

int() accepte un deuxième argument optionnel spécifiant la base de la string source. Cela vous permet d'analyser des littéraux binaires, octaux et hexadécimaux :

print(int("1010", 2))   # 10  — binary string
print(int("17", 8))     # 15  — octal string
print(int("ff", 16))    # 255 — hexadecimal string

# Pass 0 to auto-detect Python prefix notation
print(int("0b1010", 0)) # 10
print(int("0o17", 0))   # 15
print(int("0xFF", 0))   # 255

Convertir des entiers en string de base

Python dispose de trois fonctions intégrées qui formatent un entier sous la forme d'une string préfixée selon la base :

print(bin(10))   # '0b1010'
print(oct(8))    # '0o10'
print(hex(255))  # '0xff'

Ces fonctions retournent des string, pas des entiers. Si vous avez besoin de la string sans le préfixe, utilisez le slicing : bin(10)[2:] donne '1010'.

Conversions de types de collections

Vous pouvez convertir entre list, tuple et set en utilisant leurs fonctions constructeur. La conversion en set supprime les doublons et perd l'ordre :

# list → tuple
coords = [10, 20, 30]
print(tuple(coords))   # (10, 20, 30)

# tuple → list
point = (4, 5, 6)
mutable = list(point)
mutable.append(7)
print(mutable)         # [4, 5, 6, 7]

# list → set  (removes duplicates)
numbers = [1, 2, 2, 3, 3, 3]
unique = set(numbers)
print(unique)          # {1, 2, 3}

Convertir une string en liste la divise en caractères individuels :

print(list("hello"))   # ['h', 'e', 'l', 'l', 'o']

Toutes les conversions numériques et de string : référence rapide

Les exemples ci-dessous montrent l'ensemble des castings numériques et de string en un seul endroit :

Python casting numeric

# Converting an integer to a floating-point number
x = 10
y = float(x)
print(y)

# Converting a floating-point number to an integer
x = 10.5
y = int(x)
print(y)

# Converting a string to an integer
x = "10"
y = int(x)
print(y)

# Converting a string to a floating-point number
x = "10.5"
y = float(x)
print(y)

# Converting an integer to a string
x = 10
y = str(x)
print(y)

# Converting a floating-point number to a string
x = 10.5
y = str(x)
print(y)

# Converting a number to a boolean
x = 0
y = bool(x)
print(y)

x = 10
y = bool(x)
print(y)

Erreurs courantes

TypeError

Une TypeError est levée lorsque vous passez un type que la fonction ne peut pas convertir du tout — par exemple, passer une liste à int() :

Python casting unsupported type to int

Sortie :

TypeError: int() argument must be a string, a bytes-like object or a number, not 'list'

ValueError

Une ValueError est levée lorsque le type est correct (par exemple, une string) mais que la valeur ne peut pas être convertie — par exemple, un mot passé à float() :

Python casting string to float

Sortie :

ValueError: could not convert string to float: 'hello'

Perte de précision lors du casting de float en int

Convertir un flottant en entier tronque silencieusement la partie décimale. Il n'y a aucun avertissement — et pour les nombres négatifs, le comportement peut être surprenant :

Python casting float to int

Sortie :

10

Si vous avez besoin d'arrondir, utilisez round() avant le casting, ou utilisez math.floor() / math.ceil() pour contrôler explicitement la direction.

Casting sécurisé avec try/except

Lorsque votre programme reçoit des données provenant d'une entrée utilisateur, de fichiers ou d'API externes, vous ne pouvez pas savoir à l'avance si une valeur sera castée avec succès. Utilisez un bloc try/except pour gérer les échecs sans planter :

Python safe casting with try/except

Sortie :

Conversion failed: invalid literal for int() with base 10: 'hello'
10

Ce modèle est particulièrement utile lors du traitement de champs de formulaire ou de lignes CSV où n'importe quelle colonne peut contenir des données inattendues.

Pratique