Python学习笔记第二十五周（Django补充）

2022-09-16 08:06:49

　　1、render_to_reponse()

　　　　不同于render，render_to_response（）不用包含request，直接写template中文件

　　2、locals（）

　　　　如果views文件中的函数里变量过多的话，可以在render或render_to_response()里面直接增加render（request,'index.html',locals()）这样在前端界面渲染的时候可以直接写变量名

　　　　locals（）的缺点是不想传递过去的变量也传递过去了

　　3、JS中的方法：

　　　　a： hover（f1，f2）

　　　　　　例子：

　　　　　　$(".outer").hover（f1,f2） 其中f1表示鼠标进入时操作，f2表示鼠标退出时操作

　　　　　　hover比mouseover（）和mouseout（）的优点在于hover一个方法可以表示两个动作

　　　　　　$(".outer").hover（function(){

　　　　　　　　clearInterval(time);

　　　　　　　　},function(){

　　　　　　　　time=setInterval(move,1500)#每一点五秒执行setInterval动作

　　　　　　　　　}）

　　　　b:关于轮播图乱序问题解决：

　　　　$('.num .li').eq(i).stop（）.fadeIn(1000).siblings().stop（）.fadeOut(1000);#加入stop表示先将播放全部停止然后在做fadeIn和fadeOut操作

　　4、template中，如果要简单标注索引可以使用

　　　　{{  forloop.counter}}  从1开始

　　　　{{ forloop.counter0}} 从0开始

　　　　{{forloop.revcounter}} 从最大开始

　　　　{{ forloop.revcounter0}}从最大开始到0结束

模板语言中，引用base模板中内容，使用{{ block.super }}

　　5、ORM操作

　　增加：

　　　　#create方式一：Author.objects.create(name="Alvin")

　　　　#create方式二：Author.objects.create(**{"name":"Alvin"})  推荐使用

　　　　如果有外键：

　　　　　　一对多：

　　　　　　<1>models.Book.objects.create(title="python",price=2,publish_id=2)  #其中publish为外键关联，默认使用id，所以publish_id自动生成

　　　　　　<2>models.Book.objects.create(title="python",price=2,publish=obj)#publish绑定的是一对多里面一的那个对象，也就是publish对应的   推荐

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　  #obj代表一个object对象

　　　　　　多对多：

　　　　　　1、自动创建

　　　　　　  add()   remove()

　　　　　　-----------正向绑定

　　　　　　 book=models.Book.objects.filter(id=2)[0]

　　　　　　authors=models.Author.objects.filter(id__gt=2)　　　　

　　　　　　book.author.add(*authors)

　　　　　　------------反向绑定

　　　　　　authors=models.Author.objects.filter(id=2)[0]

　　　　　　books=models.Book.objects.filter(id__gt=2)　　　　　

　　　　　　author.book_set.add(*books)                  #book_set组合在一起组成一个QuerySet　,这个是django自带的功能

　　　　#save方式一：author=Author(name="alvin")

　　　　　　　　　　  author.save()

　　　　#save方式二：authorAuthor（）

　　　　　　　　　　author.name="alvin"

　　　　　　　　　　author.save()

　　　　2、手动创建

　　　　 　　class BOOKAuthor（models.Model）:

　　　　　　　　author=models.ForeignKey('Author')

　　　　　　　　book=models.ForeignKey('Book')

　　　　　　　　class Meta:

　　　　　　　　　　unique_together=['author','book']  #联合唯一

　　　　自己写第三张表

　　　　ManytoMany 通过两个ForeignKey完成

　　　　OnetoOne     通过一个ForeignKey，uiqueTrue来完成

　　　　

　　删除:

　　　　models.Book.objects.filter(id=1).delete()

　　改：

　　　　第一种：author=Author.objects.get(id-5)

　　　　　　　　authort.name='tenglan'

　　　　　　　　author.save()

　　　　第二种：Publisher.objects.filter(id=5).update(name='Ameriacan publshler‘）#不能用get（id=2）来查找锁定

　　查询API：

　　　　filter（**kwargs）：   它包含了所有刷选条件匹配的对象

　　　　all():　　　　　　　　  查询所有结果

　　　　get(**kwargs):            返回与所筛选条件匹配对象，返回结果有且只有一个，如果一个都没匹配到会报错

　　　　---------------------------------

　　　　下面方法都是对查询结果再进行处理，日不objects.filter().values()

　　　　vaules(*filed)   　　　　返回一个valuequeryset-一个特殊的queryset，运行后得到的并不是一系列model实例对象，而是一个可迭代的字典序列

　　　　exclude（**kwargs）    包含了与所给刷选条件不匹配的对象

　　　　order_by（*filed）　　   对查询结果排序，如果按照从大到小排序，可以使用order_by("-id") 这种方式来进行

　　　　reverse（）　　　　　　对结果反向排序

　　　　distinct（）　　　　     从返回结果中剔除重复记录

　　　　values_list(*filed)　　　它与values（）非常类似，返回的是一个元组序列，values返回的是字典序列

　　　  count（）　　　　      返回数据库中匹配查询QuerySet的对象数量

　　     first（）　　　　　　    返回第一条记录

　　　　last（）                      返回最后一条记录

　　　　exists（）　　　　　　如果queryset包含数据，返回True，否则返回Flase

　　

　　　　惰性机制：

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

　　　　QuerySet特点：

　　　　1、可迭代

　　　　2、可切片

　　　　#objs=models.Book.objects.all()#(obj1,obj2,obj3,.)

　　　　#QuerySet 可迭代

　　　　for obj in objs：每一个obj就是一个行对象

　　　　　　print（"obj:",obj）

　　　　#QuerySet 可切片

　　　　#print(objs[1])

　　　　#print(objs[1:4])

　　　　#print(objs[::-1])

注意，这里因为update返回的是一个整形，所以没法用query属性，对于每次创建一个对象，想显示对应的row 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

　　　　下划线使用：

　　　　一、单表查询

　　　　models.Book.objects.filter(id__gt=2)

　　　　models.Book.objects.filter(id__lt=2)

　　　　models.Book.objects.filter(id__in=[1,3,4,7]) 包含，用__in

　　　　models.Book.objects.filter(title__contian="P") #contain表示包含，icontain表示不区分大小写

　　　　models.Book.objects.filter(title__startwith="P")

　　　　models.Book.objects.filter(title__endwith="P")　　

　　　　二、关联表查询

　　　　models.Publish.objects.filter(book__title="pytohn",book_id=5).values("name").distinct()  #多个条件

　　　　models.Book.objects.filter(id__gt=2，id__lt=5)　　　　 　　

　　　　models.Book.objects.filter(publish__name="清华出版社").values("title")

　　　　models.Book.objects.filter(title="python").values(“publisher__name”)

　　　 三、聚合和分组查询

　　　　aggregate（*args,**kwargs）:

　　　　通过QuerySet进行计算，返回一个聚合值的字典，aggregate（）中每一个参数都指定一个包含在字典中的返回值，即在查询集上生成聚合

　　　　

from django.db.models import Avg,Min,Sum,Max

从整个查询集生成统计值。比如，你想要计算所有在售书的平均价钱。Django的查询语法提供了一种方式描述所有

图书的集合。

>>> Book.objects.all().aggregate(Avg('price'))

{'price__avg': 34.35}

aggregate()子句的参数描述了我们想要计算的聚合值，在这个例子中，是Book模型中price字段的平均值

aggregate()是QuerySet 的一个终止子句，意思是说，它返回一个包含一些键值对的字典。键的名称是聚合值的

标识符，值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的。如果你想要为聚合值指定

一个名称，可以向聚合子句提供它:

>>> Book.objects.aggregate(average_price=Avg('price'))

{'average_price': 34.35}

如果你也想知道所有图书价格的最大值和最小值，可以这样查询：

>>> Book.objects.aggregate(Avg('price'), Max('price'), Min('price'))

{'price__avg': 34.35, 'price__max': Decimal('81.20'), 'price__min': Decimal('12.99')}

　　　　

　　　　annotate(*args,**kwargs):

　　　　可以通过计算查询结果中每一个对象所关联的对象集合，从而得出总计值(也可以是平均值或总和)，即为查询集的每一项生成聚合。

　　　　查询alex出的书总价格 :

　　　　　　Book.objects.filter(author__name="alex").values('title')

　　　　　　Book.objects.filter(author__name="alex").aggregate(Sum('price'))

　　　　查询各个作者出的书的总价格，这里就涉及到分组了，分组条件是author__name

　　　　　　Book.objects.values("author__name").annotate(Sum('price'))

　　　　查询各个出版社最便宜的书价是多少

　　　　　　Book.objects.values('publisher__name').annotate(MIn('price'))

　　　　F查询和Q查询

　　　　仅仅靠单一的关键字参数查询已经很难满足查询要求。此时Django为我们提供了F和Q查询：

# F 使用查询条件的值,专门取对象中某列值的操作

    # from django.db.models import F

    # models.Tb1.objects.update(num=F('num')+1)

# Q 构建搜索条件

    from django.db.models import Q

    #1 Q对象(django.db.models.Q)可以对关键字参数进行封装，从而更好地应用多个查询

    q1=models.Book.objects.filter(Q(title__startswith='P')).all()

    print(q1)#[<Book: Python>, <Book: Perl>]

    # 2、可以组合使用&,|操作符，当一个操作符是用于两个Q的对象,它产生一个新的Q对象。

    Q(title__startswith='P') | Q(title__startswith='J')

    # 3、Q对象可以用~操作符放在前面表示否定，也可允许否定与不否定形式的组合

    Q(title__startswith='P') | ~Q(pub_date__year=2005)

    # 4、应用范围：

    # Each lookup function that takes keyword-arguments (e.g. filter(),

    #  exclude(), get()) can also be passed one or more Q objects as

    # positional (not-named) arguments. If you provide multiple Q object

    # arguments to a lookup function, the arguments will be “AND”ed

    # together. For example:

    Book.objects.get(

        Q(title__startswith='P'),

        Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6))

    )

    #sql:

    # SELECT * from polls WHERE question LIKE 'P%'

    #     AND (pub_date = '2005-05-02' OR pub_date = '2005-05-06')

    # import datetime

    # e=datetime.date(2005,5,6)  #2005-05-06

    # 5、Q对象可以与关键字参数查询一起使用，不过一定要把Q对象放在关键字参数查询的前面。

    # 正确：

    Book.objects.get(

        Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)),

        title__startswith='P')

    # 错误：

    Book.objects.get(

        question__startswith='P',

        Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)))

　　　　

　　6、Ajax　　

　　AJAX（Asynchronous Javascript And XML）翻译成中文就是“异步Javascript和XML”。即使用Javascript语言与服务器进行异步交互，传输的数据为XML（当然，传输的数据不只是XML）。

  • 同步交互：客户端发出一个请求后，需要等待服务器响应结束后，才能发出第二个请求；
  • 异步交互：客户端发出一个请求后，无需等待服务器响应结束，就可以发出第二个请求。

　　AJAX除了异步的特点外，还有一个就是：浏览器页面局部刷新；（这一特点给用户的感受是在不知不觉中完成请求和响应过程）

　　

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <title>Title</title>

<script type="text/javascript">

window.onload = function() {//当文档加载完毕时执行本函数

    var form = document.getElementById("form1");//获取表单元素对象

    form.onsubmit = function() {//给表单元素添加一个监听，监听表单被提交事件

        var usernameValue = form.username.value;//获取表单中名为username的表单元素值

        if(!usernameValue) {//判断该值是否为空

            var usernameSpan = document.getElementById("usernameSpan");//得到usernmae元素后的<span>元素

            usernameSpan.innerText = "用户名不能为空！";//设置span元素内容！

            return false;//返回false，表示拦截了表单提交动作

        }

        return true;//不拦截表单提交动作

    };

};

</script>

</head>

 <body>

<h1>注册页面</h1>

<form action="" method="post" id="form1">

用户名：<input type="text" name="username"/>

<span id="usernameSpan"></span>

<br/>

密　码：<input type="password" name="password"/>

<span id="passwordSpan"></span>

<br/>

<input type="submit" value="注册"/>

</form>

  </body>

</html>

js实现的局部刷新

　　Ajax常见应用场景

　　

当我们在百度中输入一个“老”字后，会马上出现一个下拉列表！列表中显示的是包含“传”字的4个关键字。

其实这里就使用了AJAX技术！当文件框发生了输入变化时，浏览器会使用AJAX技术向服务器发送一个请求，查询包含“传”字的前10个关键字，然后服务器会把查询到的结果响应给浏览器，最后浏览器把这4个关键字显示在下拉列表中。

  • 整个过程中页面没有刷新，只是刷新页面中的局部位置而已！
  • 当请求发出后，浏览器还可以进行其他操作，无需等待服务器的响应！

Python学习笔记第二十五周（Django补充）

　　当输入用户名后，把光标移动到其他表单项上时，浏览器会使用AJAX技术向服务器发出请求，服务器会查询名为zhangSan的用户是否存在，最终服务器返回true表示名为lemontree7777777的用户已经存在了，浏览器在得到结果后显示“用户名已被注册！”。

  • 整个过程中页面没有刷新，只是局部刷新了；
  • 在请求发出后，浏览器不用等待服务器响应结果就可以进行其他操作；

　　Ajax优缺点

　　

优点：

  • AJAX使用Javascript技术向服务器发送异步请求；
  • AJAX无须刷新整个页面；
  • 因为服务器响应内容不再是整个页面，而是页面中的局部，所以AJAX性能高；

缺点：

  • AJAX并不适合所有场景，很多时候还是要使用同步交互；
  • AJAX虽然提高了用户体验，但无形中向服务器发送的请求次数增多了，导致服务器压力增大；
  • 因为AJAX是在浏览器中使用Javascript技术完成的，所以还需要处理浏览器兼容性问题；

　　Ajax技术：

四步操作：

  • 创建核心对象；
  • 使用核心对象打开与服务器的连接；
  • 发送请求
  • 注册监听，监听服务器响应。

XMLHTTPRequest

  • open(请求方式, URL, 是否异步)
  • send(请求体)
  • onreadystatechange，指定监听函数，它会在xmlHttp对象的状态发生变化时被调用
  • readyState，当前xmlHttp对象的状态，其中4状态表示服务器响应结束
  • status：服务器响应的状态码，只有服务器响应结束时才有这个东东，200表示响应成功；
  • responseText：获取服务器的响应体

　　Ajax实现

　　 准备工作(后台设定)：

def login(request):

    print('hello ajax')

    return render(request,'index.html')

def ajax_get(request):

    return HttpResponse('helloyuanhao')

　　

AJAX核心（XMLHttpRequest）

　　其实AJAX就是在Javascript中多添加了一个对象：XMLHttpRequest对象。所有的异步交互都是使用XMLHttpServlet对象完成的。也就是说，我们只需要学习一个Javascript的新对象即可。

var xmlHttp = new XMLHttpRequest()；（大多数浏览器都支持DOM2规范）

注意，各个浏览器对XMLHttpRequest的支持也是不同的！为了处理浏览器兼容问题，给出下面方法来创建XMLHttpRequest对象：

function createXMLHttpRequest() {

        var xmlHttp;

        // 适用于大多数浏览器，以及IE7和IE更高版本

        try{

            xmlHttp = new XMLHttpRequest();

        } catch (e) {

            // 适用于IE6

            try {

                xmlHttp = new ActiveXObject("Msxml2.XMLHTTP");

            } catch (e) {

                // 适用于IE5.5，以及IE更早版本

                try{

                    xmlHttp = new ActiveXObject("Microsoft.XMLHTTP");

                } catch (e){}

            }

        }

        return xmlHttp;

    }

打开与服务器的连接（open方法）

当得到XMLHttpRequest对象后，就可以调用该对象的open()方法打开与服务器的连接了。open()方法的参数如下：

open(method, url, async)：

  • method：请求方式，通常为GET或POST；
  • url：请求的服务器地址，例如：/ajaxdemo1/AServlet，若为GET请求，还可以在URL后追加参数；
  • async：这个参数可以不给，默认值为true，表示异步请求；
var xmlHttp = createXMLHttpRequest();

xmlHttp.open("GET", "/ajax_get/", true);　

　　

　　发送请求

　　

当使用open打开连接后，就可以调用XMLHttpRequest对象的send()方法发送请求了。send()方法的参数为POST请求参数，即对应HTTP协议的请求体内容，若是GET请求，需要在URL后连接参数。

注意：若没有参数，需要给出null为参数！若不给出null为参数，可能会导致FireFox浏览器不能正常发送请求！

xmlHttp.send(null);

　　

　　接收服务器响应

　　

当请求发送出去后，服务器端Servlet就开始执行了，但服务器端的响应还没有接收到。接下来我们来接收服务器的响应。

XMLHttpRequest对象有一个onreadystatechange事件，它会在XMLHttpRequest对象的状态发生变化时被调用。下面介绍一下XMLHttpRequest对象的5种状态：

  • 0：初始化未完成状态，只是创建了XMLHttpRequest对象，还未调用open()方法；
  • 1：请求已开始，open()方法已调用，但还没调用send()方法；
  • 2：请求发送完成状态，send()方法已调用；
  • 3：开始读取服务器响应；
  • 4：读取服务器响应结束。

onreadystatechange事件会在状态为1、2、3、4时引发。

　　下面代码会被执行四次！对应XMLHttpRequest的四种状态！

xmlHttp.onreadystatechange = function() {

            alert('hello');

        };

　　但通常我们只关心最后一种状态，即读取服务器响应结束时，客户端才会做出改变。我们可以通过XMLHttpRequest对象的readyState属性来得到XMLHttpRequest对象的状态。

　　

xmlHttp.onreadystatechange = function() {

            if(xmlHttp.readyState == 4) {

                alert('hello');

            }

        };

　　

　　其实我们还要关心服务器响应的状态码是否为200，其服务器响应为404，或500，那么就表示请求失败了。我们可以通过XMLHttpRequest对象的status属性得到服务器的状态码。

　　最后，我们还需要获取到服务器响应的内容，可以通过XMLHttpRequest对象的responseText得到服务器响应内容。

xmlHttp.onreadystatechange = function() {

            if(xmlHttp.readyState == 4 && xmlHttp.status == 200) {

                alert(xmlHttp.responseText);

            }

        };
上一篇：【UML 建模】UML建模语言入门 -- 静态图详解 类图 对象图 包图 静态图建模实战


下一篇：TOMCAT内存大小调整