第一部分 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) ) # 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() 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) # > print(Foo.func) # # ------------------------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
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关键字。