Types de données Python : un guide complet

Chaque valeur en Python possède un type de données qui indique à l'interpréteur la nature de la donnée et les opérations autorisées sur celle-ci. Comme Python est dynamiquement typé, vous n'avez jamais besoin de déclarer un type explicitement — l'interpréteur le déduit au moment de l'exécution. Comprendre les types intégrés est donc essentiel : choisir le mauvais type entraîne des bogues, des copies inutiles ou des performances insuffisantes.

Ce chapitre couvre tous les types de données intégrés :

Utilisez la fonction intégrée type() à tout moment pour inspecter le type d'une valeur :

print(type(42))       # <class 'int'>
print(type(3.14))     # <class 'float'>
print(type("hello"))  # <class 'str'>
print(type(True))     # <class 'bool'>
print(type([1, 2]))   # <class 'list'>
print(type((1, 2)))   # <class 'tuple'>
print(type({1, 2}))   # <class 'set'>
print(type({"a": 1})) # <class 'dict'>
print(type(None))     # <class 'NoneType'>

Types numériques

Python dispose de trois types numériques : int, float et complex. Les trois prennent en charge les opérateurs arithmétiques standard (+, -, *, /, //, %, **).

int

Un int stocke un nombre entier de taille illimitée — les entiers Python ne sont pas limités à 32 ou 64 bits.

Opérateurs clés

Notez que / renvoie toujours un float, même lorsque le résultat est un nombre entier. Utilisez // lorsque vous avez besoin d'un quotient entier.

Type de données entier Python

# Integer addition
print(1 + 2)    # 3

# Integer subtraction
print(3 - 1)    # 2

# Integer multiplication
print(2 * 3)    # 6

# True division always returns float
print(6 / 2)    # 3.0

# Floor division returns int
print(7 // 2)   # 3

# Exponentiation
print(2 ** 10)  # 1024

float

Un float stocke un nombre décimal en utilisant la double précision IEEE 754. Utilisez les flottants chaque fois que vous avez besoin de valeurs fractionnaires.

Piège — représentation en virgule flottante : 0.1 + 0.2 n'est pas exactement 0.3 en virgule flottante binaire. Utilisez round() ou le module decimal lorsque l'arithmétique décimale exacte est importante (par exemple, les devises).

complex

Un nombre complex possède une partie réelle et une partie imaginaire, écrites sous la forme a + bj en Python (avec j, et non i). Les nombres complexes sont principalement utilisés en calcul scientifique, en traitement du signal et en calculs d'ingénierie.

str (Chaînes de caractères)

Un str est une séquence immuable de caractères Unicode. Les chaînes peuvent être délimitées par des guillemets simples, des guillemets doubles ou des guillemets triples (pour les chaînes multilignes).

single = 'Hello'
double = "World"
multi  = """This spans
multiple lines."""

Opérations courantes sur les chaînes

Méthodes de chaîne utiles

s = "  Hello World  "
print(s.strip())          # "Hello World"  — remove whitespace
print(s.strip().lower())  # "hello world"
print(s.strip().upper())  # "HELLO WORLD"
print("Hello World".split())   # ['Hello', 'World']
print(",".join(["a", "b", "c"]))  # a,b,c
print("Hello World".replace("World", "Python"))  # Hello Python
print(len("Hello"))       # 5

f-strings (littéraux de chaîne formatés)

Les f-strings (introduites dans Python 3.6) sont la méthode recommandée pour incorporer des valeurs dans des chaînes :

name = "Alice"
age  = 30
print(f"{name} is {age} years old.")   # Alice is 30 years old.
print(f"Next year she will be {age + 1}.")  # Next year she will be 31.

Comme les chaînes sont immuables, chaque opération qui « modifie » une chaîne crée en réalité une nouvelle chaîne. Pour en savoir plus sur les méthodes de chaîne, consultez le chapitre Python Strings.

bool (Booléen)

Un bool a exactement deux valeurs : True et False. Les booléens sont une sous-classe de int en Python — True est égal à 1 et False est égal à 0.

print(type(True))   # <class 'bool'>
print(True + 1)     # 2  (True is treated as 1)
print(False + 10)   # 10 (False is treated as 0)

Valeurs vraies et fausses

Tout objet Python peut être évalué dans un contexte booléen. Les valeurs suivantes sont fausses (s'évaluent à False) ; tout le reste est vrai :

• False, None
• Zéro numérique : 0, 0.0, 0j
• Séquences vides : "", [], (), set()
• Correspondance vide : {}

print(bool(0))      # False
print(bool(""))     # False
print(bool([]))     # False
print(bool(None))   # False

print(bool(42))     # True
print(bool("hi"))   # True
print(bool([0]))    # True  — list with one item is truthy

Pour un traitement complet, consultez le chapitre Python Booleans.

list

Une list est une séquence ordonnée et mutable. Elle peut contenir des éléments de n'importe quel type, y compris un mélange de types, et autorise les doublons.

# Creating a list
fruits = ["apple", "banana", "cherry"]

# Modifying an item
fruits[1] = "orange"
print(fruits)  # ['apple', 'orange', 'cherry']

# Adding items
fruits.append("mango")
print(fruits)  # ['apple', 'orange', 'cherry', 'mango']

# Removing an item
fruits.remove("orange")
print(fruits)  # ['apple', 'cherry', 'mango']

# Length
print(len(fruits))  # 3

Quand utiliser une list : lorsque vous avez besoin d'une collection ordonnée qui va évoluer — ajouter des éléments, en supprimer ou mettre à jour des valeurs en place. Pour une couverture approfondie, consultez le chapitre Python Lists.

tuple

Un tuple est une séquence ordonnée et immuable. Une fois créé, ses éléments ne peuvent pas être modifiés.

# Creating a tuple
coords = (10, 20)
print(coords[0])    # 10
print(len(coords))  # 2

# Tuple unpacking
x, y = coords
print(x, y)  # 10 20

# Single-element tuple needs a trailing comma
single = (42,)
print(type(single))  # <class 'tuple'>

Quand utiliser un tuple plutôt qu'une list :

• Les données ne doivent pas changer (par exemple, coordonnées GPS, valeurs de couleur RVB, lignes de base de données).
• Vous souhaitez utiliser la valeur comme clé de dictionnaire (les lists ne peuvent pas être des clés de dict car elles sont mutables ; les tuples le peuvent).
• Vous voulez exprimer une intention : « cette séquence est fixe. »

Pour en savoir plus, consultez le chapitre Python Tuples.

set

Un set est une collection non ordonnée d'éléments uniques. Les valeurs en double sont silencieusement ignorées lors de la création ou de l'ajout.

# Duplicates are automatically removed
unique = {1, 2, 2, 3, 3, 3}
print(unique)  # {1, 2, 3}

# Adding an item
unique.add(4)
print(unique)  # {1, 2, 3, 4}

# Membership test — O(1) average
print(3 in unique)  # True

# Set operations
a = {1, 2, 3}
b = {2, 3, 4}
print(a | b)  # {1, 2, 3, 4}  union
print(a & b)  # {2, 3}        intersection
print(a - b)  # {1}           difference

Quand utiliser un set : lorsque vous avez besoin de tests d'appartenance rapides ou que vous souhaitez éliminer les doublons d'une collection. Pour en savoir plus, consultez le chapitre Python Sets.

dict (Dictionnaire)

Un dict est une correspondance non ordonnée de paires clé-valeur. À partir de Python 3.7, les dictionnaires préservent l'ordre d'insertion. Les clés doivent être uniques et immuables (les chaînes et les nombres sont les choix les plus courants).

person = {"name": "John", "age": 32, "city": "New York"}

# Access by key
print(person["name"])  # John

# Add a key
person["country"] = "United States"
print(person)
# {'name': 'John', 'age': 32, 'city': 'New York', 'country': 'United States'}

# Remove a key
del person["city"]
print(person)
# {'name': 'John', 'age': 32, 'country': 'United States'}

# Safe access with a default value
print(person.get("email", "not provided"))  # not provided

# Iterate over keys and values
for key, value in person.items():
    print(f"{key}: {value}")

Quand utiliser un dict : lorsque les données sont naturellement structurées en paires clé-valeur et que vous avez besoin d'une recherche rapide par nom. Pour en savoir plus, consultez le chapitre Python Dictionary Methods.

NoneType

None est la valeur nulle de Python — elle représente l'absence de valeur. C'est la seule instance de NoneType.

result = None
print(result)         # None
print(type(result))   # <class 'NoneType'>

# Functions that do not explicitly return a value return None
def greet(name):
    print(f"Hello, {name}!")

x = greet("Alice")    # prints: Hello, Alice!
print(x)              # None

Utilisez toujours is None (vérification d'identité) plutôt que == None (vérification d'égalité) :

if result is None:
    print("No result yet")

Mutabilité en un coup d'œil

La mutabilité détermine si une valeur peut être modifiée en place après sa création. Cela affecte la justesse du code (alias accidentels), les performances (copie vs référence) et ce qui peut être utilisé comme clé de dict.

Conversion de type

Python fournit des fonctions intégrées pour convertir entre les types. C'est ce qu'on appelle la conversion de type explicite (ou transtypage).

# To int
print(int("42"))      # 42
print(int(3.9))       # 3  (truncates, does not round)
print(int(True))      # 1

# To float
print(float(7))       # 7.0
print(float("3.14"))  # 3.14

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

# Between sequences
print(list((1, 2, 3)))   # [1, 2, 3]
print(tuple([1, 2, 3]))  # (1, 2, 3)
print(set([1, 2, 2, 3])) # {1, 2, 3}

int() tronque (il n'arrondit pas) : int(3.9) donne 3, et non 4. Utilisez round() avant int() si un arrondi est nécessaire.

Pour une discussion complète des règles de transtypage, consultez le chapitre Python Casting.

Vérifier un type dans votre code

Utilisez isinstance() (méthode recommandée) ou type() pour les vérifications de type :

x = 42
print(isinstance(x, int))    # True
print(isinstance(x, float))  # False

# isinstance also works with a tuple of types
print(isinstance(x, (int, float)))  # True

Préférez isinstance() à type(x) == int car elle respecte l'héritage — un bool est aussi un int, donc isinstance(True, int) renvoie True, ce qui est généralement ce que vous souhaitez.

Résumé de référence rapide

* Ordre d'insertion préservé à partir de Python 3.7+.

Pratique