django面试题

1、什么是wsgi？

WSGI是Python在处理HTTP请求时，规定的一种处理方式。如一个HTTP Request过来了，那么就有一个相应的处理函数来进行处理和返回结果。WSGI就是规定这个处理函数的参数长啥样的，它的返回结果是长啥样的？至于该处理函数的名子和处理逻辑是啥样的，那无所谓。简单而言，WSGI就是规定了处理函数的输入和输出格式。

2、Django请求的生命周期？

• . 当用户在浏览器中输入url时,浏览器会生成请求头和请求体发给服务端
  请求头和请求体中会包含浏览器的动作(action),这个动作通常为get或者post,体现在url之中.
• . url经过Django中的wsgi,再经过Django的中间件,最后url到过路由映射表,在路由中一条一条进行匹配,
  一旦其中一条匹配成功就执行对应的视图函数,后面的路由就不再继续匹配了.
• . 视图函数根据客户端的请求查询相应的数据.返回给Django,然后Django把客户端想要的数据做为一个字符串返回给客户端.
• . 客户端浏览器接收到返回的数据,经过渲染后显示给用户.

3、列举Django的内置组件？

• .Admin是对model中对应的数据表进行增删改查提供的组件

• .model组件：负责操作数据库

• .form组件：1.生成HTML代码2.数据有效性校验3校验信息返回并展示

• .ModelForm组件即用于数据库操作,也可用于用户请求的验证

4、列举Django中间件的5个方法？以及Django中间件的应用场景？

• .process_request : 请求进来时,权限认证
• .process_view : 路由匹配之后,能够得到视图函数
• .process_exception : 异常时执行
• .process_template_responseprocess : 模板渲染时执行
• .process_response : 请求有响应时执行

5、简述什么是FBV和CBV？

FBV和CBV本质是一样的，基于函数的视图叫做FBV，基于类的视图叫做CBV
在python中使用CBV的优点：
- .提高了代码的复用性，可以使用面向对象的技术，比如Mixin（多继承）
- .可以用不同的函数针对不同的HTTP方法处理，而不是通过很多if判断，提高代码可读性

6、django的request对象是在什么时候创建的？

class WSGIHandler(base.BaseHandler):
-------request = self.request_class(environ)
请求走到WSGIHandler类的时候，执行cell方法，将environ封装成了request

7、如何给CBV的程序添加装饰器？

        from django.utils.decorators import method_decorator
        1、给方法加：
            @method_decorator(check_login)
            def post(self, request):
                ...
        2、给dispatch加：
            @method_decorator(check_login)
            def dispatch(self, request, *args, **kwargs):
                ...
        3、给类加：
            @method_decorator(check_login, name="get")
            @method_decorator(check_login, name="post")
            class HomeView(View):
                ...

8、列举django orm 中所有的方法（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():            从返回结果中剔除重复纪录

9、select_related和prefetch_related的区别？

前提：有外键存在时，可以很好的减少数据库请求的次数,提高性能
select_related通过多表join关联查询,一次性获得所有数据,只执行一次SQL查询
prefetch_related分别查询每个表,然后根据它们之间的关系进行处理,执行两次查询

10、filter和exclude的区别？

两者取到的值都是QuerySet对象,filter选择满足条件的,exclude:排除满足条件的.

11、列举django orm中三种能写sql语句的方法

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多用于查询

12、values和values_list的区别？

• values : queryset类型的列表中是字典
• values_list : queryset类型的列表中是元组

13、cookie和session的区别：

• .cookie:

  ​ cookie是保存在浏览器端的键值对,可以用来做用户认证

• .session：

  将用户的会话信息保存在服务端,key值是随机产生的字符串,value值是session的内容
  依赖于cookie将每个用户的随机字符串保存到用户浏览器上

• Django中session默认保存在数据库中：django_session表

• flask,session默认将加密的数据写在用户的cookie中

14、如何使用django orm批量创建数据？

objs=[models.Book(title="图书{}".format(i+15)) for i in range(100)]
models.Book.objects.bulk_create(objs)

15、django的Form组件中,如果字段中包含choices参数，请使用两种方式实现数据源实时更新

• 1.重写构造函数

def__init__(self, *args, **kwargs):
     super().__init__(*args, **kwargs)
     self.fields["city"].widget.choices = models.City.objects.all().values_list("id", "name")

• 2.利用ModelChoiceField字段,参数为queryset对象

  authors = form_model.ModelMultipleChoiceField(queryset=models.NNewType.objects.all())//多选
  

16、django的Model中的ForeignKey字段中的on_delete参数有什么作用？

• 删除关联表中的数据时,当前表与其关联的field的操作
• django2.0之后，表与表之间关联的时候,必须要写on_delete参数,否则会报异常

17、django的模板中自定义filter和simple_tag的区别？

• 自定义filter：{{ 参数1|filter函数名:参数2 }}
  1.可以与if标签来连用
  2.自定义时需要写两个形参

    例子：自定义filter
            1. 在app01下创建一个叫templatetags的Python包
            2. 在templatetags的文件夹下创建py文件  myfilters
            3. 在py文件中写代码
                from django import template
                register = template.Library()
                
                @register.filter
                def add_sb(value,arg='aaa'):
                    return "{}_sb_{}".formart(value,arg)
                    
                @register.filter(name='sb')
                def add_sb(value,arg='aaa'):
                    return "{}_sb_{}".formart(value,arg)     
            4. 使用自定义filter
                {% load myfilters %}
                {{ name|add_sb:'xxx'}}
                {{ name|sb:'xxx'}}

• simple_tag:{% simple_tag函数名 参数1 参数2 %}
  1.可以传多个参数,没有限制
  2.不能与if标签来连用

例子：自定义simpletag
    创建
        1 、在app01中创建一个名字是templatetags的包，
        2、在包中创建一个py文件
        3、在py文件中导入
              from django import template
              register = template.Library()
        4、写函数
              @register.simple_tag(name="plus")
              def plus(a,b,c):
                  return '{}+{}+{}'.format(a,b,c)
        5、加装饰器@register.simple_tag(name="plus")
  使用
      1、导入
            {% load mytag %}
      2、使用
           {% plus 1 2 3 %}

18、django中csrf的实现机制

• 第一步：django第一次响应来自某个客户端的请求时,后端随机产生一个token值，把这个token保存在SESSION状态中;同时,后端把这个token放到cookie中交给前端页面；
• 第二步：下次前端需要发起请求（比如发帖）的时候把这个token值加入到请求数据或者头信息中,一起传给后端；Cookies:{csrftoken:xxxxx}
• 第三步：后端校验前端请求带过来的token和SESSION里的token是否一致。

19、基于django使用ajax发送post请求时，都可以使用哪种方法携带csrf token？

• 1.后端将csrftoken传到前端，发送post请求时携带这个值发送

data: {
        csrfmiddlewaretoken: '{{ csrf_token }}'
  },

• 2.获取form中隐藏标签的csrftoken值，加入到请求数据中传给后端

data: {
          csrfmiddlewaretoken:$('[name="csrfmiddlewaretoken"]').val()
     },

• 3.cookie中存在csrftoken,将csrftoken值放到请求头中

headers:{ "X-CSRFtoken":$.cookie("csrftoken")}

20、Django本身提供了runserver，为什么不能用来部署？(runserver与uWSGI的区别)

• 1.runserver方法是调试 Django 时经常用到的运行方式，它使用Django自带的
  WSGI Server 运行，主要在测试和开发中使用，并且 runserver 开启的方式也是单进程 。
• 2.uWSGI是一个Web服务器，它实现了WSGI协议、uwsgi、http 等协议。注意uwsgi是一种通信协议，而uWSGI是实现uwsgi协议和WSGI协议的 Web 服务器。uWSGI具有超快的性能、低内存占用和多app管理等优点，并且搭配着Nginx就是一个生产环境了，能够将用户访问请求与应用 app 隔离开，实现真正的部署 。相比来讲，支持的并发量更高，方便管理多进程，发挥多核的优势，提升性能。

21、Django如何实现websocket？

• django实现websocket官方推荐大家使用channels。channels通过升级http协议 升级到websocket协议。保证实时通讯。也就是说，我们完全可以用channels实现我们的即时通讯。而不是使用长轮询和计时器方式来保证伪实时通讯。他通过改造django框架，使django既支持http协议又支持websocket协议。

22.Django的优点和缺点有哪些?

Django的优点

• 功能完善、要素齐全：自带大量企业Web开发常用工具和框架（比如分页，auth，权限管理), 适合快速开发企业级网站。
• 完善的文档：经过十多年的发展和完善，Django有广泛的实践案例和完善的在线文档。开发者遇到问题时可以搜索在线文档寻求解决方案。
• 强大的数据库访问组件：Django的Model层自带数据库ORM组件，使得开发者无须学习SQL语言即可对数据库进行操作。
• Django先进的App设计理念: App是可插拔的，是不可多得的思想。不需要了，可以直接删除，对系统整体影响不大。
• 自带台管理系统admin：只需要通过简单的几行配置和代码就可以实现一个完整的后台数据管理控制平台。

Django的缺点

• 大包大揽: 对于一些轻量级应用不需要的功能模块Django也包括了，不如Flask轻便。
• 过度封装: 很多类和方法都封装了，直接使用比较简单，但改动起来就比较困难。
• 性能劣势: 与C, C++性能上相比，Django性能偏低，当然这是python的锅，其它python框架在流量上来后会有同样问题。
• 模板问题: django的模板实现了代码和样式完全分离，不允许模板里出现python代码，灵活度对某些程序员来说可能不够。

23. 说说看Django的请求生命周期

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-s0x3Hd5i-1668657145607)(./img/v2-ed1ee3a6a6fd15b98f86bdd862c62de3_720w.webp)]

注：最重要的是回答用户请求并不是一下子通过URL匹配就达到相应视图，返回数据也不是一下子就返回给用户，中间要经历层层中间件。这个面试题其实考的核心是中间件。

Django基础(33): 中间件(middleware)的工作原理和应用场景举例

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tDQHoixV-1668657145608)(./img/v2-93bd8254551b3790d246698e03d67c01_720w.webp)]

24说说看Django的Queryset有哪些特性

Django的QuerySet主要有两个特性：

​ 一是惰性的(lazy)，

​ 二是自带缓存。

Django的QuerySet是惰性的

下例中article_list试图从数据库查询一个标题含有django的全部文章列表。

article_list = Article.objects.filter(title__contains="django")

但是当我们定义article_list的时候，Django的数据接口QuerySet并没有对数据库进行任何查询。无论你加多少过滤条件，Django都不会对数据库进行查询。只有当你需要对article_list做进一步运算时（比如打印出查询结果，判断是否存在，统计查询结果长度)，Django才会真正执行对数据库的查询(见下例1)。这个过程被称为queryset的执行(evaluation)。Django这样设计的本意是尽量减少对数据库的无效操作，比如查询了结果而不用是计算资源的很大浪费。

# example 1
for article in article_list:
    print(article.title)

Django的QuerySet自带缓存(Cache)

在例1中，当你遍历queryset(article_list)时，所有匹配的记录会从数据库获取。这些结果会载入内存并保存在queryset内置的cache中。这样如果你再次遍历或读取这个article_list时，Django就不需要重复查询了，这样也可以减少对数据库的查询。

Django基础(12)：深夜放干货。QuerySet特性及高级使用技巧，如何减少数据库的访问，节省内存，提升网站性能。

25.什么是基于函数的视图（FBV)和基于类的视图（CBV)以及各自的优点

FBV（function base views） 就是在视图里使用函数处理请求。CBV（class base views） 就是在视图里使用类处理请求。Python是一个面向对象的编程语言，如果只用函数来开发，有很多面向对象的优点就错失了（继承、封装、多态）。所以Django在后来加入了Class-Based-View，可以让我们用类写View，这样做的优点主要下面两种：

• 提高了代码的复用性，可以使用面向对象的技术，比如Mixin（多继承）
• 可以用不同的函数针对不同的HTTP方法处理，而不是通过很多if判断，提高代码可读性

当然基于函数的视图也有自己的优点，比如对新手更友好。

更多阅读:

Django核心基础(3): View视图详解。一旦你使用通用视图，你就会爱上她。

26. 如何给基于类的视图（CBV)使用装饰器

需要借助django.utils模块的method_decorator方法实现，它还支持decorators列表, 如下所示:

from django.utils.decorators import method_decorator

decorators = [login_required, check_user_permission]


@method_decorator(decorators, name='dispatch')
class ArticleCreateView(CreateView):
    model = Article
    form_class = ArticleForm
    template_name = 'blog/article_manage_form.html'

更多阅读:

Django基础(26): 常用装饰器应用场景及正确使用方法

一文看懂Python系列之装饰器(decorator)(工作面试必读)

27. 说说看使用基于类的视图(CBV)时get_queryset, get_context_data和get_object方法的作用

get_queryset()方法

正如其名，该方法可以返回一个量身定制的对象列表。当我们使用Django自带的ListView展示所有对象列表时，ListView默认会返回Model.objects.all()。

# Create your views here.
from django.views.generic import ListView
from .models import Article

class IndexView(ListView):

    model = Article

然而这可能不是我们所需要的。当我们希望只展示作者自己发表的文章列表且按文章发布时间逆序排列时，我们就可以通过更具体的get_queryset方法来返回一个我们想要显示的对象列表。

# Create your views here.
from django.views.generic import ListView
from .models import Article
from django.utils import timezone

class IndexView(ListView):

    template_name = 'blog/article_list.html'
    context_object_name = 'latest_articles'

    def get_queryset(self):
        return Article.objects.filter(author = self.request.user).order_by('-pub_date')

get_context_data()

get_context_data可以用于给模板传递模型以外的内容或参数，非常有用。例如现在的时间并不属于Article模型。如果你想把现在的时间传递给模板，你还可以通过重写get_context_data方法（如下图所示)。因为调用了父类的方法，

# Create your views here.
from django.views.generic import ListView
from .models import Article
from django.utils import timezone

class IndexView(ListView):

    queryset = Article.objects.all().order_by("-pub_date")
    template_name = 'blog/article_list.html'
    context_object_name = 'latest_articles'

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['now'] = timezone.now() #只有这行代码有用
        return context
        

get_object()方法

DetailView和EditView都是从URL根据pk或其它参数调取一个对象来进行后续操作。下面代码通过DetailView展示一篇文章的详细信息。

# Create your views here.
from django.views.generic import DetailView
from django.http import Http404
from .models import Article
from django.utils import timezone

class ArticleDetailView(DetailView):

    queryset = Article.objects.all().order_by("-pub_date") #等同于model = Article
    template_name = 'blog/article_detail.html'
    context_object_name = 'article'

然而上述代码可能满足不了你的需求。比如你希望一个用户只能查看或编辑自己发表的文章对象。当用户查看别人的对象时，返回http 404错误。这时候你可以通过更具体的get_object()方法来返回一个更具体的对象。代码如下:

from django.views.generic import DetailView
from django.http import Http404
from .models import Article
from django.utils import timezone

class ArticleDetailView(DetailView):

    queryset = Article.objects.all().order_by("-pub_date")
    template_name = 'blog/article_detail.html'
    context_object_name = 'article'

    def get_object(self, queryset=None):
        obj = super().get_object(queryset=queryset)
        if obj.author != self.request.user:
            raise Http404()
        return obj

28. 你能列举几个减少数据库查询次数的方法吗？

• 利用Django queryset的惰性和自带缓存的特性
• 使用select_related和prefetch_related方法在数据库层面进行Join操作
• 使用缓存

更多阅读:

Django基础(29): select_related和prefetch_related的用法与区别

Django基础(8): 缓存Cache应用场景及工作原理，Cache设置及如何使用

29. Django的模型继承有哪几种方式? 它们有什么区别以及何时使用它们?

Django的模型继承有如下3种方式:

1)抽象模型继承(abstract model)：当你只希望父类的类保留你不想为每个子模型键入的信息时, 使用此样式。

2)多表模型继承(multi-table inheritance)：如果要对现有模型进行子类化并且需要每个模型都有其数据库表, 则使用此样式。

3)代理模型(proxy model)：如果你只想修改模型的Python级别行为, 而不更改模型的字段, 则使用此样式

它们的区别如下:

• Django不会为抽象模型在数据库中生成自己的数据表。父类Meta中的abstract=True也不会传递给子类。如果你发现多模型有很多共同字段时，需使用抽象模型继承。
• 多表模型继承与抽象模型继承最大的区别在于Django也会为父类模型建立自己的数据表，同时隐式地在父类和子类之间建立一个一对一关系。
• 如果我们只想改变某个模型的行为方法，而不是添加额外的字段或创建额外的数据表，我们就可以使用代理模型(proxy model)。设置一个代理模型，需要在子类模型Meta选项中设置proxy=True， Django不会为代理模型生成新的数据表。

30. 说说看如何自定义模型标签(templatetags)和过滤器(filter)?

首先你要在你的app目录下新建一个叫templatetags的文件夹(不能取其它名字), 里面必需包含__init__.py的空文件。在该目录下你还要新建一个python文件专门存放你自定义的模板标签函数，本例中为blog_extras.py，当然你也可以取其它名字。整个目录结构如下所示:

blog/
   __init__.py
   models.py
   templatetags/
       __init__.py
       blog_extras.py
   views.py

在模板中使用自定义的模板标签时，需要先使用{% load blog_extras %}载入自定义的过滤器，然后通过{% tag_name %} 使用它。

举例

我们将定义3个简单模板标签，一个返回string, 一个给模板context传递变量，一个显示渲染过的模板。我们在blog_extra.py里添加下面代码。

#blog_extra.py

from django import template
import datetime
from blog.models import Article

register = template.Library()

# use simple tag to show string
@register.simple_tag
def total_articles():
    return Article.objects.filter(status='p').count()

# use simple tag to set context variable
@register.simple_tag
def get_first_article():
    return Article.objects.filter(status='p').order_by('-pub_date')[0]

# show rendered template
@register.inclusion_tag('blog/latest_article_list.html')
def show_latest_articles(count=5):
    latest_articles = Article.objects.filter(status='p').order_by('-pub_date')[:count]
    return {'latest_articles': latest_articles, }

更多阅读:

Django基础(16): 模板标签(tags)的分类及如何自定义模板标签

Django实战: 利用自定义模板标签实现仿CSDN博客月度归档

31.Flask 和 Django 路由映射的区别:

1. 在Django 中,

   路由是浏览器访问服务器时,先访问的项目中的url, 再由项目中的url找到应用中url, 然后找到我们的视图函数; 视图函数然后直接或者间接的继承了Django提供的父类View,配置路由时，使用类视图的**as_view()**方法来添加;

urlpatterns = [
    # 视图函数：注册
    # url(r'^register/$', views.register, name='register'),
    # 类视图：注册
    url(r'^register/$', views.RegisterView.as_view(), name='register'),
]

通过View函数中 dispath方法来进行判断请求的是GET 还是POST等;

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-d3UEUpb1-1668657145609)(./img/70.png)]

2. 在Flask 中

   路由是通过装饰器给每个视图函数提供的, 而且根据请求方式的不同可以一个 url 用于不同的作用;

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rZrxrtyx-1668657145609)(./img/70-16683347938433.png)]

32、 缓存方案

设置缓存到内存

缓存到redis，配置redis

CACHES = {

“default”: {

​ “BACKEND”: “django_redis.cache.RedisCache”,

​ “LOCATION”: “redis://39.96.61.39:6379”,

​ ‘PASSWORD’:‘19990104.Yu’,

​ “OPTIONS”: {

​ “CLIENT_CLASS”: “django_redis.client.DefaultClient”,

​ }

}

}

单个view缓存

​ 视图导入from django.views.decorators.cache import cache_page

​ 在需要进行缓存的视图函数上添加如下装饰器即可：

@cache_page(60 * 2)#20分钟

底层缓存API

​ 视图导入 from django.core.cache import cache

模板片段缓存

​ 使用cache标签进行缓存

在HTML文件中添加：

{%load cache%}

{%cache 60 缓存名字 %}

33、 FBV和CBV

FBV:基于函数的视图函数

CBV:基于类的视图函数

34、 session和cookie

区别：

cookie数据存放在客户的浏览器上，session数据放在服务器上

cookie不是很安全，别人可以分析存放在本地的COOKIE并进行COOKIE欺骗

考虑到安全应当使用session。

session会在一定时间内保存在服务器上。当访问增多，会比较占用你服务器的性能考虑到减轻服务器性能方面，应当使用COOKIE

单个cookie保存的数据不能超过4K，很多浏览器都限制一个站点最多保存20个cookie

建议：将登陆信息等重要信息存放为SESSION，其他信息如果需要保留，可以放在COOKIE中

Cookie代码

HttpCookie cookie = new HttpCookie(“MyCook”);//初使化并设置Cookie的名称

DateTime dt = DateTime.Now;

TimeSpan ts = new TimeSpan(0, 0, 1, 0, 0);//过期时间为1分钟

cookie.Expires = dt.Add(ts);//设置过期时间

cookie.Values.Add(“userid”, “value”);

cookie.Values.Add(“userid2”, “value2”);

Response.AppendCookie(cookie);

35、 HTTP请求常见的方式

1、opions 返回服务器针对特定资源所支持的HTML请求方法 或web服务器发送测试服务器功能（允许客户端查看服务器性能）

2、Get 向特定资源发出请求（请求指定页面信息，并返回实体主体）

3、Post 向指定资源提交数据进行处理请求（提交表单、上传文件），又可能导致新的资源的建立或原有资源的修改

4、Put 向指定资源位置上上传其最新内容（从客户端向服务器传送的数据取代指定文档的内容）

5、Head 与服务器索与get请求一致的相应，响应体不会返回，获取包含在小消息头中的原信息（与get请求类似，返回的响应中没有具体内容，用于获取报头）

6、Delete 请求服务器删除request-URL所标示的资源（请求服务器删除页面）

7、Trace 回显服务器收到的请求，用于测试和诊断

8、Connect HTTP/1.1协议中能够将连接改为管道方式的代理服务器

36、 MVC和MTV模式

MTV：Model(模型)：负责业务对象与数据库的对象(ORM)

Template(模版)：负责如何把页面展示给用户

​ View(视图)：负责业务逻辑，并在适当的时候调用Model和Template

MVC: 所谓MVC就是把web应用分为模型(M),控制器©,视图(V)三层；他们之间以一种插件似的，松耦合的方式连接在一起。模型负责业务对象与数据库的对象(ORM),视图负责与用户的交互(页面)，控制器©接受用户的输入调用模型和视图完成用户的请求。

37、 ORM

对象关系映射

优点：

1、ORM使得我们的通用数据库交互变得简单易行，并且完全不用考虑开始的SQL语句。快速开发，由此而来。

2、可以避免一些新手程序猿写sql语句带来的性能效率和安全问题。

缺点：

1、性能有所牺牲，不过现在的各种ORM框架都在尝试使用各种方法来减少这个问题（LazyLoad，Cache），效果还是很显著的。

2、对于个别的负责查询，ORM仍然力不从心。为了解决这个问题，ORm框架一般也提供了直接写原生sql的方式。

38、 中间件的作用

中间件是介于request与response处理之间的一道处理过程，能在全局上改变django的输入与输出

39、中间件的4种方法及应用场景（自定义中间件必须继承MiddlewareMixin）

导包、from django.utils.deprecation import MiddlewareMixin

4种方法：

process_request

process_view

process_exception views中出现错误执行该方法

process_response

process_template_responseprocess 当函数中有render方法会执行该方法

40、什么是wsgi,uwsgi,uWSGI？

WSGI:

web服务器网关接口,是一套协议。用于接收用户请求并将请求进行初次封装，然后将请求交给web框架

实现wsgi协议的模块：

​ 1.wsgiref,本质上就是编写一个socket服务端，用于接收用户请求(django)

​ 2.werkzeug,本质上就是编写一个socket服务端，用于接收用户请求(flask)

uwsgi:

与WSGI一样是一种通信协议，它是uWSGI服务器的独占协议,用于定义传输信息的类型

uWSGI:

​ 是一个web服务器,实现了WSGI协议,uWSGI协议,http协议

41、ORM中的方法

1. models.Book.objects.all() # 获取到所有的书籍对象,结果是对象列表

2. models.Book.objects.get(条件) # 获取符合条件的对象

3. models.Book.objects.filter(条件) # 筛选所有符合条件的,结果是对象列表

4. models.Book.objects.exclude(条件) # 筛选出所有不符合条件的,结果是对象列表

5. models.Book.objects.all().values( ) # 字典列表,[ {id:1,name:20} , {id:2,name:18} ]

​ values(‘id’)括号内不指定时显示全部,如指定则只显示指定的,[ {id:1} , {id:2,} ]

6. models.Book.objects.all().values_list( ) # 元组列表,[ (1,20) , (2,18) ]同上,指定时显示指定内容

7. models.Book.objects.all().order_by(‘id’) # 按照id升序就行排列

   models.Book.objects.all().order_by(‘-id’) # 按照id降序就行排列

   models.Book.objects.all().order_by(‘age’ , ‘-id’) # 先按age升序,age相同的按id进行降序排列

8. models.Book.objects.all().order_by(‘id’).reverse() # 对结果反转; 注意reverse前必须排序,

​ 否则reverse无效; 或在model.py文件中Book类中的Meta中指定ordering=(‘id’ , )注意逗号必须有

9. distinct(): # 去重,当获取到的结果Queryset列表中同一对象出现多次时去重,只留一个

10. models.Book.objects.all().count() # 计数,可统计结果个数,如对Queryset内元素数进行统计.

11. models.Book.objects.all().first() # 获取结果中的第一条,即使前面结果列表为空,也不会报错

12. models.Book.objects.filter().last() # 获取结果中的最后一条

13.models.Book.objects.filter().exists() # 判断Queryset列表是否有东西,结果为True或False;

返回对象列表(Queryset)的方法有:

all() filter() ordey_by() exclude() values() values_list() reverse() distinct()

返回单个对象的方法有:

first() last() get() create()创建一个对象,且返回刚创建的对象

判断布尔值的有:

exists()

返回数字的有:

count()

42、filter和exclude的区别

filter返回满足条件的数据

exclude返回不满足条件的数据

43、ORM中三种能写sql语句的方法

1、execute 直接访问数据库，避开模型层

2、extra

3、raw for p in Person.objects.raw(‘SELECT * FROM myapp_person’):

print§

44、ORM批量处理数据

插入数据：创建一个对象列表，然后调用bulk_create方法，一次将列表中的数据插入到数据库中。

product_list_to_insert = list()

for x in range(10):

product_list_to_insert.append(Product(name='product name ’ + str(x), price=x))

Product.objects.bulk_create(product_list_to_insert)

更新数据：先进行数据过滤，然后再调用update方法进行一次性地更新

Product.objects.filter(name__contains=‘name’).update(name=‘new name’)

删除数据：先是进行数据过滤，然后再调用delete方法进行一次性删除

Product.objects.filter(name__contains=‘name query’).delete()

45、CSRF实现机制

1）启用中间件

2）post请求

3）验证码

4）表单中添加{% csrf_token%}标签

46、Django中提供了runserver为什么不能用来部署项目(runserver与uWSGI的区别)

1.runserver方法是调试 Django 时经常用到的运行方式，它使用Django自带的

WSGI Server 运行，主要在测试和开发中使用，并且 runserver 开启的方式也是单进程 。

2.uWSGI是一个Web服务器，它实现了WSGI协议、uwsgi、http 等协议。注意uwsgi是一种通信协议，而uWSGI是实现uwsgi协议和WSGI协议的 Web 服务器。

uWSGI具有超快的性能、低内存占用和多app管理等优点，并且搭配着Nginx就是一个生产环境了，能够将用户访问请求与应用 app 隔离开，实现真正的署 。

相比来讲，支持的并发量更高，方便管理多进程，发挥多核的优势，提升性能。

47、Django中如何实现websocket

1、简述：django实现websocket，之前django-websocket退出到3.0之后，被废弃。官方推荐大家使用channels。

2、配置

1、需要在seting.py里配置，将我们的channels加入INSTALLED_APP里。

48、Django的跨域问题

1、为什么有跨域？

1、浏览器的同源策略 （从一个域上加载的脚本不允许访问另外一个域的文档属性。）

2、解决跨域问题

​ 1、前端设置代理进行访问

​ 2、settings中配置django-cors-headers==2.0.1

​ INSTALLED_APPS中添加 ‘corsheaders’

​ ‘corsheaders.middleware.CorsMiddleware’,#放在session中间件下面

​ 添加代码

​ CORS_ALLOW_CREDENTIALS = True

CORS_ORIGIN_ALLOW_ALL = True

#允许所有的请求头

CORS_ALLOW_HEADERS = (‘*’)

49、model继承有几种方式，分别是什么？

抽象基类(Abstract base classes)

多表继承（Multi-table inheritance）

Meta inheritance 当一个子类没有声明自己的Meta类时，它会继承基类的 Meta 类，如果子类想扩展基类的 Meta 类 ，它可以继承基类的Meta类，然后再进行扩展。

50、class Meta中的原信息字段有哪些？

1、app_label 应用场景：模型类不在默认的应用程序包下的models.py文件中，这时候你需要指定你这个模型类是那个应用程序的。

2、db_table 应用场景：用于指定自定义数据库表名的

3、db_tablespace 应用场景：通过db_tablespace来指定这个模型对应的数据库表放在哪个数据库表空间。

4、verbose_name 应用场景：给你的模型类起一个更可读的名字：

5、verbose_name_plural 应用场景： 模型的复数形式是什么

6、ordering 应用场景：象返回的记录结果集是按照哪个字段排序的

51、web框架的本质

socket服务端

自定制web框架

​ from wsgiref.simple_server import make_server

def index():

return b’index’

def login():

return b’login’

def routers():

urlpatterns = (

​ (‘/index/’, index),

​ (‘/login/’, login),

)

return urlpatterns

def RunServer(environ, start_response):

start_response(‘200 OK’, [(‘Content-Type’, ‘text/html’)])

url = environ[‘PATH_INFO’]

urlpatterns = routers()

func = None

for item in urlpatterns:

​ if item[0] == url:

​ func = item[1]

​ break

if func:

​ return [func()]

else:

​ return [b’404 not found’]

if name == ‘main’:

httpd = make_server(‘127.0.0.1’,8080,RunServer)

print(“Serving HTTP on port 8080…”)

httpd.serve_forever()

53、queryset的get和filter方法的区别

输入参数：

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

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

返回值：

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

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

异常：

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

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

54、http请求的执行流程

​ 1、域名解析

​ 2、建立连接

​ 3、接收请求 接收客户端访问某一资源的请求

​ 单进程I/O

​ 多进程I/O

​ 复用I/O

​ 4、处理请求

​ 5、访问资源

​ 6、构建响应报文

​ 7、发送响应报文

​ 8、记录日志

55、如何加载初始化数据

Body中写onload方法

Js代码写onload函数执行的过程

56、对Django的认知

#1.Django是走大而全的方向，它最出名的是其全自动化的管理后台：只需要使用起ORM，做简单的对象定义，它就能自动生成数据库结构、以及全功能的管理后台。

#2.Django内置的ORM跟框架内的其他模块耦合程度高。

#应用程序必须使用Django内置的ORM，否则就不能享受到框架内提供的种种基于其ORM的便利；

#理论上可以切换掉其ORM模块，但这就相当于要把装修完毕的房子拆除重新装修，倒不如一开始就去毛胚房做全新的装修。

#3.Django的卖点是超高的开发效率，其性能扩展有限；采用Django的项目，在流量达到一定规模后，都需要对其进行重构，才能满足性能的要求。

#4.Django适用的是中小型的网站，或者是作为大型网站快速实现产品雏形的工具。

#5.Django模板的设计哲学是彻底的将代码、样式分离； Django从根本上杜绝在模板中进行编码、处理数据的可能。

\2. Django 、Flask、Tornado的对比

#1.Django走的是大而全的方向,开发效率高。它的MTV框架,自带的ORM,admin后台管理,自带的sqlite数据库和开发测试用的服务器

#给开发者提高了超高的开发效率

#2.Flask是轻量级的框架,自由,灵活,可扩展性很强,核心基于Werkzeug WSGI工具和jinja2模板引擎

#3.Tornado走的是少而精的方向,性能优越。它最出名的是异步非阻塞的设计方式

#Tornado的两大核心模块：

#1.iostraem：对非阻塞式的socket进行简单的封装

#2.ioloop：对I/O多路复用的封装，它实现了一个单例

57、重定向的实现，用的状态码

​ 1.使用HttpResponseRedirect

​ from django.http import HttpResponseRedirect

2.使用redirect和reverse

​ 状态码：301和302 #301和302的区别：

相同点：都表示重定向，浏览器在拿到服务器返回的这个状态码后会自动跳转到一个新的URL地址

​ 不同点： 301比较常用的场景是使用域名跳转。

58、nginx的正向代理与反向代理

​ 正向代理：多台客户端访问远程资源的时候通过的是代理服务器，例如（FQ）

反向代理：多台客户端访问服务器上的资源的时候，如果用户数量超过了服务器的最大承受限度，通过反向代理分流，把多台客户访问的请求分发到不同的服务器上解决服务器压力的问题

59、路由系统中name的作用

用于反向解析路由,相当于给url取个别名，只要这个名字不变,即使对应的url改变 通过该名字也能找到该条url

60、select_related和prefetch_related的区别？

有外键存在时，可以很好的减少数据库请求的次数,提高性能

#select_related通过多表join关联查询,一次性获得所有数据,只执行一次SQL查询

#prefetch_related分别查询每个表,然后根据它们之间的关系进行处理,执行两次查询

61、django orm 中如何设置读写分离？

​ 1.手动读写分离:通过.using(db_name)来指定要使用的数据库

​ 2.自动读写分离:

​ 1.定义类：如Router #

​ 2.配置Router settings.py中指定DATABASE_ROUTERS

​ DATABASE_ROUTERS = [‘myrouter.Router’,]

62、django中如何根据数据库表生成model中的类？

​ 1.在settings中设置要连接的数据库

2.生成model模型文件

python manage.py inspectdb

3.模型文件导入到models中

​ python manage.py inspectdb > app/models.py

63、什么是RPC

远程过程调用 (RPC) 是一种协议，程序可使用这种协议向网络中的另一台计算机上的程序请求服务

1.RPC采用客户机/服务器模式。请求程序就是一个客户机，而服务提供程序就是一个服务器。

2.首先，客户机调用进程发送一个有进程参数的调用信息到服务进程，然后等待应答信息。 2.在服务器端，进程保持睡眠状态直到调用信息到达为止。当一个调用信息到达，服务器获得进程参数，计算结果，发送答复信息，然后等待下一个调用信息，

3.最后，客户端调用进程接收答复信息，获得进程结果，然后调用执行继续进行。

64、如何实现用户的登录认证

1.cookie session

2.token 登陆成功后生成加密字符串

3.JWT：json wed token缩写 它将用户信息加密到token中,服务器不保存任何用户信息 #服务器通过使用保存的密钥来验证token的正确性

65、抽象继承

​

66、is_valid()的用法

​ 检查对象变量是否已经实例化即实例变量的值是否是个有效的对象句柄

67、pv和uv

1.pv:页面访问量,没打开一次页面PV计算+1,页面刷新也是

#2.UV：独立访问数,一台电脑终端为一个访客

68、django rest framework框架中都有那些组件？

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

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

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

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

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

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

69、使用orm和原生sql的优缺点？

1.orm的开发速度快,操作简单。使开发更加对象化 #执行速度慢。处理多表联查等复杂操作时,ORM的语法会变得复杂

2.sql开发速度慢,执行速度快。性能强

70、F和Q的作用?

F:对数据本身的不同字段进行操作 如:比较和更新

Q：用于构造复杂的查询条件 如：& |操作

71.哪个基金会管理Django Web框架？

Django Web框架由独立的非营利组织Django Software Foundation(DSF)管理和维护。基本的基本目标是促进, 支持和推进Django Web框架。

72 Django是否稳定？

是的, Django非常稳定。像Disqus, Instagram, Pinterest和Mozilla这样的许多公司已经使用Django多年了。

73 Django是内容管理系统(CMS)吗？

不, Django不是CMS。相反, 它是一个Web框架和一个编程工具, 使你能够构建网站。

74 Django中中间件的典型用法是什么？

Django中中间件的一些用法是：

• 会话管理
• 使用身份验证
• 跨站点请求伪造保护
• 内容压缩

75 Django字段类类型有什么作用？

Django字段类类型指定：

• 数据库列类型。
• 呈现表单字段时可用的默认HTML小部件。
• Django管理员中使用的最低验证要求。
• 自动生成的表格。

76 Django-admin.py和manage.py的用法是什么？

Django-admin.py：这是Django的命令行工具, 用于管理任务。

Manage.py：这是每个Django项目中自动创建的文件。它是围绕Django-admin.py的薄包装。它具有以下用法：

• 它将项目的程序包放在sys.path上。
• 它将DJANGO_SETTING_MODULE环境变量设置为指向项目的setting.py文件。

77 Django中的信号是什么？

信号是包含有关正在发生的信息的代码段。调度程序用于发送信号并侦听这些信号。

78 信号中的两个重要参数是什么？

信号中的两个重要参数是：

• 接收器：指定连接到信号的回调函数。
• 发件人：它指定接收信号的特定发件人。

79 如何在Django中处理URL？

为了处理URL, Django框架使用django.urls模块。

让我们打开项目的文件urls.py, 看看它是什么样子：

// urls.py

from django.contrib import admin
from django.urls import path

urlpatterns = [
    path('admin/', admin.site.urls), ]

看, Django已经在这里为管理员提到了一个URL。 path函数将第一个参数作为字符串或正则表达式类型的路由。

view参数是一个视图函数, 用于将响应(模板)返回给用户。

django.urls模块包含各种功能, path(route, view, kwargs, name)是用于映射URL并调用指定视图的功能之一。

80 什么是Django异常？

异常是导致程序失败的异常事件。为了应对这种情况, Django使用其异常类并支持所有核心Python异常。 Django核心异常类在django.core.exceptions模块中定义。

lla这样的许多公司已经使用Django多年了。

73 Django是内容管理系统(CMS)吗？

不, Django不是CMS。相反, 它是一个Web框架和一个编程工具, 使你能够构建网站。

74 Django中中间件的典型用法是什么？

Django中中间件的一些用法是：

• 会话管理
• 使用身份验证
• 跨站点请求伪造保护
• 内容压缩

75 Django字段类类型有什么作用？

Django字段类类型指定：

• 数据库列类型。
• 呈现表单字段时可用的默认HTML小部件。
• Django管理员中使用的最低验证要求。
• 自动生成的表格。

76 Django-admin.py和manage.py的用法是什么？

Django-admin.py：这是Django的命令行工具, 用于管理任务。

Manage.py：这是每个Django项目中自动创建的文件。它是围绕Django-admin.py的薄包装。它具有以下用法：

• 它将项目的程序包放在sys.path上。
• 它将DJANGO_SETTING_MODULE环境变量设置为指向项目的setting.py文件。

77 Django中的信号是什么？

信号是包含有关正在发生的信息的代码段。调度程序用于发送信号并侦听这些信号。

78 信号中的两个重要参数是什么？

信号中的两个重要参数是：

• 接收器：指定连接到信号的回调函数。
• 发件人：它指定接收信号的特定发件人。

79 如何在Django中处理URL？

为了处理URL, Django框架使用django.urls模块。

让我们打开项目的文件urls.py, 看看它是什么样子：

// urls.py

from django.contrib import admin
from django.urls import path

urlpatterns = [
    path('admin/', admin.site.urls), ]

看, Django已经在这里为管理员提到了一个URL。 path函数将第一个参数作为字符串或正则表达式类型的路由。

view参数是一个视图函数, 用于将响应(模板)返回给用户。

django.urls模块包含各种功能, path(route, view, kwargs, name)是用于映射URL并调用指定视图的功能之一。

80 什么是Django异常？

异常是导致程序失败的异常事件。为了应对这种情况, Django使用其异常类并支持所有核心Python异常。 Django核心异常类在django.core.exceptions模块中定义。