Fundamentos de Django

1

¿Qué es Django?

2

¿Cómo instalar Django?

3

Entendiendo la arquitectura de Django

4

Qué es el patrón MVT (Model, View y Template)

La M en el Patrón: Modelo

5

Introducción a Modelos y Bases de Datos

Manejo Avanzado de Modelos y Bases de Datos

6

Gestión de Modelos y Bases de Datos en Django con SQLite

7

Inserción de Datos con Django

8

Actualización y Eliminación de Datos en Django

Relaciones y Asociaciones entre Modelos

9

Creación y Gestión de Relaciones entre Modelos en Django

10

Relaciones Muchos a Muchos (N:N) en Django

11

Relaciones Uno a Uno (1:1) en Django

12

Queries y Filtros en Django: Optimización y Estrategias Avanzadas

Configuración de URLs y Vistas Avanzadas

13

Gestión de URLs en Django: Configuración, Rutas y Mejores Prácticas

14

Vistas Basadas en Clases en Django

La T en el Patrón: Plantillas o Templates

15

Personalización de Interfaz con Plantillas en Django

Desarrollo de Aplicaciones en Django

16

Configuración del Proyectos en Django

17

Creación del Modelo para la Aplicación 'Products' en Django

18

Cómo Crear Migraciones de Datos en Django

19

Creación de la Aplicación 'Products' con Formularios en Django

20

Integracion de TailwindCSS en Django

21

Django Admin

22

Manejo de Sesiones en Django

23

Manejo de Órdenes en CoffeShop

24

Manejo de Pedidos en CoffeShop

25

Mixings en vistas basadas en clases

26

Agregar productos a la orden

Django Rest Framework

27

Django REST Framework

Despliegue de aplicaciones Django

28

Configurar PostgreSQL en AWS con Django

29

Variables de entorno en Django

30

¿Cómo usar Unit Testing en Django?

31

Debugging en Django

32

Desplegar aplicaciones de Django en AWS

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Curso de Django

Curso de Django

Luis Martínez

Luis Martínez

Inserción de Datos con Django

7/32
Recursos

¿Cómo se agrega un nuevo campo a una tabla en Django?

Para agregar un nuevo campo a una tabla existente, necesitas modificar la clase del modelo correspondiente. Por ejemplo, si deseas añadir el campo “año” a la clase Carro, lo haces así:

  • Añade el campo como un TextField con un MaxLength de 4, ya que solo necesitas almacenar valores como 2022, 2023, etc.
class Carro(models.Model):
    ...
    año = models.TextField(max_length=4, null=True)

¿Qué pasos se siguen después de modificar el modelo?

Después de agregar el nuevo campo al modelo, sigue estos pasos:

  1. Guardar los cambios en el archivo del modelo: No olvides guardar el archivo después de realizar modificaciones.
  2. Crear nuevas migraciones: Ejecuta el comando python manage.py makemigrations. Si no detecta cambios, verifica si guardaste el archivo.
  3. Aplicar las migraciones: Ejecuta python manage.py migrate. Este comando actualiza la base de datos con la nueva estructura.

¿Cómo se soluciona el error de campo no nulo?

Si intentas crear un campo no nulo en una tabla que ya contiene datos, Django te pedirá resolver cómo manejar los registros existentes. Puedes:

  • Proveer un valor por defecto.
  • Permitir valores nulos.

En este ejemplo, se permite que el campo “año” sea nulo (null=True), para evitar problemas con registros anteriores.

¿Cómo se utiliza el ORM de Django para interactuar con los datos?

Una vez aplicado el nuevo campo, puedes usar el ORM de Django para interactuar con la base de datos. Usamos el comando python manage.py shell para acceder al shell interactivo de Django.

Ejemplo de cómo crear un nuevo registro:

  1. Importar el modelo:
from my_first_app.models import Carro
  1. Crear una instancia de Carro:
nuevo_carro = Carro(titulo='BMW', año='2023')
  1. Guardar la instancia en la base de datos:
nuevo_carro.save()

¿Cómo mejorar la visualización de los objetos en el shell?

Define el método __str__ en tu modelo para que la representación textual del objeto sea más clara:

class Carro(models.Model):
    ...
    def __str__(self):
        return f"{self.titulo} - {self.año}"

¿Cómo agregar un nuevo atributo y practicar?

Añadir un nuevo atributo, como el color del carro, sigue los mismos pasos:

  1. Modifica la clase del modelo para incluir el nuevo campo.
  2. Guarda el archivo.
  3. Ejecuta los comandos makemigrations y migrate.
  4. Utiliza el shell para crear y guardar nuevos registros con el atributo color.

Aportes 11

Preguntas 3

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Me parece muy curioso lo siguiente: * En Ruby on Rails el flujo es crear las migraciones y luego en base a ellas se modifican las tablas. (Los modelos de primeras no tienen una descripción de qué atributos tienen). Algo similar pasa en Laravel. * Aquí con Django, modificas los modelos y en base a estas modificaciones se crean las migraciones. Es decir: * **Django:** Modelos primero, migraciones después. * **Rails:** Migraciones primero, modelos después. Pero de manera transversal, en ambos se puede hacer el mismo flujo...
**Para salir de la Shell de Python en Windows** Presiona `Ctrl + Z` y luego `Enter`
El método mágico `.__str__()` nos ayudará a mostrar una descripción del objeto y será llamado al momento de hacer uso de la función `str()`, como sucede en el caso de la función `print()` que internamente hace uso de esta; sin embargo, se espera que la información mostrada sea resumida para ser mostrada a los usuarios de la aplicación. ```python class Car(models.Model): title = models.TextField(max_length=250) year = models.TextField(max_length=4, null=True) def __str__(self): return f"{self.title} - {self.year}" ```class Car(models.Model): title = models.TextField(max\_length=250) year = models.TextField(max\_length=4, null=True) def \_\_str\_\_(self): return f"{self.title} - {self.year}" El método mágico `.__repr__()` mantiene una utilidad similar (siempre y cuando el método mágico `.__str__()` no haya sido definido); sin embargo, se espera que la información representada permita a los programadores, que realizan los mantenimientos a la aplicación, entender mejor cómo se crea dicho objeto. ```python class Car(models.Model): title = models.TextField(max_length=250) year = models.TextField(max_length=4, null=True) def __repr__(self): return f"Car(title='{self.title}', year='{self.year}')" ```class Car(models.Model): title = models.TextField(max\_length=250) year = models.TextField(max\_length=4, null=True) def \_\_repr\_\_(self): return f"Car(title='{self.title}', year='{self.year}')"
Aquí les comparto algunos query's que pueden ser interesantes para revisar en el futuro! <https://docs.djangoproject.com/en/5.1/topics/db/queries/>
**Salir del** `dbshell: .quit` **Salir del** `shell: exit()`
![](https://static.platzi.com/media/user_upload/imagen-3e3beac1-8316-4895-b0ef-15c535a08142.jpg) ![](https://static.platzi.com/media/user_upload/imagen-42a23701-dbb4-40f5-a210-03e8b05e862f.jpg)
Este es el código con el Color: ```python from django.db import models # Create your models here. class Car(models.Model): title = models.TextField(max_length=250) year = models.TextField(max_length=4, null=True) color = models.TextField(max_length=50, null=True) def __str__(self): return f"{self.title} - {self.year} - {self.color}" ```
yo no enseñaria este metodo personalmente, de hacer las cosas por codigo me parece muy escuelero y no funcinal ...con el mayor de los respetos
```js from django.db import models # Create your models here. class Car(models.Model): title = models.TextField(max_length=250) model =models.TextField(max_length=250, null = True) year = models.TextField(max_length=4, null = True) color = models.TextField(max_length=50, null = True) def __str__(self): return f"{self.title} - {self.model} - {self.year} - {self.color}" ``````js >>> from my_first_app.models import Car >>> my_car=Car(title="Mazda",model="Mazda 2",year="2024",color="Red") >>> print(my_car) Mazda - 2024 >>> print(my_car) Mazda - 2024 >>> my_car.save() >>> my_car=Car(title="Toyota",model="Corolla",year="2020",color="Blue") >>> print(my_car) Toyota - 2020 >>> my_car.save() >>> my_car=Car(title="Kia",model="Picanto",year="2013",color="Green") >>> my_car.save() >>> print(my_car) Kia - 2013 >>> my_car=Car(title="Chevrolet",model="Spart",year="2011",color="Gray") >>> print(my_car) Chevrolet - 2011 ```>>> from my\_first\_app.models import Car \>>> my\_car=Car(title="Mazda",model="Mazda 2",year="2024",color="Red") \>>> print(my\_car) Mazda - 2024 \>>> print(my\_car) Mazda - 2024 \>>> my\_car.save() \>>> my\_car=Car(title="Toyota",model="Corolla",year="2020",color="Blue") \>>> print(my\_car) Toyota - 2020 \>>> my\_car.save() \>>> my\_car=Car(title="Kia",model="Picanto",year="2013",color="Green") \>>> my\_car.save() \>>> print(my\_car) Kia - 2013 \>>> my\_car=Car(title="Chevrolet",model="Spart",year="2011",color="Gray") \>>> print(my\_car) Chevrolet - 2011
operations = \[        migrations.AddField(            model\_name='car',            name='year',            field=models.TextField(max\_length=4, null=True),        ),    ]
Todavía no pude salir de sqlite en la consola, pequeño detalle que no se explica