面试题

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

1. 为什么学习Python？

 我所学的专业是情报学，主要是做数据分析的，在校期间所用到的工具有SPSS和CiteSpace，但对于现在的大数据时代来说，这些传统的可视化工具来实现数据分析已经不能满足需求了；Python在数据分析和数据挖掘方面都有比较专业和全面的模块，并且相对而言入门简单，能够快速上手，所以我选择学习python。

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

看书：《流畅的python》、《python编程：从入门到实践》

看视频：以老男孩python全栈开发课程为主，以实验楼网站上实战课程为辅进行在线学习


看博客和github：平时搜索相关的博客进行拓展

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

   从编程语言的三种分类方式可以对这些语言进行对比：

1. 编译型和解释型：C和C++是编译型语言;Python，Java，PHP，C#是解释型语言。

2. 静态语言和动态语言：C,C++,C#,Java是静态语言;Python,PHP是动态语言。

3. 强类型定义语言和弱类型定义语言：Python,Java,C#是强类型定义语言;C,C++,PHP是弱类型定义语言。

4. 各语言适用领域：

    - Python：主要用于后台服务或是服务器脚本；

    - Java：网站、后台服务、安卓；

    - PHP：web网站开发;

    - C：嵌入式硬件开发;

    - C++：主要用于后台服务和桌面软件及游戏开发;

    - C#:网站、后台服务、桌面软件。

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

    编译型：运行前先由编译器将高级语言代码编译为对应机器的cpu汇编指令集，再由汇编器汇编为目标机器码，生成可执行文件，然最后运行生成的可执行文件。最典型的代表语言为C/C++，一般生成的可执行文件及.exe文件。 

    解释型：在运行时由翻译器将高级语言代码翻译成易于执行的中间代码，并由解释器（例如浏览器、虚拟机）逐一将该中间代码解释成机器码并执行（可看做是将编译、运行合二为一了）。最典型的代表语言为JavaScript、Python、Ruby和Perl等。 

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

  CPython

  当 从Python官方网站下载并安装好Python2.7后，就直接获得了一个官方版本的解释器：Cpython，这个解释器是用C语言开发的，所以叫 CPython，在命名行下运行python，就是启动CPython解释器，CPython是使用最广的Python解释器。

  IPython

  IPython是基于CPython之上的一个交互式解释器，也就是说，IPython只是在交互方式上有所增强，但是执行Python代码的功能和CPython是完全一样的，好比很多国产浏览器虽然外观不同，但内核其实是调用了IE。

  PyPy

  PyPy是另一个Python解释器，它的目标是执行速度，PyPy采用JIT技术，对Python代码进行动态编译，所以可以显著提高Python代码的执行速度。

  Jython

  Jython是运行在Java平台上的Python解释器，可以直接把Python代码编译成Java字节码执行。

  IronPython

  IronPython和Jython类似，只不过IronPython是运行在微软.Net平台上的Python解释器，可以直接把Python代码编译成.Net的字节码。

  在Python的解释器中，使用广泛的是CPython，对于Python的编译，除了可以采用以上解释器进行编译外，技术高超的开发者还可以按照自己的需求自行编写Python解释器来执行Python代码，十分的方便！

6. 位和字节的关系？

  1.位(bit) 
  来自英文bit，表示二进制位。位是计算机内部数据储存的最小单位，11010100是一个8位二进制数。一个二进制位只可以表示0和1两种状态；两个二进制位可以表示00、01、10、11四种状态；三位二进制数可表示八种状态。  

  2.字节(byte)  
  字节来自英文Byte，习惯上用大写的“B”表示。  
  字节是计算机中数据处理的基本单位。计算机中以字节为单位存储和解释信息，规定一个字节由八个二进制位构成，即1个字节等于8个比特（1Byte=8bit）。八位二进制数最小为00000000，最大为11111111；通常1个字节可以存入一个ASCII码，2个字节可以存放一个汉字国标码。

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

  
  1024

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

  缩进/空格/注释/命名等
  http://blog.sae.sina.com.cn/archives/4781

9. 通过代码实现进制转换

  ## 二进制转换成十进制：v = “0b1111011”
  ## 十进制转换成二进制：v = 18
  ## 八进制转换成十进制：v = “011”
  ## 十进制转换成八进制：v = 30
  ## 十六进制转换成十进制：v = “0x12”
  ## 十进制转换成十六进制：v = 87
  1) 二进制数、转换为十进制数的规律是:把二进制数按位权形式展开多项式和的形式，求其最后的和，就是其对应的十进制数——简称“按权求和”。
  2) 十进制整数转换为二进制整数采用"除2取余，逆序排列"法。具体做法是：用2去除十进制整数，可以得到一个商和余数；再用2去除商，又会得到一个商和余数，如此进行，直到商为零时为止，然后把先得到的余数作为二进制数的低位有效位，后得到的余数作为二进制数的高位有效位，依次排列起来。

  10进制，当然是便于我们人类来使用，我们从小的习惯就是使用十进制，这个毋庸置疑。
  2进制，是供计算机使用的，1，0代表开和关，有和无，机器只认识2进制。
  16进制，内存地址空间是用16进制的数据表示, 如0x8039326。

10. 请编写一个函数实现将IP地址转换成一个整数。

  ## 如 10.3.9.12 转换规则为：
  ##         10            00001010
  ##          3            00000011
  ##          9            00001001
  ##         12            00001100
  ## 再将以上二进制拼接起来计算十进制结果：00001010 00000011 00001001 00001100 = ？


  ip_addr='192.168.2.10'
  # transfer ip to int
  def ip2long(ip):
      ip_list=ip.split('.')
      result=0
      for i in range(4):  #0,1,2,3
          result=result+int(ip_list[i])*256**(3-i)
      return result


  long=3232236042

  # transfer int to ip
  def long2ip(long):
      floor_list=[]
      yushu=long
      for i in reversed(range(4)):   #3,2,1,0
          res=divmod(yushu,256**i)
          floor_list.append(str(res[0]))
          yushu=res[1]
      return '.'.join(floor_list)



  a=long2ip(long)
  print(a)

11. python递归的最大层数？

  998

12. 求逻辑运算符的结果

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

结论：
真假比 若都真
or选前 and选后

13. ascii、unicode、utf-8、gbk 区别？

  http://www.cnblogs.com/zhuwenlubin/p/5131026.html

14. 字节码和机器码的区别？

  机器码
  机器码(machine code)，学名机器语言指令，有时也被称为原生码（Native Code），是电脑的CPU可直接解读的数据。

  通常意义上来理解的话，机器码就是计算机可以直接执行，并且执行速度最快的代码。

  用机器语言编写程序，编程人员要首先熟记所用计算机的全部指令代码和代码的涵义。手编程序时，程序员得自己处理每条指令和每一数据的存储分配和输入输出，还得记住编程过程中每步所使用的工作单元处在何种状态。这是一件十分繁琐的工作，编写程序花费的时间往往是实际运行时间的几十倍或几百倍。而且，编出的程序全是些0和1的指令代码，直观性差，还容易出错。现在，除了计算机生产厂家的专业人员外，绝大多数的程序员已经不再去学习机器语言了。

  机器语言是微处理器理解和使用的，用于控制它的操作二进制代码。
  8086到Pentium的机器语言指令长度可以从1字节到13字节。
  尽管机器语言好像是很复杂的，然而它是有规律的。
  存在着多至100000种机器语言的指令。这意味着不能把这些种类全部列出来。
  总结：机器码是电脑CPU直接读取运行的机器指令，运行速度最快，但是非常晦涩难懂，也比较难编写，一般从业人员接触不到。

  字节码
  字节码（Bytecode）是一种包含执行程序、由一序列 op 代码/数据对 组成的二进制文件。字节码是一种中间码，它比机器码更抽象，需要直译器转译后才能成为机器码的中间代码。

  通常情况下它是已经经过编译，但与特定机器码无关。字节码通常不像源码一样可以让人阅读，而是编码后的数值常量、引用、指令等构成的序列。

  字节码主要为了实现特定软件运行和软件环境、与硬件环境无关。字节码的实现方式是通过编译器和虚拟机器。编译器将源码编译成字节码，特定平台上的虚拟机器将字节码转译为可以直接执行的指令。字节码的典型应用为Java bytecode。

  字节码在运行时通过JVM（JAVA虚拟机）做一次转换生成机器指令，因此能够更好的跨平台运行。

  总结：字节码是一种中间状态（中间码）的二进制代码（文件）。需要直译器转译后才能成为机器码。

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

  简化if语句

16. 列举 Python2和Python3的区别？

  py2和py3:
  1. 文件操作：  xreadlines

  f = open('x.log','rb')

  for line in f.xreadlines():
  print(line)

  f.close()

  2. 字符串：
  py2:
  str: 字符串   -> 字节
  unicode: u"sdfsdf"
  py3:
    bytes:
  str:
  3. 默认解释器编码
  py2: ascii
  py3: utf-8

  5. 
  py2: range/xrange 
  py3:       range 

  6. 
  py2: int / long
  py3: int 

  7. input/raw_input 

  8. 
  py2: yield
  py3: yield/yield from 

  9. 
  py2: 新式类和经典类
  py3: 新式类

17. 用一行代码实现数值交换

  a,b=b,a

18. Python3和Python2中 int 和 long的区别？

  python3 彻底废弃了 long+int 双整数实现的方法, 统一为 int , 支持高精度整数运算.

19. xrange和range的区别？

  函数说明：和range 的用法完全相同，但是返回的是一个生成器。 

20. 文件操作时：xreadlines和readlines的区别？

   1) read([size])方法从文件当前位置起读取size个字节，若无参数size，则表示读取至文件结束为止，它范围为字符串对象
    2) 从字面意思可以看出，该方法每次读出一行内容，所以，读取时占用内存小，比较适合大文件，该方法返回一个字符串对象。
    3) readlines()方法读取整个文件所有行，保存在一个列表(list)变量中，每行作为一个元素，但读取大文件会比较占内存。

21. 列举布尔值为False的常见值？

  布尔型，False表示False，其他为True
  整数和浮点数，0表示False，其他为True
  字符串和类字符串类型（包括bytes和unicode），空字符串表示False，其他为True
  序列类型（包括tuple，list，dict，set等），空表示False，非空表示True
  None永远表示False

22. 字符串、列表、元组、字典每个常用的5个方法？

  - 字符串  split/strip/replace/find/index ...
  - 列表     append/extend/insert/push/pop/reverse/sort ...
  - 元组     len/max/min/count/index ...
  - 字典     keys/values/pop/clear/del ...
  - 集合　 add/remove/clear/交集&、并集 |、差集 -　
  　
  - collections  Python内建的一个集合模块，提供了许多有用的集合类。
      1.Counter是一个简单的计数器，例如，统计字符出现的个数;
      2.OrderedDict可以实现一个FIFO（先进先出）的dict，当容量超出限制时，先删除最早添加的Key;
      3.deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈;
      4.defaultdict使用dict时，如果引用的Key不存在，就会抛出KeyError。如果希望key不存在时，返回一个默认值，就可以用defaultdict;

23. lambda表达式格式以及应用场景？

  省去函数命名的烦恼
  http://www.cnblogs.com/guigujun/p/6134828.html

24. pass的作用？

  当你在编写一个程序时，执行语句部分思路还没有完成，这时你可以用pass语句来占位，也可以当做是一个标记，是要过后来完成的代码。

25. arg和kwarg作用

  *args：（表示的就是将实参中按照位置传值，多出来的值都给args，且以元组的方式呈现）
  **kwargs：（表示的就是形参中按照关键字传值把多余的传值以字典的方式呈现）
  http://www.cnblogs.com/xuyuanyuan123/p/6674645.html

26. is和==的区别

  is 比较的是两个实例对象是不是完全相同，它们是不是同一个对象，占用的内存地址是否相同。莱布尼茨说过：“世界上没有两片完全相同的叶子”，这个is正是这样的比较，比较是不是同一片叶子（即比较的id是否相同，这id类似于人的身份证标识）。

  == 比较的是两个对象的内容是否相等，即内存地址可以不一样，内容一样就可以了。这里比较的并非是同一片叶子，可能叶子的种类或者脉络相同就可以了。默认会调用对象的 __eq__()方法。

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

  Python采用基于值得内存管理模式，赋值语句的执行过程是：首先把等号右侧标识的表达式计算出来，然后在内存中找一个位置把值存放进去，最后创建变量并指向这个内存地址。Python中的变量并不直接存储值，而是存储了值的内存地址或者引用
  简单地说，浅拷贝只拷贝一层（如果有嵌套），深拷贝拷贝所有层。
  一层的情况：
    import copy

    # 浅拷贝

    li1 = [1, 2, 3]
    li2 = li1.copy()
    li1.append(4)
    print(li1, li2)  # [1, 2, 3, 4] [1, 2, 3]

    # 深拷贝

    li1 = [1, 2, 3]
    li2 = copy.deepcopy(li1)
    li1.append(4)
    print(li1, li2)  # [1, 2, 3, 4] [1, 2, 3]
  多层的情况：
    import copy

    # 浅拷贝

    li1 = [1, 2, 3, [4, 5], 6]
    li2 = li1.copy()
    li1[3].append(7)
    print(li1, li2)  # [1, 2, 3, [4, 5, 7], 6] [1, 2, 3, [4, 5, 7], 6]

    # 深拷贝

    li1 = [1, 2, 3, [4, 5], 6]
    li2 = copy.deepcopy(li1)
    li1[3].append(7)
    print(li1, li2)  # [1, 2, 3, [4, 5, 7], 6] [1, 2, 3, [4, 5], 6]

28. Python垃圾回收机制？

  Python GC主要使用引用计数（reference counting）来跟踪和回收垃圾。在引用计数的基础上，通过“标记-清除”（mark and sweep）解决容器对象可能产生的循环引用问题，通过“分代回收”（generation collection）以空间换时间的方法提高垃圾回收效率。

  1 引用计数

  PyObject是每个对象必有的内容，其中ob_refcnt就是做为引用计数。当一个对象有新的引用时，它的ob_refcnt就会增加，当引用它的对象被删除，它的ob_refcnt就会减少.引用计数为0时，该对象生命就结束了。

  优点:

  简单 实时性 缺点:

  维护引用计数消耗资源 循环引用

  2 标记-清除机制

  基本思路是先按需分配，等到没有空闲内存的时候从寄存器和程序栈上的引用出发，遍历以对象为节点、以引用为边构成的图，把所有可以访问到的对象打上标记，然后清扫一遍内存空间，把所有没标记的对象释放。

  3 分代技术

  分代回收的整体思想是：将系统中的所有内存块根据其存活时间划分为不同的集合，每个集合就成为一个“代”，垃圾收集频率随着“代”的存活时间的增大而减小，存活时间通常利用经过几次垃圾回收来度量。

  Python默认定义了三代对象集合，索引数越大，对象存活时间越长。

  http://python.jobbole.com/82061/

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

  在Python中不可变对象指：一旦创建就不可修改的对象，包括字符串，元组，数字

  在Python中可变对象是指：可以修改的对象，包括：列表、字典

30. 求可变数据类型结果

  v = dict.fromkeys(['k1','k2'],[])
  v['k1'].append(666)
  print(v)    # {'k1': [666], 'k2': [666]}
  v['k1'] = 777
  print(v)    # {'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. 列举常见的内置函数？

   long(x)
    float(x)  # 把x转换成浮点数
    complex(x) # 转换成复数
    str(x)   # 转换成字符串
    list(x)  # 转换成列表
    tuple(x) # 转换成元组
     
    进制相互转换
     r= bin(10) #二进制
     r= int(10) #十进制

     r = oct(10) #八进制
     r = hex(10) #十六进制
     i= int("11",base=10)#进制间的相互转换base后跟 2/8/10/16
     print(i)
     
    chr(x)//返回x对应的字符，如chr(65)返回‘A'
    ord(x)//返回字符对应的ASC码数字编号，如ord('A')返回65
    abs(),all(),any(),bin(),bool(),bytes(),chr(),dict()dir(),divmod(),enumerate(),eval(),filter(),float(),gloabls(),help(),hex(),id(),input(),int(),isinstance(),len(),list(),locals(),map(),max(),min(),oct(),open(),ord(),pow(),print(),range(),round(),set(),type(),sorted(),str(),sum(),tuple()

33. filter、map、reduce的作用？

  filter:对于序列中的元素进行筛选，最终获取符合条件的序列
  map:遍历序列，对序列中每个元素进行操作，最终获取新的序列
  reduce:对于序列内所有元素进行累计操作

34. 一行代码实现9乘9乘法表

  print("
".join("	".join(["%s*%s=%s" %(x,y,x*y) for y in range(1, x+1)]) for x in range(1, 10)) )

35. 如何安装第三方模块？以及用过哪些第三方模块？

  - pip包管理器
  - 源码安装
      - 下载->解压->cd 到对应路径
      - python setup.py build
      - python setup.py install 

36. 常用模块都有哪些？

  - re/json/logging/os/sys/requests/beautifulsoup4

37. re的match和search区别？

  match和search的区别

  re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；
  re.search匹配整个字符串，直到找到一个匹配。

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

  贪婪和非贪婪
  正则表达式通常用于在文本中查找匹配的字符串。Python里数量词默认是贪婪的（在少数语言里也可能是默认非贪婪），总是尝试匹配尽可能多的字符；非贪婪则相反，总是尝试匹配尽可能少的字符。在"*","?","+","{m,n}"后面加上？，使贪婪变成非贪婪。

39. 求结果：a. [ i % 2 for i in range(10) ] b. ( i % 2 for i in range(10) )

  [ i % 2 for i in range(10) ]  # [0, 1, 0, 1, 0, 1, 0, 1, 0, 1]
  ( i % 2 for i in range(10) )  # <generator object <genexpr> at 0x0000000003180FC0>

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

  1
  2
  False
  True

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

  def func(a, b=[]):
      b.append(a)
      return b
   
   
  s = func(1)
  print(s)  # [1]
  s = func(1)
  print(s)  # [1, 1]
   
  # 第二次调用的时候 b的初始值是[1]了

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

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

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

  [int(x) for x in ['1','2','3']]

44. 比较： a = [1,2,3] 和 b = [(1),(2),(3) ] 以及 b = [(1,),(2,),(3,) ] 的区别？

  前两个列表内是int
  最后一个列表内是元组

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

  i*i for i in range(1,11)]

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

  list(set([1, 2, 3, 4, 45, 1, 2, 343, 2, 2]))

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

  在函数中定义的局部变量如果和全局变量同名，则它会隐藏该全局变量。如果想在函数中使用全局变量，则需要使用global进行声明。

48. logging模块的作用？以及应用场景？

  logging模块是Python内置的标准模块，主要用于输出运行日志，可以设置输出日志的等级、日志保存路径、日志文件回滚等；相比print，具备如下优点：

    可以通过设置不同的日志等级，在release版本中只输出重要信息，而不必显示大量的调试信息；

    print将所有信息都输出到标准输出中，严重影响开发者从标准输出中查看其它数据；logging则可以由开发者决定将信息输出到什么地方，以及怎么输出。
    https://www.cnblogs.com/testdjt/p/7834856.html

49. 请用代码简单实现一个栈。

  # 后进先出
  class Stack():
      def __init__(self, size):
          self.size = size
          self.stack = []
          self.top = -1

      # 入栈之前检查栈是否已满
      def push(self, x):
          if self.isfull():
              raise exception("stack is full")
          else:
              self.stack.append(x)
              self.top = self.top + 1

      # 出栈之前检查栈是否为空
      def pop(self):
          if self.isempty():
              raise exception("stack is empty")
          else:
              self.top = self.top - 1
              self.stack.pop()

      def isfull(self):
          return self.top + 1 == self.size

      def isempty(self):
          return self.top == '-1'

      def showStack(self):
          print(self.stack)


  s = Stack(10)
  for i in range(6):
      s.push(i)  # 入栈
  s.showStack()  # [0, 1, 2, 3, 4, 5]

  for i in range(2):
      s.pop()  # 出栈
  s.showStack()  # [0, 1, 2, 3]

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

  Python的字符串格式化有两种方式:%格式符方式，format方式

51. 简述 生成器、迭代器、可迭代对象 以及应用场景？

  如果给定一个list或tuple，我们可以通过for循环来遍历这个list或tuple，这种遍历我们称为迭代（Iteration）刚才说过，很多容器都是可迭代对象，此外还有更多的对象同样也是可迭代对象，比如处于打开状态的files，sockets等等。但凡是可以返回一个 迭代器 的对象都可称之为可迭代对象
  那么什么迭代器呢？它是一个带状态的对象，他能在你调用 next() 方法的时候返回容器中的下一个值，任何实现了 __next__() （python2中实现 next() ）方法的对象都是迭代器
  生成器算得上是Python语言中最吸引人的特性之一，生成器其实是一种特殊的迭代器，不过这种迭代器更加优雅。生成器（yield）不需要再像上面的类一样写 __iter__() 和 __next__() 方法了，只需要一个 yiled 关键字。 生成器有如下特征是它一定也是迭代器（反之不成立），因此任何生成器也是以一种懒加载的模式生成值。
  http://www.cnblogs.com/yuanchenqi/articles/5769491.html

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

  def bin_search_rec(data_set, value, low, high):
      if low <= high:
          mid = (low + high) // 2
          if data_set[mid] == value:
              return mid
          elif data_set[mid] > value:
              return bin_search_rec(data_set, value, low, mid - 1)
          else:
              return bin_search_rec(data_set, value, mid + 1, high)
      else:
          return

53. 谈谈你对闭包的理解？

  https://www.cnblogs.com/Lin-Yi/p/7305364.html

54. os和sys模块的作用？

  os就是一个普通的python库，用来向Python程序提供运行环境，特别是在文件系统、创建新进程、获取操作系统本身的一些信息（比如uname)，并屏蔽各种不同操作系统之间的细节差异。
  sys模块则是python程序用来请求解释器行为的接口。比如关于调试类的（trace, frames，except）等，profiling类（stats， getsizeof)，运行时环境类（python path, stderr, stdout)，解释器本身（如version）。inspect某种程度上可以看成是在sys提供的功能上的一个包装。

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

  random.randint(a,b)

56. 如何使用python删除一个文件？

  删除子目录
  os.rmdir( path )   # path: "要删除的子目录"

  产生异常的可能原因:
  (1) path 不存在
  (2) path 子目录中有文件或下级子目录
  (3) 没有操作权限或只读

  删除文件
  os.remove(   filename )   # filename: "要删除的文件名"

  产生异常的可能原因:
  (1)   filename 不存在
  (2) 对filename文件， 没有操作权限或只读。

57. 谈谈你对面向对象的理解？

  从三大特性说起：继承、封装、多态
  
  封装：
      起始就是将很多数据封装到一个对象中，类似于把很多东西放到一个箱子中，
      如：一个函数如果好多参数，起始就可以把参数封装到一个对象再传递。
      
      在哪里用过：
        - django rest framework中的request对象。
        - flask中：ctx_context/app_context对象
  继承：
      如果多个类中都有共同的方法，那么为了避免反复编写，就可以将方法提取到基类中实现，
      让所有派生类去继承即可。
      
      在哪里用过？
        - 视图
        - 版本、认证、分页
  多态：
      python本身就是多态的，崇尚鸭子模型，只要会呱呱叫的就是鸭子。
      def func(arg):
        arg.send()
  https://www.cnblogs.com/iyouyue/p/8535796.html

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

  Python3的继承机制
    子类在调用某个方法或变量的时候，首先在自己内部查找，如果没有找到，则开始根据继承机制在父类里查找。
    根据父类定义中的顺序，以深度优先的方式逐一查找父类！
    继承参数的书写有先后顺序，写在前面的被优先继承。

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

  继承顺序
  http://www.liujiangblog.com/course/python/44

60. 面向对象中super的作用？

  我们都知道，在子类中如果有与父类同名的成员，那就会覆盖掉父类里的成员。那如果你想强制调用父类的成员呢？使用super()函数！这是一个非常重要的函数，最常见的就是通过super调用父类的实例化方法__init__！

  语法：super(子类名, self).方法名()，需要传入的是子类名和self，调用的是父类里的方法，按父类的方法需要传入参数。
  class A:
      def __init__(self, name):
          self.name = name
          print("父类的__init__方法被执行了！")
      def show(self):
          print("父类的show方法被执行了！")

  class B(A):
      def __init__(self, name, age):
          super(B, self).__init__(name=name)
          self.age = age

      def show(self):
          super(B, self).show()

  obj = B("jack", 18)
  obj.show()

61. 是否使用过functools中的函数？其作用是什么？

  1.functools.partial
  官网文档说的真是不好理解,就当作是把一个函数，绑定部分或者全部参数后生成一个新版本的函数
  2.functools.partialwrap
  文档说的比较详细，如果不使用这个wraps，那么原始函数的__name__和__doc__都会丢失
  https://blog.csdn.net/secretx/article/details/51700361

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

  __init__ :      构造函数，在生成对象时调用
  __del__ :       析构函数，释放对象时使用
  __repr__ :      打印，转换
  __setitem__ :   按照索引赋值
  __getitem__:    按照索引获取值
  __len__:        获得长度
  __cmp__:        比较运算
  __call__:       调用
  __add__:        加运算
  __sub__:        减运算
  __mul__:        乘运算
  __div__:        除运算
  __mod__:        求余运算
  __pow__:        幂
  https://ltoddy.github.io/essay/2018/05/27/python-magic-methods.html

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

  print(isinstance(obj.func, FunctionType))   # False
  print(isinstance(obj.func, MethodType))    # True

  示例:
  class Foo(object):
      def __init__(self):
          self.name = 'lcg'
   
      def func(self):
          print(self.name)
   
   
  obj = Foo()
  print(obj.func)  # <bound method Foo.func of <__main__.Foo object at 0x000001ABC0F15F98>>
   
  print(Foo.func)  # <function Foo.func at 0x000001ABC1F45BF8>
   
  # ------------------------FunctionType, MethodType------------#
   
   
  from types import FunctionType, MethodType
   
  obj = Foo()
  print(isinstance(obj.func, FunctionType))  # False
  print(isinstance(obj.func, MethodType))  # True
   
  print(isinstance(Foo.func, FunctionType))  # True
  print(isinstance(Foo.func, MethodType))  # False
   
  # ------------------------------------------------------------#
  obj = Foo()
  Foo.func(obj)  # lcg
   
  obj = Foo()
  obj.func()  # lcg
   
  """
  注意：
      方法，无需传入self参数
      函数，必须手动传入self参数
  """

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

  classmethod 必须有一个指向类对象的引用作为第一个参数，而 staticmethod 可以没有任何参数

  class Num:
      # 普通方法：能用Num调用而不能用实例化对象调用   
      def one():  
          print ('1')
   
      # 实例方法：能用实例化对象调用而不能用Num调用
      def two(self):
          print ('2')
   
      # 静态方法：能用Num和实例化对象调用
      @staticmethod 
      def three():  
          print ('3')
   
      # 类方法：第一个参数cls长什么样不重要，都是指Num类本身，调用时将Num类作为对象隐式地传入方法   
      @classmethod 
      def go(cls): 
          cls.three() 
   
  Num.one()          #1
  #Num.two()         #TypeError: two() missing 1 required positional argument: 'self'
  Num.three()        #3
  Num.go()           #3
   
  i=Num()                
  #i.one()           #TypeError: one() takes 0 positional arguments but 1 was given         
  i.two()            #2      
  i.three()          #3
  i.go()             #3 

65. 列举面向对象中的特殊成员以及应用场景

  http://www.cnblogs.com/bainianminguo/p/8076329.html

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

  i = 0
  for x in range(1, 6):
      for y in range(1, 6):
          for z in range(1, 6):
              if (x != y) and (y != z) and (z != x):
                  i += 1
                  if i % 4:
                      print("%d%d%d" % (x, y, z), end=" | ")
                  else:
                      print("%d%d%d" % (x, y, z))
  print(i)

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

  反射就是通过字符串的形式，导入模块；通过字符串的形式，去模块寻找指定函数，并执行。利用字符串的形式去对象（模块）中操作（查找/获取/删除/添加）成员，一种基于字符串的事件驱动！
  https://www.cnblogs.com/vipchenwei/p/6991209.html

68. metaclass作用？以及应用场景？

  metaclass用来指定类是由谁创建的。

  类的metaclass 默认是type。我们也可以指定类的metaclass值。
  http://www.cnblogs.com/0bug/p/8578747.html

69. 用尽量多的方法实现单例模式。

  http://python.jobbole.com/87294/
  http://www.cnblogs.com/0bug/p/8576802.html
  常用方式：
      使用模块
      使用 __new__
      使用装饰器（decorator）
      使用元类（metaclass）

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

  装饰器的应用场景：比如插入日志，性能测试，事务处理，缓存等等场景。
  def outer(func):
      def inner(*args,**kwargs):
          print("认证成功！")
          result = func(*args,**kwargs)
          print("日志添加成功")
          return result
      return inner

  @outer
  def f1(name,age):
      print("%s 正在连接业务部门1数据接口......"%name)

  # 调用方法
  f1("jack",18)
  http://www.cnblogs.com/iyouyue/p/8934547.html

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

  while True:
    try:
        x = int(input("Please enter a number: "))
        break
    except ValueError:
        print("Oops!  That was no valid number.  Try again   ")


  raise主动抛出一个异常
  http://www.runoob.com/python3/python3-errors-execptions.html

72. 什么是面向对象的mro

  mro就是方法解析顺序。
  方法解析顺序Method Resolution Order
  参考：http://www.cnblogs.com/0bug/p/8728570.html#_label8

73. isinstance作用以及应用场景？

  用于判断一个对象是否是一个类或者其子类的实例。
  class A:
      pass
   
   
  class b(A):
      pass
   
   
  class c(b):
      pass
   
   
  bb = b()
   
  print(isinstance(bb, A))  # True
  print(isinstance(bb, b))  # True
  print(isinstance(bb, c))  # False

74. 写代码并实现LeetCode两数之和：

  ## 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:  
    def twoSum(self,nums, target):  
        """ 
        :type nums: List[int] 
        :type target: int 
        :rtype: List[int] 
        """  
        #用len()方法取得nums列表长度  
        n = len(nums)  
        #x从0到n取值（不包括n）  
        for x in range(n):  
            a = target - nums[x]  
            #用in关键字查询nums列表中是否有a  
            if a in nums:  
                #用index函数取得a的值在nums列表中的索引  
                y = nums.index(a)  
                #假如x=y,那么就跳过,否则返回x,y  
                if x == y:  
                    continue  
                else:  
                    return x,y  
                    break  
            else :  
                continue  
  https://blog.csdn.net/linfeng886/article/details/79772348

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"}

  https://www.cnblogs.com/tkqasn/p/6005025.html

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

  在序列化时，中文汉字总是被转换为unicode码，在dumps函数中添加参数ensure_ascii=False即可解决。

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

  python assert断言是声明其布尔值必须为真的判定，如果发生异常就说明表达示为假

  比如我想测试 a==1。就可以用断言。如果我的猜想错误就会抛出异常，可以用于测试一段表达式是否成立。

78. 有用过with statement吗？它的好处是什么？

  with语句适用于对资源进行访问的场合，确保不管使用过程中是否发生异常都会执行必要的“清理”操作，释放资源，比如文件使用后自动关闭、线程中锁的自动获取和释放等。

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

  # 方法一：（不使用os.walk）
  def print_directory_contents(sPath):
      import os

      for sChild in os.listdir(sPath):
          sChildPath = os.path.join(sPath, sChild)
          if os.path.isdir(sChildPath):
              print_directory_contents(sChildPath)
          else:
              print(sChildPath)
              
  # 方法二：（使用os.walk）
  def print_directory_contents(sPath):
      import os
      for root, _, filenames in os.walk(sPath):
          for filename in filenames:
              print(os.path.abspath(os.path.join(root, filename)))


  print_directory_contents('已知路径')

  sPath-- 是你所要便利的目录的地址, 返回的是一个三元组(root,dirs,files)。
      root 所指的是当前正在遍历的这个文件夹的本身的地址
      _ 是一个 list ，内容是该文件夹中所有的目录的名字(不包括子目录)
      filenames 同样是 list , 内容是该文件夹中所有的文件(不包括子目录)   

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