zoukankan      html  css  js  c++  java
  • 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.
  • 相关阅读:
    Encrypted Handshake Message
    RSAParameters Struct
    What if JWT is stolen?
    What's the difference between JWTs and Bearer Token?
    RSA Algorithm Example
    第18届Jolt大奖结果公布
    Ruby on rails开发从头来(windows)(三十六) 调试技巧
    Ruby on rails开发从头来(四十二) ActiveRecord基础(主键和ID)
    YouTube开放基础技术架构 让用户建自家YouTube
    Ruby on rails开发从头来(四十) ActiveRecord基础(Boolean属性)
  • 原文地址:https://www.cnblogs.com/xiangtingshen/p/10614168.html
Copyright © 2011-2022 走看看