码迷,mamicode.com
首页 > 其他好文 > 详细

面试题

时间:2018-09-25 10:15:13      阅读:217      评论:0      收藏:0      [点我收藏+]

标签:进制   哪些   下划线   转译   java虚拟机   外观   min()   lob   内核   

第一部分 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("\n".join("\t".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. 列举面向对象中带双下划线的特殊方法,如:newinit

  __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关键字。

 

面试题

标签:进制   哪些   下划线   转译   java虚拟机   外观   min()   lob   内核   

原文地址:https://www.cnblogs.com/yangqian007/p/9697710.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!