Python学习笔记第二十五周(Django补充)

  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内存大小调整