python面试题解析(前端、框架和其他)

答：

HTTP是一个属于应用层的面向对象的协议，由于其简捷、快速的方式，适用于分布式超媒体信息系统。它于1990年提出，经过几年的使用与发展，得到不断地完善和扩展。目前在WWW中使用的是HTTP/1.0的第六版，HTTP/1.1的规范化工作正在进行之中，而且HTTP-NG(Next Generation of HTTP)的建议已经提出。
HTTP协议的主要特点可概括如下：
1.支持客户/服务器模式。
2.简单快速：客户向服务器请求服务时，只需传送请求方法和路径。请求方法常用的有GET、HEAD、POST。每种方法规定了客户与服务器联系的类型不同。由于HTTP协议简单，使得HTTP服务器的程序规模小，因而通信速度很快。
3.灵活：HTTP允许传输任意类型的数据对象。正在传输的类型由Content-Type加以标记。
4.无连接：无连接的含义是限制每次连接只处理一个请求。服务器处理完客户的请求，并收到客户的应答后，即断开连接。采用这种方式可以节省传输时间。
5.无状态：HTTP协议是无状态协议。无状态是指协议对于事务处理没有记忆能力。缺少状态意味着如果后续处理需要前面的信息，则它必须重传，这样可能导致每次连接传送的数据量增大。另一方面，在服务器不需要先前信息时它的应答就较快。

答：

WebSocket协议支持（在受控环境中运行不受信任的代码的）客户端与（选择加入该代码的通信的）远程主机之间进行全双工通信。用于此的安全模型是Web浏览器常用的基于原始的安全模式。协议包括一个开放的握手以及随后的TCP层上的消息帧。
该技术的目标是为基于浏览器的、需要和服务器进行双向通信的（服务器不能依赖于打开多个HTTP连接（例如，使用XMLHttpRequest或<iframe>和长轮询））应用程序提供一种通信机制。

答:

所谓魔数和魔字符串就是在代码中直接使用某一个数字或者字符串，而不是常量。

4.答：

通过浏览器和设备分辨率的改变做出相应的变化

本质是通过 @media属性来完成：

<style>

body{

margin:0;}

.pg-header{

background-color:red;

height: 48px;}

@media(
min-width: 768px ){

.pg-header{background-color: green;}}

@media(
min-width: 992px ){

.pg-header{background-color: pink;}}

</style>

1.布局及设置meta标签

2.通过媒体查询来设置样式media query

3.设置多种视图宽度

4.字体设置

5.答：

-
jQuery

-
BootStrap

-
Vue.js、React、Angular.js

6．答：

AJAX，Asynchronous
JavaScript and XML (异步的JavaScript和XML)，一种创建交互式网页应用的网页开发技术方案。

异步的JavaScript：
使用【JavaScript语言】以及相关【浏览器提供类库】的功能向服务端发送请求，当服务端处理完请求之后，【自动执行某个JavaScript的回调函数】。
PS：以上请求和响应的整个过程是【偷偷】进行的，页面上无任何感知。

XML
XML是一种标记语言，是Ajax在和后台交互时传输数据的格式之一

利用AJAX可以做：
1、注册时，输入用户名自动检测用户是否已经存在。
2、登陆时，提示用户名密码错误
3、删除数据行时，将行ID发送到后台，后台在数据库中删除，数据库删除成功后，在页面DOM中将数据行也删除。（博客园）

<!DOCTYPE
html>

<html>

</head>

<body>

<p>

</p>

function JqSendRequest(){

$.ajax({

url:
"http://c2.com:8000/test/",

type: 'GET',

dataType: 'text',

success: function(data,
statusText, xmlHttpRequest){

console.log(data);

}

})

}

</script>

</body>

</html>

基于jQueryAjax - Demo

7.答：

轮询

轮询是在特定的的时间间隔（如每1秒），由浏览器对服务器发出HTTP request，然后由服务器返回最新的数据给客户端的浏览器。这种传统的HTTP request 的模式带来很明显的缺点 – 浏览器需要不断的向服务器发出请求，然而HTTP request 的header是非常长的，里面包含的有用数据可能只是一个很小的值，这样会占用很多的带宽。

var
xhr = new XMLHttpRequest();

setInterval(function(){

xhr.open('GET','/user');

xhr.onreadystatechange = function(){

};

xhr.send();

},1000)

8.
答：

ajax实现:在发送ajax后,服务器端会阻塞请求直到有数据传递或超时才返回。客户端JavaScript响应处理函数会在处理完服务器返回的信息后，再次发出请求，重新建立连接。

function ajax(){

var xhr = new XMLHttpRequest();

xhr.open('GET','/user');

xhr.onreadystatechange = function(){

ajax();

};

xhr.send();

}

9.答：

它采用集中式存储管理应用的所有组件的状态，并以相应的规则保证状态以一种可预测的方式发生变化。

10.答：

在每次http的请求响应之后，如果设置了拦截器如下，会优先执行拦截器函数，获取响应体，然后才会决定是否把response返回给then进行接收。那么我们可以在这个拦截器里边添加对响应状态码的判断，来决定是跳转到登录页面还是留在当前页面继续获取数据。

11.
答：

Axios的特点

从浏览器中创建 XMLHttpRequests

从 node.js 创建 http 请求

支持 Promise API

拦截请求和响应
（就是有interceptor）

转换请求数据和响应数据

取消请求

自动转换 JSON 数据

客户端支持防御 XSRF

12.
答：

v-if//v-show//v-else//v-for//v-bind//v-on

13.答：

JSONP原理：
首先在客户端注册一个callback, 然后把callback的名字传给服务器。

此时，服务器先生成 json 数据。
然后以 javascript 语法的方式，生成一个function
, function 名字就是传递上来的参数 jsonp.

最后将 json 数据直接以入参的方式，放置到
function 中，这样就生成了一段 js 语法的文档，返回给客户端。

客户端浏览器，解析script标签，并执行返回的
javascript 文档，此时数据作为参数，传入到了客户端预先定义好的 callback 函数里.（动态执行回调函数）

14.
答：

Cross-Origin
Resource Sharing（CORS）跨域资源共享是一份浏览器技术的规范，提供了 Web 服务从不同域传来沙盒脚本的方法，以避开浏览器的同源策略，是 JSONP 模式的现代版。与 JSONP 不同，CORS 除了 GET 要求方法以外也支持其他的 HTTP 要求。用 CORS 可以让网页设计师用一般的 XMLHttpRequest，这种方式的错误处理比 JSONP 要来的好。另一方面，JSONP 可以在不支持 CORS 的老旧浏览器上运作。现代的浏览器都支持 CORS。

15．答：

GET：用于请求访问已经被URI（统一资源标识符）识别的资源，可以通过URL传参给服务器

POST：用于传输信息给服务器，主要功能与GET方法类似，但一般推荐使用POST方式。

PUT：传输文件，报文主体中包含文件内容，保存到对应URI位置。

HEAD：获得报文首部，与GET方法类似，只是不返回报文主体，一般用于验证URI是否有效。

DELETE：删除文件，与PUT方法相反，删除对应URI位置的文件。

OPTIONS：查询相应URI支持的HTTP方法。

16.答：

200：请求被正常处理

204：请求被受理但没有资源可以返回

206：客户端只是请求资源的一部分，服务器只对请求的部分资源执行GET方法，相应报文中通过Content-Range指定范围的资源。

301：永久性重定向

302：临时重定向

303：与302状态码有相似功能，只是它希望客户端在请求一个URI的时候，能通过GET方法重定向到另一个URI上

304：发送附带条件的请求时，条件不满足时返回，与重定向无关

307：临时重定向，与302类似，只是强制要求使用POST方法

400：请求报文语法有误，服务器无法识别

401：请求需要认证

403：请求的对应资源禁止被访问

404：服务器无法找到对应资源

500：服务器内部错误

503：服务器正忙

17.答：

1.
通用首部字段（请求报文与响应报文都会使用的首部字段）

- Date：创建报文时间

- Connection：连接的管理

- Cache-Control：缓存的控制

- Transfer-Encoding：报文主体的传输编码方式

2.
请求首部字段（请求报文会使用的首部字段）

- Host：请求资源所在服务器

- Accept：可处理的媒体类型

- Accept-Charset：可接收的字符集

- Accept-Encoding：可接受的内容编码

- Accept-Language：可接受的自然语言

3.
响应首部字段（响应报文会使用的首部字段）

- Accept-Ranges：可接受的字节范围

- Location：令客户端重新定向到的URI

- Server：HTTP服务器的安装信息

4.
实体首部字段（请求报文与响应报文的的实体部分使用的首部字段）

- Allow：资源可支持的HTTP方法

- Content-Type：实体主类的类型

- Content-Encoding：实体主体适用的编码方式

- Content-Length：实体主体的的字节数

- Content-Range：实体主体的位置范围，一般用于发出部分请求时使用

18.答：李杰

19.答：武沛齐

20.答：老男孩

21.答：undefined

22.答: 武沛齐

23.答：ALEX

24.答：

一、对外数据接口

三者作为web框架，都是通过url映射对外的接口

flask：以decorator的形式，映射到函数中

django：以字典形式，映射到函数

tornado:
以字典形式，映射到类中

flask的接口散落在整个app文件中，多了的话，稍微不易于管理；django单独集中在url.py文件中，挺好。

对于接口简单（如cms系统），映射到函数，简单明了；对于复杂的接口（富应用的web app），映射到类，更适合面向对象编程。

二、可扩展性

flask：作为微型框架，它可以自由组配外部功能模块，如orm、template机制等

django：作为大而全框架，它几乎不可能组配其他外部功能模块，但是可以增加丰富它的Middlerware/contrib等

tornado：接近flask

三、代码层次结构

作为framwork，三者的架构基本都是一个callable的App类为核心，

django对使用者，呈现的是mvc结构。比较符合现在的主流。当然flask/tornado都容易做到mvc，只是额外增加工作量。

四、开发效率

flask：由于它协助完成功能很少，除非是小型应用，否则它开发效率比较大

django：大而全的框架，完成了session/orm/等。如果考虑安全性在内，对于一般网站，它的开发效率是非常高的。

tornado：介于flask、django之间。由于没有session机制，所以开发效率也不低。但它原生实现了websocket，所以对于开发需要很多长连接的web应用，会比较快。

五、并发能力

flask：内容很少，对于大应用，性能如何，很大程度看后面人员如何扩展

django：由于代码量大，而且又是同步的，所以抗压能力很弱

tornado：异步框架，性能相对好

实际上，生产时候，都是把framework通过nginx/gevent部署，而tornado对于前面二者来说，并发性能也没有优势。

总体而言：

flask适合用于小型应用开发；如果开发团队能力强，也可以用来做大中型应用

django适合应用用于访问量不大的大中型应用

tornado适合用于开发长连接多的web应用。比如股票信息推送、网络聊天等。

25.答：

是web服务网关接口，是一套协议。以下模块实现了wsgi协议：

- wsgiref ：性能低，易配置

- werkzurg

- uwsgi

以上模块本质：实现socket监听请求，获取请求后将数据封装，然后交给web框架处理

详解：

本质是编写了socket服务端，用来监听用户的请求，如果有请求到来，则将请求进行一次封装然后将【请求】交给web框架来进行下一步处理

26.答：

1.
当用户在浏览器中输入url时,浏览器会生成请求头和请求体发给服务端请求头和请求体中会包含浏览器的动作(action),这个动作通常为get或者post,体现在url之中.

2.
url经过Django中的wsgi,再经过Django的中间件,最后url到过路由映射表,在路由中一条一条进行匹配, 一旦其中一条匹配成功就执行对应的视图函数,后面的路由就不再继续匹配了.

3.
视图函数根据客户端的请求查询相应的数据.返回给Django,然后Django把客户端想要的数据做为一个字符串返回给客户端.

4.
客户端浏览器接收到返回的数据,经过渲染后显示给用户.

27.答：model
form,form,admin ,view,middleware.

28.答：

django
中的中间件（middleware），在django中，中间件其实就是一个类，在请求到来和结束后，django会根据自己的规则在合适的时机执行中间件中相应的方法。

中间件中可以定义五个方法，分别是：

process_request(self,request)

process_view(self,
request, callback, callback_args, callback_kwargs)

process_template_response(self,request,response)

process_exception(self,
request, exception)

process_response(self,
request, response)

29.答：

FBV（function
base views）就是在视图里使用函数处理请求。

CBV（class
base views）就是在视图里使用类处理请求。

30.答：

当请求一个页面时，Django会建立一个包含请求元数据的HttpRequest对象。当Django加载对应的视图的时候，HttpRequest对象将作为视图函数的第一个参数。每个视图会返回一个HttpResponse对象。

31.答：

#在用户认证时的一个应用

装饰器：

FBV：

def
auth(func):

def inner(reqeust,*args,**kwargs):

v = reqeust.COOKIES.get('user')

if not v:

return redirect('/login')

return func(reqeust, *args,**kwargs)

return inner

CBV:

from
django import views

from
django.utils.decorators import
method_decorator

@method_decorator(auth,
name='dispatch') #也可以写到类上, 这样在get,post请求都可以省略，也可以写在类里面方法上

class
Order(views.View):

#@method_decorator(auth)

#def dispatch(self, request, *args,
**kwargs):

#return
super(Order, self).dispatch(request, *args, **kwargs)

#@method_decorator(auth): #只对get请求有效

def get(self, request):

v = request.COOKIE.get('username')

return render(request, 'index.html',
{'current_user': v })

def post(self, request):

v = request.COOKIE.get('username')

return render(request, 'index.html',
{'current_user': v })

32．答：

def
orm(request):

orm2添加一条记录的方法

单表

1、表.objects.create（）

models.Publish.objects.create(name='浙江出版社',addr="浙江.杭州")

models.Classify.objects.create(category='武侠')

models.Author.objects.create(name='金庸',sex='男',age=89,university='东吴大学')

2、类实例化：obj=类（属性=XX） obj.save()

obj=models.Author(name='吴承恩',age=518,sex='男',university='龙溪学院')

obj.save()

1对多

1、表.objects.create()

models.Book.objects.create(title='笑傲江湖',price=200,date=1968,classify_id=6,
publish_id=6)

2、类实例化：obj=类（属性=X,外键=obj）obj.save()

classify_obj=models.Classify.objects.get(category='武侠')

publish_obj=models.Publish.objects.get(name='河北出版社')

注意以上获取得是和 book对象向关联的（外键）的对象

book_obj=models.Book(title='西游记',price=234,date=1556,classify=classify_obj,publish=publish_obj)

book_obj.save()

多对多

如果两表之间存在双向1对N关系，就无法使用外键来描述其关系了；

只能使用多对多的方式，新增第三张表关系描述表；

book=models.Book.objects.get(title='笑傲江湖')

author1=models.Author.objects.get(name='金庸')

author2=models.Author.objects.get(name='张根')

book.author.add(author1,author2)

书籍和作者是多对多关系，

切记：如果两表之间存在多对多关系，例如书籍相关的所有作者对象集合，作者也关联的所有书籍对象集合

book=models.Book.objects.get(title='西游记')

author=models.Author.objects.get(name='吴承恩')

author2 = models.Author.objects.get(name='张根')

book.author.add(author,author2)

#add()
添加

#clear() 清空

#remove() 删除某个对象

return
HttpResponse('OK')

改：

#
修改方式1 update()

models.Book.objects.filter(id=1).update(price=3)

#修改方式2 obj.save()

book_obj=models.Book.objects.get(id=1)

book_obj.price=5

book_obj.save()

查：def ormquery(request):

books=models.Book.objects.all() #------query_set对象集合
[对象1、对象2、.... ]

books=models.Book.objects.filter(id__gt=2,price__lt=100)

book=models.Book.objects.get(title__endswith='金') #---------单个对象，没有找到会报错

book1 =
models.Book.objects.filter(title__endswith='金').first()

book2 =
models.Book.objects.filter(title__icontains='瓶').last()

books=models.Book.objects.values('title','price', #-------query_set字典集合
[{一条记录},{一条记录} ]

'publish__name',

'date',

'classify__category', #切记正向连表:外键字段___对应表字段

'author__name', #反向连表：小写表名__对应表字段

'author__sex', #区别：正向外键字段__，反向小写表名__

'author__age',

'author__university')

books=models.Book.objects.values('title','publish__name').distinct()

#exclude 按条件排除。。。

#distinct()去重, exits()查看数据是否存在？返回 true 和false

a=models.Book.objects.filter(title__icontains='金').

return HttpResponse('OK')

反向连表查询：

1、通过object的形式反向连表， obj.小写表名_set.all()

publish=models.Publish.objects.filter(name__contains='湖南').first()

books=publish.book_set.all()

for book in
books:

print(book.title)

通过object的形式反向绑定外键关系

authorobj =
models.Author.objects.filter(id=1).first()

objects = models.Book.objects.all()

authorobj.book_set.add(*objects)

authorobj.save()

2、通过values双下滑线的形式，objs.values("小写表名__字段")

注意对象集合调用values（），正向查询是外键字段__XX,而反向是小写表名__YY看起来比较容易混淆；

books=models.Publish.objects.filter(name__contains='湖南').values('name','book__title')

authors=models.Book.objects.filter(title__icontains='我的').values('author__name')

print(authors)

fifter()也支持__小写表名语法进行连表查询：在publish标查询出版过《笑傲江湖》的出版社

publishs=models.Publish.objects.filter(book__title='笑傲江湖').values('name')

print(publishs)

查询谁（哪位作者）出版过的书价格大于200元

authors=models.Author.objects.filter(book__price__gt=200).values('name')

print(authors)

通过外键字段正向连表查询，出版自保定的书籍；

city=models.Book.objects.filter(publish__addr__icontains='保定').values('title')

print(city)

etc.

33.答：

暂时阻挡，稍后可再继续进行。

决定延期至适当日子

34.答：

select_related()的效率要高于prefetch_related()。因此，最好在能用select_related()的地方尽量使用它，也就是说，对于ForeignKey字段，避免使用prefetch_related()。

1.prefetch_related主要针一对多和多对多关系进行优化。
2.prefetch_related通过分别获取各个表的内容，然后用Python处理他们之间的关系来进行优化。
3.可以通过可变长参数指定需要select_related的字段名。指定方式和特征与select_related是相同的。
4.在Django >= 1.7可以通过Prefetch对象来实现复杂查询，但低版本的Django好像只能自己实现。
5.作为prefetch_related的参数，Prefetch对象和字符串可以混用。
6.prefetch_related的链式调用会将对应的prefetch添加进去，而非替换，似乎没有基于不同版本上区别。
7.可以通过传入None来清空之前的prefetch_related。

select_related主要针一对一和多对一关系进行优化。
2.select_related使用SQL的JOIN语句进行优化，通过减少SQL查询的次数来进行优化、提高性能。
3.可以通过可变长参数指定需要select_related的字段名。也可以通过使用双下划线“__”连接字段名来实现指定的递归查询。没有指定的字段不会缓存，没有指定的深度不会缓存，如果要访问的话Django会再次进行SQL查询。
4.也可以通过depth参数指定递归的深度，Django会自动缓存指定深度内所有的字段。如果要访问指定深度外的字段，Django会再次进行SQL查询。
5.也接受无参数的调用，Django会尽可能深的递归查询所有的字段。但注意有Django递归的限制和性能的浪费。
6.Django >= 1.7，链式调用的select_related相当于使用可变长参数。Django < 1.7，链式调用会导致前边的select_related失效，只保留最后一个。

35.
略

36.答：

手动读写分离

在使用数据库时，通过.using(db_name)来手动指定要使用的数据库

自动读写分离

通过配置数据库路由，来自动实现，这样就不需要每次读写都手动指定数据库了。数据库路由中提供了四个方法。这里这里主要用其中的两个：def db_for_read()决定读操作的数据库，def
db_for_write()决定写操作的数据库。

37.答：

Orm操作即可

38.
答：

F作用：操作数据表中的某列值，F（）允许Django在未实际链接数据的情况下具有对数据库字段值的引用，不用获取对象放在内存中再对字段进行操作，直接执行原生产sql语句操作。

Q作用：对对象进行复杂查询，并支持&（and）,|（or），~（not）操作符。

39.答：

values方法可以获取number字段的字典列表。

values_list可以获取number的元组列表。

values_list方法加个参数flat=True可以获取number的值列表。

40.答：

数据模型定义

首先，定义一个实例使用的django数据库模型Product，只是象征性地定义了两个字段name和price。

from
django.db import models

class
Product(models.Model):

name = models.CharField(max_length=200)

price = models.DecimalField(max_digits=10,
decimal_places=2)

批量插入数据

批量插入数据时，只需先生成个一要传入的Product数据的列表，然后调用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方法进行一次性地更新。下面的语句将生成类似update...where...的SQL语句。

Product.objects.filter(name__contains='name').update(name='new
name')

批量删除数据

批量更新数据时，先是进行数据过滤，然后再调用delete方法进行一次性地删除。下面的语句将生成类似delete
from...where...的SQL语句。

Product.objects.filter(name__contains='name
query').delete()

41.答：

Django中Model负责操作数据库，并且具有简单的数据库验证功能（基本不用）；Form用于用户请求的验证，具有强悍的数据库验证功能；ModelForm是将二者合二为一，即可用于数据库操作（部分），也可用于用户请求的验证（部分）！但由于ModelForm的耦合性太强，其作用一般用作于结构简单的小站点或者重写Django
Admin

42.答：略

43.答：

对于外键，删除是是默认为级联删除，当删除一个，对应相关数据也会被删除，所以，我们有时候需要修改这一性质，在创建外键是使用on_delete即可

44.答：

目标：防止用户直接向服务端发起POST请求。

方案：先发送GET请求时，将token保存到：cookie、Form表单中（隐藏的input标签），以后再发送请求时只要携带过来即可。

问题：如果想后台发送POST请求？

form表单提交：

{% csrf_token %}

</form>

ajax提交：

$.ajax({

url:'/index',

type:'POST',

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

})

前提：引入jquery + 引入jquery.cookie

$.ajax({

url: 'xx',

type:'POST',

data:{name:'oldboyedu'},

headers:{

X-CSRFToken: $.cookie('csrftoken')

dataType:'json', // arg =
JSON.parse('{"k1":123}')

success:function(arg){

console.log(arg)

}

})

45.答：Django
channels。

46.答：

在视图中使用 render （而不要使用 render_to_response）

使用 jQuery 的 ajax 或者
post 之前加入这个 js 代码

47.答：

1、在models文件中生成类，来生成表
2、在view中导入app01的models文件
3、在urls中建立orm的路由
4、在view中建立orm的视图函数
5、引用models.UserInfo(表名称).objects.create（对应的表行关系）
6、选填给在页面做出反应

48.答：

Django
settings 中 cache 默认为

{

'default': {

'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',

}

也就是默认利用本地的内存来当缓存，速度很快

49.答：

from
django.conf import settings

from
django.core.cache import cache

#read
cache user id

def
read_from_cache(self, user_name):

key = 'user_id_of_'+user_name

value = cache.get(key)

if value == None:

data = None

else:

data = json.loads(value)

return data

#write
cache user id

def
write_to_cache(self, user_name):

key = 'user_id_of_'+user_name

cache.set(key,
json.dumps(user_name), settings.NEVER_REDIS_TIMEOUT)

50.答：

类似给url取一个别名。

51.答：

Filter可以在控制语句中使用，而simple_tag不能

52.答：

为Django提供调试功能。

53.答：

Django的单元测试使用python的unittest模块，这个模块使用基于类的方法来定义测试。类名为django.test.TestCase,继承于python的unittest.TestCase。

执行目录下所有的测试(所有的test*.py文件)：运行测试的时候，测试程序会在所有以test开头的文件中查找所有的test cases(inittest.TestCase的子类),自动建立测试集然后运行测试。

54.答：

Database
First是基于已存在的数据库，利用某些工具（如VS提供的EF设计器）创建实体类，数据库对象与实体类的匹配关系等，你也可以手动修改这些自动生成的代码及匹配文件。也就是从一个数据库开始，然后生成实体框架和相应代码。

Code
First 这种方式需要先写一些代码，如实体对象，数据关系等，然后根据已有的代码描述，自动创建数据对象。但其实这种方法与Model First是非常类似的。我们自己写的代码，其实就是用代码表示实体模型，而Model
First是用可视化的方式描述了实体模型。

55.答：python
manage.py makemigrations

56.答：

1）提高开发效率，降低开发成本
2）使开发更加对象化
3）可移植
4）可以很方便地引入数据缓存之类的附加功能
缺点：
1）自动化进行关系数据库的映射需要消耗系统性能。其实这里的性能消耗还好啦，一般来说都可以忽略之。
2）在处理多表联查、where条件复杂之类的查询时，ORM的语法会变得复杂。

57．答：

MVC:Model
代表数据存取层，View 代表的是系统中选择显示什么和怎么显示的部分，Controller 指的是系统中根据用户输入并视需要访问模型，以决定使用哪个视图的那部分。

以下是 Django 中 M、V 和 C 各自的含义：

M ，数据存取部分，由django数据库层处理，本章要讲述的内容。

V ，选择显示哪些数据要显示以及怎样显示的部分，由视图和模板处理。

C ，根据用户输入委派视图的部分，由 Django 框架根据 URLconf 设置，对给定 URL 调用适当的 Python 函数。

C
是由框架自行处理，而 Django 里更关注的是模型（Model）、模板(Template)和视图（Views）， Django 也被称为 MTV 框架。在 MTV 开发模式中：

M 代表模型（Model），即数据存取层。该层处理与数据相关的所有事务：
如何存取、如何验证有效

T 代表模板(Template)，即表现层。该层处理与表现相关的决定：
如何在页面或其他类型文档中进行显示。

V 代表视图（View），即业务逻辑层。该层包含存取模型及调取恰当模板的相关逻辑。
你可以把它看作模型与模板之间的桥梁。

58.答：

contenttypes
是Django内置的一个应用，可以追踪项目中所有app和model的对应关系，并记录在ContentType表中。、

59.答：

REST（Representational
State Transfer）表述性状态转换，REST指的是一组架构约束条件和原则。如果一个架构符合REST的约束条件和原则，我们就称它为RESTful架构。REST本身并没有创造新的技术、组件或服务，而隐藏在RESTful背后的理念就是使用Web的现有特征和能力，更好地使用现有Web标准中的一些准则和约束。虽然REST本身受Web技术的影响很深，但是理论上REST架构风格并不是绑定在HTTP上，只不过目前HTTP是唯一与REST相关的实例。

60.答：

接口的幂等性实际上就是接口可重复调用，在调用方多次调用的情况下，接口最终得到的结果是一致的。

61.答：

远程过程调用 (RPC) 是一种协议，程序可使用这种协议向网络中的另一台计算机上的程序请求服务。由于使用 RPC 的程序不必了解支持通信的网络协议的情况，因此 RPC 提高了程序的互操作性。在 RPC 中，发出请求的程序是客户程序，而提供服务的程序是服务器。

RPC（远程过程调用）是一项广泛用于支持分布式应用程序（不同组件分布在不同计算机上的应用程序）的技术。RPC 的主要目的是为组件提供一种相互通信的方式，使这些组件之间能够相互发出请求并传递这些请求的结果。

62．答：

对传输内容加密
端口：

HTTP：80

HTTPS：443
自定义证书

1.
通信使用明文不加密，内容可能被窃听

2.
不验证通信方身份，可能遭到伪装

3.
无法验证报文完整性，可能被篡改

#
HTTPS就是HTTP加上加密处理（一般是SSL安全通信线路）+认证+完整性保护

63.答：

方便开发 RESTful 模式接口的，内部给你分离了 HTTP Verbs，还是比较方便的默认也有无状态的访问权限管理。

64.答：

快速实例，序列化。

65.答：

使用混合类组建视图。

66.答：

67.答：

https://www.cnblogs.com/supery007/p/8423769.html

68．答：

flask框架中的上下文管理较为耀眼。第三方组件很多，可扩展性强，还可以自定义组件

69．答：

设置一个requirements.txt文件

70.答：

一个蓝图定义了可用于单个应用的视图，模板，静态文件等等的集合。尽可能将代码尽量的模块化，是代码看起来更加优雅和流畅。

71.答：

-
内置组件

- 配置 - 路由 - 视图

- 模板 - session - 蓝图

- 闪现 - 装饰器 - 中间件

-
第三方组件

- Flask-session # 将原来保存在cookie中的session数据，放到Redis/memcache/文件/数据库中

- Flask-migrate # 做数据库迁移

- Flask-script #

- Flask-SQLAlchemy # ORM

- blinker

-
公共：

- DButils # 数据库连接池：两种模式；为每个参数设置一个连接/共享一个连接；全局参数

- wtforms # form组件：做表单验证+生成HTML标签

- gevent-websocket

-
自定义组件：

- flask-login

72.答：

　简单来说，falsk上下文管理可以分为三个阶段：

　　1、请求进来时，将请求相关的数据放入上下文管理中

　　2、在视图函数中，要去上下文管理中取值

　　3、请求响应，要将上下文管理中的数据清除

　详细点来说：

　　1、请求刚进来，将request，session封装在RequestContext类中，app，g封装在AppContext类中，并通过LocalStack将requestcontext和appcontext放入Local类中

　　2、视图函数中，通过localproxy--->偏函数--->localstack--->local取值

　　3、请求相应时，先执行save.session()再各自执行pop(),将local中的数据清除

73.答：

- G 相当于一次请求的全局变量，当请求进来时将 G 和 current_app 封装为一个 APPContext 类，在通过 LocalStack 将 Appcontext 放入 Local 中，
取值时通过偏函数，LocalStack、loca 中取值，响应时将 Local 中的 g 数据删除：
- 应用场景：
befor_request + G = 权限认证系统

74.答：

1、每一个线程都会在Local类中创建一条数据

　　　　　　　　　　　　　　　　　　｛
　　　　　　　　　　　　　　　　　　　　“唯一标识”:{stark:[ctx,]}
　　　　　　　　　　　　　　　　　　　　“唯一标识”:{stark:[ctx,]}

　　　　　　　　　　　　　　　　　　　｝

2、当请求进来之后，将请求相关数据添加到列表里面[request，]，以后如果使用时，就去读取

3、列表中的数据，请求完成之后，将request从列表中移除

2、在源码中分析上下文管理

第一阶段：执行__call__--->app.wsgi-->将ctx（request,session）封装为RequestContent()在（open_session）, app_ctx(g,app)封装为APPContent()通过LocalStack将这两个类放入Local对象中

第二阶段：视图函数导入：request/session/g/app
,通过偏函数(_lookup_req_object)在通过（LocalProxy()）去LocalStack中的Local类中对其进行增删改查操作

　　　　第三阶段：请求处理完毕　　　　　　　

　　　　　　- 通过save_session将签名session保存到cookie

　　　　　　-通过ctx.pop()去LocalStack中的Local类- 将ctx删除
　　　　

75.答：

　　　　-保存
请求上下文对象和app上下文对象

　　　　　-localstack的源码与threading.local（线程处理）作用相似，不同之处是Local是通过greenlet（协程）获取唯一标识，粒度更细

将local对象中的数据维护成一个栈【ctx,ctx】（先进后出）

{
“协程或线程的唯一标识”: {
stack:[ctx,ctx,ctx,] }
}

76.答：

请求上下文管理的方式实现的。

77.答：

Flask-socketio模块。

78.答：

主要用于对用户请求数据进行验证

79.答：

　　当请求进来时，会将 requset 和 session 封装为一个 RequestContext 对象，通过 LocalStack 将 RequestContext 放入到Local对象中，
因为请求第一次来 session 是空值，所以执行
open_session,给 session（uuid4()）赋值，再通过视图函数处理，请求响应时执行save.session,
将签名 session 写入 cookie 中，再将 Local 中的数值pop掉。

80.答：

Flask的session默认是完全保留在客户端浏览器中的，也就是说我往flask的session中写入数据，最终这些数据将会以json字符串的形式，经过base64编码写入到用户浏览器的cookie里，也就是说无须依赖第三方数据库保存 session数据，也无需依赖文件来保存

81.答：

业务解耦，通过blinker提供信号支持。

82.答：

而使用scoped_session的目的主要是为了线程安全。

scoped_session类似单例模式，当我们调用使用的时候，会先在Registry里找找之前是否已经创建session了。

要是有，就把这个session返回。

要是没有，就创建新的session，注册到Registry中以便下次返回给调用者。

这样就实现了这样一个目的：在同一个线程中，call scoped_session 的时候，返回的是同一个对象：

83.答：

方式1, 使用raw sql;

方式2, 使用SqlAlchemy的sql
expression;

方式3, 使用ORM.

84.答：

将关系数据库中的表映射为对象，从而将对数据库的操作转化为对对象的操作。

85.答：

DBUtils
属于WebWare项目的数据库连接池实现模块，用于对数据库连接线程化，使可以安全和有效的访问数据库的模块

86.答:

不正确。

87.答：

设置引擎编码方式为utf-8

设置数据库编码发方式为utf8

88.答：

UniqueConstraint(‘id’,
‘name’,name= ‘uix_id_name)

89.答：

Tornado在设计之初就考虑到了性能因素，旨在解决C10K问题，这样的设计使得其成为一个拥有非常高性能的框架。此外，它还拥有处理安全性、用户验证、社交网络以及与外部服务（如数据库和网站API）进行异步交互的工具。

90.答：

内置的一个回调函数以及创建task。

91.答:

Tornado在websocket模块中提供了一个WebSocketHandler类。这个类提供了和已连接的客户端通信的WebSocket事件和方法的钩子。当一个新的WebSocket连接打开时，open方法被调用，而on_message和on_close方法分别在连接接收到新的消息和客户端关闭时被调用。

此外，WebSocketHandler类还提供了write_message方法用于向客户端发送消息，close方法用于关闭连接。

92.
答：

在tornado中，处理静态文件的类StaticFileHandler，在web.py模块中，该类不仅处理静态文件的映射也处理了静态文件的主动式缓存。

处理静态文件时需要设置settings中关于静态文件的值”static_ ath“，指明静态文件的路径。

93.答：

TornDB是一个轻量级的基于MySQLdb封装的一个模块

94.答：

tornado
可用的异步 redis 客户端，使用很方便。
下面的例子介绍了怎么使用管道设置值和读取值的简单操作

#coding:utf-8

import
tornadoredis

import
tornado.httpserver

import
tornado.web

import
tornado.ioloop

import
tornado.gen

#设置连接池

CONNECTION_POOL
= tornadoredis.ConnectionPool(max_connections=500,wait_for_available=True)

#
生成一个客户端，这里并没有给出host和port，使用的默认的参数，我的redis使用默认的参数也可以连接上

#
Client的参数为

#
def __init__(self, host='localhost', port=6379, unix_socket_path=None,

# password=None,
selected_db=None, io_loop=None,

# connection_pool=None):

c
= tornadoredis.Client(connection_pool=CONNECTION_POOL)

class
MainHandler(tornado.web.RequestHandler):

@tornado.web.asynchronous

@tornado.gen.engine

def get(self):

name = yield
tornado.gen.Task(c.get,'name')

age = yield
tornado.gen.Task(c.get,'age')

height = yield
tornado.gen.Task(c.get,'height')

self.finish("name: {0} age: {1}
height: {2}".format(name, age, height))

application
= tornado.web.Application([

(r'/', MainHandler),

])

@tornado.gen.engine

def
create_test_data():

c = tornadoredis.Client()

# 使用管道设置值

with c.pipeline() as pipe:

pipe.set('name', 'zhangsan')

pipe.set('age', '10')

pipe.set('height', '1.8')

yield tornado.gen.Task(pipe.execute)

if
__name__ == '__main__':

# Start the data initialization routine

create_test_data()

http_server =
tornado.httpserver.HTTPServer(application)

http_server.listen(8888)

print
'Demo is runing at 0.0.0.0:8888\nQuit the demo with CONTROL-C'

tornado.ioloop.IOLoop.instance().start()

95.答：

高并发，异步非阻塞，即是服务器又是框架，性能优越，速度快。

96.答：

git
init

在本地新建一个repo,进入一个项目目录,执行git
init,会初始化一个repo,并在当前文件夹下创建一个.git文件夹.

git
clone

获取一个url对应的远程Git repo, 创建一个local copy.

一般的格式是git clone [url].

clone下来的repo会以url最后一个斜线后面的名称命名,创建一个文件夹,如果想要指定特定的名称,可以git
clone [url] newname指定.

git
status

查询repo的状态.

git status -s: -s表示short, -s的输出标记会有两列,第一列是对staging区域而言,第二列是对working目录而言.

git
log

show commit history of a branch.

git log --oneline --number: 每条log只显示一行,显示number条.

git log --oneline --graph:可以图形化地表示出分支合并历史.

git log branchname可以显示特定分支的log.

git log --oneline branch1 ^branch2,可以查看在分支1,却不在分支2中的提交.^表示排除这个分支(Window下可能要给^branch2加上引号).

git log --decorate会显示出tag信息.

git log --author=[author name] 可以指定作者的提交历史.

git log --since --before --until --after 根据提交时间筛选log.

--no-merges可以将merge的commits排除在外.

git log --grep 根据commit信息过滤log:
git log --grep=keywords

默认情况下, git log --grep --author是OR的关系,即满足一条即被返回,如果你想让它们是AND的关系,可以加上--all-match的option.

git log -S: filter by introduced diff.

比如: git log -SmethodName (注意S和后面的词之间没有等号分隔).

git log -p: show patch introduced at each commit.

每一个提交都是一个快照(snapshot),Git会把每次提交的diff计算出来,作为一个patch显示给你看.

另一种方法是git show [SHA].

git log --stat: show diffstat of changes introduced at each
commit.

同样是用来看改动的相对信息的,--stat比-p的输出更简单一些.

git
add

在提交之前,Git有一个暂存区(staging area),可以放入新添加的文件或者加入新的改动. commit时提交的改动是上一次加入到staging area中的改动,而不是我们disk上的改动.

git add .

会递归地添加当前工作目录中的所有文件.

git
diff

不加参数的git diff:

show diff of unstaged changes.

此命令比较的是工作目录中当前文件和暂存区域快照之间的差异,也就是修改之后还没有暂存起来的变化内容.

若要看已经暂存起来的文件和上次提交时的快照之间的差异,可以用:

git
diff --cached 命令.

show diff of staged changes.

(Git
1.6.1 及更高版本还允许使用 git diff --staged，效果是相同的).

git diff HEAD

show diff of all staged or unstated changes.

也即比较woking directory和上次提交之间所有的改动.

如果想看自从某个版本之后都改动了什么,可以用:

git diff [version tag]

跟log命令一样,diff也可以加上--stat参数来简化输出.

git diff [branchA] [branchB]可以用来比较两个分支.

它实际上会返回一个由A到B的patch,不是我们想要的结果.

一般我们想要的结果是两个分支分开以后各自的改动都是什么,是由命令:

git diff [branchA]…[branchB]给出的.

实际上它是:git diff $(git merge-base [branchA] [branchB]) [branchB]的结果.

git
commit

提交已经被add进来的改动.

git commit -m “the commit message"

git commit -a 会先把所有已经track的文件的改动add进来,然后提交(有点像svn的一次提交,不用先暂存). 对于没有track的文件,还是需要git add一下.

git commit --amend 增补提交. 会使用与当前提交节点相同的父节点进行一次新的提交,旧的提交将会被取消.

git
reset

undo changes and commits.

这里的HEAD关键字指的是当前分支最末梢最新的一个提交.也就是版本库中该分支上的最新版本.

git reset HEAD: unstage files from index and reset pointer to HEAD

这个命令用来把不小心add进去的文件从staged状态取出来,可以单独针对某一个文件操作: git reset HEAD - - filename, 这个- - 也可以不加.

git reset --soft

move HEAD to specific commit reference, index and staging are
untouched.

git reset --hard

unstage files AND undo any changes in the working directory since
last commit.

使用git reset —hard HEAD进行reset,即上次提交之后,所有staged的改动和工作目录的改动都会消失,还原到上次提交的状态.

这里的HEAD可以被写成任何一次提交的SHA-1.

不带soft和hard参数的git
reset,实际上带的是默认参数mixed.

总结:

git reset --mixed id,是将git的HEAD变了(也就是提交记录变了),但文件并没有改变，(也就是working tree并没有改变). 取消了commit和add的内容.

git
reset --soft id. 实际上，是git reset –mixed id 后,又做了一次git add.即取消了commit的内容.

git
reset --hard id.是将git的HEAD变了,文件也变了.

按改动范围排序如下:

soft (commit) < mixed (commit + add) < hard (commit + add +
local working)

git
revert

反转撤销提交.只要把出错的提交(commit)的名字(reference)作为参数传给命令就可以了.

git revert HEAD: 撤销最近的一个提交.

git revert会创建一个反向的新提交,可以通过参数-n来告诉Git先不要提交.

git
rm

git rm file: 从staging区移除文件,同时也移除出工作目录.

git rm --cached: 从staging区移除文件,但留在工作目录中.

git rm --cached从功能上等同于git reset HEAD,清除了缓存区,但不动工作目录树.

git
clean

git clean是从工作目录中移除没有track的文件.

通常的参数是git clean -df:

-d表示同时移除目录,-f表示force,因为在git的配置文件中, clean.requireForce=true,如果不加-f,clean将会拒绝执行.

git
mv

git rm - - cached orig; mv orig new; git add new

git
stash

把当前的改动压入一个栈.

git stash将会把当前目录和index中的所有改动(但不包括未track的文件)压入一个栈,然后留给你一个clean的工作状态,即处于上一次最新提交处.

git stash list会显示这个栈的list.

git stash apply:取出stash中的上一个项目(stash@{0}),并且应用于当前的工作目录.

也可以指定别的项目,比如git stash apply stash@{1}.

如果你在应用stash中项目的同时想要删除它,可以用git
stash pop

删除stash中的项目:

git stash drop: 删除上一个,也可指定参数删除指定的一个项目.

git stash clear: 删除所有项目.

git
branch

git branch可以用来列出分支,创建分支和删除分支.

git branch -v可以看见每一个分支的最后一次提交.

git branch: 列出本地所有分支,当前分支会被星号标示出.

git branch (branchname): 创建一个新的分支(当你用这种方式创建分支的时候,分支是基于你的上一次提交建立的).

git branch -d (branchname): 删除一个分支.

删除remote的分支:

git push (remote-name) :(branch-name): delete a remote branch.

这个是因为完整的命令形式是:

git push remote-name local-branch:remote-branch

而这里local-branch的部分为空,就意味着删除了remote-branch

git
checkout

　　git checkout (branchname)

切换到一个分支.

git checkout -b (branchname): 创建并切换到新的分支.

这个命令是将git branch newbranch和git checkout newbranch合在一起的结果.

checkout还有另一个作用:替换本地改动:

git checkout --<filename>

此命令会使用HEAD中的最新内容替换掉你的工作目录中的文件.已添加到暂存区的改动以及新文件都不会受到影响.

注意:git checkout filename会删除该文件中所有没有暂存和提交的改动,这个操作是不可逆的.

git
merge

把一个分支merge进当前的分支.

git merge [alias]/[branch]

把远程分支merge到当前分支.

如果出现冲突,需要手动修改,可以用git mergetool.

解决冲突的时候可以用到git diff,解决完之后用git add添加,即表示冲突已经被resolved.

git
tag

tag a point in history as import.

会在一个提交上建立永久性的书签,通常是发布一个release版本或者ship了什么东西之后加tag.

比如: git tag v1.0

git tag -a v1.0, -a参数会允许你添加一些信息,即make an annotated tag.

当你运行git tag -a命令的时候,Git会打开一个编辑器让你输入tag信息.

我们可以利用commit SHA来给一个过去的提交打tag:

git tag -a v0.9 XXXX

push的时候是不包含tag的,如果想包含,可以在push时加上--tags参数.

fetch的时候,branch HEAD可以reach的tags是自动被fetch下来的, tags that aren’t reachable from
branch heads will be skipped.如果想确保所有的tags都被包含进来,需要加上--tags选项.

git
remote

list, add and delete remote repository aliases.

因为不需要每次都用完整的url,所以Git为每一个remote
repo的url都建立一个别名,然后用git remote来管理这个list.

git remote: 列出remote aliases.

如果你clone一个project,Git会自动将原来的url添加进来,别名就叫做:origin.

git remote -v:可以看见每一个别名对应的实际url.

git remote add [alias] [url]: 添加一个新的remote repo.

git remote rm [alias]: 删除一个存在的remote alias.

git remote rename [old-alias] [new-alias]: 重命名.

git remote set-url [alias] [url]:更新url. 可以加上—push和fetch参数,为同一个别名set不同的存取地址.

git
fetch

download new branches and data from a remote repository.

可以git fetch [alias]取某一个远程repo,也可以git fetch --all取到全部repo

fetch将会取到所有你本地没有的数据,所有取下来的分支可以被叫做remote branches,它们和本地分支一样(可以看diff,log等,也可以merge到其他分支),但是Git不允许你checkout到它们.

git
pull

fetch from a remote repo and try to merge into the current branch.

pull == fetch + merge FETCH_HEAD

git pull会首先执行git fetch,然后执行git merge,把取来的分支的head merge到当前分支.这个merge操作会产生一个新的commit.

如果使用--rebase参数,它会执行git rebase来取代原来的git merge.

git
rebase

--rebase不会产生合并的提交,它会将本地的所有提交临时保存为补丁(patch),放在”.git/rebase”目录中,然后将当前分支更新到最新的分支尖端,最后把保存的补丁应用到分支上.

rebase的过程中,也许会出现冲突,Git会停止rebase并让你解决冲突,在解决完冲突之后,用git add去更新这些内容,然后无需执行commit,只需要:

git rebase --continue就会继续打余下的补丁.

git rebase --abort将会终止rebase,当前分支将会回到rebase之前的状态.

git
push

push your new branches and data to a remote repository.

git push [alias] [branch]

将会把当前分支merge到alias上的[branch]分支.如果分支已经存在,将会更新,如果不存在,将会添加这个分支.

如果有多个人向同一个remote repo push代码, Git会首先在你试图push的分支上运行git log,检查它的历史中是否能看到server上的branch现在的tip,如果本地历史中不能看到server的tip,说明本地的代码不是最新的,Git会拒绝你的push,让你先fetch,merge,之后再push,这样就保证了所有人的改动都会被考虑进来.

git
reflog

git reflog是对reflog进行管理的命令,reflog是git用来记录引用变化的一种机制,比如记录分支的变化或者是HEAD引用的变化.

当git reflog不指定引用的时候,默认列出HEAD的reflog.

HEAD@{0}代表HEAD当前的值,HEAD@{3}代表HEAD在3次变化之前的值.

git会将变化记录到HEAD对应的reflog文件中,其路径为.git/logs/HEAD, 分支的reflog文件都放在.git/logs/refs目录下的子目录中.

特殊符号:

^代表父提交,当一个提交有多个父提交时,可以通过在^后面跟上一个数字,表示第几个父提交: ^相当于^1.

~<n>相当于连续的<n>个^.

97，98上同。

99.答：

分为如下几个步骤：

1.创建一个git裸服务器
（git init --bare）

2.从裸服务器将版本库克隆至本地（git clone ）

3.本地常规操作

4.推送版本至服务器（git remote + git push origin
master）

5.从远程服务器拉取版本（git pull）

100.答：见96

101．答：

版本管理

分布式系统中，像 Git，Mercurial，Bazaar
以及 Darcs 等，客户端并不只提取最新版本的文件快照，而是把代码仓库完整地镜像下来。这么一来，任何一处协同工作用的服务器发生故障，事后都可以用任何一个镜像出来的本地仓库恢复。

102.答：

GitLab
是一个用于仓库管理系统的开源项目，使用Git作为代码管理工具，并在此基础上搭建起来的web服务

103．答：

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

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

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

104.答：

构建完自己想要的代码，git命令 git push origin master(这代表 push 到我们自己的github上面),回到自己的github主页可以发现本地修改的已经push 上去了,然后点击 new pull request 。如图片顺序,然后写上自己 pull request 的理由,等待对方的回应

105.答：

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

106.答：

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

107.答：

Jenkins 是一个可扩展的持续集成引擎。

主要用于：

l 持续、自动地构建/测试软件项目。

l 监控一些定时执行的任务。

108.答:码云

109.答：

rabbitmq
基于amqp 协议实现，可以保证消息的点对点，topic 传递，并且有消息确认机制保证消息的可靠传输,消息可以持久化存储

RabbitMQ既支持内存队列也支持持久化队列，消费端为推模型，消费状态和订阅关系由服务端负责维护，消息消费完后立即删除，不保留历史消息。

缺点，保证了一致性和可靠性的同时，吞吐率和性能有所下降。

可以用于对数据一致性、稳定性和可靠性要求很高的场景

zeromq本身不是一个独立进程，他是建立　在socket 之上的一条通道，所以他可以做消息的转发，但是不能解耦服务，其他的都可以为服务解耦合。

kafka
本身侧重点在于消息的吞吐量上，处理速度上，不侧重消息的可靠性传递，没有消息确认机制，所以适合一些不重要的消息存储,

Kafka只支持消息持久化，消费端为拉模型，消费状态和订阅关系由客户端端负责维护，消息消费完后不会立即删除，会保留历史消息。

因此支持多订阅时，消息只会存储一份就可以了。但是可能产生重复消费的情况。

不支持事务，适合产生大量数据的互联网服务的数据收集业务。

110.答：

持久化信息

把它的投递默认选项设置为持久化
2. 发送到持久化的交换机
3. 到达持久化的队列

111.答：

为了保证RabbitMQ在退出或者crash等异常情况下数据没有丢失，需要将queue，exchange和Message都持久化。

queue的持久化

queue的持久化是通过durable=true来实现的。

如过将queue的持久化标识durable设置为true,则代表是一个持久的队列，那么在服务重启之后，也会存在，因为服务会把持久化的queue存放在硬盘上，当服务重启的时候，会重新什么之前被持久化的queue。队列是可以被持久化，但是里面的消息是否为持久化那还要看消息的持久化设置。也就是说，重启之前那个queue里面还没有发出去的消息的话，重启之后那队列里面是不是还存在原来的消息，这个就要取决于发生着在发送消息时对消息的设置了。
如果要在重启后保持消息的持久化必须设置消息是持久化的标识。

112.答：

消息的TTL就是消息的存活时间。RabbitMQ可以对队列和消息分别设置TTL。对队列设置就是队列没有消费者连着的保留时间，也可以对每一个单独的消息做单独的设置。超过了这个时间，我们认为这个消息就死了，称之为死信。如果队列设置了，消息也设置了，那么会取小的。所以一个消息如果被路由到不同的队列中，这个消息死亡的时间有可能不一样（不同的队列设置）。这里单讲单个消息的TTL，因为它才是实现延迟任务的关键。

113.答：

direct型的Exchange，通常是将同一个message以一种循环的方式分发到不同的Queue，即不同的消费者手中，使用这种方式，值得注意的是message在消费者之间做了一个均衡，而不是说message在Queues之间做了均衡。

Fanout

使用这种类型的Exchange，会忽略routing key的存在，直接将message广播到所有的Queue中。、

Topic

Topic Exchange是根据routing key和Exchange的类型将message发送到一个或者多个Queue中，我们经常拿他来实现各种publish/subscribe，即发布订阅，这也是我们经常使用到的ExchangeType。

114.答：

Celery是专注实时处理和任务调度的分布式任务队列。

主要应用场景：

1，web应用，当需要触发事件需要较长时间处理完成，可以交给celery进行异步执行，执行完后返回结果，这段时间不用等待，提高系统的吞吐量和响应时间。

2，完成任务时，需要额外的事件处理，如发送邮件等。

3，后台定时任务处理，celery可以帮助我们在不同服务器进行定时任务管理。

115.答:

116.答：

（1）在配置文件中指定；（2）在程序中指定。

117.答：

/root/test/proj/celery

├──
celeryconfig.py

├── celery.py

├── __init__.py

└──
tasks.py

118.答：

@shared_task 装饰器能让你在没有具体的 Celery 实例时创建任务：

119.答：做网络请求模块，模拟浏览器发送网络请求行为。

120．答：

BeautifulSoup是一个非常优秀的Python扩展库，它可以从HTML或XML文件中提取我们感兴趣的数据。它不但可以标签进行查找，还可以通过标签属性来查找。

BeautifulSoup对象是一个复杂的树形结构，它的每一个节点都是一个Python对象，获取网页内容就是一个提取对象内容的过程，其提取对象的方法可以分为：遍历文档树、搜索文档树、CSS选择器。
所有的对象可以分为4种：
<1> Tag：Tag对象与XML或HTML原生文档中的tag相同。它有很多方法和属性，其中最重要的是：name和attributes。BeautifulSoup对象通过find()和find_all()方法，或者直接调用子标签获取一列对象或单个对象。
<2> NavigableString：用来表示标签里的文字，不是标签。
<3> Comment：这是一个特殊类型的NavigableString对象，用来查找HTML文档中的注释。
<4> BeautifulSoup：这个对象表示文档的全部内容。大部分时候可以把它当作Tag对象，它支持遍历文档树和搜索文档树的大部分方法。

121．答：

爬取动态页面。

from
selenium import webdriver

from
selenium.webdriver.support.ui import WebDriverWait

from
selenium.webdriver.support import expected_conditions as EC

from
selenium.webdriver.common.by import By

122.答:

ENGINE
: 引擎, 框架的核心, 其他所有组件在其控制下协同工作

SCHEDULER:
调度器, 负责对SPIDER提交的下载请求进行调度

DOWNLOADER:
下载器, 负责下载页面, (发送HTTP请求/接收HTTP响应)

SPIDER:
爬虫, 负责提取页面中的数据, 并产生对新页面的下载请求

MIDDLEWARE:
中间件, 负责对Request对象和Response对象进行处理

ITEM
PIPELINE: 数据管道, 负责对爬取到的数据进行处理

当SPIDER要爬取某URL地址的页面时,
需要使用该URL构建一个Request对象, 提交给Engine

Request对象随后进入SCHEDULER按照某种算法进行排队, 之后的某一个时刻SHCEDULER将其送出队,送往DOWNLOADER

DOWNLOADER根据Request对象中的URL地址发送一次HTTP请求到网站服务器, 之后用服务器返回的HTTP响应构造出一个Response对象,其中包含页面的HTML文本

Response对象最终会被递送给SPIDER的页面解析函数(构造Request对象时指定)进行处理,页面解析函数从页面中提取数据,
封装成Item后提交给ENGINE,Item之后被送往ITEM PIPELINES进行处理,最终可能由EXPROTER以某种数据格式写入文件;另一方面, 页面解析函数还从页面中提取URL, 构造出新的Request对象提交给ENGINE

123.答：

一．使用中间件DownLoaderMiddleware进行配置

二．直接在爬虫程序中设置proxy字段。

124.答：

使用FilesPipeline下载大文件。

125.答：

算法根据以下规则调整下载延迟及并发数:

spider永远以1并发请求数及 AUTOTHROTTLE_START_DELAY 中指定的下载延迟启动。

当接收到回复时，下载延迟会调整到该回复的延迟与之前下载延迟之间的平均值。

126.答：

直接使用Timer类

使用标准库的sched模块

127.答:

在settings.py文件里设置COMMANDS_MODULE =
'properties.hi' ，就可以在Scrapy的帮助中看到这个命令，运行时用scrapy hi。自定义命令的默认设置default_settings会和工程的设置合并到
一起，但是相比在settings.py文件里和命令行定义的设置优先级要低。

如果需要自定义多个命令，则可以在工程的根目录下建立一个文件夹，又如commands，里面放一些类似上面hi.py文件的命令，然后设置COMMANDS_MODULE = 'properties.commands即可。

128.答：

1.通过Response对象的地址序列和Request对象的请求处理完成深度采集
2.通过CrawlSpider类型中的请求链接提取规则自动进行深度数据采集处理

129.答：

当Item在Spider中被收集之后，它将会被传递到Item Pipeline，一些组件会按照一定的顺序执行对Item进行处理。

每个Item Pipeline都是实现了简单方法的Python类，比如决定此Item是丢弃而存储。以下是Item Pipeline的典型应用：

验证爬取的数据（检查爬取的数据是否包含某些字段，数据清洗）
查重（重复的数据丢弃）
将爬取的结果保存到文件或数据库

130．答：

from
scrapy.exceptions import DropItem

class
DuplicatesPipeline(object):

def __init__(self):

self.ids_seen = set()

def process_item(self, item, spider):

if item['id'] in self.ids_seen:

raise DropItem("Duplicate item
found: %s" % item)

else:

self.ids_seen.add(item['id'])

return item

131.答：

见前面。

132.答：

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

133.答：

1. 对Doc进行关键词抽取(分词和计算TF-IDF权重)，抽出n个关键词[(wod1, weight1), (word2, weight2),
…,(wordn, weightn)]
2. 对每个word，计算哈希值 hash_weight_pairs =
[(hash(word1), weight), (hash(word2), weight2),…, (hash(wordn), weightn)]，每个单词被hash成默认64位的二进制比特。
3. 对hash_weight_pairs进行纵向加权求和，如果该位是1，则+weight,如果是0，则-weight，最后生成长度位64的数组
4.遍历这64位的数组，如果该位为正，则转换成1，否则位0

134．答：

深度优先

是从左到右深度进行爬取的，以深度为准则从左到右的执行（递归方式实现）Scrapy默认是深度优先的

' v:shapes="_x0000_i1027">

' v:shapes="_x0000_i1028">

广度优先

是以层级来执行的，（列队方式实现）

v:shapes="_x0000_i1029">

135.答：

在python开发中，我们可能会遇到一种情况，就是当前的项目依赖的是某一个版本，但是另一个项目依赖的是另一个版本，这样就会造成依赖冲突，而virtualenv就是解决这种情况的，virtualenv通过创建一个虚拟化的python运行环境，将我们所需的依赖安装进去的，不同项目之间相互不干扰。

136.答：

pipreqs，可以自动根据源码生成
requirements.txt .

137.答：Pychecker，Pylint。

138.答：

运维管理工具的对比。

139-155，简要回答

B树和B+树其实都是平衡搜索树。这里要脑补一下平衡搜索树的概念：这个词划分一下就是平衡+搜索+树。也就是说，他首先是一棵树，其次能搜索，再次他是平衡的。大家耳熟能详的一个概念：二叉平衡搜索树。

冒泡，插入，选择，希尔，堆排序，快速排序，归并排序。

顺序查找，二分查找，哈希表。

工厂模式，单例模式，建造者模式，原型模式，适配器模式，桥接模式，过滤器模式。

Sudo apt

Pv page view 页面访问量

Uv Unique Visitor 独立访客访问数

每秒查询率QPS是对一个特定的查询服务器在规定时间内所处理流量多少的衡量标准。

1 WSGI是一种通信协议

2
uwsgi是一种线路协议而不是通信协议，在此常用于在uWSGI服务器与其他网络服务器的数据通信。

3 而uWSGI是实现了uwsgi和WSGI两种协议的Web服务器。

supervisor管理进程，是通过fork/exec的方式将这些被管理的进程当作supervisor的子进程来启动，所以我们只需要将要管理进程的可执行文件的路径添加到supervisor的配置文件中就好了。此时被管理进程被视为supervisor的子进程，若该子进程异常中断，则父进程可以准确的获取子进程异常中断的信息，通过在配置文件中设置autostart=ture，可以实现对异常中断的子进程的自动重启。

反向代理（Reverse Proxy）方式是指以代理服务器来接受internet上的连接请求，然后将请求转发给内部网络上的服务器，并将从服务器上得到的结果返回给internet上请求连接的客户端，此时代理服务器对外就表现为一个反向代理服务器。

明文：需要秘密传送的消息。

密文：明文经过密码变换后的消息。

加密：由明文到密文的变换。

解密：从密文恢复出明文的过程。

破解：非法接收者试图从密文分析出明文的过程。

加密算法：对明文进行加密时采用的一组规则。

解密算法：对密文进行解密时采用的一组规则。

密钥：加密和解密时使用的一组密码信息。

对称加密：是采用单钥密码系统的加密方法，使用同一密钥对信息进行加密和解密的加密方法。

非对称加密：需要两个密钥：公共密钥和私有密钥，它们成对出现，公钥加密的数据有且只有私钥能解密，私钥加密的数据有且只有公钥解密，相对于“对称加密”，“非对称加密”加密方法加密和解密使用不同的密钥，所以叫“非对称加密”加密方法。

对称加密和非对称加密的区别：在于加密和解密是否使用的同一个密钥。

加密、身份认证、数字签名认证：

加密：将数据资料加密，使得非法用户即便获取加密后的资料，也无法获取正确的资料内容，所以数据加密可以保证数据防止监听攻击；其重点在于数据的安全性。

身份认证：判断某身份的真实性，确认身份后，系统才可以依不同的身份赋予不同的权限；其重点在于用户的真实性。

数字签名认证：首先"数字签名"就是附加在数据单元上的一些数据，或是对数据单元所作的密码变换。这种数据或变换允许接收者判断数据的来源和数据的完整性，防止被伪造篡改。数字签名认证侧重于把保证数据的完整性，防止被伪造和篡改。

认证原理:

有2种认证方式：

基于账号和口令的验证方式和基于公钥和私钥的验证方式

ssh的登录过程分为5个阶段

1、版本号协商阶段

2、密钥和算法协商阶段

3、认证阶段

4、会话请求阶段

5、会话交互阶段

1、版本号协商阶段

服务端打开端口22，等待客户连接。

客户端向服务端发起TCP连接，连接建立后，服务端向客户端发送第一个报文，包括版本标志字符串，格式为“协议版本号次协议版本号软件版本号”。

客户端收到报文后，解析协议版本号，如果服务端的协议版本号比自己的低，且客户端能支持服务端的低版本，就使用服务端的协议号，否则使用自己的协议版本号。

客户端回复服务端一个报文，包含了客户端决定使用的协议版本号。

服务端比较客户端发过来的版本号，决定是否能同客户端交互。

如果协商成功，就进入密钥和算法协商阶段。否则服务端断开TCP连接。

2、密钥和算法协商阶段

服务端和客户端分别发送算法协商报文给对方，报文中包含自己支持的公钥算法列表、加密算法列表、消息验证码算法列表、压缩算法列表等。

服务端和客户端根据对方和自己支持的算法得出最终使用的算法。

服务端和客户端利用DH交换算法、主机密钥对等参数，生成会话密钥和会话ID。

c公客户端公钥

c密客户端密钥

s公服务端公钥

s密服务端密钥

在版本号协商阶段完成后：

服务端将 s公发送给客户端。

服务端生成会话ID ，设为 id ，发送给客户端。

客户端生成会话密钥，设为 key ，并计算 res = id 异或 key。

客户端将 res 用 s公进行加密，将结果发送给服务端。

服务端用 s密进行解密，得到 res。

服务器计算 res 异或 id，得到 key。

至此服务端和客户端都知道了会话密钥和会话ID，以后的数据传输都使用会话密钥进行加密和解密。

3、认证阶段

基于账号和口令的验证方式：

客户端使用密钥和算法协商阶段生成的会话密钥加密账号、认证方法、口令，将结果发送给服务器。

服务端使用获得的会话密钥解密报文，得到账号和口令。

服务端对这个账号和口令进行判断，如果失败，向客户端发送认证失败报文，其中包含了可以再次认证的方法列表。

客户端从认证方法列表中选择一种方法进行再次认证。

这个过程反复进行，直到认证成功或者认证次数达到上限，服务端关闭本次TCP连接。

基于公钥和私钥的验证方式：

使用ssh-keygen程序生成公钥 id_dsa.pub 和私钥 id_dsa，一般是在客户端上生成，然后把 id_dsa.pub 通过某种方式发送给服务端。

服务端放在将要远程登录过来的那个账号的目录的.ssh目录下面。

客户端使用密钥和算法协商阶段生成的会话密钥加密账号、认证方法、id_dsa.pub，将结果发送给服务端。

服务端使用会话密钥解密报文，得到账号、id_dsa.pub。服务端在这个账号的目录的.ssh目录下找对应的公钥，如果没有找到，发送失败消息给客户端，如果找到，比较客户发送过来的这个公钥和找到的公钥，如果内容相同，服务端生成一个随机的字符串，简称“质询”，然后使用找到的公钥加密这个质询，然后使用会话密钥再次加密。

服务端把这个双重加密的数据发送给客户端。

客户端使用会话密钥解密报文，然后使用id_dsa再次解密数据，得到质询。

客户端使用会话密钥加密质询，发送给服务端。

服务端使用会话密钥解密报文，得到质询，判断是不是自己生成的那个质询，如果不相同，发送失败消息给客户端，如果相同，认证通过。