[Introduction à Python3 Day 18] Chapitre 8 Destinations de données (8.3.6.2 à 8.3.6.3)

8.3.6.2 Langage de représentation SQL

• Le langage d'expression introduit des fonctions qui créent du SQL pour diverses opérations.

--L'objet zoo suivant adopte une approche intermédiaire entre le monde des bases de données SQL et le monde des structures de données Python. (** Je comprends qu'il existe un mélange de syntaxe similaire aux instructions SQL (uniquement en majuscules et minuscules) et à la syntaxe Python telle que select () **)

>>> import sqlalchemy as sa
>>> conn=sa.create_engine("sqlite://")
#Utilisez un langage d'expression au lieu de SQL pour définir la table zoo.
>>> meta=sa.MetaData()
>>> zoo=sa.Table("zoo",meta,
...     sa.Column("critter",sa.String,primary_key=True),
...     sa.Column("count",sa.Integer),
...     sa.Column("damages",sa.Float)
...     )
>>> meta.create_all(conn)
#Insérez des données à l'aide d'un langage de représentation.
>>> conn.execute(zoo.insert(("bear",2,1000.0)))
<sqlalchemy.engine.result.ResultProxy object at 0x108f30590>
>>> conn.execute(zoo.insert(("weasel",1,2000.0)))
<sqlalchemy.engine.result.ResultProxy object at 0x108f306d0>
>>> conn.execute(zoo.insert(("duck",10,0)))
<sqlalchemy.engine.result.ResultProxy object at 0x108f303d0>
#Faites une instruction SELECT. zoo.select()Est un SQL Python SELECT simple*Égal à FROM zoo, il sélectionne les informations pour toutes les tables représentées par l'objet zoo.
>>> result=conn.execute(zoo.select())
#Obtenez des informations et stockez-les en lignes.
>>> rows=result.fetchall()
>>> print(rows)
[('bear', 2, 1000.0), ('weasel', 1, 2000.0), ('duck', 10, 0.0)]

8.3.6.3 ORM (Object Relationship Mapping)

--Au niveau supérieur de SQLAIchemy, ORM utilise la représentation SQL, mais le mécanisme de base de données réel n'est pas visible. Si vous définissez une classe, ORM traitera les données avec le DB.

• ** L'idée de base du mappage de relation d'objet est de pouvoir faire référence à des objets dans le code et de continuer à écrire du code à la manière de Python tout en utilisant le SGBDR. ** **

>>> import sqlalchemy as sa
>>> from sqlalchemy.ext.declarative import declarative_base
#Ouverture d'une connexion.
>>> conn=sa.create_engine("sqlite:///zoo.db")
>>> Base=declarative_base()
#Entrez l'ORM de SQL AIchemy.
>>> class Zoo(Base):
...     __tablename__="zoo"
...     critter=sa.Column("critter",sa.String,primary_key=True)
...     count=sa.Column("count",sa.Integer)
...     dameges=sa.Column("damages",sa.Float)
...     def __init__(self,critter,count,damages):
...         self.critter=critter
...         self.count=count
...         self.damages=damages
...     def __repr__(self):
...         return "<Zoo({},{},{})>".format(self.critter,self.count,self.damages)
... 
#Création de bases de données et de tables
>>> Base.metadata.create_all(conn)
#Si vous créez un objet Python, vous pouvez insérer des données dans la table zoo.
>>> first=Zoo("duck",10,0.0)
>>> second=Zoo("bear",2,1000.0)
>>> third=Zoo("weasel",1,2000.0)
>>> first
<Zoo(duck,10,0.0)>

--Créez une session pour interagir avec DB.

>>> from sqlalchemy.orm import sessionmaker
>>> Session =sessionmaker(bind=conn)
>>> session=Session()
#Écrivez les trois objets créés plus tôt dans la session dans la base de données.
#add()La fonction ajoute un objet_all()La fonction ajoute une liste.
>>> session.add(first)
>>> session.add_all([second,third])
#Enfin, terminez de force tous les traitements.
>>> session.commit
<bound method Session.commit of <sqlalchemy.orm.session.Session object at 0x108f3f1d0>>

Impressions

J'étudie actuellement le traitement parallèle au chapitre 11, mais le contenu est assez riche. Cela ne me vient pas du tout à l'esprit, mais quand je regarde la documentation Python, il y a des parties qui sont écrites plus en détail que le livre, et je suis devenu capable de comprendre le multitraitement que je ne comprenais pas hier, et j'ai senti l'importance de la documentation.

Les références

"Introduction à Python3 par Bill Lubanovic (publié par O'Reilly Japon)"