面试题2.20

1.什么是lambda函数？他有什么好处？另外python在函数式编程方面提供了些什么函数和语法？
lambda函数就是可以接受任意多个参数(包括可选参数)并且返回单个表达式值得函数
好处：
1.lambda函数比较轻便，即用即扔，适合完成只在一处使用的简单功能
2.匿名函数，一般用来给filter，map这样的函数式编程服务
3.作为回调函数，传递给某些应用，比如消息处理
2.什么是装饰器？写一个装饰器，可以打印输出方法执行时长的信息。
装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。
这种模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供了额外的功能。
我们通过下面的实例来演示装饰器模式的用法。其中，我们将把一个形状装饰上不同的颜色，同时又不改变形状类。
import time

def timer(func):
def decor(*args):

start_time = time.time()
func(*args)
end_time = time.time()
d_time = end_time - start_time
print("run the func use : ", d_time)
return decor

@timer #printSth = timer(printSth) -> printSth = decor
def printSth(str, count):
for i in range(count):
print("%d hello,%s!"%(i,str))

printSth("world", 1000000)#run the func use : 4.414000034332275
3.什么是进程，线程，协程，说一说python对他们的支持？
多进程：进程之间是独立的，
python的线程是用的操作系统的原生线程、python的进程也是用的操作系统的原生进程。
原生进程是由操作系统去维护的，python只是通过C代码库去起了一个进程，真正进程的管理还是通过操作系统去完成的。
操作系统的进程管理是没有全局解释器锁的，进程只是是独立的，根本不需要锁的概念。
import multiprocessing
import threading
import time

def thread_run(i,n):
print("在进程%s的线程%s"%(i,n))

def run(i):
print("进程：%s "%i)
time.sleep(1)
for n in range(2):
t = threading.Thread(target=thread_run,args=(i,n))
t.start()

if __name__ == '__main__': # 这个必须要有
for i in range(4):
p = multiprocessing.Process(target=run,args=(i,))
p.start()

from multiprocessing import Process
import os

def info(title): # 打印进程信息
print(title)
print('module name:', __name__) # 模块名
print('parent process:', os.getppid()) # 父进程ID
print('process id:', os.getpid()) # 进程ID
print("\n")

def f(name):
info('\033[31;1mcalled from child process function f\033[0m') # 打印子进程信息
print('hello', name)

if __name__ == '__main__':
info('\033[32;1mmain process line\033[0m') # 打印当前进程信息
p = Process(target=f, args=('FGF',)) # 子进程
p.start()
# p.join()

全局解释器锁的存在让多线程只有一个线程在执行，所以python里的多线程是假的多线程，不管多少核，同一时间只能在一个核上运行。
所有我们利用多线程的优势只是利用了它的什么优势呢？利用了CPU上下文切换的优势，看上去说并发的效果。

什么时候用多线程呢？

io操作不占用cpu，计算占用cpu
大量计算，耗cpu的用单线程
python多线程，不适合cpu密集操作型的任务，适合io密集型的任务
IO密集开多线程，计算密集开多进程
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import threading
import time

def show(arg):
time.sleep(1)
print 'thread'+str(arg)

for i in range(10):
t = threading.Thread(target=show, args=(i,))
t.start()

print 'main thread stop'

协程，又称微线程，纤程。英文名Coroutine。协程是一种用户态的轻量级线程。

协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈。因此：

协程能保留上一次调用时的状态（即所有局部状态的一个特定组合），每次过程重入时，就相当于进入上一次调用的状态，换种说法：进入上一次离开时所处逻辑流的位置。

线程的切换，会保存到CPU的寄存器里。
CPU感觉不到协程的存在，协程是用户自己控制的。

之前通过yield做的生产者消费者模型，就是协程，在单线程下实现并发效果。

协程的好处：

无需线程上下文切换的开销
无需数据操作锁定及同步的开销
方便切换控制流，简化编程模型
高并发+高扩展性+低成本：一个CPU支持上万的协程都不是问题。所以很适合用于高并发处理。
缺点：

无法利用多核资源：协程的本质是个单线程,它不能同时将 单个CPU 的多个核用上,协程需要和进程配合才能运行在多CPU上.当然我们日常所编写的绝大部分应用都没有这个必要，除非是cpu密集型应用。
进行阻塞（Blocking）操作（如IO时）会阻塞掉整个程序

import time

def consumer(name):
print("--->starting eating baozi...")
while True:
new_baozi = yield
print("[%s] is eating baozi %s" % (name,new_baozi))
# time.sleep(1)

def producer():
r = con.__next__()
r = con2.__next__()
n = 0
while n < 5:
n +=1
print("\033[32;1m[producer]\033[0m is making baozi %s" %n )
con.send(n)
con2.send(n)
time.sleep(1)

if __name__ == '__main__':
con = consumer("c1") # 第一次调用只是生成器，next的时候才回生成
con2 = consumer("c2")
p = producer()
4.用python实现"九九乘法表"，用两种不同的方式实现
No.1(列表生成式，简单粗暴)
print('\n'.join(' '.join(['{}*{}={}'.format(i,j,i*j) for i in range(1,j+1)])
for j in range(1,10)))


No.2(递归大法好)
def f(i):
if i>=1:
f(i-1)
print(['%dx%d=%d'%(j,i,i*j) for j in range(1,i+1)])

if __name__=='__main__':
f(9)