Python Academy · Leçon

Définir des modèles

Associer des classes à des tables

Définir des modèles est une leçon Python Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Python Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Python Academy comprend 4 leçons au total.

Les modèles correspondent aux tables

Dans l'ORM de SQLAlchemy, un modèle est une classe Python associée à une table de base de données. Chaque instance devient une ligne.

Les modèles héritent d'une classe Base commune.

from sqlalchemy.orm import DeclarativeBase
class Base(DeclarativeBase):
    pass
print('Base class ready')

Le tablename

Chaque modèle définit __tablename__ avec le nom de sa table. SQLAlchemy l'utilise lors de la génération du SQL.

from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
class Base(DeclarativeBase):
    pass
class User(Base):
    __tablename__ = 'users'
    id: Mapped[int] = mapped_column(primary_key=True)
print(User.__tablename__)

Colonnes avec Mapped

Les versions modernes de SQLAlchemy déclarent les colonnes avec des indications de type : Mapped[int] et mapped_column(). L'indication de type définit le type Python et renseigne le type de colonne.

from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
class Base(DeclarativeBase):
    pass
class User(Base):
    __tablename__ = 'users'
    id: Mapped[int] = mapped_column(primary_key=True)
    name: Mapped[str]
    age: Mapped[int]
print('User has id, name, age')

La clé primaire

Marquez une colonne comme clé primaire avec primary_key=True. Les clés primaires entières s'incrémentent automatiquement par défaut.

from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
class Base(DeclarativeBase):
    pass
class Product(Base):
    __tablename__ = 'products'
    id: Mapped[int] = mapped_column(primary_key=True)
    title: Mapped[str]
print('id is the primary key')

Colonnes facultatives

Utilisez Mapped[str | None] ou Optional[str] pour autoriser les valeurs NULL. Un simple Mapped[str] est NOT NULL.

from typing import Optional
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
class Base(DeclarativeBase):
    pass
class User(Base):
    __tablename__ = 'users'
    id: Mapped[int] = mapped_column(primary_key=True)
    nickname: Mapped[Optional[str]]
print('nickname can be NULL')

Valeurs par défaut et unicité

mapped_column() accepte des options telles que unique=True et default= pour ajouter des contraintes et des valeurs de remplacement.

from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
class Base(DeclarativeBase):
    pass
class User(Base):
    __tablename__ = 'users'
    id: Mapped[int] = mapped_column(primary_key=True)
    email: Mapped[str] = mapped_column(unique=True)
    active: Mapped[bool] = mapped_column(default=True)
print('email is unique, active defaults to True')

Longueur des chaînes

Pour les bases de données qui l'exigent, définissez la longueur d'une chaîne avec mapped_column(String(50)).

from sqlalchemy import String
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
class Base(DeclarativeBase):
    pass
class User(Base):
    __tablename__ = 'users'
    id: Mapped[int] = mapped_column(primary_key=True)
    name: Mapped[str] = mapped_column(String(50))
print('name limited to 50 chars')

Créer le schéma

Base.metadata.create_all(engine) crée des tables pour chaque modèle qui hérite de Base.

from sqlalchemy import create_engine
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
class Base(DeclarativeBase):
    pass
class User(Base):
    __tablename__ = 'users'
    id: Mapped[int] = mapped_column(primary_key=True)
    name: Mapped[str]
engine = create_engine('sqlite:///:memory:')
Base.metadata.create_all(engine)
print('Schema created')

Créer des instances

Construisez une ligne en instanciant le modèle comme un objet Python ordinaire et en transmettant les valeurs des colonnes sous forme d'arguments nommés.

from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
class Base(DeclarativeBase):
    pass
class User(Base):
    __tablename__ = 'users'
    id: Mapped[int] = mapped_column(primary_key=True)
    name: Mapped[str]
u = User(name='Alice')
print(u.name)

Ajouter un repr

Un __repr__ personnalisé facilite le débogage en affichant clairement les données de l'objet.

from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
class Base(DeclarativeBase):
    pass
class User(Base):
    __tablename__ = 'users'
    id: Mapped[int] = mapped_column(primary_key=True)
    name: Mapped[str]
    def __repr__(self):
        return 'User(name=' + self.name + ')'
print(repr(User(name='Bob')))

Les modèles restent du Python ordinaire

Un modèle reste une classe ordinaire. Vous pouvez y ajouter des méthodes et des propriétés qui agissent sur ses données, en associant comportement et persistance.

from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
class Base(DeclarativeBase):
    pass
class User(Base):
    __tablename__ = 'users'
    id: Mapped[int] = mapped_column(primary_key=True)
    name: Mapped[str]
    def greet(self):
        return 'Hi, ' + self.name
print(User(name='Carol').greet())

Vérification rapide

Vérifiez vos compétences en définition de modèles.

Récapitulatif

Vous avez appris à définir des modèles ORM.

Les modèles héritent d'une DeclarativeBase et définissent __tablename__
Les colonnes utilisent Mapped[type] et mapped_column()
primary_key, unique et default ajoutent des contraintes
create_all() crée les tables

Questions Fréquemment Posées

La leçon « Définir des modèles » est-elle gratuite ?

Oui — le texte complet de « Définir des modèles » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Python Academy, passe à CoddyKit PRO. Le cours Python Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Définir des modèles » ?

Associer des classes à des tables Tu pratiques Python Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Python Academy ?

Aucune expérience préalable n'est requise. Python Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Définir des modèles » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Python Academy ?

Oui. Chaque leçon Python Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Python Academy