Police :

print("Bonjour, monde !") # Écrivez votre code Python ici nom = input("Entrez votre prénom : ") print(f"Bonjour, {nom} !")

# Le résultat de l'exécution s'affichera ici

Fonctionnalités du compilateur Python en ligne

Exécution immédiate

Lancez votre code Python instantanément, sans installer d'interpréteur ni configurer d'environnement.

Compatible tous appareils

Écrivez et testez votre code sur n'importe quel appareil — ordinateur, tablette ou téléphone.

Sauvegardez votre code

Téléchargez vos scripts pour les réutiliser plus tard ou les partager avec d'autres développeurs.

Messages d'erreur détaillés

Obtenez des descriptions précises des erreurs après chaque exécution pour identifier et corriger les problèmes rapidement.

Autocomplétion

L'éditeur propose des suggestions pendant que vous tapez, ce qui réduit les fautes de frappe et accélère l'écriture.

Interface personnalisable

Choisissez entre le thème clair et le thème sombre selon vos préférences. L'interface est entièrement disponible en français.

Guide de syntaxe


# Variables et types de données en Python
# Pas besoin de déclarer le type, Python s'en charge
nom = "Alice"       # chaîne de caractères
age = 30            # entier
taille = 1.75       # flottant
python_cest_bien = True  # booléen

# Les f-strings permettent d'insérer des variables dans une chaîne
print(f"Je m'appelle {nom}, j'ai {age} ans et je mesure {taille} m.")
print(f"Est-ce que Python, c'est bien ? {python_cest_bien}")

# Afficher le type d'une variable
print("Type de nom :", type(nom))
print("Type de age :", type(age))
print("Type de python_cest_bien :", type(python_cest_bien))

# Types de données complexes
nombres = [1, 2, 3, 4, 5]          # liste
infos_utilisateur = {               # dictionnaire
    "nom": "Alice",
    "age": 30,
    "langages": ["Python", "JavaScript", "SQL"]
}
coordonnees = (48.8566, 2.3522)     # tuple (immuable)
tags_uniques = {"python", "programmation", "apprentissage"}  # ensemble

# Conversion de types
nombre_str = "42"
nombre_int = int(nombre_str)        # conversion chaîne → entier
print(f"Nombre converti : {nombre_int}, type : {type(nombre_int)}")

# Opérations arithmétiques
a, b = 10, 3
print(f"Addition : {a + b}")
print(f"Soustraction : {a - b}")
print(f"Multiplication : {a * b}")
print(f"Division : {a / b}")
print(f"Division entière : {a // b}")
print(f"Modulo : {a % b}")
print(f"Puissance : {a ** b}")


# Conditions et boucles en Python
x = 10
if x > 5:
    print("x est supérieur à 5")
elif x == 5:
    print("x est égal à 5")
else:
    print("x est inférieur à 5")

# Opérateurs logiques
a, b = 5, 10
if a > 0 and b > 0:
    print("Les deux nombres sont positifs")
if a > 0 or b < 0:
    print("Au moins un des nombres est positif")
if not (a > b):
    print("a n'est pas supérieur à b")

# Opérateur ternaire
age = 20
statut = "majeur" if age >= 18 else "mineur"
print(f"Statut : {statut}")

# Boucle for sur une liste
fruits = ["pomme", "banane", "orange"]
for fruit in fruits:
    print(f"Fruit : {fruit}")

# Boucle for avec range()
for i in range(1, 5):  # de 1 à 4
    print(f"Nombre : {i}")

# Boucle for avec enumerate() pour obtenir l'index
for index, fruit in enumerate(fruits):
    print(f"Index {index} : {fruit}")

# Boucle while
compteur = 1
while compteur <= 3:
    print(f"Itération {compteur}")
    compteur += 1

# break et continue
for i in range(10):
    if i == 3:
        continue  # sauter cette itération
    if i == 7:
        break     # sortir de la boucle
    print(i)

# else sur une boucle (s'exécute si la boucle se termine normalement)
for i in range(3):
    print(i)
else:
    print("Boucle terminée normalement")


# Fonctions et modules en Python
def saluer(nom):
    """Fonction de salutation"""
    print(f"Bonjour, {nom} !")

saluer("Alice")

# Paramètres par défaut
def saluer_avec_message(nom, message="Bienvenue !"):
    print(f"Bonjour, {nom} ! {message}")

saluer_avec_message("Marie")
saluer_avec_message("Jean", "Content de te voir !")

# Nombre variable d'arguments
def somme_tout(*args):
    total = 0
    for n in args:
        total += n
    return total

print(f"Somme : {somme_tout(1, 2, 3, 4, 5)}")

# Arguments nommés
def infos_utilisateur(**kwargs):
    for cle, valeur in kwargs.items():
        print(f"{cle} : {valeur}")

infos_utilisateur(nom="Alice", age=30, ville="Paris")

# Retourner plusieurs valeurs
def obtenir_dimensions():
    largeur = 100
    hauteur = 50
    return largeur, hauteur

l, h = obtenir_dimensions()
print(f"Largeur : {l}, Hauteur : {h}")

# Modules
import math
nombre = 25
print(f"Racine carrée de {nombre} : {math.sqrt(nombre)}")

from random import randint, choice
print(f"Nombre aléatoire entre 1 et 10 : {randint(1, 10)}")
print(f"Fruit aléatoire : {choice(['pomme', 'poire', 'banane'])}")

import datetime as dt
maintenant = dt.datetime.now()
print(f"Date et heure actuelles : {maintenant}")


# Indentation et commentaires en Python
# En Python, les blocs de code sont définis par l'indentation
# Toutes les lignes d'une fonction ou d'une boucle doivent être indentées
def saluer(nom):
    # Ceci est un commentaire
    print(f"Bonjour, {nom} !")  # afficher le message

saluer("Alice")

# Les commentaires commencent par #
# L'interpréteur les ignore, mais ils aident à comprendre le code

# Exemple d'indentation dans une boucle
for i in range(3):
    # Afficher l'itération courante
    print(f"Itération {i}")

# Commentaire multi-lignes avec des guillemets triples
"""
Ceci est un commentaire sur plusieurs lignes.
On s'en sert souvent pour documenter les fonctions et les classes.
"""

# Blocs imbriqués : chaque niveau ajoute une indentation
def fonction_externe():
    print("Fonction externe")
    
    def fonction_interne():
        print("Fonction imbriquée")
        
        for i in range(2):
            print(f"Boucle imbriquée, itération {i}")
    
    fonction_interne()

fonction_externe()

# Docstrings pour documenter le code
def calculer_aire(rayon):
    """
    Calcule l'aire d'un cercle à partir de son rayon.
    
    Arguments :
        rayon (float) : le rayon du cercle
        
    Retourne :
        float : l'aire du cercle
    """
    return 3.14159 * rayon ** 2

help(calculer_aire)


# Listes et dictionnaires en Python

# Listes — collections ordonnées et modifiables
fruits = ["pomme", "banane", "orange", "poire", "kiwi"]

# Accès aux éléments
print(f"Premier élément : {fruits[0]}")
print(f"Dernier élément : {fruits[-1]}")
print(f"Éléments 1 à 3 : {fruits[1:4]}")

# Modification
fruits[1] = "raisin"
print(f"Liste modifiée : {fruits}")

# Méthodes de liste
fruits.append("ananas")       # ajouter en fin
fruits.insert(1, "mangue")    # insérer à un index
fruits.remove("orange")       # supprimer par valeur
retire = fruits.pop()         # retirer et retourner le dernier
print(f"Élément retiré : {retire}")
print(f"Liste après modifications : {fruits}")

print(f"Taille de la liste : {len(fruits)}")

# Tri
fruits.sort()
print(f"Liste triée : {fruits}")
fruits.sort(reverse=True)
print(f"Liste triée à l'envers : {fruits}")

# Compréhension de liste
nombres = [1, 2, 3, 4, 5]
carres = [x**2 for x in nombres]
print(f"Carrés : {carres}")

# Filtrage avec compréhension
nombres_pairs = [x for x in range(1, 11) if x % 2 == 0]
print(f"Nombres pairs : {nombres_pairs}")

# Dictionnaires — paires clé-valeur
personne = {
    "nom": "Anna",
    "age": 28,
    "profession": "développeuse",
    "langages": ["Python", "JavaScript", "Java"]
}

# Accès aux valeurs
print(f"Nom : {personne['nom']}")
print(f"Âge : {personne['age']}")

# Accès sécurisé avec get()
print(f"Ville : {personne.get('ville', 'non renseignée')}")

# Modification et ajout
personne["age"] = 29
personne["ville"] = "Lyon"
print(f"Dictionnaire mis à jour : {personne}")

# Méthodes du dictionnaire
cles = list(personne.keys())
valeurs = list(personne.values())
paires = list(personne.items())

print(f"Clés : {cles}")
print(f"Valeurs : {valeurs}")
print(f"Paires : {paires}")

# Compréhension de dictionnaire
dict_carres = {x: x**2 for x in range(1, 6)}
print(f"Dictionnaire des carrés : {dict_carres}")


# Gestion des exceptions en Python

# Structure try-except de base
try:
    x = 10 / 0
except ZeroDivisionError:
    print("Erreur : division par zéro")

# Gérer plusieurs types d'exceptions
try:
    nombre = int(input("Entrez un nombre : "))
    resultat = 100 / nombre
    print(f"Résultat : {resultat}")
except ValueError:
    print("Erreur : ce n'est pas un nombre")
except ZeroDivisionError:
    print("Erreur : division par zéro")

# Capturer plusieurs exceptions dans un seul bloc
try:
    valeur = int("abc")
except (ValueError, TypeError):
    print("Erreur de conversion")

# Utiliser else
try:
    nombre = 5
    resultat = 100 / nombre
except ZeroDivisionError:
    print("Division par zéro")
else:
    # S'exécute si aucune exception n'a été levée
    print(f"Division réussie, résultat : {resultat}")

# Utiliser finally
try:
    fichier = open("exemple.txt", "r")
    contenu = fichier.read()
except FileNotFoundError:
    print("Fichier introuvable")
finally:
    # S'exécute toujours, exception ou non
    print("Opération terminée")
    try:
        fichier.close()
    except:
        pass

# Exceptions personnalisées
class ValeurNegativeErreur(Exception):
    """Exception levée pour les valeurs négatives"""
    pass

def calculer_racine(valeur):
    if valeur < 0:
        raise ValeurNegativeErreur("Impossible de calculer la racine carrée d'un nombre négatif")
    return valeur ** 0.5

try:
    resultat = calculer_racine(-5)
except ValeurNegativeErreur as e:
    print(f"Erreur : {e}")

# assert pour vérifier une condition
def diviser(a, b):
    assert b != 0, "Le diviseur ne peut pas être zéro"
    return a / b

try:
    resultat = diviser(10, 0)
except AssertionError as e:
    print(f"Assertion échouée : {e}")


# Classes et programmation orientée objet en Python

class Personne:
    # Attribut de classe (partagé par toutes les instances)
    espece = "Homo sapiens"
    
    # Constructeur
    def __init__(self, nom, age):
        self.nom = nom
        self.age = age
        self._attribut_prive = "Privé"  # convention : usage interne
    
    # Méthode d'instance
    def se_presenter(self):
        return f"Bonjour, je m'appelle {self.nom} et j'ai {self.age} ans."
    
    # Méthode qui modifie l'état
    def feter_anniversaire(self):
        self.age += 1
        return f"{self.nom} a maintenant {self.age} ans !"
    
    # Méthode statique (ne nécessite pas d'instance)
    @staticmethod
    def est_majeur(age):
        return age >= 18
    
    # Méthode de classe (travaille avec la classe, pas l'instance)
    @classmethod
    def depuis_annee_naissance(cls, nom, annee_naissance, annee_courante=2024):
        age = annee_courante - annee_naissance
        return cls(nom, age)

# Créer des instances
personne1 = Personne("Anna", 28)
personne2 = Personne("Jean", 35)

print(personne1.se_presenter())
print(personne2.se_presenter())
print(personne1.feter_anniversaire())
print(f"Espèce : {Personne.espece}")
print(f"Est majeur : {Personne.est_majeur(16)}")

personne3 = Personne.depuis_annee_naissance("Marie", 1995)
print(personne3.se_presenter())

# Héritage
class Etudiant(Personne):
    def __init__(self, nom, age, universite):
        super().__init__(nom, age)
        self.universite = universite
        self.cours = []
    
    # Surcharge de méthode
    def se_presenter(self):
        base = super().se_presenter()
        return f"{base} J'étudie à {self.universite}."
    
    def s_inscrire(self, cours):
        self.cours.append(cours)
        return f"{self.nom} s'est inscrit(e) à {cours}"

etudiant1 = Etudiant("Alex", 20, "Sorbonne")
print(etudiant1.se_presenter())
print(etudiant1.s_inscrire("Programmation Python"))
print(f"Cours de l'étudiant : {etudiant1.cours}")

# Héritage multiple
class Employe:
    def __init__(self, salaire):
        self.salaire = salaire
    
    def afficher_salaire(self):
        return f"Salaire : {self.salaire} €"

class AssistantEnseignant(Etudiant, Employe):
    def __init__(self, nom, age, universite, salaire):
        Etudiant.__init__(self, nom, age, universite)
        Employe.__init__(self, salaire)
    
    def se_presenter(self):
        base = Etudiant.se_presenter(self)
        salaire = self.afficher_salaire()
        return f"{base} {salaire}"

ae = AssistantEnseignant("Paul", 22, "CentraleSupélec", 1800)
print(ae.se_presenter())


# Travailler avec les fichiers en Python
# Le bloc with ferme automatiquement le fichier

try:
    # Écriture dans un fichier
    with open("exemple.txt", "w", encoding="utf-8") as fichier:
        fichier.write("Bonjour, monde !\n")
        fichier.write("Voici un exemple de manipulation de fichiers en Python.\n")
        
        lignes = ["Première ligne\n", "Deuxième ligne\n", "Troisième ligne\n"]
        fichier.writelines(lignes)
    
    print("Fichier écrit avec succès.")
    
    # Lire tout le fichier d'un coup
    with open("exemple.txt", "r", encoding="utf-8") as fichier:
        contenu = fichier.read()
        print("\nContenu du fichier (lecture complète) :")
        print(contenu)
    
    # Lire ligne par ligne
    with open("exemple.txt", "r", encoding="utf-8") as fichier:
        print("\nContenu du fichier (ligne par ligne) :")
        for ligne in fichier:
            print(f">>> {ligne.strip()}")
    
    # Lire dans une liste
    with open("exemple.txt", "r", encoding="utf-8") as fichier:
        lignes = fichier.readlines()
        print("\nLignes dans une liste :")
        for i, ligne in enumerate(lignes):
            print(f"Ligne {i+1} : {ligne.strip()}")
    
    # Ajouter du contenu sans écraser
    with open("exemple.txt", "a", encoding="utf-8") as fichier:
        fichier.write("Cette ligne a été ajoutée après coup.\n")
    
    print("\nLigne ajoutée au fichier.")
    
    # Relire après l'ajout
    with open("exemple.txt", "r", encoding="utf-8") as fichier:
        print("\nFichier mis à jour :")
        print(fichier.read())
    
    # Fichiers binaires
    with open("exemple_binaire.bin", "wb") as fichier:
        fichier.write(b'\x42\x6f\x6e\x6a\x6f\x75\x72')  # "Bonjour" en binaire
    
    with open("exemple_binaire.bin", "rb") as fichier:
        donnees = fichier.read()
        print("\nDonnées binaires :", donnees)
        print("Données décodées :", donnees.decode("utf-8"))
    
    # Déplacer le curseur dans le fichier
    with open("exemple.txt", "r", encoding="utf-8") as fichier:
        debut = fichier.read(10)
        print("\n10 premiers caractères :", debut)
        
        fichier.seek(20)
        depuis_20 = fichier.read(10)
        print("10 caractères depuis la position 20 :", depuis_20)

except FileNotFoundError:
    print("Fichier introuvable.")
except PermissionError:
    print("Permissions insuffisantes pour accéder au fichier.")
except Exception as e:
    print(f"Une erreur s'est produite : {e}")

Erreurs fréquentes

SyntaxError : erreur de syntaxe

Se produit quand le code ne respecte pas les règles de syntaxe de Python. C'est l'une des erreurs les plus courantes chez les débutants.

Exemple de code erroné :


# Deux-points manquants après if
if x > 5
    print("x est supérieur à 5")

# Guillemets mal assortis
print('Bonjour, "monde !")

# Parenthèse non fermée
print("Résultat :", (10 + 5 * 2

Version corrigée :


# Deux-points ajoutés après if
if x > 5:
    print("x est supérieur à 5")

# Guillemets cohérents
print('Bonjour, "monde !"')

# Parenthèse fermée
print("Résultat :", (10 + 5 * 2))

Comment corriger :

Lisez attentivement le message d'erreur : il indique généralement la ligne concernée.
Vérifiez que toutes les parenthèses, crochets et accolades sont bien fermés.
Assurez-vous qu'un deux-points suit bien les conditions et les déclarations de fonctions.
Vérifiez les guillemets : ils doivent être appariés et du même type (' ou ").
Faites attention aux espaces et à l'indentation en début de ligne.

NameError : nom non défini

Se produit quand on essaie d'utiliser une variable ou une fonction qui n'a pas encore été définie.

Exemple de code erroné :


# Utiliser une variable avant de la définir
print(message)
message = "Bonjour, monde !"

# Faute de frappe dans le nom de variable
nom = "Alice"
print(nmo)

# Fonction non définie
resultat = calculer_somme(5, 10)

Version corrigée :


# Définir la variable avant de l'utiliser
message = "Bonjour, monde !"
print(message)

# Corriger la faute de frappe
nom = "Alice"
print(nom)

# Définir la fonction avant de l'appeler
def calculer_somme(a, b):
    return a + b

resultat = calculer_somme(5, 10)

Comment corriger :

Définissez toujours les variables avant de les utiliser.
Vérifiez l'orthographe des noms (Python est sensible à la casse).
Pensez à la portée des variables (locale/globale).
Si vous utilisez une fonction, assurez-vous qu'elle est définie ou importée.
Les fautes de frappe sont la cause la plus fréquente de cette erreur.

TypeError : types de données incompatibles

Se produit quand on tente d'effectuer une opération avec des types incompatibles, ou qu'on passe un mauvais type d'argument à une fonction.

Exemple de code erroné :


# Concaténer une chaîne et un entier
age = 25
message = "J'ai " + age + " ans"

# Appeler une méthode sur un mauvais type
nombres = 12345
premier_chiffre = nombres[0]

# Passer un mauvais type à une fonction
resultat = len(42)

Version corrigée :


# Convertir l'entier en chaîne
age = 25
message = "J'ai " + str(age) + " ans"
# Ou mieux : utiliser une f-string
message = f"J'ai {age} ans"

# Convertir en chaîne pour accéder à l'index
nombres = 12345
premier_chiffre = str(nombres)[0]

# Passer le bon type
chaine_nombre = "42"
resultat = len(chaine_nombre)

Comment corriger :

Utilisez les fonctions de conversion : str(), int(), float().
Le message d'erreur indique généralement quels types sont incompatibles.
Pour déboguer, utilisez type() pour vérifier le type d'une variable.
Certaines méthodes ne fonctionnent qu'avec des types spécifiques.
Préférez les f-strings pour combiner texte et nombres.

IndexError : index hors limites

Se produit quand on accède à un élément d'une liste ou d'une chaîne avec un index qui n'existe pas.

Exemple de code erroné :


# Accès à un index inexistant
fruits = ["pomme", "banane", "orange"]
print(fruits[3])  # l'index max est 2

# Accès sur une liste vide
liste_vide = []
premier = liste_vide[0]

# Boucle qui dépasse la taille de la liste
for i in range(5):
    nombres = [1, 2, 3, 4]
    print(nombres[i])

Version corrigée :


# Utiliser le bon index
fruits = ["pomme", "banane", "orange"]
print(fruits[2])  # retourne "orange"

# Vérifier que la liste n'est pas vide
liste_vide = []
if liste_vide:
    premier = liste_vide[0]
else:
    print("La liste est vide")

# Itérer sur la longueur réelle
nombres = [1, 2, 3, 4]
for i in range(len(nombres)):
    print(nombres[i])
# Ou encore mieux, itérer directement
for nombre in nombres:
    print(nombre)

Comment corriger :

En Python, les index commencent à 0.
L'index maximum est len(collection) - 1.
Utilisez len() pour connaître la taille d'une collection.
Préférez la boucle for-each aux boucles à index quand c'est possible.
Utilisez try-except ou vérifiez l'index avant d'y accéder.

IndentationError : erreur d'indentation

Se produit quand l'indentation est incorrecte. En Python, l'indentation est obligatoire pour délimiter les blocs de code.

Exemple de code erroné :


# Indentation incohérente dans un bloc if
if True:
    print("Première ligne")
  print("Deuxième ligne")  # indentation incorrecte

# Pas d'indentation dans une boucle
for i in range(3):
print(i)  # manque l'indentation

# Mélange de tabulations et d'espaces
def exemple():
    print("Cette ligne utilise des espaces")
	print("Cette ligne utilise une tabulation")

Version corrigée :


# Indentation cohérente
if True:
    print("Première ligne")
    print("Deuxième ligne")  # indentation correcte

# Bonne indentation dans la boucle
for i in range(3):
    print(i)  # indentation ajoutée

# Uniquement des espaces (recommandé par PEP 8)
def exemple():
    print("Cette ligne utilise des espaces")
    print("Cette ligne aussi")

Comment corriger :

N'utilisez que des espaces, ou que des tabulations — ne mélangez jamais les deux.
PEP 8 recommande 4 espaces par niveau d'indentation.
Configurez votre éditeur pour convertir automatiquement les tabulations en espaces.
Toutes les lignes d'un même bloc doivent avoir la même indentation.
Après un deux-points (conditions, boucles, fonctions), un bloc indenté doit suivre.

ImportError / ModuleNotFoundError : erreur d'import

Se produit quand on tente d'importer un module non installé, introuvable, ou avec une faute de frappe dans le nom.

Exemple de code erroné :


# Importer un module inexistant
import module_inexistant

# Faute de frappe dans le nom du module
import padas  # au lieu de pandas

# Importer une fonction inexistante
from math import factorial, racinecarree  # racinecarree n'existe pas

Version corrigée :


# Installer le module avant de l'importer
# pip install requests
import requests

# Corriger la faute de frappe
import pandas

# Bon nom de fonction
from math import factorial, sqrt  # sqrt à la place de racinecarree

# Gérer l'absence d'un module
try:
    import matplotlib.pyplot as plt
except ImportError:
    print("matplotlib n'est pas installé. Lancez : pip install matplotlib")

Comment corriger :

Vérifiez que le module est bien installé (pip install pour les modules externes).
Contrôlez l'orthographe du nom du module.
Vérifiez que le module est accessible depuis le PYTHONPATH.
Consultez la documentation du module pour les noms exacts des fonctions et classes.
Utilisez try-except pour gérer les éventuelles erreurs d'import.

KeyError : clé introuvable

Se produit quand on tente d'accéder à une clé qui n'existe pas dans un dictionnaire.

Exemple de code erroné :


# Accès à une clé inexistante
utilisateur = {"nom": "Alice", "age": 30}
print(utilisateur["email"])  # la clé "email" n'existe pas

# Faute de frappe dans la clé
parametres = {"timeout": 30, "nb_tentatives": 3}
print(parametres["time_out"])  # faute dans "timeout"

# Supprimer une clé inexistante
config = {"debug": True, "logs": False}
del config["cache"]  # la clé "cache" n'existe pas

Version corrigée :


# Accès sécurisé avec get()
utilisateur = {"nom": "Alice", "age": 30}
email = utilisateur.get("email", "non renseigné")
print(f"Email : {email}")

# Vérifier l'existence de la clé
parametres = {"timeout": 30, "nb_tentatives": 3}
cle = "time_out"
if cle in parametres:
    print(parametres[cle])
else:
    print(f"Clé '{cle}' introuvable")

# Suppression sécurisée
config = {"debug": True, "logs": False}
cle_a_supprimer = "cache"
if cle_a_supprimer in config:
    del config[cle_a_supprimer]
else:
    print(f"La clé '{cle_a_supprimer}' n'existe pas")

Comment corriger :

Préférez get() à l'accès direct dict[clé] : il permet de définir une valeur par défaut.
Vérifiez l'existence d'une clé avec l'opérateur in avant d'y accéder.
Faites attention à la casse et aux fautes de frappe dans les noms de clés.
Utilisez try-except pour gérer les clés manquantes.
Pour déboguer, affichez toutes les clés avec dict.keys().

AttributeError : attribut introuvable

Se produit quand on tente d'accéder à un attribut ou une méthode qui n'existe pas sur un objet.

Exemple de code erroné :


# Appeler une méthode inexistante
texte = "bonjour"
texte_majuscules = texte.mettre_tout_en_majuscules()  # n'existe pas

# Faute de frappe dans le nom de méthode
nombres = [1, 2, 3]
nombres.ajou(4)  # au lieu de append

# Accéder à un attribut de None
def trouver_utilisateur(id_utilisateur):
    return None  # utilisateur non trouvé

utilisateur = trouver_utilisateur(123)
print(utilisateur.nom)  # erreur : None n'a pas d'attribut nom

Version corrigée :


# Utiliser la méthode correcte
texte = "bonjour"
texte_majuscules = texte.upper()  # méthode correcte

# Corriger la faute de frappe
nombres = [1, 2, 3]
nombres.append(4)  # méthode correcte

# Vérifier None avant d'accéder à un attribut
def trouver_utilisateur(id_utilisateur):
    return None

utilisateur = trouver_utilisateur(123)
if utilisateur is not None:
    print(utilisateur.nom)
else:
    print("Utilisateur non trouvé")

# Vérifier l'existence d'un attribut avec hasattr
class Personne:
    def __init__(self, nom):
        self.nom = nom

personne = Personne("Anna")
if hasattr(personne, "age"):
    print(personne.age)
else:
    print("L'attribut 'age' n'existe pas")

Comment corriger :

Consultez la documentation ou utilisez dir() pour lister les attributs et méthodes disponibles.
Vérifiez le type de l'objet avec type() ou isinstance() avant d'appeler une méthode.
Vérifiez toujours qu'un objet n'est pas None avant d'accéder à ses attributs.
Utilisez hasattr() pour tester l'existence d'un attribut.
Le message d'erreur indique généralement quelle méthode ou quel attribut est manquant.

Questions fréquentes

Comment utiliser ce compilateur en ligne ?

Collez simplement votre code Python dans l'éditeur et cliquez sur « Exécuter ». Le résultat s'affiche presque immédiatement en dessous. C'est un moyen rapide de tester un bout de code sans installer Python sur votre machine.

Comment ça fonctionne ?

Ce service repose sur Pyodide, un projet qui permet d'exécuter Python dans le navigateur grâce à WebAssembly. Votre code tourne entièrement côté client, sans serveur Python distant.

Quelle version de Python est utilisée ?

Le compilateur utilise Python 3.8, une version stable et très répandue. Elle prend en charge la plupart des fonctionnalités modernes du langage et une large gamme de bibliothèques.

Quelles bibliothèques sont disponibles ?

De nombreuses bibliothèques Python populaires sont préinstallées, notamment :

NumPy : calcul numérique et tableaux multidimensionnels.
Pandas : analyse et manipulation de données tabulaires.
SciPy : calcul scientifique basé sur NumPy.
Matplotlib : création de graphiques et visualisations.
Scikit-learn : apprentissage automatique et analyse de données.
Requests : requêtes HTTP.
Flask : création d'applications web légères.
Django : développement d'applications web plus complexes.
PyTest : tests automatisés.
LXML : analyse de documents XML et HTML.
PyYAML : lecture et écriture de fichiers YAML.
Regex : expressions régulières avancées.
Cryptography : opérations cryptographiques.
BeautifulSoup4 : parsing de documents HTML et XML.
SQLAlchemy : interaction avec les bases de données.
Pillow : traitement d'images.
SymPy : calcul symbolique.
NetworkX : analyse de graphes et réseaux.
Pyodide : intégration avec WebAssembly.
Micropip : installation de paquets supplémentaires depuis PyPI.

La liste complète est disponible sur le site de Pyodide.

Mon code est-il sauvegardé après fermeture du navigateur ?

Non, le code n'est pas conservé après la fermeture de l'onglet. Pensez à télécharger votre fichier .py ou à copier votre code avant de quitter.

Mon code est-il envoyé à un serveur ?

Non. Tout le traitement s'effectue dans votre navigateur : votre code ne quitte pas votre machine. Cela dit, pour du code contenant des données sensibles ou confidentielles, mieux vaut utiliser un environnement local ou une solution cloud sécurisée.

Y a-t-il des limitations ?

Quelques contraintes à garder en tête :

Temps d'exécution : limité pour éviter de bloquer le navigateur.
Mémoire : le code s'exécutant dans le navigateur, la mémoire disponible est limitée par votre appareil.

Les opérations sur de gros volumes de données peuvent donc être plus lentes qu'en local.

Comment déboguer mon code ?

Vous pouvez utiliser print() pour afficher des valeurs intermédiaires et suivre l'exécution pas à pas. La fonction traceback est aussi disponible pour obtenir des informations détaillées sur les erreurs. Des outils de débogage plus avancés pourraient être ajoutés à l'avenir.

Commencez à coder en Python dès maintenant

Que vous débutiez en programmation ou que vous ayez déjà de l'expérience, cet éditeur en ligne vous permet d'écrire, tester et améliorer votre code sans configuration préalable.

Aller à l'éditeur

Compilateur Python en ligne

Fonctionnalités du compilateur Python en ligne

Exécution immédiate

Compatible tous appareils

Sauvegardez votre code

Messages d'erreur détaillés

Autocomplétion

Interface personnalisable

Guide de syntaxe

Erreurs fréquentes

SyntaxError : erreur de syntaxe

Exemple de code erroné :

Version corrigée :

Comment corriger :

NameError : nom non défini

Exemple de code erroné :

Version corrigée :

Comment corriger :

TypeError : types de données incompatibles

Exemple de code erroné :

Version corrigée :

Comment corriger :

IndexError : index hors limites

Exemple de code erroné :

Version corrigée :

Comment corriger :

IndentationError : erreur d'indentation

Exemple de code erroné :

Version corrigée :

Comment corriger :

ImportError / ModuleNotFoundError : erreur d'import

Exemple de code erroné :

Version corrigée :

Comment corriger :

KeyError : clé introuvable

Exemple de code erroné :

Version corrigée :

Comment corriger :

AttributeError : attribut introuvable

Exemple de code erroné :

Version corrigée :

Comment corriger :

Questions fréquentes