"Se um trabalhador quiser fazer bem o seu trabalho, ele deve primeiro afiar suas ferramentas." - Confúcio, "Os Analectos de Confúcio. Lu Linggong"
Ferramentas on-line
Tutorial de software
Navegação no site
Programação
Primeira página > Programação > Despejando dados JSON para modelos Django: usando configuração e comandos do Django

Despejando dados JSON para modelos Django: usando configuração e comandos do Django

Publicado em 2024-09-02
Navegar:352

Dumping JSON data to Django Models: Using Django Setup and Commands

A necessidade de dados se torna mais importante quando você completa sua primeira versão do site usando Django ou API REST usando Django Rest Framework (DRF). Para um problema semelhante, escrevi meu artigo anterior, no qual discuti uma abordagem direta de despejo de dados JSON no modelo Django, inserindo-os diretamente no banco de dados e tabelas SQLite. No entanto, também mencionei que o Django possui loaddata, dumpdata e fixtures para problemas semelhantes, mas que precisam de um pouco mais de compreensão do framework.

Hoje, vou percorrer essa curva de aprendizado e discutir como converter seus dados JSON normais em um acessório e, em seguida, usar loaddata para despejar dados JSON em um modelo específico. Da mesma forma, se você tiver alguns dados para modelos (podem ser adicionados através da página de administração, etc.), então como despejá-los como acessórios para usar com outro modelo ou em outro projeto.

O artigo anterior tem duas partes: a primeira parte é a configuração normal necessária para o despejo de dados e a segunda parte é sobre o script python para despejar dados JSON no modelo. Portanto, seja breve no artigo. Neste artigo, começarei pela segunda parte e você pode seguir a Parte I do artigo anterior para seguir este artigo. Então, supondo que você tenha um aplicativo de livro e no qual exista o modelo Book dentro de models.py, da mesma forma os endpoints da API estão prontos, como (repositório Github da postagem anterior) :

http://127.0.0.1:8000/api/books/1

ou você simplesmente deseja carregar dados no modelo Book para um site baseado em Django. Você pode seguir o código do seguinte repositório git.

Despejo de dados JSON para modelo

Dados dois repositórios, você pode usar qualquer um para seguir o artigo daqui, você só precisa do seguinte:

    Um projeto Django funcional com um modelo Book com ou sem recursos de API
    2. Um arquivo json com informações do livro de acordo com o modelo Book.
Exemplo 1: O modelo de livro em book/models.py


de modelos de importação do django.db livro de classe (models.Model): título = modelos.CharField(max_length=200) autor = modelos.CharField(max_length=100) isbn = modelos.CharField(max_length=13, único=True) páginas = modelos.PositiveIntegerField() idioma = modelos.CharField(max_length=30) def __str__(auto): retornar self.title 
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
livros.json


[ { "title": "Exemplo de Livro 1", "autor": "John Doe", "isbn": "1234567890123", "páginas": 350, "idioma": "Inglês" }, { "title": "Exemplo de Livro 2", "autor": "Kumar Ajit", "isbn": "9876543210987", "páginas": 280, "idioma": "hindi" } ] 
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
Exemplo 2: O modelo de livro do artigo anterior


de modelos de importação do django.db livro de classe (models.Model): título = modelos.CharField(max_length=200) autor = modelos.CharField(max_length=100) preço = modelos.DecimalField(max_digits=6, decimal_places=2) def __str__(auto): retornar self.title 
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
Você pode encontrar o arquivo data.json aqui.

Despejo de dados para modelar

Temos um projeto Django em funcionamento com um modelo

Book e um arquivo JSON extra com informações de livros. Então, agora qual é o problema? Queremos despejar os dados JSON no modelo para que possam ser usados ​​com o site Django (por exemplo, passando dados para o modelo para exibição ao usuário) ou servindo dados via API para o frontend.

Django possui loaddata, fixtures e dumpdata, ao lado da página de administração (você pode registrar seu modelo e inserir dados) e shell (para manipular diretamente o banco de dados usando SQL ou ORM). No entanto, carregar dados por meio de fixtures parece melhor se você quiser mesclar grandes dados ou quiser fazer isso muitas vezes (geralmente um caso de uso durante o desenvolvimento e teste).

Vamos começar explicando essas ferramentas e depois nos aprofundaremos no script python para realizar a tarefa de despejo de dados.

Carregar dados

$django-admin loaddata 
$django-admin loaddata
Jogos

Um fixture é uma coleção de arquivos que contém o conteúdo serializado do banco de dados. Cada aparelho possui um nome exclusivo e os arquivos que o compõem podem ser distribuídos em vários diretórios, em vários aplicativos. [fonte]

Vamos pular para a parte futura do artigo e dar uma olhada nas luminárias dos

livros.

[ { "modelo": "livro.livro", "pk": 40, "campos": { "title": "Exemplo de Livro 1", "autor": "John Doe", "isbn": "123456734890123", "páginas": 350, "idioma": "Inglês" } }, { "modelo": "livro.livro", "pk": 41, "campos": { "title": "Exemplo de Livro 2", "autor": "Kumar Ajit", "isbn": "9876543455210987", "páginas": 280, "idioma": "hindi" } } ] 
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
Se você deu uma olhada no arquivo fixture, você deve ter descoberto que é apenas outro arquivo JSON com mais pares de valores-chave e esses são metadados para modelos/tabelas do Django. Então, sim, você está certo e nosso objetivo é converter nosso formato books.json para o formato fixture para que a ferramenta de administração do Django o reconheça e despeje os dados em tabelas adequadas.

Agora, para criar um fixture você pode ter duas situações: 1) você tem dados em modelos e deseja criar um fixture para uso ou teste futuro etc.

2) Você não possui dados em modelos/tabelas, mas possui dados em fontes externas como json, csv ou qualquer outro formato e deseja carregar esses dados no Django por meio do comando discutido anteriormente
loaddata .( Isto O artigo é sobre esta situação, mas no final, usaremos dumpdata para comparar a saída manual e dumpdata.)

Antes de ir para o script python para converter o arquivo json normal para o formato de fixture, vamos entender como o Django procura o arquivo de fixture e como usá-lo.

Existem três pontos de interesse e ordem [fonte]:

  1. No diretório fixtures de cada aplicativo instalado: Isto é semelhante à recomendação para outro diretório como template ou media ou pasta estática organizada dentro de um projeto Django. No entanto, você também pode fornecer um caminho direto como mencionado abaixo.

  2. Em qualquer diretório listado na configuração FIXTURE_DIRS

  3. No caminho literal nomeado pelo fixture: Funciona com projetos ou aplicativos menores, mas é melhor ter um local recomendado adequado para os fixtures, para que seja fácil de usar com testes ou depuração, etc.

Nota:Um dos principais benefícios do uso de fixtures é aplicar e usar compressão em fixtures.

Dados de despejo

Este é o comando django-admin para enviar todos os dados da tabela para a saída padrão.

Nota 1: envia para a saída padrão todos os dados no banco de dados associados ao(s) aplicativo(s) nomeado(s).

Nota 2: A saída de dumpdata pode ser usada como entrada para loaddata.(como fixture)

django-admin dumpdata [app_label[.ModelName] 
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
você pode ler mais neste link.

Script Python de json simples para Django Fixtures.

de aplicativos de importação do django.apps importar Django importar sistema operacional importar JSON # Defina o módulo de configurações do Django os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'dataloading.settings') Django.setup() #pegue todos os modelos modelos = apps.get_models() # Obtenha os nomes dos modelos para modelo em modelos: imprimir (modelo) imprimir(modelo.__nome__) # Escolha Modelo para criar fixtures de book.models importar livro # Obtém todos os nomes dos campos field_names = [field.name para campo em Book._meta.get_fields()] fixture_name = "books.json" #leia o arquivo de dados json, csv etc. com open('data.json','r') como fp: livros= json.load(fp) livros_fixture =[] # obtém o valor pk do modelo, se houver dados pacote = 1 # itera todos os livros no arquivo json para livro em livros: livro_fixture={} # Adicione o nome do modelo (mais importante para o fixture) livro_fixture['model']= 'livro.livro' pk=1 livro_fixture['pk']=pk # assumindo que os dados tenham o mesmo nome de campo do modelo, caso contrário o mapeamento é necessário livro_fixture['campos']=livro livros_fixture.append(livro_fixture) # Escrevendo Json convertido como arquivo para fixture com open(fixture_name,'w') como fp: json.dump(livros_fixture,fp) # print(nomes_campos) # se __name__ =='__main__' : #create_book() 
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
Depois que seu fixture for criado como books.json. É hora de movê-lo /copy para um local adequado (book/fixtures/book/) para que o gerenciador Django possa encontrá-lo facilmente e então executar o comando loaddata para despejar todos os dados no modelo Book.


$mv books.json book/fixtures/book/ $python manager.py loaddata book/fixtures/book/books.json 
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
Você também pode usar um script semelhante para gravar dados diretamente no método sing .save() do modelo. Abaixo está o método create_book() que pode ser usado para inserir um ou mais registros de dados (loop) no modelo Book.


# def create_book(): # livro = Livro( # title="Isto é do script", # autor ="ajit", # isbn = "2024-0809", # páginas=300, # idioma ='Inglês' #) # livro.save() # print(f'Livro {book.title} de {book.author} criado.') 
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
Você também pode consultar o Dumpscript das extensões do Django para tarefas semelhantes.

Espero que seja útil.

Nota: O artigo não foi revisado e formatado corretamente devido à restrição de tempo. Portanto, use-o com cuidado e deixe comentários abaixo para quaisquer erros, dúvidas ou dúvidas. Responderei e editarei o artigo com o tempo.

Declaração de lançamento Este artigo foi reproduzido em: https://dev.to/ajitkumar/dumping-json-data-to-django-models-using-django-setup-and-commands-1hj2?1 Se houver alguma violação, entre em contato com study_golang @163.com excluir
Tutorial mais recente Mais>
ClassificaçãoMais>
Aprenda japonês Aprender coreano Aprenda chinês Aprender língua estrangeira Jogo Problema comum Periféricos de tecnologia IA Tutorial de software Programação Artigo

Estude chinês

FerramentaMais>
Decodificação de imagem base64
pinyin chinês
Codificação Unicode
Compressão de criptografia de ofuscação JS
Ferramenta de criptografia hexadecimal de URL
Ferramenta de conversão de codificação UTF-8
Ferramentas online de codificação e decodificação Ascii
Ferramenta de criptografia MD5
Ferramenta on-line de criptografia e descriptografia de texto Hash/Hash
Criptografia SHA on-line

Isenção de responsabilidade: Todos os recursos fornecidos são parcialmente provenientes da Internet. Se houver qualquer violação de seus direitos autorais ou outros direitos e interesses, explique os motivos detalhados e forneça prova de direitos autorais ou direitos e interesses e envie-a para o e-mail: [email protected]. Nós cuidaremos disso para você o mais rápido possível.

Copyright© 2022 湘ICP备2022001581号-3