Der Bedarf an Daten wird am wichtigsten, wenn Sie Ihre erste Version der Website mit Django oder der REST-API mit Django Rest Framework (DRF) fertigstellen. Für ein ähnliches Problem habe ich meinen vorherigen Artikel geschrieben, in dem ich einen direkten Ansatz zum Speichern von JSON-Daten im Django-Modell durch direktes Einfügen in SQLite-Datenbanken und -Tabellen diskutiert habe. Allerdings habe ich auch erwähnt, dass Django über Loaddata, Dumpdata und Fixtures für ähnliche Probleme verfügt, für die jedoch kaum mehr Verständnis des Frameworks erforderlich ist.

Heute werde ich diese Lernkurve durchlaufen und besprechen, wie Sie Ihre normalen JSON-Daten in eine Vorrichtung konvertieren und dann mit loaddata JSON-Daten in ein bestimmtes Modell übertragen. Wenn Sie über einige Daten für Modelle verfügen (können über die Admin-Seite usw. hinzugefügt werden), erfahren Sie, wie Sie diese als Vorrichtungen speichern, um sie mit anderen Modellen oder in anderen Projekten zu verwenden.

Der vorherige Artikel besteht aus zwei Teilen: Im ersten Teil geht es um die normale Einrichtung, die für die Datenausgabe erforderlich ist, und im zweiten Teil geht es um das Python-Skript zum Speichern von JSON-Daten im Modell. Halten Sie den Artikel also kurz. In diesem Artikel beginne ich mit dem zweiten Teil und Sie können Teil I des vorherigen Artikels folgen, um diesem Artikel zu folgen. Angenommen, Sie haben eine Buch-App und ein Buchmodell in models.py, dann sind die API-Endpunkte ebenfalls bereit, wie zum Beispiel (Github-Repo des vorherigen Beitrags):
http://127.0.0.1:8000/api/books/1

oder Sie möchten einfach Daten in das Book-Modell für eine Django-basierte Website laden. Sie können dem Code aus dem folgenden Git-Repository folgen.
JSON-Datendumping an Modell

Angesichts der zwei Repositories können Sie von hier aus jeden verwenden, um dem Artikel zu folgen. Sie benötigen lediglich die folgenden Dinge:

1. Ein funktionierendes Django-Projekt mit einem Buchmodell mit oder ohne API-Funktionen
2. Eine JSON-Datei mit Buchinformationen gemäß dem Buchmodell.

Beispiel 1: Das Buchmodell in book/models.py

from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.CharField(max_length=100)    
    isbn = models.CharField(max_length=13, unique=True)
    pages = models.PositiveIntegerField()   
    language = models.CharField(max_length=30)

    def __str__(self):
        return self.title

books.json

[
  {
    "title": "Example Book 1",
    "author": "John Doe",
    "isbn": "1234567890123",
    "pages": 350,
    "language": "English"
  },
  {
    "title": "Example Book 2",
    "author": "Kumar Ajit",
    "isbn": "9876543210987",
    "pages": 280,
    "language": "Hindi"
  }
]

Beispiel 2: Das Buchmodell aus dem vorherigen Artikel

from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.CharField(max_length=100)
    price = models.DecimalField(max_digits=6, decimal_places=2)

    def __str__(self):
        return self.title

Die Datei data.json finden Sie hier.

Daten-Dumping zum Modell

Wir haben ein funktionierendes Django-Projekt mit einem Modell-Buch und einer zusätzlichen JSON-Datei mit Buchinformationen. Also, was ist nun das Problem?
Wir möchten die JSON-Daten in das Modell einfügen, sodass sie entweder mit der Django-Website verwendet werden können (z. B. Daten an eine Vorlage übergeben, um sie dem Benutzer anzuzeigen) oder Daten über eine API an das Frontend liefern können.

Django verfügt über Ladedaten, Fixtures und Dump-Daten sowie eine Admin-Seite (Sie können Ihr Modell registrieren und Daten einfügen) und eine Shell (zur direkten Bearbeitung der Datenbank mithilfe von SQL oder ORM). Das Laden von Daten über Fixtures scheint jedoch besser zu sein, wenn große Datenmengen zusammengeführt werden sollen oder dies mehrmals erfolgen soll (häufig ein Anwendungsfall während der Entwicklung und beim Testen).

Beginnen wir mit der Erläuterung dieser Tools und tauchen Sie dann in das Python-Skript ein, um die Daten-Dump-Aufgabe zu erfüllen.

Daten laden

$django-admin loaddata 

Vorrichtungen

Ein Fixture ist eine Sammlung von Dateien, die den serialisierten Inhalt der Datenbank enthalten. Jedes Gerät hat einen eindeutigen Namen und die Dateien, aus denen das Gerät besteht, können über mehrere Verzeichnisse in mehreren Anwendungen verteilt werden. [Quelle]

Lassen Sie uns zum nächsten Teil des Artikels springen und einen Blick auf die Bücher Spielpläne werfen.

[
  {
    "model": "book.book",
    "pk": 40,
    "fields": {
      "title": "Example Book 1",
      "author": "John Doe",
      "isbn": "123456734890123",
      "pages": 350,
      "language": "English"
    }
  },
  {
    "model": "book.book",
    "pk": 41,
    "fields": {
      "title": "Example Book 2",
      "author": "Kumar Ajit",
      "isbn": "9876543455210987",
      "pages": 280,
      "language": "Hindi"
    }
  }
]

Wenn Sie sich die Fixture-Datei angesehen haben, müssen Sie festgestellt haben, dass es sich nur um eine weitere JSON-Datei mit mehr Schlüssel-Wert-Paaren handelt und dass es sich hierbei um Metadaten für Django-Modelle/-Tabellen handelt. Also ja, Sie haben Recht und unser Ziel ist es, unser Books.json-Format in das Fixture-Format zu konvertieren, damit das Django-Administratortool es erkennt und Daten in geeigneten Tabellen ablegt.

Nun können Sie beim Erstellen einer Vorrichtung zwei Situationen haben: 1) Sie haben Daten in Modellen und möchten eine Vorrichtung für zukünftige Verwendung oder Tests usw. erstellen.
2) Sie haben keine Daten in Modellen/Tabellen, aber Sie haben Daten in externen Quellen wie JSON, CSV oder anderen Formaten und möchten diese Daten in Django über den zuvor besprochenen Befehl loaddata laden.( Dies In diesem Artikel geht es um diese Situation, aber gegen Ende werden wir dumpdata verwenden, um die manuelle Ausgabe mit der dumpdata-Ausgabe zu vergleichen.)

Bevor Sie zum Python-Skript gehen, um die normale JSON-Datei in das Fixture-Format zu konvertieren, machen Sie sich klar, wie Django nach der Fixture-Datei sucht und wie sie diese verwendet.

Es gibt drei Punkte von Interesse und Reihenfolge [Quelle]:

1. Im Fixtures-Verzeichnis jeder installierten Anwendung: Dies ähnelt der Empfehlung für andere Verzeichnisse wie Vorlagen oder Medien oder statische Ordner, die in einem Django-Projekt organisiert sind. Sie können jedoch auch einen direkten Pfad angeben, wie unten beschrieben.

2. In jedem Verzeichnis, das in der FIXTURE_DIRS-Einstellung aufgeführt ist

3. Im wörtlichen Pfad, der durch das Gerät benannt wird: Funktioniert mit kleineren Projekten oder Apps, aber es ist besser, einen geeigneten empfohlenen Speicherort für Geräte zu haben, damit es beim Testen oder Debuggen usw. einfach verwendet werden kann.

Hinweis: Ein großer Vorteil der Verwendung von Fixtures besteht darin, Komprimierung auf Fixtures anzuwenden und zu verwenden.

Dumpdaten

Dies ist der Django-Admin-Befehl zur Ausgabe aller Daten der Tabelle in die Standardausgabe.

Hinweis 1: Gibt alle Daten in der Datenbank, die mit der/den benannten Anwendung(en) verknüpft sind, in die Standardausgabe aus.
Hinweis 2: Die Ausgabe von Dumpdata kann als Eingabe für Loaddata verwendet werden. (als Fixture)

django-admin dumpdata [app_label[.ModelName] 

Sie können mehr über diesen Link lesen.

Python-Skript von einfachem JSON bis zu Django Fixtures.

from django.apps import apps
import django
import os
import json


# Set the Django settings module
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'dataloading.settings')
django.setup()

# get all models
models = apps.get_models()

# Get the model names
for model in models:
    print(model)
    print(model.__name__)

# Choose Model to create fixtures
from book.models import Book 

# Get all field names
field_names = [field.name for field in Book._meta.get_fields()]
fixture_name = "books.json"

#read the data file json, csv etc.

with open('data.json','r') as fp:
    books= json.load(fp)


books_fixture =[]
# get the pk value from model , if there is data
pk=1 
# iterate all the books in json file
for book in books:
    book_fixture={}
    # Add model name (most important for fixture)
    book_fixture['model']= 'book.book'
    pk =1
    book_fixture['pk']=pk
    # assuming the data has same fields name as model else mapping is required
    book_fixture['fields']=book
    books_fixture.append(book_fixture)
# Writing converted Json as file for fixture

with open(fixture_name,'w') as fp:
    json.dump(books_fixture,fp)

# print(field_names)
# if __name__ =='__main__' :
    #create_book()  

Sobald Ihr Gerät als „books.json“ erstellt wurde. Es ist an der Zeit, es an einen geeigneten Ort zu verschieben/kopieren (Buch/Fixtures/Buch/), damit der Django-Manager es leicht finden und dann den Befehl „loaddata“ ausführen kann, um alle Daten in das Buchmodell zu übertragen.

$mv books.json book/fixtures/book/
$python manage.py loaddata book/fixtures/book/books.json

Sie können ein ähnliches Skript auch verwenden, um Daten direkt in die Methode sing .save() des Modells zu schreiben. Nachfolgend finden Sie die Methode create_book(), mit der Sie einen oder mehrere (Schleifen-)Datensätze in das Buchmodell einfügen können.

# def create_book():
#     book = Book(
#         title="This is from script",
#         author ="ajit",
#         isbn = "2024-0809",
#         pages=300,
#         language ='English'
#     )
#     book.save()
#     print(f'Book {book.title} by {book.author} created.')

Sie können für ähnliche Aufgaben auch in Dumpscript von Django-Erweiterungen nachsehen.

Ich hoffe, es wird hilfreich sein.

Hinweis: Der Artikel wurde aus Zeitgründen nicht ordnungsgemäß Korrektur gelesen und formatiert. Gehen Sie also bitte vorsichtig damit um und hinterlassen Sie unten einen Kommentar zu etwaigen Fehlern, Zweifeln oder Fragen. Ich werde den Artikel im Laufe der Zeit beantworten und bearbeiten.