代码改变世界
[登录 · 注册]
  • django(七)之数据库表的单表增删改查QuerySet,双下划线
  • https://www.cnblogs.com/haiyan123/p/7738435.html

    https://www.cnblogs.com/yuanchenqi/articles/6083427.htm

    一、添加表记录

    对于单表有两种方式

    # 添加数据的两种方式
        # 方式一:实例化对象就是一条表记录
        Frank_obj = models.Student(name ="海东",course="python",birth="2000-9-9",fenshu=80)
        Frank_obj.save()
        # 方式二:
        models.Student.objects.create(name ="alex",course="python",birth="1995-5-9",fenshu=88)

    二、查询表记录

    查询相关API

    # 查询相关API
        # 1、all():查看所有
        student_obj = models.Student.objects.all()
        print(student_obj)  #打印的结果是QuerySet集合
        # 2、filter():可以实现且关系,但是或关系需要借助Q查询实现。。。
        #              查不到的时候不会报错
        print(models.Student.objects.filter(name="Frank"))  #查看名字是Frank的
        print(models.Student.objects.filter(name="Frank",fenshu=80))  #查看名字是Frank的并且分数是80的
        # 3、get():如果找不到就会报错,如果有多个值,也会报错,只能拿有一个值的
        print(models.Student.objects.get(name="Frank"))  #拿到的是model对象
        print(models.Student.objects.get(nid=2))  #拿到的是model对象
        # 4、exclude():排除条件
        print( models.Student.objects.exclude(name="海东")) #查看除了名字是海东的信息
        # 5、values():是QuerySet的一个方法 (吧对象转换成字典的形式了,)
        print(models.Student.objects.filter(name="海东").values("nid","course")) #查看名字为海东的编号和课程
        #打印结果:<QuerySet [{'nid': 2, 'course': 'python'}, {'nid': 24, 'course': 'python'}]>
        # 6、values_list():是queryset的一个方法 (吧对象转成元组的形式了)
        print(models.Student.objects.filter(name="海东").values_list("nid", "course"))
        #打印结果:< QuerySet[(2, 'python'), (24, 'python')] >
        # 7、order_by():排序
        print(models.Student.objects.all().order_by("fenshu"))
        # 8、reverse():倒序
        print(models.Student.objects.all().reverse())
        # 9、distinct():去重(只要结果里面有重复的)
        print(models.Student.objects.filter(course="python").values("fenshu").distinct())
        # 10、count():查看有几条记录
        print(models.Student.objects.filter(name="海东").count())
    
        # 11、first()
        # 12、last()
        return render(request,"test.html",{"student_obj":student_obj})
        # 13、esits:查看有没有记录,如果有返回True,没有返回False
            #         并不需要判断所有的数据,
            # if models.Book.objects.all().exists():

     双下划线之单表查询

    models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 获取id小于1 且 大于10的值
     
    models.Tb1.objects.filter(id__in=[11, 22, 33])   # 获取id等于11、22、33的数据
    models.Tb1.objects.exclude(id__in=[11, 22, 33])  # not in
     
    models.Tb1.objects.filter(name__contains="ven")  #包括ven的
    models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感
     
    models.Tb1.objects.filter(id__range=[1, 2])      # 范围bettwen and
     
    startswith,istartswith, endswith, iendswith
    对象可以调用自己的属性,用一个点就可以
    还可以通过双下划线。。。
        models.Book.objects.filter(price__gt=100)   价格大于100的书
        models.Book.objects.filter(author__startwith= "")    查看作者的名字是以张开头的
        主键大于5的且小于2
        price__gte=99大于等于
        publishDate__year =2017,publishDate__month = 10   查看2017年10月份的数据
    from django.shortcuts import render,HttpResponse
    
    # Create your views here.
    from app01.models import *
    
    def index(request):
    
        return render(request,"index.html")
    
    def addbook(request):
    
        # b=Book(name="python基础",price=99,author="yuan",pub_date="2017-12-12")
        # b.save()
        Book.objects.create(name="老男孩linux",price=78,author="oldboy",pub_date="2016-12-12")
        #Book.objects.create(**dic)
    
        return HttpResponse("添加成功")
    
    
    def update(request):
    
        Book.objects.filter(author="yuan").update(price=999)
    
        # b=Book.objects.get(author="oldboy")
        # b.price=120
        # b.save()
        # print(b)#<QuerySet [<Book: Book object>]>
        # print(type(b))
    
        return HttpResponse("修改成功!")
    
    
    def delete(req):
    
        Book.objects.filter(author="oldboy").delete()
    
        return HttpResponse("success")
    
    def select(req):
        # book_list=Book.objects.all()
        # print(book_list)
        # print(book_list[0])#Book object
        # book_list = Book.objects.filter(id=2)
        # book_list = Book.objects.all()[::2] # 步长
        # book_list = Book.objects.all()[::-1] # 倒序
        # book_list = Book.objects.first()
        # book_list = Book.objects.last()
        # book_list = Book.objects.get(id=2)#只能取出一条记录时才不报错
        # ret1=Book.objects.filter(author="oldboy").values("name")
        # ret2=Book.objects.filter(author="yuan").values_list("name","price")
        # book_list=Book.objects.exclude(author="yuan").values("name","price")
        # print(ret1)
        # print(ret2)
    
        # book_list= Book.objects.all().values("name").distinct()
        # book_count= Book.objects.all().values("name").distinct().count()
        # print(book_count)
    
        #万能的  __
    
        # book_list=Book.objects.filter(price__gt=50).values("name","price")
        book_list=Book.objects.filter(name__contains="P").values_list("name","price")
    
    
        return render(req,"index.html",{"book_list":book_list})

    表(模型)的创建:

    实例:我们来假定下面这些概念,字段和关系

    作者模型:一个作者有姓名。

    作者详细模型:把作者的详情放到详情表,包含性别,email地址和出生日期,作者详情模型和作者模型之间是一对一的关系(one-to-one)(类似于每个人和他的身份证之间的关系),在大多数情况下我们没有必要将他们拆分成两张表,这里只是引出一对一的概念。

    出版商模型:出版商有名称,地址,所在城市,省,国家和网站。

    书籍模型:书籍有书名和出版日期,一本书可能会有多个作者,一个作者也可以写多本书,所以作者和书籍的关系就是多对多的关联关系(many-to-many),一本书只应该由一个出版商出版,所以出版商和书籍是一对多关联关系(one-to-many),也被称作外键。

    from django.db import models<br>
    class Publisher(models.Model):
        name = models.CharField(max_length=30, verbose_name="名称")
        address = models.CharField("地址", max_length=50)
        city = models.CharField('城市',max_length=60)
        state_province = models.CharField(max_length=30)
        country = models.CharField(max_length=50)
        website = models.URLField()
     
        class Meta:
            verbose_name = '出版商'
            verbose_name_plural = verbose_name
     
        def __str__(self):
            return self.name
     
    class Author(models.Model):
        name = models.CharField(max_length=30)
        def __str__(self):
            return self.name
     
    class AuthorDetail(models.Model):
        sex = models.BooleanField(max_length=1, choices=((0, ''),(1, ''),))
        email = models.EmailField()
        address = models.CharField(max_length=50)
        birthday = models.DateField()
        author = models.OneToOneField(Author)
     
    class Book(models.Model):
        title = models.CharField(max_length=100)
        authors = models.ManyToManyField(Author)
        publisher = models.ForeignKey(Publisher)
        publication_date = models.DateField()
        price=models.DecimalField(max_digits=5,decimal_places=2,default=10)
        def __str__(self):
            return self.title

    分析代码:

           <1>  每个数据模型都是django.db.models.Model的子类,它的父类Model包含了所有必要的和数据库交互的方法。并提供了一个简介漂亮的定义数据库字段的语法。

           <2>  每个模型相当于单个数据库表(多对多关系例外,会多生成一张关系表),每个属性也是这个表中的字段。属性名就是字段名,它的类型(例如CharField)相当于数据库的字段类型(例如varchar)。大家可以留意下其它的类型都和数据库里的什么字段对应。

           <3>  模型之间的三种关系:一对一,一对多,多对多。

                 一对一:实质就是在主外键(author_id就是foreign key)的关系基础上,给外键加了一个UNIQUE=True的属性;

                 一对多:就是主外键关系;(foreign key)

                 多对多:(ManyToManyField) 自动创建第三张表(当然我们也可以自己创建第三张表:两个foreign key)

    -------------------------------------增(create  ,  save) -------------------------------

    from app01.models import *
    
        #create方式一:   Author.objects.create(name='Alvin')
    
        #create方式二:   Author.objects.create(**{"name":"alex"})
    
        #save方式一:     author=Author(name="alvin")
                        author.save()
    
        #save方式二:     author=Author()
                        author.name="alvin"
                        author.save()

    重点来了------->那么如何创建存在一对多或多对多关系的一本书的信息呢?(如何处理外键关系的字段如一对多的publisher和多对多的authors)

    #一对多(ForeignKey):
    
        #方式一: 由于绑定一对多的字段,比如publish,存到数据库中的字段名叫publish_id,所以我们可以直接给这个
        #       字段设定对应值:
               Book.objects.create(title='php',
                                   publisher_id=2,   #这里的2是指为该book对象绑定了Publisher表中id=2的行对象
                                   publication_date='2017-7-7',
                                   price=99)
    
    
        #方式二:
        #       <1> 先获取要绑定的Publisher对象:
            pub_obj=Publisher(name='河大出版社',address='保定',city='保定',
                    state_province='河北',country='China',website='http://www.hbu.com')
        OR  pub_obj=Publisher.objects.get(id=1)
    
        #       <2>将 publisher_id=2 改为  publisher=pub_obj
    
    #多对多(ManyToManyField()):
    
        author1=Author.objects.get(id=1)
        author2=Author.objects.filter(name='alvin')[0]
        book=Book.objects.get(id=1)
        book.authors.add(author1,author2)
        #等同于:
        book.authors.add(*[author1,author2])
        book.authors.remove(*[author1,author2])
        #-------------------
        book=models.Book.objects.filter(id__gt=1)
        authors=models.Author.objects.filter(id=1)[0]
        authors.book_set.add(*book)
        authors.book_set.remove(*book)
        #-------------------
        book.authors.add(1)
        book.authors.remove(1)
        authors.book_set.add(1)
        authors.book_set.remove(1)
    
    #注意: 如果第三张表是通过models.ManyToManyField()自动创建的,那么绑定关系只有上面一种方式
    #     如果第三张表是自己创建的:
         class Book2Author(models.Model):
                author=models.ForeignKey("Author")
                Book=  models.ForeignKey("Book")
    #     那么就还有一种方式:
                author_obj=models.Author.objects.filter(id=2)[0]
                book_obj  =models.Book.objects.filter(id=3)[0]
    
                s=models.Book2Author.objects.create(author_id=1,Book_id=2)
                s.save()
                s=models.Book2Author(author=author_obj,Book_id=1)
                s.save()

    -----------------------------------------删(delete) ---------------------------------------------

    删除方法就是 delete()。它运行时立即删除对象而不返回任何值。例如:e.delete()

    def delstudent(request,id):
        # 删除数据
        models.Student.objects.filter(nid=id).delete()
        return redirect("/test/")

    你也可以一次性删除多个对象。每个 QuerySet 都有一个 delete() 方法,它一次性删除 QuerySet 中所有的对象。

    例如,下面的代码将删除 pub_date 是2005年的 Entry 对象:

    Entry.objects.filter(pub_date__year=2005).delete()

    要牢记这一点:无论在什么情况下,QuerySet 中的 delete() 方法都只使用一条 SQL 语句一次性删除所有对象,而并不是分别删除每个对象。如果你想使用在 model 中自定义的 delete() 方法,就要自行调用每个对象的delete 方法。(例如,遍历 QuerySet,在每个对象上调用 delete()方法),而不是使用 QuerySet 中的 delete()方法。

    在 Django 删除对象时,会模仿 SQL 约束 ON DELETE CASCADE 的行为,换句话说,删除一个对象时也会删除与它相关联的外键对象。例如:

    b = Blog.objects.get(pk=1)
    # This will delete the Blog and all of its Entry objects.
    b.delete()

    要注意的是: delete() 方法是 QuerySet 上的方法,但并不适用于 Manager 本身。这是一种保护机制,是为了避免意外地调用 Entry.objects.delete() 方法导致 所有的 记录被误删除。如果你确认要删除所有的对象,那么你必须显式地调用:

    Entry.objects.all().delete()

    -----------------------------------------改(update和save) ----------------------------------------

    实例:

        

    注意:

    <1> 第二种方式修改不能用get的原因是:update是QuerySet对象的方法,get返回的是一个model对象,它没有update方法,而filter返回的是一个QuerySet对象(filter里面的条件可能有多个条件符合,比如name='alvin',可能有两个name='alvin'的行数据)。

    <2>在“插入和更新数据”小节中,我们有提到模型的save()方法,这个方法会更新一行里的所有列。 而某些情况下,我们只需要更新行里的某几列。

    #---------------- update方法直接设定对应属性----------------
        models.Book.objects.filter(id=3).update(title="PHP")
        ##sql:
        ##UPDATE "app01_book" SET "title" = 'PHP' WHERE "app01_book"."id" = 3; args=('PHP', 3)
    
    
    #--------------- save方法会将所有属性重新设定一遍,效率低-----------
        obj=models.Book.objects.filter(id=3)[0]
        obj.title="Python"
        obj.save()
    # SELECT "app01_book"."id", "app01_book"."title", "app01_book"."price", 
    # "app01_book"."color", "app01_book"."page_num", 
    # "app01_book"."publisher_id" FROM "app01_book" WHERE "app01_book"."id" = 3 LIMIT 1; 
    # 
    # UPDATE "app01_book" SET "title" = 'Python', "price" = 3333, "color" = 'red', "page_num" = 556,
    # "publisher_id" = 1 WHERE "app01_book"."id" = 3;

    在这个例子里我们可以看到Django的save()方法更新了不仅仅是title列的值,还有更新了所有的列。 若title以外的列有可能会被其他的进程所改动的情况下,只更改title列显然是更加明智的。更改某一指定的列,我们可以调用结果集(QuerySet)对象的update()方法,与之等同的SQL语句变得更高效,并且不会引起竞态条件。

    此外,update()方法对于任何结果集(QuerySet)均有效,这意味着你可以同时更新多条记录update()方法会返回一个整型数值,表示受影响的记录条数。

    注意,这里因为update返回的是一个整形,所以没法用query属性;对于每次创建一个对象,想显示对应的raw sql,需要在settings加上日志记录部分

    LOGGING = {
        'version': 1,
        'disable_existing_loggers': False,
        'handlers': {
            'console':{
                'level':'DEBUG',
                'class':'logging.StreamHandler',
            },
        },
        'loggers': {
            'django.db.backends': {
                'handlers': ['console'],
                'propagate': True,
                'level':'DEBUG',
            },
        }
    }
    
    LOGGING

    ---------------------------------------查(filter,value等) -------------------------------------

    ---------->查询API:

    # 查询相关API:
    
    #  <1>filter(**kwargs):      它包含了与所给筛选条件相匹配的对象
    
    #  <2>all():                 查询所有结果
    
    #  <3>get(**kwargs):         返回与所给筛选条件相匹配的对象,返回结果有且只有一个,如果符合筛选条件的对象超过一个或者没有都会抛出错误。
    
    #-----------下面的方法都是对查询的结果再进行处理:比如 objects.filter.values()--------
    
    #  <4>values(*field):        返回一个ValueQuerySet——一个特殊的QuerySet,运行后得到的并不是一系列 model的实例化对象,而是一个可迭代的字典序列
                                         
    #  <5>exclude(**kwargs):     它包含了与所给筛选条件不匹配的对象
    
    #  <6>order_by(*field):      对查询结果排序
    
    #  <7>reverse():             对查询结果反向排序
    
    #  <8>distinct():            从返回结果中剔除重复纪录
    
    #  <9>values_list(*field):   它与values()非常相似,它返回的是一个元组序列,values返回的是一个字典序列
    
    #  <10>count():              返回数据库中匹配查询(QuerySet)的对象数量。
    
    # <11>first():               返回第一条记录
    
    # <12>last():                返回最后一条记录
    
    #  <13>exists():             如果QuerySet包含数据,就返回True,否则返回False。
    View Code

    补充:

    #扩展查询,有时候DJANGO的查询API不能方便的设置查询条件,提供了另外的扩展查询方法extra:
    #extra(select=None, where=None, params=None, tables=None,order_by=None, select_params=None
    
    (1)  Entry.objects.extra(select={'is_recent': "pub_date > '2006-01-01'"})
    (2)  Blog.objects.extra(
            select=SortedDict([('a', '%s'), ('b', '%s')]),
            select_params=('one', 'two'))
    
    (3)  q = Entry.objects.extra(select={'is_recent': "pub_date > '2006-01-01'"})
         q = q.extra(order_by = ['-is_recent'])
    
    (4)  Entry.objects.extra(where=['headline=%s'], params=['Lennon'])  
    
    extra
    View Code

    --------->惰性机制:

    所谓惰性机制:Publisher.objects.all()或者.filter()等都只是返回了一个QuerySet(查询结果集对象),它并不会马上执行sql,而是当调用QuerySet的时候才执行。

    QuerySet特点:

           <1>  可迭代的

           <2>  可切片

    #objs=models.Book.objects.all()#[obj1,obj2,ob3...]
    
        #QuerySet:   可迭代
    
        # for obj in objs:#每一obj就是一个行对象
        #     print("obj:",obj)
        # QuerySet:  可切片
    
        # print(objs[1])
        # print(objs[1:4])
        # print(objs[::-1])

    QuerySet的高效使用:

    <1>Django的queryset是惰性的
    
         Django的queryset对应于数据库的若干记录(row),通过可选的查询来过滤。例如,下面的代码会得
         到数据库中名字为‘Dave’的所有的人:person_set = Person.objects.filter(first_name="Dave")
         上面的代码并没有运行任何的数据库查询。你可以使用person_set,给它加上一些过滤条件,或者将它传给某个函数,
         这些操作都不会发送给数据库。这是对的,因为数据库查询是显著影响web应用性能的因素之一。
    
    <2>要真正从数据库获得数据,你可以遍历queryset或者使用if queryset,总之你用到数据时就会执行sql.
       为了验证这些,需要在settings里加入 LOGGING(验证方式)
            obj=models.Book.objects.filter(id=3)
            # for i in obj:
            #     print(i)
    
            # if obj:
            #     print("ok")
    
    <3>queryset是具有cache的
         当你遍历queryset时,所有匹配的记录会从数据库获取,然后转换成Django的model。这被称为执行
        (evaluation).这些model会保存在queryset内置的cache中,这样如果你再次遍历这个queryset,
         你不需要重复运行通用的查询。
            obj=models.Book.objects.filter(id=3)
    
            # for i in obj:
            #     print(i)
                              ## models.Book.objects.filter(id=3).update(title="GO")
                              ## obj_new=models.Book.objects.filter(id=3)
            # for i in obj:
            #     print(i)   #LOGGING只会打印一次
    
    <4>
         简单的使用if语句进行判断也会完全执行整个queryset并且把数据放入cache,虽然你并不需要这些
         数据!为了避免这个,可以用exists()方法来检查是否有数据:
    
                obj = Book.objects.filter(id=4)
                #  exists()的检查可以避免数据放入queryset的cache。
                if obj.exists():
                    print("hello world!")
    
    <5>当queryset非常巨大时,cache会成为问题
    
         处理成千上万的记录时,将它们一次装入内存是很浪费的。更糟糕的是,巨大的queryset可能会锁住系统
         进程,让你的程序濒临崩溃。要避免在遍历数据的同时产生queryset cache,可以使用iterator()方法
         来获取数据,处理完数据就将其丢弃。
            objs = Book.objects.all().iterator()
            # iterator()可以一次只从数据库获取少量数据,这样可以节省内存
            for obj in objs:
                print(obj.name)
            #BUT,再次遍历没有打印,因为迭代器已经在上一次遍历(next)到最后一次了,没得遍历了
            for obj in objs:
                print(obj.name)
    
         #当然,使用iterator()方法来防止生成cache,意味着遍历同一个queryset时会重复执行查询。所以使
         #用iterator()的时候要当心,确保你的代码在操作一个大的queryset时没有重复执行查询
    
    总结:
        queryset的cache是用于减少程序对数据库的查询,在通常的使用下会保证只有在需要的时候才会查询数据库。
    使用exists()和iterator()方法可以优化程序对内存的使用。不过,由于它们并不会生成queryset cache,可能
    会造成额外的数据库查询。

    ---------->对象查询,单表条件查询,多表条件关联查询

    #--------------------对象形式的查找--------------------------
        # 正向查找
        ret1=models.Book.objects.first()
        print(ret1.title)
        print(ret1.price)
        print(ret1.publisher)
        print(ret1.publisher.name)  #因为一对多的关系所以ret1.publisher是一个对象,而不是一个queryset集合
    
        # 反向查找
        ret2=models.Publish.objects.last()
        print(ret2.name)
        print(ret2.city)
        #如何拿到与它绑定的Book对象呢?
        print(ret2.book_set.all()) #ret2.book_set是一个queryset集合
    
    #---------------了不起的双下划线(__)之单表条件查询----------------
    
    #    models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 获取id大于1 且 小于10的值
    #
    #    models.Tb1.objects.filter(id__in=[11, 22, 33])   # 获取id等于11、22、33的数据
    #    models.Tb1.objects.exclude(id__in=[11, 22, 33])  # not in
    #
    #    models.Tb1.objects.filter(name__contains="ven")
    #    models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感
    #
    #    models.Tb1.objects.filter(id__range=[1, 2])   # 范围bettwen and
    #
    #    startswith,istartswith, endswith, iendswith,
    
    #----------------了不起的双下划线(__)之多表条件关联查询---------------
    
    # 正向查找(条件)
    
    #     ret3=models.Book.objects.filter(title='Python').values('id')
    #     print(ret3)#[{'id': 1}]
    
          #正向查找(条件)之一对多
    
          ret4=models.Book.objects.filter(title='Python').values('publisher__city')
          print(ret4)  #[{'publisher__city': '北京'}]
    
          #正向查找(条件)之多对多
          ret5=models.Book.objects.filter(title='Python').values('author__name')
          print(ret5)
          ret6=models.Book.objects.filter(author__name="alex").values('title')
          print(ret6)
    
          #注意
          #正向查找的publisher__city或者author__name中的publisher,author是book表中绑定的字段
          #一对多和多对多在这里用法没区别
    
    # 反向查找(条件)
    
        #反向查找之一对多:
        ret8=models.Publisher.objects.filter(book__title='Python').values('name')
        print(ret8)#[{'name': '人大出版社'}]  注意,book__title中的book就是Publisher的关联表名
    
        ret9=models.Publisher.objects.filter(book__title='Python').values('book__authors')
        print(ret9)#[{'book__authors': 1}, {'book__authors': 2}]
    
        #反向查找之多对多:
        ret10=models.Author.objects.filter(book__title='Python').values('name')
        print(ret10)#[{'name': 'alex'}, {'name': 'alvin'}]
    
        #注意
        #正向查找的book__title中的book是表名Book
        #一对多和多对多在这里用法没区别
    View Code

    注意:条件查询即与对象查询对应,是指在filter,values等方法中的通过__来明确查询条件。

    编辑表格中的内容的涉及到的语法

    编辑操作涉及到的语法
    
    分析:
        1、点击编辑,让跳转到另一个页面,拿到我点击的那一行
        两种取id值的方式
        方式一:
            利用数据传参数(作为数据参数传过去了)
            <a href="/edit/?book_id = {{book_obj.nid}}"></a>  #相当于发了一个键值对
            url里面就不用写匹配的路径了,
            id = request.GET.get("book_id")  #取值 
        
        方式二:
            利用路径传参,得在url里面加上(d+),就得给函数传个参数,无名分组从参数里面取值
            <a href="/{{book_obj.nid}}"></a>
        
        2、拿到id,然后在做筛选
            id = request.GET.get("book_id")
            book_obj = models.Book.objects.filter(nid=id)  #拿到的是一个列表对象
            注意:
                1.取[0]就拿到对象了,,然后对象.属性就可以取到值了
                2.用get,你取出来的数据必须只有一条的时候,,如果有多条用get就会报错,,,但是用get就不用加[0]了
            book_obj = models.Book.objects.filter(nid=id)[0]    
            
        3、当点击编辑的时候怎么让input框里显示文本内容
            value = "{{book_obj.title}}"
        4、改完数据后重新提交
            当提交的时候走action...../edit/}
            隐藏一个input,
            <input type="hidden" name = "book_id" value="{{book_obj.nid}}">
            判断post的时候:
                修改数据 
                    方式一:save(这种方式效率是非常低的,不推荐使用,了解就行了)
                        修改的前提是先取(拿到要编辑的id值)
                        id = request.POST.get("book_id")
                        bk_obj = models.Book.objects.filter(nid=id)[0]
                        bk_obj.title = "hhhhhh"  #这是写死了,不能都像这样写死了
                        bk_obj.save()  只要是用对象的这种都要.save
                    方式二:update
                    title = request.POST.get("title")
                    models.Book.objects.filter(nid=id).update(title=title,......)
                跳转到index
                
                
                
                
    如果是post请求的时候怎么找到id呢,
    一、如果是数据传参:(也就是get请求的时候)
        可以通过一个隐藏的input框,给这个框给一个name属性,value属性。通过request.POST.get(""),,就可以得到id的值
    二、如果是路径传参
        可以通过传参的形式,当正则表达式写一个(d+)的时候,就给函数传一个id,可通过这个id知道id.
  • 【推广】 阿里云小站-上云优惠聚集地(新老客户同享)更有每天限时秒杀!
    【推广】 云服务器低至0.95折 1核2G ECS云服务器8.1元/月
    【推广】 阿里云老用户升级四重礼遇享6.5折限时折扣!
  • 原文:https://www.cnblogs.com/xiangtingshen/p/10614168.html
Copyright 2008-2020 晋ICP备12007731号-1