第四部分前端、框架和其他（155题）

1. 谈谈你对http协议的认识。

    浏览器本质，socket客户端遵循Http协议
　  HTTP协议本质：通过\r\n分割的规范，请求响应之后断开链接 ==> 短连接、无状态
具体：
　　Http协议是建立在tcp/ip之上的，是一种规范，它规范定了发送的数据的数据格式，
然而这个数据格式是通过\r\n进行分割的，请求头与请求体也是通过2个\r\n分割的，响应的时候，
响应头与响应体也是通过\r\n分割，并且还规定已请求已响应就会断开链接，即-->短连接、无状态

2. 谈谈你对websocket协议的认识。

websocket是给浏览器新建的一套（类似于http）协议，协议规定：浏览器和服务器连接之后不断开，以达到服务端向客户端主动推送消息。
本质：
创建一个连接后不断开的socket
当连接成功之后：
    客户端（浏览器）会自动向服务端发送消息，包含：Sec-WebSocket-Key: iyRe1KMHi4S4QXzcoboMmw==
    服务端接收之后，会对于该数据进行加密：base64(sha1(swk + magic_string))
    构造响应头：
            HTTP/1.1 101 Switching Protocols\r\n
            Upgrade:websocket\r\n
            Connection: Upgrade\r\n
            Sec-WebSocket-Accept: 加密后的值\r\n
            WebSocket-Location: ws://127.0.0.1:8002\r\n\r\n        
    发给客户端（浏览器）
建立：双工通道，接下来就可以进行收发数据
    发送数据是加密，解密，根据payload_len的值进行处理
        payload_len <= 125
        payload_len == 126
        payload_len == 127
    获取内容：
        mask_key
        数据
        根据mask_key和数据进行位运算，就可以把值解析出来。

3. 什么是magic string ？

客户端向服务端发送消息时，会有一个'sec-websocket-key'和'magic string'的随机字符串(魔法字符串)，
 服务端接收到消息后会把他们连接成一个新的key串，进行编码、加密，确保信息的安全性。

4. 如何创建响应式布局？

响应式布局是通过@media实现的
@media （min-width：768px）{
     .pg-header{
           background-color:green;
      }      
}
@media   (min-width:992px){
     .pg-header{
            background-color:pink;
     }
}    

代码
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Title</title>
    <style>
        body{
            margin: 0;
        }
        .pg-header{
            background-color: red;
            height: 48px;
        }

        @media (min-width: 768px) {
            .pg-header{
                background-color: aqua;
            }
        }
        @media (min-width: 992px) {
            .pg-header{
                background-color: blueviolet;
            }
        }
    </style>
</head>
<body>
    <div class="pg-header"></div>
</body>
</html>

View Code

5. 你曾经使用过哪些前端框架？

- jQuery
- Bootstrap
- Vue.js(与vue齐名的前端框架React和Angular)

6. 什么是ajax请求？并使用jQuery和XMLHttpRequest对象实现一个ajax请求。

7. 如何在前端实现轮训？

8. 如何在前端实现长轮训？

9. vuex的作用？

多组件之间共享：vuex

补充luffyvue
1：router-link / router-view
2：双向绑定，用户绑定v-model
3：循环展示课程：v-for
4：路由系统，添加动态参数
5：cookie操作：vue-cookies
6：多组件之间共享：vuex
7：发送ajax请求：axios (js模块)

10. vue中的路由的拦截器的作用？

vue-resource的interceptors拦截器的作用正是解决此需求的妙方。
在每次http的请求响应之后，如果设置了拦截器如下，会优先执行拦截器函数，获取响应体，然后才会决定是否把response返回给then进行接收

11. axios的作用？

发送ajax请求：axios (js模块)

12. 列举vue的常见指令。

  1、v-show指令：条件渲染指令，无论返回的布尔值是true还是false，元素都会存在在html中，只是false的元素会隐藏在html中，并不会删除.
  2、v-if指令：判断指令，根据表达式值得真假来插入或删除相应的值。
  3、v-else指令：配合v-if或v-else使用。
  4、v-for指令：循环指令，相当于遍历。
  5、v-bind：给DOM绑定元素属性。
  6、v-on指令：监听DOM事件。

13. 简述jsonp及实现原理？

JSONP 是json用来跨域的一个东西。原理是通过script标签的跨域特性来绕过同源策略。
JSONP的简单实现：创建一个回调函数，然后在远程服务上调用这个函数并且将JSON数据作为参数传递，完成回调。

14. 是什么cors ？

CORS：跨域资源共享（CORS，Cross-Origin Resource Sharing），随着技术的发展，现在的浏览器可以支持主动设置从而允许跨域请求，其本质是设置响应头，使得浏览器允许跨域请求。

浏览器将CORS请求分成两类：简单请求和复杂请求

简单请求(同时满足以下两大条件)
（1）请求方法是以下三种方法之一:
HEAD
GET
POST
（2）HTTP的头信息不超出以下几种字段：
Accept
Accept-Language
Content-Language
Last-Event-ID
Content-Type：只限于三个值application/x-www-form-urlencoded、multipart/form-data、text/plain

凡是不同时满足上面两个条件，就属于非简单请求

15. 列举Http请求中常见的请求方式？

GET、POST、PUT、DELETE
PATCH（修改数据）
HEAD（类似于get请求，只不过返回的响应中没有具体的内容，用于获取报头）

16. 列举Http请求中的状态码？

分类：
1**  信息，服务器收到请求，需要请求者继续执行操作
2**  成功，操作被成功接收并处理
3**  重定向，需要进一步的操作以完成请求
4**  客户端错误，请求包含语法错误或无法完成请求
5**  服务器错误，服务器在处理请求的过程中发生了错误

常见的状态码
200 - 请求成功
202 - 已接受请求，尚未处理
204 - 请求成功，且不需返回内容
301 - 资源（网页等）被永久转移到其他url
400 - 请求的语义或是参数有错
403 - 服务器拒绝请求
404 - 请求资源（网页）不存在
500 - 内部服务器错误
502 - 网关错误，一般是服务器压力过大导致连接超时
503 - 由于超载或系统维护，服务器暂时的无法处理客户端的请求

17. 列举Http请求中常见的请求头？

- user-agent （代理）
- host
- referer
- cookie 
- content-type

18. 看图写结果：

19. 看图写结果：

20. 看图写结果：

21. 看图写结果：

22. 看图写结果：

23. 看图写结果：

24. django、flask、tornado框架的比较？

#1.Django走的是大而全的方向,开发效率高。它的MTV框架,自带的ORM,admin后台管理,自带的sqlite数据库和开发测试用的服务器
#给开发者提高了超高的开发效率
#2.Flask是轻量级的框架,自由,灵活,可扩展性很强,核心基于Werkzeug WSGI工具和jinja2模板引擎
#3.Tornado走的是少而精的方向,性能优越。它最出名的是异步非阻塞的设计方式
#Tornado的两大核心模块：
#    1.iostraem：对非阻塞式的socket进行简单的封装
#    2.ioloop：对I/O多路复用的封装，它实现了一个单例

25. 什么是wsgi？

    WSGI，全称 Web Server Gateway Interface，是为 Python 语言定义的 Web 服务器和 Web 应用程序或框架之间的一种简单而通用的接口。也就是网关。作用就是在协议之间进行转换。 
    WSGI 是作为 Web 服务器与 Web 应用程序或应用框架之间的一种低级别的接口，以提升可移植 Web 应用开发的共同点。WSGI 是基于现存的 CGI 标准而设计的。 

作用：WSGI有两方：“服务器”或“网关”一方，以及“应用程序”或“应用框架”一方。服务方调用应用方，提供环境信息，以及一个回调函数（提供给应用程序用来将消息头传递给服务器方），并接收Web内容作为返回值。 
所谓的 WSGI中间件同时实现了API的两方，因此可以在WSGI服务和WSGI应用之间起调解作用：从WSGI服务器的角度来说，中间件扮演应用程序，而从应用程序的角度来说，中间件扮演服务器。“中间件”组件可以执行以下功能：
 1. 重写环境变量后，根据目标URL，将请求消息路由到不同的应用对象。
 2. 允许在一个进程中同时运行多个应用程序或应用框架。
 3. 负载均衡和远程处理，通过在网络上转发请求和响应消息。
 4. 进行内容后处理，例如应用XSLT样式表。
#WSGI:
# web服务器网关接口,是一套协议。用于接收用户请求并将请求进行初次封装，然后将请求交给web框架
# 实现wsgi协议的模块：
# 1.wsgiref,本质上就是编写一个socket服务端，用于接收用户请求(django)
# 2.werkzeug,本质上就是编写一个socket服务端，用于接收用户请求(flask)
#uwsgi:
# 与WSGI一样是一种通信协议，它是uWSGI服务器的独占协议,用于定义传输信息的类型
#uWSGI:
# 是一个web服务器,实现了WSGI协议,uWSGI协议,http协议,

对django的认识？

# 1.Django是走大而全的方向，它最出名的是其全自动化的管理后台：只需要使用起ORM，做简单的对象定义，它就能自动生成数据库结构、以及全功能的管理后台。
# 2.Django内置的ORM跟框架内的其他模块耦合程度高。
# 应用程序必须使用Django内置的ORM，否则就不能享受到框架内提供的种种基于其ORM的便利；
# 理论上可以切换掉其ORM模块，但这就相当于要把装修完毕的房子拆除重新装修，倒不如一开始就去毛胚房做全新的装修。
# 3.Django的卖点是超高的开发效率，其性能扩展有限；采用Django的项目，在流量达到一定规模后，都需要对其进行重构，才能满足性能的要求。
# 4.Django适用的是中小型的网站，或者是作为大型网站快速实现产品雏形的工具。
# 5.Django模板的设计哲学是彻底的将代码、样式分离； Django从根本上杜绝在模板中进行编码、处理数据的可能。

django请求的生命周期？

# 1.wsgi,请求封装后交给web框架 （Flask、Django）     
# 2.中间件，对请求进行校验或在请求对象中添加其他相关数据，例如：csrf、request.session     - 
# 3.路由匹配 根据浏览器发送的不同url去匹配不同的视图函数    
# 4.视图函数，在视图函数中进行业务逻辑的处理，可能涉及到：orm、templates => 渲染     - 
# 5.中间件，对响应的数据进行处理。 
# 6.wsgi,将响应的内容发送给浏览器。

列举django的内置组件？

# 1.Admin是对model中对应的数据表进行增删改查提供的组件
# 2.model组件：负责操作数据库
# 3.form组件：1.生成HTML代码2.数据有效性校验3校验信息返回并展示
# 4.ModelForm组件即用于数据库操作,也可用于用户请求的验证

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

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

# MIDDLEWARES中间件的作用和应用场景？
# 中间件是介于request与response处理之间的一道处理过程,用于在全局范围内改变Django的输入和输出。
# 简单的来说中间件是帮助我们在视图函数执行之前和执行之后都可以做一些额外的操作
# 例如：
# 1.Django项目中默认启用了csrf保护,每次请求时通过CSRF中间件检查请求中是否有正确#token值
# 2.当用户在页面上发送请求时，通过自定义的认证中间件，判断用户是否已经登陆，未登陆就去登陆。
# 3.当有用户请求过来时，判断用户是否在白名单或者在黑名单里

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

# 1.使用HttpResponseRedirect
# from django.http import HttpResponseRedirect  
# 2.使用redirect和reverse
# 状态码：301和302
# 301和302的区别：
# 相同点：都表示重定向，浏览器在拿到服务器返回的这个状态码后会自动跳转到一个新的URL地址
# 不同点：
# 301比较常用的场景是使用域名跳转。比如，我们访问 http://www.baidu.com 会跳转到 https://www.baidu.com
# 表示旧地址A的资源已经被永久地移除了
# 302用来做临时跳转，比如未登陆的用户访问用户中心重定向到登录页面。表示旧地址A的资源还在（仍然可以访问），这个重定向只是临时地从旧地址A跳转到地址B

cookie和session的区别：

1. cookie:
cookie是保存在浏览器端的键值对,可以用来做用户认证
2. session：
将用户的会话信息保存在服务端,key值是随机产生的字符串,value值是session的内容

依赖于cookie将每个用户的随机字符串保存到用户浏览器上
Django中session默认保存在数据库中：django_session表
flask的session默认将加密的数据写在用户的cookie中

简述什么是FBV和CBV？

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

简述MVC和MTV

#MVC软件系统分为三个基本部分：模型(Model)、视图(View)和控制器(Controller)
#Model：负责业务对象与数据库的映射(ORM)
#View：负责与用户的交互
#Control：接受用户的输入调用模型和视图完成用户的请求
#Django框架的MTV设计模式借鉴了MVC框架的思想,三部分为：Model、Template和View
#Model(模型)：负责业务对象与数据库的对象(ORM)
#Template(模版)：负责如何把页面展示给用户
#View(视图)：负责业务逻辑，并在适当的时候调用Model和Template
#此外,Django还有一个urls分发器,
#它将一个个URL的页面请求分发给不同的view处理,view再调用相应的Model和Template

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

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

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

#引入method_decorator模块
#1.直接在类上加装饰器
@method_decorator(test,name='dispatch')
class Loginview(View):
    pass
#2.直接在处理的函数前加装饰器
@method_decorator(test)
def post(self,request,*args,**kwargs):
    pass

列举django orm 中所有的方法（QuerySet对象的所有方法）

#<1> all():                  查询所有结果 
#<2> filter(**kwargs):       它包含了与所给筛选条件相匹配的对象。获取不到返回None
#<3> get(**kwargs):          返回与所给筛选条件相匹配的对象，返回结果有且只有一个。获取不到会返回None
#如果符合筛选条件的对象超过一个或者没有都会抛出错误。
#<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():            从返回结果中剔除重复纪录

only和defer的区别？

# defer('id','name'):取出对象，字段除了id和name都有
# only('id','name'):取的对象，只有id和name

select_related和prefetch_related的区别？

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

filter和exclude的区别？

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

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

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

# 1.手动读写分离:通过.using(db_name)来指定要使用的数据库
# 2.自动读写分离:
#    1.定义类：如Router
#    2.配置Router
#        settings.py中指定DATABASE_ROUTERS
#        DATABASE_ROUTERS = ['myrouter.Router',] 
# 提高读的性能：多配置几个数据库,并在读取时,随机选取。写的时候写到主库
# 实现app之间的数据库分离：分库分表

F和Q的作用?

# F:对数据本身的不同字段进行操作 如:比较和更新
# Q：用于构造复杂的查询条件 如：& |操作

values和values_list的区别？

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

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

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

django的Form和ModeForm的作用？

# Form作用：
#    1.在前端生成HTML代码
#    2.对数据作有效性校验
#    3.返回校验信息并展示
# ModeForm：根据模型类生成From组件,并且可以操作数据库

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())//多选

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

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

django中csrf的实现机制？

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

django如何实现websocket？

# 列举django orm中三种能写sql语句的方法。
# 1.使用execute执行自定义的SQL
# 2.使用extra方法 
# 3.使用raw方法
#    1.执行原始sql并返回模型
#    2.依赖model多用于查询

基于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")}

django中如何实现orm表中添加数据时创建一条日志记录。

django内置的缓存如何设置？

# 全站缓存
MIDDLEWARE_CLASSES = (
    ‘django.middleware.cache.UpdateCacheMiddleware’, #第一
    'django.middleware.common.CommonMiddleware',
    ‘django.middleware.cache.FetchFromCacheMiddleware’, #最后
)

# 视图缓存
from django.views.decorators.cache import cache_page
import time

@cache_page(15)          #超时时间为15秒
def index(request):
 t=time.time()      #获取当前时间
 return render(request,"index.html",locals())

# 模板缓存
{% load cache %}
 <h3 style="color: green">不缓存:-----{{ t }}</h3>

{% cache 2 'name' %} # 存的key
 <h3>缓存:-----:{{ t }}</h3>
{% endcache %}

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

#1.安装 pip install django-redis
#2.在stting中配置CACHES,可以设置多个缓存,根据名字使用
        CACHES = {
            "default": {
                "BACKEND": "django_redis.cache.RedisCache",
                "LOCATION": "redis://127.0.0.1:6379",
                "OPTIONS": {
                    "CLIENT_CLASS": "django_redis.client.DefaultClient",
                    "CONNECTION_POOL_KWARGS": {"max_connections": 100}
                    # "PASSWORD": "密码",
                }
            }
        },
        #另添加缓存
        "JERD": { }
#3.根据名字去连接池中获取连接
        from django_redis import get_redis_connection
        conn = get_redis_connection("default")

django路由系统中name的作用？

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

django的模板中filter和simple_tag的区别？

1. 自定义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{ % loadmyfilters %}
{{name | add_sb: 'xxx'}}
{{name | sb: 'xxx'}}

2. 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 %}

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 隔离开，实现真正的部署 。
# 相比来讲，支持的并发量更高，方便管理多进程，发挥多核的优势，提升性能。

django-debug-toolbar的作用？

# 作用：
# 1.是django的第三方工具包,给django扩展了调试功能
# 包括查看sql语句,db查询次数,request,headers等

# 1. 配置
pip install django-debug-toolbar   
在settings.py里的 INSTALLED_APPS 添加 'debug_toolbar'，在MIDDLEWARE里添加 'debug_toolbar.middleware.DebugToolbarMiddleware',

#显示设置调试工具不要调整settings中的设置
DEBUG_TOOLBAR_PATCH_SETTINGS = False
# 添加调试工具的IP
INTERNAL_IPS = ("127.0.0.1",)
# 在settings.py去使用DEBUG_TOOLBAR_PANELS配置我们需要显示的面板即可
DEBUG_TOOLBAR_PANELS = [
    # 代表是哪个django版本
    'debug_toolbar.panels.versions.VersionsPanel',
    # 用来计时的，判断加载当前页面总共花的时间
    'debug_toolbar.panels.timer.TimerPanel',
    # 读取django中的配置信息
    'debug_toolbar.panels.settings.SettingsPanel',
    # 看到当前请求头和响应头信息
    'debug_toolbar.panels.headers.HeadersPanel',
    # 当前请求的想信息（视图函数，Cookie信息，Session信息等）
    'debug_toolbar.panels.request.RequestPanel',
    # 查看SQL语句
    'debug_toolbar.panels.sql.SQLPanel',
    # 静态文件
    'debug_toolbar.panels.staticfiles.StaticFilesPanel',
    # 模板文件
    'debug_toolbar.panels.templates.TemplatesPanel',
    # 缓存
    'debug_toolbar.panels.cache.CachePanel',
    # 信号
    'debug_toolbar.panels.signals.SignalsPanel',
    # 日志
    'debug_toolbar.panels.logging.LoggingPanel',
    # 重定向
    'debug_toolbar.panels.redirects.RedirectsPanel',
]

# 添加到全局url
if settings.DEBUG:
    import debug_toolbar
    urlpatterns += patterns('', url(r'^__debug__/', include(debug_toolbar.urls)),)

django中如何实现单元测试？

解释orm中 db first 和 code first的含义？

# 数据持久化的方式：
# db first基于已存在的数据库,生成模型
# code first基于已存在的模型,生成数据库库

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

# 1.在settings中设置要连接的数据库
# 2.生成model模型文件
# python manage.py inspectdb
# 3.模型文件导入到models中
#    python manage.py inspectdb > app/models.py

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

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

django的contenttype组件的作用？

# 这个组件保存了项目中所有app和model的对应关系,每当我们创建了新的model并执行数据库迁移后，ContentType表中就会自动新增一条记录
# 当一张表和多个表FK关联,并且多个FK中只能选择其中一个或其中n个时,可以利用contenttypes

谈谈你对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/
            }
    }

接口的幂等性是什么意思？

#1.是系统的接口对外一种承诺(而不是实现)
#2.承诺只要调用接口成功,外部多次调用对系统的影响都是一致的,不会对资源重复操作

什么是RPC？

#远程过程调用 (RPC) 是一种协议，程序可使用这种协议向网络中的另一台计算机上的程序请求服务
#1.RPC采用客户机/服务器模式。请求程序就是一个客户机，而服务提供程序就是一个服务器。
#2.首先，客户机调用进程发送一个有进程参数的调用信息到服务进程，然后等待应答信息。
#2.在服务器端，进程保持睡眠状态直到调用信息到达为止。当一个调用信息到达，服务器获得进程参数，计算结果，发送答复信息，然后等待下一个调用信息，
#3.最后，客户端调用进程接收答复信息，获得进程结果，然后调用执行继续进行。

Http和Https的区别？

为什么要使用django rest framework框架？

# 能自动生成符合 RESTful 规范的 API
# 1.在开发REST API的视图中，虽然每个视图具体操作的数据不同，
#但增、删、改、查的实现流程基本一样,这部分的代码可以简写
# 2.在序列化与反序列化时，虽然操作的数据不同，但是执行的过程却相似,这部分的代码也可以简写
# REST framework可以帮助简化上述两部分的代码编写，大大提高REST API的开发速度

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中获取版本，根据版本不同 做不同处理

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

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

#1.用户请求走进来后,走APIView,初始化了默认的认证方法
#2.走到APIView的dispatch方法,initial方法调用了request.user
#3.如果我们配置了认证类,走我们自己认证类中的authentication方法

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

#使用IP/用户账号作为键，每次的访问时间戳作为值，构造一个字典形式的数据，存起来，每次访问时对时间戳列表的元素进行判断，
#把超时的删掉，再计算列表剩余的元素数就能做到频率限制了 
#匿名用户：使用IP控制，但是无法完全控制，因为用户可以换代理IP登录用户：使用账号控制，但是如果有很多账号，也无法限制

rest_framework序列化组件的作用,以及一些外键关系的钩子方法

#作用：帮助我们序列化数据
#1.choices  get_字段名_display
#2.ForeignKey source=orm 操作
#3.ManyToManyFiled  SerializerMethodField()
#                    def get_字段名():
#                    return 自定义

如何将dict转换成url的格式

# 使用urlencode
# from urllib.parse import urlencode
# post_data={"k1"："v1","k2":"v2"}
# ret=urlencode(post_data)
# print(ret,type(ret))  #k1=v1&k2=v2 <class 'str'>

Flask框架的优势？
Flask框架依赖组件？
Flask蓝图的作用？
列举使用过的Flask第三方组件？
简述Flask上下文管理流程?
Flask中的g的作用？
Flask中上下文管理主要涉及到了那些相关的类？并描述类主要作用？
为什么要Flask把Local对象中的的值stack 维护成一个列表？
Flask中多app应用是怎么完成？
在Flask中实现WebSocket需要什么组件？
wtforms组件的作用？
Flask框架默认session处理机制？
解释Flask框架中的Local对象和threading.local对象的区别？
Flask中 blinker 是什么？
SQLAlchemy中的 session和scoped_session 的区别？
SQLAlchemy如何执行原生SQL？
ORM的实现原理？
DBUtils模块的作用？

以下SQLAlchemy的字段是否正确？如果不正确请更正：

from datetime import datetime
 from sqlalchemy.ext.declarative
import declarative_base
 from sqlalchemy import Column, Integer, String, DateTime
  
Base = declarative_base()  
class UserInfo(Base):    
    __tablename__ = 'userinfo'    
    id = Column(Integer, primary_key=True, autoincrement=True) 
    name = Column(String(64), unique=True) 
    ctime = Column(DateTime, default=datetime.now())

SQLAchemy中如何为表设置引擎和字符编码？
SQLAchemy中如何设置联合唯一索引？
简述Tornado框架的特点。
简述Tornado框架中Future对象的作用？
Tornado框架中如何编写WebSocket程序？
Tornado中静态文件是如何处理的？ 如： <link href="{{static_url("commons.css")}}" rel="stylesheet" />
Tornado操作MySQL使用的模块？
Tornado操作redis使用的模块？
简述Tornado框架的适用场景？

git常见命令作用：

# 1. git init 初始化，当前所在的文件夹可以被管理且以后版本相关的数据都会存储到.git文件中
# 2. git status 查看当前文件夹以及子目录中文件是否发生变化：内容修改/新增文件/删除，已经变化的文件会变成红色，已经add的文件会变成绿色
# 3. git add . 给发生变化的文件（贴上一个标签）或 将发生变化的文件放到某个地方，只写一个句点符就代表把git status中红色的文件全部打上标签
# 4. git commit -m ‘新增用户登录认证功能以及xxx功能’ 将“绿色”文件添加到版本中
# 5. git log 查看所有版本提交记录，可以获取版本号
# 6. git reset –hard 版本号 将最新的版本回退到更早的版本
# 7. git reflog 回退到之前版本后悔了，再更新到最新或者最新之前的版本
# 8. git reset –hard 版本 回退

简述以下git中stash命令作用以及相关其他命令。

# stash用于将工作区发生变化的所有文件获取临时存储在“某个地方”，将工作区还原当前版本未操作前的状态；stash还可以将临时存储在“某个地方”的文件再次拿回到工作区。

# 1. git stash 将当前工作区所有修改过的内容存储到“某个地方”，将工作区 # 2. 还原到当前版本未修改过的状态
# 3. git stash list 查看“某个地方”存储的所有记录
# 4. git stash clear 清空“某个地方”
# 5. git stash pop 将第一个记录从“某个地方”重新拿到工作区（可能有冲突）
# 6. git stash apply 编号, 将指定编号记录从“某个地方”重新拿到工作区（可能有冲突）
# 7. git stash drop 编号，删除指定编号的记录

git 中 merge 和 rebase命令的区别。

# 采用merge和rebase后，git log的区别，merge命令不会保留merge的分支的commit

公司如何基于git做的协同开发？
https://www.cnblogs.com/abelsu/p/5138136.html
如何基于git实现代码review？
git如何实现v1.0 、v2.0 等版本的管理？

什么是gitlab？

# GitLab 是一个用于仓库管理系统的开源项目，使用Git作为代码管理工具，并在此基础上搭建起来的web服务。安装方法是参考GitLab在GitHub上的Wiki页面。

github和gitlab的区别？

先说一下相同点，二者都是基于web的Git仓库，在很大程度上GitLab是仿照GitHub来做的，它们都提供了分享开源项目的平台，为开发团队提供了存储、分享、发布和合作开发项目的中心化云存储的场所。

GitHub作为开源代码库及版本控制系统，拥有超过900万的开发者用户，目前仍然是最火的开源项目托管系统。GitHub同时提供公共仓库和私有仓库，但如果要使用私有仓库，是需要付费的。

而GitLab解决了这个问题，你可以在上面创建私人的免费仓库。

GitLab让开发团队对他们的代码仓库拥有更多的控制，相比于GitHub，它有不少的特色：

允许免费设置仓库权限；允许用户选择分享一个project的部分代码；允许用户设置project的获取权限，进一步的提升安全性；可以设置获取到团队整体的改进进度；通过innersourcing让不在权限范围内的人访问不到该资源。

从代码私有性方面来看，有时公司并不希望员工获取到全部的代码，这个时候GitLab无疑是更好的选择。但对于开源项目而言，GitHub依然是代码托管的首选。

如何为github上牛逼的开源项目贡献代码？

对一个开源项目有足够了解的情况下，如果你发现问题或者更好的解决方案的话，可以开个issue先。

一般情况下维护这个项目的人或者其他使用这个项目的人会参与讨论的，然后基于这些讨论你可以发一些pull requests。

如果你的方案得到很多人赞同的话，项目维护人员会把他们merge，你也就成了这个项目的contributor了。

当然很多情况下，你开的这个issue已经有人提过了，或者说是你自己误解了，但是相信在和其他开发人员交流的过程中，你也能学到许多。

git中 .gitignore文件的作用?

一般来说每个Git项目中都需要一个“.gitignore”文件，这个文件的作用就是告诉Git哪些文件不需要添加到版本管理中。

实际项目中，很多文件都是不需要版本管理的，比如Python的.pyc文件和一些包含密码的配置文件等等。

什么是敏捷开发？

敏捷开发以用户的需求进化为核心，采用迭代、循序渐进的方法进行软件开发。在敏捷开发中，软件项目在构建初期被切分成多个子项目，各个子项目的成果都经过测试，具备可视、可集成和可运行使用的特征。
换言之，就是把一个大项目分为多个相互联系，但也可独立运行的小项目，并分别完成，在此过程中软件一直处于可使用状态。

简述 jenkins 工具的作用?
公司如何实现代码发布？
简述 RabbitMQ、Kafka、ZeroMQ的区别？
RabbitMQ如何在消费者获取任务后未处理完前就挂掉时，保证数据不丢失？
RabbitMQ如何对消息做持久化？
RabbitMQ如何控制消息被消费的顺序？
以下RabbitMQ的exchange type分别代表什么意思？如：fanout、direct、topic。
简述 celery 是什么以及应用场景？
简述celery运行机制。
celery如何实现定时任务？
简述 celery多任务结构目录？
celery中装饰器 @app.task 和 @shared_task的区别？

简述 requests模块的作用及基本使用？

使用requests可以模拟浏览器发送的请求
发送get请求：requests.get()
发送post请求:requests.post()
读取请求返回内容:requests.text()
保存cookie:requests.cookie()

简述 beautifulsoup模块的作用及基本使用？

简述 seleninu模块的作用及基本使用?

selenium最初是一个自动化测试工具,而爬虫中使用它主要是为了解决requests无法直接执行JavaScript代码的问题

selenium本质是通过驱动浏览器，完全模拟浏览器的操作，比如跳转、输入、点击、下拉等，来拿到网页渲染之后的结果，可支持多种浏览器

scrapy框架中各组件的工作流程？

Scrapy Engine(引擎): 负责Spider、ItemPipeline、Downloader、Scheduler中间的通讯，信号、数据传递等。

Scheduler(调度器): 它负责接受引擎发送过来的Request请求，并按照一定的方式进行整理排列，入队，当引擎需要时，交还给引擎。

Downloader（下载器）：负责下载Scrapy Engine(引擎)发送的所有Requests请求，并将其获取到的Responses交还给Scrapy Engine(引擎)，由引擎交给Spider来处理，

Spider（爬虫）：它负责处理所有Responses,从中分析提取数据，获取Item字段需要的数据，并将需要跟进的URL提交给引擎，再次进入Scheduler(调度器)，

Item Pipeline(管道)：它负责处理Spider中获取到的Item，并进行进行后期处理（详细分析、过滤、存储等）的地方.

Downloader Middlewares（下载中间件）：你可以当作是一个可以自定义扩展下载功能的组件。

Spider Middlewares（Spider中间件）：你可以理解为是一个可以自定扩展和操作引擎和Spider中间通信的功能组件（比如进入Spider的Responses;和从Spider出去的Requests）

在scrapy框架中如何设置代理（两种方法）？

from scrapy.downloadermiddlewares.httpproxy import HttpProxyMiddleware 
from urllib.request import getproxies

scrapy框架中如何实现大文件的下载？
```
FilesPipeline
ImagesPipeline
```

scrapy中如何实现限速？

修改setting文件的AUTOTHROTTLE_START_DELAY 打开后默认限速为5秒

scrapy中如何实现暂定爬虫？

在cmd上cd 进入项目 
然后在项目目录下创建 记录文件：remain/001 
然后输入：scrapy crawl zhihu -s JOBDIR=remain/001 
回车运行就行了 
按ctrl+c 暂停 
继续运行只要再次输入：scrapy crawl zhihu -s JOBDIR=remain/001就行了 
需要重新爬取就换个文件 002就行了

scrapy中如何进行自定制命令？

scrapy中如何实现的记录爬虫的深度？

class scrapy.contrib.spidermiddleware.depth.DepthMiddleware 
DepthMiddleware是一个用于追踪每个Request在被爬取的网站的深度的中间件。 其可以用来限制爬取深度的最大深度或类似的事情。

DepthMiddleware 可以通过下列设置进行配置(更多内容请参考设置文档):

DEPTH_LIMIT - 爬取所允许的最大深度，如果为0，则没有限制。 
DEPTH_STATS - 是否收集爬取状态。 
DEPTH_PRIORITY - 是否根据其深度对requet安排优先级

scrapy中的pipelines工作原理？

Scrapy 提供了 pipeline 模块来执行保存数据的操作。在创建的 Scrapy 项目中自动创建了一个 pipeline.py 文件，同时创建了一个默认的 Pipeline 类。我们可以根据需要自定义 Pipeline 类，然后在 settings.py 文件中进行配置即可

scrapy的pipelines如何丢弃一个item对象？

到pipelines的时候不执行持久化保存就会什么也不执行也就是丢弃

简述scrapy中爬虫中间件和下载中间件的作用？

下载器中间件(Downloader Middlewares) 
位于Scrapy引擎和下载器之间的框架，主要是处理Scrapy引擎与下载器之间的请求及响应。 
爬虫中间件(Spider Middlewares) 
介于Scrapy引擎和爬虫之间的框架，主要工作是处理蜘蛛的响应输入和请求输出。

scrapy-redis组件的作用？

scheduler - 调度器 
dupefilter - URL去重规则（被调度器使用） 
pipeline - 数据持久化

scrapy-redis组件中如何实现的任务的去重？

# 定义去重规则（被调度器调用并应用）

  a. 内部会使用以下配置进行连接Redis

      # REDIS_HOST = 'localhost'                            # 主机名
      # REDIS_PORT = 6379                                   # 端口
      # REDIS_URL = 'redis://user:pass@hostname:9001'       # 连接URL（优先于以上配置）
      # REDIS_PARAMS  = {}                                  # Redis连接参数             默认：REDIS_PARAMS = {'socket_timeout': 30,'socket_connect_timeout': 30,'retry_on_timeout': True,'encoding': REDIS_ENCODING,}）
      # REDIS_PARAMS['redis_cls'] = 'myproject.RedisClient' # 指定连接Redis的Python模块  默认：redis.StrictRedis
      # REDIS_ENCODING = "utf-8"                            # redis编码类型             默认：'utf-8'

  b. 去重规则通过redis的集合完成，集合的Key为：

      key = defaults.DUPEFILTER_KEY % {'timestamp': int(time.time())}
      默认配置：
          DUPEFILTER_KEY = 'dupefilter:%(timestamp)s'

  c. 去重规则中将url转换成唯一标示，然后在redis中检查是否已经在集合中存在

      from scrapy.utils import request
      from scrapy.http import Request

      req = Request(url='http://www.cnblogs.com/wupeiqi.html')
      result = request.request_fingerprint(req)
      print(result) # 8ea4fd67887449313ccc12e5b6b92510cc53675c


      PS:
          - URL参数位置不同时，计算结果一致；
          - 默认请求头不在计算范围，include_headers可以设置指定请求头
          示例：
              from scrapy.utils import request
              from scrapy.http import Request

              req = Request(url='http://www.baidu.com?name=8&id=1',callback=lambda x:print(x),cookies={'k1':'vvvvv'})
              result = request.request_fingerprint(req,include_headers=['cookies',])

              print(result)

              req = Request(url='http://www.baidu.com?id=1&name=8',callback=lambda x:print(x),cookies={'k1':666})

              result = request.request_fingerprint(req,include_headers=['cookies',])

              print(result)

scrapy-redis的调度器如何实现任务的深度优先和广度优先？
简述 vitualenv 及应用场景?
简述 pipreqs 及应用场景？
在Python中使用过什么代码检查工具？
简述 saltstack、ansible、fabric、puppet工具的作用？
B Tree和B+ Tree的区别？
请列举常见排序并通过代码实现任意三种。
请列举常见查找并通过代码实现任意三种。
请列举你熟悉的设计模式？
有没有刷过leetcode？
列举熟悉的的Linux命令。
公司线上服务器是什么系统？
解释 PV、UV 的含义？
解释 QPS的含义？
uwsgi和wsgi的区别？
supervisor的作用？
什么是反向代理？
简述SSH的整个过程。
有问题都去那些找解决方案？
是否有关注什么技术类的公众号？
最近在研究什么新技术？
是否了解过领域驱动模型？

posted @ 2021-03-02 10:15 huangyanpeng 阅读(231) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

阅读排行：
· C# 13 中的新增功能实操
· Ollama本地部署大模型总结
· 【杭电多校比赛记录】2025“钉耙编程”中国大学生算法设计春季联赛（4）
· langchain0.3教程：从0到1打造一个智能聊天机器人
· 2025成都.NET开发者Connect圆满结束

公告

昵称： huangyanpeng
园龄： 7年5个月
粉丝： 15
关注： 68

2025年3月

日

一

二

三

四

五

六

huangyanpeng

第四部分前端、框架和其他（155题）

公告

搜索

常用链接

随笔分类

随笔档案

文章分类

阅读排行榜

评论排行榜

推荐排行榜

最新评论