Tout ce que vous devez savoir sur Python et les cartes relationnelles objet

Tout ce que vous devez savoir sur Python et les cartes relationnelles objet

Vous avez peut-être entendu parler du mappage objet-relationnel (ORM). Vous en avez peut-être même utilisé un, mais quels sont-ils exactement ? Et comment les utilisez-vous en Python ?





Voici tout ce que vous devez savoir sur les ORM et Python.



Qu'est-ce qu'un ORM ?

Le mappage objet-relationnel (ORM) est une technique de programmation utilisée pour accéder à une base de données. Il expose votre base de données dans une série d'objets. Vous n'avez pas besoin d'écrire des commandes SQL pour insérer ou récupérer des données, vous utilisez une série d'attributs et de méthodes attachés aux objets.





Cela peut sembler complexe et inutile, mais cela peut vous faire gagner beaucoup de temps et vous aider à contrôler l'accès à votre base de données.

Voici un exemple. Dites que chaque fois que vous insérez un mot de passe dans votre base de données, vous souhaitez le hacher, comme expliqué dans Sécurité des mots de passe du site Web . Ce n'est pas un problème pour les cas d'utilisation simples --- vous faites le calcul avant l'insertion. Mais que se passe-t-il si vous devez insérer un enregistrement à plusieurs endroits dans le code ? Que se passe-t-il si un autre programmeur insère dans votre table, et vous ne le savez pas ?



En utilisant un ORM, vous pouvez écrire du code pour vous assurer qu'à tout moment et n'importe où une ligne ou un champ de votre base de données est accessible, votre autre code personnalisé est exécuté en premier.

Cela agit également comme une « source unique de vérité ». Si vous souhaitez modifier un calcul personnalisé, vous n'avez qu'à le modifier à un seul endroit, pas à plusieurs. Il est possible d'appliquer bon nombre de ces principes avec programmation orientée objet (POO) en Python , mais les ORM fonctionnent en tandem avec les principes de la POO pour contrôler l'accès à une base de données.



Il y a certaines choses à surveiller lors de l'utilisation d'un ORM, et il y a des circonstances où vous ne voudrez peut-être pas en utiliser un, mais elles sont généralement considérées comme une bonne chose à avoir, en particulier dans une grande base de code.

ORM en Python à l'aide de SQLAlchemy

Comme de nombreuses tâches en Python, il est plus rapide et plus facile d'importer un module que d'écrire le vôtre. Bien sûr, il est possible d'écrire son propre ORM, mais pourquoi réinventer la roue ?



Les exemples suivants utilisent tous SQLAlchimie , un ORM Python populaire, mais de nombreux principes s'appliquent quelle que soit l'implémentation.

Configuration de Python pour SQLAlchemy

Avant de vous lancer, vous devrez configurer votre machine pour le développement Python avec SQLAlchemy.

Vous devrez utiliser Python 3.6 pour suivre ces exemples. Alors que les anciennes versions fonctionneront, le code ci-dessous nécessitera quelques modifications avant de s'exécuter. Vous n'êtes pas sûr des différences ? Notre FAQ Python couvre toutes les différences.

Avant de coder, vous devez configurer un environnement Python , ce qui évitera les problèmes avec d'autres packages Python importés.

Assurez-vous que vous avez PIP, le gestionnaire de paquets Python installé, qui est fourni avec la plupart des versions modernes de Python.

Une fois que vous êtes prêt, vous pouvez commencer par préparer SQLAlchemy. Depuis votre environnement Python dans la ligne de commande, installez SQLAlchemy avec le pip installer commander:

pip install SQLAlchemy-1.2.9

Les 1.2.9 est le numéro de version. Vous pouvez laisser cette option désactivée pour obtenir le dernier package, mais il est recommandé d'être précis. Vous ne savez pas quand une nouvelle version peut casser votre code actuel.

Vous êtes maintenant prêt à commencer à coder. Vous devrez peut-être préparer votre base de données pour accepter une connexion Python, mais les exemples suivants utilisent tous un SQLite base de données créée en mémoire ci-dessous.

Modèles en SQLAlchemy

L'un des éléments clés d'un ORM est un maquette . Il s'agit d'une classe Python qui décrit à quoi devrait ressembler une table et comment elle devrait fonctionner. C'est la version ORM du CRÉER UN TABLEAU instruction en SQL. Vous avez besoin d'un modèle pour chaque table de votre base de données.

Ouvrez votre éditeur de texte ou IDE préféré et créez un nouveau fichier appelé test.py . Saisissez ce code de démarrage, enregistrez le fichier et exécutez-le :

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
Base = declarative_base()
engine = create_engine('sqlite://') # Create the database in memory
Base.metadata.create_all(engine) # Create all the tables in the database

Ce code fait plusieurs choses. Les importations sont nécessaires pour que Python comprenne où trouver les modules SQLAlchemy dont il a besoin. Vos modèles utiliseront le base_déclarative plus tard, et il configure tous les nouveaux modèles pour qu'ils fonctionnent comme prévu.

Les créer_moteur La méthode crée une nouvelle connexion à votre base de données. Si vous avez déjà une base de données, vous devrez changer sqlite:// à l'URI de votre base de données. En l'état, ce code créera une nouvelle base de données en mémoire uniquement. La base de données est détruite une fois l'exécution de votre code terminée.

Finalement, le créer_tout La méthode crée toutes les tables définies dans vos modes dans votre base de données. Comme vous n'avez pas encore défini de modèles, rien ne se passera. Allez-y et exécutez ce code, pour vous assurer que vous n'avez pas de problèmes ou de fautes de frappe.

Faisons un modèle. Ajoutez une autre importation en haut de votre fichier :

from sqlalchemy import Column, Integer, String

Cela importe le Colonne , Entier , et Chaîne de caractères modules de SQLAlchemy. Ils définissent le fonctionnement des tables, champs, colonnes et types de données de la base de données.

Sous le base_déclarative , créez votre classe de modèle :

class Cars(Base):
__tablename__ = 'cars'
id = Column(Integer, primary_key=True)
make = Column(String(50), nullable=False)
color = Column(String(50), nullable=False)

Cet exemple simple utilise des voitures, mais vos tables peuvent contenir des données.

Chaque classe doit hériter Base . Le nom de votre table de base de données est défini dans __nom de la table__ . Cela devrait être le même que le nom de la classe, mais ce n'est qu'une recommandation, et rien ne sera cassé s'ils ne correspondent pas.

Enfin, chaque colonne est définie comme une variable python au sein de la classe. Différents types de données sont utilisés et le clé primaire L'attribut indique à SQLAlchemy de créer le identifiant colonne comme clé primaire.

Allez-y et ajoutez une dernière importation, cette fois pour le Clé étrangère module. Ajoutez ceci à côté de votre Colonne importer:

from sqlalchemy import Column, ForeignKey, Integer, String

Créez maintenant une deuxième classe de modèle. Cette classe s'appelle Propriétaires de voitures , et stocke les détails du propriétaire de voitures spécifiques stockées dans le Voitures table:

class CarOwners(Base):
__tablename__ = 'carowners'
id = Column(Integer, primary_key=True)
name = Column(String(50), nullable=False)
age = Column(Integer, nullable=False)
car_id = Column(Integer, ForeignKey('cars.id'))
car = relationship(Cars)

Il y a plusieurs nouveaux attributs introduits ici. Les id_voiture est défini comme une clé étrangère. Il est lié au identifiant dans le voitures table. Remarquez comment le nom de table en minuscules est utilisé, à la place du nom de classe en majuscules.

Enfin, un attribut de auto est défini comme un relation amoureuse . Cela permet à votre modèle d'accéder au Voitures tableau via cette variable. Ceci est démontré ci-dessous.

Si vous exécutez ce code maintenant, vous verrez que rien ne se passe. C'est parce que vous ne lui avez pas encore dit de faire quoi que ce soit de notable.

Objets dans SQLAlchemy

Maintenant que vos modèles sont créés, vous pouvez commencer à accéder aux objets, lire et écrire des données. C'est une bonne idée de placer votre logique dans sa propre classe et son propre fichier, mais pour l'instant, elle peut rester à côté des modèles.

Écriture de données

Dans cet exemple, vous devez insérer des données dans la base de données avant de pouvoir les lire. Si vous utilisez une base de données existante, vous disposez peut-être déjà de données. Quoi qu'il en soit, il est toujours très utile de savoir comment insérer des données.

Vous avez peut-être l'habitude d'écrire INSÉRER instructions en SQL. SQLAlchemy gère cela pour vous. Voici comment insérer une ligne dans le Voitures maquette. Commencez par une nouvelle importation pour créateur de session :

from sqlalchemy.orm import sessionmaker

Ceci est nécessaire pour créer le session et Session DBS objets, qui sont utilisés pour lire et écrire des données :

DBSession = sessionmaker(bind=engine)
session = DBSession()

Maintenant, mettez ceci sous votre créer_tout déclaration:

car1 = Cars(
make='Ford',
color='silver'
)
session.add(car1)
session.commit()

Décomposons ce code. La variable voiture1 est défini comme un objet basé sur le Voitures maquette. Sa marque et sa couleur sont définies en tant que paramètres. C'est comme dire « faites-moi une voiture, mais ne l'écrivez pas encore dans la base de données ». Cette voiture existe en mémoire mais attend d'être écrite.

Ajouter la voiture à la session avec session.ajouter , puis écrivez-le dans la base de données avec session.commit .

Ajoutons maintenant un propriétaire :

owner1 = CarOwners(
name='Joe',
age='99',
car_id=(car1.id)
)
session.add(owner1)
session.commit()

Ce code est quasiment identique à l'encart précédent pour le Voitures maquette. La principale différence ici est que id_voiture est une clé étrangère, il faut donc un identifiant de ligne qui existe dans l'autre table. Celui-ci est accessible via le car1.id biens.

Vous n'avez pas besoin d'interroger la base de données ou de renvoyer des identifiants, car SQLAlchemy gère cela pour vous (tant que vous validez les données en premier).

Lecture de données

Une fois que vous avez écrit certaines données, vous pouvez commencer à les relire. Voici comment interroger le Voitures et Propriétaires de voitures les tables:

result = session.query(Cars).all()

C'est aussi simple que cela. En utilisant le mettre en doute méthode trouvée dans le session , vous spécifiez le modèle, puis utilisez le tous méthode pour récupérer tous les résultats. Si vous savez qu'il n'y aura qu'un seul résultat, vous pouvez utiliser le premier méthode:

result = session.query(Cars).first()

Une fois que vous avez interrogé le modèle et stocké les résultats renvoyés dans une variable, vous pouvez accéder aux données via l'objet :

print(result[0].color)

Cela imprime la couleur « argent », car cet enregistrement est la première ligne. Vous pouvez boucler sur l'objet de résultat si vous le souhaitez.

Lorsque vous avez défini la relation dans votre modèle, il est possible d'accéder aux données des tables associées sans spécifier de jointure :

result = session.query(CarOwners).all()
print(result[0].name)
print(result[0].car.color)

Cela fonctionne parce que votre modèle contient des détails sur la structure de votre table et le auto l'attribut a été défini comme un lien vers le voitures table.

Qu'est-ce qu'il n'y a pas à aimer dans les ORM ?

Ce didacticiel ne couvrait que les bases, mais une fois que vous les maîtrisez, vous pouvez passer aux sujets avancés. Les ORM présentent certains inconvénients potentiels :

  • Vous devez écrire votre modèle avant de pouvoir exécuter des requêtes.
  • C'est une autre nouvelle syntaxe à apprendre.
  • Il peut être trop complexe pour des besoins simples.
  • Vous devez avoir une bonne conception de base de données pour commencer.

Ces problèmes ne sont pas un gros problème en eux-mêmes, mais ce sont des choses à surveiller. Si vous travaillez avec une base de données existante, vous risquez de vous faire prendre.

Si vous n'êtes pas convaincu qu'un ORM est le bon outil pour vous, alors assurez-vous de lire sur le commandes SQL importantes que les programmeurs doivent connaître .

Partager Partager Tweeter E-mail Devriez-vous passer à Windows 11 immédiatement ?

Windows 11 arrive bientôt, mais faut-il mettre à jour dès que possible ou attendre quelques semaines ? Découvrons-le.

Lire la suite Rubriques connexes
  • La programmation
  • Python
  • SQL
  • Tutoriels de codage
A propos de l'auteur Joe Coburn(136 articles publiés)

Joe est diplômé en informatique de l'Université de Lincoln, au Royaume-Uni. C'est un développeur de logiciels professionnel, et lorsqu'il ne pilote pas de drones ou n'écrit pas de musique, on le trouve souvent en train de prendre des photos ou de produire des vidéos.

meilleur endroit pour acheter des t-shirts graphiques
Plus de Joe Coburn

Abonnez-vous à notre newsletter

Rejoignez notre newsletter pour des conseils techniques, des critiques, des ebooks gratuits et des offres exclusives !

Cliquez ici pour vous abonner