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

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

2、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代码，十分的方便！

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

字节(byte)： 字节来自英文Byte，习惯上用大写的“B”表示。

字节是计算机中数据处理的基本单位。计算机中以字节为单位存储和解释信息，规定一个字节由八个二进制位构成，即1个字节等于8个比特（1Byte=8bit）。八位二进制数最小为00000000，最大为11111111；通常1个字节可以存入一个ASCII码，2个字节可以存放一个汉字国标码。

4、至少举例5个pep8规范
缩进/空格/注释/命名等
http://blog.sae.sina.com.cn/archives/4781

5、通过代码实现进制转换

二进制转换成十进制：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。

6、请编写一个函数实现将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)

7、python递归的最大层数？？====>998

8、求逻辑运算符的结果

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选后

9、ASCII、Unicode、utf-8、gbk区别？
http://www.cnblogs.com/zhuwenlubin/p/5131026.html

10、字节码和机器码的区别

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

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

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

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

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

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

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

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

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

11、三元运算规则和应用场景？简化if语句

12、举例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

py2: range/xrange
py3: range

py2: int / long
py3: int

7. input/raw_input

py2: yield
py3: yield/yield from

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

13、用一行代码实现数值交换。a, b = b, a

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

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

16、文件操作时，xreadlines和readlines的区别

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

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

18、字符串，列表，元组，字典，集合五个常用方法

• 字符串 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;

19、lambda表达式的格式以及应用场景
省去函数命名的烦恼
http://www.cnblogs.com/guigujun/p/6134828.html

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

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

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

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

23、简述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]

24、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/

25、python的可变数据类型和不可变数据类型
在Python中不可变对象指：一旦创建就不可修改的对象，包括字符串，元组，数字

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

26、求可变数据类型的结果
v = dict.fromkeys(['k1','k2'],[])
v['k1'].append(666)
print(v) # {'k1': [666], 'k2': [666]}
v['k1'] = 777
print(v) # {'k1': 777, 'k2': [666]}

27、求匿名函数的结果
def num():
return[lambda x: i*x for i in range(4)]

print([m(2) for m in num()]) # [6, 6, 6, 6]

28、列举常见的内置函数
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()

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

30、一行代码实现99乘法表
print("\n".join("\t".join(["%s%s=%s" %(x,y,xy) for y in range(1, x+1)]) for x in range(1, 10)) )

31、如何安装第三方模块，以及用过哪些模块

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

32、常见的模块有哪些
re/json/logging/os/sys/requests/beautifulsoup4

33、re模块的match和search的区别
match和search的区别

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

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

35、求结果：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>

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

37、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]了

38、如何实现“1，2，3”变成['1', '2', '3']
list("1,2,3".split(','))

39、如何实现['1', '2', '3']变成[1, 2, 3]
[int(x) for x in ['1','2','3']]

40、比较：a=[1, 2, 3]和b=[(1), (2), (3)]以及b=[(1,), (2,), (3,)]的区别
前两个列表内是int
最后一个列表内是元组

41、用一行代码生成[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
i*i for i in range(1,11)]

42、一行代码实现删除列表重复的值
list(set([1, 2, 3, 4, 45, 1, 2, 343, 2, 2]))

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

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

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

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

45、请用代码实现一个栈

# 后进先出
  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]

46、简述生成器、迭代器、可迭代对象以及应用场景
如果给定一个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

47、用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

48、谈谈对闭包的理解
https://www.cnblogs.com/Lin-Yi/p/7305364.html

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

50、如何生成一个随机数
random.randint(a,b)

51、如何使用Python删除一个文件
删除子目录
os.rmdir( path ) # path: "要删除的子目录"

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

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

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

52、谈谈你对面向对象的理解
从三大特性说起：继承、封装、多态

封装：
起始就是将很多数据封装到一个对象中，类似于把很多东西放到一个箱子中，
如：一个函数如果好多参数，起始就可以把参数封装到一个对象再传递。

  在哪里用过：
    - django rest framework中的request对象。
    - flask中：ctx_context/app_context对象

继承：
如果多个类中都有共同的方法，那么为了避免反复编写，就可以将方法提取到基类中实现，
让所有派生类去继承即可。

  在哪里用过？
    - 视图
    - 版本、认证、分页

多态：
python本身就是多态的，崇尚鸭子模型，只要会呱呱叫的就是鸭子。
def func(arg):
arg.send()
https://www.cnblogs.com/iyouyue/p/8535796.html

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

54、面向对象的深度优先和广度优先是什么
继承顺序
http://www.liujiangblog.com/course/python/44

55、面向对象中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()

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

57、列举面向对象中带双下划线的特殊方法，如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

58、如何判断是函数还是方法
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参数
"""

59、静态方法和类方法区别

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 

60、列举面向对象中的特殊成员和应用场景
http://www.cnblogs.com/bainianminguo/p/8076329.html

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

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

63、metaclass作用以及应用场景
metaclass用来指定类是由谁创建的。

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

64、用尽量多的方法来实现单例模式
http://python.jobbole.com/87294/
http://www.cnblogs.com/0bug/p/8576802.html
常用方式：
使用模块
使用 new
使用装饰器（decorator）
使用元类（metaclass）

65、装饰器的写法和应用场景
装饰器的应用场景：比如插入日志，性能测试，事务处理，缓存等等场景。
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

66、异常处理写法以及如何主动抛出异常和应用场景
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

67、什么是面向对象的mro
mro就是方法解析顺序。
方法解析顺序Method Resolution Order
参考：http://www.cnblogs.com/0bug/p/8728570.html#_label8

68、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

69、写代码并实现LeetCodde两数之和

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

70、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

71、json序列化时，遇到中文默认会转化成Unicode，如果要保留中文怎么做
在序列化时，中文汉字总是被转换为unicode码，在dumps函数中添加参数ensure_ascii=False即可解决。

72、什么是断言，应用场景
python assert断言是声明其布尔值必须为真的判定，如果发生异常就说明表达示为假
比如我想测试 a==1。就可以用断言。如果我的猜想错误就会抛出异常，可以用于测试一段表达式是否成立。

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

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

# 方法一：（不使用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 , 内容是该文件夹中所有的文件(不包括子目录)

75、简述yield和yield from关键字
https://blog.csdn.net/chenbin520/article/details/78111399?locationNum=7&fps=1