JSON-Daten an Django-Modelle ausgeben: Django-Setup und -Befehle verwenden

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, die jedoch kaum mehr Verständnis des Frameworks erfordern.

Heute werde ich diese Lernkurve durchlaufen und diskutieren, wie Sie Ihre normalen JSON-Daten in eine Vorrichtung konvertieren und dann loaddata verwenden, um JSON-Daten in ein bestimmtes Modell zu ü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 in models.py befindet sich ein Buchmodell, dann sind auch die API-Endpunkte 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 zum Modell

Angesichts der zwei Repositories können Sie von hier aus jedes beliebige zum Verfolgen von Artikeln verwenden. 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 die Vorlage übergeben, um sie dem Benutzer anzuzeigen) oder Daten über die 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 Sie große Datenmengen zusammenführen möchten oder dies mehrmals tun möchten (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 <fixture label>

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ücherSpielplä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 dabei 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-Administrationstool 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 über den zuvor besprochenen Befehl loaddata in Django 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 eine normale JSON-Datei in das Fixture-Format zu konvertieren, machen Sie sich klar, wie Django nach Fixture-Dateien sucht und wie sie diese verwenden.

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. In the literal path named by the fixture: Works with smaller project or app but it is better to have a proper recommended location for fixtures so it will easy to use with testing or debugging etc.

Note:One major benefit of using fixture is to apply and use compression on fixtures.

Dumpdata

This is django-admin command to output all data of table to standard output.

Note 1: Outputs to standard output all data in the database associated with the named application(s).
Note 2 : The output of dumpdata can be used as input for loaddata.(as fixture )

django-admin dumpdata [app_label[.ModelName] 

you can read more from this link.

Python script from simple json to 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()  

Once your fixture is created as books.json. It time to move it /copy to suitable location (book/fixtures/book/) so that Django manager can find it easily and then run loaddata command to dump all data to Book model.

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

You can also use similar script to directly write data to model sing .save() method. Below is create_book() method that can be use to insert one or more (looping) data records into Book model.

# 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.')

You can also look into Dumpscript from Django-extensions for similar task.

I hope it will be helpful.

Note: The article in not properly proofread and formatted because of time constraint. So, please use it carefully and leave comments below for any errors, dobuts or questions. I will reply and edit the article overtime.

Das obige ist der detaillierte Inhalt vonJSON-Daten an Django-Modelle ausgeben: Django-Setup und -Befehle verwenden. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!