1、 python多线程有全局解释器锁（global interpreter lock），这种锁意味着解释器只能在任何时候使用一个线程，跟单 cpu跑多个程序一个意思，大家轮流用，叫并发，不是并行。可使用多进程共享数据 multiprocessing.Value和multiprocessing.Array。
如果你的应用程序真的对性能有超严格的要求，比如 100us 对你的应用影响很大，那我必须说，Python 也许不是你的最佳选择。当然，可以理解的是，有时候我们不可避免想暂时放松自己，摆脱它 GIL，例如，在深度学习应用中，大多数代码都是 Python 的。在实际工作中，如果我们想实现一个自定义的微分算子或一个特定硬件的加速器，我们必须使用这些关键性能（performance-critical）代码在 C 实现(不再接受) GIL 限制)，然后提供 Python 调用接口。一般来说，你只需要记住重点，绕过它 GIL 有两种一般的想法：
- 绕过 CPython，使用 JPython（Java 实现的 Python 实现解释器等；
- 将关键性能代码放在其他语言中(通常是 C ）中实现。
2、什么是lambda函数？它有什么好处？ lambda 函数是一种能够接收任何多个参数(包括可选参数)并返回单个表达值的函数。lambda 函数不能包含命令，它们不能包含超过一个表达式。不要试图朝向lambda 函数中插入的东西太多如果你需要更复杂的东西，你应该定义一个普通的函数，然后尽可能长。 3、Python如何转换类型？
①函数描述② int(x [,base ]) 将x转换为整数 ③long(x [,base ]) 将x转换为长整数 ④float(x ) 将x转换为浮点数 ⑤complex(real [,imag ]) 创建复数 ⑥str(x ) 将对象 x 转换为字符串 ⑦repr(x ) 将对象 x 转换为表达式字符串 ⑧eval(str ) 用于计算字符串中的有效性Python表达式，并返回对象 ⑨tuple(s ) 将序列 s 转换为元组 ⑩list(s ) 将序列 s 将其转换为列表 ?chr(x ) 将整数转换为字符 ?unichr(x ) 将整数转换为Unicode字符 ?ord(x ) 将一个字符转换为它的整数 ?hex(x ) 将整数转换为16个制字符串 ?oct(x ) 将整数转换为八进制字符串
4、python多线程与多过程的区别
在UNIX在平台上，当一个过程结束时，过程需要被父亲的过程调用wait，否则，过程将成为僵尸过程(Zombie)。因此，每一个都有必要Process对象调用join()方法 (实际上等同于wait)]]]]]] 。对于多线程来说，因为只有一个过程，所以没有必要。 多过程应避免共享资源。在多线程中，我们可以更容易地共享资源，如使用全球变量或传输参数。在多过程中，上述方法不合适，因为每个过程都有自己独立的内存空间。此时，我们可以共享内存Manager共享资源的方法。 但由于同步的需要，这提高了程序的复杂性，降低了程序的效率。
5、Python如何在里面复制一个对象？ 标准库中的copy模块提供了两种实现复制的方法。一种方法是copy，它返回内容与参数相同的对象。deepcopy对象中的属性也被复制。 6、介绍一下except用法和作用？ Python的except用于捕获所有异常，因为Python每一个错误都会抛出一个异常，所以每个程序的错误都被视为一个操作错误。 7 、Python中pass句子的作用是什么？ pass句子什么都不做，一般作为占位符或创建占位程序，pass句子不会执行任何操作。 8、Python解释器的类型和特点？ Python这是一种解释器语言，代码要想运行，必须通过解释器执行，Python基于不同语言开发的解释器种类繁多。每个解释器都有不同的特点，但可以正常运行Python以下是五种常用代码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代码，很方便！
9.列出布尔值 False的常见值？ 0, [] , () , {} , '' , False , None
每个常用的五种方法是字符串、列表、元组和字典？ 字符串：repleace,strip,split,reverse,upper,lower,join... 列表：append,pop,,remove,sort,count,index... 元组：index,count,__len__(),__dir__() 字典：get,keys,values,pop,popitems,clear,,items...
11、lambda表达格式和应用场景？ 表达式格式：lambda后面是一个或多个参数，后面是一个冒号，后面是一个表达式。冒号前是参数，冒号后是例如:lambda x : 2x
应用场景：常与一些内置函数相结合，如 map(),filter(),sorted(),reduce()等 12、pass的作用？ ①空语句do nothing； ②确保格式完整； ③确保语义完整。
13、arg和 *kwarg作用？ 通用参数解决了函数参数不固定的问题 *arg：将位置参数转换为tuple **kwarg：将关键字参数转化为关键字参数dict
14、is和==的区别？
is:判断内存地址是否相等； ==：判断值是否相等。 15、简述Python深度复制和应用场景？ copy()：浅copy，浅拷贝是指只复制数据集的第一层数据 deepcopy():深copy,深度复制是指复制数据集的所有层
16、Python垃圾回收机制？ python辅以引用计数机制、标记清除和分代收集（分代回收和分代回收）两种机制的策略 计数机制： Python的GC该模块主要使用引用计数来跟踪和回收垃圾。在引用计数的基础上，也可以标记-清除 解决容器对象可能产生的循环引用问题。通过分代回收利用空间换取时间，进一步提高垃圾回收效率。 标记-清除： 标记-清除的出现打破了循环引用，即只关注可能产生循环引用的对象。 缺点：该机制带来的额外操作与需要回收的内存块成正比。代际回收：
原理：根据系统中的存活时间，将系统中的所有内存块分为不同的集合，每一集都成为代，随着代生存时间的增加，垃圾收集的频率降低。也就是说，活得越久，垃圾就越不可能，应降低垃圾收集频率。那么如何衡量这个生存时间:通常用几个垃圾收集动作来衡量，如果一个对象收集的垃圾越多，可以得出这个对象存活的时间就越长。
17、python的可变类型和不可变类型？ 不可变类型(数字、字符串、元组、不可变集合)；可变类型(列表、字典、可变集合)。 18、Python里面search()和match()的区别？ match()只检测函数RE是不是在string匹配开始位置，search()扫描整个 string查找匹配, 也就是说match() 只有在0位始位置匹配成功，只有在0位置匹配成功，match()就返回none 19、用Python匹配HTML tag的时候，<.>和<.?>有什么区别？ 前者是贪婪的匹配，会从头到尾匹配 xyz，而后者是非贪婪匹配，只匹配到第一个 >。 20、Python如何在里面生成随机数？ import random； random.random()；
2021年最新Python面试题及答案 1、Python如何在里面复制一个对象？(赋值、浅拷贝、深拷贝的区别) 答：赋值（），就是创建了对象的一个新的引用，修改其中任意一个变量都会影响到另一个。 浅拷贝：创建一个新的对象，但它包含的是对原始对象中包含项的引用（如果用引用的方式修改其中一个对象，另外一个也会修改改变）{1,完全切片方法；2，工厂函数，如list()；3，copy模块的copy()函数} 深拷贝：创建一个新的对象，并且递归的复制它所包含的对象（修改其中一个，另外一个不会改变）{copy模块的()函数} 2、Python里面match()和search()的区别？ 答：re模块中match(pattern,string[,flags]),检查string的开头是否与pattern匹配。 re模块中research(pattern,string[,flags]),在string搜索pattern的第一个匹配值。
print(‘super’, ‘superstition’).span()) (0, 5) print(‘super’, ‘insuperable’)) None print(‘super’, ‘superstition’).span()) (0, 5) print(‘super’, ‘insuperable’).span()) (2, 7) 3、有没有一个工具可以帮助查找python的bug和进行静态的代码分析？ 答：PyChecker是一个python代码的静态分析工具，它可以帮助查找python代码的bug, 会对代码的复杂度和格式提出警告 Pylint是另外一个工具可以进行codingstandard检查 4、简要描述Python的垃圾回收机制（garbage collection）。 答案 这里能说的很多。你应该提到下面几个主要的点： Python在内存中存储了每个对象的引用计数（reference count）。如果计数值变成0，那么相应的对象就会小时，分配给该对象的内存就会释放出来用作他用。 偶尔也会出现引用循环（reference cycle）。垃圾回收器会定时寻找这个循环，并将其回收。举个例子，假设有两个对象o1和o2，而且符合 == o2和 == o1这两个条件。如果o1和o2没有其他代码引用，那么它们就不应该继续存在。但它们的引用计数都是1。 Python中使用了某些启发式算法（heuristics）来加速垃圾回收。例如，越晚创建的对象更有可能被回收。对象被创建之后，垃圾回收器会分配它们所属的代（generation）。每个对象都会被分配一个代，而被分配更年轻代的对象是优先被处理的。 5、什么是lambda函数？它有什么好处? 答：lambda 表达式，通常是在需要一个函数，但是又不想费神去命名一个函数的场合下使用，也就是指匿名函数 lambda函数：首要用途是指点短小的回调函数 lambda [arguments]:expression a=lambdax,y:x+y a(3,11) 6、请写出一段Python代码实现删除一个list里面的重复元素 答： 1,使用set函数，set(list) 2，使用字典函数， a=[1,2,4,2,4,5,6,5,7,8,9,0] b={} b=(a) c=list()) c 7、用Python匹配HTML tag的时候，<.>和<.?>有什么区别？ 答：术语叫贪婪匹配( <.> )和非贪婪匹配(<.?> ) 例如: test <.> : test <.?> : 8、如何在一个function里面设置一个全局的变量？ 答：解决方法是在function的开始插入一个global声明： def f() global x 9、编程用sort进行排序，然后从最后一个元素开始判断 a=[1,2,4,2,4,5,7,10,5,5,7,8,9,0,3] () last=a[-1] for i inrange(len(a)-2,-1,-1): if last==a[i]: del a[i] else:last=a[i] print(a) 10、下面的代码在Python2中的输出是什么？解释你的答案 def div1(x,y): print “%s/%s = %s” % (x, y, x/y)
def div2(x,y): print "%s2) div2(5,2) div2(5.,2.) 另外，在Python3中上面的代码的输出有何不同(假设代码中的print语句都转化成了Python3中的语法结构)？ 在Python2中，代码的输出是： 5/2 = 2 2 = 52结果是 注意你可以通过下面的import语句来覆盖Python2中的这一行为 from future import division 还要注意“双斜杠”(//)操作符将会一直执行整除，忽略操作数的类型。这就是为什么/即使在Python2中结果也是 但是在Python3并没有这一行为。两个操作数都是整数时，也不执行整数运算。在Python3中，输出如下： 5/2 = 2 = 5//2 = 2 / =
Python基础知识笔试 一、单选题（2.5分*20题）
下列哪个表达式在Python中是非法的？ B 1 A. x = y = z = 1 B. x = (y = z + 1) C. x, y = y, x D. x += y 2. python my.py v1 v2 命令运行脚本，通过 from sys import argv如何获得v2的参数值? C A. argv[0] B. argv[1] C. argv[2] D. argv[3] 3. 如何解释下面的执行结果? B print 1.2 - 1.0 == 0.2 False A. Python的实现有错误 B. 浮点数无法精确表示 C. 布尔运算不能用于浮点数比较 D. Python将非0数视为False 4. 下列代码执行结果是什么? D x = 1 def change(a): x+= 1 print x change(x) A. 1 B. 2 C. 3 D. 报错 5. 下列哪种类型是Python的映射类型？ D A. str B. list C. tuple D. dict 6. 下述字符串格式化语法正确的是？ D A. ‘GNU’s Not %d %%’ % ‘UNIX’ B. ‘GNU’s Not %d %%’ % ‘UNIX’ C. ‘GNU’s Not %s %%’ % ‘UNIX’ D. ‘GNU’s Not %s %%’ % ‘UNIX’ 7. 在Python 2.7中，下列哪种是Unicode编码的书写方式?C A. a = ‘中文’ B. a = r‘中文’ C. a = u’中文’ D. a = b’中文’ 8. 下列代码的运行结果是？ D print ‘a’ < ‘b’ < ‘c’ A. a B. b C. c D. True E. False 9. 下列代码运行结果是？ C a = ‘a’ print a > ‘b’ or ‘c’ A. a B. b C. c D. True E. False 10. 下列哪种不是Python元组的定义方式？ A A. (1) B. (1, ) C. (1, 2) D. (1, 2, (3, 4)) 11. a与b定义如下，下列哪个是正确的？ B a = ‘123’ b = ‘123’ A. a != b B. a is b C. a == 123 D. a + b = 246 12. 下列对协程的理解错误的是？ D A. 一个线程可以运行多个协程 B. 协程的调度由所在程序自身控制 C. Linux中线程的调度由操作系统控制 D. Linux中协程的调度由操作系统控制 13. 下列哪种函式参数定义不合法? C A. def myfunc(*args): B. def myfunc(arg1=1): C. def myfunc(*args, a=1): D. def myfunc(a=1, args): 14. 下列代码执行结果是？ A [ii for i in xrange(3)] A. [1, 1, 4] B. [0, 1, 4] C. [1, 2, 3] D. (1, 1, 4) 15. 一个段代码定义如下，下列调用结果正确的是？A def bar(multiple): def foo(n): return multiple ** n return foo A. bar(2)(3) == 8 B. bar(2)(3) == 6 C. bar(3)(2) == 8 D. bar(3)(2) == 6 16. 下面代码运行结果？ C a = 1 try: a += 1 except: a += 1 else: a += 1 finally: a += 1 print a A. 2 B. 3 C. 4 D. 5 17. 下面代码运行后，a、b、c、d四个变量的值，描述错误的是？ D import copy a = [1, 2, 3, 4, [‘a’, ‘b’]] b = a c = copy.copy(a) d = copy.deepcopy(a) a.append(5) a[4].append(‘c’) A. a == [1,2, 3, 4, [‘a’, ‘b’, ‘c’], 5] B. b == [1,2, 3, 4, [‘a’, ‘b’, ‘c’], 5] C. c == [1,2, 3, 4, [‘a’, ‘b’, ‘c’]] D. d == [1,2, 3, 4, [‘a’, ‘b’, ‘c’]] 18. 有如下函数定义，执行结果正确的是？ A def dec(f): n = 3 def wrapper(*args,**kw): return f(*args,**kw) * n return wrapper
@dec def foo(n): return n * 2 A. foo(2) == 12 B. foo(3) == 12 C. foo(2) == 6 D. foo(3) == 6 19. 有如下类定义，下列描述错误的是？ D class A(object): pass
class B(A): pass
b = B() A. isinstance(b, A) == True B. isinstance(b, object) == True C. issubclass(B, A) == True D. issubclass(b, B) == True 20. 下列代码运行结果是？ C a = map(lambda x: x**3, [1, 2, 3]) list(a) A. [1, 6, 9] B. [1, 12, 27] C. [1, 8, 27] D. (1, 6, 9) 二、多选题（5分5题） 21. Python中函数是对象，描述正确的是? ABCD A. 函数可以赋值给一个变量 B. 函数可以作为元素添加到集合对象中 C. 函数可以作为参数值传递给其它函数 D. 函数可以当做函数的返回值 22. 若 a = range(100)，以下哪些操作是合法的? ABCD A. a[-3] B. a[2:13] C. a[::3] D. a[2-3] 23. 若 a = (1, 2, 3)，下列哪些操作是合法的? ABD A. a[1:-1] B. a3 C. a[2] = 4 D. list(a) 24. Python中单下划线_foo与双下划线__foo与__foo__的成员，下列说法正确的是？ABC A. _foo 不能直接用于’from module import ’ B. __foo解析器用_classname__foo来代替这个名字，以区别和其他类相同的命名 C. __foo__代表python里特殊方法专用的标识 D. __foo 可以直接用于’from module import ’ 25. __new__和__init__的区别，说法正确的是？ ABCD A. new__是一个静态方法，而__init__是一个实例方法 B. new__方法会返回一个创建的实例，而__init__什么都不返回 C. 只有在__new__返回一个cls的实例时，后面的__init__才能被调用 D. 当创建一个新实例时调用__new，初始化一个实例时用__init 三、填空题（5分5题） 26. 在Python 2.7中，执行下列语句后，显示结果是什么？ 答：0 0.5 from future importdivision print 1//2, 1/2 27. 在Python 2.7中，执行下列语句后的显示结果是什么? 答：none 0 a = 1 b = 2 * a / 4 a = “none” print a,b 28. 下列语句执行结果是什么? 答：[1, 2, 3, 1, 2, 3, 1, 2, 3] a = [1, 2, 3] print a3 29. 下列语句的执行结果是什么？ 答：3 a = 1 for i in range(5): if i == 2: break a += 1 else: a += 1 print a 30. 下列代码的运行结果是多少？ 答：4 def bar(n): m = n while True: m += 1 yield m b = bar(3) print b.next()
附录：Python常见面试题精选 一、 基础知识（7题） 题01：Python中的不可变数据类型和可变数据类型是什么意思？ 难度： ★☆☆☆☆【参考答案】 不可变数据类型是指不允许变量的值发生变化，如果改变了变量的值，相当于是新建了一个对象，而对于相同的值的对象，在内存中则只有一个对象（一个地址）。数值型、字符串string和元组tuple都属于不可变数据类型。 可变数据类型是指允许变量的值发生变化，即如果对变量执行append、+=等操作，只会改变变量的值，而不会新建一个对象，变量引用的对象的地址也不会变化。不过对于相同的值的不同对象，在内存中会存在不同的对象，即每个对象都有自己的地址，相当于内存中对于同值的对象保存了多份，这里不存在引用计数，是实实在在的对象。列表list和字典dict都属于可变数据类型。 题02：请简述Python中is和==的区别。 难度：★★☆☆☆ 【参考答案】 Python中的对象包含三个要素：id、type和value。is比较的是两个对象的id。==比较的是两个对象的value。 题03：请简述function(args, **kwargs)中的 args, kwargs分别是什么意思？ 难度：★★☆☆☆ 【参考答案】 *args和kwargs主要用于函数定义的参数。Python语言允许将不定数量的参数传给一个函数，其中args表示一个非键值对的可变参数列表，kwargs则表示不定数量的键值对参数列表。注意：*args和kwargs可以同时在函数的定义中，但是args必须在**kwargs前面。 题04：请简述面向对象中__new__和__init__的区别。 难度： ★★★☆☆【参考答案】 （1）__new__至少要有一个参数cls，代表当前类，此参数在实例化时由Python解释器自动识别。
（2） __new__返回生成的实例，可以返回父类（通过super(当前类名, cls)的方式）__new__出来的实例， 1 或者直接是对象的__new__出来的实例。这在自己编程实现__new__时要特别注意。 （3） __init__有一个参数self，就是这个__new__返回的实例，__init__在__new__的基础上可以完成一 些其它初始化的动作，init__不需要返回值。 （4） 如果__new__创建的是当前类的实例，会自动调用__init，通过返回语句里面调用的__new__函 数的第一个参数是cls来保证是当前类实例，如果是其他类的类名，那么实际创建并返回的就是其他类的实例，也就不会调用当前类或其他类的__init__函数。 题05：Python子类继承自多个父类时，如多个父类有同名方法，子类将继承自哪个方法？ 难度：★☆☆☆☆
【参考答案】 1 Python语言中子类继承父类的方法是按照继承的父类的先后顺序确定的，例如，子类A继承自父类B、C，且B、C中具有同名方法Test()，那么A中的Test()方法实际上是继承自B中的Test()方法。 题06：请简述Python中如何避免死锁？ 难度：★☆☆☆☆
【参考答案】 1 死锁是指不同线程获取了不同的锁，但是线程间又希望获取对方的锁，双方都在等待对方释放锁，这种相互等待资源的情况就是死锁。Python语言可以使用threading.Condition对象，基于条件事件通知的形式去协调线程的运行，即可避免死锁。 题07：什么是排序算法的稳定性？常见的排序算法如冒泡排序、快速排序、归并排序、堆排 序、Shell排序、二叉树排序等的时间、空间复杂度和稳定性如何？ 难度：★★★☆☆
【参考答案】 1 假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。 常见排序算法的时间、空间复杂度和稳定性如下表所示。
*基数排序的复杂度中，r表示关键字的基数，d表示长度，n表示关键字的个数。
二、 字符串与数字（7题） 题08：字符串内容去重并按字母顺序排列。 难度：★☆☆☆☆ 令 s = “hfkfdlsahfgdiuanvzx”，试对 s 去重并按字母顺序排列输出 “adfghiklnsuvxz”。 【参考答案】
s = "hfkfdlsahfgdiuanvzx" s = list(set(s)) s.sort(reverse=False) print("".join(s))
1 2 3 4 题09：判断两个字符串是否同构。 难度：★★☆☆☆ 字符串同构是指字符串s中的所有字符都可以替换为t中的所有字符。在保留字符顺序的同时，必须用另一个字符替换所有出现的字符。不能将s中的两个字符映射到t中同一个字符，但字符可以映射到自身。试判定给定的字符串s和t是否同构。 例如： s = “add” t = “apple” 输出 False s = “paper” t = “title” 输出 True 【参考答案】
print(len(set(s)) == len(set(t)) == len(set(zip(s, t))))
1 2 题10：使用Lambda表达式实现将IPv4的地址转换为int型整数。 难度：★★★☆☆ 例如：ip2int(“192.168.3.5”) 输出： 3232236293
【参考答案】
ip2int = lambda x:sum([256**j*int(i) for j,i in enumerate(x.split('.')[::-1])]) 1 2 题11：罗马数字使用字母表示特定的数字，试编写函数romanToInt()，输入罗马数字字符 串，输出对应的阿拉伯数字。 难度：★★★☆☆
【参考答案】 罗马数字中字母与阿拉伯数字的对应关系如下： M:1000，CM:900，D:500，CD:400，C:100，XC:90，L:50，XL: 40，X:10，IX:9，V:5，VI:4，I:1
def romanToInt(s): table = {'M':1000, 'CM':900, 'D':500, 'CD':400, 'C':100, 'XC':90, 'L':50, 'XL': 40, 'X':10, 'IX':9, 'V':5, 'VI':4, 'I':1} result = 0 for i in range(len(s)): if i > 0 and table[s[i]] > table[s[i-1]]: result += table[s[i]] result -= 2 * table[s[i-1]] else: result += table[s[i]] return result 1 2 3 4 5 题12：判断括号是否成对。 难度：★★★☆☆ 给定一个只包含字符“(”“)”“{”“}”“[”和“]”的字符串，试编写函数isParenthesesValid()，输入该字符串，确定输入的字符串是否有效。括号必须以正确的顺序关闭，例如“()”和“()[]{}”都是有效的，但“(]”和“([]]”不是。 【参考答案】
def isParenthesesValid(s): pars = [None] parmap = {')': '(', '}': '{', ']': '['} for c in s: if c in parmap: if parmap[c] != pars.pop(): return False else: pars.append(c) return len(pars) == 1 1 2 3 4 5 题13：编写函数输出count-and-say序列的第n项。 难度：★★★★☆ count-and-say序列是一个整数序列，其前五个元素如下： 1 11 21
1211 111221 1 1读作“1”或11。11读作“两个1”或21。21读作“一个2，然后一个1”或1211。即下一项是将上一项“读出来”再写成数字。 试编写函数CountAndSay(n)，输出count-and-say序列的第n项。 【参考答案】
def CountAndSay(n): ans = "1" n -= 1 while n > 0: res = "" pre = ans[0] count = 1 for i in range(1, len(ans)): if pre == ans[i]: count += 1 else: res += str(count) + pre pre = ans[i] count = 1 res += str(count) + pre ans = res
n -= 1 return ans 1 2 3 4 5 6 7 题14：不使用sqrt
函数，试编写squareRoot()函数，输入一个正数，输出它的平方根的整 1 数部分 难度：★★★★☆ 【参考答案】
def squareRoot(x): result = 1.0 while abs(result * result - x) > 0.1: result = (result + x / result) / 2 return int(result) 1 2 3 三、 正则表达式（4题） 题15：请写出匹配中国大陆手机号且结尾不是4和7的正则表达式。 难度：★☆☆☆☆ 【参考答案】
import re 1 tels = [“159********”, “14456781234”, “12345678987”, “11444777”] for tel in tels: print(“Valid”) if (re.match(r"1\d{9}[0-3,5-6,8-9]", tel) != None) else print(“Invalid”) 题16：请写出以下代码的运行结果。 难度：★★☆☆☆
import re
str = '<div class="nam">中国</div>' res = re.findall(r'<div class=".*">(.*?)</div>',str) print(res) 1 2 3 4 结果如下： 【参考答案】 1 ['中国 '] 题17：请写出以下代码的运行结果。 难度：★★★☆☆
import re
match = re.compile('www\....?').match("www.baidu.com") if match: print(match.group()) else: print("NO MATCH") 1 2 3 4 5 【参考答案】 www.bai 题18：请写出以下代码的运行结果。 难度：★★☆☆☆
import re example = "<div>test1</div><div>test2</div>" Result = re.compile("<div>.*").search(example) print("Result = %s" % Result.group()) 1 2 3 4 【参考答案】 Result =
test1 test2 四、 列表、字典、元组、数组、矩阵（9题） 1 题19：使用递推式将矩阵转换为一维向量。 难度：★☆☆☆☆ 使用递推式将 [[ 1, 2 ], [ 3, 4 ], [ 5, 6 ]] 转换为
[1, 2, 3, 4, 5, 6]。 【参考答案】 a = [[1, 2], [3, 4], [5, 6]] print([j for i in a for j in i]) 1 2 题20：写出以下代码的运行结果。 难度：★★★★☆
def testFun():
temp = [lambda x : i*x for i in range(5)] return temp for everyLambda in testFun(): print (everyLambda(3)) 1 2 3 4 5 6 7 8 结果如下： 【参考答案】
12 12 12 12 12 1 题21：编写Python程序，打印星号金字塔。 难度：★★★☆☆ 编写尽量短的Python程序，实现打印星号金字塔。例如n=5时输出以下金字塔图形：
* *** ***** ******* ********* 1 2 3 4 5 参考代码如下： 【参考答案】
n = 5 for i in range(1,n+1): print(' '*(n-(i-1))+'*'*(2*i-1)) 1 2 3 题22：获取数组的支配点。 难度：★★★☆☆ 支配数是指数组中某个元素出现的次数大于数组元素总数的一半时就成为支配数，其所在下标称为支配点。编写Python
函数FindPivot(li)，输入数组，输出其中的支配点和支配数，若数组中不存在支配数，输出None。 1 例如：[3,3,1,2,2,1,2,2,4,2,2,1,2,3,2,2,2,2,2,4,1,3,3]中共有23个元素，其中元素2出现了12次，其支配点和支配数组合是(18, 2)。 【参考答案】
def FindPivot(li): mid = len(li)/2 for l in li: count = 0 i = 0 mark = 0 while True: if l == li[i]: count += 1 temp = i i += 1 if count > mid: mark = temp return (mark, li[mark]) if i > len(li) - 1: break 1 2 3 题23：将函数按照执行效率高低排序 难度：★★★☆☆ 有如下三个函数，请将它们按照执行效率高低排序。
def S1(L_in): l1 = sorted(L_in) l2 = [i for i in l1 if i<0.5] return [i*i for i in l2]
def S2(L_in): l1 = [i for i in L_in if i<0.5] l2 = sorted(l1) return [i*i for i in l2] def S3(L_in): l1 = [i*i for i in L_in] l2 = sorted(l1) return [i for i in l2 if i<(0.5*0.5)] 1 2 3 4 5 6 7 8 9 10 11 12 13 【参考答案】 使用cProfile库即可测试三个函数的执行效率：
import random import cProfile L_in = [random.random() for i in range(1000000)] cProfile.run('S1(L_in)') cProfile.run('S2(L_in)') cProfile.run('S3(L_in)') 1 2 3 从结果可知，执行效率从高到低依次是S2、S1、S3。 题24：螺旋式返回矩阵的元素 难度：★★★★★ 给定m×n个元素的矩阵（m行，n列），编写Python
函数spiralOrder(matrix)，以螺旋顺序返回矩阵的所有元素。 1 例如，给定以下矩阵： [[ 1, 2, 3 ], [ 4, 5, 6 ], [ 7, 8, 9 ]] 应该返回[1,2,3,6,9,8,7,4,5] 【参考答案】
def spiralOrder(matrix): if len(matrix) == 0 or len(matrix[0]) == 0: return [] ans = [] left, up, down, right = 0, 0, len(matrix) - 1, len(matrix[0]) - 1 while left <= right and up <= down: for i in range(left, right + 1): ans += matrix[up][i], up += 1 for i in range(up, down + 1): ans += matrix[i][right], right -= 1 for i in reversed(range(left, right + 1)): ans += matrix[down][i], down -= 1 for i in reversed(range(up, down + 1)): ans += matrix[i][left], left += 1 return ans[:(len(matrix) * len(matrix[0]))] 1 2 3 4 5 6 7 题25：矩阵重整 难度：★★★★☆
对于一个给定的二维数组表示的矩阵，以及两个正整数r和c，分别表示所需重新整形矩阵的行数和列数。reshape函数生成一个新的矩阵，并且将原矩阵的所有元素以与原矩阵相同的行遍历顺序填充进去，将该矩阵重新整形为一个不同大小的矩阵但保留其原始数据。对于给定矩阵和参数的reshape操作是可以完成且合法的，则输出新的矩阵；否则，输出原始矩阵。请使用Python语言实现reshape函数。 例如：
输入 1 2 3 4 5 6 r, c 输出
说明
nums = [[1,2], [3,4]] r = 1，c = 4 [[1,2,3,4]] 行遍历的是[1,2,3,4]。新的重新形状矩阵是1 * 4矩阵，使用前面的列表逐行填充。 nums = [[1,2], [3,4]] r = 2，c = 4 [[1,2], [3,4]] 无法将2 * 2矩阵重新整形为2 * 4矩阵。所以输出原始矩阵。 注意：给定矩阵的高度和宽度在[1,100]范围内。给定的r和c都是正数。 【参考答案】
def matrixReshape(nums, r, c): """ if r * c != len(nums) * len(nums[0]): return nums m = len(nums) n = len(nums[0]) ans = [[0] * c for _ in range(r)] for i in range(r * c): ans[i / c][i % c] = nums[i / n][i % n] return ans 1 2 3 4 题26：查找矩阵中第k个最小元素。 难度：★★★★☆ 给定n×n矩阵，其中每行每列元素均按升序排列，试编写Python函数kthSmallest(matrix, k)，找到矩阵中的第k个最小元素。 注意：查找的是排序顺序中的第k个最小元素，而不是第k个不同元素。 例如： 矩阵= [[1,5,9], [10,11,13], [12,13,15]] k = 8，应返回13。
【参考答案】 1 import heapq def kthSmallest(matrix, k): visited = {(0, 0)} heap = [(matrix[0][0], (0, 0))] while heap: val, (i, j) = heapq.heappop(heap) k -= 1 if k == 0: return val if i + 1 < len(matrix) and (i + 1, j) not in visited: heapq.heappush(heap, (matrix[i + 1][j], (i + 1, j))) visited.add((i + 1, j)) if j + 1 < len(matrix) and (i, j + 1) not in visited: heapq.heappush(heap, (matrix[i][j + 1], (i, j + 1))) visited.add((i, j + 1)) 1 2 3 4 5 6 7 8 9 10 题27：试编写函数largestRectangleArea()，求一幅柱状图中包含的最大矩形的面积。 难度：★★★★★ 例如对于下图：
输入：[2,1,5,6,2,3] 输出：10 【参考答案】
def largestRectangleArea(heights): stack=[] i=0 area=0 while i<len(heights):
if stack==[] or heights[i]>heights[stack[len(stack)-1]]: # 递增直接入栈 stack.append(i) else: # 不递增开始弹栈 curr=stack.pop() if stack == []: width = i else: width = i-stack[len(stack)-1]-1 area=max(area,width*heights[curr]) i-=1 i+=1 while stack != []: curr = stack.pop() if stack == []: width = i else: width = len(heights)-stack[len(stack)-1]-1 area = max(area,width*heights[curr]) return area 1 2 3 4 5 6 7 8 9 五、 设计模式（3
题） 1 题28：使用Python语言实现单例模式。 难度：★★★☆☆
【参考答案】
class Singleton(object): def __new__(cls, *args, **kw): if not hasattr(cls, '_instance'): orig = super(Singleton, cls) cls._instance = orig.__new__(cls, *args, **kw) return cls._instance 1 2 3 题29：使用Python语言实现工厂模式。 难度：★★★★☆ 编写适当的Python程序，完成以下功能： 1. 定义基类Person，含有获取名字，性别的方法。 2. 定义Person类的两个子类Male和Female，含有打招呼的方法。 3. 定义工厂类，含有getPerson方法，接受两个输入参数：名字和性别。 4. 用户通过调用getPerson方法使用工厂类。 【参考答案】
class Person: def __init__(self): self.name = None self.gender = None def getName(self): return self.name def getGender(self): return self.gender class Male(Person): def __init__(self, name): print("Hello Mr." + name) class Female(Person): def __init__(self, name): print("Hello Miss." + name) class Factory: def getPerson(self, name, gender): if(gender == 'M'): return Male(name) if(gender == 'F'): return Female(name) if __name__ == '__main__': factory = Factory() person = factory.getPerson("Huang", "M") 1 2 3 4 5 6 7 8 9 10 11 12 题30：使用Python语言实现观察者模式。 难度：★★★★★ 给定一个数字，现有的默认格式化显示程序以十进制格式显示此数字。请编写适当的Python程序，实现支持添加（注册）更多的格式化程序（如添加一个十六进制格式化程序和一个二进制格式化程序）。每次数值更新时，已注册的程序就会收到通知，并显示更新后的值。 【参考答案】
import itertools class Publisher: def __init__(self): self.observers = set() def add(self, observer, *observers): for observer in itertools.chain((observer, ), observers): self.observers.add(observer) observer.update(self) def remove(self, observer): try: self.observers.discard(observer) except ValueError: print('移除 {} 失败!'.format(observer)) def notify(self): [observer.update(self) for observer in self.observers] class DefaultFormatter(Publisher): def __init__(self, name): Publisher.__init__(self) self.name = name self._data = 0 def __str__(self): return "{}: '{}' 的值 = {}".format(type(self).__name__, self.name, self._data) @property def data(self): return self._data @data.setter def data(self, new_value): try: self._data = int(new_value) except ValueError as e: print('错误: {}'.format(e)) else: self.notify() class HexFormatter: def update(self, publisher): print("{}: '{}' 的十六进制值 = {}".format(type(self).__name__, publisher.name, hex(publisher.data))) class BinaryFormatter: def update(self, publisher): print("{}: '{}' 的二进制值 = {}".format(type(self).__name__, publisher.name, bin(publisher.data))) def main(): df = DefaultFormatter('test1') print(df) hf = HexFormatter() df.add(hf) df.data = 37 print(df) bf = BinaryFormatter() df.add(bf) df.data = 23 print(df) df.remove(hf) df.data = 56 print(df) df.remove(hf) df.add(bf) df.data = 'hello' print(df) df.data = 7.2 print(df) if __name__ == '__main__': main() 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 六、 树、二叉树、图（5题） 题31：使用Python编写实现二叉树前序遍历的函数preorder(root, res=[])。 难度：★★☆☆☆ 【参考答案】
def preorder(root, res=[]): if not root: return res.append(root.val) preorder(root.left,res) preorder(root.right,res) return res 1 2 题32：使用Python实现一个二分查找函数。 难度：★★★☆☆
【参考答案】
def binary_search(num_list, x): num_list = sorted(num_list) left, right = 0, len(num_list) - 1 while left <= right: mid = (left + right) // 2 if num_list[mid] > x: right = mid - 1 elif num_list[mid] < x: left = mid + 1 else: return '待查元素{0}在排序后列表中的下标为： {1}'.format(x, mid) return '待查找元素%s不存在指定列表中' %x 题 1 2 3 4 5 6 33：编写Python函数maxDepth()，实现获取二叉树root最大深度。 1 难度：★★★★☆ 【参考答案】
def maxDepth(self, root): if root == None: return 0 return max(self.maxDepth(root.left),self.maxDepth(root.right))+1 1 2 题34：输入两棵二叉树Root1、Root2，判断Root2是否Root1的子结构（子树）。 难度：★★★★☆ 【参考答案】
class TreeNode: def __init__(self, x): self.val = x self.left = None self.right = None def istree(pRoot1, pRoot2): if not pRoot2: return True if not pRoot1 and pRoot2: return False if pRoot1.val != pRoot2.val: return False elif pRoot1.val == pRoot2.val: return istree(pRoot1.left, pRoot2.left) and istree(pRoot1.right, pRoot2.right) def HasSubtree(pRoot1, pRoot2): if not pRoot1 or not pRoot2: return False if pRoot1.val == pRoot2.val: return istree(pRoot1, pRoot2) else: return HasSubtree(pRoot1.left, pRoot2) or HasSubtree(pRoot1.right, pRoot2) 1 2 3 4 5 6 7 8 9 10 11 题35：判断数组是否某棵二叉搜索树后序遍历的结果。 难度：★★★★☆ 编写函数VerifySquenceOfBST(sequence)，实现以下功能：输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出True,否则输出False。假设输入数组的任意两个数字都互不相同。 【参考答案】
def VerifySquenceOfBST(sequence): if not sequence: return False i= 0 for i in range(len(sequence)-1): if sequence[i]>sequence[-1]: break if i < len(sequence)-2: for j in range(i+1,len(sequence)-1): if sequence[j]<sequence[-1]: return False left = True right = True if i>0: left = VerifySquenceOfBST(sequence[:i]) elif i< len(sequence)-2: right = VerifySquenceOfBST(sequence[i:-1]) return left and right 1 2 3 4 5 6 7 8 9 10 11 12 13 14 七、 文件操作（3题） 题36：计算test.txt中的大写字母数。 难度：★☆☆☆☆ 【参考答案】
import os os.chdir('D:\\') with open('test.txt') as test: count = 0 for i in test.read(): if i.isupper(): count+=1 print(count) 1 2 3 4 题37：补全缺失的代码。 难度：★★☆☆☆ def print_directory_contents(sPath): # 补充该函数的实现代码 print_directory_contents()函数接受文件夹路径名称作为输入参数，返回其中包含的所有子文件夹和文件的完整路径。 【参考答案】
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) 1 2 3 4 5 题38：设计内存中的文件系统。 难度：★★★★☆ 使用Python语言设计内存中的文件系统，实现以下命令。 ls：给定字符串格式的路径。如果是文件路径，则返回仅包含此文件名称的列表。如果是目录路径，则返回此目录中的文件和目录名称列表。输出结果（文件和目录名称）应按字典顺序排列。 mkdir：如果目录路径不存在，则应根据路径创建新目录。如果路径中的中间目录也不存在，则也应该创建它们。此函数具有void返回类型。 注： 可以假设所有文件或目录路径都是以/开头并且不以/结尾的绝对路径，除了路径只是“/”。 可以假设所有操作都将传递有效参数，用户不会尝试检索文件内容或列出不存在的目录或文件。 可以假设所有目录名称和文件名只包含小写字母，并且同一目录中不存在相同的名称。
【参考答案】
class FileNode(object): def __init__(self, name): self.isFolder = True self.childs = {} self.name = name self.data = "" class FileSystem(object): def __init__(self): self.root = FileNode("/") def ls(self, path): fd = self.lookup(path, False) if not fd: return [] if not fd.isFolder: return [fd.name] files = [] for file in fd.childs: files.append(file) files.sort() return files def lookup(self, path, isAutoCreate): path = path.split("/") p = self.root for name in path: if not name: continue if name not in p.childs: if isAutoCreate: p.childs[name] = FileNode(name) else: return None p = p.childs[name] return p def mkdir(self, path): self.lookup(path, True) # 测试 obj = FileSystem() obj.mkdir("/test/path") obj.ls("/test")
1 2 3 4 5 6 7 8 9 10 11 12 13 14 八、 网络编程（4题） 1 题39：请至少说出三条TCP和UDP协议的区别。 难度：★★☆☆☆
【参考答案】 （1） TCP面向连接（如打电话要先拨号建立连接）；UDP是无连接的，即发送数据之前不需要建立连 接。 （2） TCP提供可靠的服务。也就是说，通过TCP连接传送的数据，无差错，不丢失，不重复，且按序 到达；UDP尽最大努力交付，即不保证可靠交付。 （3） TCP面向字节流，实际上是TCP把数据看成一连串无结构的字节流；UDP是面向报文的，UDP没 有拥塞控制，因此网络出现拥塞不会使源主机的发送速率降低（对实时应用很有用，如IP电话，实时视频会议等）。 （4） 每一条TCP连接只能是点到点的；UDP支持一对一，一对多，多对一和多对多的交互通信。 （5） TCP首部开销20字节；UDP的首部开销小，只有8个字节。 （6） TCP的逻辑通信信道是全双工的可靠信道，UDP则是不可靠信道。 题40：请简述Cookie和Session的区别。 难度：★☆☆☆☆
【参考答案】 （1） Session在服务器端，Cookie在客户端（浏览器）。 （2） Session可以存放在文件、数据库或内存中，默认以文件方式保存。 （3） Session的运行依赖Session ID，而Session ID保存在Cookie中。因此，如果浏览器禁用了Cookie， 同时Session也会失效。 题41：请简述向服务器端发送请求时的GET方式与POST方式的区别。 难度：★☆☆☆☆
【参考答案】 （1） 在浏览器回退时GET方式没有变化，而POST会再次提交请求。 （2） GET请求会被浏览器主动缓存，而POST不会，除非手动设置。 （3） GET请求只能进行URL编码，而POST支持多种编码方式。 （4） GET请求参数会被完整保留在浏览器历史记录里，而POST中的参数不会被保留。 （5） 对参数的数据类型，GET只接受ASCII字符，而POST没有限制。 （6） GET比POST更不安全，因为参数直接暴露在URL上，所以不能用来传递敏感信息。 （7） GET参数通过URL传递且传送的参数是有长度限制的，POST放在Request body中且长度没有 限制。 （8） 对于GET方式的请求，浏览器会把http header和data一并发送出去，服务器响应200（返回数 据）；而对于POST，浏览器先发送header，服务器响应100 continue，浏览器再发送data，服务器响应200 ok（返回数据）。
题42：使用threading组件编写支持多线程的Socket服务端。 难度：★★★★☆ 使用Python语言的threading组件编写支持多线程的Socket服务端，支持-x和-p参数，分别表示指定最大连接数和监听端口。
【参考答案】
import socket import threading,getopt,sys,string opts, args = getopt.getopt(sys.argv[1:], "hp:l:",["help","port=","list="]) list=50 port=8001 for op, value in opts: if op in ("-x","--maxconn"): list = int(value) elif op in ("-p","--port"): port = int(value) def Config(client, address): try: client.settimeout(500) buf = client.recv(2048) client.send(buf) except socket.timeout: print('time out') client.close() def main(): sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.bind(('localhost', port)) sock.listen(list) while True: client,address = sock.accept() thread = threading.Thread(target=Config, args=(client, address)) thread.start() if __name__ == '__main__': main() 1 2 3 4 5 6 7 8 9 10 11 12 九、 数据库编程（6题） 题43：简述数据库的第一、第二、第三范式的内容。
难度：★★☆☆☆
【参考答案】 范式是“符合某一种级别的关系模式的集合，表示一个关系内部各属性之间的联系的合理化程度”，实际上就是一张数据表的表结构所符合的某种设计标准的级别。 1NF的定义为：符合1NF的关系中的每个属性都不可再分。1NF是所有关系型数据库的最基本要求。 2NF在1NF的基础之上，消除了非主属性对于码的部分函数依赖。判断步骤如下。 第一步：找出数据表中所有的码。 第二步：根据第一步所得到的码，找出所有的主属性。 第三步：数据表中，除去所有的主属性，剩下的就都是非主属性了。 第四步：查看是否存在非主属性对码的部分函数依赖。 3NF在2NF的基础之上，消除了非主属性对于码的传递函数依赖。 题44：根据以下数据表结构和数据，按照要求编写SQL语句。 难度：★★☆☆☆ 数据库中现有Course、Score、Student和Teacher四张数据表，其中数据分别如下所示。
试编写SQL语句，查询平均成绩大于80的所有学生的学号、姓名和平均成绩。 【参考答案（使用SQLServer）】
select a.s_id, b.s_name, avg(a.s_score) as avg_score from Score a, Student b where a.s_id=b.s_id group by a.s_id, b.s_name having avg(a.s_score)>80 1 查询结果如下：
题45：按照44题所给条件，编写SQL语句查询没有学全所有课程的学生信息。 难度：★★☆☆☆ 【参考答案（使用SQLServer）】
select b.s_id, b.s_name from Score a, Student b where a.s_id=b.s_id group by b.s_id, b.s_name having count(a.c_id)<(select count(c_id) from Course) 1 2 3 查询结果如下：
题46：按照44题所给条件，编写SQL语句查询所有课程第2
名和第3名的学生信息及该课 1 程成绩。 难度：★★★★☆ 【参考答案（使用SQLServer）】
select * from ( select a.s_id, b.s_name, b.s_birth, b.s_sex, a.c_id, a.s_score, ro