Python：Django面试题

 Q：Django创建项目的命令

django-adminstartproject项目名称

pythonmanage.pystartapp应用app名

Q：Django创建项目后，项目文件夹下的组成部分

manage.py：项目运行的入口，指定配置文件路径。与项目同名的目录，包含项目的配置文件。

init.py：是一个空文件，作用是这个目录可以被当作包使用。

settings.py：项目的整体配置文件。

urls.py：是项目的URL配置文件。

wsgi.py：是项目与WSGI兼容的Web服务器。

Q：对MVC,MVT解读的理解

MVC:

M：Model，模型，和数据库进行交互

V：View，视图，负责产生Html页面

C：Controller，控制器，接收请求，进行处理，与M和V进行交互，返回应答。

列举用户注册流程：

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页面进行解析展示。

MVT:

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页面内容进行解析，展示。

Q：Django中models利用ORM对Mysql 进行查表的语句

A：关于查询：Django框架 ：数据库基础操作_mengnf的专栏-CSDN博客

基本查询

get：返回表格中满足条件的一条数据，如果查到多条数据，则抛异常：MultipleObjectsReturned， 查询不到数据，则抛异常：DoesNotExist。

all：查询多个结果，返回模型类对应表格中的所有数据。

count：查询结果数量。

filter()：参数写查询条件，返回满足条件 QuerySet 集合数据。

条件格式：**模型类属性名** 条件名=值

注意：此处是模型类属性名，不是表中的字段名

过滤查询

实现SQL中的where功能，包括

filter：过滤出多个结果
exclude：排除掉符合条件剩下的结果
get：过滤单一结果

对于过滤条件的使用，上述三个方法相同，故仅以filter进行讲解。

过滤条件的表达语法如下：

属性名称__比较运算符=值

# 属性名称和比较运算符间使用两个下划线，所以属性名不能包括多个下划线
1）相等

exact：表示判等。

例：查询编号为1的图书。

BookInfo.objects.filter(id__exact=1)
可简写为：
BookInfo.objects.filter(id=1)

2）模糊查询

contains：是否包含。

说明：如果要包含%无需转义，直接写即可。

例：查询书名包含'传'的图书。

BookInfo.objects.filter(name__contains='传')
]>

startswith、endswith：以指定值开头或结尾。

例：查询书名以'部'结尾的图书

>>> BookInfo.objects.filter(name__endswith='部')
]>
以上运算符都区分大小写，在这些运算符前加上i表示不区分大小写，如iexact、icontains、istartswith、iendswith.

3） 空查询

isnull：是否为null。

例：查询书名为空的图书。

>>> BookInfo.objects.filter(name__isnull=True)

4） 范围查询

in：是否包含在范围内。

例：查询编号为1或3或5的图书

>>> BookInfo.objects.filter(id__in=[1,3，5])
, ]>
5）比较查询

gt大于 (greater then)
gte大于等于 (greater then equal)
lt小于 (less then)
lte小于等于 (less then equal)
例：查询编号大于3的图书

BookInfo.objects.filter(id__gt=3)
不等于的运算符，使用exclude()过滤器。

例：查询编号不等于3的图书

>>> BookInfo.objects.filter(id__gt=3)
]>
6）日期查询

year、month、day、week_day、hour、minute、second：对日期时间类型的属性进行运算。

例：查询1980年发表的图书。

>>> BookInfo.objects.filter(pub_date__year=1980)
]>
例：查询1990年1月1日后发表的图书。

>>> BookInfo.objects.filter(pub_date__gt='1990-1-1')
]>
三、F和Q对象
1.F对象
之前的查询都是对象的属性与常量值比较，两个属性怎么比较呢？ 答：使用F对象，被定义在django.db.models中。

语法如下：

F(属性名)
例：查询阅读量大于等于评论量的图书。

>>> from django.db.models import F
>>> BookInfo.objects.filter(readcount__gt=F('commentcount'))
]>
可以在F对象上使用算数运算。

例：查询阅读量大于2倍评论量的图书。

>>> BookInfo.objects.filter(readcount__gt=F('commentcount')*2)
]>
2.Q对象
多个过滤器逐个调用表示逻辑与关系，同sql语句中where部分的and关键字。

例：查询阅读量大于20，并且编号小于3的图书。

>>> BookInfo.objects.filter(readcount__gt=20,id__lt=3)
]>
 
或者
 
>>> BookInfo.objects.filter(readcount__gt=20).filter(id__lt=3)
]>
如果需要实现逻辑或or的查询，需要使用Q()对象结合|运算符，Q对象被义在django.db.models中。

语法如下：

Q(属性名__运算符=值)
例：查询阅读量大于20的图书，改写为Q对象如下。

BookInfo.objects.filter(Q(readcount__gt=20))
Q对象可以使用&、|连接，&表示逻辑与，|表示逻辑或。

例：查询阅读量大于20，或编号小于3的图书，只能使用Q对象实现

>>> BookInfo.objects.filter(Q(readcount__gt=20)|Q(id__lt=3))
, , ]>
Q对象前可以使用~操作符，表示非not。

例：查询编号不等于3的图书。

>>> BookInfo.objects.filter(~Q(id=3))
, , ]>

Q：django 中间件的使用

A：Django在中间件中预置了六个方法，这六个方法的区别在于不同的阶段执行，对输入或输出进行干预，方法如下：

1. 初始化：无需任何参数，服务器响应第一个请求的时候调用一次，用于确定是否启用当前中间件。

def init():

pass

2. 处理请求前：在每个请求上调用，返回None或HttpResponse对象。

def process_request(request):

pass

3. 处理视图前：在每个请求上调用，返回None或HttpResponse对象。

def process_view(request,view_func,view_args,view_kwargs):

pass

4. 处理模板响应前：在每个请求上调用，返回实现了render方法的响应对象。

def process_template_response(request,response):

pass

5. 处理响应后：所有响应返回浏览器之前被调用，在每个请求上调用，返回HttpResponse对象。

def process_response(request,response):

pass

6. 异常处理：当视图抛出异常时调用，在每个请求上调用，返回一个HttpResponse对象。

def process_exception(request,exception):

pass

Q：谈一下你对 uWSGI 和 nginx 的理解？

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.强大的反向代理和负载均衡功能，平衡集群中各个服务器的负载压力应用。

Q：django 开发中数据库做过什么优化

1）设计表时，尽量少使用外键，因为外键约束会影响插入和删除性能；

2）使用缓存，减少对数据库的访问；                                                                      

3）在 orm 框架下设置表时，能用 varchar 确定字段长度时，就别用 text；

4）可以给搜索频率高的字段属性，在定义时创建索引；

5）Django orm 框架下的 Querysets 本来就有缓存的；

6）如果一个页面需要多次连接数据库，最好一次性取出所有需要的数据，减少对数据库的查询次数；

7）若页面只需要数据库里某一个两个字段时，可以用 QuerySet.values()；

8）在模板标签里使用 with 标签可以缓存 Qset 的查询结果。

Q：验证码过期时间怎么设置

将验证码保存到数据库或 session，设置过期时间为 1 分钟，然后页面设置一个倒计时(一般是前端js 实现这个计时)的展示，一分钟过后再次点击获取新的信息。

Q：Python 中三大框架各自的应用场景

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 服务的一个 理想框架。

Q：django 如何提升性能（高并发）

对一个后端开发程序员来说，提升性能指标主要有两个一个是并发数，另一个是响应时间网站性能的优化一般包括 web 前端性能优化，应用服务器性能优化，存储服务器优化。

对前端的优化主要有：

1）减少 http 请求，减少数据库的访问量，比如使用雪碧图。

2）使用浏览器缓存，将一些常用的 css，js，logo 图标，这些静态资源缓存到本地浏览器，通过设置 http 头中的 cache-control 和 expires 的属性，可设定浏览器缓存，缓存时间可以自定义。

3）对 html，css，javascript 文件进行压缩，减少网络的通信量。

对我个人而言，我做的优化主要是以下三个方面：

1）合理的使用缓存技术，对一些常用到的动态数据，比如首页做一个缓存，或者某些常用的数据做个缓存，设置一定得过期时间，这样减少了对数据库的压力，提升网站性能。

2）使用 celery 消息队列，将耗时的操作扔到队列里，让 worker 去监听队列里的任务，实现异步操作，比如发邮件，发短信。

3）就是代码上的一些优化，补充：nginx 部署项目也是项目优化，可以配置合适的配置参数，提升效率，增加并发量。

4）如果太多考虑安全因素，服务器磁盘用固态硬盘读写，远远大于机械硬盘，这个技术现在没有普及，主要是固态硬盘技术上还不是完全成熟， 相信以后会大量普及。

5）另外还可以搭建服务器集群，将并发访问请求，分散到多台服务器上处理。

6）最后就是运维工作人员的一些性能优化技术了。

Q：什么是 restful api，谈谈你的理解

REST:Representational State Transfer 的缩写，翻译：“具象状态传输”。一般解释为“表现层状态转换”。

REST 是设计风格而不是标准。是指客户端和服务器的交互形式。我们需要关注的重点是如何设计

REST 风格的网络接口。

REST 的特点：

（1）具象的。一般指表现层，要表现的对象就是资源。比如，客户端访问服务器，获取的数据就是资源。比如文字、图片、音视频等。

（2）表现：资源的表现形式。txt 格式、html 格式、json 格式、jpg 格式等。浏览器通过 URL 确定资源的位置，但是需要在 HTTP 请求头中，用 Accept 和 Content-Type 字段指定，这两个字段是对资源表现的描述。

（3）状态转换：客户端和服务器交互的过程。在这个过程中，一定会有数据和状态的转化，这种转化叫做状态转换。其中，GET 表示获取资源，POST 表示新建资源，PUT 表示更新资源，DELETE 表示删除资源。HTTP 协议中最常用的就是这四种操作方式。

RESTful 架构：

（1）每个 URL 代表一种资源；

（2）客户端和服务器之间，传递这种资源的某种表现层；

（3）客户端通过四个 http 动词，对服务器资源进行操作，实现表现层状态转换。

Q：什么 是csrf 攻击原理？如何解决？

简单来说就是: 你访问了信任网站 A，然后 A 会用保存你的个人信息并返回给你的浏览器一个cookie，然后呢，在 cookie 的过期时间之内，你去访问了恶意网站 B，它给你返回一些恶意请求代码， 要求你去访问网站 A，而你的浏览器在收到这个恶意请求之后，在你不知情的情况下，会带上保存在本地浏览器的 cookie 信息去访问网站 A，然后网站 A 误以为是用户本身的操作，导致来自恶意网站 C 的攻击代码会被执：发邮件，发消息，修改你的密码，购物，转账，偷窥你的个人信息，导致私人信息泄漏和账户财产安全收到威胁。

解决：如短信验证、添加一个隐藏的csrf_token字段

专题延伸：Python 10.5.1 Django框架 ：CSRF_mengnf的专栏-CSDN博客

Q：启动 Django 服务的方法

runserver 方法是调试 Django 时经常用到的运行方式，它使用  Django  自带的 WSGI Server  运行，主要在测试和开发中使用，并且 runserver 开启的方式也是单进程。

python manage.py runserver ip:端口

Q：有过部署经验？用的什么技术？

1. 有部署经验，在阿里云服务器上部署的 

2. 技术有：nginx + uwsgi 的方式来部署 Django 项目

Q：Django 中哪里用到了线程?哪里用到了协程?哪里用到了进程？

Django中耗时的任务用一个进程或者线程来执行，比如发邮件，使用 celery。

部署 django 项目的时候，配置文件中设置了进程和协程的相关配置。

Q：对 cookie与session 的了解？他们能单独用吗

Session 采用的是在服务器端保持状态的方案，而 Cookie 采用的是在客户端保持状态的方案。但是禁用 Cookie 就不能得到 Session。因为 Session  是用  Session ID  来确定当前对话所对应的服务器 Session，而 Session ID 是通过  Cookie  来传递的，禁用  Cookie  相当于失去了  SessionID，也就得不到 Session。

Q：django关闭浏览器，怎样清除 cookies 和 session

设 置 Cookie:

def cookie_set():

response = HttpResponse("

设置 Cookie，请查看响应报文头

")

response.set_cookie('h1', 'hello django')

读 取 Cookie:

def cookie_get(request):

response = HttpResponse("读取 Cookie，数据如下：
")

if request.COOKIES.has_key('h1'):

response.write('

' + request.COOKIES['h1'] + '

')

以键值对的格式写会话:

request.session['键']=值

根据键读取值:

request.session.get('键',默认值)

清除所有会话，在存储中删除值部分:

request.session.clear()

清除会话数据，在存储中删除会话的整条数据:

request.session.flush()

删除会话中的指定键及值，在存储中只删除某个键及对应的值:

del request.session['键']

设置会话的超时时间，如果没有指定过期时间则两个星期后过期。

request.session.set_expiry(value)

如果 value 是一个整数，会话将在 value 秒没有活动后过期。

如果 value 为 0，那么用户会话的 Cookie 将在用户的浏览器关闭时过期。如果 value 为 None，那么会话永不过期。

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 在浏览器中存活的时间。

Q：代码优化从哪些方面考虑？有什么想法

（1）优化算法时间

算法的时间复杂度对程序的执行效率影响最大，在 Python 中可以通过选择合适的数据结构来优化时间复杂度，如 list 和 set 查找某一个元素的时间复杂度分别是  O(n)和  O(1)。不同的场景有不同的优化方式，总得来说，一般有分治，分支界限，贪心，动态规划等思想。

（2）循环优化

每种编程语言都会强调需要优化循环。当使用 Python 的时候，你可以依靠大量的技巧使得循环运行得更快。然而，开发者经常漏掉的一个方法是：

避免在一个循环中使用点操作。每一次你调用方法 str.upper，Python 都会求该方法的值。然而， 如果你用一个变量代替求得的值，值就变成了已知的，Python 就可以更快地执行任务。优化循环的关键，是要减少  Python  在循环内部执行的工作量，因为 Python  原生的解释器在那种情况下，真的会减缓执行的速度。（注意：优化循环的方法有很多，这只是其中的一个。例如，许多程序员都会说，列表推导是在循环中提高执行速度的最好方式。这里的关键是，优化循环是程序取得更高的执行速度的更好方式之一。）

（3）函数选择

在循环的时候使用 xrange 而不是 range；使用 xrange 可以节省大量的系统内存，因为  xrange() 在序列中每次调用只产生一个整数元素。而 range()將直接返回完整的元素列表，用于循环时会有不必要的开销。在 python3 中 xrange 不再存在，里面 range 提供一个可以遍历任意长度的范围的iterator。

（4）并行编程

因为 GIL 的存在，Python 很难充分利用多核 CPU 的优势。但是，可以通过内置的模块multiprocessing 实现下面几种并行模式：

多进程：对于 CPU 密集型的程序，可以使用 multiprocessing 的 Process，Pool 等封装好的类， 通过多进程的方式实现并行计算。但是因为进程中的通信成本比较大，对于进程之间需要大量数据交互的程序效率未必有大的提高。

多线程：对于 IO 密集型的程序，multiprocessing.dummy 模块使用 multiprocessing  的接口封装 threading，使得多线程编程也变得非常轻松(比如可以使用 Pool 的 map 接口，简洁高效)。

分布式：multiprocessing 中的 Managers 类提供了可以在不同进程之共享数据的方式，可以在此基础上开发出分布式的程序。

不同的业务场景可以选择其中的一种或几种的组合实现程序性能的优化。

（5）使用性能分析工具

除了上面在 ipython 使用到的 timeit 模块，还有 cProfile。cProfile 的使用方式也非常简单： python-mcProfilefilename.py，filename.py 是要运行程序的文件名，可以在标准输出中看到每一个函数被调用的次数和运行的时间，从而找到程序的性能瓶颈，然后可以有针对性地优化。

（6）set 的用法

set 的 union，intersection，difference 操作要比  list  的迭代要快。因此如果涉及到求  list  交集，并集或者差的问题可以转换为 set 来操作。

（7）PyPy

PyPy 是用 RPython(CPython  的子集)实现的 Python，根据官网的基准测试数据，它比  CPython 实现的 Python 要快  6  倍以上。快的原因是使用了 Just-in-Time(JIT)编译器，即动态编译器，与静态编译器(如 gcc，javac 等)不同，它是利用程序运行的过程的数据进行优化。由于历史原因，目前  pypy 中还保留着 GIL，不过正在进行的 STM 项目试图将 PyPy 变成没有 GIL 的 Python。如果 python 程序中含有  C  扩展(非  cffi  的方式)，JIT  的优化效果会大打折扣，甚至比  CPython 慢（比  Numpy）。所以在 PyPy 中最好用纯 Python 或使用 cffi 扩展。

Q：请简述浏览器是如何获取一枚网页的

（1）在用户输入目的 URL 后，浏览器先向 DNS 服务器发起域名解析请求；

（2）在获取了对应的 IP 后向服务器发送请求数据包；

（3）服务器接收到请求数据后查询服务器上对应的页面，并将找到的页面代码回复给客户端；

（4）客户端接收到页面源代码后，检查页面代码中引用的其他资源，并再次向服务器请求该资源；

（5）在资源接收完成后，客户端浏览器按照页面代码将页面渲染输出显示在显示器上；

Q：Django HTTP 请求的处理流程

Django 和其他 Web 框架的 HTTP 处理的流程大致相同，Django 处理一个  Request 的过程是首先通过中间件，然后再通过默认的 URL 方式进行的。我们可以在 Middleware 这个地方把所有

Request 拦截住，用我们自己的方式完成处理以后直接返回 Response。

（1）加载配置

Django  的配置都在  “Project/settings.py”  中定义，可以是 Django 的配置，也可以是自定义的配置，并且都通过 django.conf.settings 访问，非常方便。

（2）启动

最核心动作的是通过 django.core.management.commands.runfcgi 的 Command 来启动， 它运行 django.core.servers.fastcgi 中的  runfastcgi，runfastcgi  使用了  flup  的 WSGIServer来启动 fastcgi 。而 WSGIServer  中携带了  django.core.handlers.wsgi  的  WSGIHandler  类的一个实例，通过 WSGIHandler 来处理由 Web 服务器（比如  Apache，Lighttpd  等）传过来的请求，此时才是真正进入 Django 的世界。

（3）处 理 Request

当有 HTTP 请求来时，WSGIHandler 就开始工作了，它从 BaseHandler 继承而来。

WSGIHandler 为每个请求创建一个 WSGIRequest 实例，而 WSGIRequest 是从

http.HttpRequest 继承而来。接下来就开始创建 Response 了。

（4）创 建 Response

BaseHandler 的 get_response 方法就是根据 request 创建 response，而具体生成

response 的动作就是执行 urls.py 中对应的 view 函数了，这也是 Django 可以处理“友好 URL ” 的关键步骤，每个这样的函数都要返回一个 Response 实例。此时一般的做法是通过 loader 加载template 并生成页面内容，其中重要的就是通过 ORM 技术从数据库中取出数据，并渲染到Template 中，从而生成具体的页面了。

（5）处 理 Response

Django 返回 Response 给  flup，flup  就取出  Response  的内容返回给  Web  服务器，由后者返回给浏览器。

总之，Django 在 fastcgi 中主要做了两件事：处理 Request 和创建 Response，而它们对应的核心就是“ urls 分析”、“模板技术”和“ ORM 技术”。

       一个 HTTP 请求，首先被转化成一个 HttpRequest 对象，然后该对象被传递给Request 中间件处理，如果该中间件返回了 Response，则直接传递给 Response 中间件做收尾处理。否则的话 Request 中间件将访问 URL 配置，确定哪个 view 来处理，在确定了哪个 view 要执行，但是还没有执行该 view 的时候，系统会把 request 传递给  view  中间件处理器进行处理，如果该中间件返回了 Response，那么该 Response 直接被传递给 Response  中间件进行后续处理，否则将执行确定的 view 函数处理并返回  Response，在这个过程中如果引发了异常并抛出，会被  Exception 中间件处理器进行处理。

Q：Django里QuerySet的get和filter方法的区别

（1） 输入参数

 get 的参数只能是 model 中定义的那些字段，只支持严格匹配。

filter 的参数可以是字段，也可以是扩展的 where 查询关键字，如 in，like 等。

（2）返回值

 get 返回值是一个定义的 model 对象。

filter 返回值是一个新的 QuerySet 对象，然后可以对 QuerySet 在进行查询返回新的  QuerySet 对象，支持链式操作，QuerySet 一个集合对象，可使用迭代或者遍历，切片等，但是不等于 list 类型(使用一定要注意)。

（3） 异常

 get 只有一条记录返回的时候才正常，也就说明 get 的查询字段必须是主键或者唯一约束的字段。当返回多条记录或者是没有找到记录的时候都会抛出异常

filter 有没有匹配的记录都可以

Q：django 中当一个用户登录 A 应用服务器（进入登录状态），然后下次请求被 nginx代理到 B 应用服务器会出现什么影响？

如果用户在 A 应用服务器登陆的 session 数据没有共享到 B 应用服务器，那么之前的登录状态就没有了。

Q：跨域请求问题 django 怎么解决的

启用中间件

post 请求

验证码

表单中添加 csrf_token 标签

Q：Django对数据查询结果排序怎么做，降序怎么做

排序使用 order_by()

降序需要在排序字段名前加-

Q：Django 重定向你是如何实现的？用的什么状态码

使用 HttpResponseRedirect

redirect 和 reverse

状态码：302,301

Q：生成迁移文件和执行迁移文件的命令是什么

python manage.py

makemigrations python

manage.py migrate

Q：关系型数据库的关系包括哪些类型

· ForeignKey：一对多，将字段定义在多的一端中。

· ManyToManyField：多对多：将字段定义在两端中。

· OneToOneField：一对一，将字段定义在任意一端中。

Q：查询集返回列表的过滤器有哪些？

all() ：返回所有的数据

filter()：返回满足条件的数据

exclude()：返回满足条件之外的数据，相当于 sql 语句中 where 部分的 not 关键字

order_by()：排序

Q：判断查询集是否有数据？

exists()：判断查询集中否有数据，如果有则返回 True，没有则返回 False。

Q：Django 本身提供了 runserver，为什么不能用来部署？

runserver 方法是调试 Django 时经常用到的运行方式，它使用 Django  自带的 WSGI Server 运行，主要在测试和开发中使用，并且 runserver 开启的方式也是单进程 。

uWSGI 是一个 Web  服务器，它实现了 WSGI  协议、uwsgi、http  等协议。注意  uwsgi  是一种通信协议，而 uWSGI 是实现 uwsgi 协议和  WSGI  协议的 Web  服务器。uWSGI  具有超快的性能、低内存占用和多 app 管理等优点，并且搭配着  Nginx 就是一个生产环境了，能够将用户访问请求与应用 app 隔离开，实现真正的部署。相比来讲，支持的并发量更高，方便管理多进程，发挥多核的优势， 提升性能。

Q：apache 和 nginx 的区别

Nginx 相对 Apache 的优点：

轻量级，同样web服务，比 apache 占用更少的内存及资源；

并发，nginx 处理请求是异步非阻塞的，支持更多的并发连接，而 apache 则是阻塞型的，在高并发下 nginx 能保持低资源低消耗高性能；

配置简洁；

高度模块化的设计，编写模块相对简单； 社区活跃。

Apache 相对 Nginx 的优点：

rewrite ，比 nginx 的 rewrite 强大； 模块超多，基本想到的都可以找到；

少 bug ，nginx 的 bug 相对较多； 超稳定。

Q：varchar 与 char 的区别？

 char 长度是固定的，不管你存储的数据是多少他都会都固定的长度。

 varchar 则处可变长度但他要在总长度上加 1 字符，这个用来存储位置。所以在处理速度上 char 要比 varchar 快速很多，但是对费存储空间，所以对存储不大，但在速度上有要求的可以使用 char 类型，反之可以用 varchar 类型。

Q：查询集两大特性？惰性执行

惰性执行、缓存 。

创建查询集不会访问数据库，直到调用数据时，才会访问数据库，调用数据的情况包括迭代、序列化、与 if 合用

Q：git 常用命令

git clone  克隆指定仓库

git status 查看当前仓库状态git diff 比较版本的区别

git log 查看 git 操作日志git reset 回溯历史版本

git add 将文件添加到暂存区

git commit 将文件提交到服务器git checkout  切换到指定分支git rm 删除指定文件

Q：电商网站库存问题

       一般团购，秒杀，特价之类的活动，这样会使访问量激增，很多人抢购一个商品，作为活动商品， 库存肯定是很有限的。控制库存问题，数据库的事务功能是控制库存超卖的有效方式。

（1）在秒杀的情况下，肯定不能如此频率的去读写数据库，严重影响性能问题，必须使用缓存，将需要秒杀的商品放入缓存中，并使用锁来处理并发情况，先将商品数量增减（加锁、解析）后在进行其他方面的处理，处理失败再将数据递增（加锁、解析）,否则表示交易成功。

（2）这个肯定不能直接操作数据库的，会挂的。直接读库写库对数据库压力太大了，要用到缓存。

（3）首先，多用户并发修改同一条记录时，肯定是后提交的用户将覆盖掉前者提交的结果了。这个直接可以使用加乐观锁的机制去解决高并发的问题。

Q：HttpRequest 和 HttpResponse 是什么?干嘛用的？

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 才有数据。

？a=10 的键和值时怎么产生的，键是开发人员在编写代码时确定下来的，值时根据数据生成或者用户填写的，总之是不确定的。

403 错误：表示资源不可用，服务器理解客户的请求，但是拒绝处理它，通常由于服务器上文件和目录的权限设置导致的 web 访问错误。如何解决：1、把中间件注释。2、在表单内部添加{% scrf_token %}

request.GET.get()取值时如果一键多值情况，get 是覆盖的方式获取的。getlist（）可以获取多个值。在一个有键无值的情况下，该键名 c 的值返回空。有键无值：c: getlist 返回的是列表，空列表

在无键无值也没有默认值的情况下，返回的是 None 无键无值：e:None

HttpResponse 常见属性：

content：表 示 返 回 的 内 容charset: 表 示  response 采 用 的 编 码 字 符 集 ， 默 认 是 utf-8 status_code:返回的 HTTP 响应状态码 3XX 是对请求继续进一步处理，常见的是重定向。常见方法：

init:创建 httpResponse 对象完成返回内容的初始化

set_cookie：设置 Cookie 信息：格式：set_cookies('key','value',max_age=None,expires=None) max_age 是一个整数，表示指定秒数后过期，expires 指定过期时间，默认两个星期后过期。

write 向响应体中写数据应答对象：

方式一：render(request,"index.html") 返回一个模板render(request,"index.html", context) 返回一个携带动态数据的页面

方式二：render_to_response("index.html") 返回一个模板页面方式三：redirect("/") 重定向

方式四：HttpResponseRdeirect("/") 实现页面跳转功能

方式五：HttpResponse（"itcast1.0")在返回到额页面中添加字符串内容方式六：HttpResponseJson() 返回的页面中添加字符串内容。

JsonResponse 创建对象时候接收字典作为参数，返回的对象是一个 json 对象。

能接收 Json 格式数据的场景，都需要使用 view 的 JsonResponse 对象返回一个 json 格式数据

ajax 的使用场景，页面局部刷新功能。ajax 接收 Json 格式的数据。

在返回的应答报文中，可以看到 JsonResponse 应答的 content-Type 内容是 application/json

ajax 实现网页局部刷新功能：ajax 的 get()方法获取请求数据 ajax 的 each()方法遍历输出这些数据

Q：什么是反向解析

使用场景：模板中的超链接，视图中的重定向

使用：在定义 url 时为 include 定义 namespace 属性，为 url 定义 name 属性在模板中使用 url 标签：{% url 'namespace_value:name_value'%}

在视图中使用 reverse 函数：redirect(reverse('namespce_value:name_value’))根据正则表达式动态生成地址，减轻后期维护成本。

注意反向解析传参数，主要是在我们的反向解析的规则后面天界了两个参数，两个参数之间使用空格隔开：位置参数

Q：Django 日志管理

配置好之后：

import logging

logger=logging.getLogger( name ) # 为 loggers 中定义的名称

logger.info("some info ...)

可用函数有：logger.debug() logger.info() logger.warning() logger.error()

Django 文件管理：对于 jdango 老说，项目中的 css，js,图片都属于静态文件，我们一般会将静态文件放到一个单独的目录中，以方便管理，在 html 页面调用时，也需要指定静态文件的路径。静态文件可以放在项目根目录下，也可以放在应用的目录下，由于这些静态文件在项目中是通用的，所以推荐放在项目的根目录下。

在生产中，只要和静态文件相关的，所有访问，基本上没有 django 什么事，一般都是由 nignx 软件代劳了，为什么？因为 nginx 就是干这个的。

Q：django请求的生命周期？

 1.wsgi,请求封装后交给web框架

 2.中间件，对请求进行校验或者在请求对象中添加其他相关数据，

 3.路由匹配，根据浏览器发送的不同url去匹配不同的视图函数

 4.视图函数，在视图函数中进行业务逻辑的处理

 5.中间件，对响应的数据进行处理

 6.wsgi,将响应的内容发送给浏览器

Q：列举django中间件的5个方法？以及django中间件的应用场景？

 1.process_request

 接收到客户端信息后立即执行，视图函数之前

 2.process_response

 返回到客户端信息前最后执行，视图函数之后

 3.process_view

 拿到视图函数的名称，参数，执行process_view()方法

 4.process_exception

 视图函数出错时执行

 5.process_template_response

 在视图函数执行完后立即执行，前提是视图返回的对象中有一个render()方法

Q：谈谈你对restfull 规范的认识？

 #首先restful是一种软件架构风格或者说是一种设计风格，并不是标准，它只是提供了一组设计#原则和约束条件，主要用于客户端和服务器交互类的软件。

 #就像设计模式一样，并不是一定要遵循这些原则，而是基于这个风格设计的软件可以更简洁，更#有层次，我们可以根据开发的实际情况，做相应的改变。

 #它里面提到了一些规范，例如：

 #1.restful 提高了代码的复用性，可以使用面向对象的技术倡面向资源编程,在url接口中尽量要使用名词，不要使用动词

 #2、在url接口中推荐使用Https协议，让网络接口更加安全

 #https://www.bootcss.com/v1/mycss？page=3

 #（Https是Http的安全版，即HTTP下加入SSL层，HTTPS的安全基础是SSL，

 #因此加密的详细内容就需要SSL（安全套接层协议））

 #3、在url中可以体现版本号

 #https://v1.bootcss.com/mycss

 #不同的版本可以有不同的接口，使其更加简洁，清晰

 #4、url中可以体现是否是API接口

 #https://www.bootcss.com/api/mycss

 #5、url中可以添加条件去筛选匹配

 #https://www.bootcss.com/v1/mycss？page=3

 #6、可以根据Http不同的method，进行不同的资源操作

 #（5种方法：GET / POST / PUT / DELETE / PATCH）

 #7、响应式应该设置状态码

 #8、有返回值，而且格式为统一的json格式

 #9、返回错误信息

 #返回值携带错误信息

 #10、返回结果中要提供帮助链接，即API最好做到Hypermedia

 #如果遇到需要跳转的情况 携带调转接口的URL

 　　 ret = {

 code: 1000,

 data:{

 id:1,

 name:'小强',

 depart_id:http://www.luffycity.com/api/v1/depart/8/

 }

 }

Q：django rest framework框架中都有那些组件？

 1.序列化组件:serializers 对queryset序列化以及对请求数据格式校验

 2.路由组件routers 进行路由分发

 3.视图组件ModelViewSet 帮助开发者提供了一些类，并在类中提供了多个方法

 4.认证组件 写一个类并注册到认证类(authentication_classes)，在类的的authticate方法中编写认证逻

 5.权限组件 写一个类并注册到权限类(permission_classes)，在类的的has_permission方法中编写认证逻辑。

 6.频率限制 写一个类并注册到频率类(throttle_classes)，在类的的allow_request/wait 方法中编写认证逻辑

 7.解析器 选择对数据解析的类，在解析器类中注册(parser_classes)

 8.渲染器 定义数据如何渲染到到页面上,在渲染器类中注册(renderer_classes)

 9.分页 对获取到的数据进行分页处理, pagination_class

 10.版本 版本控制用来在不同的客户端使用不同的行为

 在url中设置version参数，用户请求时候传入参数。在request.version中获取版本，根据版本不同 做不同处理

Q：django rest framework框架中的视图都可以继承哪些类？

 #class View(object):

 #class APIView(View): 封装了view,并且重新封装了request,初始化了各种组件

 #class GenericAPIView(views.APIView):

 #1.增加了一些属性和方法,如get_queryset,get_serializer

 #class GenericViewSet(ViewSetMixin, generics.GenericAPIView)

 #父类ViewSetMixin 重写了as_view,返回return csrf_exempt(view)

 #并重新设置请求方式与执行函数的关系

 class ModelViewSet(mixins.CreateModelMixin,

 mixins.RetrieveModelMixin,

 mixins.UpdateModelMixin,

 mixins.DestroyModelMixin,

 mixins.ListModelMixin,

 GenericViewSet):pass

 #继承了mixins下的一些类,封装了list,create,update等方法

 #和GenericViewSet

Q：简述 django rest framework框架的认证流程。

 1.cbv的实现原理

 通过as_view方法，执行dispatch函数，在dispatch函数中通过request的method方法，调用视图类的不同方法

 2.继承rest frame work的APIview类

 APIView继承了Django的View,并且重写了dispatch方法

 重写的dispatch方法除了保留分发功能，同时做了以下几个操作：

 1.封装request

 封装的request返回一个request类的实例对象

 authentication_classes是一个放置认证类的列表，那么get_authenticators方法返回的就是认证的实例化对象列表，传入到重写的request对象中

 2.执行initial方法

 perform_authentication函数

 调用封装后的requestd对象的user

 user方法调用了_authenticate方法

 _authenticate方法中，self.authenticators其中self指的是封装后的request对象

 _authenticate方法就是对认证类对象列表进行循环执行，并且是执行认证类对象中的authenticate方法，将返回值user_auth_tuple复制给self.user和self.auth

Q：django rest framework如何实现的用户访问频率控制？

from rest_framework.throttling import SimpleRateThrottle

 这里使用的节流类是继承了SimplePateThrottle类，而这个类利用了django内置的缓存来存储访问记录。通过全局节流设置，所有的视图类默认是使用UserThrottle类进行节流，如果不想使用默认的类就自定义给throttle_classes属性变量赋值，如：“throttle_classes = [VisitThrottle,]”。

Q：Celery 分布式任务队列

　　情景：用户发起 request，并等待 response 返回。在本些 views 中，可能需要执行一段耗时的程序，那么用户就会等待很长时间，造成不好的用户体验，比如发送邮件、手机验证码等。
　　使用 celery 后，情况就不一样了。解决：将耗时的程序放到 celery 中执行。
　　将多个耗时的任务添加到队列 queue 中，也就是用 redis 实现 broker 中间人，然后用多个 worker 去监听队列里的任务去执行。
　　任务 task：就是一个 Python 函数。
   　 队列 queue：将需要执行的任务加入到队列中。
　　工人 worker：在一个新进程中，负责执行队列中的任务。
　　代理人 broker：负责调度，在布置环境中使用 redis。

Q：drf继承过哪些视图类？以及他们之间的区别？

第一种：APIView 第一种遵循了CBV的模式，里面的功能比较多但是需要自己写的代码也有很多 提供了免除csrf认证，版本处理、认证、权限、节流、解析器、筛选器、分页、序列化、渲染器。

第二种：ListAPIView,RetrieveAPIView,CreateAPIView,UpdateAPIView,DestroyAPIView

第二种则在第一种的基础上，封装了许多我们需要自己的写的代码，许多功能的实现只需要给专属的变量名赋值就可以实现该功能。

第三种：GenericViewSet、ListModelMixin,RetrieveModelMixin,CreateModelMixin,UpdateModelMixin,DestroyModelMixin

第三种则重构了APIView中的as_view()方法，结合请求方法和不同Mixin类的方法名从而进行执行不同的功能。

与前面两种最主要的区别是url路由中as_view()方法中需要传值。

目前使用的主要目的是把第二种的bug(查询全部数据的功能和查询单个数据的功能无法在一个类中实现)实现在一个类中！

Q：什么是jwt？ 它的优势是什么？

jwt的全称是json web token，一般用于用户认证 jwt的实现原理：

- 用户登录成功之后，会给前端返回一段token。

- token是由.分割的三段组成。

    - 第一段header：类型+算法+base64url加密 -

    - 第二段paylod：用户信息+超时时间+base64url加密 -

    - 第三段sign：hs256（前两段拼接）加密 + base64url - 以后前端再次发来信息时 - 超时验证 - token合法性校验

　　优势： - token只在前端保存，后端只负责校验。 - 内部集成了超时时间，后端可以根据时间进行校验是否超时。 - 由于内部存在hash256加密，所以用户不可以修改token，只要一修改就认证失败。

Q：drf版本的实现过程？

# drf自带的版本类 "DEFAULT_VERSIONING_CLASS": "rest_framework.versioning.URLPathVersioning",

# 允许出现的版本 "ALLOWED_VERSIONS": ['v1', 'v2'],

# 如果没有传版本，可以使用默认版本 default_version = api_settings.DEFAULT_VERSION

# 设置url中获取版本的变量，默认是version version_param = api_settings.VERSION_PARAM

Q：drf组件提供的功能

免除csrf认证 视图(三种：(1)APIView,(2)ListAPIview,(3)ListModelMixin)

版本处理 认证 权限 节流（频率限制）

解析器 筛选器 分页

序列化和数据校验：

    可以对QuerySet进行序列化，也可以对用户提交的数据进行校验——展示特殊的数据

　depth source：无需加括号，在源码内部会去判断是否可执行，如果可执行自动加括号。

　【多对一、一对一/choice】 SerializerMethodField定义钩子方法【多对多】

渲染器：可以帮我们把json数据渲染到drf自己的页面上。

Q：GenericAPIView视图类的作用

GenericAPIView主要为drf内部帮助我们提供增删改查的类LIstAPIView、CreateAPIView、UpdateAPIView、提供了执行流程和功能，我们在使用drf内置类做增删改查时，就可以通过自定义 静态字段（类变量）或重写方法（get_queryset、get_serializer_class）来进行更高级的定制。 

Q：django-debug-toolbar的作用？

用来调试请求的接口

Q：django中如何实现单元测试

django的单元测试使用python的unittest模块，这个模块使用基于类的方法来定义测试

Q：django的缓存能使用redis吗？如果可以的话，如何配置？

 redis可以干什么

 1.记录评论数，热度，浏览量

 2.记录我的收藏，我的文章，等列表类数据

 3.记录谋篇文章的点赞人员列表

 4.缓存频繁访问但是不太多的东西，例如：热门推荐

 5.记录与当前浏览的对象相关的对象

 6.记录分类排行榜

 7.缓存历史记录

 string的应用

 缓存用户基本信息

 list的应用

 通常用作异步队列，存储列表数据

 hash的作用

 无序字典，字典的值是字符串

 可以对用户信息的每个字段单独存储

 set集合的应用

 用来防止重复事件发生