1.谈谈你对csrf的理解和django中CSRF防护机制。

什么是 CSRF 
CSRF, Cross Site Request Forgery, 跨站点伪造请求。举例来讲，某个恶意的网站上有一个指向你的网站的链接，如果

某个用户已经登录到你的网站上了，那么当这个用户点击这个恶意网站上的那个链接时，就会向你的网站发来一个请求，

你的网站会以为这个请求是用户自己发来的，其实呢，这个请求是那个恶意网站伪造的。

具体的细节及其危害见 wikipedia

Django 提供的 CSRF 防护机制
django 第一次响应来自某个客户端的请求时，会在服务器端随机生成一个 token，把这个 token 放在 cookie 里。然后每次 POST 请求都会带上这个 token，

这样就能避免被 CSRF 攻击。

在返回的 HTTP 响应的 cookie 里，django 会为你添加一个 csrftoken 字段，其值为一个自动生成的 token
在所有的 POST 表单时，必须包含一个 csrfmiddlewaretoken 字段 （只需要在模板里加一个 tag， django 就会自动帮你生成，见下面）
在处理 POST 请求之前，django 会验证这个请求的 cookie 里的 csrftoken 字段的值和提交的表单里的 csrfmiddlewaretoken 字段的值是否一样。如果一样，则表明这是一个合法的请求，否则，这个请求可能是来自于别人的 csrf 攻击，返回 403 Forbidden.
在所有 ajax POST 请求里，添加一个 X-CSRFTOKEN header，其值为 cookie 里的 csrftoken 的值
Django 里如何使用 CSRF 防护
首先，最基本的原则是：GET 请求不要用有副作用。也就是说任何处理 GET 请求的代码对资源的访问都一定要是“只读“的。
要启用 django.middleware.csrf.CsrfViewMiddleware 这个中间件
再次，在所有的 POST 表单元素时，需要加上一个 {% csrf_token %} tag
在渲染模块时，使用 RequestContext。RequestContext 会处理 csrf_token 这个 tag,  从而自动为表单添加一个名为 csrfmiddlewaretoken 的 input

CSRF

　　http://www.cnblogs.com/hyddd/archive/2009/04/09/1432744.html?login=1

防御手段：cookie设置为HttpOnly，增加token， 通过Referer识别

2.XSS攻击和常用防御手段，SQL注入，文件上传漏洞，Ddos攻击

　　跨域脚本攻击(Cross Site Scripting),页面转义，请求参数过滤等方法解决

　　SQL注入：' ;drop tableaaa;–，'  or '1'='1；使用预编译语句，orm框架，避免密码明文存放，妥善处理异常信息显示。

第一部分 Python基础篇（80题）

1. 为什么学习Python？
   易学，可移植性强，开源库多，可读性强，面向对象。

2. 通过什么途径学习的Python？

3. Python和Java、PHP、C、C#、C++等其他语言的对比？

   

   语言之间的对比
   
   　　PHP类：适合写网页
   
   　　Python、Java：既可以写网页，也可以写后台功能
   
   　　　　-Python：执行效率低，开发效率高
   
   　　　　-Java：执行效率高，开发效率低
   
   　　
   
   　　C语言： 代码编译得到 机器码 ，机器码在处理器上直接执行，每一条指令控制CPU工作
   
   　　其他语言： 代码编译得到 字节码 ，虚拟机执行字节码并转换成机器码再后在处理器上执行
   
    
   
   　　Python 和 C  Python这门语言是由C开发而来
   
   　　　　对于使用：Python的类库齐全并且使用简洁，如果要实现同样的功能，Python 10行代码可以解决，C可能就需要100行甚至更多.
   　　　　对于速度：Python的运行速度相较与C慢了
   
   　　Python 和 Java、C#等
   
   　　　　对于使用：Linux原装Python，其他语言没有；以上几门语言都有非常丰富的类库支持
   　　　　对于速度：Python在速度上可能稍显逊色

   anwser

4. 简述解释型和编译型编程语言？

   

   编译型语言在程序执行之前，先会通过编译器对程序执行一个编译的过程，把程序转变成机器语言。运行时就不需要翻译，而直接执行就可以了。最典型的例子就是C语言。
   
   解释型语言就没有这个编译的过程，而是在程序运行的时候，通过解释器对程序逐行作出解释，然后直接运行，最典型的例子是Ruby。

   answer

5. Python解释器种类以及特点？

   

   cpython 这个解释器是用c语言开发的，cpython是使用最广的python解释器。
   
   lpython是基于cpython之上的一个交互式计时器，交互方式增强，功能和cpython功能一样，调用ie。
   
   pypy是另一个python解释器，它的目标是执行速度，pypy采用JIT技术，对python代码进行动态编译，
   
   可提高代码执行效率。
   
   jython是运行在java平台上的解释器，可以直接把python代码编译成java字节码执行。
   
   Ironpython是运行在微软.Net平台上的解释器，把python代码编译成.Net的字节码。

   answer

6. 位和字节的关系？
   1：“字节”是byte，“位”是bit ； 
   2： 1 byte = 8 bit ；

7. b、B、KB、MB、GB 的关系？
   ...

8. 请至少列举5个 PEP8 规范（越多越好）。

   

   缩进
       每级缩进用4个空格。
       括号中使用垂直隐式缩进或使用悬挂缩进。
   最大行宽
       每行最大行宽不超过 79 个字符
       一般续行可使用反斜杠
       括号内续行不需要使用反斜杠
   空行
       两行空行用于分割顶层函数和类的定义
       单个空行用于分割类定义中的方法    
   模块导入
       导入的每个模块应该单独成行
       导入顺序如下: (各模块类型导入之间要有空行分割，各组里面的模块的顺序按模块首字母自上而下升序排列) 
       标准库
       相关的第三方库
       本地库
   字符串
       单引号和双引号作用是一样的，但必须保证成对存在，不能夹杂使用. (建议句子使用双引号, 单词使用单引号, 但不强制.)
   表达式和语句中的空格
       括号里边避免空格  
       逗号，冒号，分号之前避免空格 
       函数调用的左括号之前不能有空格
       赋值等操作符前后不能因为对齐而添加多个空格
       二元运算符两边放置一个空格 
   注释
       注释块
       注释块通常应用在代码前，并和代码有同样的缩进。每行以 ‘# ' 开头, 而且#后面有单个空格。
       单行注释(应避免无谓的注释)
   命名规则
       包和模块名: 
           包和模块名应该简短，全部用小写字母, 多字母之间可以使用单下划线连接。
       类名: 
           遵循驼峰命名
       全局变量名: 
           全局变量名应尽量只在模块内部使用, 对可能使用语句 from moduleName import variableName 而被导入的模块，应采用 __all__ 机制来防止全局变量被别的模块导入, 或者在全局变量名开头加一个前置下划线.
   函数名 
       函数名    应该为全部小写的凹驼峰规则。
       常量名 
           常量全部使用大写字母的凹驼峰规则来表示, 通常在模块顶格定义
       方法名和实例变量 
           非公开方法和实例变量开头使用前置下划线
               有时候可能会为了避免与子类命名冲突，采用两个前置下划线 
               需要注意的是: 若 class Foo 的属性名为 __a， 该属性是不能以 Foo.__a 的方式访问的(执著的用户还是可以通过Foo._Foo__a 来访问), 所以通常双前置下划线仅被用来避免与基类的属性发生命名冲突。
       None 的比较用 is 或 is not，而不要用 ==
       用 is not 代替 not … is, 前者的可读性更好
   使用函数定义关键字 def 代替 lambda 赋值给标识符, 这样更适合于回调和字符串表示
   异常类应该继承自Exception，而不是 BaseException
   捕获异常时尽量指明具体异常, 尽量不用 except Exception, 应该捕获出了什么问题，而不是问题发生
   try/except 子句中的代码要尽可能的少, 以免屏蔽掉其他的错误
   函数或者方法在没有返回值时要明确返回 None
   使用字符串方法而不是 string 模块 
   使用 isinstance() 代替对象类型的比较
   空序列类型对象的 bool 为 False
   不要用 == 进行 bool 比较，用is

   8 answer
9. 通过代码实现如下转换：
   

   二进制转换成十进制：v = “0b1111011”
  # print(int(v,2))
   十进制转换成二进制：v = 18
                 # bin(v)
   八进制转换成十进制：v = “011”
           # print(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 = ？
    
    

    def ipfunc(ip):
        a = ip.split('.')
        s = ''
        l = []
        for i in a:
            i = bin(int(i))[2:]
            i = i.rjust(8, '0')
            l.append(i)
        s = s.join(l)
        return s
    
    print(int(ipfunc('192.168.1.1'),2))

    10 answer

11. python递归的最大层数？
    998

    1、递归必须要有一个明确的结束条件

    2、每次进入更深一层递归时，问题规模相比上次递归都有应有所减少

    3、递归效率不高，递归层次过多会导致栈溢出

    import sys
    sys.setrecursionlimit(递归的最大次数)

12. 求结果：
        v1 = 1 or 3
   #  1
        v2 = 1 and 3
 # 3
        v3 = 0 and 2 and 1 # 0
    
    v4 = 0 and 2 or 1   # 0
    
    v5 = 0 and 2 or 1 or 4  # 1
    
    v6 = 0 or Flase and 1  False

13. ascii、unicode、utf-8、gbk 区别？
    参考http://kaito-kidd.com/2018/05/30/ascii-gb18030-unicode-utf8/

14. 字节码和机器码的区别？
    一，机器码，完全依附硬件而存在～并且不同硬件由于内嵌指令集不同，即使相同的0 1代码 意思也可能是不同的～换句话说，根本不存在跨平台性～比如～不同型号的CPU,你给他个指令10001101，他们可能会解析为不同的结果。
    二，我们知道JAVA是跨平台的，为什么呢？因为他有一个jvm,不论那种硬件，只要你装有jvm,那么他就认识这个JAVA字节码

    字节码：字节码通常指的是已经经过编译的源码，字节码的实现方式是通过编译器和虚拟机器

    机器码：机器语言是一种指令集的体系，这种指令集就是机器码，是电脑cpu可以直接解读的数据

15. 三元运算规则以及应用场景？

    三元运算符的功能与‘if ...else’流程语句一致，它在一行中书写，代码非常精练，执行效率更高

    嵌套使用的三元运算符可读性不太好，日后对代码的维护极可能存在问题

16. 列举 Python2和Python3的区别？

    

    1.字符串类型
    
    python中有两种字符类型：字节字符串和文本字符串。
    
    版本    python2    python3
    字节字符串    str    bytes
    文本字符串    Unicode    str
    
    2.默认字符
    python2中默认的字符串类型默认是ASCII，python3中默认的字符串类型是Unicode。
    3.print
    
    python2中，print是个特殊语句，python3中print是函数。
    
    python2：print 'hello word!'
    
    python3：print('hello word!',file=sys.stderr)
    
    4.除法/
    
    python2中/的结果是整型，python3中是浮点类型。
    
    5.导入
    
    python2中的包导入顺序：标准库—相对倒入（即当前目录）—绝对导入（sys.path）
    
    python3中的包导入顺序：标准库—绝对导入（如果想要相对导入，使用from .moudel）
    
    6.类
    
    python2中默认类是旧式类，需要显式继承新式类（object）来创建新式类。
    
    python3中完全移除旧式类，所有类都是新式类，但仍可显式继承object类。
    
    7.元类声明
    
    python2中声明元类：__metaclass__ = MetaClass
    
    python3中声明元类：class newclass(metaclass=MetaClass)：pass
    
    8.异常
    
    python2中引发异常：raise ValueError,'Invalid value'
    
    python3中引发异常：raise ValueError('Invalid value')——在python2中也生效
    
    9.处理异常
    
    python2中处理异常：
    
    try:
    
    raise ValueError,'Invalid value'
    
    except ValueError,e:
    
    pass
    
    python3中处理异常：
    
    try:
    
    raise ValueError,'Invalid value'
    
    except ValueError as e:#在python2中也生效
    
    
    pass
    
    
    python2中异常链会丢失原始异常信息，即：处理B异常时引发了A异常，B异常信息会丢失。
    
    python3中将原始异常信息赋值给__context__属性。并且可以显式指定一个异常作为另一个异常的子句：raise DatabaseError() from IOError()
    
    10.字典
    
    python2中的dict类中的keys、values和items均返回list对象，iterkeys、itervalues和iteritems返回生成器对象。
    
    python3中移除了list、只返回一个生成器的对象，只保留视图（生成器），但方法名为：keys、values和items。
    
    11.模块合并
    
    python2中的StringIO和cStringIO合并为python3中的io
    
    python2中的pickle和cPickle合并为python3中的pickle。
    
    python2中的urllib、urllib2和urlparse合并为python3中的urllib
    
    12.重命名模块
    
    python3    python2
    Configparser    ConfigParser
    filter    itertools.ifilter
    input    raw_input
    map    itertools.imap
    range    xrange
    functools.reduce    reduce
    socketserver    SocketServer
    zip    itertools.izip
    
    ---------------------
    
    本文来自 泠月飞花 的CSDN 博客 ，全文地址请点击：https://blog.csdn.net/ljl6158999/article/details/78983725?utm_source=copy 

    answer

     

17. 用一行代码实现数值交换：
         
 a = 1
     
     b = 2
    a,b = b,a

18. Python3和Python2中 int 和 long的区别？
    Python 2有为非浮点数准备的int和long类型。int类型的最大值不能超过sys.maxint，而且这个最大值是平台相关的。可以通过在数字的末尾附上一个L来定义长整型，显然，它比int类型表示的数字范围更大。在Python 3里，只有一种整数类型int.(https://blog.csdn.net/samxx8/article/details/21535901?utm_source=copy)

19. xrange和range的区别？
    range     函数说明：range([start,] stop[, step])，根据start与stop指定的范围以及step设定的步长，生成一个序列。
    xrange     函数说明：用法与range完全相同，所不同的是生成的不是一个数组，而是一个生成器。

20. 文件操作时：xreadlines和readlines的区别？
    # 返回一个list for line in f.readlines()  print line 
    # 返回一个生成器 for line in f.xreadlines()  print line 
    所以二者返回类型不同。但使用时相同。 

21. 列举布尔值为False的常见值？
    0,[],{},set(),(),None

22. 字符串、列表、元组、字典每个常用的5个方法？
    # 0)、字符串：length,index,append,remove,reverse

    # 1）、元组：
    # 定义方法：用圆括号，只有一个元素要加逗号。如 (a,)
    # 元组为不可变列表，不能增删改其元素，但其‘孙子’可能可以，
    # 2）、列表：
    # 定义：li = [],list(可迭代对象)等
    # 新增：append #尾部加
    # insert #按位置插入
    # extend #迭代着添加
    # 更改：按索引改
    # 按切片改
    # 删除：pop # 按位置删除
    # remove # 按元素删除
    # clear # 清空列表
    # del # 内存级别删除
    # 3）字典
    # 定义：{‘k’:'v'},dict.fromkeys(,)
    # 新增：dic['k'] = ‘v’，有则覆盖，无则添加
    # dic.setdefault(k,v1) 有则不变，无则添加
    # 更改：dic['k'] = ‘v’
    # 删除：pop() # 按元素删除，返回删除元素
    # popitem() # 随机删除，元组形式返回键值对
    # cle

23. lambda表达式格式以及应用场景？
    lambda 参数:返回值，map、filter等对数据简单处理场景中。

24. pass的作用？
    pass语句什么也不做，一般作为占位符或者创建占位程序，pass语句不会执行任何操作2、保证格式完整 3、保证语义完整 。

25. *arg和**kwarg作用
    在位置参数和关键字参数个数不确定的时候使用，函数定义的时候可以pack,调用的时候unpack。

26. is和==的区别
    == 判断值是否相等
    is 判断内存地址是否相等

27. 简述Python的深浅拷贝以及应用场景？

    • 深浅拷贝都是对源对象的复制，占用不同的内存空间
    • 如果源对象只有一级目录的话，源做任何改动，不影响深浅拷贝对象
    • 如果源对象不止一级目录的话，源做任何改动，都要影响浅拷贝，但不影响深拷贝
    • 序列对象的切片其实是浅拷贝，即只拷贝顶级的对象

28. Python垃圾回收机制？

    

    import sys sys.getrefcount()查看引用计数
    字符串中间有空格！？等会重新创建新的字符串
    总结
    1. 小整数[-5,257)共用对象，常驻内存，不会被释放。
    2. 单个字符共用对象，常驻内存。
    3. 单个单词，不可修改，默认开启intern机制，共用对象，引用计数为0，则销毁 。
    4. 大整数不共用内存，引用计数为0，销毁 .
    5. 数值类型和字符串类型在 Python 中都是不可变的，这意味着你无法修改这个对象的值，每次对变量的修改，实际上是创建一个新的对象 .
    Garbage collection(GC垃圾回收)
    python采用的是引用计数机制为主，标记-清除和分代收集(隔代回收、分代回收)两种机制为辅的策略
    
    引用计数机制的优点：
    
    1、简单
    
    2、实时性：一旦没有引用，内存就直接释放了。不用像其他机制等到特定时机。实时性还带来一个好处：处理回收内存的时间分摊到了平时。
    引用计数机制的缺点：
    维护引用计数消耗资源
    循环引用，解决不了
    
    gc模块
    
    3.1. 垃圾回收机制
    导致引用计数+1的情况
    1.对象被创建，例如a = "hello"
    2.对象被引用，例如b=a
    3.对象被作为参数，传入到一个函数中，例如func(a)
    4.对象作为一个元素，存储在容器中，例如list1=[a,a]
    1. 常用函数
    1、gc.set_debug(flags) 设置gc的debug日志，一般设置为gc.DEBUG_LEAK
    2、gc.collect([generation]) 显式进行垃圾回收，可以输入参数，0代表只检查零代的对象，1代表检查零，一代的对象，2代表检查零，一，二代的对象，如果不传参数，执行一个full collection，也就是等于传2。 在python2中返回不可达（unreachable objects）对象的数目
    3、gc.get_threshold() 获取的gc模块中自动执行垃圾回收的频率。
    4、gc.set_threshold(threshold0[, threshold1[, threshold2]) 设置自动执行垃圾回收的频率。
    5、gc.get_count() 获取当前自动执行垃圾回收的计数器，返回一个长度为3的列表
    Python的GC模块主要运用了引用计数来跟踪和回收垃圾。在引用计数的基础上，还可以通过“标记-清除”解决容器对象可能产生的循环引用的问题。通过分代回收以空间换取时间进一步提高垃圾回收的效率。
    
    标记-清除
    
    标记-清除的出现打破了循环引用，也就是它只关注那些可能会产生循环引用的对象
    缺点：该机制所带来的额外操作和需要回收的内存块成正比。
    一旦这个差异累计超过某个阈值(700,10,10)，则Python的收集机制就启动了，并且触发上边所说到的零代算法释放“浮动的垃圾”，并且将剩下的对象移动到一代列表。随着时间的推移，程序所使用的对象逐渐从零代列表移动到一代列表。通过这种方法，你的代码所长期使用的对象，那些你的代码持续访问的活跃对象，会从零代链表转移到一代再转移到二代。通过不同的阈值设置，Python可以在不同的时间间隔处理这些对象。Python处理零代最为频繁，其次是一代然后才是二代。
    
    隔代回收
    
    原理：将系统中的所有内存块根据其存活时间划分为不同的集合，每一个集合就成为一个“代”，垃圾收集的频率随着“代”的存活时间的增大而减小。也就是说，活得越长的对象，就越不可能是垃圾，就应该减少对它的垃圾收集频率。那么如何来衡量这个存活时间：通常是利用几次垃圾收集动作来衡量，如果一个对象经过的垃圾收集次数越多，可以得出：该对象存活时间就越长。
    dir(__builtins__)查看内建属性
    __getattribute__内建属性。属性访问拦截器(方法和属性都可以被拦截)，可以返回一个值：以后不要在__getattribute__方法中调用self.xxxx会引起递归时程序死掉
    map函数会根据提供的函数对指定序列做映射返回值是列表
    map(function, sequence[, sequence, ...]) -> list
    •    function:是一个函数
    •    sequence:是一个或多个序列,取决于function需要几个参数
    •    返回值是一个list
    filter函数python3返回的是生产器filter函数会对指定序列执行过滤操作
    filter(function or None, sequence) -> list, tuple, or string
    •    function:接受一个参数，返回布尔值True或False
    •    sequence:序列可以是str，tuple，list
    list(filter(lambda x x%2==0,[1,2,3,4,5,6])---->[2,4,6]
    sorted函数-排序
    sorted(iterable, reverse=False) --> new sorted list
    functools模块import functools
    partial函数(偏函数)把一个函数的某些参数设置默认值，返回一个新的函数，调用这个新函数会更简单。
    wraps函数 使用装饰器时，让外界看被装饰的函数时内容一致。
    例如，被装饰后的函数其实已经是另外一个函数了（函数名等函数属性会发生改变）。
    functools.wraps(func)

    View Code

29. Python的可变类型和不可变类型？

    　　1、对于不可变类型，无论创建多少个不可变类型，只要值相同，都指向同个内存地址（若值不同，那么一定指向不同的内存地址）。

     　  2、对于可变类型，无论创建多少个可变类型，只要值相同，都不指向同个内存地址（除非进行复制操作，那么他们将会指向同一个地址）。求结果：

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. 求结果：
    
    
    6 6 6 6

32. 列举常见的内置函数？
    abs all any bin bool list dict dir id .....

33. filter、map、reduce的作用？

    filter函数传入两个参数，传入的函数会作用于序列的每个元素，并将不符合传入函数要求的过滤掉。
    filter返回的也是一个迭代器Iterator

    map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。

34. 一行代码实现9*9乘法表
    print('\n'.join(['\t'.join(["%2s*%2s=%2s"%(j,i,i*j) for j in range(1,i+1)]) for i in range(1,10)])) 

35. 如何安装第三方模块？以及用过哪些第三方模块？
    pip install xxx 
    requests Pillow charset psutil

36. 至少列举8个常用模块都有那些？
    datetime collections base64 struct hashlib hmac itertools contextlib urllib XML HTMLParser

37. re的match和search区别？
    re.match()从开头开始匹配string。
    re.search()从anywhere 来匹配string。

38. 什么是正则的贪婪匹配？

    婪匹配:正则表达式一般趋向于最大长度匹配，也就是所谓的贪婪匹配。

    非贪婪匹配：就是匹配到结果就好，就少的匹配字符。

39. 求结果：
 a. [ i % 2 for i in range(10) ]
 b. ( i % 2 for i in range(10) )
    列表推导式 列表生成式

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

41. def func(a,b=[]) 这种写法有什么坑？
    可变对象作为参数时，只会初始化一次，以后每次调用该参数都是用的是同一个可变对象地址

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

    li = "1,2,3".split(",")

43. 如何实现[‘1’,’2’,’3’]变成[1,2,3] ?
    [int(i) for i in [‘1’,’2’,’3]]

44. 比较： a = [1,2,3] 和 b = [(1),(2),(3) ] 以及 b = [(1,),(2,),(3,) ] 的区别？
    a 等同于b 第一个
    a 不等同
    因为元组只有一个元素时且不加逗号和括号内数据类型一致，实际上就不是元组了。

45. 如何用一行代码生成[1,4,9,16,25,36,49,64,81,100] ?
    [i**2 for i in rang(1,11)]

46. 一行代码实现删除列表中重复的值 ?
    list(set(li))

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

48. logging模块的作用？以及应用场景？
    Python的logging模块提供了通用的日志系统，可以方便第三方模块或者是应用使用。这个模块提供不同的日志级别，并可以采用不同的方式记录日志，比如文件，HTTP GET/POST，SMTP，Socket等，甚至可以自己实现具体的日志记录方式。
    
    

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

    

    class Stack(object):
        def __init__(self):
            self.stack = []
    
        def push(self, value):    # 进栈
            self.stack.append(value)
    
        def pop(self):  #出栈
            if self.stack:
                self.stack.pop()
            else:
                raise LookupError('stack is empty!')
    
        def is_empty(self): # 如果栈为空
            return bool(self.stack)
    
        def top(self): 
            #取出目前stack中最新的元素
            return self.stack[-1]

    answer

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

    

    Python的字符串格式化常用的有三种！
    
    　　第一种：最方便的
    
    　　缺点：需一个个的格式化
    
    print('hello %s and %s'%('df','another df'))
     
    
    　　第二种：最好用的
    
    　　优点：不需要一个个的格式化，可以利用字典的方式，缩短时间
    
    print('hello %(first)s and %(second)s'%{'first':'df' , 'second':'another df'})
    　　第三种：最先进的
    
    　   优点：可读性强
    
    print('hello {first} and {second}'.format(first='df',second='another df'))

    answer

51. 简述 生成器、迭代器、可迭代对象 以及应用场景？
    迭代器：定义：可迭代对象.__iter__（）就是迭代器，含有__iter__且__next__

    生成器：本质：迭代器，是自己用python写的迭代器
    　　生成器函数yield，yield from，调用生成器函数生成对象
           每调用一次__next__，执行一个yield
            生成器表达式，用（）替换列表推导式的[]即可
    可迭代对象：内部函数__next__方法

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

    

    def binary_search(li,aim,start=0,end =None):
        end = len(li)-1 if end is None else end
        mid = (end - start) // 2 + start
        if start < end:
            if aim == li[mid]:
                return mid
            elif aim > li[mid]:
                return binary_search(li, aim, mid+1, end)
            else:
                return binary_search(li, aim, start, mid-1)
        else:
            return None
    
    print(binary_search([1,2,3,4,5,6],5))

    bin_search

53. 谈谈你对闭包的理解？
    必须是一个嵌套的函数。 闭包必须返回嵌套函数。 嵌套函数必须引用一个外部的非全局的局部自由变量。 

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

55. 如何生成一个随机数？

    

    import random
    for i in range(5):
        n = random.randint(0,9)
        l = chr(random.randint(65,90))
        u = chr(random.randint(97,122))
        print(random.sample([n,l,u],2))

    随机random

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

57. 谈谈你对面向对象的理解？
    不着急直接去计算/操作代码获取结果，从一个大的问题中要到要描述的角色，将角色的属性和行为抽象出来形成一个模子，后期用到角色的时候都围绕这个模子来操作。

58. Python面向对象中的继承有什么特点？

    减少代码重用，可以多继承，缺点就是把子类与父类强耦合到一起

59. 面向对象深度优先和广度优先是什么？

    深度优先主要体现在经典类在菱形继承的背景下，查找属性的方式
    #广度优先主要体现在新式类在菱形继承的背景下，查找属性的方式，

60. 面向对象中super的作用？
    super 指的是 MRO 中的下一个类，在 MRO 中，基类永远出现在派生类后面，如果有多个基类，基类的相对顺序保持不变。什么 super 啊，MRO 啊，都是针对 new-style class。

61. 是否使用过functools中的函数？其作用是什么？
    Python的functools模块用以为可调用对象（callable objects）定义高阶函数或操作。简单地说，就是基于已有的函数定义新的函数。 所谓高阶函数，就是以函数作为输入参数，返回也是函数。 

62. 列举面向对象中带爽下划线的特殊方法，如：__new__、__init__
    __dict__, __name__,__doc__,__get__,__set__,__delete,__getitem__,__call__

63. 如何判断是函数还是方法？

    1. 函数(function)是Python中一个可调用对象(callable), 方法(method)是一种特殊的函数。
    2. 一个可调用对象是方法和函数，和这个对象无关，仅和这个对象是否与类或实例绑定有关（bound method）。
    3. 实例方法，在类中未和类绑定，是函数；在实例中，此实例方法与实例绑定，即变成方法。
    4. 静态方法没有和任何类或实例绑定，所以静态方法是个函数。
    5. 装饰器不会改变被装饰函数或方法的类型。
    6. 类实现__call__方法,其实例也不会变成方法或函数,依旧是类的实例。
    7. 使用callalble() 只能判断对象是否可调用,不能判断是不是函数或方法。
    8. 判断对象是函数或方法应该使用type(obj)。

64. 静态方法和类方法区别？

    　　　　#@classmethod 绑定类方法

    　　　　　　类方法

    　　　　　　调用者是类

    　　　　　　默认参数是CLS,表示当前类。

    　　　　　　主要用途，用来操作类的静态变量，类方法，静态方法

                  #@staticmethod 静态方法

                        调用者是类

                        没有默认参数

                        # 什么时候用静态方法
         　　　　　　   # 既不会用到对象的资源也不会用到类的资源的时候  　

65. 列举面向对象中的特殊成员以及应用场景
    1. __doc__  描述类的信息
    2. __call__ 对象后面加括号，触发执行
    3. __dict__ 查看类或对象中的所有成员
     4. __str__ 如果一个类中定义了__str__方法，那么在打印对象时，默认输出该方法的返回值
     5. __getitem__ 、 __setitem__ 、__delitem__ 用于索引操作，如字典。分别表示获取、设置、删除数据
    6. __new__ 、__metaclass__

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

    

    # 5.
    # li = [1, 2, 3, 4, 5]
    # li_new = []
    # for i in li:
    #     for j in li:
    #         if j == i:
    #             continue
    #         for k in li:
    #             if k == i or k == j:
    #                 continue
    #             data = i * 100 + j * 10 + k
    #             if data not in li_new:
    #                 li_new.append(data)
    #
    # print(len(li_new))

    View Code

67. 什么是反射？以及应用场景？

    　使用字符串数据类型的变量名来操作一个变量的值。

    　　#使用反射获取某个命名空间中的值，

    　　　　#需要

    　　　　　　#有一个变量指向这个命名空间

    　　　　　　#字符串数据类型的名字

    　　　　#再使用getattr获取值，

    　　　　　　#如果变量能直接获取结果

    　　　　　　#如果是函数，只能拿到内存地址，加上括号就是执行

     　　#使用类名反射：　　静态属性、类方法、静态方法

    　　#使用对象名反射：　　对象属性、绑定对象方法

    　　#使用模块名反射：　　变量、函数、类

    　　#在自己所在文件中反射全局变量：　　getattr（sys.modules[__name__],'要反射的名字'）

68. metaclass作用？以及应用场景？
    类其实是能够创建出类实例的对象，ORM。。。。

69. 用尽量多的方法实现单例模式。
    装饰器、导入模块，__new__,元类

70. 装饰器的写法以及应用场景。

    

    import time
    from functools import  wraps
    
    def wrapper(f):
        @wraps(f)
        def inner(*args, **kwargs):
    #       inner.__name__ = f.__name_
            #print(inner.__closure__)
            print('login执行前！',  f.__name__)
            ret = f(*args, **kwargs)
            print('login执行后！')
            return ret
        return inner

    装饰器

    给来的函数等增加功能

71. 异常处理写法以及如何主动跑出异常（应用场景）
    raise 1=1

    try:
        print(111)
    except Exception as e:
        print(111)
    else:
        print(1111)
    finally:
        print(222)

72. 什么是面向对象的mro
    方法解析顺序

73. isinstance作用以及应用场景？
    判断一个对象是否是某个类的实例。

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]

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

    

     　　　　1）、json
    　　　　　　数字
    
    　　　　　   字符
    
    　　　　　　列表（元组会转换成列表后序列化，反序列化后是列表）
    
    　　　　　　字典（key值必须是str，否则不能被序列化）
    
                          这四种类型可以被序列化，其他的都不行，被json序列化后，与其他语言通用。
    
              json.dumps()/json.loads() 在内存中转换
    
    　　   json.dump()/json.load() 在文件和内存之间转换
    
                       2)、json的问题
    　　　　　　1.有限的数据类型
    
    　　　　　　2.字典的key必须为str
    
    　　　　　　3.不能连续load
    
    　　　　　　3）、序列化参数说明

    View Code
    

    import json 
    from datetime import date 
    from datetime import datetime 
       
    class JsonCustomEncoder(json.JSONEncoder): 
        
        def default(self, field): 
         
            if isinstance(field, datetime): 
                return o.strftime('%Y-%m-%d %H:%M:%S') 
            elif isinstance(field, date): 
                return o.strftime('%Y-%m-%d') 
            else: 
                return json.JSONEncoder.default(self, field) 
       

    JSONEncoder

     

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

77. 什么是断言？应用场景？

    assert断言语句用来声明某个条件是真的，其作用是测试一个条件(condition)是否成立，如果不成立，则抛出异常。

    断言是用来检查非法情况而不是错误情况的，用来帮开发者快速定位问题的位置。 异常处理用于对程序发生异常情况的处理，增强程序的健壮性和容错性。

78. 有用过with statement吗？它的好处是什么？
    with语句的好处是通过context manager封装了try...finally语句，起到代码重用的目的

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

    

    import os
    
    rootdir = './'   # 需要遍历的文件夹，这里设定为当前文件夹
    list = os.listdir(rootdir)
    for line in list:
        filepath = os.path.join(rootdir, line)
        if os.path.isdir(filepath):
            print "dir:" + filepath
        if os.path.isfile(filepath):
            print "file:" + filepath

    遍历文件夹

     

80. 简述 yield和yield from关键字。

    yield from iterable本质上等于 for item in iterable: yield item的缩写版

    程序在遇见yield语句时会停下来等待下一个next继续运行。

第二部分 网络编程和并发（34题）

1. 简述 OSI 七层协议。
   应用层、表示层、会话层、传输层、网络层、数据链路层、物理层
   https://www.cnblogs.com/bigtreei/p/8109303.html

2. 什么是C/S和B/S架构？

   

   两种架构：一种是C/S架构的；一种是B/S架构的。这两种架构的概念区别是什么呢、各有哪些优缺点呢？
   
   C/S 架构
   
   C/S 架 构是一种典型的两层架构，其全称是Client/Server，即客户端服务器端架构，其客户端包含一个或多个在用户的电脑上运行的程序，而服务器端有两 种，一种是数据库服务器端，客户端通过数据库连接访问服务器端的数据；另一种是Socket服务器端，服务器端的程序通过Socket与客户端的程序通 信。
   
   C/S 架构也可以看做是胖客户端架构。因为客户端需要实现绝大多数的业务逻辑和界面展示。这种架构中，作为客户端的部分需要承受很 大的压力，因为显示逻辑和事务处理都包含在其中，通过与数据库的交互（通常是SQL或存储过程的实现）来达到持久化数据，以此满足实际项目的需要。
   
   C/S 架构的优缺点
   
   优点：
   
   1.C/S架构的界面和操作可以很丰富。
   
   2.安全性能可以很容易保证，实现多层认证也不难。
   
   3.由于只有一层交互，因此响应速度较快。
   
   缺点：
   
   1.适用面窄，通常用于局域网中。
   
   2.用户群固定。由于程序需要安装才可使用，因此不适合面向一些不可知的用户。
   
   3.维护成本高，发生一次升级，则所有客户端的程序都需要改变。
   
   B/S架构
   
   B/S 架构的全称为Browser/Server，即浏览器/服务器结构。Browser指的是Web浏览器，极少数事务逻辑在前端实现，但主要事务逻辑在服务 器端实现，Browser客户端，WebApp服务器端和DB端构成所谓的三层架构。B/S架构的系统无须特别安装，只有Web浏览器即可。
   
   B/S架构中，显示逻辑交给了Web浏览器，事务处理逻辑在放在了WebApp上，这样就避免了庞大的胖客户端，减少了客户端的压力。因为客户端包含的逻辑很少，因此也被成为瘦客户端。
   
   B/S架构的优缺点
   
   优点：
   
   1）客户端无需安装，有Web浏览器即可。
   
   2）BS架构可以直接放在广域网上，通过一定的权限控制实现多客户访问的目的，交互性较强。
   
   3）BS架构无需升级多个客户端，升级服务器即可。
   
   缺点：
   
   1）在跨浏览器上，BS架构不尽如人意。
   
   2）表现要达到CS程序的程度需要花费不少精力。
   
   3）在速度和安全性上需要花费巨大的设计成本，这是BS架构的最大问题。
   
   4）客户端服务器端的交互是请求-响应模式，通常需要刷新页面，这并不是客户乐意看到的

   anwser

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

    

4. 什么是arp协议？
   ARP协议的基本功能就是通过目标设备的IP地址，查询目标设备的MAC地址，以保证通信的进行

5. TCP和UDP的区别？
   TCP有连接，面向字节流，无消息边界，可靠。
   UDP无连接，面向数据包，快，不可靠。

6. 什么是局域网和广域网？
   广域网（WAN），就是我们通常所说的Internet，它是一个遍及全世界的网络。 
   局域网（LAN），相对于广域网（WAN）而言，主要是指在小范围内的计算机互联网络。这个“小范围”可以是一个家庭，一所学校，一家公司，或者是一个政府部门。

7. 为何基于tcp协议的通信比基于udp协议的通信更可靠？

       tcp:可靠 对方给了确认收到信息，才发下一个，如果没收到确认信息就重发
       udp:不可靠 一直发数据，不需要对方回应

8. 什么是socket？简述基于tcp协议的套接字通信流程。
   Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。
   

    

9. 什么是粘包？ socket 中造成粘包的原因是什么？ 哪些情况会发生粘包现象？

   

   　　1.粘包
   　　　　1）产生粘包原因：
   　　　　　　（1）、接收方不知道消息之间的边界，不知道一次性要取多少字节的数据造成的。
   
   　　　　　　（2）、数据包较小且时间间隔较小，由于合包机制和Nagle算法，将合成一个大包发送过去，由于接收方不知道精准的拆包机制导致粘包
   
   　　　　2）产生粘包的两种情况
   　　　　　　（1）、发送端需要等缓冲区满才将数据发送出去，产生粘包，（数据包小，时间间隔短，合到一起，产生粘包）
   
   　　　　　　（2）、接收端不及时接收缓冲区的包，造成接收数据混乱（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产生粘包）
   
    
   
   　　2.解决粘包
   　　　　思路：
   
   　　　　1、让接收端知道发送数据的大小，发送要传送文件的大小等信息给接收端，这样产生新问题，这个传送文件大小等的信息字典因为不知道他的长度，可能和后边要传送的文件数据产生粘包。
   
   　　　　2、将传送文件大小等的信息字典通过struct模块中的pack方法打包成固定大小为4的包数据，在接收端通过接收4字节的大小包并unpack解包，获取文件信息数据，这样就可以完美避免粘包了。

   答案

10. IO多路复用的作用？
    IO多路复用是一种系统调用，内核能够同时对多个IO描述符进行就绪检查。当所有被监听的IO都没有就绪时，调用将阻塞；当至少有一个IO描述符就绪时，调用将返回，用户代码可通过检查究竟是哪个IO就绪来进一步处理业务。显然，IO多路复用是解决系统里面存在N个IO描述符的问题的，这里必须明确IO复用和IO阻塞与否并不是一个概念，IO复用只检测IO是否就绪（读就绪或者写就绪等），具体的数据的输入输出还是需要依靠具体的IO操作完成（阻塞操作或非阻塞操作）。最典型的IO多路复用技术有select、poll、epoll等。select具有最大数量描述符限制，而epoll则没有，并且在机制上，epoll也更为高效。select的优势仅仅是跨平台支持性，所有平台和较低版本的内核都支持select模式，epoll则不是。

11. 什么是防火墙以及作用？

    　1.防火墙是什么：防火墙就是用于实现Linux下访问控制的功能的，它分为硬件的或者软件的防火墙两种。无论是在哪个网络中，防火墙工作的地方一定是在网络的边缘。而我们的任务就是需要去定义到底防火墙如何工作，这就是防火墙的策略，规则，以达到让它对出入网络的IP、数据进行检测。现在比较常见的防火墙一般是网络层的防火墙，它会在这层对源地址和目标地址进行检测。

    　2.防火墙的原理：防火墙策略一般分为两种，一种叫“通”策略，一种叫“堵”策略。通策略，默认门是关着的，必须要定义谁能进。堵策略则是，大门是洞开的，但是你必须有身份认证，否则不能进。所以我们要定义，让进来的进来，让出去的出去，所以通，是要全通，而堵，则是要选择。

    
    https://www.cnblogs.com/chen1carpolite/p/8987011.html

12. select、poll、epoll 模型的区别？
    http://www.cnblogs.com/linhaifeng/articles/7454717.html
    https://www.cnblogs.com/Anker/p/3265058.html
    
    

13. 简述 进程、线程、协程的区别 以及应用场景？

    一、概念

    　　1、进程

    进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位。每个进程都有自己的独立内存空间，不同进程通过进程间通信来通信。由于进程比较重量，占据独立的内存，所以上下文进程间的切换开销（栈、寄存器、虚拟内存、文件句柄等）比较大，但相对比较稳定安全。

    　　2、线程

    线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。线程间通信主要通过共享内存，上下文切换很快，资源开销较少，但相比进程不够稳定容易丢失数据。

    　　3、协程

    协程是一种用户态的轻量级线程，协程的调度完全由用户控制。协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈，直接操作栈则基本没有内核切换的开销，可以不加锁的访问全局变量，所以上下文的切换非常快。

     

    二、区别：

    1、进程多与线程比较

    线程是指进程内的一个执行单元,也是进程内的可调度实体。线程与进程的区别:
    1) 地址空间:线程是进程内的一个执行单元，进程内至少有一个线程，它们共享进程的地址空间，而进程有自己独立的地址空间
    2) 资源拥有:进程是资源分配和拥有的单位,同一个进程内的线程共享进程的资源
    3) 线程是处理器调度的基本单位,但进程不是
    4) 二者均可并发执行

    5) 每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口，但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制

    　　2、协程多与线程进行比较

    1) 一个线程可以多个协程，一个进程也可以单独拥有多个协程，这样python中则能使用多核CPU。

    2) 线程进程都是同步机制，而协程则是异步

    3) 协程能保留上一次调用时的状态，每次过程重入时，就相当于进入上一次调用的状态

14. GIL锁是什么鬼？

15. Python中如何使用线程池和进程池？

16. threading.local的作用？

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

18. 什么是并发和并行？

19. 进程锁和线程锁的作用？

20. 解释什么是异步非阻塞？

21. 路由器和交换机的区别？

22. 什么是域名解析？

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

24. 生产者消费者模型应用场景及优势？

25. 什么是cdn？

26. LVS是什么及作用？

27. Nginx是什么及作用？

28. keepalived是什么及作用?

29. haproxy是什么以及作用？

30. 什么是负载均衡？

31. 什么是rpc及应用场景？

32. 简述 asynio模块的作用和应用场景。

33. 简述 gevent模块的作用和应用场景。

34. twisted框架的使用和应用？

第三部分 数据库和缓存（46题）

1. 列举常见的关系型数据库和非关系型都有那些？

2. MySQL常见数据库引擎及比较？

3. 简述数据三大范式？

4. 什么是事务？MySQL如何支持事务？

5. 简述数据库设计中一对多和多对多的应用场景？

6. 如何基于数据库实现商城商品计数器？

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

8. 简述触发器、函数、视图、存储过程？

9. MySQL索引种类

10. 索引在什么情况下遵循最左前缀的规则？

11. 主键和外键的区别？

12. MySQL常见的函数？

13. 列举 创建索引但是无法命中索引的8种情况。

14. 如何开启慢日志查询？

15. 数据库导入导出命令（结构+数据）？

16. 数据库优化方案？

17. char和varchar的区别？

18. 简述MySQL的执行计划？

19. 在对name做了唯一索引前提下，简述以下区别：
 
            select * from tb where name = ‘Oldboy-Wupeiqi’ 
 
            select * from tb where name = ‘Oldboy-Wupeiqi’ limit 1

20. 1000w条数据，使用limit offset 分页时，为什么越往后翻越慢？如何解决？

21. 什么是索引合并？

22. 什么是覆盖索引？

23. 简述数据库读写分离？

24. 简述数据库分库分表？（水平、垂直）

25. redis和memcached比较？

26. redis中数据库默认是多少个db 及作用？

27. python操作redis的模块？

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

29. redis如何实现主从复制？以及数据同步机制？

30. redis中的sentinel的作用？

31. 如何实现redis集群？

32. redis中默认有多少个哈希槽？

33. 简述redis的有哪几种持久化策略及比较？

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

35. MySQL 里有 2000w 数据，redis 中只存 20w 的数据，如何保证 redis 中都是热点数据？ 

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

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

38. 如何基于redis实现发布和订阅？以及发布订阅和消息队列的区别？

39. 什么是codis及作用？

40. 什么是twemproxy及作用？

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

42. redis中的watch的命令的作用？

43. 基于redis如何实现商城商品数量计数器？

44. 简述redis分布式锁和redlock的实现机制。

45. 什么是一致性哈希？Python中是否有相应模块？

46. 如何高效的找到redis中所有以oldboy开头的key？

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

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

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

3. 什么是magic string ？

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

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

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

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

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

9. vuex的作用？

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

11. axios的作用？

12. 列举vue的常见指令。

13. 简述jsonp及实现原理？

14. 是什么cors ？

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

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

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

18. 看图写结果：
    

19. 看图写结果：
    

20. 看图写结果：
    

21. 看图写结果：
     

22. 看图写结果：
    

23. 看图写结果：
    

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

25. 什么是wsgi？

26. django请求的生命周期？

27. 列举django的内置组件？

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

29. 简述什么是FBV和CBV？

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

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

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

33. only和defer的区别？

34. select_related和prefetch_related的区别？

35. filter和exclude的区别？

36. 列举django orm中三种能写sql语句的方法。

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

38. F和Q的作用?

39. values和values_list的区别？

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

41. django的Form和ModeForm的作用？

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

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

44. django中csrf的实现机制？

45. django如何实现websocket？

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

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

48. django缓存如何设置？

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

50. django路由系统中name的作用？

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

52. django-debug-toolbar的作用？

53. django中如何实现单元测试？

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

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

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

57. 简述MVC和MTV

58. django的contenttype组件的作用？

59. 谈谈你对restfull 规范的认识？

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

61. 什么是RPC？

62. Http和Https的区别？

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

64. django rest framework框架中都有那些组件？

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

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

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

68. Flask框架的优势？

69. Flask框架依赖组件？

70. Flask蓝图的作用？

71. 列举使用过的Flask第三方组件？

72. 简述Flask上下文管理流程?

73. Flask中的g的作用？

74. Flask中上下文管理主要涉及到了那些相关的类？并描述类主要作用？

75. 为什么要Flask把Local对象中的的值stack 维护成一个列表？

76. Flask中多app应用是怎么完成？

77. 在Flask中实现WebSocket需要什么组件？

78. wtforms组件的作用？

79. Flask框架默认session处理机制？

80. 解释Flask框架中的Local对象和threading.local对象的区别？

81. Flask中 blinker 是什么？

82. SQLAlchemy中的 session和scoped_session 的区别？

83. SQLAlchemy如何执行原生SQL？

84. ORM的实现原理？

85. DBUtils模块的作用？

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

    1 2 3 4 5 6 7 8 9 10 11

    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())

87. SQLAchemy中如何为表设置引擎和字符编码？

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

89. 简述Tornado框架的特点。

90. 简述Tornado框架中Future对象的作用？

91. Tornado框架中如何编写WebSocket程序？

92. Tornado中静态文件是如何处理的？
如： <link href="{{static_url("commons.css")}}" rel="stylesheet" />

93. Tornado操作MySQL使用的模块？

94. Tornado操作redis使用的模块？

95. 简述Tornado框架的适用场景？

96. git常见命令作用：

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

98. git 中 merge 和 rebase命令 的区别。

99. 公司如何基于git做的协同开发？

100. 如何基于git实现代码review？

101. git如何实现v1.0 、v2.0 等版本的管理？

102. 什么是gitlab？

103. github和gitlab的区别？

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

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

106. 什么是敏捷开发？

107. 简述 jenkins 工具的作用?

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

109. 简述 RabbitMQ、Kafka、ZeroMQ的区别？

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模块的作用及基本使用？

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

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

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

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

124. scrapy框架中如何实现大文件的下载？

125. scrapy中如何实现限速？

126. scrapy中如何实现暂定爬虫？

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

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

129. scrapy中的pipelines工作原理？

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

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

132. scrapy-redis组件的作用？

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

134. scrapy-redis的调度器如何实现任务的深度优先和广度优先？

135. 简述 vitualenv 及应用场景?

136. 简述 pipreqs 及应用场景？

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

138. 简述 saltstack、ansible、fabric、puppet工具的作用？

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

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

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

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

143. 有没有刷过leetcode？

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

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

146. 解释 PV、UV 的含义？

147. 解释 QPS的含义？

148. uwsgi和wsgi的区别？

149. supervisor的作用？

150. 什么是反向代理？

151. 简述SSH的整个过程。

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

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

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

155. 是否了解过领域驱动模型？