Python面试题

Python

1、为什么学习Python？
简单、易学、免费、开源、可扩展、可嵌入，代码可读性高，语法简洁，编程效率高；
Python拥有动态类型系统和垃圾回收功能，能够自动管理内存使用，并且支持多种编程范式，包括面向对象、命令式、函数式和过程式编程。其本身拥有一个巨大而广泛的标准库；Python解释器没有操作系统限制，全平台通用，可移植、组件集成、丰富库支持；
python编程脚本；
方向广泛：系统运维库编程、网络编程、web编程、多媒体应用、pymo引擎、爬虫编写、机器学习、人工智能。

2、通过什么途径学习的Python？
书籍（python基础教程）、网络课程（python基础教程）、官方文档、编程练习项目

3、Python和Java、PHP、C、C#、C++等其他语言的对比？
C++、python、Java：强类型，面向对象
强类型和弱类型
强类型：如果一种语言的所有程序都是well behaved——即不可能出现forbidden behaviors（包含所有出错后继续执行，可能包括出错后停止），则该语言为strongly typed。
弱类型：类型检查更不严格，偏向于容忍隐式类型转换。譬如说C语言的int可以变成double，容易产生forbidden behaviours。
静态类型和动态类型
静态类型 statically: 如果在编译时拒绝ill behaved程序，则是statically typed;
动态类型dynamiclly: 如果在运行时拒绝ill behaviors, 则是dynamiclly typed。

面向对象与面向过程
“面向过程”是一种是事件为中心的编程思想，就是分析出解决问题所需的步骤，然后用函数把这写步骤实现，并按顺序调用。
面向对象是以“对象”为中心的编程思想，将事物高度抽象化，抽象出类，并定义这些类的行为和方法。

面向过程就是分析出解决问题所需的步骤，面向对象则是把构成问题的事物分解成对象，抽象出对象的目的并不在于完成某个步骤，而是描述其在整个解决问题的步骤中的行为。
面向过程的思维方式是分析综合，面向对象的思维方式是构造。
从代码层结构上来说的话，面向对象和面向过程的主要区别就是数据是单独存储还是与操作存储在一起。面向对象提供了数据的封装后，对某一操作而言，数据的访问变得可靠了。 面向过程就是将coding当做一件事，一步一步完成，面向对象就是将coding当做一件事物，需要做什么的时候由事物(对象)本身的行为去完成。
面向对象更加模块化和抽象化，代码重用度高。

python：快速开发应用程序
java：健壮的大型软件
C++：需求效率的软件
C： 操作系统及驱动

C++更接近于底层，方便直接操作内存。C++不仅拥有计算机高效运行的实用性特征，同时还致力于提高大规模程序的编程质量与程序设计语言的问题描述能力。
Java在C++的基础上又做了更高级的封装，具有良好的平台间的可移植性。C++一次编写到处编译，而Java一次编译到处运行。Java中的功能C++都能够实现，只是相对来说在编程方面会比较复杂一些。
C++ 编译成本地机器码, 可以由操作系统直接运行，运行效率较高。
Java 编译成字节码，需由Java虚拟机读取运行，所以效率偏低，但可通过JIT提高运行效率。
垃圾回收方面，C++需要程序员自己回收，python和JAVA自己回收。
Python效率低，编程简单。
C是一种面向过程的语言。

4、简述解释型和编译型编程语言？
解释型语言编写的程序不需要编译，在执行的时候，专门有一个解释器能够将VB语言翻译成机器语言，每个语句都是执行的时候才翻译。这样解释型语言每执行一次就要翻译一次，效率比较低。
编译型语言写的程序执行之前，需要一个专门的编译过程，通过编译系统，把源高级程序编译成为机器语言文件，翻译只做了一次，运行时不需要翻译，所以编译型语言的程序执行效率高。部分解释型语言的解释器通过在运行时动态优化代码，甚至能够使解释型语言的性能超过编译型语言。

5、Python解释器种类以及特点？
CPython、IPython、PyPy、Jython、IronPython

6、位和字节的关系？
1字节=8位

7、b、B、KB、MB、GB 的关系？
1GB=1024 MB=1024 KB=1024 Bytes=8bit

8、请至少列举5个 PEP8 规范（越多越好）。
http://blog.sae.sina.com.cn/archives/4781

9、通过代码实现如下转换：
二进制转换成十进制：v = “0b1111011”
eval('0b1010')
int(v,2)
十进制转换成二进制：v = 18
bin(v)
八进制转换成十进制：v = “011”
int(v,8)
十进制转换成八进制：v = 30
oct(v)
十六进制转换成十进制：v = “0x12”
int(v,16)
十进制转换成十六进制：v = 87
hex(v)

10、请编写一个函数实现将IP地址转换成一个整数。
如 10.3.9.12 转换规则为：
10 00001010
3 00000011
9 00001001
12 00001100
再将以上二进制拼接起来计算十进制结果：00001010 00000011 00001001 00001100 = ？

ip = input().split('.')
ip_bin=''
for i in ip:
    ip_str=bin(int(i))[2:].rjust(8,'0')
    ip_bin+=ip_str
print(int(ip_bin,2))

11、python递归的最大层数？
系统堆栈深度有一定限度，防止无限递归造成Python溢出崩溃

#修改深度
import sys
sys.setrecursionlimit(1500)

12、求结果：

v1 = 1 or 3
v2 = 1 and 3
v3 = 0 and 2 and 1
v4 = 0 and 2 or 1
v5 = 0 and 2 or 1 or 4
v6 = 0 or Flase and 1

python and or 及三目表达式：
在python中，and自左向右扫描布尔表达式，如果所有值为真，则返回最后一个为真的表达式，如果为假，则返回第一个为假的表达式，一旦计算得出表达式是假，则直接返回第一个为假的值；
or的使用与and正好相反，自左向右计算整个布尔表达式，如果有为真的值，那么立刻返回第一个为真的值，如果整个表达式为假，则返回最后一个为假的值；
三目表达式：
result2 = a if 1 < 0 else b
Shell
表达式1 ? 表达式2 :表达式3
表达式1成立则执行表达式2，否则执行表达式3

13、ascii、unicode、utf-8、gbk 区别？
ASCII 1个字节 英文
Unicode 2个字节（生僻字4个） 所有语言
UTF-8 1-6个字节，英文字母1个字节，汉字3个字节，生僻字4-6个字节 所有语言
GBK 兼容ASCLL 兼容 GB2312 是GB2312的扩展

14、字节码和机器码的区别？
机器码：CPU可直接读取的数据机器指令，执行最快的代码，编程效率低；
字节码：节码是一种中间状态（中间码）的二进制代码（文件）。需要直译器转译后才能成为机器码。

15、三元运算规则以及应用场景？
result=a if 1>0 else b

16、列举 Python2和Python3的区别？
https://www.cnblogs.com/kendrick/p/7478304.html

17、用一行代码实现数值交换：
a = 1
b = 2
c=a;a=b;b=c

18、Python3和Python2中 int 和 long的区别？
int整数，long长整数（无限大小整数）
32位编译系统：int占四字节，与long相同。
64位编译系统：int占四字节，long占8字节
python3无long，统一使用int

19、xrange和range的区别？
xrange返回生成器，range返回list，对于循环来说，xrange性能更好
python3中去掉xrange()，统一改用range()返回生成器

20、文件操作时：xreadlines和readlines的区别？
read()会读取整个文件，将读取到底的文件内容放到一个字符串变量，返回str类型
readline()读取一行内容，放到一个字符串变量，返回str类型
readlines()读取文件所有内容，按行为单位放到一个列表中，返回list类型
xreadlines()返回一个生成器，来循环操作文件的每一行

21、列举布尔值为False的常见值？
None
False
数值中的零，包括0，0.0，0j（虚数）
空序列，包括空字符串(”)，空元组(())，空列表([])
空的字典{}
自定义的对象的实例，该对象的bool方法返回False或者len方法返回0

22、字符串、列表、元组、字典每个常用的5个方法？
字符串：len() format() islower() rjust() upper()
列表：append() count() index() pop() remove() clear()
元组：len(tuple) max(tuple) min(tuple) tuple(seq)
字典：copy() clear() items() update() setdefault()

23、lambda表达式格式以及应用场景？
lambda argument: manipulate(argument)
List sorting
Parallel sorting of lists

24、pass的作用？
空操作，语句语法需要，作为占位符，不返回值，不执行代码

25、*arg和**kwarg作用

def function(required_arg,*arg,**kwarg):
    pass

*arg会把多出来的位置参数转化为tuple
**kwarg会把关键字参数(key=value)转化为dict

26、is和==的区别
对象：id(身份标识)、type(数据类型)和value(值)
is判断对象所有信息，==比较值
只有数值型和字符串型的情况下，a is b才为True，当a和b是tuple，list，dict或set型时，a is b为False

27、简述Python的深浅拷贝以及应用场景？
浅复制：仅拷贝基本数据类型，字典 copy 方法和copy.copy()方法，也是浅复制；
深复制：拷贝数据类型和引用，计算机开辟一块新内存用于存放复制对象。

28、Python垃圾回收机制？
GC，垃圾回收，专注于1. 找到内存中无用的垃圾资源 2. 清除这些垃圾并把内存让出来给其他对象使用。Python语言默认采用的垃圾收集机制是『引用计数法 Reference Counting』，需要额外空间维持计数，不能解决循环引用问题。
循环引用示例：

#!/usr/bin/python3.5.1
# coding=utf-8
import pkg_demo.test2 as d2
def do_test1() :
    d2.do_test2()
if __name__ == '__main__' :
    do_test1()

#!/usr/bin/python3.5.1
# coding=utf-8
import pkg_demo.test1 as d1
def do_test2() :
    d1.do_test1()

为了解决对象的循环引用问题，Python引入了标记-清除和分代回收两种GC机制。

• 标记清除算法（标记和清除），对象引用构成有限图，引用关系构成边，作为Python的辅助垃圾收集技术主要处理的是一些容器对象，比如list、dict、tuple，instance等，因为对于字符串、数值对象是不可能造成循环引用问题。清除非活动的对象前它必须顺序扫描整个堆内存，哪怕只剩下小部分活动对象也要扫描所有对象。
• 分代回收，以空间换时间，将内存根据存活时间划分成不同集合，每个集合为一代，分为年轻代，中年代 ，老年代；新创建对象在年轻代，年轻代链表达到总数上限，python垃圾回收，把那些可以被回收的对象回收掉，而那些不会回收的对象就会被移到中年代，同理到老年代。分代回收是建立在标记清除技术基础之上。分代回收同样作为Python的辅助垃圾收集技术处理那些容器对象。
  https://foofish.net/python-gc.html

29、Python的可变类型和不可变类型？
不可变数据：Number（数字）、String（字符串）、Tuple（元组）；
可变数据：List（列表）、Dictionary（字典）、Sets（集合）。

30、求结果：

v = dict.fromkeys(['k1','k2'],[])
v['k1'].append(666)
print(v)
v['k1'] = 777
print(v)

{'k1': [666], 'k2': [666]}
{'k1': 777, 'k2': [666]}

31、求结果：

def num():
    return [lambda x:i*x for i in range(4)]
print([m(2) for m in num()])

[6, 6, 6, 6]

32、列举常见的内置函数？

33、filter、map、reduce的作用？

#map将函数作用在列表的各个元素，生成新的列表
map(function_to_apply, list_of_inputs)
items = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, items))

#fliter返回条件为True的元素列表，fliter返回一个生成器
number_list = range(-5, 5)
less_than_zero = list(filter(lambda x: x < 0, number_list))
print(less_than_zero)

#reduce列表滚动运算执行一系列的值
from functools import reduce
product = reduce((lambda x, y: x * y), [1, 2, 3, 4])

容器、生成器、迭代器、可迭代对象：
https://foofish.net/iterators-vs-generators.html

34、一行代码实现9*9乘法表

print '\n'.join([' '.join(['%s*%s=%-2s' % (y,x,x*y) for y in range(1,x+1)]) for x in range(1,10)])

35、如何安装第三方模块？以及用过哪些第三方模块？
在Pypi注册，easy_install或者pip安装，
numpy、flask、Django

36、至少列举8个常用模块都有那些？
sys 当前解释器
platform 计算机相关信息
math 数学计算
random 随机数
decimal 高精度浮点数计算（比float更高）
fractions 表现和处理分数
time 时间模块
re 正则
os 与操作系统交互
hashlib 摘要算法

os模块负责程序与操作系统的交互，提供了访问操作系统底层的接口;sys模块负责程序与python解释器的交互，提供了一系列的函数和变量，用于操控python的运行时环境。

37、re的match和search区别？
match（）函数只检测RE是不是在string的开始位置匹配，search()会扫描整个string查找匹配；。

38、什么是正则的贪婪匹配？
全部匹配

39、求结果：
a. [ i % 2 for i in range(10) ] #list
b. ( i % 2 for i in range(10) ) #生成器

40、求结果：
a. 1 or 2 #1
b. 1 and 2 #2
c. 1 < (2==2) #False
d. 1 < 2 == 2 #True

41、def func(a,b=[]) 这种写法有什么坑？

def func(a,b=[]):
    b.append(a)
    print(b)
func(1)
func(1)
func(1)
func(1)

　　[1]
　　[1, 1]
　　[1, 1, 1]
　　[1, 1, 1, 1]

多次实例化，需要始终保持为1的话，只有None

42、如何实现 “1,2,3” 变成 [‘1’,’2’,’3’] ?

("1, 2, 3".split(','))

43、如何实现[‘1’,’2’,’3’]变成[1,2,3] ?

list(int(i) for i in ['1','2'])

44、比较： a = [1,2,3] 和 b = [(1),(2),(3) ] 以及 c = [(1,),(2,),(3,) ] 的区别？
a和b是一样的，c是元组元素

45、如何用一行代码生成[1,4,9,16,25,36,49,64,81,100] ?

list(i**2 for i in range(1,11))

46、一行代码实现删除列表中重复的值 ?

list(set).sort(key=a.list)

47、如何在函数中设置一个全局变量 ?

global num

48、logging模块的作用？以及应用场景？
logging模块定义的函数和类为应用程序和库的开发实现了一个灵活的事件日志系统

49、请用代码简答实现stack 。

class Stack:
    def __init__(self):
        self.stack = []
    def add(self, dataval):
        if dataval not in self.stack:
            self.stack.append(dataval)
            return True
        else:
            return False
    def peek(self):     
        return self.stack[-1]
    def remove(self):
        if len(self.stack) <= 0:
            return ("No element in the Stack")
        else:
            return self.stack.pop()

50、常用字符串格式化哪几种？

%s    字符串 (采用str()的显示)
%r    字符串 (采用repr()的显示)
%c    单个字符
%b    二进制整数
%d    十进制整数
%i    十进制整数
%o    八进制整数
%x    十六进制整数
%e    指数 (基底写为e)
%E    指数 (基底写为E)
%f    浮点数
%F    浮点数，与上相同
%g    指数(e)或浮点数 (根据显示长度)
%G    指数(E)或浮点数 (根据显示长度)

51、简述容器、生成器、迭代器、可迭代对象 以及应用场景？
容器：多元素组织的数据结构，可逐个迭代地获取，通常数据结构把元素存储在内存中（迭代器和生成器对象不放在内存）。
可迭代对象：很多容器都是可迭代对象，实现了iter方法，还有打开状态的files、sockets可以返回一个迭代器的对象，。
迭代器：带状态的对象，可以通过调用实现iter和next的对象都是迭代器，iter返回自身，next返回容器的下一个值。
生成器：生成器是一类特殊的迭代器，不需要iter和next方法，直接使用yield返回，生成器一定是迭代器，生成器以一种懒加载的模式生成值。可以利用更少地中间变量写流式代码，相比其它容器对象更加节约内存和CPU
生成器表达式：列表推导式，返回一个生成器对象。

52、用Python实现一个二分查找的函数。

def binary_search(alist, item):
    """二分查找 非递归方式"""
    n = len(alist)
    start = 0
    end = n - 1
    while start <= end:
        mid = (start + end) // 2
        if alist[mid] == item:
            return True
        elif item < alist[mid]:
            end = mid - 1
        else:
            start = mid + 1
    return False
def binary_search_2(alist, item):
    """二分查找 递归方式"""
    n = len(alist)
    if 0 == n:
        return False
    mid = n // 2
    if alist[mid] == item:
        return True
    elif item < alist[mid]:
        return binary_search_2(alist[:mid], item)
    else:
        return binary_search_2(alist[mid + 1:], item)
if __name__ == '__main__':
    li = [17, 20, 26, 31, 44, 54, 55, 77, 93]
    # print(binary_search(li, 55))
    # print(binary_search(li, 100))
    print(binary_search_2(li, 55))
    print(binary_search_2(li, 100))

53、谈谈你对闭包的理解？
闭包使得局部变量在函数外被访问成为可能，函数作为函数的值返回，闭包本质上是一个特殊的函数，闭包将变量的值始终保存在函数中。闭包避免了使用全局变量，此外，闭包允许将函数与其所操作的某些数据（环境）关连起来。这一点与面向对象编程是非常类似的，在面向对象编程中，对象允许我们将某些数据（对象的属性）与一个或者多个方法相关联。当对象中只有一个方法时，这时使用闭包是更好的选择。所有函数都有一个 closure属性，如果这个函数是一个闭包的话，那么它返回的是一个由 cell 对象 组成的元组对象。cell 对象的cell_contents 属性就是闭包中的自由变量。

54、os和sys模块的作用？
os系统调用
sys python解释器环境

55、如何生成一个随机数？
import random

56、如何使用python删除一个文件？
os.remove(my_file)

57、谈谈你对面向对象的理解？
“面向过程”是一种是事件为中心的编程思想，就是分析出解决问题所需的步骤，然后用函数把这写步骤实现，并按顺序调用。
面向对象是以“对象”为中心的编程思想，将事物高度抽象化，抽象出类，并定义这些类的行为和方法。
面向对象更加模块化和抽象化，有利于代码复用。
面向对象的特征：

• 封装：程序=对象+消息
• 继承：类继承、多重继承
  一个派生类（derived class）继承基类（bass class）字段和方法。
  issubclass()或者isinstance()方法来检测类之间的关系。
• 多态：方法多态、运算符多态
  多态意味着可以对不同的对象使用同样的操作，但它们可能会以多种形态呈现出结果。在Python中，任何不知道对象到底是什么类型，但又需要对象做点什么的时候，都会用到多态。

58、Python面向对象中的继承有什么特点？
子类会继承父类的所有的属性和方法，子类也可以覆盖父类同名的变量和方法。

59、面向对象深度优先和广度优先是什么？
深入，广度同级

60、面向对象中super的作用？
它解决了子类调用父类方法的一些问题， 父类多次被调用时只执行一次， 优化了执行逻辑。

61、是否使用过functools中的函数？其作用是什么？
管理函数的工具，处理其他函数的函数。

62、列举面向对象中带爽下划线的特殊方法，如：new、init

__doc__
显示类的解释注释
__del__
析构方法
等程序执行结束后统一销毁
__call__
实例化加（）自动执行call方法  无卵用
__new__
把类重写， new调用了init   暂时无用
__dict__
类的成员变量以字典形式显示出来

63、如何判断是函数还是方法？
Function也是包含一个函数头和一个函数体, 也同样支持0到n个形参,而Method则是在function的基础上, 多了一层类的关系, 正因为这一层类, 所以区分了 function 和 method。
类关联

64、静态方法和类方法区别？
python 类语法中有三种方法，实例方法，静态方法，类方法。
@staticmethod装饰的不带self参数的方法叫做静态方法，没有@staticmethod修饰的不带sefl参数的方法叫类方法。
1.静态方法和类方法都可以通过类来调用；
2.静态方法可以实例来调用，类方法不能通过实例来调用。

65、列举面向对象中的特殊成员以及应用场景
call
getitem、setitem、delitem
dict获取类或对象中的所有成员

66、1、2、3、4、5 能组成多少个互不相同且无重复的三位数

67、什么是反射？以及应用场景？
反射：通过字符串映射object对象的方法或者属性
核心本质其实就是利用字符串的形式去对象（模块）中操作（查找/获取/删除/添加）成员，一种基于字符串的事件驱动

hasattr(obj,name_str): 判断objec是否有name_str这个方法或者属性
getattr(obj,name_str): 获取object对象中与name_str同名的方法或者函数
setattr(obj,name_str,value): 为object对象设置一个以name_str为名的value方法或者属性
delattr(obj,name_str): 删除object对象中的name_str方法或者属性

在我们做接口自动化的时候,需要通过不同的请求方式,调用不同的函数

68、metaclass作用？以及应用场景？
元类就是用来创建类这种对象的东西，元类是类的类，type就是Python的内建元类。
元类的主要目的就是为了当创建类时能够自动地改变类。元类的主要用途是创建API。

69、用尽量多的方法实现单例模式。
单例模式（Singleton Pattern）是一种常用的软件设计模式，该模式的主要目的是确保某一个类只有一个实例存在。当你希望在整个系统中，某个类只能出现一个实例时，单例对象就能派上用场。
使用模块

class My_Singleton(object):
    def foo(self):
        pass
my_singleton = My_Singleton()

from mysingleton import my_singleton
my_singleton.foo()

使用 __new__

class Singleton(object):
    _instance = None
    def __new__(cls, *args, **kw):
        if not cls._instance:
            cls._instance = super(Singleton, cls).__new__(cls, *args, **kw)  
        return cls._instance  
class MyClass(Singleton):  
    a = 1

使用装饰器（decorator）

from functools import wraps
def singleton(cls):
    instances = {}
    @wraps(cls)
    def getinstance(*args, **kw):
        if cls not in instances:
            instances[cls] = cls(*args, **kw)
        return instances[cls]
    return getinstance
@singleton
class MyClass(object):
    a = 1

使用元类（metaclass）

class Singleton(type):
    _instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]
# Python2
class MyClass(object):
    __metaclass__ = Singleton
# Python3
# class MyClass(metaclass=Singleton):
#    pass

70、装饰器的写法以及应用场景。
装饰器的强大在于它能够在不修改原有业务逻辑的情况下对代码进行扩展，权限校验、用户认证、日志记录、性能测试、事务处理、缓存等都是装饰器的绝佳应用场景，它能够最大程度地对代码进行复用。
装饰器是一个带有函数作为参数并返回一个新函数的闭包，本质上装饰器也是函数。Python为装饰器提供了语法糖 @调用。

71、异常处理写法以及如何主动抛出异常（应用场景）
try...except...finally

72、什么是面向对象的mro
对于你定义的每一个类，Python 会计算出一个方法解析顺序（Method Resolution Order, MRO）列表，它代表了类继承的顺序，我们可以使用下面的方式获得某个类的 MRO 列表：
那这个 MRO 列表的顺序是怎么定的呢，它是通过一个 C3 线性化算法来实现的，这里我们就不去深究这个算法了，感兴趣的读者可以自己去了解一下，总的来说，一个类的 MRO 列表就是合并所有父类的 MRO 列表，并遵循以下三条原则：

• 子类永远在父类前面
• 如果有多个父类，会根据它们在列表中的顺序被检查
• 如果对下一个类存在两个合法的选择，选择第一个父类

最佳实现:
避免多重继承
super使用一致
不要混用经典类和新式类
调用父类的时候注意检查类层次

73、isinstance作用以及应用场景？
isinstance() 函数来判断一个对象是否是一个已知的类型，isinstance(object, classinfo)

74、写代码并实现：
Given an array of integers, return indices of the two numbers such that they add up to a specific target.You may assume that each input would
have exactly one solution, and you may not use the same element twice.
Example:
Given nums = [2, 7, 11, 15], target = 9,
Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1]

class Solution(object):
    def twoSum(self, nums, target):
        dict={}
        for i in  range(len(nums)):
            if  target-nums[i] in dict:
                return  [dict[target-nums[i]],i]
            dict[nums[i]] = i
        return  []
result=Solution()
print(result.twoSum([2, 7, 11, 15],9))

75、json序列化时，可以处理的数据类型有哪些？如何定制支持datetime类型？

自定义时间序列化转换器
import json
from json import JSONEncoder
from datetime import datetime
class ComplexEncoder(JSONEncoder):
    def default(self, obj):
        if isinstance(obj, datetime):
            return obj.strftime('%Y-%m-%d %H:%M:%S')
        else:
            return super(ComplexEncoder,self).default(obj)
d = { 'name':'alex','data':datetime.now()}
print(json.dumps(d,cls=ComplexEncoder))
# {"name": "alex", "data": "2018-05-18 19:52:05"}

76、json序列化时，默认遇到中文会转换成unicode，如果想要保留中文怎么办？

import json
a=json.dumps({"ddf":"你好"},ensure_ascii=False)
print(a) #{"ddf": "你好"}

77、什么是断言？应用场景？
断言(声明)一个表达式必须为真, 否则的话就抛出异常信息, 让程序预先崩溃。
assert捕捉程序员的错误
exception捕捉的是用户或者环境的错误
应用场景：

• 防御性的编程
• 运行时对程序逻辑的检测
• 合约性检查（比如前置条件，后置条件）
• 程序中的常量
• 检查文档

78、有用过with statement吗？它的好处是什么？
自动清理释放资源

With open('1.txt') as f1, open('2.txt') as  f2:
    do something

79、使用代码实现查看列举目录下的所有文件。

import os
files= os.listdir(path)

80、简述 yield和yield from关键字。
带有 yield 的函数不再是一个普通函数，Python 解释器会将其视为一个 generator。
利用yield from语句向生成器（协程）传送数据。

第二部分 网络编程和并发（34题）
1、简述 OSI 七层协议。
物理层、数据链路层、网络层、传输层、会话层、表示层、应用层

2、什么是C/S和B/S架构？
C/S客户端-服务端模型
B/S浏览器-服务端模型，处理数据较少

3、简述 三次握手、四次挥手的流程。

4、什么是arp协议？
IP-->MAC
RARP：MAC-->IP

5、TCP和UDP的区别？
可靠传输（面向连接、端到端、拥塞控制、流量控制、分片重组、数据校验、全双工、紧急数据传输、字节流传输） vs 尽力传输（无连接、面向报文、多对多、时延小、首部小）

6、什么是局域网和广域网？
跨域

7、为何基于tcp协议的通信比基于udp协议的通信更可靠？
面向连接：三次握手和四次挥手
拥塞控制、流量控制
数据包校验，分片重组

8、什么是socket？简述基于tcp协议的套接字通信流程。
socket翻译为套接字，socket是在应用层和传输层之间的一个抽象层，它把TCP/IP层复杂的操作抽象为几个简单的接口供应用层调用已实现进程在网络中通信。IP+协议+端口
socket是一种"打开—读/写—关闭"模式的实现，服务器和客户端各自维护一个"文件"，在建立连接打开后，可以向自己文件写入内容供对方读取或者读取对方内容，通讯结束时关闭文件。

通信流程：

• 服务器根据地址类型（ipv4,ipv6）、socket类型、协议创建socket
• 服务器为socket绑定ip地址和端口号
• 服务器socket监听端口号请求，随时准备接收客户端发来的连接，这时候服务器的socket并没有被打开
• 客户端创建socket
• 客户端打开socket，根据服务器ip地址和端口号试图连接服务器socket
• 服务器socket接收到客户端socket请求，被动打开，开始接收客户端请求，直到客户端返回连接信息。这时候socket进入阻塞状态，所谓阻塞即accept()方法一直到客户端返回连接信息后才返回，开始接收下一个客户端请求
• 客户端连接成功，向服务器发送连接状态信息
• 服务器accept方法返回，连接成功
• 客户端向socket写入信息
• 服务器读取信息
• 客户端关闭
• 服务器端关闭

9、什么是粘包？ socket 中造成粘包的原因是什么？ 哪些情况会发生粘包现象？
粘包：指发送方发送的若干包数据到接收方接收时粘成一包，从接收缓冲区看，后一包数据的头紧接着前一包数据的尾。出现粘包现象的原因是多方面的，它既可能由发送方造成，也可能由接收方造成。
发送方：TCP协议
接收方：接收方用户进程不及时接收数据
1发送端需要等缓冲区满才发送出去，造成粘包
2接收方不及时接收缓冲区的包，造成多个包接收
方法：调整缓冲区（发送接收变长消息，根据消息长度制定缓冲区）、消息首尾添加特殊字符

10、IO多路复用的作用？
I/O多路复用实际上就是用select, poll, epoll监听多个io对象，当io对象有变化（有数据）的时候就通知用户进程。好处就是单个进程可以处理多个socket。
I/O 多路复用的特点是通过一种机制一个进程能同时等待多个文件描述符，而这些文件描述符（套接字描述符）其中的任意一个进入读就绪状态，select()函数就可以返回。

11、什么是防火墙以及作用？
防火墙是指设置在不同网络（如可信任的企业内部网和不可信的公共网）或网络安全域之间的一系列部件的组合。 它可通过监测、限制、更改跨越防火墙的数据流，尽可能地对外部屏蔽网络内部的信息、结构和运行状况， 以此来实现网络的安全保护。
在逻辑上，防火墙是一个分离器，一个限制器，也是一个分析器，有效地监控了内部网和Internet之间的任何活动， 保证了内部网络的安全。
作用：访问控制，安全管理

12、select、poll、epoll 模型的区别？
http://blog.jobbole.com/103290/
select是不断轮询去监听的socket，socket个数有限制，一般为1024个；

（1）每次调用select，都需要把fd集合从用户态拷贝到内核态，这个开销在fd很多时会很大
（2）同时每次调用select都需要在内核遍历传递进来的所有fd，这个开销在fd很多时也很大
（3）select支持的文件描述符数量太小了，默认是1024

poll还是采用轮询方式监听，只不过没有个数限制，采用链表存储，大量数组复制于用户态和内核地址空间之间，水平触发，没有被处理，下次还会报告。

epoll并不是采用轮询方式去监听了(读写就绪链表)，而是当socket有变化时通过回调的方式主动告知用户进程。支持水平触发和边缘触发，支持事件通知。
没有最大并发连接限制（1G内存监听约10万）；效率提升（只管活跃的链接，与连接总数无关）；内存拷贝

但select，poll，epoll本质上都是同步I/O，因为他们都需要在读写事件就绪后自己负责进行读写，也就是说这个读写过程是阻塞的

（1）select，poll实现需要自己不断轮询所有fd集合，直到设备就绪，期间可能要睡眠和唤醒多次交替。而epoll其实也需要调用epoll_wait不断轮询就绪链表，期间也可能多次睡眠和唤醒交替，但是它是设备就绪时，调用回调函数，把就绪fd放入就绪链表中，并唤醒在epoll_wait中进入睡眠的进程。虽然都要睡眠和交替，但是select和poll在“醒着”的时候要遍历整个fd集合，而epoll在“醒着”的时候只要判断一下就绪链表是否为空就行了，这节省了大量的CPU时间。这就是回调机制带来的性能提升。
（2）select，poll每次调用都要把fd集合从用户态往内核态拷贝一次，并且要把current往设备等待队列中挂一次，而epoll只要一次拷贝，而且把current往等待队列上挂也只挂一次（在epoll_wait的开始，注意这里的等待队列并不是设备等待队列，只是一个epoll内部定义的等待队列）。这也能节省不少的开销。

import select
import socket
import sys
import Queue
# Create a TCP/IP socket
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.setblocking(0)
# Bind the socket to the port
server_address = ('localhost', 10000)
print >>sys.stderr, 'starting up on %s port %s' % server_address
server.bind(server_address)
# Listen for incoming connections
server.listen(5)

13、简述 进程、线程、协程的区别 以及应用场景？
子程序调用是通过栈实现的，一个线程就是执行一个子程序。
协程运行效率极高，无需线程切换，由程序自身控制；
协程控制共享资源不加锁，执行效率比多线程高；
多核CPU使用：多进程+协程，既充分利用多核，又充分发挥协程的高效率，可获得极高的性能。
1.进程拥有自己独立的堆和栈，堆和栈都不共享，进程由操作系统调度
2.线程拥有自己独立的栈，但是堆却是共享的，标准的线程是由操作系统调度的，线程阻塞由操作系统内核切换。

yield/send

堆栈：
浅谈堆和栈的区别：https://www.cnblogs.com/mysticCoder/p/4921724.html

栈（操作系统）：由操作系统自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。
堆（操作系统）： 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收，分配方式倒是类似于链表

14、GIL锁是什么鬼？
全局解释锁，CPython的产物
尽管Python完全支持多线程编程， 但是解释器的C语言实现部分在完全并行执行时并不是线程安全的。 实际上，解释器被一个全局解释器锁保护着，它确保任何时候都只有一个Python线程执行。
http://cenalulu.github.io/python/gil-in-python/

15、Python中如何使用线程池和进程池？
多线程和多进程
目前Python多线程不能利用CPU多核优势，IO密集型可用多线程，CPU密集型适合用多进程。
进程池multiprocessing.Pool和线程池multiprocessing.dummy.Pool
https://blog.csgrandeur.com/blogs/20160510-python-threadpool-processpool

16、threading.local的作用？
线程同步机制，通过互斥锁，条件变量或者读写锁来控制对全局变量的访问。ThreadLocal 变量，它本身是一个全局变量，但是每个线程却可以利用它来保存属于自己的私有数据，这些私有数据对其他线程也是不可见的。每个线程都可以通过 global_data.num 获得自己独有的数据，并且每个线程读取到的 global_data 都不同，真正做到线程之间的隔离。
http://python.jobbole.com/86150/

17、进程之间如何进行通信？

• 管道（pipe）及命名管道（named pipe）：管道可用于具有亲缘关系的父子进程间的通信，有名管道除了具有管道所具有的功能外，它还允许无亲缘关系进程间的通信；
• 信号（signal）：信号是一种比较复杂的通信方式，用于通知接收进程某个事件已经发生；
• 消息队列：消息队列是消息的链接表，它克服了上两种通信方式中信号量有限的缺点，具有写权限得进程可以按照一定得规则向消息队列中添加新信息；对消息队列有读权限得进程则可以从消息队列中读取信息；
  共享内存：可以说这是最有用的进程间通信方式。它使得多个进程可以访问同一块内存空间，不同进程可以及时看到对方进程中对共享内存中数据得更新。这种方式需要依靠某种同步操作，如互斥锁和信号量等；
• 信号量：主要作为进程之间及同一种进程的不同线程之间得同步和互斥手段；
• 套接字：这是一种更为一般得进程间通信机制，它可用于网络中不同机器之间的进程间通信，应用非常广泛。

18、什么是并发和并行？
多线程是并发执行的；
多核CPU是并行执行的，单核CPU是不可以并行执行的；
并发（Concurrent）：是一种构造程序的方式，把任务分解为一个个独立运行的小任务。通信是协调这些小任务的手段。
并行（Parallel）：以分组的方式，同时执行每一组并发任务。

19、进程锁和线程锁的作用？
进程间共享数据的保护，需要进程互斥锁。
线程间共享数据的保护，需要线程互斥锁，能锁住变量的更新, 让它按预定的方式进行更新和交流。
文件锁，锁住文件，禁止访问。
分布式锁是控制分布式系统之间同步访问共享资源的一种方式。 在分布式系统中，常常需要协调他们的动作。 如果不同的系统或是同一个系统的不同主机之间共享了一个或一组资源，那么访问这些资源的时候，往往需要互斥来防止彼此干扰来保证一致性，在这种情况下，便需要使用到分布式锁。

20、解释什么是异步非阻塞？
同步，异步，阻塞，非阻塞
同步/异步：针对于C端，数据访问进程是否阻塞
- 同步：事情必须一件一件做完；
例如普通B/S模式，提交请求-->等待服务器处理-->处理完毕返回，期间浏览器不能干任何事
- 异步：调用者不会立刻得到结果，实际调用在完成后，会通过状态、通知和回调来通知调用者。
ajax请求：请求通过事件触发-->服务器处理（之间浏览器可以处理其他事情）-->处理完毕

阻塞/非阻塞：针对于S端，应用程序调用是否立即返回
- 阻塞：
调用结果返回之前，当前线程会被挂起（进程进入非可执行状态，在这个状态下，cpu不会给线程分配时间片，即线程暂停运行），函数只有在得到结果之后才会返回。
- 非阻塞：
不能立刻得到结果之前，该函数不会阻塞当前线程，二会立刻返回。

21、路由器和交换机的区别？
交换机是利用物理地址或者说MAC地址来确定转发数据的目的地址。而路由器则是利用不同网络的ID号(即IP地址)来确定数据转发的地址。

22、什么是域名解析？
DNS，URL/URI-->IP
URI：Uniform Resource Identifier，统一资源标识符
URL：Uniform Resource Location统一资源定位符，属于URI中的一种
URN：唯一的一个命名。
URI，是统一资源标识符，用来唯一的标识一个资源。而URL是统一资源定位器，它是一种具体的URI，即URL可以用来标识一个资源，而且还指明了如何locate这个资源。而URN，统一资源命名，是通过名字来标识资源。

23、如何修改本地hosts文件？

cat /etc/hosts | grep ...
echo '' >> /etc/hosts
sed -i 's///g' file
sed -i '$a\要插入的文字' file.txt #最后一行后插入

24、生产者消费者模型应用场景及优势？
https://segmentfault.com/a/1190000008909344
生产者和消费者模式是一种并发设计模式，生产者消费者模式解决的是两者速率不一致而产生的阻抗不匹配，该模式通过平衡生产线程和消费线程的工作能力来提高程序的整体处理数据的速度。
3种关系：生产者之间（互斥)、消费者之间（互斥）、生产者与消费者（同步、互斥）
2个角色：生产者与消费者
1个场所：缓冲区（仓库）
特点：

• 解耦
  生产者不直接调用消费者，不会产生完全的依赖关系，耦合度降低。
• 并发
  缓冲区通信，可以不断的往缓冲区放数据。
• 支持忙闲等待
  生产者产生的数据放在缓冲区，慢慢处理，不会因为消费者的性能造成数据丢失或者影响生产者生产。

25、什么是cdn？
内容分发网络，是在现有 Internet 中增加的一层新的网络架构，由遍布全国的高性能加速节点构成。这些高性能的服务节点都会按照一定的缓存策略存储您的业务内容，当您的用户向您的某一业务内容发起请求时，请求会被调度至最接近用户的服务节点，直接由服务节点快速响应，有效降低用户访问延迟，提升可用性。

26、LVS是什么及作用？
https://www.cnblogs.com/codebean/archive/2011/07/25/2116043.html
LVS，Linux虚拟服务器，LVS主要用于多服务器的负载均衡。它工作在网络层，可以实现高性能，高可用的服务器集群技术。它廉价，可把许多低性能的服务器组合在一起形成一个超级服务器。它易用，配置非常简单，且有多种负载均衡的方法。它稳定可靠，即使在集群的服务器中某台服务器无法正常工作，也不影响整体效果。另外可扩展性也非常好。

27、Nginx是什么及作用？
Nginx是一个高性能的 HTTP 和 反向代理 服务器，也是一个 IMAP/POP3/SMTP 代理服务器。因它的稳定性、丰富的功能集、示例配置文件和低系统资源的消耗而闻名。
优点：更快、高扩展性、高可靠性、低内存消耗、单机支持高并发(10w条)、热部署、支持BSD协议。

28、keepalived是什么及作用?
keepadlive是通过路由器的VRRP协议实现来实现服务器的高可用防止单点故障发生的技术。
VRRP协议简介：VRRP是一种容错协议，它保证当主机的下一跳坏掉时，可以及时由另一台路由器来代替，从而保持通讯的连续性和可靠性。为了使vrrp能正常工作，要在路由器上配置虚拟路由器号和路由器的虚拟ip地址，同时产生一个虚拟MAC地址,这样在网络这就加入了一个虚拟路由器。一个主路由器和若干个备份路由器组成一个虚拟路由器，当主路由器发生故障时，一个备份路由器成为主路由器，接替他工作。
支持三层（ICMP，IP）、四层（IP+PORT）、七层（相关服务特殊设置）

29、haproxy是什么以及作用？
HAProxy提供高可用性、负载均衡以及基于TCP和HTTP应用的代理 ，支持虚拟机，它是免费、快速并且可靠的一种解决方案。HAProxy特别适用于高负载且需要持久连接或7层处理机制的web站点，这些站点通常又要会话保持或七层处理，HAProxy运行在时下的硬件上，完全可以支持数以万计的并发连接，并且它的运行模式使得它可以很简单安全的融合进你当前的架构中，同时可以保护你的web服务器不被暴露到网络上。
HAProxy实现了一种事件驱动、单一进行模型，此模型支持非常大的并发连接数，多进行或多线程模型受内存限制、系统调度器限制以及无处不在的锁限制，很少处理数千并发连接。
高性能方法：

• 单进程、事件驱动模型
  显著降低了上下文切换的开销及内存占用
• O（1）事件检查器（event checker）
  允许其在高并发连接中对任何连接的任何事件实现即时探测
• 单缓冲（single buffering）机制
  以不复制任何数据的方式完成读写操作，这会节约大量的CPU时钟周期及内存带宽
• splice()系统调用机制
  在2.6(>=2.6.27.19)Haproxy可以实现零复制转发（zero-copy forwarding）,在Linux3.5及以上的OS中还可以实现零复制启动（zero-starting）
• 优秀的内存分配器
  内存分配器在固定大小的内存池中实现即时内存分配，能够显著减少创建一个会话的时长
• 树形存储
  侧重于使用作者多年前开发的弹性二叉树算法，实现了以O(log(N))的低开销来保持启动计时器命令、保持运行队列命令及管理轮询及最少连接队列
• 优化的HTTP首部分析机制
  优化的首部分析功能避免了HTTP首部分析过程中重读任何区域
• 精心地降低了昂贵的系统调用
  大部分工作在用户空间完成，如时间读取、缓冲聚合及文件描述符的启用和禁用等
  软件负载均衡设备使用TCP缓冲，可建立极长的请求，且有着较大的响应时间。

30、什么是负载均衡？
负载平衡（Load balancing）是一种计算机技术，用来在多个计算机（计算机集群）、网络连接、CPU、磁碟驱动器或其他资源中分配负载，以达到最佳化资源使用、最大化吞吐率、最小化响应时间、同时避免过载的目的。
使用带有负载平衡的多个伺服器组件，取代单一的组件，可以通过冗余提高可靠性。负载平衡服务通常是由专用软件和硬件来完成。

31、什么是rpc及应用场景？
RPC（Remote Procedure Call Protocol）——远程过程调用协议，它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。RPC协议假定某些传输协议的存在，如TCP或UDP，为通信程序之间携带信息数据。在OSI网络通信模型中，RPC跨越了传输层和应用层。RPC使得开发包括网络分布式多程序在内的应用程序更加容易。

32、简述 asyncio模块的作用和应用场景。
asyncio模块提供了一种关于事件循环的框架。事件循环就是等待一些任务发生，然后执行相应的事件。它也会处理例如IO操作或者系统事件。asyncio实际中有好几种循环实现方式。模块默认使用的方式是其所运行的操作系统上最有效的方式。如果你愿意，你也可以显式地选择其它事件循环方式。一个事件循环就是当事件A发生时，函数B共同起作用。

33、简述 gevent模块的作用和应用场景。
基于协程的Python网络库
API的概念和Python标准库一致(如事件，队列)。
TCP/UDP/HTTP服务器
能够使用标准库和第三方模块创建标准的阻塞套接字
可以配合socket，ssl模块使用
子进程支持（通过gevent.subprocess）
基于greenlet的轻量级执行单元
线程池
gevent每次遇到io操作，需要耗时等待时，会自动跳到下一个协程继续执行。
gevent的代码风格和线程非常相似，运行出来后的效果也非常相似。

34、twisted框架的使用和应用？
twisted是一个用python语言写的事件驱动的网络框架，他支持很多种协议，包括UDP,TCP,TLS和其他应用层协议，比如HTTP，SMTP，NNTM，IRC，XMPP/Jabber。 非常好的一点是twisted实现和很多应用层的协议，开发人员可以直接只用这些协议的实现。其实要修改Twisted的SSH服务器端实现非常简单。很多时候，开发人员需要实现protocol类。
一个Twisted程序由reactor发起的主循环和一些回调函数组成。当事件发生了，比如一个client连接到了server，这时候服务器端的事件会被触发执行。

第三部分 数据库和缓存（46题）
1、列举常见的关系型数据库和非关系型都有那些？
关系型：Mysql、Oracle、MS SQL
瓶颈：高并发读写需求，海量数据的高效率读写、高扩展性和可用性
非关系型：
面向高性能并发读写的key-value数据库：Redis
面向海量数据访问的面向文档数据库：MongoDB
面向可扩展性的分布式数据库
常见的Oracle 、SQLserver、Mysql都属于关系型数据库，主要是存放结构化数据，像可以表格 化的数据，mongoDB属于非关系型数据库，主要用于存放非结构化数据，像音频视频、文本。

2、MySQL常见数据库引擎及比较？
MyISAM是mysql的默认数据库引擎，其由早期的ISAM（Indexed Sequential Access Method：有索引的顺序访问方法）所改良。虽然MyISAM性能极佳，但却有一个显著的缺点：不支持事务处理。不过，MySQL也导入了另一种数据库引擎InnoDB，以强化参考完整性与并发违规处理机制，后来就逐渐取代MyISAM。
InnoDB是MySQL的数据库引擎之一，其由Innobase oy公司所开发，2006年五月由甲骨文公司并购。与传统的ISAM、MyISAM相比，InnoDB的最大特色就是支持ACID兼容的事务功能，类似于PostgreSQL。目前InnoDB采用双轨制授权，一是GPL授权，另一是专有软件授权。具体地，MyISAM与InnoDB作为MySQL的两大存储引擎的差异主要包括：

• 存储结构：每个MyISAM在磁盘上存储成三个文件：第一个文件的名字以表的名字开始，扩展名指出文件类型。.frm文件存储表定义，数据文件的扩展名为.MYD (MYData)，索引文件的扩展名是.MYI (MYIndex)。InnoDB所有的表都保存在同一个数据文件中（也可能是多个文件，或者是独立的表空间文件），InnoDB表的大小只受限于操作系统文件的大小，一般为2GB。
• 存储空间：MyISAM可被压缩，占据的存储空间较小，支持静态表、动态表、压缩表三种不同的存储格式。InnoDB需要更多的内存和存储，它会在主内存中建立其专用的缓冲池用于高速缓冲数据和索引。
• 可移植性、备份及恢复：MyISAM的数据是以文件的形式存储，所以在跨平台的数据转移中会很方便，同时在备份和恢复时也可单独针对某个表进行操作。InnoDB免费的方案可以是拷贝数据文件、备份 binlog，或者用 mysqldump，在数据量达到几十G的时候就相对痛苦了。
• 事务支持：MyISAM强调的是性能，每次查询具有原子性，其执行数度比InnoDB类型更快，但是不提供事务支持。InnoDB提供事务、外键等高级数据库功能，具有事务提交、回滚和崩溃修复能力。
• AUTO_INCREMENT：在MyISAM中，可以和其他字段一起建立联合索引。引擎的自动增长列必须是索引，如果是组合索引，自动增长可以不是第一列，它可以根据前面几列进行排序后递增。InnoDB中必须包含只有该字段的索引，并且引擎的自动增长列必须是索引，如果是组合索引也必须是组合索引的第一列。
• 表锁差异：MyISAM只支持表级锁，用户在操作MyISAM表时，select、update、delete和insert语句都会给表自动加锁，如果加锁以后的表满足insert并发的情况下，可以在表的尾部插入新的数据。InnoDB支持事务和行级锁。行锁大幅度提高了多用户并发操作的新能，但是InnoDB的行锁，只是在WHERE的主键是有效的，非主键的WHERE都会锁全表的。
• 全文索引：MyISAM支持 FULLTEXT类型的全文索引；InnoDB不支持FULLTEXT类型的全文索引，但是innodb可以使用sphinx插件支持全文索引，并且效果更好。
• 表主键：MyISAM允许没有任何索引和主键的表存在，索引都是保存行的地址。对于InnoDB，如果没有设定主键或者非空唯一索引，就会自动生成一个6字节的主键(用户不可见)，数据是主索引的一部分，附加索引保存的是主索引的值。
• 表的具体行数：MyISAM保存表的总行数，select count() from table;会直接取出出该值；而InnoDB没有保存表的总行数，如果使用select count() from table；就会遍历整个表，消耗相当大，但是在加了wehre条件后，myisam和innodb处理的方式都一样。
• CURD操作：在MyISAM中，如果执行大量的SELECT，MyISAM是更好的选择。对于InnoDB，如果你的数据执行大量的INSERT或UPDATE，出于性能方面的考虑，应该使用InnoDB表。DELETE从性能上InnoDB更优，但DELETE FROM table时，InnoDB不会重新建立表，而是一行一行的删除，在innodb上如果要清空保存有大量数据的表，最好使用truncate table这个命令。
• 外键：MyISAM不支持外键，而InnoDB支持外键。
  通过上述的分析，基本上可以考虑使用InnoDB来替代MyISAM引擎了，原因是InnoDB自身很多良好的特点，比如事务支持、存储过程、视图、行级锁、外键等等。尤其在并发很多的情况下，相信InnoDB的表现肯定要比MyISAM强很多。另外，必须需要注意的是，任何一种表都不是万能的，合适的才是最好的，才能最大的发挥MySQL的性能优势。如果是不复杂的、非关键的Web应用，还是可以继续考虑MyISAM的，这个具体情况具体考虑。

3、简述数据三大范式？
1NF：列不可再分；
2NF：有主键，保证完全依赖；
3NF：无传递依赖(非主键列 A 依赖于非主键列 B，非主键列 B 依赖于主键的情况)。

4、什么是事务？MySQL如何支持事务？
数据库事务是数据库管理系统执行过程中的一个逻辑单位，由一个有限的数据库操作序列构成。
MySQL的事务支持不是绑定在MySQL服务器本身，而是与存储引擎相关，MySQL支持事务的存储引擎是Innodb。
Innodb的事务实现：
事务的隔离性由锁来实现，原子性，一致性，持久性通过数据库的 redo log（用来保证原子性和持久性，redo 恢复提交事务修改的页操作，redo通常是物理日志，记录的是页的修改操作）和 undo log（用来保证一致性，undo 回滚行记录到某个特定版本，undo是逻辑日志，根据每行记录进行记录）来完成。
redo log
binlog
undo log
http://wiki.xiaohansong.com/db/innoDB_transaction.html

5、简述数据库设计中一对多和多对多的应用场景？
数据库实体间有三种对应关系：一对一，一对多，多对多。
一对多（一个班级对多名学生）：设计数据库表：只需在 学生表 中多添加一个班级号的ID；
多对多（多个学生对多门课程）：处理多对多表问题时，就要考虑建立关系表了所以对于多对多表，通过关系表就建立起了两张表的联系！多对多表时建立主外键后，要先删除约束表内容再删除主表内容。

6、如何基于数据库实现商城商品计数器？
SPU = Standard Product Unit （标准化产品单元）
SKU = stock keeping unit(库存量单位)
ARPU = Average Revenue Per User(每用户平均收入)
SPU、SKU、ARPU
分类表 <= 商品表 <= SKU表(库存表)
分类表 <= 属性名 <= 属性值
商品表 <= 商品和属性关系表 => 属性名|属性值

7、常见SQL（必备）
详见武沛齐博客：
https://www.cnblogs.com/wupeiqi/articles/5729934.html
http://www.runoob.com/sql/sql-tutorial.html

8、简述触发器、函数、视图、存储过程？
触发器：触发器是与表相关的数据库对象，在满足定义条件时触发，并执行触发器中定义的语句集合。触发器的这种特性可以协助应用在数据库端确保数据库的完整性。
函数：
SQL Aggregate 函数计算从列中取得的值，返回一个单一的值。
有用的 Aggregate 函数：
AVG() - 返回平均值
COUNT() - 返回行数
FIRST() - 返回第一个记录的值
LAST() - 返回最后一个记录的值
MAX() - 返回最大值
MIN() - 返回最小值
SUM() - 返回总和

SQL Scalar 函数基于输入值，返回一个单一的值。
有用的 Scalar 函数：
UCASE() - 将某个字段转换为大写
LCASE() - 将某个字段转换为小写
MID() - 从某个文本字段提取字符，MySql 中使用
SubString(字段，1，end) - 从某个文本字段提取字符
LEN() - 返回某个文本字段的长度
ROUND() - 对某个数值字段进行指定小数位数的四舍五入
NOW() - 返回当前的系统日期和时间
FORMAT() - 格式化某个字段的显示方式

视图：
视图是一种虚拟的表，通常是有一个表或者多个表的行或列的子集，具有和物理表相同的功能，可以对视图进行增，删，改，查等操作。特别地，对视图的修改不影响基本表。相比多表查询，它使得我们获取数据更容易。

游标：是对查询出来的结果集作为一个单元来有效的处理。游标可以定在该单元中的特定行，从结果集的当前行检索一行或多行。可以对结果集当前行做修改。一般不使用游标，但是需要逐条处理数据的时候，游标显得十分重要。

存储过程：存储过程是事先经过编译并存储在数据库中的一段SQL语句的集合。进一步地说，存储过程是由一些T-SQL语句组成的代码块，这些T-SQL语句代码像一个方法一样实现一些功能（对单表或多表的增删改查），然后再给这个代码块取一个名字，在用到这个功能的时候调用他就行了。存储过程具有以下特点：

• 存储过程只在创建时进行编译，以后每次执行存储过程都不需再重新编译，而一般 SQL 语句每执行一次就编译一次，所以使用存储过程可提高数据库执行效率；
• 当SQL语句有变动时，可以只修改数据库中的存储过程而不必修改代码；
• 减少网络传输，在客户端调用一个存储过程当然比执行一串SQL传输的数据量要小；
• 通过存储过程能够使没有权限的用户在控制之下间接地存取数据库，从而确保数据的安全。

存储过程与函数的区别：
区别：

9、MySQL索引种类
单列：
　　1、普通索引 index 　　加速查找
　　2、唯一索引 unique 　　加速查找+不能重复
　　3、主键索引 primary key 加速查找+不能重复+不能为空
多列：
　　1、联合索引
　　2、联合唯一索引
　　3、联合主键索引

10、索引在什么情况下遵循最左前缀的规则？
联合索引遵从最左前缀原则
如果组合索引为：(name,email)
name and email -- 使用索引
name -- 使用索引
email -- 不使用索引

11、主键和外键的区别？
主键：指字段唯一、不为空值的列，是能确定一条记录的唯一标识。
外键：用于与另一张表的关联。

12、MySQL常见的函数？
https://www.cnblogs.com/falling-maple/p/6230142.html
SQL Aggregate 函数计算从列中取得的值，返回一个单一的值。
有用的 Aggregate 函数：
AVG() - 返回平均值
COUNT() - 返回行数
FIRST() - 返回第一个记录的值
LAST() - 返回最后一个记录的值
MAX() - 返回最大值
MIN() - 返回最小值
SUM() - 返回总和

SQL Scalar 函数基于输入值，返回一个单一的值。
有用的 Scalar 函数：
UCASE() - 将某个字段转换为大写
LCASE() - 将某个字段转换为小写
MID() - 从某个文本字段提取字符，MySql 中使用
SubString(字段，1，end) - 从某个文本字段提取字符
LEN() - 返回某个文本字段的长度
ROUND() - 对某个数值字段进行指定小数位数的四舍五入
NOW() - 返回当前的系统日期和时间
FORMAT() - 格式化某个字段的显示方式

13、列举 创建索引但是无法命中索引的8种情况。
1) 没有查询条件，或者查询条件没有建立索引
2) 在查询条件上没有使用引导列
3) 查询的数量是大表的大部分，应该是30％以上。
4) 索引本身失效
5) 查询条件使用函数在索引列上，或者对索引列进行运算，运算包括(+，-，*，/，! 等) 错误的例子：select * from test where id-1=9; 正确的例子：select * from test where id=10;
6) 对小表查询
7) 提示不使用索引
8) 统计数据不真实
9) CBO计算走索引花费过大的情况。其实也包含了上面的情况，这里指的是表占有的block要比索引小。
10)隐式转换导致索引失效.这一点应当引起重视.也是开发中经常会犯的错误. 由于表的字段tu_mdn定义为varchar2(20),但在查询时把该字段作为number类型以where条件传给Oracle,这样会导致索引失效. 错误的例子：select * from test where tu_mdn=13333333333; 正确的例子：select * from test where tu_mdn='13333333333';
12) 1,<> 2,单独的>,<,(有时会用到，有时不会)
13,like "%_" 百分号在前.
4,表没分析.
15,单独引用复合索引里非第一位置的索引列.
16,字符型字段为数字时在where条件里不添加引号.
17,对索引列进行运算.需要建立函数索引.
18,not in ,not exist.
19,当变量采用的是times变量，而表的字段采用的是date变量时.或相反情况。
20,B-tree索引 is null不会走,is not null会走,位图索引 is null,is not null 都会走
21,联合索引 is not null 只要在建立的索引列（不分先后）都会走, in null时 必须要和建立索引第一列一起使用,当建立索引第一位置条件是is null 时,其他建立索引的列可以是is null（但必须在所有列 都满足is null的时候）,或者=一个值； 当建立索引的第一位置是=一个值时,其他索引列可以是任何情况（包括is null =一个值）,以上两种情况索引都会走。其他情况不会走。

14、如何开启慢日志查询？
MySQL的慢查询日志是MySQL提供的一种日志记录，它用来记录在MySQL中响应时间超过阀值的语句，具体指运行时间超过long_query_time值的SQL，则会被记录到慢查询日志中。long_query_time的默认值为10，意思是运行10S以上的语句。默认情况下，Mysql数据库并不启动慢查询日志，需要我们手动来设置这个参数，当然，如果不是调优需要的话，一般不建议启动该参数，因为开启慢查询日志会或多或少带来一定的性能影响。慢查询日志支持将日志记录写入文件，也支持将日志记录写入数据库表。
开启方法：

mysql>set global slow_query_log=1;

修改my.cnf

slow_query_log =1
slow_query_log_file=/tmp/mysql_slow.log

日志分析工具mysqldumpslow

15、数据库导入导出命令（结构+数据）？
导出数据和表结构：
mysqldump -u用户名 -p 数据库名 > 数据库名.sql
导入数据和结构
mysql -u用户名 -p 数据库名 < 数据库名.sql

16、数据库优化方案？
MySQL的优化主要涉及SQL语句及索引的优化、数据表结构的优化、系统配置的优化和硬件的优化四个方面：
1)、SQL语句及索引的优化
(1). SQL语句的优化
　　SQL语句的优化主要包括三个问题，即如何发现有问题的SQL、如何分析SQL的执行计划以及如何优化SQL，下面将逐一解释。
a. 怎么发现有问题的SQL?（通过MySQL慢查询日志对有效率问题的SQL进行监控）
　　MySQL的慢查询日志是MySQL提供的一种日志记录，它用来记录在MySQL中响应时间超过阀值的语句，具体指运行时间超过long_query_time值的SQL，则会被记录到慢查询日志中。long_query_time的默认值为10，意思是运行10s以上的语句。慢查询日志的相关参数如下所示：
　　通过MySQL的慢查询日志，我们可以查询出执行的次数多占用的时间长的SQL、可以通过pt_query_disgest(一种mysql慢日志分析工具)分析Rows examine(MySQL执行器需要检查的行数)项去找出IO大的SQL以及发现未命中索引的SQL，对于这些SQL，都是我们优化的对象。
b. 通过explain查询和分析SQL的执行计划
　　使用 EXPLAIN 关键字可以知道MySQL是如何处理你的SQL语句的，以便分析查询语句或是表结构的性能瓶颈。通过explain命令可以得到表的读取顺序、数据读取操作的操作类型、哪些索引可以使用、哪些索引被实际使用、表之间的引用以及每张表有多少行被优化器查询等问题。当扩展列extra出现Using filesort和Using temporay，则往往表示SQL需要优化了。
c. SQL语句的优化
优化insert语句：一次插入多值；
应尽量避免在 where 子句中使用!=或<>操作符，否则将引擎放弃使用索引而进行全表扫描；
应尽量避免在 where 子句中对字段进行null值判断，否则将导致引擎放弃使用索引而进行全表扫描；
优化嵌套查询：子查询可以被更有效率的连接(Join)替代；
很多时候用 exists 代替 in 是一个好的选择。
1)、索引优化
　　建议在经常作查询选择的字段、经常作表连接的字段以及经常出现在order by、group by、distinct 后面的字段中建立索引。但必须注意以下几种可能会引起索引失效的情形：
以“%(表示任意0个或多个字符)”开头的LIKE语句，模糊匹配；
OR语句前后没有同时使用索引；
数据类型出现隐式转化（如varchar不加单引号的话可能会自动转换为int型）；
对于多列索引，必须满足最左匹配原则(eg,多列索引col1、col2和col3，则 索引生效的情形包括col1或col1，col2或col1，col2，col3)。
2). 数据库表结构的优化
　　数据库表结构的优化包括选择合适数据类型、表的范式的优化、表的垂直拆分和表的水平拆分等手段。
(1). 选择合适数据类型
使用较小的数据类型解决问题；
使用简单的数据类型(mysql处理int要比varchar容易)；
尽可能的使用not null 定义字段；
尽量避免使用text类型，非用不可时最好考虑分表；
(2). 表的范式的优化
　　一般情况下，表的设计应该遵循三大范式。
(3). 表的垂直拆分
　　把含有多个列的表拆分成多个表，解决表宽度问题，具体包括以下几种拆分手段：
把不常用的字段单独放在同一个表中；
把大字段独立放入一个表中；
把经常使用的字段放在一起；
这样做的好处是非常明显的，具体包括：拆分后业务清晰，拆分规则明确、系统之间整合或扩展容易、数据维护简单。
(4). 表的水平拆分
　　表的水平拆分用于解决数据表中数据过大的问题，水平拆分每一个表的结构都是完全一致的。一般地，将数据平分到N张表中的常用方法包括以下两种：
对ID进行hash运算，如果要拆分成5个表，mod(id,5)取出0~4个值；
针对不同的hashID将数据存入不同的表中；
表的水平拆分会带来一些问题和挑战，包括跨分区表的数据查询、统计及后台报表的操作等问题，但也带来了一些切实的好处：
表分割后可以降低在查询时需要读的数据和索引的页数，同时也降低了索引的层数，提高查询速度；
表中的数据本来就有独立性，例如表中分别记录各个地区的数据或不同时期的数据，特别是有些数据常用，而另外一些数据不常用。
需要把数据存放到多个数据库中，提高系统的总体可用性(分库，鸡蛋不能放在同一个篮子里)。
3). 系统配置的优化
操作系统配置的优化：增加TCP支持的队列数
mysql配置文件优化：Innodb缓存池设置(innodb_buffer_pool_size，推荐总内存的75%)和缓存池的个数（innodb_buffer_pool_instances）
4). 硬件的优化
CPU：核心数多并且主频高的
内存：增大内存
磁盘配置和选择：磁盘性能

17、char和varchar的区别？
char 固定长度（255）
varchar 变长 （理论65535）

18、简述MySQL的执行计划？
Mysql如何执行一条Sql语句,包括Sql查询的顺序、是否使用索引、以及使用的索引信息等内容。
https://juejin.im/post/5a52386d51882573443c852a
explain select * from tb; #查看sql语句执行速度

19、在对name做了唯一索引前提下，简述以下区别：
select * from tb where name = ‘Oldboy-Wupeiqi’ 速度快
select * from tb where name = ‘Oldboy-Wupeiqi’ limit 1
限制显示行数

20、1000w条数据，使用limit offset 分页时，为什么越往后翻越慢？如何解决？
数据量过大，页数越大，查询速度越慢，因为页数越大，数据id就越大，查询时就会从头开始扫描数据。
方案一：
1、记录当期页,数据ID的最大值、最小值，
2、翻页查询时，先根据数据ID筛选数据，再limit查询
select * from (select * from tb where id > 22222222) as B limit 10 offset 0
如果用户自己修改url上的页码，我们可以参考rest-frameword中的分页，对url中的页码进行加密处理
方案二：
可以根据实际业务需求，只展示部分数据（只显示200-300页的数据）

21、什么是索引合并？
索引合并访问方法可以在查询中对一个表使用多个索引,对它们同时扫描，并且合并结果(intersect/union)。 此访问方法合并来自单个表的索引扫描; 它不会将扫描合并到多个表中。

索引的优缺点？
优点：
大大加快数据的检索速度，这也是创建索引的最主要的原因；
加速表和表之间的连接；
在使用分组和排序子句进行数据检索时，同样可以显著减少查询中分组和排序的时间；
通过创建唯一性索引，可以保证数据库表中每一行数据的唯一性；
缺点：
时间方面：创建索引和维护索引要耗费时间，具体地，当对表中的数据进行增加、删除和修改的时候，索引也要动态的维护，这样就降低了数据的维护速度；
空间方面：索引需要占物理空间。

22、什么是覆盖索引？
覆盖索引只是特定于具体select语录而言的联合索引。也就是说一个联合索引对于某个select语句，通过索引可以直接获取查询结果，而不再需要回表查询啦，就称该联合索引覆盖了这条select语句。

23、简述数据库读写分离？
读写分离，利用数据库的主从进行分离：主：用于删除、修改更新；从：查。

24、简述数据库分库分表？（水平、垂直）
https://blog.csdn.net/weixin_38399962/article/details/80108079
分库，当数据库中表太多，将表分到不同的数据库；例如：1w张表
- 分表
　　- 水平分表，将某些列拆分到另外一张表；例如：博客+博客详细
　　- 垂直分表，将历史信息分到另外一张表中；例如：账单
分库分表：
分区表工作：对用户而言，分区表是一个独立的逻辑表，但是底层MySQL将其分成了多个物理子表，这对用户来说是透明的，每一个分区表都会使用一个独立的表文件。创建表时使用partition by子句定义每个分区存放的数据，执行查询时，优化器会根据分区定义过滤那些没有需要的数据的分区，这样只需要查询数据所在分区即可。分区的主要目的是将数据按照一个较粗的粒度分在不同的表中，这样可以将相关的数据存放在一起，而且如果想一次性的删除整个分区的数据也和方便。

适用场景
1、表非常大，无法全部存在内存，或者只在表的最后有热点数据，其他都是历史数据。
2、分区表的数据更易维护，可以对独立的分区进行独立的操作。
3、分区表的数据可以分布在不同的机器上，从而高效适用资源。
4、可以使用分区表来避免某些特殊的瓶颈
5、可以备份和恢复独立的分区
限制
1、一个表最多只能有1024个分区
2、5.1版本中，分区表表达式必须是整数，5.5可以使用列分区
3、分区表字段如果有主键和唯一索引列，那么主键列和唯一索引列都必须包含进来
4、分区表中无法使用外键约束
5、需要对现有表的结构进行修改
6、所有分区都必须使用相同的存储引擎
7、分区函数中可以使用的函数和表达式会有一些限制
8、某些存储引擎不支持分区
9、对于MyISAM的分区表，不能使用load index into cache
10、对于MyISAM表，使用分区表时需要打开更多的文件描述符

分库分表的工作原理
通过一些HASH算法或者工具实现将一张数据表垂直或者水平进行物理切分
适用场景
1、单表记录条数达到百万或千万级别时
2、解决表锁的问题

分表方式
水平分表：表很大，分割后可以降低在查询时需要读的数据和索引的页数，同时也降低了索引的层数，提高查询次数
适用场景
1、表中的数据本身就有独立性，例如表中分表记录各个地区的数据或者不同时期的数据，特别是有些数据常用，有些不常用。
2、需要把数据存放在多个介质上。
水平切分的缺点
1、给应用增加复杂度，通常查询时需要多个表名，查询所有数据都需UNION操作
2、在许多数据库应用中，这种复杂度会超过它带来的优点，查询时会增加读一个索引层的磁盘次数
垂直分表：把主键和一些列放在一个表，然后把主键和另外的列放在另一个表中
适用场景
1、如果一个表中某些列常用，另外一些列不常用
2、可以使数据行变小，一个数据页能存储更多数据，查询时减少I/O次数
缺点
管理冗余列，查询所有数据需要join操作
分表缺点
有些分表的策略基于应用层的逻辑算法，一旦逻辑算法改变，整个分表逻辑都会改变，扩展性较差

MySQL5.7和8.0的差别：
1. 性能：MySQL 8.0 的速度要比 MySQL 5.7 快 2 倍。MySQL 8.0 在以下方面带来了更好的性能：读/写工作负载、IO 密集型工作负载、以及高竞争（"hot spot"热点竞争问题）工作负载
2. NoSQL：Mysql支持NoSQL存储功能，该项功能消除了对独立的 NoSQL 文档数据库的需求，而 MySQL 文档存储也为 schema-less 模式的 JSON 文档提供了多文档事务支持和完整的 ACID 合规性。
3. 窗口函数(Window Functions)：从 MySQL 8.0 开始，新增了一个叫窗口函数的概念，它可以用来实现若干新的查询方式。窗口函数与 SUM()、COUNT() 这种集合函数类似，但它不会将多行查询结果合并为一行，而是将结果放回多行当中。即窗口函数不需要 GROUP BY。
4. 隐藏索引：在 MySQL 8.0 中，索引可以被“隐藏”和“显示”。当对索引进行隐藏时，它不会被查询优化器所使用。我们可以使用这个特性用于性能调试，例如我们先隐藏一个索引，然后观察其对数据库的影响。如果数据库性能有所下降，说明这个索引是有用的，然后将其“恢复显示”即可；如果数据库性能看不出变化，说明这个索引是多余的，可以考虑删掉。
5. 降序索引：MySQL 8.0 为索引提供按降序方式进行排序的支持，在这种索引中的值也会按降序的方式进行排序。
6. 通用表表达式(Common Table Expressions CTE)：在复杂的查询中使用嵌入式表时，使用 CTE 使得查询语句更清晰。
7. UTF-8 编码：从 MySQL 8 开始，使用 utf8mb4 作为 MySQL 的默认字符集。
8. JSON：MySQL 8 大幅改进了对 JSON 的支持，添加了基于路径查询参数从 JSON 字段中抽取数据的 JSON_EXTRACT() 函数，以及用于将数据分别组合到 JSON 数组和对象中的 JSON_ARRAYAGG() 和 JSON_OBJECTAGG() 聚合函数。
9. 可靠性：InnoDB 现在支持表 DDL 的原子性，也就是 InnoDB 表上的 DDL 也可以实现事务完整性，要么失败回滚，要么成功提交，不至于出现 DDL 时部分成功的问题，此外还支持 crash-safe 特性，元数据存储在单个事务数据字典中。
10. 高可用性(High Availability)：InnoDB 集群为您的数据库提供集成的原生 HA 解决方案。
11. 安全性：对 OpenSSL 的改进、新的默认身份验证、SQL 角色、密码强度、授权。

25、redis和memcached比较？
两者都是非关系型内存键值数据库。有以下主要不同：
数据类型
Memcached 仅支持字符串类型，而 Redis 支持五种不同种类的数据类型，使得它可以更灵活地解决问题。
数据持久化
Redis 支持两种持久化策略：RDB 快照和 AOF 日志，而 Memcached 不支持持久化。
分布式
Memcached 不支持分布式，只能通过在客户端使用一致性哈希这样的分布式算法来实现分布式存储，这种方式在存储和查询时都需要先在客户端计算一次数据所在的节点。
Redis Cluster 实现了分布式的支持。
内存管理机制
在 Redis 中，并不是所有数据都一直存储在内存中，可以将一些很久没用的 value 交换到磁盘。而 Memcached 的数据则会一直在内存中。
Memcached 将内存分割成特定长度的块来存储数据，以完全解决内存碎片的问题，但是这种方式会使得内存的利用率不高，例如块的大小为 128 bytes，只存储 100 bytes 的数据，那么剩下的 28 bytes 就浪费掉了。

26、redis中数据库默认是多少个db 及作用？
0-15个库，默认的db0单库
http://blog.kankanan.com/article/52ff7528-redis-7684591a5e93.html

27、python操作redis的模块？
redis提供两个类Redis和StrictRedis用于实现Redis的命令，StrictRedis用于实现大部分官方的命令，并使用官方的语法和命令，Redis是StrictRedis的子类，用于向后兼容旧版本的redis-py。

28、如果redis中的某个列表中的数据量非常大，如果实现循环显示每一个值？
yield 一个生成器

29、redis如何实现主从复制？以及数据同步机制？
目的：是对redis做高可用，为每一个redis实例创建一个备份称为slave，主redis进行写操作，从redis做读操作，并且让主和从之间进行数据同步，
优点：
- 性能提高，从分担读的压力。
- 高可用，一旦主redis挂了，从可以直接代替。
存在问题：当主挂了之后，需要人为手工将从变成主。
数据同步机制：
主从刚刚连接的时候，进行全量同步；全同步结束后，进行增量同步。当然，如果有需要，slave 在任何时候都可以发起全量同步。
redis 策略是，无论如何，首先会尝试进行增量同步，如不成功，要求从机进行全量同步。
https://blog.csdn.net/sk199048/article/details/50725369

30、redis中的sentinel的作用？
Redis-Sentinel是Redis官方推荐的高可用性(HA)解决方案，当用Redis做Master-slave的高可用方案时，假如master宕机了，Redis本身(包括它的很多客户端)都没有实现自动进行主备切换，而Redis-sentinel本身也是一个独立运行的进程，它能监控多个master-slave集群，发现master宕机后能进行自动切换。
https://segmentfault.com/a/1190000002680804

31、如何实现redis集群？
Redis 集群通过分区（partition）来提供一定程度的可用性（availability）： 即使集群中有一部分节点失效或者无法进行通讯， 集群也可以继续处理命令请求。
集群方案：
- redis cluster 官方提供的集群方案。
- codis，豌豆荚技术团队。
- tweproxy，Twiter技术团队。
redis cluster的原理？
- 基于分片来完成。
- redis将所有能放置数据的地方创建了 16384 个哈希槽。
- 如果设置集群的话，就可以为每个实例分配哈希槽：
- 192.168.1.20【0-5000】
- 192.168.1.21【5001-10000】
- 192.168.1.22【10001-16384】
- 以后想要在redis中写值时，
set k1 123
将k1通过crc16的算法，将k1转换成一个数字。然后再将该数字和16384求余，如果得到的余数 3000，那么就将该值写入到 192.168.1.20 实例中。

32、redis中默认有多少个哈希槽？
2的14次方，16384个哈希槽

33、简述redis的有哪几种持久化策略及比较？
RDB持久化
　　-每隔一段时间对redis进行一次持久化（基于时间点快照的方式，复用方式进行数据持久化）
　　-效率较高，数据不完整，安全性不高
AOF持久化
　　-把所有命令保存起来，如果想到重新生成到redis，那么就要把命令重新执行一次。
　　-效率相对较低，安全性较高

34、列举redis支持的过期策略。

• 定时删除
  含义：在设置key的过期时间的同时，为该key创建一个定时器，让定时器在key的过期时间来临时，对key进行删除
  优点：保证内存被尽快释放
  缺点：
  若过期key很多，删除这些key会占用很多的CPU时间，在CPU时间紧张的情况下，CPU不能把所有的时间用来做要紧的事儿，还需要去花时间删除这些key
  定时器的创建耗时，若为每一个设置过期时间的key创建一个定时器（将会有大量的定时器产生），性能影响严重
  没人用
• 惰性删除
  含义：key过期的时候不删除，每次从数据库获取key的时候去检查是否过期，若过期，则删除，返回null。
  优点：删除操作只发生在从数据库取出key的时候发生，而且只删除当前key，所以对CPU时间的占用是比较少的，而且此时的删除是已经到了非做不可的地步（如果此时还不删除的话，我们就会获取到了已经过期的key了）
  缺点：若大量的key在超出超时时间后，很久一段时间内，都没有被获取过，那么可能发生内存泄露（无用的垃圾占用了大量的内存）
• 定期删除
  含义：每隔一段时间执行一次删除过期key操作
  优点：
  通过限制删除操作的时长和频率，来减少删除操作对CPU时间的占用--处理"定时删除"的缺点
  定期删除过期key--处理"惰性删除"的缺点
  缺点
  在内存友好方面，不如"定时删除"
  在CPU时间友好方面，不如"惰性删除"
  难点
  合理设置删除操作的执行时长（每次删除执行多长时间）和执行频率（每隔多长时间做一次删除）（这个要根据服务器运行情况来定了）

35、MySQL 里有 2000w 数据，redis 中只存 20w 的数据，如何保证 redis 中都是热点数据？
redis 内存数据集大小上升到一定大小的时候，就会施行数据淘汰策略。redis 提供 6种数据淘汰策略：
1. volatile-lru：从已设置过期时间的数据集（server.db[i].expires）中挑选最近最少使用的数据淘汰
2. volatile-ttl：从已设置过期时间的数据集（server.db[i].expires）中挑选将要过期的数据淘汰
3. volatile-random：从已设置过期时间的数据集（server.db[i].expires）中任意选择数据淘汰
4. allkeys-lru：从数据集（server.db[i].dict）中挑选最近最少使用的数据淘汰
5. allkeys-random：从数据集（server.db[i].dict）中任意选择数据淘汰
6. no-enviction（驱逐）：禁止驱逐数据

36、写代码，基于redis的列表实现 先进先出、后进先出队列、优先级队列。

37、如何基于redis实现消息队列？

• 首先redis它的设计是用来做缓存的，但是由于它自身的某种特性使得他可以用来做消息队列。它有几个阻塞式的API（brpop、Sub，他们都是阻塞版的）可以使用，正是这些阻塞式的API让他有做消息队列的能力。
• 其次，消息队列的其他特性例如FIFO也很容易实现，只需要一个List对象从头取数据，从尾部塞数据即可实现。

38、如何基于redis实现发布和订阅？以及发布订阅和消息队列的区别？
Redis 通过 PUBLISH 、 SUBSCRIBE 等命令实现了订阅与发布模式， 这个功能提供两种信息机制， 分别是订阅/发布到频道和订阅/发布到模式。
发布订阅：只要发布者发布任务则所有订阅者都会接受到此任务。
消息队列：队列中放一个任务，则只有一个进程取任务

39、什么是codis及作用？
Codis是一个分布式的Redis解决方案，对于上层的应用来说，连接Codis Proxy和连接原生的Redis Server没有明显的区别，上层应用可以像使用单机的Redis一样使用，Codis底层会处理请求的转发，不停机的数据迁移等工作，所有后边的一切事情，对于前面客户端来说是透明的，可以简单的认为后边连接是一个内存无限大的Redis服务。

40、什么是twemproxy及作用？
Twemproxy也叫nutcraker，是twtter开源的一个redis和memcache代理服务器程序。redis作为一个高效的缓存服务器，非常具有应用价值。但在用户数据量增大时，需要运行多个redis实例，此时将迫切需要一种工具统一管理多个redis实例，避免在每个客户端管理所有连接带来的不方便和不易维护，Twemproxy即为此目标而生。

41、写代码实现redis事务操作。

#!/usr/bin/python
#-*- coding: utf-8 -*-
import redis
import sys
if __name__=="__main__":
    try:
        conn=redis.StrictRedis('192.168.80.41')
        pipe=conn.pipeline()
        pipe.sadd('s001','a')
        sys.exit()
        #在事务还没有提交前退出，所以事务不会被执行。
        pipe.sadd('s001','b')
        pipe.execute()
        pass
    except Exception as err:
        print(err)
        pass

42、redis中的watch的命令的作用？
WATCH命令可以监控一个或多个键，一旦其中有一个键被修改（或删除），之后的事务就不会执行。监控一直持续到EXEC命令（事务中的命令是在EXEC之后才执行的，所以在MULTI命令后可以修改WATCH监控的键值）

43、基于redis如何实现商城商品数量计数器？
https://www.cnblogs.com/JockChou/p/4647973.html

44、简述redis分布式锁和redlock的实现机制。
用一个状态值表示锁，对锁的占用和释放通过状态值来标识。

互斥性。在任意时刻，只有一个客户端能持有锁。
不会发生死锁。即使有一个客户端在持有锁的期间崩溃而没有主动解锁，也能保证后续其他客户端能加锁。
具有容错性。只要大部分的Redis节点正常运行，客户端就可以加锁和解锁。
解铃还须系铃人。加锁和解锁必须是同一个客户端，客户端自己不能把别人加的锁给解了。

45、什么是一致性哈希？Python中是否有相应模块？
一致性哈希：是一种分布式算法，将任务均匀的分布到不同的服务器上，常用于负载均衡，当节点数量改变时，能够使失效的缓存数量尽可能少。
hash_ring 将key利用crc32------>数字------>数字和服务器数取余-------->放入服务器对应的数值区间
圆环hash规则

46、如何高效的找到redis中所有以oldboy开头的key？
keys(pattern="*")
根据模型获取redis的name
更多：
# KEYS * 匹配数据库中所有 key 。
# KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。
# KEYS h*llo 匹配 hllo 和 heeeeello 等。
# KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo

第四部分 前端、框架和其他（155题）
1、谈谈你对http协议的认识。

2、谈谈你对websocket协议的认识。
WebSocket的出现，使得浏览器具备了实时双向通信的能力。
支持双向通信，实时性更强。
更好的二进制支持。
较少的控制开销。连接创建后，ws客户端、服务端进行数据交换时，协议控制的数据包头部较小。在不包含头部的情况下，服务端到客户端的包头只有2~10字节（取决于数据包长度），客户端到服务端的的话，需要加上额外的4字节的掩码。而HTTP协议每次通信都需要携带完整的头部。
支持扩展。ws协议定义了扩展，用户可以扩展协议，或者实现自定义的子协议。（比如支持自定义压缩算法等）

3、什么是magic string？
魔法数字，它是一个小型，快速的实用程序，用于操作字符串和生成源图。
很多类型的文件，其起始的几个字节的内容是固定的（或是有意填充，或是本就如此）。根据这几个字节的内容就可以确定文件类型，因此这几个字节的内容被称为魔数 (magic number)。此外在一些程序代码中，程序员常常将在代码中出现但没有解释的数字常量或字符串称为魔数 (magic number)或魔字符串。

4、如何创建响应式布局？
1.实现响应式布局的三个要素：
　　　　viewport视口设置
　　　　@media媒体查询
　　　　不要把尺寸写死：
- 多用百分比宽度来确定布局尺寸
- 多用rem em来确定布局尺寸（在第六部分有更具体的说明）
- 多用vh vw来确定布局尺寸（在第七部分有更具体的说明）
2.视口设置：
视口就是可见的屏幕尺寸
视口不说高度只说宽度，因为高度是根据内容撑开的，宽度才是需要设置的
移动端：视口就是屏幕的大小，因为都是全屏显示的一般
设置方法：设置meta标签就可以
媒体查询：查询我们用什么设备来访问网页
媒体查询查的其实是视口宽度

主要步骤：
1.布局及设置meta标签
2.通过媒体查询来设置样式media query
3.设置多种视图宽度
4.字体设置
5.响应式设计需要注意的问题：
（1）宽度不固定，可以使用百分比
（2）图片处理

5、你曾经使用过哪些前端框架？
Python前端框架：Django、Tornado、Flask、Twisted
Bootstrap框架、jQuery

6、什么是ajax请求？并使用jQuery和XMLHttpRequest对象实现一个ajax请求。
AJAX 是一种在无需重新加载整个网页的情况下，能够更新部分网页的技术。
AJAX = 异步 JavaScript 和 XML。
AJAX 是一种用于创建快速动态网页的技术。
通过在后台与服务器进行少量数据交换，AJAX 可以使网页实现异步更新。这意味着可以在不重新加载整个网页的情况下，对网页的某部分进行更新。
传统的网页（不使用 AJAX）如果需要更新内容，必需重载整个网页面。

AJAX请求和普通HTTP请求区别：

• AJAX通xmlHttpRequest发送请求给服务器，服务器接受请求返数据实现刷新交互
• 普通http请求通httpRequest发送请求给服务器，服务器接受请求返数据需要页面刷新

通过XMLHttpRequest和jQuery实现ajax的几种方式：
https://www.cnblogs.com/good10001/archive/2015/09/07/4788029.html

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、vuex的作用？

• 组件之间的数据通信
• 使用单向数据流的方式进行数据的中心化管理
  https://segmentfault.com/q/1010000011402824/a-1020000011407634

10、vue中的路由的拦截器的作用？
拦截器能帮助我们解决的：

• 添加统一的request的参数
• 处理统一的responseError

11、axios的作用？
axios用于http请求

12、列举vue的常见指令。
1. v-model:将组件与变量进行双向绑定，当组件数据修改时，变量会随之改变。它后面可加修饰符，例如.lazy，只有在标签中的值发生改变时才同步到变量，.trim过滤用户输入中的空格。
2. v-once:不允许修改数据
3. v-if="表达式"，根据表达式的结果来判断，是true则渲染元素，false则将元素注释掉
4. v-show与v-if类似，true就渲染，但是false并不是注释掉，而是通过display:none;来将元素隐藏，如果需要来回切换，使用v-show更好。
5. v-else、v-else-if与v-if连在一起使用构成逻辑判断，不可以单独或者分开使用。
6. v-for用于遍历元素，使用格式为v-for="(值的形参,索引) in 遍历内容"，其遍历的内容可以说数组/对象/字符串。
7. v-text：向标签内注入数据，并且覆盖标签内的其他内容
8. v-html：向标签内覆盖注入HTML内容作为其子元素
9. v-bind：给标签绑定属性、类、样式等，可以缩写为冒号。

13、简述jsonp及实现原理？
ajax请求受同源策略影响，不允许进行跨域请求，而script标签src属性中的链接却可以访问跨域的js脚本，利用这个特性，服务端不再返回JSON格式的数据，而是返回一段调用某个函数的js代码，在src中进行了调用，这样实现了跨域。

14、什么是cors ？
CORS 全称是跨域资源共享（Cross-Origin Resource Sharing），是一种 AJAX 跨域请求资源的方式，支持现代浏览器，IE支持10以上。
CORS与JSONP的使用目的相同，但是比JSONP更强大。JSONP只支持GET请求，CORS支持所有类型的HTTP请求。JSONP的优势在于支持老式浏览器，以及可以向不支持CORS的网站请求数据。
浏览器将CORS请求分成两类：简单请求（simple request）和非简单请求（not-so-simple request）

只要同时满足以下两大条件，就属于简单请求

• 请求方法是以下三种方法之一：

HEAD
GET
POST

• HTTP的头信息不超出以下几种字段：

Accept
Accept-Language
Content-Language
Last-Event-ID
Content-Type：只限于三个值application/x-www-form-urlencoded、multipart/form-data、text/plain

15、列举Http请求中常见的请求方式？
post
get
DELETE、HEAD、OPTIONS、PUT、TRACE

16、列举Http请求中的状态码？
1xx：指示信息--表示请求已接收，继续处理
2xx：成功--表示请求已被成功接收、理解、接受
200：请求被正常处理
204：请求被受理但没有资源可以返回
206：客户端只是请求资源的一部分，服务器只对请求的部分资源执行GET方法，相应报文中通过Content-Range指定范围的资源。
3xx：重定向--要完成请求必须进行更进一步的操作
301：永久性重定向
302：临时重定向
303：与302状态码有相似功能，只是它希望客户端在请求一个URI的时候，能通过GET方法重定向到另一个URI上
304：发送附带条件的请求时，条件不满足时返回，与重定向无关
307：临时重定向，与302类似，只是强制要求使用POST方法
4xx：客户端错误--请求有语法错误或请求无法实现
400：请求报文语法有误，服务器无法识别
401：请求需要认证
403：请求的对应资源禁止被访问
404：服务器无法找到对应资源
5xx：服务器端错误--服务器未能实现合法的请求
500：服务器内部错误
502：错误网关，作为网关或者代理工作的服务器尝试执行请求时，从上游服务器接收到无效的响应。，
503：临时的服务器维护或者过载，服务器当前无法处理请求

17、列举Http请求中常见的请求头？
https://blog.csdn.net/tangxiujiang/article/details/79664710

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 app与web server之间接口格式，实现web app与web server间的解耦。

WSGI:
web服务器网关接口,是一套协议。用于接收用户请求并将请求进行初次封装，然后将请求交给web框架
实现wsgi协议的模块：
1.wsgiref,本质上就是编写一个socket服务端，用于接收用户请求(django)
2.werkzeug,本质上就是编写一个socket服务端，用于接收用户请求(flask)
uwsgi:
与WSGI一样是一种通信协议，它是uWSGI服务器的独占协议,用于定义传输信息的类型
uWSGI:
是一个web服务器,实现了WSGI协议,uWSGI协议,http协议,

26、django请求的生命周期？
Django的请求生命周期是指当用户在浏览器上输入url到用户看到网页的这个时间段内,Django后台所发生的事情.

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

27、列举django的内置组件？
Django的form组件
Django的model form组件
https://blog.csdn.net/xgy123xx/article/details/82722185
https://blog.csdn.net/qq_23934063/article/details/72417915

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

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

应用场景：

由于中间件工作在 视图函数执行前、执行后（像不像所有视图函数的装饰器！）适合所有的请求/部分请求做批量处理
1. 做IP限制
放在中间件类的列表中，阻止某些IP访问了；
2. URL访问过滤
如果用户访问的是login视图（放过）
如果访问其他视图（需要检测是不是有session已经有了放行，没有返回login），这样就省得在多个视图函数上写装饰器了
3. 缓存（还记得CDN吗?）
客户端请求来了，中间件去缓存看看有没有数据，有直接返回给用户，没有再去逻辑层 执行视图函数

https://www.cnblogs.com/huchong/p/7819296.html

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

30、django的request对象是在什么时候创建的？
当URLconf文件匹配到用户输入的路径后，会调用对应的view函数，并将 HttpRequest对象 作为第一个参数传入该函数。
其中 请求报文 由客户端发送，其中包含和许多的信息，而 django 将这些信息封装成了 HttpRequest 对象，该对象由 HttpRequest 类创建。每一个请求都会生成一个 HttpRequest 对象，django会将这个对象自动传递给响应的视图函数，一般视图函数约定俗成地使用 request 参数承接这个对象。

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

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

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

32、列举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():            从返回结果中剔除重复纪录

33、only和defer的区别？
only:从数据库中只取指定字段的内容
defer：指定字段的内容不被检索

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

35、filter和exclude的区别？
取到的值都是QuerySet对象,filter选择满足条件的,exclude:排除满足条件的。

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

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

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

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

39、values和values_list的区别？
values : 取字典的queryset
values_list : 取元组的queryse

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

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

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

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

#1.重写构造函数
def 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对象

43、django的Model中的ForeignKey字段中的on_delete参数有什么作用？
删除关联表中的数据时,当前表与其关联的field的操作
django2.0之后，表与表之间关联的时候,必须要写on_delete参数,否则会报异常.

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

45、django如何实现websocket？
dwebsocket或者Django channels

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

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

#models.py
class Setting(models.Model): 
    ...            
    user = models.CharField(max_length=50, blank=True, help_text=u"添加者")
    ...
#admin.py
@register(Setting)
class SettingAdmin(admin.ModelAdmin):
    list_display = ("pk", "user", "other_field")
    def save_model(self, request, obj, form, change):
        obj.user = request.user
        obj.save()
    readonly_fields = ("user", )

48、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 %}

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

1. 服务器端安装redis
2. Redis访问控制
3. 安装django-redis和settings配置
4. 测试缓存是否成功

https://blog.csdn.net/sinat_29699167/article/details/79699200

50、django路由系统中name的作用？
用于反向解析路由,相当于给url取个别名，只要这个名字不变,即使对应的url改变;
通过该名字也能找到该条url.

51、django的模板中filter和simple_tag的区别？
1.simple_tag的代码方式与filter一样，不同的是在装饰器部分需要调用simple_tag方法
2.传递参数
- filter 最多支持两个参数传递
- simple 支持多个参数传递

52、django-debug-toolbar的作用？
django_debug_toolbar 是django的第三方工具包，给django扩展了调试功能。
包括查看执行的sql语句，db查询次数，request，headers，调试概览等。

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

54、解释orm中 db first 和 code first的含义？
1. db first 是现有数据库，再写代码。根据数据库的表生成类。
django里面：python manage.py inspectdb
2. code first 是先写代码，后创建数据库。根据类创建数据库表。
djiango里面：python manage.py makemigrations python manage.py migrate

55、django中如何根据数据库表生成model中的类？
根据model生成数据库表：
python manage.py syncdb
根据数据库表生成model：
python manage.py inspectdb>models.py

56、使用orm和原生sql的优缺点？
优点:
方便的使用面向对象，语句清晰
防注入『这个其实不算ORM的核心，因为比如Phalcon的SQL形式写法也可以防注入』
方便动态构造语句，对于不同的表的相同操作采用多态实现更优雅
一定程度方便重构数据层『比如改表名，字段名等』
设置钩子函数
缺点:不太容易处理复杂查询语句性能较直接用SQL差
https://blog.csdn.net/qq_35443962/article/details/80361987

57、简述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

负责业务的逻辑其实是放在Model模块中的,View虽然是控制器,但是它只是负责的流程控制,而业务处理的逻辑,controler是不管的.

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

59、谈谈你对restfull规范的认识？
RESTful是目前最流行的一种互联网软件架构。它结构清晰、符合标准、易于理解、扩展方便，所以正得到越来越多网站的采用。
REST是Representational State Transfer的缩写，是Roy Thomas Fielding在他2000年的博士论文中提出的。其提出的设计概念和准则为：
1. 网络上的所有事物都可以抽象为资源
2. 每个资源都应该有唯一的标识（identifier），对资源的操作不会改变标识
3. 所有的操作都是无状态的
4. 使用标准方法（GET、POST、PUT、PATCH、DELETE）操作资源
https://www.cnblogs.com/Erik_Xu/p/9011013.html

60、接口的幂等性是什么意思？
接口可重复调用，在调用方多次调用的情况下，接口最终得到的结果是一致的。

61、什么是RPC？
RPC（Remote Procedure Call Protocol）——远程过程调用协议，它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。RPC协议假定某些传输协议的存在，如TCP或UDP，为通信程序之间携带信息数据。在OSI网络通信模型中，RPC跨越了传输层和应用层。RPC使得开发包括网络分布式多程序在内的应用程序更加容易。

62、Http和Https的区别？
HTTPS就是HTTP加上加密处理（一般是SSL安全通信线路）+认证+完整性保护
1、https协议需要到ca申请证书，一般免费证书较少，因而需要一定费用。
2、http是超文本传输协议，信息是明文传输，https则是具有安全性的ssl加密传输协议。
3、http和https使用的是完全不同的连接方式，用的端口也不一样，前者是80，后者是443。
4、http的连接很简单，是无状态的；HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议，比http协议安全

63、为什么要使用django rest framework框架？
1.客户端-服务端分离
优点：提高用户界面的便携性，通过简化服务器提高可伸缩性
2.无状态（Stateless）：从客户端的每个请求要包含服务器所需要的所有信息
优点：提高可见性（可以单独考虑每个请求），提高了可靠性（更容易从局部故障中修复），提高可扩展性（降低了服务器资源使用）
有状态与无状态区别：
如查询员工工资，如果查询工资是需要登陆系统，进入查询工资的页面，执行相关操作，获取工资的多少，则这种情况下是有状态的，因为查询工资的每一步操作都依赖于前一步操作，只需要前面操作不成功，后序操作就无法执行；如果输入一个url即可得到指定员工的工资，则这种情况下是无状态的，因为获取员工工资不依赖于其他资源或者状态，且这种情况下，员工工资是一个资源，由一个url与其对应，可以通过HTTP的GET方法得到资源。
3.缓存（Cachable）：服务器返回信息必须被标记是否可以缓存，如果缓存，客户端可能会重用之前的信息发送请求
优点：减少交互次数，减少交互的平均延迟
4.统一接口
优点：提高交互的可见性，鼓励单独改善组件
5.支持按需代码（Code-On-Demand 可选）
优点：提高可扩展性
https://www.cnblogs.com/vipchenwei/p/7867028.html

64、django rest framework框架中都有那些组件？
序列化
视图
认证与权限组件
解析器
分页

65、django rest framework框架中的视图都可以继承哪些类？
除了提供Mixin类之外，还提供了GenericAPIView和Mixins的组合View类，这些类称为具体通用视图。

66、简述 django rest framework框架的认证流程。
https://blog.csdn.net/qq_33733970/article/details/79422829

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

from rest_framework.views import APIView
from rest_framework import exceptions
from rest_framework.response import Response
from rest_framework.throttling import SimpleRateThrottle
class MySimpleRateThrottle(SimpleRateThrottle):
    scope = "limit"
    def get_cache_key(self, request, view):
        return self.get_ident(request)
class LimitView(APIView):
    authentication_classes = []
    permission_classes = []
    throttle_classes = [MySimpleRateThrottle, ]    # 自定义分流类
    def get(self, request, *args, **kwargs):
        self.dispatch
        return Response('控制访问频率示例')
    def throttled(self, request, wait):
        class MyThrottled(exceptions.Throttled):
            default_detail = '请求被限制.'
            extra_detail_singular = 'Expected available in {wait} second.'
            extra_detail_plural = '还需要再等待{wait}'
        raise MyThrottled(wait)

68、Flask框架的优势？
Flask
- Flask确实很“轻”，不愧是Micro Framework，从Django转向Flask的开发者一定会如此感慨，除非二者均为深入使用过
- Flask自由、灵活，可扩展性强，第三方库的选择面广，开发时可以结合自己最喜欢用的轮子，也能结合最流行最强大的Python库
- 入门简单，即便没有多少web开发经验，也能很快做出网站
- 非常适用于小型网站
- 非常适用于开发web服务的API
- 开发大型网站无压力，但代码架构需要自己设计，开发成本取决于开发者的能力和经验
- 各方面性能均等于或优于Django
- Django自带的或第三方的好评如潮的功能，Flask上总会找到与之类似第三方库
- Flask灵活开发，Python高手基本都会喜欢Flask，但对Django却可能褒贬不一
- Flask与关系型数据库的配合使用不弱于Django，而其与NoSQL数据库的配合远远优于Django
- Flask比Django更加Pythonic，与Python的philosophy更加吻合

Django
- Django太重了，除了web框架，自带ORM和模板引擎，灵活和自由度不够高
- Django能开发小应用，但总会有“杀鸡焉用牛刀”的感觉
- Django的自带ORM非常优秀，综合评价略高于SQLAlchemy
- Django自带的模板引擎简单好用，但其强大程度和综合评价略低于Jinja
- Django自带ORM也使Django与关系型数据库耦合度过高，如果想使用MongoDB等NoSQL数据，需要选取合适的第三方库，且总感觉Django+SQL才是天生一对的搭配，Django+NoSQL砍掉了Django的半壁江山
- Django目前支持Jinja等非官方模板引擎Django自带的数据库管理app好评如潮
- Django非常适合企业级网站的开发：快速、靠谱、稳定
- Django成熟、稳定、完善，但相比于Flask，Django的整体生态相对封闭
- Django是Python web框架的先驱，用户多，第三方库最丰富，最好的Python库，如果不能直接用到Django中，也一定能找到与之对应的移植
- Django上手也比较容易，开发文档详细、完善，相关资料丰富

一、整体设计方面

首先，两者都是非常优秀的框架。整体来讲，两者设计的哲学是区别最大的地方。Django提供一站式的解决方案，从模板、ORM、Session、Authentication等等都分配好了，连app划分都做好了，总之，为你做尽量多的事情，而且还有一个killer级的特性，就是它的admin，配合django-suit，后台就出来了，其实最初Django就是由在新闻发布公司工作的人设计的。Flask只提供了一些核心功能，非常简洁优雅。它是一个微框架，其他的由扩展提供，但它的blueprint使它也能够很方便的进行水平扩展。

二、路由设计

Django的路由设计是采用集中处理的方法，利用正则匹配。Flask也能这么做，但更多的是使用装饰器的形式，这个有优点也有缺点，优点是读源码时看到函数就知道怎么用的，缺点是一旦源码比较长，你要查路由就不太方便了，但这也促使你去思考如何更合理的安排代码。

三、应用模块化设计

Django的模块化是集成在命令里的，也就是说一开始Django的目标就是为以后玩大了做准备的。每个都是一个独立的模块，为以后的复用提供了便利。Flask通过Blueprint来提供模块化，自己对项目结构划分成不同的模块进行组织。

69、Flask框架依赖组件？
Route(路由)
templates(模板)
Models(orm模型)
blueprint(蓝图)
Jinja2模板引擎

70、Flask蓝图的作用？
将不同的功能模块化
构建大型应用
优化项目结构
增强可读性,易于维护（跟Django的view功能相似）

71、列举使用过的Flask第三方组件？
内置:
- 配置
- 路由
- 视图
- 模板
- session
- 闪现
- 蓝图
- 中间件
- 特殊装饰器
第三方:
- Flask组件：
- flask-session
- flask-SQLAlchemy
- flask-migrate
- flask-script
- blinker
- 公共组件：
- wtforms
- dbutile
- sqlalchemy
- 自定义Flask组件
- auth ，参考flask-login组件

72、简述Flask上下文管理流程?
每次有请求过来的时候，flask 会先创建当前线程或者进程需要处理的两个重要上下文对象，把它们保存到隔离的栈里面，这样视图函数进行处理的时候就能直接从栈上获取这些信息。

73、Flask中的g的作用？
g 相当于一次请求的全局变量，当请求进来时将g和current_app封装为一个APPContext类，在通过LocalStack将Appcontext放入Local中，取值时通过偏函数，LocalStack、local中取值，响应时将local中的g数据删除

74、Flask中上下文管理主要涉及到了那些相关的类？并描述类主要作用？
flask
requestcontext
request
securecookiesessioninterface
securecookiesession

75、为什么要Flask把Local对象中的的值stack 维护成一个列表？
当是web应用时：不管是单线程还是多线程，栈中只有一个数据
- 服务端单线程：
　　　　{
　　　　111:{stack: [ctx, ]}
　　　　}
- 服务端多线程：
　　　　{
　　　　111:{stack: [ctx, ]}
　　　　112:{stack: [ctx, ]}
　　　　}

76、Flask中多app应用是怎么完成？
请求进来时，可以根据URL的不同，交给不同的APP处理。

77、在Flask中实现WebSocket需要什么组件？
Flask-SocketIO
Flask-Sockets是Flask框架的一个扩展，通过它，Flask应用程序可以使用WebSocket。

78、wtforms组件的作用？
WTForms是一个支持多个web框架的form组件，主要用于对用户请求数据进行验证。
https://www.cnblogs.com/big-handsome-guy/p/8552079.html

79、Flask框架默认session处理机制？
Flask的默认session利用了Werkzeug的SecureCookie，把信息做序列化(pickle)后编码(base64)，放到cookie里了。
过期时间是通过cookie的过期时间实现的。
为了防止cookie内容被篡改，session会自动打上一个叫session的hash串，这个串是经过session内容、SECRET_KEY计算出来的，看得出，这种设计虽然不能保证session里的内容不泄露，但至少防止了不被篡改。

80、解释Flask框架中的Local对象和threading.local对象的区别？
a. threading.local
作用：为每个线程开辟一块空间进行数据存储。
b. 自定义Local对象
作用：为每个线程(协程)开辟一块空间进行数据存储。
https://www.jianshu.com/p/3f38b777a621

81、Flask中 blinker 是什么？
Flask框架中的信号基于blinker，可以让开发者在flask请求过程中定制一些用户行为执行。
在请求前后，模板渲染前后，上下文前后，异常 的时候

82、SQLAlchemy中的 session和scoped_session 的区别？
使用scoped_session的目的主要是为了线程安全。
scoped_session类似单例模式，当我们调用使用的时候，会先在Registry里找找之前是否已经创建session了。
要是有，就把这个session返回。
要是没有，就创建新的session，注册到Registry中以便下次返回给调用者。
这样就实现了这样一个目的：在同一个线程中，call scoped_session 的时候，返回的是同一个对象

83、SQLAlchemy如何执行原生SQL？

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
engine = create_engine('mysql://root:*****@127.0.0.1/database?charset=utf8')
DB_Session = sessionmaker(bind=engine)
session = DB_Session()
session.execute('alter table mytablename drop column mycolumn ;')

84、ORM的实现原理？
概念： 对象关系映射（Object Relational Mapping，简称ORM，或O/RM，或O/R mapping），是一种程序技术，用于实现面向对象编程语言里不同类型系统的数据之间的转换。

详细介绍： 让我们从O/R开始。字母O起源于”对象”(Object),而R则来自于”关系”(Relational)。几乎所有的程序里面，都存在对象和关系数据库。在业务逻辑层和用户界面层中，我们是面向对象的。当对象信息发生变化的时候，我们需要把对象的信息保存在关系数据库中。

当你开发一个应用程序的时候(不使用O/R Mapping),你可能会写不少数据访问层的代码，用来从数据库保存，删除，读取对象信息，等等。你在DAL中写了很多的方法来读取对象数据，改变状态对象等等任务。而这些代码写起来总是重复的。
ORM解决的主要问题是对象关系的映射。域模型和关系模型分别是建立在概念模型的基础上的。域模型是面向对象的，而关系模型是面向关系的。一般情况下，一个持久化类和一个表对应，类的每个实例对应表中的一条记录，类的每个属性对应表的每个字段。

ORM技术特点：
* 提高了开发效率。由于ORM可以自动对Entity对象与数据库中的Table进行字段与属性的映射，所以我们实际可能已经不需要一个专用的、庞大的数据访问层。
* ORM提供了对数据库的映射，不用sql直接编码，能够像操作对象一样从数据库获取数据。

85、DBUtils模块的作用？
使用DBUtils模块
两种使用模式：
1. 为每个线程创建一个连接，连接不可控，需要控制线程数
1. 创建指定数量的连接在连接池，当线程访问的时候去取，如果不够了线程排队，直到有人释放。平时建议使用这种！

86、以下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())

ctime字段中的参数应该为default=datetime.now, now后面不应该加括号.如果加了,字段不会随时更新

87、SQLAchemy中如何为表设置引擎和字符编码？
sqlalchemy设置编码字符集一定要在数据库访问的URL上增加charset=utf8，否则数据库的连接就不是utf8的编码格式

eng = create_engine(‘mysql://root:root@localhost:3306/test2?charset=utf8’,echo=True)

88、SQLAchemy中如何设置联合唯一索引？
UniqueConstraint 设置联合唯一索引

89、简述Tornado框架的特点。
Tornado的独特之处在于其所有开发工具能够使用在应用开发的任意阶段以及任何档次的硬件资源上。而且，完整集的Tornado工具可以使开发人员完全不用考虑与目标连接的策略或目标存储区大小。

Tornado 结构的专门设计为开发人员和第三方工具厂商提供了一个开放环境。已有部分应用程序接口可以利用并附带参考书目，内容从开发环境接口到连接实现。Tornado包括强大的开发和调试工具，尤其适用于面对大量问题的嵌入式开发人员。这些工具包括C和C++源码级别的调试器，目标和工具管理，系统目标跟踪，内存使用分析和自动配置. 另外，所有工具能很方便地同时运行，很容易增加和交互式开发。

90、简述Tornado框架中Future对象的作用？
http://python.jobbole.com/87310/

91、Tornado框架中如何编写WebSocket程序？
https://www.cnblogs.com/aguncn/p/5665916.html

92、Tornado中静态文件是如何处理的？如：

static_path = os.path.join(os.paht.dirname(file), “static”) 
#这里增加设置了静态路径 

另外一个修改就是在实例化 tornado.web.Application() 的时候，在参数中，出了有静态路径参数 static_path ，还有一个参数设置 debug=True

93、Tornado操作MySQL使用的模块？
torndb是一个轻量级的基于MySQLdb封装的一个模块，从tornado3.0版本以后，其已经作为一个独立模块发行了。torndb依赖于MySQLdb模块，因此，在使用torndb模块时，要保证系统中已经有MySQLdb模块。

94、Tornado操作redis使用的模块？
tornado-redis

95、简述Tornado框架的适用场景？
Tornado是使用Python编写的一个强大的、可扩展的Web服务器。它在处理严峻的网络流量时表现得足够强健，但却在创建和编写时有着足够的轻量级，并能够被用在大量的应用和工具中。

我们现在所知道的Tornado是基于Bret Taylor和其他人员为FriendFeed所开发的网络服务框架，当FriendFeed被Facebook收购后得以开源。不同于那些最多只能达到10,000个并发连接的传统网络服务器，Tornado在设计之初就考虑到了性能因素，旨在解决C10K问题，这样的设计使得其成为一个拥有非常高性能的框架。此外，它还拥有处理安全性、用户验证、社交网络以及与外部服务（如数据库和网站API）进行异步交互的工具。

96、git常见命令作用：

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

https://willireamangel.github.io/2018/05/29/Git%E5%9F%BA%E7%A1%80/

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

stash用于将工作区发生变化的所有文件获取临时存储在“某个地方”，将工作区还原当前版本未操作前的状态；stash还可以将临时存储在“某个地方”的文件再次拿回到工作区。
git stash 将当前工作区所有修改过的内容存储到“某个地方”，将工作区还原到当前版本未修改过的状态
git stash list 查看“某个地方”存储的所有记录
git stash clear 清空“某个地方”
git stash pop 将第一个记录从“某个地方”重新拿到工作区（可能有冲突）
git stash apply 编号, 将指定编号记录从“某个地方”重新拿到工作区（可能有冲突）
git stash drop 编号，删除指定编号的记录

98、git 中 merge 和 rebase命令 的区别。
git rebase 和 git merge 一样都是用于从一个分支获取并且合并到当前分支，但是他们采取不同的工作方式，以下面的一个工作场景说明其区别(你在一个feature分支进行新特性的开发，与此同时，master 分支的也有新的提交):
merge 特点：自动创建一个新的commit
如果合并的时候遇到冲突，仅需要修改后重新commit
优点：记录了真实的commit情况，包括每个分支的详情
缺点：因为每次merge会自动产生一个merge commit，所以在使用一些git 的GUI tools，特别是commit比较频繁时，看到分支很杂乱。
rebase 特点：会合并之前的commit历史
优点：得到更简洁的项目历史，去掉了merge commit
缺点：如果合并出现代码问题不容易定位，因为re-write了history

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

99、公司如何基于git做的协同开发？
https://www.cnblogs.com/abelsu/p/5138136.html

100、如何基于git实现代码review？
利用github/gitlab自带的在线Diff展示功能做。
https://blog.csdn.net/maray/article/details/50206927

第一步，建分支，删本地

 git checkout -b myfeature;
 git push origin myfeature;
 git checkout master;
 git branch -d myfeature;1234

第二步，拉分支，做开发

 git checkout -b dperf origin/dperf;
 git add xxx; git commit -m 'dev xxx';
 git push origin dperf;123

代码push到origin服务器后，可以去网页上发起Merge Request
第三步, 合并分支

 git checkout master;
 git pull;
 git checkout dperf;
 git fetch origin master;
 git rebase master;

101、git如何实现v1.0 、v2.0 等版本的管理？
git tag
https://blog.csdn.net/zhazhaji/article/details/75258426

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

104、如何为github上牛逼的开源项目贡献代码？
对一个开源项目有足够了解的情况下，如果你发现问题或者更好的解决方案的话，可以开个issue先。
一般情况下维护这个项目的人或者其他使用这个项目的人会参与讨论的，然后基于这些讨论你可以发一些pull requests。
如果你的方案得到很多人赞同的话，项目维护人员会把他们merge，你也就成了这个项目的contributor了。
当然很多情况下，你开的这个issue已经有人提过了，或者说是你自己误解了，但是相信在和其他开发人员交流的过程中，你也能学到许多。

克隆项目-->fork项目-->本地新建分支并修改提交-->在github上pull request-->等待目标库维护者合入代码
https://blog.csdn.net/DucklikeJAVA/article/details/78744838

105、git中 .gitignore文件的作用?

一般来说每个Git项目中都需要一个“.gitignore”文件，这个文件的作用就是告诉Git哪些文件不需要添加到版本管理中。
实际项目中，很多文件都是不需要版本管理的，比如Python的.pyc文件和一些包含密码的配置文件等等。

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

107、简述 jenkins 工具的作用?
1.Jenkins概念：
Jenkins是一个功能强大的应用程序，允许持续集成和持续交付项目，无论用的是什么平台。这是一个免费的源代码，可以处理任何类型的构建或持续集成。集成Jenkins可以用于一些测试和部署技术。Jenkins是一种软件允许持续集成。
2.Jenkins目的：
持续、自动地构建/测试软件项目。
监控软件开放流程，快速问题定位及处理，提示开放效率。
3.特性：
开源的java语言开发持续集成工具，支持CI，CD。
易于安装部署配置：可通过yum安装,或下载war包以及通过docker容器等快速实现安装部署，可方便web界面配置管理。
消息通知及测试报告：集成RSS/E-mail通过RSS发布构建结果或当构建完成时通过e-mail通知，生成JUnit/TestNG测试报告。
分布式构建：支持Jenkins能够让多台计算机一起构建/测试。
文件识别:Jenkins能够跟踪哪次构建生成哪些jar，哪次构建使用哪个版本的jar等。
丰富的插件支持:支持扩展插件，你可以开发适合自己团队使用的工具，如git，svn，maven，docker等。
4.产品发布流程：
产品设计成型 -> 开发人员开发代码 -> 测试人员测试功能 -> 运维人员发布上线
持续集成 （Continuous integration，简称CI）
持续交付（Continuous delivery）
持续部署（continuous deployment）
5.使用：
使用requests可以模拟浏览器发送的请求
发送get请求：requests.get()
发送post请求:requests.post()
读取请求返回内容:requests.text()
保存cookie:requests.cookie()

108、公司如何实现代码发布？

109、简述 RabbitMQ、Kafka、ZeroMQ的区别？
https://blog.csdn.net/qq_26182553/article/details/77011242

110、RabbitMQ如何在消费者获取任务后未处理完前就挂掉时，保证数据不丢失？

111、RabbitMQ如何对消息做持久化？

112、RabbitMQ如何控制消息被消费的顺序？

113、以下RabbitMQ的exchange type分别代表什么意思？如：fanout、direct、topic。

114、简述 celery 是什么以及应用场景？

115、简述celery运行机制。

116、celery如何实现定时任务？

117、简述 celery多任务结构目录？

118、celery中装饰器 @app.task 和 @shared_task的区别？

119、简述 requests模块的作用及基本使用？
使用requests可以模拟浏览器发送的请求
发送get请求：requests.get()
发送post请求:requests.post()
读取请求返回内容:requests.text()
保存cookie:requests.cookie()

120、简述 beautifulsoup模块的作用及基本使用？
查找xml/html文本中查找指定信息的三方库
* 获取title信息 soup.title
* 获取title的属性 soup.title.attrs
https://blog.csdn.net/qq_37275405/article/details/80953517

121、简述 seleninu模块的作用及基本使用?
selenium最初是一个自动化测试工具,而爬虫中使用它主要是为了解决requests无法直接执行JavaScript代码的问题
selenium本质是通过驱动浏览器，完全模拟浏览器的操作，比如跳转、输入、点击、下拉等，来拿到网页渲染之后的结果，可支持多种浏览器

122、scrapy框架中各组件的工作流程？
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工作流程：
当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、在scrapy框架中如何设置代理（两种方法）？
使用中间件DownloaderMiddleware进行配置
直接在爬虫程序中设置proxy字段

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

124、scrapy框架中如何实现大文件的下载？
* FilesPipeline
* ImagesPipeline
http://www.itdaan.com/blog/2018/06/05/369ffa706185a1aab4e9913d432b027d.html

125、scrapy中如何实现限速？
修改setting文件的AUTOTHROTTLE_START_DELAY 打开后默认限速为5秒

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

127、scrapy中如何进行自定制命令？
在spiders同级创建任意目录，如：commands
在其中创建 crawlall.py 文件 （此处文件名就是自定义的命令）

      from scrapy.commands import ScrapyCommand
      from scrapy.utils.project import get_project_settings
      class Command(ScrapyCommand):
          requires_project = True
          def syntax(self):
              return '[options]'
          def short_desc(self):
              return 'Runs all of the spiders'
          def run(self, args, opts):
              spider_list = self.crawler_process.spiders.list()
              for name in spider_list:
                  self.crawler_process.crawl(name, **opts.__dict__)
              self.crawler_process.start()

在settings.py 中添加配置 COMMANDS_MODULE = ‘项目名称.目录名称’
在项目目录执行命令：scrapy crawlall

128、scrapy中如何实现的记录爬虫的深度？
class scrapy.contrib.spidermiddleware.depth.DepthMiddleware
DepthMiddleware是一个用于追踪每个Request在被爬取的网站的深度的中间件。 其可以用来限制爬取深度的最大深度或类似的事情。
DepthMiddleware 可以通过下列设置进行配置(更多内容请参考设置文档):
DEPTH_LIMIT - 爬取所允许的最大深度，如果为0，则没有限制。
DEPTH_STATS - 是否收集爬取状态。
DEPTH_PRIORITY - 是否根据其深度对requet安排优先级

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

130、scrapy的pipelines如何丢弃一个item对象？
到pipelines的时候不执行持久化保存就会什么也不执行也就是丢弃

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

132、scrapy-redis组件的作用？
scheduler - 调度器
dupefilter - URL去重规则（被调度器使用）
pipeline - 数据持久化

133、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)

134、scrapy-redis的调度器如何实现任务的深度优先和广度优先？
http://www.cnblogs.com/wupeiqi/articles/6912807.html

135、简述 vitualenv 及应用场景?
virtualenv为应用提供了隔离的Python运行环境，解决了不同应用间多版本的冲突问题。

136、简述 pipreqs 及应用场景？
一起开发项目的时候总是要搭建环境和部署环境的，这个时候必须得有个python第三方包的list，一般都叫做requirements.txt。 如果一个项目使用时virtualenv环境，还好办 pip freeze 就可以解决，但是如果一个项目的依赖list没有维护，而且又是环境混用，那就不好整理的呀，不过，这里安利一个工具pipreqs，可以自动根据源码生成requirements.txt .
pip freeze命令

$ pip freeze > requirements.txt

　　这种方式配合virtualenv 才好使，否则把整个环境中的包都列出来了。

137、在Python中使用过什么代码检查工具？
Flake8、Pylint

138、简述 saltstack、ansible、fabric、puppet工具的作用？
https://blog.csdn.net/zzq900503/article/details/80143740

• Ansible(基于SSH)是用于在可重复的方式将应用程序部署到远程节点和配置服务器的开源工具。 它为您提供了使用推送模型设置推送多层应用程序和应用程序工件的通用框架，但如果愿意，您可以将其设置为主客户端。 Ansible是建立在playbooks，你可以应用于各种各样的系统部署你的应用程序。
• Chef是配置管理的开源工具，专注于开发方为它的用户群。 厨师作为主客户端模型运行，具有控制主人所需的单独的工作站。 它基于Ruby，用纯Ruby编写的大多数元素。 厨师的设计是透明的，并根据它给出的说明，这意味着你必须确保你的说明是清楚的。
• Fabric是在应用程序部署精简SSH一个基于Python的工具。 它主要用于跨多个远程系统运行任务，但也可以使用插件扩展以提供更高级的功能。 Fabric将配置您的系统，执行系统/服务器管理，并自动部署您的应用程序。
• Puppet是在全面配置管理空间长期工具之一。 它是一个开源工具，但考虑到它已经存在多久，它已经被良好的审查和部署在一些最大和最苛刻的环境中。 Puppet基于Ruby，但是使用更接近JSON的定制的域脚本语言（DSL）来在其中工作。 它作为主客户端设置运行，并使用模型驱动方法。 Puppet代码设计作为依赖关系列表，这可以使事情更容易或更混乱，这取决于您的设置。
• SaltStack（或Salt）是一个基于命令行的工具，可以设置一个主客户端模式还是非集中模式。 Salt基于Python，提供了一种推送方法和一种与客户端通信的SSH方法。 Salt允许对客户端和配置模板进行分组，以简化对环境的控制。

139、B Tree和B+ Tree的区别？

140、请列举常见排序并通过代码实现任意三种。

141、请列举常见查找并通过代码实现任意三种。

142、请列举你熟悉的设计模式？

143、有没有刷过leetcode？

144、列举熟悉的的Linux命令。

145、公司线上服务器是什么系统？

146、解释 PV、UV 的含义？
- PV（Page View）访问量, 即页面浏览量或点击量，衡量网站用户访问的网页数量；在一定统计周期内用户每打开或刷新一个页面就记录1次，多次打开或刷新同一页面则浏览量累计。
- UV（Unique Visitor）独立访客，统计1天内访问某站点的用户数(以cookie为依据);访问网站的一台电脑客户端为一个访客。可以理解成访问某网站的电脑的数量。网站判断来访电脑的身份是通过来访电脑的cookies实现的。如果更换了IP后但不清除cookies，再访问相同网站，该网站的统计中UV数是不变的。如果用户不保存cookies访问、清除了cookies或者更换设备访问，计数会加1。00:00-24:00内相同的客户端多次访问只计为1个访客。

147、解释 QPS的含义？
QPS：Queries Per Second意思是“每秒查询率”，是一台服务器每秒能够相应的查询次数，是对一个特定的查询服务器在规定时间内所处理流量多少的衡量标准。

148、uwsgi和wsgi的区别？
https://www.rapospectre.com/blog/31

149、supervisor的作用？
Supervisor是一个进程管理工具。
用途就是有一个进程需要每时每刻不断的跑，但是这个进程又有可能由于各种原因有可能中断。当进程中断的时候我希望能自动重新启动它，此时，我就需要使用到了Supervisor
这个工具主要就两个命令：
supervisord : supervisor的服务器端部分，启动supervisor就是运行这个命令
supervisorctl：启动supervisor的命令行窗口

150、什么是反向代理？
1. 反向代理
真实的服务器不能直接被外部网络访问，所以需要一台代理服务器，而代理服务器能被外部网络访问的同时又跟真实服务器在同一个网络环境，当然也可能是同一台服务器。
2. 正向代理
正向代理是一个位于客户端和目标服务器之间的代理服务器(中间服务器)。为了从原始服务器取得内容，客户端向代理服务器发送一个请求，并且指定目标服务器，之后代理向目标服务器转交并且将获得的内容返回给客户端.

151、简述SSH的整个过程。
SSH协议版本协商阶段。SSH目前包括SSH1和SSH2两个大版本。
密钥和算法协商阶段，SSH支持多种加密算法，双方根据自己和对端支持的算法进行协商，最终决定要使用的算法。
认证阶段，服务器对客户端进行身份验证。
会话请求阶段，完成认证后，客户端会向服务器端发送会话请求。
交互会话阶段，会话请求通过后，服务器端和客户端进行信息的交互。

152、有问题都去那些找解决方案？

153、是否有关注什么技术类的公众号？

154、最近在研究什么新技术？

155、是否了解过领域驱动模型？
以一种领域专家、设计人员、开发人员都能理解的通用语言作为相互交流的工具，在交流的过程中发现领域概念，然后将这些概念设计成一个领域模型；由领域模型驱动软件设计，用代码来实现该领域模型；由此可见，领域驱动设计的核心是建立正确的领域模型。