青少年编程与数学 02-009 Django 5 Web 编程 08课题、数据库操作

课题摘要: 本文详细介绍了Django中数据库操作的方法和技巧。首先，讲解了通过Django模型进行数据操作的基本方法，包括创建、查询、更新和删除记录，以及聚合与注解操作。接着，分别深入探讨了创建记录、查询记录、更新记录和删除记录的具体步骤和高级技巧，如使用Q对象构建复杂查询条件、F表达式进行字段间更新等。此外，还介绍了如何进行动态操作，例如使用getattr()、setattr()函数动态获取和设置字段值，以及字典解包实现动态查询和更新。最后，通过一个完整的示例，展示了如何对Book模型进行创建、查询、更新和删除操作，以及动态操作记录的方法。文章强调了在进行数据库操作时需要注意的事项，如确保字段值符合模型定义、考虑业务逻辑和数据完整性、验证和清理用户输入等，以确保操作的安全性和准确性。

一、数据操作

在Django中，模型（Model）是与数据库表对应的一个Python类，用于定义数据的结构和行为。通过模型，你可以方便地对数据库表中的记录进行各种操作，如创建、查询、更新和删除等。以下是通过Django模型对表中记录进行操作的基本方法：

1. 创建记录

要创建一条新的记录，首先需要实例化模型类并设置相应的字段值，然后调用save()方法将其保存到数据库中。

from myapp.models import MyModel

# 创建一个新的记录
obj = MyModel(field1='value1', field2='value2')
obj.save()

或者使用create()方法直接创建并保存记录：

MyModel.objects.create(field1='value1', field2='value2')

2. 查询记录

Django提供了强大的查询API，可以通过objects属性进行查询操作。

• 获取所有记录：

  all_records = MyModel.objects.all()
  

• 过滤记录：

  filtered_records = MyModel.objects.filter(field1='value1')
  

• 获取单个记录：

  try:
      single_record = MyModel.objects.get(id=1)
  except MyModel.DoesNotExist:
      print("记录不存在")
  

• 排序记录：

  sorted_records = MyModel.objects.order_by('field1')
  

3. 更新记录

要更新记录，可以先获取记录，修改字段值，然后调用save()方法保存更改。

obj = MyModel.objects.get(id=1)
obj.field1 = 'new_value'
obj.save()

或者使用update()方法批量更新记录：

MyModel.objects.filter(field1='value1').update(field1='new_value')

4. 删除记录

删除记录可以通过调用delete()方法实现。

obj = MyModel.objects.get(id=1)
obj.delete()

或者批量删除：

MyModel.objects.filter(field1='value1').delete()

5. 聚合与注解

Django还支持聚合和注解操作，用于对查询结果进行统计和计算。

• 聚合：

  from django.db.models import Count
  result = MyModel.objects.aggregate(count=Count('id'))
  print(result['count'])  # 输出记录数
  

• 注解：

  from django.db.models import Count
  annotated_records = MyModel.objects.annotate(num_related=Count('related_field'))
  

这些是Django模型操作数据库记录的基本方法。通过这些方法，你可以灵活地对数据库进行各种操作，满足不同的业务需求。

二、创建记录

在Django中创建记录通常涉及以下几个步骤：定义模型、迁移模型到数据库、以及使用模型来创建记录。下面将详细说明这些步骤：

1. 定义模型

首先，在Django应用的models.py文件中定义一个模型类。模型类继承自django.db.models.Model，并定义了数据库表的字段。

from django.db import models

class MyModel(models.Model):
    field1 = models.CharField(max_length=100)
    field2 = models.IntegerField()
    created_at = models.DateTimeField(auto_now_add=True)

在这个例子中，MyModel模型有三个字段：field1是一个字符字段，field2是一个整数字段，created_at是一个日期时间字段，且在记录创建时自动设置为当前时间.

2. 迁移模型到数据库

定义好模型后，需要将模型迁移到数据库中，以便创建对应的表结构。这通常通过以下命令完成：

• 生成迁移文件：

  python manage.py makemigrations
  

  这个命令会检查你的模型定义，并为需要进行的数据库表结构变更创建迁移文件。

• 应用迁移：

  python manage.py migrate
  

  这个命令会应用迁移文件，实际在数据库中创建或修改表结构。

3. 使用模型创建记录

一旦模型被迁移到数据库，就可以使用Django的ORM（对象关系映射）来创建记录了。以下是几种创建记录的方法：

方法一：实例化模型并调用save()

from myapp.models import MyModel

# 创建一个新的模型实例
obj = MyModel(field1='value1', field2=123)
# 保存到数据库
obj.save()

方法二：使用create()方法

from myapp.models import MyModel

# 直接创建并保存记录
obj = MyModel.objects.create(field1='value1', field2=123)

create()方法是Manager类的一个便捷方法，它会自动调用save()方法将新创建的对象保存到数据库中，并返回新创建的对象实例。

方法三：使用bulk_create()批量创建

如果你需要一次性创建多条记录，可以使用bulk_create()方法。这个方法可以减少数据库交互次数，提高效率。

from myapp.models import MyModel

# 准备要创建的记录列表
objects_to_create = [
    MyModel(field1='value1', field2=123),
    MyModel(field1='value2', field2=456),
    MyModel(field1='value3', field2=789),
]

# 批量创建记录
MyModel.objects.bulk_create(objects_to_create)

使用bulk_create()时需要注意，它不会返回创建的对象列表，也不会触发模型的save()方法或信号（signals）等，因此在某些情况下可能不适用。

注意事项

• 在创建记录时，确保提供的字段值符合模型中定义的字段类型和约束条件，否则可能会引发错误。
• 如果模型中定义了外键字段，创建记录时需要提供有效的外键关联对象或其主键值.
• 在实际应用中，创建记录的操作通常会在视图（View）或表单处理逻辑中进行，以便根据用户输入或其他业务逻辑来动态创建数据.

通过以上步骤和方法，你可以在Django中灵活地创建数据库记录，满足应用的数据存储需求。

三、查询记录

在Django中，查询记录是通过模型的objects管理器来实现的。objects是一个Manager实例，它提供了多种方法来查询数据库中的记录。以下是查询记录的一些常用方法和技巧：

基本查询方法

获取所有记录

使用all()方法可以获取模型对应表中的所有记录：

from myapp.models import MyModel

all_records = MyModel.objects.all()

过滤记录

使用filter()方法可以根据条件过滤记录：

filtered_records = MyModel.objects.filter(field1='value1')

filter()方法接受关键字参数，参数名对应模型的字段名，参数值是过滤条件。它返回一个QuerySet对象，包含所有符合条件的记录。

获取单个记录

使用get()方法可以获取单个记录：

try:
    single_record = MyModel.objects.get(id=1)
except MyModel.DoesNotExist:
    print("记录不存在")

get()方法也接受关键字参数，但与filter()不同，它返回单个对象实例。如果符合条件的记录不存在，会抛出DoesNotExist异常；如果存在多条符合条件的记录，会抛出MultipleObjectsReturned异常。

高级查询技巧

排序记录

使用order_by()方法可以对查询结果进行排序：

sorted_records = MyModel.objects.order_by('field1')

order_by()方法接受字段名作为参数，字段名前可以加上-符号表示降序排序。例如，order_by('-field1')表示按field1字段降序排序。

限制查询结果数量

使用limit()和offset()方法可以限制查询结果的数量和起始位置：

limited_records = MyModel.objects.all()[:10]  # 获取前10条记录
offset_records = MyModel.objects.all()[10:20]  # 获取第11到第20条记录

在Django中，可以通过切片语法来实现limit()和offset()的效果。

聚合和注解

使用aggregate()和annotate()方法可以对查询结果进行聚合和注解：

from django.db.models import Count, Sum

# 聚合
result = MyModel.objects.aggregate(count=Count('id'), sum_field2=Sum('field2'))
print(result['count'])  # 输出记录数
print(result['sum_field2'])  # 输出field2字段的总和

# 注解
annotated_records = MyModel.objects.annotate(num_related=Count('related_field'))

aggregate()方法用于对整个查询集进行聚合计算，返回一个字典，包含聚合结果；annotate()方法用于对每个记录进行注解计算，返回一个QuerySet对象，每个记录都增加了注解字段。

复杂查询条件

使用Q对象可以构建复杂的查询条件：

from django.db.models import Q

complex_records = MyModel.objects.filter(
    Q(field1='value1') | Q(field2__gt=100)
)

Q对象允许使用位运算符（如|表示或，&表示与）来组合多个查询条件，实现复杂的查询逻辑。

查询优化

选择性加载字段

使用only()和defer()方法可以控制加载的字段：

# 只加载特定字段
partial_records = MyModel.objects.only('field1', 'field2')

# 延迟加载特定字段
deferred_records = MyModel.objects.defer('field3')

only()方法指定只加载指定字段，defer()方法指定延迟加载指定字段，可以减少数据传输量，提高查询效率。

使用索引

在数据库层面为经常查询的字段创建索引，可以显著提高查询性能。在Django中，可以在模型字段定义中使用db_index=True参数来创建索引：

class MyModel(models.Model):
    field1 = models.CharField(max_length=100, db_index=True)

通过以上方法和技巧，你可以在Django中灵活地查询数据库记录，满足各种复杂的查询需求。

四、更新记录

在Django中更新记录可以通过多种方式实现，以下是几种常见的方法：

方法一：获取记录后修改字段并调用save()

首先，通过查询获取要更新的记录，然后修改记录的字段值，最后调用save()方法将更改保存到数据库中。

from myapp.models import MyModel

# 获取要更新的记录
obj = MyModel.objects.get(id=1)

# 修改字段值
obj.field1 = 'new_value1'
obj.field2 = 12345

# 保存更改
obj.save()

这种方法适用于更新单条记录，并且可以对多个字段进行修改。调用save()方法时，Django会生成一个UPDATE SQL语句，将指定字段的值更新到数据库中对应的记录上.

方法二：使用update()方法批量更新

如果你需要更新多条记录，可以使用update()方法。这个方法可以直接在查询集上调用，对查询集中的所有记录进行批量更新。

from myapp.models import MyModel

# 批量更新记录
MyModel.objects.filter(field1='old_value1').update(field1='new_value1', field2=67890)

在这个例子中，所有field1字段值为'old_value1'的记录都会被更新，field1字段值变为'new_value1'，field2字段值变为67890。update()方法不会返回更新后的记录实例，而是返回更新的记录数量.

方法三：使用F表达式进行字段间更新

如果你需要根据记录的其他字段值来更新某个字段，可以使用F表达式。F表达式允许你在更新时引用记录的其他字段。

from django.db.models import F
from myapp.models import MyModel

# 根据字段值进行更新
MyModel.objects.filter(field1='value1').update(field2=F('field3') + 10)

在这个例子中，所有field1字段值为'value1'的记录，其field2字段值会被更新为field3字段值加10。F表达式在数据库层面进行计算，避免了将记录加载到内存中再进行更新，提高了效率.

方法四：使用bulk_update()批量更新记录

如果你已经获取了一组记录实例，并对它们进行了修改，可以使用bulk_update()方法将这些更改批量保存到数据库中。

from myapp.models import MyModel

# 获取要更新的记录列表
objects_to_update = MyModel.objects.filter(field1='value1')

# 修改记录字段值
for obj in objects_to_update:
    obj.field2 = 12345

# 批量更新记录
MyModel.objects.bulk_update(objects_to_update, ['field2'])

在这个例子中，bulk_update()方法接受要更新的记录列表和一个包含要更新字段名的列表作为参数，将这些更改批量保存到数据库中。这种方法可以减少数据库交互次数，提高更新效率.

注意事项

• 在更新记录时，确保提供的字段值符合模型中定义的字段类型和约束条件，否则可能会引发错误.
• 如果更新操作涉及到复杂的业务逻辑或需要进行额外的处理（如发送通知、更新相关数据等），建议在视图或服务层进行相应的逻辑处理，而不是直接在模型层进行更新.
• 在使用update()方法进行批量更新时，要注意它不会触发模型的save()方法或相关的信号（signals），因此不会执行模型中定义的任何保存时的钩子函数或信号处理逻辑.
• 使用bulk_update()方法时，需要注意它不会返回更新后的记录实例，也不会触发模型的save()方法或信号，因此在某些情况下可能不适用.

五、删除记录

在Django中删除记录可以通过几种不同的方法来实现，以下是几种常用的方法：

方法一：获取记录后调用delete()

首先，通过查询获取要删除的记录，然后调用delete()方法将其从数据库中删除。

from myapp.models import MyModel

# 获取要删除的记录
obj = MyModel.objects.get(id=1)

# 删除记录
obj.delete()

这种方法适用于删除单条记录。调用delete()方法时，Django会生成一个DELETE SQL语句，将数据库中对应的记录删除。如果该记录有外键关联的子记录，并且外键的on_delete参数设置为CASCADE，则子记录也会被级联删除.

方法二：使用查询集的delete()方法批量删除

如果你需要删除多条记录，可以使用查询集的delete()方法进行批量删除。

from myapp.models import MyModel

# 批量删除记录
MyModel.objects.filter(field1='value1').delete()

在这个例子中，所有field1字段值为'value1'的记录都会被删除。查询集的delete()方法会生成一个DELETE SQL语句，将查询集中的所有记录从数据库中删除。它返回一个元组，包含删除的记录数量和一个字典，字典中列出了每个模型被删除的记录数量.

方法三：使用QuerySet的in_bulk()方法批量删除

如果你已经获取了一组记录的主键列表，并且想要删除这些记录，可以使用in_bulk()方法获取对应的记录实例，然后调用delete()方法进行删除。

from myapp.models import MyModel

# 获取要删除的记录主键列表
ids_to_delete = [1, 2, 3]

# 获取对应的记录实例
objects_to_delete = MyModel.objects.in_bulk(ids_to_delete)

# 删除记录
for obj in objects_to_delete.values():
    obj.delete()

这种方法适用于当你已经知道要删除的记录的主键时，可以先获取这些记录的实例，然后逐一删除。不过，这种方法不如直接使用查询集的delete()方法高效，因为它需要先查询出记录实例，然后再逐个删除.

注意事项

• 在删除记录之前，确保已经考虑了相关的业务逻辑和数据完整性问题。例如，如果记录与其他数据有依赖关系，删除操作可能会影响这些数据的完整性.
• 如果记录有外键关联的子记录，并且外键的on_delete参数设置为PROTECT，则删除操作会被阻止，以防止数据完整性被破坏.
• 在使用查询集的delete()方法进行批量删除时，要注意它不会触发模型的save()方法或相关的信号（signals），因此不会执行模型中定义的任何删除时的钩子函数或信号处理逻辑.
• 如果你使用的是Django的事务管理功能，删除操作会在事务的上下文中执行。如果在事务执行过程中发生错误，可以回滚事务以撤销删除操作.

六、动态操作

在Django中，如果字段名存放在一个变量中，你可以使用Python的字典解包或getattr()、setattr()等函数来动态地对记录的字段进行操作。以下是几种常用的方法：

动态获取字段值

使用getattr()函数可以根据字段名变量动态地获取记录的字段值。

from myapp.models import MyModel

# 获取要操作的记录
obj = MyModel.objects.get(id=1)

# 字段名存放在变量中
field_name = 'field1'

# 动态获取字段值
field_value = getattr(obj, field_name)
print(field_value)

在这个例子中，field_name变量存储了要获取的字段名，通过getattr(obj, field_name)可以动态地获取obj对象中对应字段的值.

动态设置字段值

使用setattr()函数可以根据字段名变量动态地设置记录的字段值。

from myapp.models import MyModel

# 获取要操作的记录
obj = MyModel.objects.get(id=1)

# 字段名存放在变量中
field_name = 'field1'

# 动态设置字段值
new_value = 'new_value1'
setattr(obj, field_name, new_value)

# 保存更改
obj.save()

在这个例子中，field_name变量存储了要设置的字段名，通过setattr(obj, field_name, new_value)可以动态地设置obj对象中对应字段的值，然后调用save()方法将更改保存到数据库中.

动态查询和过滤

在进行查询和过滤时，可以使用字典解包的方式将字段名变量传递给查询方法。

from myapp.models import MyModel

# 字段名存放在变量中
field_name = 'field1'
field_value = 'value1'

# 动态查询
query_kwargs = {field_name: field_value}
objects = MyModel.objects.filter(**query_kwargs)

在这个例子中，field_name变量存储了要查询的字段名，field_value是对应的查询值。通过构建一个查询字典query_kwargs，然后使用**query_kwargs进行字典解包，可以将字段名和值动态地传递给filter()方法进行查询.

动态更新记录

在更新记录时，也可以使用字典解包的方式将字段名变量传递给更新方法。

from myapp.models import MyModel

# 字段名存放在变量中
field_name = 'field1'
new_value = 'new_value1'

# 动态更新记录
update_kwargs = {field_name: new_value}
MyModel.objects.filter(id=1).update(**update_kwargs)

在这个例子中，field_name变量存储了要更新的字段名，new_value是新的字段值。通过构建一个更新字典update_kwargs，然后使用**update_kwargs进行字典解包，可以将字段名和值动态地传递给update()方法进行更新.

注意事项

• 在使用动态字段名进行操作时，要确保字段名是模型中存在的有效字段，否则可能会引发AttributeError或FieldError等错误.
• 如果字段名来自不可信的用户输入，需要进行适当的验证和清理，以防止潜在的安全问题，如SQL注入等.
• 在进行动态查询和更新时，要注意查询条件和更新字段的正确性，以避免错误地修改或删除数据.

通过以上方法，你可以在Django中灵活地对记录进行动态操作，满足一些需要根据字段名变量进行处理的场景需求.

七、练习

以下是一个使用Django对记录进行各种操作的完整示例，包括创建、查询、更新和删除操作。假设我们有一个名为Book的模型，它包含一些基本的书籍信息字段：

# myapp/models.py
from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.CharField(max_length=100)
    publication_year = models.IntegerField()
    is_available = models.BooleanField(default=True)

    def __str__(self):
        return self.title

创建记录

# 创建一条新的书籍记录
new_book = Book.objects.create(
    title='Django for Beginners',
    author='William S. Vincent',
    publication_year=2018,
    is_available=True
)
print(f"Created book: {new_book}")

查询记录

# 获取所有书籍记录
all_books = Book.objects.all()
print("All books:")
for book in all_books:
    print(book)

# 根据条件过滤书籍记录
available_books = Book.objects.filter(is_available=True)
print("Available books:")
for book in available_books:
    print(book)

# 获取单个书籍记录
try:
    book = Book.objects.get(id=1)
    print(f"Book with ID 1: {book}")
except Book.DoesNotExist:
    print("Book with ID 1 does not exist.")

更新记录

# 获取要更新的书籍记录
book_to_update = Book.objects.get(id=1)

# 更新字段值
book_to_update.title = 'Django for Beginners (Updated)'
book_to_update.save()
print(f"Updated book: {book_to_update}")

# 批量更新书籍记录
Book.objects.filter(publication_year__lt=2020).update(is_available=False)
print("Updated availability for books published before 2020.")

删除记录

# 获取要删除的书籍记录
book_to_delete = Book.objects.get(id=1)

# 删除记录
book_to_delete.delete()
print(f"Deleted book with ID 1.")

# 批量删除书籍记录
Book.objects.filter(is_available=False).delete()
print("Deleted unavailable books.")

动态操作记录

# 动态字段名
field_name = 'author'
new_author = 'Jane Doe'

# 动态获取字段值
book = Book.objects.get(id=2)
author_value = getattr(book, field_name)
print(f"Original {field_name}: {author_value}")

# 动态设置字段值
setattr(book, field_name, new_author)
book.save()
print(f"Updated {field_name}: {getattr(book, field_name)}")

# 动态查询
query_kwargs = {field_name: new_author}
books_by_author = Book.objects.filter(**query_kwargs)
print(f"Books by {new_author}:")
for book in books_by_author:
    print(book)

注意事项

• 在实际应用中，这些操作通常会在Django的视图（View）或表单处理逻辑中进行，以便根据用户输入或其他业务逻辑来动态创建、查询、更新和删除数据.
• 在进行更新和删除操作时，要确保已经考虑了相关的业务逻辑和数据完整性问题，以防止意外地修改或删除重要数据.
• 对于批量操作（如批量更新和删除），要注意它们不会触发模型的save()方法或相关的信号（signals），因此不会执行模型中定义的任何保存或删除时的钩子函数或信号处理逻辑.
• 在处理用户输入或动态字段名时，要进行适当的验证和清理，以防止潜在的安全问题，如SQL注入等.