Django - Dynamische modellen

In Django klassen zijn objecten Python, Net als elk ander object kunnen we veel interessante effecten bereiken op het moment van uitvoering van het programma, dankzij het feit dat we alle Python-functies en -methoden beschikbaar in Django kunnen we klassen bouwen die dynamische klassen kunnen genereren.
Het creëren van een dynamische klasse kan ons enkele voordelen bieden, zoals het maken van een model van een klasse, waardoor nieuwe functionaliteiten worden gegenereerd.
Hoe werken lessen in het kader?
Om tot het punt te komen van het genereren van dynamische modellen, moeten we er eerst voor zorgen dat we begrijpen hoe klassen werken in Python.
We weten dat de lessen in Python zijn objecten die tijdens runtime kunnen worden gemaakt met behulp van de interne constructor typ () en het ontvangen van de details van hoe ze moeten worden gedefinieerd.
Modellen in Django
Omdat we weten hoe klassen werken in Python, moeten we benadrukken dat de modellen in Django het zijn standaard Python-klassen, alleen worden ze zo gedeclareerd dat: Django u ze kunt gebruiken en dat het standaardklassen zijn, stelt ons in staat om tijdens runtime modellen te genereren.
Eerste implementatie
Laten we de volgende afbeelding bekijken met een kleine code:

Hier zien we hoe de Django-framework We importeren de modellenmodule en vervolgens maken we een methode om de modellen te maken met de constructortype () die we in het vorige punt van de tutorial hadden genoemd.
Hoewel deze simplistische benadering die we hebben toegepast natuurlijk niet gaat werken, is het probleem dat Django verwacht dat een woordenboek een module met zijn code bevat.
Laten we nu een code bekijken waarmee we dit probleem oplossen:

 def create_model (naam, module_pad): retourtype (naam, (modellen.Model,), {'__module__': module_pad}) 

Met deze implementatie hebben we de eerste fout geëlimineerd die bij het eerste voorbeeld naar voren kwam.
Configuratie-opties toevoegen
We gaan onze code voltooien voor het genereren van dynamische modellen, inclusief de mogelijkheid dat we de opties van kunnen opnemen django-configuratie, hiervoor gebruiken we de Meta klasse en we gaan de werking ervan overschrijven zodat onze nieuwe implementatie ons in staat stelt om de manier waarop we de opties gaan afhandelen opnieuw te definiëren, laten we in de volgende afbeelding de code zien die al is voltooid om dit te bereiken:

In deze code hebben we duidelijk enkele aspecten van onze oorspronkelijke code veranderd, we beginnen met te definiëren dat het pad van de module is: Django.db.models, vanaf hier gaan we de eerste definities krijgen, zodra dit gebeurt, maken we een woordenboek waar we het aan toewijzen __module__ de waarde van het pad dat we hebben gedefinieerd.
Dan herwerken we de Meta-klasse, hiermee redden we de mogelijke problemen die we aan het begin van dit punt hadden besproken, eindelijk kunnen we onze type () methode, het doorgeven van de benodigde gegevens en geen fout.
Met deze nieuwe kennis die we hebben gegenereerd, hebben we al een solide basis waarmee we kunnen communiceren met de code van Django op een veiligere manier, wat ons in een gunstige positie plaatst voor de ontwikkeling van onze applicaties en het dynamisch genereren van modellen in de uitvoeringstijd van ons programma.Vond je deze Tutorial leuk en heb je eraan geholpen?Je kunt de auteur belonen door op deze knop te drukken om hem een ​​positief punt te geven