Django:save（）vs update（）更新数据库？

我正在编写一个Django应用程序，我需要一个函数来更新数据库中的一个字段。是否有任何理由使用这些方法中的一种而不是另一种

def save_db_field(name,field,value):
    obj = MyModel.objects.get(name=name)
    obj.field = value
    obj.save()

def update_db_field(name,field,value):
    MyModel.objects.get(name=name).update(field=value)

看起来第二个更好，因为它在一个DB调用中而不是在两个DB调用中完成。有什么原因让抓取然后更新更好吗？

save（）方法可以用来插入新记录和更新现有记录，通常用于保存数据库中单个记录（mysql中的行）的实例

---

update（）不用于插入记录，可用于更新数据库中的多条记录（mysql中的行）。

update仅适用于更新查询集。如果要同时更新多个字段，例如从单个对象实例的dict可以执行以下操作：

obj.__dict__.update(your_dict)
obj.save()

---

请记住，您的字典必须包含正确的映射，其中键必须是您的字段名，值必须是要插入的值。

两者看起来相似，但有一些关键点：

save（）。因此，如果您有一些具有重写的save方法的模型，您必须避免使用update，或者找到另一种方法来执行您在重写的
save（）方法上执行的操作

obj.save（）

如果不小心，可能会有一些副作用。使用

get（…）

检索对象，所有模型字段值都会传递给obj。调用

obj.save（）

时，django将保存当前对象状态以进行记录。因此，如果通过其他进程在

get（）

和

save（）

之间发生一些更改，那么这些更改将丢失。使用

save（update_fields=[…]）

可避免此类问题

在Django版本1.5之前，Django在插入之前执行一个

SELECT

，因此执行查询需要花费2美元。在1.5版中，该方法已被弃用

---

，有一个很好的指南或

save（）

和

update（）

方法以及它们的执行方式。

有几个关键区别

update

用于查询集，因此可以一次更新多个对象

正如所指出的，custom

save（）

方法的触发方式存在差异，但记住

信号和
模型管理器也很重要。我已经建立了一个小的测试应用程序，以显示一些有价值的差异。我使用的是Python2.7.5、Django==1.7.7和SQLite，请注意，在Django的不同版本和不同的数据库引擎上，最终的SQL可能会有所不同

好的，下面是示例代码

models.py
：

from __future__ import print_function
from django.db import models
from django.db.models import signals
from django.db.models.signals import pre_save, post_save
from django.dispatch import receiver

__author__ = 'sobolevn'

class CustomManager(models.Manager):
    def get_queryset(self):
        super_query = super(models.Manager, self).get_queryset()
        print('Manager is called', super_query)
        return super_query


class ExtraObject(models.Model):
    name = models.CharField(max_length=30)

    def __unicode__(self):
        return self.name


class TestModel(models.Model):

    name = models.CharField(max_length=30)
    key = models.ForeignKey('ExtraObject')
    many = models.ManyToManyField('ExtraObject', related_name='extras')

    objects = CustomManager()

    def save(self, *args, **kwargs):
        print('save() is called.')
        super(TestModel, self).save(*args, **kwargs)

    def __unicode__(self):
        # Never do such things (access by foreing key) in real life,
        # because it hits the database.
        return u'{} {} {}'.format(self.name, self.key.name, self.many.count())


@receiver(pre_save, sender=TestModel)
@receiver(post_save, sender=TestModel)
def reicever(*args, **kwargs):
    print('signal dispatched')

def index(request):
    if request and request.method == 'GET':

        from models import ExtraObject, TestModel

        # Create exmple data if table is empty:
        if TestModel.objects.count() == 0:
            for i in range(15):
                extra = ExtraObject.objects.create(name=str(i))
                test = TestModel.objects.create(key=extra, name='test_%d' % i)
                test.many.add(test)
                print test

        to_edit = TestModel.objects.get(id=1)
        to_edit.name = 'edited_test'
        to_edit.key = ExtraObject.objects.create(name='new_for')
        to_edit.save()

        new_key = ExtraObject.objects.create(name='new_for_update')
        to_update = TestModel.objects.filter(id=2).update(name='updated_name', key=new_key)
        # return any kind of HttpResponse

views.py
：

from __future__ import print_function
from django.db import models
from django.db.models import signals
from django.db.models.signals import pre_save, post_save
from django.dispatch import receiver

__author__ = 'sobolevn'

class CustomManager(models.Manager):
    def get_queryset(self):
        super_query = super(models.Manager, self).get_queryset()
        print('Manager is called', super_query)
        return super_query


class ExtraObject(models.Model):
    name = models.CharField(max_length=30)

    def __unicode__(self):
        return self.name


class TestModel(models.Model):

    name = models.CharField(max_length=30)
    key = models.ForeignKey('ExtraObject')
    many = models.ManyToManyField('ExtraObject', related_name='extras')

    objects = CustomManager()

    def save(self, *args, **kwargs):
        print('save() is called.')
        super(TestModel, self).save(*args, **kwargs)

    def __unicode__(self):
        # Never do such things (access by foreing key) in real life,
        # because it hits the database.
        return u'{} {} {}'.format(self.name, self.key.name, self.many.count())


@receiver(pre_save, sender=TestModel)
@receiver(post_save, sender=TestModel)
def reicever(*args, **kwargs):
    print('signal dispatched')

def index(request):
    if request and request.method == 'GET':

        from models import ExtraObject, TestModel

        # Create exmple data if table is empty:
        if TestModel.objects.count() == 0:
            for i in range(15):
                extra = ExtraObject.objects.create(name=str(i))
                test = TestModel.objects.create(key=extra, name='test_%d' % i)
                test.many.add(test)
                print test

        to_edit = TestModel.objects.get(id=1)
        to_edit.name = 'edited_test'
        to_edit.key = ExtraObject.objects.create(name='new_for')
        to_edit.save()

        new_key = ExtraObject.objects.create(name='new_for_update')
        to_update = TestModel.objects.filter(id=2).update(name='updated_name', key=new_key)
        # return any kind of HttpResponse

这导致了以下SQL查询：

# to_edit = TestModel.objects.get(id=1):
QUERY = u'SELECT "main_testmodel"."id", "main_testmodel"."name", "main_testmodel"."key_id" 
FROM "main_testmodel" 
WHERE "main_testmodel"."id" = %s LIMIT 21' 
- PARAMS = (u'1',)

# to_edit.save():
QUERY = u'UPDATE "main_testmodel" SET "name" = %s, "key_id" = %s 
WHERE "main_testmodel"."id" = %s' 
- PARAMS = (u"'edited_test'", u'2', u'1')

# to_update = TestModel.objects.filter(id=2).update(name='updated_name', key=new_key):
QUERY = u'UPDATE "main_testmodel" SET "name" = %s, "key_id" = %s 
WHERE "main_testmodel"."id" = %s' 
- PARAMS = (u"'updated_name'", u'3', u'2')

我们只有一个查询
update（）
，两个查询
save（）

接下来，让我们讨论重写
save（）
方法。显然，
save（）
方法只调用一次。值得一提的是，
.objects.create（）
还调用
save（）
方法

但是
update（）
不会在模型上调用
save（）
。如果没有为
update（）
调用
save（）
方法，则也不会触发信号。输出：

Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

# TestModel.objects.get(id=1):
Manager is called [<TestModel: edited_test new_for 0>]
Manager is called [<TestModel: edited_test new_for 0>]
save() is called.
signal dispatched
signal dispatched

# to_update = TestModel.objects.filter(id=2).update(name='updated_name', key=new_key):
Manager is called [<TestModel: edited_test new_for 0>]

在启动开发服务器http://127.0.0.1:8000/
使用CONTROL-C退出服务器。
#TestModel.objects.get（id=1）：
经理被称为[]
经理被称为[]
调用save（）。
发出信号
发出信号
#to_update=TestModel.objects.filter（id=2）.update（name='updated_name'，key=new_key）：
经理被称为[]

您可以看到
save（）
触发
Manager
的
get\u queryset（）
两次。当
update（）
仅更新一次时

决议。如果需要“静默”更新值，而不调用
save（）
，请使用
update
。用例：
上次看到的用户字段。当您需要正确更新模型时，使用
save（）
更新将为您提供多个对象的查询集更好的性能，因为它将为每个查询集调用一个数据库

但是，save很有用，因为可以很容易地重写模型中的save方法并在其中添加额外的逻辑。例如，在我自己的应用程序中，当其他字段发生更改时，我会更新日期

Class myModel(models.Model): 
    name = models.CharField()
    date_created = models.DateField()

    def save(self):
        if not self.pk :
           ### we have a newly created object, as the db id is not set
           self.date_created = datetime.datetime.now()
        super(myModel , self).save()

直接使用更新效率更高，还可以防止完整性问题

来自官方文件

如果您只是更新一个记录，而不需要对其执行任何操作
对于模型对象，最有效的方法是调用update（），
而不是将模型对象加载到内存中。例如，相反
要做到这一点：

e = Entry.objects.get(id=10)
e.comments_on = False
e.save()

…这样做：

Entry.objects.filter(id=10).update(comments_on=False)

使用update（）还可以防止可能发生某些情况的竞争条件
在加载之间的短时间内更改数据库
对象并调用save（）

可能是@sobolevn的副本，因为django是1.0或1.1版或类似版本，所以该问题和答案已经过时。这些Verison已被弃用，不再受支持，因为在此期间发生了许多更改。@FallenAngel，是的，a首先看到了日期。但是当我弄明白时，我给出了一个答案。在更新示例中调用
get
是否会导致查找并删除使用更新可能获得的任何优势？IIUC然后使用
过滤器
不会导致额外的查找？我在尝试更新
AttributeError时遇到此错误：“TableName”对象没有属性“update”
filter
似乎可以工作，但是对于第二个，get
不起作用，最好在触发
obj.save（）
之前使用
obj.refresh\u from_db（）