Shulou(Shulou.com)06/01 Report--

This article mainly introduces "how to use Python to achieve a simple ORM model". In daily operation, I believe many people have doubts about how to use Python to achieve a simple ORM model. The editor consulted all kinds of materials and sorted out simple and easy-to-use operation methods. I hope it will be helpful to answer the doubts of "how to use Python to achieve a simple ORM model". Next, please follow the editor to study!

Metaclass

As for metaclass, my understanding is actually relatively shallow, which is probably what it means.

All classes are created using metaclasses, and the parent class of all classes must be object (for Python3). There is only one metaclass in Python (type). Of course, there is no custom metaclass here.

Let's take a look at the creation of classes.

Class Test: # define a class passTest1 = type ("Test2", (object,), {"name": "test"}) # define a class print (type (Test)) print (type (Test1))--

As can be seen from the above, there are actually two ways to create a class, one is to define it through the class keyword, the other is to create it through type, of course, it is commonly used to create a class. Looking at the final result, you can see that the type of the class is type. It means that our class is created by type.

After understanding this, let's sort out how to use custom metaclasses to create classes. To understand, custom metaclasses need to inherit type.

Class MetaClass (type): # define a metaclass passclass Test (metaclass=MetaClass): # create a class passprint (type (Test)) using a custom metaclass

It is obvious that the Test class was created with the MetaClass class

Descriptor

From the definition of a descriptor, as long as one or more of _ _ get__, _ _ set__, _ _ delete__ are implemented in a class, an instance of this class can be called a descriptor.

Let's define a simple descriptor

Class Describer: def _ _ set__ (self, instance, value): print ("called when setting properties") self.value = value def _ _ get__ (self, instance, owner): print ("called when getting properties") return self.value def _ _ delete__ (self Instance): print ("called when deleting an attribute") self.value = Noneclass Test: name = Describer () t = Test () t.name = "xxxxx" print (t.name)-- xxxxx is called when the property is called to get the property

Do you have any ideas from the above code? Since the _ _ set__ method will be called when we set the property, can we do something with the property before setting it?

ORM model

What on earth is the ORM model? ORM is certainly no stranger to back-end research and development, including many back-end frameworks now come with this model.

ORM (Object Relational Mapping) object-relational mapping

Since it is an object-relational mapping, what is the object? My understanding is: for the mapping between the classes in Python and the database, there is no need to write SQL for the operation of the data, because it is all encapsulated. For example, if you want to insert a piece of data, you can create an object directly.

Python-> Database

Class name-> Table name in the database

Object-> A row of data in a database

Properties-> Fields in the database

It's roughly the mapping relationship above.

ORM implementation steps

1. Use the descriptor to realize the restriction on the type and length of database fields.

2. Implement the Mode class, that is, the class in Python

3. Use metaclass to realize the mapping relationship.

Okay, let's first use the descriptor to limit the type and length of the data field.

Class BaseFiled: passclass CharFiled (BaseFiled): "" define the type restriction of a string "" def _ _ init__ (self, length=10): self.length = length def _ _ set__ (self, instance, value): if isinstance (value, str): if len (value)

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.