标签：ini 名称 note migration channels 相同 门户 erro 服务器
目录
selected_related：内部是连表操作，封装到对象，走一次数据库全部查出
优点：只走一次sql查询
缺点：耗时耗在 连接表的操作 10s
prefetch_related：内部是子查询
优点：耗时耗在 查询次数比如10次 1s
缺点：走两次sql查询大白话总结：
defer与only互为相反，获取没有的数据走数据库拿。
only: 括号内有指定的字段属性
defer:括号内没有指定的字段属性
res = models.Book.objects.only('title') # 這些对象内部只有title屬性
# print(res)
for r in res:
print(r.title) # only括号内有title属性，不走数据库
print(r.price) # 括号内没有price属性，走数据库拿
res = models.Book.objects.defer('title') # defer与only互为反关系对象关系映射，通过models中的类来对应数据库中的一个表，一个对象对应一个数据行，一个属性对应数据库中的一个字段
dango-admin startproject 项目名称 # 创建Django项目
python manage.py startapp 应用app名 # 创建app项目文件下的组成部分：
manage.py 十项目运行的入口，指定配置文件路径
与项目同名的目录，包含项目的配置文件。
__init__.py是一个空文件，作用是这个目录可以被当作包使用，也可以做一些初始化操作。
settings.py是项目的整体配置文件。
urls.py是项目的URL配置文件
wsgi.py 是项目与WSGI兼容的web服务器MTV: django号称是MTV框架
MTV本质也是MVC
MTV：
M :models 模型
T :templates 模版
V :views 视图
MVC：
M:models 模型
V:views 视图
C:contronnar 控制器(路由分发 urls.py)
1、 用户点击注按钮，将要注册的信息发送给网站服务器。
2、 Controller控制器接收到用户的注册信息，Controller会告诉Model层将用户的注册信息保存到数据库
3、 Model层将用户的注册信息保存到数据库
4、 数据保存之后将保存的结果返回给Model模型，
5、 Model层将保存的结果返回给Controller控制器。
6、 Controller控制器收到保存的结果之后，或告诉View视图，view视图产生一个html页面。
7、 View将产生的Html页面的内容给了Controller控制器。
8、 Controller将Html页面的内容返回给浏览器。
9、 浏览器接受到服务器Controller返回的Html页面进行解析展示。
M：Model，模型，和MVC中的M功能相同，和数据库进行交互。
V：view，视图，和MVC中的C功能相同，接收请求，进行处理，与M和T进行交互，返回应答。
T：Template，模板，和MVC中的V功能相同，产生Html页面
1、 用户点击注册按钮，将要注册的内容发送给网站的服务器。
2、 View视图，接收到用户发来的注册数据，View告诉Model将用户的注册信息保存进数据库。
3、 Model层将用户的注册信息保存到数据库中。
4、 数据库将保存的结果返回给Model
5、 Model将保存的结果给View视图。
6、 View视图告诉Template模板去产生一个Html页面。
7、 Template生成html内容返回给View视图。
8、 View将html页面内容返回给浏览器。
9、 浏览器拿到view返回的html页面内容进行解析，展示。字段查询：
all():返回模型类对于表的所有数据
get():返回表中满足条件的数据，如果查到多条数据则抛出异常。查不到数据也抛出异常
filter():参数写查询条件(相当于where)，返回满足条件的QuerySet集合数据字段查询
all():返回模型类对应表格中的所有数据。
get():返回表格中满足条件的一条数据，如果查到多条数据，则抛异常：MultipleObjectsReturned，
查询不到数据，则抛异常：DoesNotExist。
filter():参数写查询条件，返回满足条件 QuerySet 集合数据。
条件格式：
模型类属性名__条件名=值
注意：此处是模型类属性名，不是表中的字段名
关于 filter 具体案例如下：
判等 exact。
Copy
BookInfo.object.filter(id=1)
BookInfo.object.filter(id__exact=1)此处的__exact 可以省略
模糊查询 like
例：查询书名包含'传'的图书。contains
Copy
1. contains BookInfo.objects.filter(btitle__contains=’传’)
空查询 where 字段名 isnull
Copy
1. BookInfo.objects.filter(btitle__isnull=False)
范围查询 where id in (1，3，5)
Copy
1. BookInfo.objects.filter(id__in=[1，3，5])
比较查询 gt lt(less than) gte(equal) lte
Copy
1. BookInfo.objects.filter(id__gte=3)
日期查询
Copy
1. BookInfo.objects.filter(bpub_date__year = 1980)
2. BookInfo.objects.filter(bpub_date__gt = date(1980，1，1))
exclude:返回不满足条件的数据。
Copy
3. BookInfo.objects.exclude(id=3)
F 对象
作用：用于类属性之间的比较条件。
Copy
1. from django.db.models import F
2. 例：where bread > bcomment BookInfo.objects.filter(bread__gt =F(‘bcomment’))
3. 例：BookInfo.objects.filter(bread__gt=F(‘bcomment’)*2)
Q 对象
作用：用于查询时的逻辑条件。可以对 Q 对象进行&|~操作。
Copy
1. from django.db.models import Q
2. BookInfo.objects.filter(id__gt=3， bread__gt=30)
3. BooInfo.objects.filter(Q(id__gt=3) & Q(bread__gt=3))
4. 例：BookInfo.objects.filter(Q(id__gt=3) | Q(bread__gt=30))
5. 例：BookInfo.objects.filter(~Q(id=3))
order_by 返回 QuerySet
作用：对查询结果进行排序。
Copy
1. 例： BookInfo.objects.all().order_by('id')
2. 例： BookInfo.objects.all().order_by('-id')
3. 例：BookInfo.objects.filter(id__gt=3).order_by('-bread')
聚合函数
作用：对查询结果进行聚合操作。
Copy
1. sum count max min avg
aggregate：调用这个函数来使用聚合。
Copy
1. from django.db.models import Sum，Count，Max，Min，Avg
2. 例：BookInfo.objects.aggregate(Count('id'))
{'id__count': 5} 注意返回值类型及键名
Copy
1. 例：BookInfo.objects.aggregate(Sum(‘bread’))
{‘bread__sum’:120} 注意返回值类型及键名
count 函数
作用：统计满足条件数据的数目。
例：统计所有图书的数目。
Copy
1. BookInfo.objects.all().count()
例：统计 id 大于 3 的所有图书的数目。
Copy
1. BookInfo.objects.filter(id__gt = 3).count()
模型类关系
一对多关系
例：图书类-英雄类
models.ForeignKey() 定义在多的类中。
2）多对多关系
例：新闻类-新闻类型类
models.ManyToManyField() 定义在哪个类中都可以。
3）一对一关系
例：员工基本信息类-员工详细信息类
models.OneToOneField() 定义在哪个类中都可以。面试官问你Django中间件的时候，我们不应该只是局限于面试官的问题，而应做到举一反三。
面试之前准备一些白纸，在问到一些问题的时候应该用画图的形式展示出来
比如这里问到Django的中间件，我们应该给面试官画出Django的生命周期整体流程图，把中间件作为一部分的回答内容，
这样的好处在于，即展示了你对Django从前到后的流程都很熟悉又回答了面试官的问题，还顺带秀了一把其他技能，一举两得。
中间件介绍:作为Django的门户，一切请求都会先经过中间件才会到达Django后端，所以中间件可以用来做全局方面的一些功能
详细:给我们定义了五个方法
1.def process_request(request):
pass
2.def process_view(request):
pass
3.def process_template_response(request):
pass
4.def process_exception(request):
pass
5.def process_response(request):
pass
1.uWSGI是一个Web服务器，它实现了WSGI协议、uwsgi、http等协议。Nginx中HttpUwsgiModule的作用是与uWSGI服务器进行交换。WSGI是一种Web服务器网关接口。它是一个Web服务器（如nginx，uWSGI等服务器）与web应用（如用Flask框架写的程序）通信的一种规范。
要注意 WSGI / uwsgi / uWSGI 这三个概念的区分。
WSGI是一种通信协议。
uwsgi是一种线路协议而不是通信协议，在此常用于在uWSGI服务器与其他网络服务器的数据通信。
uWSGI是实现了uwsgi和WSGI两种协议的Web服务器。
2. nginx是一个开源的高性能的HTTP服务器和反向代理：
1.作为web服务器，它处理静态文件和索引文件效果非常高；
2.它的设计非常注重效率，最大支持5万个并发连接，但只占用很少的内存空间；
3.稳定性高，配置简洁；
4.强大的反向代理和负载均衡功能，平衡集群中各个服务器的负载压力应用。首先浏览器发起http请求到nginx服务器，Nginx根据接收到请求包，进行url分析，判断访问的资源类型，如果是静态资源，直接读取静态资源返回给浏览器，如果请求的是动态资源就转交给uwsgi服务器，uwsgi服务器根据自身的uwsgi和WSGI协议，找到对应的Django框架，Django框架下的应用进行逻辑处理后，将返回值发送到uwsgi服务器，然后uwsgi服务器再返回给nginx，最后nginx将返回值返回给浏览器进行渲染显示给用户。 如果可以，画图讲解效果更佳，可以 将下面的图画给面试官。
1.设计表时，尽量少使用外键，因为外键约束会影响插入和删除性能；
2.使用缓存，减少对数据库的访问；
3.在orm框架下设置表时，能用varchar确定字段长度时，就别用text；
4.可以给搜索频率高的字段属性，在定义时创建索引；
5.Django orm框架下的Querysets 本来就有缓存的；
6.如果一个页面需要多次连接数据库，最好一次性取出所有需要的数据，减少对数据库的查询次数；
7.若页面只需要数据库里某一个两个字段时，可以用QuerySet.values()；
8.在模板标签里使用with标签可以缓存Qset的查询结果。Django默认过期时间14天
将验证码保存到数据库或session，设置过期时间为1分钟，然后页面设置一个倒计时 （前端）的展示，一分钟后再次点击获取新的信息
request.session.set_expiry(value)
* 如果value是个整数，session会在些秒数后失效。
* 如果value是个datatime或timedelta，session就会在这个时间后失效。
* 如果value是0,用户关闭浏览器session就会失效。
* 如果value是None,session会依赖全局session失效策略。 A:socket
B:路由分发
C:模板渲染
django
A:用的别人的 wsgiref
B:自己写的
C:自己写的
flask
A:用的被人的 werkzeug
B:自己写的
C:用的别人的 jinja2
tornado
A，B，C都是自己的。追求速度django
优点：大而全，自身携带的组件和功能特别特别多，功能全面；就类似于塔吊机
缺点：大嘛，所以就笨重，需要的不需要的功能都有。当你只需要盖一间房子的时候，你会用到塔吊机嘛？
flask
优点：小而精，源码600多行（分为请求上下文，应用上下文），自身携带的组件和功能特别特别少，但是第三方支持该框架的模块特别特别多，如果你将flask第三方模块全部叠加起来，甚至可以超过django
缺点：常言你的优点就是你的缺点。因此flask受限于第三方模块，版本更新导致不兼容问题比较常见。
tornado
异步非阻塞，天然支持高并发，甚至可以用它来开发游戏服务器。
django：主要是用来搞快速开发的，他的亮点就是快速开发，节约成本，正常的并发量不过10000，如果要实现高并发的话，就要对django进行二次开发，比如把整个笨重的框架给拆掉，自己写socket实现http的通信，底层用纯c，c++写提升效率，ORM框架给干掉，自己编写封装与数据库交互的框架，因为啥呢，ORM虽然面向对象来操作数据库，但是它的效率很低，使用外键来联系表与表之间的查询；
flask：轻量级，主要是用来写接口的一个框架，实现前后端分离，提升开发效率，Flask本身相当于一个内核，其他几乎所有的功能都要用到扩展（邮件扩展Flask-Mail，用户认证Flask-Login），都需要用第三方的扩展来实现。比如可以用Flask-extension加入ORM、窗体验证工具，文件上传、身份验证等。Flask没有默认使用的数据库，你可以选择MySQL，也可以NoSQL。其 WSGI 工具箱采用 Werkzeug（路由模块），模板引擎则使用 Jinja2。这两个也是Flask框架的核心。Python最出名的框架要数Django，此外还有Flask、Tornado等框架。虽然Flask不是最出名的框架，但是Flask应该算是最灵活的框架之一，这也是Flask受到广大开发者喜爱的原因。
Tornado： Tornado是一种 Web 服务器软件的开源版本。Tornado 和现在的主流 Web 服务器框架（包括大多数 Python 的框架）有着明显的区别：它是非阻塞式服务器，而且速度相当快。 得利于其非阻塞的方式和对epoll的运用，Tornado 每秒可以处理数以千计的连接，因此 Tornado 是实时 Web 服务的一个 理想框架。
对一个后端程序员来书，提升性能指标主要有两个：并发量和响应时间
网站的性能优化一般包括：web前端性能优化，应用服务器性能优化，存储服务器优化
对前端的优化主要有：
1、减少http请求，稍稍数据库的访问量，比如使用雪碧图（网站图标）
2、使用浏览器缓存，将一些常用的CSS，JS,logo图标，这些静态资源缓存到本地浏览器，通过设置http头中的cache-control和expires的属性，可设定六拉你去缓存，缓存时间可以自定义
3、对html，CSS,javascript文件进行压缩，减少网络的通信量
对我个人而言，我做的优化主要是以下方面：
1.合理的使用缓存技术，对一些常用到的动态数据，比如首页做一个缓存，或者某些常用的数据做个缓存，设置一定得过期时间，这样减少了对数据库的压力，提升网站性能。
2.使用celery消息队列，将耗时的操作扔到队列里，让worker去监听队列里的任务，实现异步操作，比如发邮件，发短信。
3.就是代码上的一些优化，补充：nginx部署项目也是项目优化，可以配置合适的配置参数，提升效率，增加并发量。
4.如果太多考虑安全因素，服务器磁盘用固态硬盘读写，远远大于机械硬盘，这个技术现在没有普及，主要是固态硬盘技术上还不是完全成熟， 相信以后会大量普及。
5.另外还可以搭建服务器集群，将并发访问请求，分散到多台服务器上处理。
6.最后就是运维工作人员的一些性能优化技术了。近年来移动互联网的发展，前端设备层出不穷（手机、平板、桌面电脑、其他专用设备......），因此，必须有一种统一的机制，方便不同的前端设备与后端进行通信,于是RESTful诞生了，它可以通过一套统一的接口为 Web，iOS和Android提供服务。
URL：统一资源标识符，服务器上每一种资源，比如文档、图像、视频片段、程序 都由一个通用资源标识符进行定位。
常用的HTTP动词有下面五个：
GET（SELECT）：从服务器取出资源（一项或多项）。
POST（CREATE）：在服务器新建一个资源。
PUT（UPDATE）：在服务器更新资源（客户端提供改变后的完整资源）。
PATCH（UPDATE）：在服务器更新资源（客户端提供改变的属性）。
DELETE（DELETE）：从服务器删除资源。
RESTful架构：
1.每个URL代表一种资源
2.客户端和服务端之间，传递这种资源的某种表现层
3.客户端通过四个HTTP动词，对服务器资源进行操作，实现表现层状态转换一、域名：
将api部署在专用域名下：
http://api.example.com
或者将api放在主域名下：
http://www.example.com/api/
二、版本：
将API的版本号放在url中。
http://www.example.com/app/1.0/info
http://www.example.com/app/1.2/info
三、路径：
路径表示API的具体网址。每个网址代表一种资源。 资源作为网址，网址中不能有动词只能有名词，一般名词要与数据库的表名对应。而且名词要使用复数。
错误示例：
http://www.example.com/getGoods
http://www.example.com/listOrders
正确示例：
获取单个商品
http://www.example.com/app/goods/1
获取所有商品
http://www.example.com/app/goods
四、使用标准的HTTP方法：
对于资源的具体操作类型，由HTTP动词表示。 常用的HTTP动词有四个。
GET SELECT ：从服务器获取资源。
POST CREATE ：在服务器新建资源。
PUT UPDATE ：在服务器更新资源。
DELETE DELETE ：从服务器删除资源。
示例：
获取指定商品的信息
GET http://www.example.com/goods/ID
新建商品的信息
POST http://www.example.com/goods
更新指定商品的信息
PUT http://www.example.com/goods/ID
删除指定商品的信息
DELETE http://www.example.com/goods/ID
五、过滤信息：
如果资源数据较多，服务器不能将所有数据一次全部返回给客户端。API应该提供参数，过滤返回结果。 实例：
指定返回数据的数量
http://www.example.com/goods?limit=10
指定返回数据的开始位置
http://www.example.com/goods?offset=10
指定第几页，以及每页数据的数量
http://www.example.com/goods?page=2&per_page=20
六、状态码：
服务器向用户返回的状态码和提示信息，常用的有：
200 OK ：服务器成功返回用户请求的数据
201 CREATED ：用户新建或修改数据成功。
202 Accepted：表示请求已进入后台排队。
400 INVALID REQUEST ：用户发出的请求有错误。
401 Unauthorized ：用户没有权限。
403 Forbidden ：访问被禁止。
404 NOT FOUND ：请求针对的是不存在的记录。
406 Not Acceptable ：用户请求的的格式不正确。
500 INTERNAL SERVER ERROR ：服务器发生错误。
七、错误信息：
一般来说，服务器返回的错误信息，以键值对的形式返回。
Copy
{
error: 'Invalid API KEY'
}
八、响应结果：
针对不同结果，服务器向客户端返回的结果应符合以下规范。
返回商品列表
GET http://www.example.com/goods
返回单个商品
GET http://www.example.com/goods/cup
返回新生成的商品
POST http://www.example.com/goods
返回一个空文档
DELETE http://www.example.com/goods
九、使用链接关联相关的资源：
在返回响应结果时提供链接其他API的方法，使客户端很方便的获取相关联的信息。
十、其他：
服务器返回的数据格式，应该尽量使用JSON，避免使用XML。设置cookie:
def cookie_set(request):
response = HttpResponse("<h1>设置Cookie，请查看响应报文头</h1>")
response.set_cookie('h1', 'hello django')
return response 读取cookie:
def cookie_get(request):
response = HttpResponse("读取Cookie，数据如下：<br>")
if request.COOKIES.has_key('h1'):
response.write('<h1>' + request.COOKIES['h1'] + '</h1>')
return response 以键值对的格式写会话：
request.session['键']=值 根据键读取值：
request.session.get('键',默认值) 清除所有会话，在存储中删除值部分：
request.session.clear() 清除会话数据，在存储中删除会话的整条数据：
request.session.flush() 删除会话中的指定键及值，在存储中只删除某个键及对应的值：
del request.session['键'] 1.设置会话超时时间，如果没有指定容器则14天后过期。
2.如果value是一个整数，会话将在整数秒没有活动后过期。如果活动则重新刷新时间。
3.如果value为0,那么用户会话的cookie将在用户的浏览器关闭时过期。
4.如果value为None,那么会话将在14天后过期。
request.session.set_expiry(value) Session 依赖于 Cookie，如果浏览器不能保存 cookie 那么 session 就失效了。因为它需要浏览器的 cookie 值去 session 里做对比。session就是用来在服务器端保存用户的会话状态。
cookie 可以有过期时间，这样浏览器就知道什么时候可以删除 cookie了。 如果 cookie 没有设置过期时间，当用户关闭浏览器的时候，cookie 就自动过期了。你可以改变 SESSION_EXPIRE_AT_BROWSER_CLOSE 的设置来控制session 框架的这一行为。缺省情况下， SESSION_EXPIRE_AT_BROWSER_CLOSE设置为 False ，这样，会话 cookie 可以在用户浏览器中保持有效达SESSION_COOKIE_AGE 秒（缺省设置是两周，即 1，209，600 秒）如果你不想用户每次打开浏览器都必须重新登陆的话，用这个参数来帮你。如果SESSION_EXPIRE_AT_BROWSER_CLOSE
设置为 True，当浏览器关闭时，Django 会使 cookie 失效。
SESSION_COOKIE_AGE：设置 cookie 在浏览器中存活的时间。
Django提供6种缓存方式:
开发调试
内存
文件
数据库
Memcache缓存(python-memcached模块)
Memcache缓存(pylibmc模块)
除此之外还可使用redis缓存
由于Django是动态网站，所有每次请求均会去数据进行相应的操作，当程序访问量大时，耗时必然会更加明显，
最简单解决方式是使用：缓存，缓存将一个某个views的返回值保存至内存或者memcache中，5分钟内(默认配置)再有人来访问时，
则不再去执行view中的操作，而是直接从内存或者Redis中之前缓存的内容拿到，并返回。
这里可以向面试官介绍一下前面提到的Django中间件配合缓存协同工作的机制
首先需要搞清楚的是session是存储在服务器上的，cookie是存储在客户端浏览器上的两者是相辅相成的用户首次访问服务器，服务器会为每个用户单独创建一个session对象(HttpSession)，
并为每个session分配唯一一个id(sessionId)，sessionId通过cookie保存到用户端，当用户再次访问服务器时，需将对应的sessionId携带给服务器，服务器通过这个唯一sessionId就可以找到用户对应的session对象，从而达到管理用户状态
1) 输入参数
get 的参数只能是model中定义的那些字段，只支持严格匹配。
filter的参数可以是字段，也可以是扩展的 where查询关键字，如 in，like 等。
2) 返回值
get返回值是一个定义的 model 对象。
filter返回值是一个新的 QuerySet 对象，然后可以对 QuerySet 在进行查询返回新的 QuerySet 对象，支持链式操作，QuerySet 一个集合对象，可使用迭代或者遍历，切片等，但是不等于 list 类型(使用一定要注意)。
3) 异常
get只有一条记录返回的时候才正常，也就说明 get 的查询字段必须是主键或者唯一约束的字段。当返回多条记录或者是没有找到记录的时候都会抛出异常。 filter 有没有匹配的记录返回空
排序使用order_by()
降序需要在排序字段名前加‘-‘负号
查询字段大于某个值：使用filter(字段名_gt=值)
更多操作：
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") # 获取name字段包含"ven"的
models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感
models.Tb1.objects.filter(id__range=[1, 3]) # id范围是1到3的，等价于SQL的bettwen and
类似的还有：startswith，istartswith, endswith, iendswith
date字段还可以：
models.Class.objects.filter(first_day__year=2017)python manage.py makemigrations
python manage.py migrate uWSGI是一个 Web 服务器，它实现了WSGI 协议、uwsgi、http 等协议。注意 uwsgi 是一种通信协议，而 uWSGI 是实现 uwsgi 协议和 WSGI 协议的Web 服务器。uWSGI 具有超快的性能、低内存占用和多app 管理等优点，并且搭配着 Nginx就是一个生产环境了，能够将用户访问请求与应用 app 隔离开，实现真正的部署。相比来讲，支持的并发量更高，方便管理多进程，发挥多核的优势，提升性能。
公司开始把代码从GitHub上迁移到GitLab上，在使用一段时间过后，发现GitLab与GitHub还是有不少区别的。
先说一下相同点，二者都是基于web的Git仓库，在很大程度上GitLab是仿照GitHub来做的，它们都提供了分享开源项目的平台，为开发团队提供了存储、分享、发布和合作开发项目的中心化云存储的场所。
GitHub作为开源代码库及版本控制系统，拥有超过900万的开发者用户，目前仍然是最火的开源项目托管系统。GitHub同时提供公共仓库和私有仓库，但如果要使用私有仓库，是需要付费的。
而GitLab解决了这个问题，你可以在上面创建私人的免费仓库。
GitLab让开发团队对他们的代码仓库拥有更多的控制，相比于GitHub，它有不少的特色：
允许免费设置仓库权限；允许用户选择分享一个project的部分代码；允许用户设置project的获取权限，进一步的提升安全性；可以设置获取到团队整体的改进进度；通过innersourcing让不在权限范围内的人访问不到该资源。
从代码私有性方面来看，有时公司并不希望员工获取到全部的代码，这个时候GitLab无疑是更好的选择。但对于开源项目而言，GitHub依然是代码托管的首选。
公司开始把代码从GitHub上迁移到GitLab上，在使用一段时间过后，发现GitLab与GitHub还是有不少区别的。
HttpRequest是django接受用户发送多来的请求报文后，将报文封装到HttpRequest对象中去。
HttpResponse 返回的是一个应答的数据报文。render内部已经封装好了HttpResponse类。
视图的第一个参数必须是HttpRequest对象，两点原因：表面上说，他是处理web请求的，所以必须是请求对象，根本上说，他是基于请求的一种web框架，所以，必须是请求对象。 因为view处理的是一个request对象，请求的所有属性我们都可以根据对象属性的查看方法来获取具体的信息：格式：request.属性
request.path 请求页面的路径，不包含域名
request.get_full_path 获取带参数的路径
request.method 页面的请求方式
request.GET GET 请求方式的数据
request.POST POST请求方式的数据
request.COOKIES 获取cookie
request.session 获取session
request.FILES 上传图片（请求页面有enctype="multipart/form-data"属性时FILES才有数据)
反向解析
通过一些方法 能够得到一个结果 该结果可以访问到对应的url
使用方式
先给路由与视图函数对应关系 起一个名字
url(r'^testadd/',views.testadd,name='add')
前端解析
{% url 'add' %}
后端解析
from django.shortcuts import render,HttpResponse,redirect,reverse
reverse('add')GET 请求指定的页面信息，并返回实体主体。
HEAD 类似于get请求，只不过返回的响应中没有具体的内容，用于获取报头
POST 向指定资源提交数据进行处理请求（例如提交表单或者上传文件）。数据被包含在请求体中。POST请求可能会导致新的资源的建立和/或已有资源的修改。
PUT 从客户端向服务器传送的数据取代指定的文档的内容。
DELETE 请求服务器删除指定的页面。
CONNECT HTTP/1.1协议中预留给能够将连接改为管道方式的代理服务器。
OPTIONS 允许客户端查看服务器的性能。
TRACE 回显服务器收到的请求，主要用于测试或诊断。状态代码有三位数字组成，第一个数字定义了响应的类别，共分五种类别:
1xx：指示信息--表示请求已接收，继续处理
2xx：成功--表示请求已被成功接收、理解、接受
3xx：重定向--要完成请求必须进行更进一步的操作
4xx：客户端错误--请求有语法错误或请求无法实现
5xx：服务器端错误--服务器未能实现合法的请求
常见状态码：
200 OK //客户端请求成功
400 Bad Request //客户端请求有语法错误，不能被服务器所理解
401 Unauthorized //请求未经授权，这个状态代码必须和WWW-Authenticate报头域一起使用
403 Forbidden //服务器收到请求，但是拒绝提供服务
404 Not Found //请求资源不存在，eg：输入了错误的URL
500 Internal Server Error //服务器发生不可预期的错误
503 Server Unavailable //服务器当前不能处理客户端的请求，一段时间后可能恢复正常
更多状态码http://www.runoob.com/http/http-status-codes.htmlhttp：的中文叫做超文本传输协议,它负责完成客户端到服务端的一系列操作,是专门用来传输注入HTML的超媒体文档等web内容的协议,它是基于传输层的TCP协议的应用层协议
https:https是基于安全套接字的http协议,也可以理解为是http+ssl/tls(数字证书)的组合
http和https的区别:
https传输的数据是加密的，http传输的数据是明文的
HTTP 的 URL 以 http:// 开头，而 HTTPS 的 URL 以 https:// 开头
HTTP 是不安全的，而 HTTPS 是安全的
HTTP 标准端口是 80 ，而 HTTPS 的标准端口是 443
在 OSI 网络模型中，HTTPS的加密是在传输层完成的,因为SSL是位于传输层的,TLS的前身是SSL,所以同理
HTTP无需认证证书,而https需要认证证书 websocket是一种在单个TCP连接上进行全双工通讯的协议，双工（duplex）是指两台通讯设备之间，允许有双向的资料传输。全双工的是指，允许两台设备间同时进行双向资料传输。这是相对于半双工来说的，半双工不能同时进行双向传输，这期间的区别相当于手机和对讲机的区别，手机在讲话的同时也能听到对方说话，对讲机只能一个说完另一个才能说。dango实现websocket达式有两种方式，一种channels,一种是dwebsocket。
channels依赖与redis，twisted等，相比之下使用dwebsocket更方便
安装
# pip install dwebsocket
配置：
# setting.py
INSTALLED_APPS = [
.....
.....
'dwebsocket',
]
MIDDLEWARE_CLASSES = [
......
......
'dwebsocket.middleware.WebSocketMiddleware' # 为所有的URL提供websocket，如果只是单独的视图需要可以不选
]
WEBSOCKET_ACCEPT_ALL=True # 可以允许每一个单独的视图实用websockets
简单使用：
模拟文件下载的简单示例
from dwebsocket.decorators import accept_websocket
@accept_websocket
def test(request):
if not request.is_websocket(): # 判断是不是websocket连接
return render(request, 'websocket.html')
else:
download = Haproxy()
t = threading.Thread(target=download.run)
t.start()
sent = []
while download.status:
if len(download.res_dict) > len(sent):
for i in download.res_dict.keys():
if i not in sent:
sent.append(i)
request.websocket.send(str(sent[-1]+str(download.res_dict[sent[-1]])).encode('utf-8')) # 发送消息到客户端
if not download.status:
request.websocket.send('下载完成'.encode('utf-8'))dwebsocket有两种装饰器：require_websocket和accept_websocekt，使用require_websocket装饰器会导致视图函数无法接收导致正常的http请求，一般情况使用accept_websocket方式就可以了，
dwebsocket的一些内置方法：
request.is_websocket（）：判断请求是否是websocket方式，是返回true，否则返回false
request.websocket： 当请求为websocket的时候，会在request中增加一个websocket属性，
WebSocket.wait（） 返回客户端发送的一条消息，没有收到消息则会导致阻塞
WebSocket.read（） 和wait一样可以接受返回的消息，只是这种是非阻塞的，没有消息返回None
WebSocket.count_messages（）返回消息的数量
WebSocket.has_messages（）返回是否有新的消息过来
WebSocket.send（message）像客户端发送消息，message为byte类型
WSGI的全称是Web Server Gateway Interface，翻译过来就是Web服务器网关接口。具体的来说，WSGI是一个规范，定义了Web服务器如何与Python应用程序进行交互，使得使用Python写的Web应用程序可以和Web服务器对接起来。.Admin是对model中对应的数据表进行增删改查提供的组件
.model组件：负责操作数据库
.form组件：1.生成HTML代码2.数据有效性校验3校验信息返回并展示
.ModelForm组件即用于数据库操作,也可用于用户请求的验证 SlugField本质上相当于存放字符串，但在意义上，主要用于把某些字段形成语义化的，可以访问的短网址form.is_valid()
内部机制：看seld.errors中是否值，只要有值就是flaseselect * from company where title like "%abc%" or mecount>999 order by createtime desc;
差不多：
from django.db.models import Q
(models.company.objects.filter(Q(title="%abc%") | Q(Q(mecount__gt=999)))as 'aa').order_by('-aa')排序使用order_by()
降序需要在排序字段名前加-
查询字段大于某个值：使用filter(字段名_gt=值)安装：
首先要在django运行环境中安装：python-memcached（命令：pip install python-memcached）
1）在Django的settings中设置缓存
CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
'LOCATION': ,'127.0.0.1:11211', # 可以为远程地址和端口，可以设置多个ip
'TIMEOUT': 86400, # 1 day,设置成0缓存将失效
'OPTIONS': {
'MAX_ENTRIES': 1000, # 高速缓存允许的最大条目数，超出这个数则旧值将被删除. 这个参数默认是300.
'CULL_FREQUENCY': 3, # 当达到MAX_ENTRIES 的时候,被删除的条目比率。 实际比率是 1 / CULL_FREQUENCY，默认是3
}
}
}
2）业务逻辑
#coding=utf-8
def key_hash(value):
"""hash缓存key，防止过长"""
import hashlib
return '%s' % hashlib.md5(value).hexdigest()
def cache(num1, num2):
"""
:param num1: 获取或者设置cache的标识
:param num2：获取或者设置cache的标识
:return: 缓存dict
"""
from django.core.cache import cache
import logging
log = logging.getLogger(__name__) # 日志
# 去重并排序，增加缓存命中率
cache_key = 'num1={num1}&num2={num2}'.format(num1=num1, num2=num2)
cache_key = key_hash(cache_key)
# in cache, return cache
if cache.get(cache_key):
log.debug('cache %s hitting ' % cache_key)
return cache.get(cache_key)
# not in cache, get result and set cache
ret = None
# TODO do something get result
ret = 'something'
cache.set(cache_key, ret, 60 * 60 * 24) # 一天过期
return ret1.浏览器向DNS服务器发出解析域名的请求；
2.DNS服务器将"www.baidu.com"域名解析为对应的IP地址，并返回给浏览器；
3.浏览器与百度服务器进行三次握手，建立TCP连接；
4.浏览器发出HTTP请求报文；
5.服务器回复HTTP响应报文；
6.浏览器解析响应报文，渲染HTML内容，并显示在页面上；
7.收发报文结束，释放TCP连接，执行四次挥手。利用Django的Model的Siggnal Dispatcher，通过django.db.models.signals.pre_save()方法，在时间发生前，发射触发信号，这一切都被调度中的receiver方法保存了
信号处理一般都在model中，比如：
import logging
from django.db import models
from django.db.models.signals import pre_save
from django.dispatch import receiver
class Order(models.Model):
logger = logging.getLogger(__name__)
@receiver(pre_save, sender=Order)
def pre_save_handler(sender, **kwargs):
logger.debug("{},{}".format(sender, **kwargs))`class WSGIHandler(base.BaseHandler):`
`-------request = self.request_class(environ)`
请求走到WSGIHandler类的时候，执行**cell**方法，将environ封装成了request Django中可以定义的5个方法：
.process_request : 请求进来时,权限认证
.process_view : 路由匹配之后,能够得到视图函数
.process_exception : 异常时执行
.process_template_responseprocess : 模板渲染时执行
.process_response : 请求有响应时执行FBV：基于函数的视图
CBV：基于类的视图
CBV：源码内部默认8个请求方式，根据当前请求方式自动匹配要执行对应的请求代码。
优点：1.提高代码的复用性，可以使用面向对象的技术
2.可以用不同的函数针对不同的HTTP方法处理，而不是通过很多if判断，提高代码的可读性
# CBV路由配置
url(r'^login/',views.MyLogin.as_view()),
同样写在views.py中
from django.views import View
class MyLogin(View):
def get(self,request):
return render(request,'login.html') //写功能
def post(self,request):
return HttpResponse('我是类里面的post方法') /写功能1.在指定函数头上装
@method_decorator(csrf_protect) # 第一种方式
def post(self,request):
return HttpResponse('post')2.在类名头上指名道姓给某个方法装
@method_decorator(csrf_protect,name='post')
class MyHome(View):
def dispatch(self, request, *args, **kwargs):
return super().dispatch(request,*args,**kwargs)
def post(self,request):
return HttpResponse('post')
def get(self,request):
return HttpResponse('get')3.类中所有方法都装
class MyHome(View):
@method_decorator(csrf_protect) # 第三种 类中所有的方法都装
def dispatch(self, request, *args, **kwargs):
return super().dispatch(request,*args,**kwargs)
def post(self,request):
return HttpResponse('post')
def get(self,request):
return HttpResponse('get')在配置文件中增加slave数据库的配置
在Django的配置文件setting.py中，DATABASES中添加代码如下：
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'HOST': '127.0.0.1', # 主服务器的运行ip
'PORT': 3306, # 主服务器的运行port
'USER': 'django', # 主服务器的用户名
'PASSWORD': 'django', # 主服务器的密码
'NAME': 'djangobase' # 数据表名
},
'slave': {
'ENGINE': 'django.db.backends.mysql',
'HOST': '127.0.0.1',
'PORT': 8306,
'USER': 'django_slave',
'PASSWORD': 'django_slave',
'NAME': 'djangobase_slave'
}
} 创建数据库操作的路由分类
在项目的urls中创建db_router.py文件，并在该文件中定义袷db类，用来进行读写分离：
class MasterSlaveDBRouter(object):
"""数据库主从读写分离路由"""
def db_for_read(self, model, **hints):
"""读数据库"""
return "slave"
def db_for_write(self, model, **hints):
"""写数据库"""
return "default"
def allow_relation(self, obj1, obj2, **hints):
"""是否运行关联操作"""
return True 配置读写分离路由
在配置文件setting.py中添加：
#配置读写分离
DATABASE_ROUTERS = ['项目名.utils.db_router."自定义的类名称"']# QuerySet对象的所有方法
<1> all(): 查询所有结果
<2> filter(**kwargs): 它包含了与所给筛选条件相匹配的对象。获取不到返回None
<3> get(**kwargs): 返回与所给筛选条件相匹配的对象，返回结果有且只有一个。
如果符合筛选条件的对象超过一个或者没有都会抛出错误。
<4> exclude(**kwargs): 它包含了与所给筛选条件不匹配的对象
<5> order_by(*field): 对查询结果排序
<6> reverse(): 对查询结果反向排序
<8> count(): 返回数据库中匹配查询(QuerySet)的对象数量。
<9> first(): 返回第一条记录
<10> last(): 返回最后一条记录
<11> exists(): 如果QuerySet包含数据，就返回True，否则返回False
<12> values(*field): 返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的
并不是一系 model的实例化对象，而是一个可迭代的字典序列
<13> values_list(*field): 它与values()非常相似，它返回的是一个元组序列，values返回的是一个字典序列
<14> distinct(): 从返回结果中剔除重复纪录简而言之：F()查询可以动态获取表字段对应的值
使用方法：
from django.db.models import F,Q
# 1.查询库存数大于卖出数的书籍
res = models.Book.objects.filter(kucun__gt=F('maichu'))
print(res)
# 2.将所有书的价格提高100
res = models.Book.objects.update(price=F('price') + 100)Q查询：进阶更复杂的条件筛选
','逗号隔开是and关系
'|'管道符是or的关系
'~'是not关系
'gt':大于
'lt':小于
filter() 等方法中的关键字参数查询都是一起进行“AND” 的。 如果你需要执行更复杂的查询（例如OR语句），你可以使用Q对象。1.使用execute执行自定义的SQL
直接执行SQL语句（类似于pymysql的用法）
# 更高灵活度的方式执行原生SQL语句
from django.db import connection
cursor = connection.cursor()
cursor.execute("SELECT DATE_FORMAT(create_time, '%Y-%m') FROM blog_article;")
ret = cursor.fetchall()
print(ret)
2.使用extra方法 ：queryset.extra(select={"key": "原生的SQL语句"})
3.使用raw方法
1.执行原始sql并返回模型
2.依赖model多用于查询互为相反，查询数据时走数据库的次数
defer('id','name'):取出对象，字段除了id和name都有
only('id','name'):取的对象，只有id和name前提：有外键存在时，可以很好的减少数据库请求的次数,提高性能
select_related通过多表join关联查询,一次性获得所有数据,只执行一次SQL查询，耗时在join连表上
prefetch_related分别查询每个表,然后根据它们之间的关系进行处理,执行两次查询，耗时在查询次数上标签：ini 名称 note migration channels 相同 门户 erro 服务器
原文地址：https://www.cnblogs.com/guyouyin123/p/12291587.html
