Posted on Jul 20, 2025· Updated on Jul 20, 2025

Types de Données Python Expliqués - Guide Visuel pour Débutants

#python #beginner #data types

Python est livré avec neuf types de données de base qui couvrent presque tout ce dont vous aurez besoin. Choisir le bon rend votre code plus clair, plus rapide et plus sûr. Ce guide montre comment chaque type fonctionne, quand l’utiliser et à quoi faire attention. Pour un aperçu rapide, consultez également notre guide sur les bases.

Diagramme des catégories de types de données intégrés à Python et de leur mutabilité.

1. Nombres – int, float, complex

Python dispose de trois types pour travailler avec des nombres, chacun conçu pour différentes situations.

Exemples de base d’abord

# Integers - nombres entiers
age = 25
score = 100
negative = -10

# Floats - nombres avec décimales
price = 19.99
temperature = 98.6
pi = 3.14159

# Complex - nombres avec parties réelle et imaginaire (mathématiques avancées)
z = 2 + 3j  # j représente l'unité imaginaire en Python

Plus d’exemples

# Travailler avec des entiers
items = 5
total_items = items * 3  # 15

# Travailler avec des flottants
radius = 2.5
area = 3.14159 * radius * radius  # 19.634...

# Attention à la précision des flottants
result = 0.1 + 0.2  # 0.30000000000000004 (pas exactement 0.3 !)

# Nombres complexes (vous n'en aurez probablement pas besoin en tant que débutant)
z = complex(2, 3)     # Identique à 2+3j
magnitude = abs(z)    # 3.605...

2. Chaînes de caractères – str

Les chaînes de caractères contiennent du texte et sont l’un des types les plus importants que vous utiliserez. Pour des opérations de chaînes plus détaillées, consultez notre guide sur la manipulation des chaînes de caractères.

Exemples de base

# Création de chaînes
name = "Alice"
message = 'Hello world'
long_text = """Ceci est une
chaîne multiligne"""

# Opérations de base
greeting = "Hello, " + name  # "Hello, Alice"
repeated = "Ha" * 3          # "HaHaHa"
length = len(message)        # 11

Caractéristiques clés :

• Immuables : une fois créées, vous ne pouvez pas les modifier (mais vous pouvez en créer de nouvelles)
• Utiliser des guillemets simples ' ou doubles "
• Triple guillemets """ pour le texte multiligne
• Prend en charge Unicode (emojis, caractères internationaux)

Opérations courantes sur les chaînes

text = "  Python Programming  "

# Méthodes utiles
clean_text = text.strip()           # "Python Programming"
words = clean_text.split()          # ["Python", "Programming"]
joined = "-".join(words)            # "Python-Programming"
upper_text = clean_text.upper()     # "PYTHON PROGRAMMING"
replaced = clean_text.replace("Python", "Java")  # "Java Programming"

# Vérification du contenu
starts_with_p = clean_text.startswith("Python")  # True
has_gram = "gram" in clean_text                   # True

# Formatage moderne (recommandé)
age = 25
formatted = f"I am {age} years old"  # "I am 25 years old"

3. Booléens – bool

Les booléens représentent les valeurs Vrai ou Faux - essentiels pour prendre des décisions dans votre code. Apprenez-en davantage sur la fonction bool().

Exemples de base

# Valeurs booléennes simples
is_student = True
is_graduated = False

# Opérations booléennes
has_degree = is_student or is_graduated  # True
ready_to_work = is_graduated and not is_student  # False

Vérité (Truthiness) : Python traite de nombreuses valeurs comme Vrai ou Faux dans les conditions :

# Celles-ci sont "truthy" (agissent comme Vrai)
if "hello":     # chaînes non vides
if [1, 2, 3]:   # listes non vides
if 42:          # nombres non nuls

# Celles-ci sont "falsy" (agissent comme Faux)
if "":          # chaîne vide
if []:          # liste vide
if 0:           # zéro
if None:        # valeur None

Exemples pratiques

items = []
if items:
    print("We have items!")
else:
    print("No items found")  # Ceci sera affiché

score = 85
passed = score >= 60  # True

4. Type None – NoneType

None représente “rien” ou “aucune valeur” - vous le verrez partout en Python.

Exemples de base

# Variables qui n'ont pas encore de valeur
result = None
user_input = None

# Les fonctions retournent None par défaut
def greet(name):
    print(f"Hello, {name}")

return_value = greet("Alice")  # return_value est None

# Vérifier si c'est None
if result is None:
    print("No result yet")

# Modèle courant : valeurs optionnelles
def find_user(username):
    # ... logique de recherche ...
    if user_found:
        return user_data
    else:
        return None  # Rien trouvé

Important : Utilisez toujours is et is not lors de la comparaison avec None, et non == :

# Correct
if value is None:
    # faire quelque chose

# Incorrect (mais fonctionne)
if value == None:
    # faire quelque chose

5. Listes – list

Les listes stockent plusieurs éléments dans l’ordre et vous permettent de les modifier après leur création. Pour des opérations complètes sur les listes, consultez notre guide sur les listes et tuples.

Exemples de base

# Création de listes
fruits = ["apple", "banana", "orange"]
numbers = [1, 2, 3, 4, 5]
mixed = ["hello", 42, True, None]  # Les listes peuvent contenir différents types
empty = []

# Accéder aux éléments (commence à l'index 0)
first_fruit = fruits[0]      # "apple"
last_fruit = fruits[-1]      # "orange"

Opérations courantes

shopping_list = ["milk", "bread"]

# Ajouter des éléments
shopping_list.append("eggs")         # ["milk", "bread", "eggs"]
shopping_list.insert(0, "butter")    # ["butter", "milk", "bread", "eggs"]
shopping_list.extend(["cheese", "ham"])  # Ajouter plusieurs éléments

# Supprimer des éléments
shopping_list.remove("milk")         # Supprimer la première occurrence
last_item = shopping_list.pop()      # Supprimer et retourner le dernier élément
first_item = shopping_list.pop(0)    # Supprimer et retourner le premier élément

# Opérations utiles
length = len(shopping_list)
has_bread = "bread" in shopping_list

Quand utiliser les listes

• Lorsque vous avez besoin de données ordonnées qui peuvent changer
• Construire des collections élément par élément
• Lorsque vous devez accéder aux éléments par position

# Bons cas d'utilisation
grades = [85, 92, 78, 96]
todo_items = ["wash dishes", "walk dog", "study Python"]

# Traitement des listes
total = sum(grades)
average = total / len(grades)

for item in todo_items:
    print(f"Task: {item}")

6. Dictionnaires – dict

Les dictionnaires stockent des données sous forme de paires clé-valeur, comme un vrai dictionnaire où vous recherchez des mots (clés) pour trouver des définitions (valeurs). Pour des opérations complètes sur les dictionnaires, consultez notre guide sur les dictionnaires.

Exemples de base

# Création de dictionnaires
person = {"name": "Alice", "age": 30, "city": "New York"}
grades = {"math": 85, "english": 92, "science": 78}
empty = {}

# Accéder aux valeurs
name = person["name"]        # "Alice"
age = person.get("age")      # 30 (méthode plus sûre)
height = person.get("height", "unknown")  # "unknown" si la clé n'existe pas

Opérations courantes

student = {"name": "Bob", "grade": 85}

# Ajouter/mettre à jour des valeurs
student["age"] = 20           # Ajouter une nouvelle paire clé-valeur
student["grade"] = 90         # Mettre à jour la valeur existante

# Méthodes utiles
keys = student.keys()         # dict_keys(['name', 'grade', 'age'])
values = student.values()     # dict_values(['Bob', 90, 20])
items = student.items()       # dict_items([('name', 'Bob'), ...])

# Vérifier les clés
if "name" in student:
    print(f"Student name: {student['name']}")

# Supprimer des éléments
age = student.pop("age")      # Supprimer et retourner la valeur
student.pop("height", None)   # Suppression sûre (pas d'erreur si la clé est manquante)

Quand utiliser les dictionnaires

• Lorsque vous devez rechercher des valeurs par un identifiant unique
• Stocker des données structurées (comme des enregistrements)
• Compter des choses
• Mise en cache/mémorisation

# Bons cas d'utilisation
inventory = {"apples": 50, "bananas": 30, "oranges": 25}
user_profile = {
    "username": "alice123",
    "email": "alice@example.com",
    "is_premium": True
}

# Exemple de comptage
text = "hello world"
char_count = {}
for char in text:
    char_count[char] = char_count.get(char, 0) + 1
# Résultat : {'h': 1, 'e': 1, 'l': 3, 'o': 2, ' ': 1, 'w': 1, 'r': 1, 'd': 1}

7. Tuples – tuple

Les tuples sont comme des listes mais ne peuvent pas être modifiés après leur création. Considérez-les comme des listes “verrouillées”. Apprenez-en davantage sur les tuples dans notre guide sur les listes et tuples.

Exemples de base

# Création de tuples
coordinates = (10, 20)
rgb_color = (255, 0, 128)
single_item = (42,)    # Notez la virgule pour les tuples à un seul élément
empty = ()

# Les parenthèses sont souvent facultatives
point = 5, 10          # Identique à (5, 10)
name_age = "Alice", 25 # Identique à ("Alice", 25)

# Accéder aux éléments (identique aux listes)
x = coordinates[0]     # 10
y = coordinates[1]     # 20

Dépaquetage de tuples

# Le dépaquetage est très utile
point = (100, 200)
x, y = point          # x=100, y=200

# Échanger des valeurs
a = 5
b = 10
a, b = b, a           # Maintenant a=10, b=5

# Fonction retournant plusieurs valeurs
def get_name_age():
    return "Bob", 25

name, age = get_name_age()

Quand utiliser les tuples

• Lorsque vous avez une collection fixe qui ne changera pas
• Retourner plusieurs valeurs à partir de fonctions
• Comme clés de dictionnaire (car ils sont immuables)
• Représenter des coordonnées, des valeurs RVB, etc.

# Bons cas d'utilisation
WINDOW_SIZE = (800, 600)        # Constantes
DEFAULT_COLOR = (255, 255, 255) # RVB blanc

# Dictionnaire avec des clés de tuple
locations = {
    (0, 0): "origin",
    (1, 1): "northeast",
    (-1, -1): "southwest"
}

8. Ensembles – set

Les ensembles stockent des éléments uniques sans doublons et sans ordre particulier. Idéal pour les tests d’appartenance et la suppression des doublons. Pour des opérations complètes sur les ensembles, consultez notre guide sur les ensembles.

Exemples de base

# Création d'ensembles
colors = {"red", "green", "blue"}
numbers = {1, 2, 3, 4, 5}
empty = set()  # Attention : {} crée un dictionnaire vide, pas un ensemble !

# À partir de listes (supprime les doublons)
mixed_list = [1, 2, 2, 3, 3, 3]
unique_numbers = set(mixed_list)  # {1, 2, 3}

Opérations courantes

tags = {"python", "programming", "beginner"}

# Ajouter des éléments
tags.add("tutorial")
tags.update(["coding", "learning"])  # Ajouter plusieurs éléments

# Supprimer des éléments
tags.remove("beginner")     # Erreur si l'élément n'existe pas
tags.discard("advanced")    # Pas d'erreur si l'élément n'existe pas

# Test d'appartenance (très rapide !)
if "python" in tags:
    print("This is about Python!")

# Opérations d'ensemble
set1 = {1, 2, 3}
set2 = {3, 4, 5}
union = set1 | set2         # {1, 2, 3, 4, 5}
intersection = set1 & set2   # {3}
difference = set1 - set2     # {1, 2}

Quand utiliser les ensembles

• Supprimer les doublons d’une collection
• Test d’appartenance rapide
• Opérations mathématiques d’ensembles
• Suivi des visiteurs uniques, des identifiants, etc.

# Bons cas d'utilisation
unique_visitors = set()
unique_visitors.add("user123")
unique_visitors.add("user456")
unique_visitors.add("user123")  # N'ajoutera pas le doublon
print(len(unique_visitors))     # 2

# Supprimer les doublons d'une liste
items = ["apple", "banana", "apple", "orange", "banana"]
unique_items = list(set(items))  # ['apple', 'banana', 'orange']

Choisir le bon type – conseils pratiques

Aide-mémoire sur la mutabilité et l’hashabilité

Points clés à retenir pour les débutants

1. Commencez simplement : Utilisez int pour les nombres entiers, float pour les décimales, str pour le texte, bool pour vrai/faux, et None pour “aucune valeur”.

2. Collections simplifiées : Utilisez list lorsque vous devez modifier des choses, tuple lorsque vous ne le devez pas, dict pour les paires clé-valeur, et set pour les éléments uniques.

3. En cas de doute : list et dict couvrent la plupart des besoins de collection pour les débutants.

4. Entraînez-vous avec des exemples simples avant de passer à des cas d’utilisation complexes.

5. Rappelez-vous : Python est indulgent – vous pouvez toujours convertir entre des types compatibles si nécessaire.