python面试题汇总（史上最全）

python面试题

对于机器学习算法工程师而言，Python是不可或缺的语言，它的优美与简洁令人无法自拔。那么你了解过Python编程面试题吗？今天我们就来了解一下！   1、python  下多线程的限制以及多进程中传递参数的方式 

1、 python多线程有个全局解释器锁（global interpreter lock），这个锁的意思是任一时间只能有一个线程使用解释器，跟单 cpu跑多个程序一个意思，大家都是轮着用的，这叫“并发”，不是“并行”。
多进程间共享数据，可以使用 multiprocessing.Value和multiprocessing.Array。 2、什么是lambda函数？它有什么好处？
2、 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 ) 将一个整数转换为一个十六进制字符串 ⑮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 10、字符串、列表、元组、字典每个常用的            
            5个方法？                     
            字符串：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位置匹配成功的话才有返回，如果不是开始位置匹配成功的话，
        
            
        
            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题）

1.  下列哪个表达式在Python中是非法的？ B
   

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__出来的实例，

或者直接是对象的__new__出来的实例。这在自己编程实现__new__时要特别注意。
（3） __init__有一个参数self，就是这个__new__返回的实例，__init__在__new__的基础上可以完成一
些其它初始化的动作，init__不需要返回值。
（4） 如果__new__创建的是当前类的实例，会自动调用__init，通过返回语句里面调用的__new__函
数的第一个参数是cls来保证是当前类实例，如果是其他类的类名，那么实际创建并返回的就是其他类的实例，也就不会调用当前类或其他类的__init__函数。
题05：Python子类继承自多个父类时，如多个父类有同名方法，子类将继承自哪个方法？
难度：★☆☆☆☆

             【参考答案】 

Python语言中子类继承父类的方法是按照继承的父类的先后顺序确定的，例如，子类A继承自父类B、C，且B、C中具有同名方法Test()，那么A中的Test()方法实际上是继承自B中的Test()方法。
题06：请简述Python中如何避免死锁？
难度：★☆☆☆☆

             【参考答案】 

死锁是指不同线程获取了不同的锁，但是线程间又希望获取对方的锁，双方都在等待对方释放锁，这种相互等待资源的情况就是死锁。Python语言可以使用threading.Condition对象，基于条件事件通知的形式去协调线程的运行，即可避免死锁。
题07：什么是排序算法的稳定性？常见的排序算法如冒泡排序、快速排序、归并排序、堆排
序、Shell排序、二叉树排序等的时间、空间复杂度和稳定性如何？
难度：★★★☆☆

             【参考答案】 

假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，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))

题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))))

题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])]) 

题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 

题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 

题13：编写函数输出count-and-say序列的第n项。
难度：★★★★☆
count-and-say序列是一个整数序列，其前五个元素如下： 1 11 21

            1211 111221 

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 

题14：不使用sqrt

            函数，试编写squareRoot()函数，输入一个正数，输出它的平方根的整

数部分
难度：★★★★☆ 【参考答案】

  def squareRoot(x):     result = 1.0 
                    while abs(result * result - x) > 0.1:         result = (result + x / result) / 2 
                    return int(result) 

三、 正则表达式（4题）
题15：请写出匹配中国大陆手机号且结尾不是4和7的正则表达式。
难度：★☆☆☆☆ 【参考答案】

            import re 

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 = '
中国
' 
res = re.findall(r'
(.*?)
',str) print(res) 

            结果如下： 【参考答案】 

['中国 ']
题17：请写出以下代码的运行结果。
难度：★★★☆☆

import re 

                match = re.compile('www\....?').match("www.baidu.com") if match: 
    print(match.group()) else:                                
                    print("NO MATCH") 

【参考答案】
www.bai
题18：请写出以下代码的运行结果。
难度：★★☆☆☆

 import re  
example = "
test1
test2
" Result = re.compile("
.*").search(example) 
      
                print("Result = %s" % Result.group()) 

【参考答案】
Result =

test1

test2

            四、 列表、字典、元组、数组、矩阵（9题） 

题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]) 

题20：写出以下代码的运行结果。
难度：★★★★☆

def testFun():  

                    temp = [lambda x : i*x for i in range(5)]  
            
                
            
                    return temp 
for everyLambda in testFun():      print (everyLambda(3)) 

结果如下： 【参考答案】

            12 12 12 12 12 

题21：编写Python程序，打印星号金字塔。
难度：★★★☆☆
编写尽量短的Python程序，实现打印星号金字塔。例如n=5时输出以下金字塔图形：

                 * 
        
            
        
                ***    *****   *******  ********* 

参考代码如下： 【参考答案】

                n = 5 
for i in range(1,n+1): 
    print(' '*(n-(i-1))+'*'*(2*i-1)) 

题22：获取数组的支配点。
难度：★★★☆☆
支配数是指数组中某个元素出现的次数大于数组元素总数的一半时就成为支配数，其所在下标称为支配点。编写Python

            函数FindPivot(li)，输入数组，输出其中的支配点和支配数，若数组中不存在支配数，输出None。 

例如：[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 

题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)] 

【参考答案】
使用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)') 

从结果可知，执行效率从高到低依次是S2、S1、S3。
题24：螺旋式返回矩阵的元素
难度：★★★★★
给定m×n个元素的矩阵（m行，n列），编写Python

            函数spiralOrder(matrix)，以螺旋顺序返回矩阵的所有元素。 

例如，给定以下矩阵： [[ 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]))] 

题25：矩阵重整
难度：★★★★☆

            对于一个给定的二维数组表示的矩阵，以及两个正整数r和c，分别表示所需重新整形矩阵的行数和列数。reshape函数生成一个新的矩阵，并且将原矩阵的所有元素以与原矩阵相同的行遍历顺序填充进去，将该矩阵重新整形为一个不同大小的矩阵但保留其原始数据。对于给定矩阵和参数的reshape操作是可以完成且合法的，则输出新的矩阵；否则，输出原始矩阵。请使用Python语言实现reshape函数。 例如： 

        
            
        
            输入 

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 

题26：查找矩阵中第k个最小元素。
难度：★★★★☆
给定n×n矩阵，其中每行每列元素均按升序排列，试编写Python函数kthSmallest(matrix, k)，找到矩阵中的第k个最小元素。
注意：查找的是排序顺序中的第k个最小元素，而不是第k个不同元素。 例如： 矩阵= [[1,5,9], [10,11,13], [12,13,15]] k = 8，应返回13。

            【参考答案】 

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

题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 

五、 设计模式（3

            题） 

题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 

题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") 

题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() 

六、 树、二叉树、图（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 

题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 
题
            

            33：编写Python函数maxDepth()，实现获取二叉树root最大深度。 

难度：★★★★☆ 【参考答案】

def maxDepth(self, root):         if root == None:             return 0 
        return max(self.maxDepth(root.left),self.maxDepth(root.right))+1 

题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) 

题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 

七、 文件操作（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) 

题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) 

题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") 

            八、 网络编程（4题）

题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() 

九、 数据库编程（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 

查询结果如下：

题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) 

查询结果如下：

题46：按照44题所给条件，编写SQL语句查询所有课程第2

            名和第3名的学生信息及该课

程成绩。
难度：★★★★☆
【参考答案（使用SQLServer）】

  select * from ( 
select a.s_id, b.s_name, b.s_birth, b.s_sex, a.c_id, a.s_score, row_number() over (partition by a.c_id order by a.s_score desc) rno from Score a, Student b where a.s_id=b.s_id 
    ) as a where a.rno in (2, 3) order by c_id, rno 

查询结果如下：

题47：按照44题所给条件，编写SQL语句查询所教课程有2人及以上不及格的教师、课
程、学生信息及该课程成绩。
难度：★★★☆☆

            【参考答案（使用SQLServer）】 

  select a.s_id, d.s_name, a.s_score, a.c_id, b.c_name, b.t_id, c.t_name from Score a, Course b, Teacher c, Student d 
where a.c_id=b.c_id and b.t_id=c.t_id and a.s_id=d.s_id and a.s_score<60 and c.t_id in (  SELECT c.t_id   
                 FROM Score a, Course b, Teacher c 
 where a.c_id=b.c_id and b.t_id=c.t_id and a.s_score<60  group by c.t_id  having count(1)>1 
) 

查询结果如下：

题48：按照44题所给条件，编写SQL语句生成每门课程的一分段表（课程ID、课程名
称、分数、该课程该分数人数、该课程累计人数）。

            难度：★★★★☆

【参考答案（使用SQLServer）】

select a.c_id, b.c_name, a.s_score, COUNT(1) 人数, 
(select COUNT(1) from Score c where c.c_id=a.c_id and c.s_score>=a.s_score) 累计人数 from Score a, Course b where a.c_id=b.c_id 
group by a.c_id, b.c_name, a.s_score order by a.c_id, b.c_name, a.s_score desc; 

查询结果如下：

十、 图形图像与可视化（2题）

题49：绘制一个二次函数的图形，并同时画出使用梯形法求积分时的各个梯形。
难度：★★★☆☆

             【参考答案】 

以()=62+7+13为例，代码如下：

  def Quadratic_Function(x): 

                    return 6*x**2 + 7*x + 13  
import numpy as np 
import matplotlib.pyplot as plt from ipywidgets import interact  
def plot_ladder(laddernum): 
    x = np.linspace(-5, 5, num=100)     y = Quadratic_Function(x)     plt.plot(x, y)      
    a = np.linspace(-5, 5, num=laddernum)     for i in range(laddernum): 
        plt.plot([a[i], a[i]], [0, Quadratic_Function(a[i])], color="blue")  
    ladders = [] 
                    for i in range(laddernum): 
        ladders.append([a[i], Quadratic_Function(a[i])])      
    npladders = np.array(ladders) 
    plt.plot(npladders[:,0], npladders[:,1])  
interact(plot_ladder, laddernum=(1, 80, 1)) 

运行结果如下（使用Jupyter Notebook）：

题50：将给定数据可视化并给出分析结论
难度：★★★☆☆
某门店部分顾客的年龄、月收入以及每月平均在本店消费情况如下表所示。

请据此使用Python语言绘制适当的图形并分析得到结论。 【参考答案】

import matplotlib.pyplot as plt plt.figure(figsize=(10, 5)) # 年龄 
age = [34, 40, 37, 30, 44, 36, 32, 26, 32, 36] # 收入 
income = [7000, 9000, 3380, 3780, 3660, 1600, 3320, 2400, 1500, 2800] # 消费额 
expense = [1230, 1140, 1350, 1390, 1170, 1210, 1330, 1400, 1330, 1330] # 年龄，收入 散点图 ax1 = plt.subplot(121) ax1.scatter(age, income) 
ax1.set_title('年龄，收入 散点图', family='kaiti', size=16) # 年龄，消费额 散点图 ax2 = plt.subplot(122) ax2.scatter(age, expense) 
ax2.set_title('年龄，消费额 散点图', family='kaiti', size=16) plt.show() 

从图中可以看到，顾客年龄与消费额几近负相关，收入与消费额也几乎负相关，而年龄与收入之间没有特别明显的关联关系。

140.对Flask蓝图(Blueprint)的理解？
蓝图的定义
蓝图 /Blueprint 是Flask应用程序组件化的方法，可以在一个应用内或跨越多个项目共用蓝图。使用蓝图可以极大简化大型应用的开发难度，也为Flask扩展提供了一种在应用中注册服务的集中式机制。 蓝图的应用场景：
把一个应用分解为一个蓝图的集合。这对大型应用是理想的。一个项目可以实例化一个应用对象，初始化几个扩展，并注册一集合的蓝图。
以URL前缀和/或子域名，在应用上注册一个蓝图。URL前缀/子域名中的参数即成为这个蓝图下的所有视图函数的共同的视图参数（默认情况下） 在一个应用中用不同的URL规则多次注册一个蓝图。
通过蓝图提供模板过滤器、静态文件、模板和其他功能。一个蓝图不一定要实现应用或视图函数。
初始化一个Flask扩展时，在这些情况中注册一个蓝图。 蓝图的缺点：
不能在应用创建后撤销注册一个蓝图而不销毁整个应用对象。 使用蓝图的三个步骤 1.创建一个蓝图对象
blue = Blueprint(“blue”,name)
2.在这个蓝图对象上进行操作，例如注册路由、指定静态文件夹、注册模板过滤器…
@blue.route(’/’) def blue_index():
return “Welcome to my blueprint”
3.在应用对象上注册这个蓝图对象

            app.register_blueprint(blue,url_prefix="/blue") 

141.Flask 和 Django 路由映射的区别？

            在django中，路由是浏览器访问服务器时，先访问的项目中的url，再由项目中的url找到应用中url，这些url是放在一个列表里，遵从从前往后匹配的规则。在flask中，路由是通过装饰器给每个视图函数提供的，而且根据请求方式的不同可以一个url用于不同的作用。 

Django
142.什么是wsgi,uwsgi,uWSGI?
WSGI:
web服务器网关接口，是一套协议。用于接收用户请求并将请求进行初次封装，然后将请求交给web框架。
实现wsgi协议的模块：wsgiref,本质上就是编写一socket服务端，用于接收用户请求（django)
werkzeug,本质上就是编写一个socket服务端，用于接收用户请求(flask) uwsgi:
与WSGI一样是一种通信协议，它是uWSGI服务器的独占协议，用于定义传输信息的类型。 uWSGI:
是一个web服务器，实现了WSGI的协议，uWSGI协议，http协议
143.Django、Flask、Tornado的对比？
1、 Django走的大而全的方向，开发效率高。它的MTV框架，自带的
ORM,admin后台管理,自带的sqlite数据库和开发测试用的服务器，给开发者提高了超高的开发效率。 重量级web框架，功能齐全，提供一站式解决的思路，能让开发者不用在选择上花费大量时间。
自带ORM和模板引擎，支持jinja等非官方模板引擎。
自带ORM使Django和关系型数据库耦合度高，如果要使用非关系型数据库，需要使用第三方库 自带数据库管理app 成熟，稳定，开发效率高，相对于Flask，Django的整体封闭性比较好，适合做企业级网站的开发。python web框架的先驱，第三方库丰富
2、 Flask 是轻量级的框架，自由，灵活，可扩展性强，核心基于Werkzeug WSGI工具 和jinja2 模板引擎
适用于做小网站以及web服务的API,开发大型网站无压力，但架构需要自己设计
与关系型数据库的结合不弱于Django，而与非关系型数据库的结合远远优于Django
3、 Tornado走的是少而精的方向，性能优越，它最出名的异步非阻塞的设计方式
Tornado的两大核心模块：
iostraem:对非阻塞的socket进行简单的封装 ioloop: 对I/O 多路复用的封装,它实现一个单例
144.CORS 和 CSRF的区别？
什么是CORS？
CORS是一个W3C标准,全称是“跨域资源共享"(Cross-origin resoure sharing). 它允许浏览器向跨源服务器，发出XMLHttpRequest请求，从而客服了AJAX只能同源使用的限制。 什么是CSRF？
CSRF主流防御方式是在后端生成表单的时候生成一串随机token,内置到表单里成为一个字段，同时，将此串token置入session中。每次表单提交到后端时都会检查这两个值是否一致，以此来判断此次表单提交是否是可信的，提交过一次之后，如果这个页面没有生成CSRF token,那么token将会被清空,如果有新的需求，那么token会被更新。 攻击者可以伪造POST表单提交，但是他没有后端生成的内置于表单的token，session中没有token都无济于事。
145.Session,Cookie,JWT的理解
为什么要使用会话管理
众所周知，HTTP协议是一个无状态的协议，也就是说每个请求都是一个独立的请求，请求与请求之间并无关系。但在实际的应用场景，这种方式并不能满足我们的需求。举个大家都喜欢用的例子，把商品加入购物车，单独考虑这个请求，服务端并不知道这个商品是谁的，应该加入谁的购物车？因此这个请求的上下文环境实际上应该包含用户的相关信息，在每次用户发出请求时把这一 小部分额外信息，也做为请求的一部分，这样服务端就可以根据上下文中的信息，针对具体的用户进行操作。所以这几种技术的出现都是对HTTP协议的一个补充，使得我们可以用HTTP协议+状态管理构建一个的面向用户的WEB应用。
Session 和Cookie的区别
这里我想先谈谈session与cookies,因为这两个技术是做为开发最为常见的。那么session与cookies的区别是什么？个人认为session与cookies最核心区别在于额外信息由谁来维护。利用cookies来实现会话管理时，用户的相关信息或者其他我们想要保持在每个请求中的信息，都是放在cookies中,而
cookies是由客户端来保存，每当客户端发出新请求时，就会稍带上cookies,服务端会根据其中的信息进行操作。 当利用session来进行会话管理时，客户端实际上只存了一个由服务端发送的session_id,而由这个session_id,可以在服务端还原出所需要的所有状态信息，从这里可以看出这部分信息是由服务端来维护的。
除此以外，session与cookies都有一些自己的缺点： cookies的安全性不好，攻击者可以通过获取本地cookies进行欺骗或者利用cookies进行CSRF攻击。使用cookies时,在多个域名下，会存在跨域问题。 session 在一定的时间里，需要存放在服务端，因此当拥有大量用户时，也会大幅度降低服务端的性能，当有多台机器时，如何共享session也会是一个问题.(redis集群)也就是说，用户第一个访问的时候是服务器A，而第二个请求被转发给了服务器B，那服务器B如何得知其状态。实际上，session与cookies是有联系的，比如我们可以把session_id存放在cookies中的。 JWT是如何工作的
首先用户发出登录请求，服务端根据用户的登录请求进行匹配，如果匹配成功，将相关的信息放入payload中，利用算法，加上服务端的密钥生成
token，这里需要注意的是secret_key很重要，如果这个泄露的话，客户端就可以随机篡改发送的额外信息，它是信息完整性的保证。生成token后服务端将其返回给客户端，客户端可以在下次请求时，将token一起交给服务端，一般是说我们可以将其放在Authorization首部中，这样也就可以避免跨域问题。
146.简述Django请求生命周期
一般是用户通过浏览器向我们的服务器发起一个请求(request),这个请求会去访问视图函数，如果不涉及到数据调用，那么这个时候视图函数返回一个模板也就是一个网页给用户） 视图函数调用模型毛模型去数据库查找数据，然后逐级返回，视图函数把返回的数据填充到模板中空格中，最后返回网页给用户。 1.wsgi ,请求封装后交给web框架（Flask，Django)
2.中间件，对请求进行校验或在请求对象中添加其他相关数据，例如：csrf,request.session
3.路由匹配 根据浏览器发送的不同url去匹配不同的视图函数 4.视图函数，在视图函数中进行业务逻辑的处理，可能涉及到：orm，templates
5.中间件，对响应的数据进行处理 6.wsgi，将响应的内容发送给浏览器
147.用的restframework完成api发送时间时区
当前的问题是用django的rest framework模块做一个get请求的发送时间以及时区信息的api

class getCurrenttime(APIView):    def get(self,request): 
       local_time = time.localtime() 
       time_zone =settings.TIME_ZONE 
       temp = {'localtime':local_time,'timezone':time_zone}        return Response(temp) 

148.nginx,tomcat,apach到都是什么？
Nginx（engine x)是一个高性能的HTTP和反向代理服务器，也是 一个IMAP/POP3/SMTP服务器，工作在OSI七层，负载的实现方式：轮询，
IP_HASH,fair,session_sticky. Apache HTTP Server是一个模块化的服务器，源于NCSAhttpd服务器 Tomcat 服务器是一个免费的开放源代码的Web应用服务器，属于轻量级应用服务器，是开发和调试JSP程序的首选。
149.请给出你熟悉关系数据库范式有哪些，有什么作用？
在进行数据库的设计时，所遵循的一些规范，只要按照设计规范进行设计，就能设计出没有数据冗余和数据维护异常的数据库结构。
数据库的设计的规范有很多，通常来说我们在设是数据库时只要达到其中一些规范就可以了，这些规范又称之为数据库的三范式，一共有三条，也存在着其他范式，我们只要做到满足前三个范式的要求，就能设陈出符合我们的数据库了，我们也不能全部来按照范式的要求来做，还要考虑实际的业务使用情况，所以有时候也需要做一些违反范式的要求。 1.数据库设计的第一范式(最基本)，基本上所有数据库的范式都是符合第一范式的，符合第一范式的表具有以下几个特点：
数据库表中的所有字段都只具有单一属性，单一属性的列是由基本的数据类型（整型，浮点型，字符型等）所构成的设计出来的表都是简单的二比表 2.数据库设计的第二范式(是在第一范式的基础上设计的)，要求一个表中只具有一个业务主键，也就是说符合第二范式的表中不能存在非主键列对只对部分主键的依赖关系
3.数据库设计的第三范式，指每一个非主属性既不部分依赖与也不传递依赖于业务主键，也就是第二范式的基础上消除了非主属性对主键的传递依赖
150.简述QQ登陆过程
qq登录，在我们的项目中分为了三个接口，
第一个接口是请求qq服务器返回一个qq登录的界面;
第二个接口是通过扫码或账号登陆进行验证，qq服务器返回给浏览器一个code和state,利用这个code通过本地服务器去向qq服务器获取
access_token覆返回给本地服务器，凭借access_token再向qq服务器获取用户的openid(openid用户的唯一标识)
第三个接口是判断用户是否是第一次qq登录，如果不是的话直接登录返回的jwt-token给用户，对没有绑定过本网站的用户，对openid进行加密生成token进行绑定
151.post 和 get的区别?
1.GET是从服务器上获取数据，POST是向服务器传送数据
2.在客户端，GET方式在通过URL提交数据，数据在URL中可以看到，POST方式，数据放置在HTML——HEADER内提交
3.对于GET方式，服务器端用Request.QueryString获取变量的值，对于POST方式，服务器端用Request.Form获取提交的数据
152.项目中日志的作用
一、日志相关概念
1.日志是一种可以追踪某些软件运行时所发生事件的方法
2.软件开发人员可以向他们的代码中调用日志记录相关的方法来表明发生了某些事情
3.一个事件可以用一个包含可选变量数据的消息来描述
4.此外，事件也有重要性的概念，这个重要性也可以被成为严重性级别(level) 二、日志的作用
1.通过log的分析，可以方便用户了解系统或软件、应用的运行情况; 2.如果你的应用log足够丰富，可以分析以往用户的操作行为、类型喜好，地域分布或其他更多信息;
3.如果一个应用的log同时也分了多个级别，那么可以很轻易地分析得到该应用的健康状况，及时发现问题并快速定位、解决问题，补救损失。
4.简单来讲就是我们通过记录和分析日志可以了解一个系统或软件程序运行情况是否正常，也可以在应用程序出现故障时快速定位问题。不仅在开发中，在运维中日志也很重要，日志的作用也可以简单。总结为以下几点： 1.程序调试
2.了解软件程序运行情况，是否正常 3,软件程序运行故障分析与问题定位
4,如果应用的日志信息足够详细和丰富，还可以用来做用户行为分析
153.django中间件的使用？
Django在中间件中预置了六个方法，这六个方法的区别在于不同的阶段执行，对输入或输出进行干预，方法如下：
1.初始化：无需任何参数，服务器响应第一个请求的时候调用一次，用于确定是否启用当前中间件
def init(): pass
2.处理请求前：在每个请求上调用，返回None或HttpResponse对象。
def process_request(request): pass
3.处理视图前:在每个请求上调用，返回None或HttpResponse对象。
def process_view(request,view_func,view_args,view_kwargs): pass
4.处理模板响应前：在每个请求上调用，返回实现了render方法的响应对象。
def process_template_response(request,response): pass
5.处理响应后：所有响应返回浏览器之前被调用，在每个请求上调用，返回HttpResponse对象。 def process_response(request,response): pass
6.异常处理：当视图抛出异常时调用，在每个请求上调用，返回一个HttpResponse对象。
def process_exception(request,exception): pass
154.谈一下你对uWSGI和nginx的理解？
1.uWSGI是一个Web服务器，它实现了WSGI协议、uwsgi、http等协议。Nginx中HttpUwsgiModule的作用是与uWSGI服务器进行交换。WSGI是一种Web服务器网关接口。它是一个Web服务器（如nginx，uWSGI等服务器）与web应用（如用Flask框架写的程序）通信的一种规范。 要注意WSGI/uwsgi/uWSGI这三个概念的区分。 WSGI是一种通信协议。
uwsgi是一种线路协议而不是通信协议，在此常用于在uWSGI服务器与其他网络服务器的数据通信。
uWSGI是实现了uwsgi和WSGI两种协议的Web服务器。 nginx 是一个开源的高性能的HTTP服务器和反向代理： 1.作为web服务器，它处理静态文件和索引文件效果非常高
2.它的设计非常注重效率，最大支持5万个并发连接，但只占用很少的内存空间
3.稳定性高，配置简洁。
4.强大的反向代理和负载均衡功能，平衡集群中各个服务器的负载压力应用
155.Python中三大框架各自的应用场景？
django:主要是用来搞快速开发的，他的亮点就是快速开发，节约成本，,如果要实现高并发的话，就要对django进行二次开发，比如把整个笨重的框架给拆掉自己写socket实现http的通信,底层用纯c,c++写提升效率，ORM框架给干掉，自己编写封装与数据库交互的框架,ORM虽然面向对象来操作数据库，但是它的效率很低，使用外键来联系表与表之间的查询; flask: 轻量级，主要是用来写接口的一个框架，实现前后端分离，提考开发效率，Flask本身相当于一个内核，其他几乎所有的功能都要用到扩展(邮件扩展Flask-Mail，用户认证Flask-Login),都需要用第三方的扩展来实现。比如可以用Flask-extension加入ORM、文件上传、身份验证等。Flask没有默认使用的数据库，你可以选择MySQL，也可以用NoSQL。
其WSGI工具箱用Werkzeug(路由模块)，模板引擎则使用Jinja2,这两个也是Flask框架的核心。
Tornado： Tornado是一种Web服务器软件的开源版本。Tornado和现在的主流Web服务器框架（包括大多数Python的框架）有着明显的区别：它是非阻塞式服务器，而且速度相当快。得利于其非阻塞的方式和对epoll的运用，Tornado每秒可以处理数以千计的连接因此Tornado是实时Web服务的一个理想框架
156.Django中哪里用到了线程？哪里用到了协程？哪里用到了进程？
1.Django中耗时的任务用一个进程或者线程来执行，比如发邮件，使用celery. 2.部署django项目是时候，配置文件中设置了进程和协程的相关配置。
157.有用过Django REST framework吗？
Django REST framework是一个强大而灵活的Web API工具。使用RESTframework的理由有：
Web browsable API对开发者有极大的好处 包括OAuth1a和OAuth2的认证策略 支持ORM和非ORM数据资源的序列化
全程自定义开发–如果不想使用更加强大的功能，可仅仅使用常规的function-based views额外的文档和强大的社区支持
158.对cookies与session的了解？他们能单独用吗？
Session采用的是在服务器端保持状态的方案，而Cookie采用的是在客户端保持状态的方案。但是禁用Cookie就不能得到Session。因为Session是用Session ID来确定当前对话所对应的服务器Session，而Session ID是通过Cookie来传递的，禁用Cookie相当于SessionID,也就得不到Session。
爬虫
159.试列出至少三种目前流行的大型数据库 160.列举您使用过的Python网络爬虫所用到的网络数据包?
requests, urllib,urllib2, httplib2
161.爬取数据后使用哪个数据库存储数据的，为什么？ 162.你用过的爬虫框架或者模块有哪些？优缺点？
Python自带：urllib,urllib2 第三方：requests 框架： Scrapy
urllib 和urllib2模块都做与请求URL相关的操作，但他们提供不同的功能。 urllib2: urllib2.urlopen可以接受一个Request对象或者url,(在接受Request对象时，并以此可以来设置一个URL的headers),urllib.urlopen只接收一个url。 urllib 有urlencode,urllib2没有，因此总是urllib, urllib2常会一起使用的原因 scrapy是封装起来的框架，他包含了下载器，解析器，日志及异常处理，基于多线程，twisted的方式处理，对于固定单个网站的爬取开发，有优势，但是对于多网站爬取100个网站，并发及分布式处理不够灵活，不便调整与扩展 requests是一个HTTP库，它只是用来请求，它是一个强大的库，下载，解析全部自己处理，灵活性高
Scrapy优点：异步，xpath，强大的统计和log系统，支持不同url。shell方便独立调试。写middleware方便过滤。通过管道存入数据库 163.写爬虫是用多进程好？还是多线程好？ 164.常见的反爬虫和应对方法？
165.解析网页的解析器使用最多的是哪几个? 166.需要登录的网页，如何解决同时限制ip，cookie,session 167.验证码的解决?
168.使用最多的数据库，对他们的理解？ 169.编写过哪些爬虫中间件？ 170.“极验”滑动验证码如何破解？
171.爬虫多久爬一次，爬下来的数据是怎么存储？ 172.cookie过期的处理问题？
173.动态加载又对及时性要求很高怎么处理？ 174.HTTPS有什么优点和缺点？
175.HTTPS是如何实现安全传输数据的？ 176.TTL，MSL，RTT各是什么？
177.谈一谈你对Selenium和PhantomJS了解
178.平常怎么使用代理的 ？
179.存放在数据库(redis、mysql等)。 180.怎么监控爬虫的状态?
181.描述下scrapy框架运行的机制？ 182.谈谈你对Scrapy的理解？
183.怎么样让 scrapy 框架发送一个 post 请求（具体写出来）
184.怎么监控爬虫的状态 ？ 185.怎么判断网站是否更新？
186.图片、视频爬取怎么绕过防盗连接
187.你爬出来的数据量大概有多大？大概多长时间爬一次？
188.用什么数据库存爬下来的数据？部署是你做的吗？怎么部署？ 189.增量爬取
190.爬取下来的数据如何去重，说一下scrapy的具体的算法依据。
191.Scrapy的优缺点?
192.怎么设置爬取深度？
193.scrapy和scrapy-redis有什么区别？为什么选择redis数据库？
194.分布式爬虫主要解决什么问题？
195.什么是分布式存储？
196.你所知道的分布式爬虫方案有哪些？
197.scrapy-redis，有做过其他的分布式爬虫吗？