小渣渣学习笔记 python day37【对比网页文件差异 difflib模块，池，线程池，进程池 concurrent.futures 回调函数 add_done_callback】

#对比网页文件的差异，A和B，四种情况，A包含B ，B包含A ，A和B没有交集，A和B有交集
#主要手上有A，对比B
#如果相等不管
#如果B内容少了，提示内容删减，显示出A中有的内容
#如果B中多了，提示B中增加内容
import difflib
with open(r'C:\Users\Administrator\Desktop\file1.html',encoding='utf-8') as f1:
    msg1 = f1.read().splitlines()
with open(r'C:\Users\Administrator\Desktop\file2.html',encoding='utf-8') as f2:
    msg2 = f2.read().splitlines()
d = difflib.Differ() #difflib模块中的Differ类，用于判断字符串差异
l = list(d.compare(msg1,msg2)) #比较函数compare
for i in l:
    if i.startswith('-') or i.startswith('+') or i.startswith('?'):
        print(i)
    # -          #file2 比 file1 中少了1个空格行
    # + hahaha   #file2 比 file1 多了一行 hahaha

#池中子线程传参数
import time,random
from threading import current_thread
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
def func(a,b):
    print(current_thread().ident,' start',a,b)
    time.sleep(random.randint(1,3))
    print(current_thread().ident,' end')
if __name__ == '__main__':
    tp = ThreadPoolExecutor(3)
    a = 1
    b = 2
    for i  in range(10):
        tp.submit(func,a,b) #参数直接放，不像创建子进程或者子线程一样，还要放到元组中 args=(a,b,)
# 显示3个线程id

#进程池
import time,random,os
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
def func(a,b):
    print(os.getpid(),' start',a,b) #这里在打印的时候没有出现拥堵现象，进程还是没有线程执行的快
    time.sleep(random.randint(1,3))
    print(os.getpid(),' end')
if __name__ == '__main__':
    tp = ProcessPoolExecutor(3)
    a = 1
    b = 2
    for i  in range(10):
        tp.submit(func,a,b)
# 总共显示3个进程id

#获取线程任务结果
# #进程池
import time,random,os
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
def func(a,b):
    print(os.getpid(),' start',a,b) #这里在打印的时候没有出现拥堵现象，进程还是没有线程执行的快
    time.sleep(random.randint(1,3))
    print(os.getpid(),' end')
    return a+b
if __name__ == '__main__':
    tp = ProcessPoolExecutor(3)
    ret_list = []
    for i  in range(10):
        ret = tp.submit(func,i,i+1)
        ret_list.append(ret)
    for ret in ret_list:
        print(ret) #结果是Future对象
        print(ret.result())#这里取ret的时候是按照顺序 取的，因为append的时候是按顺序放进去，这里打印的时候，会等相应的进程结束，才打印结果，否则就等

#map  不是函数里的内置函数
import time,random,os
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
def func(a): #这里参数变成1个a，这里的a是从下面map函数里的range(10)传进来的,如果要传多个参数呢 ？
    b = a+1
    print(os.getpid(),' start',a,b)
    time.sleep(random.randint(1,3))
    print(os.getpid(),' end')
    return a+b
if __name__ == '__main__':
    tp = ProcessPoolExecutor(3)
    ret_list = tp.map(func,range(10))#map 返回了可迭代对象，map节省代码，不用for循环2次了，
    for ret in ret_list: #但是这里还是顺序执行，同步阻塞
        print(ret)

#回调函数
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
from threading import current_thread
import random,time
def func(a):
    print(current_thread().ident,'start')
    time.sleep(random.randint(1,3))
    return a**2
def callback(ret): #回调函数
    print(ret.result())
if __name__ == '__main__':
    tp = ProcessPoolExecutor(3)
    for i in range(10):
        ret = tp.submit(func,i)
        ret.add_done_callback(callback) #指定回调函数
# 19080 start
# 22664 start
# 20412 start
# 19080 start
# 0
# 19080 start
# 9              #总共3个线程，这里9先打印的，1后面才打印，说明谁的返回值先到就打印谁，这是异步阻塞的表现
# 22664 start
# 1
# 20412 start.....

#【回顾】map内置函数，实现迭代对象分别在指定函数中执行，并返回结果
def func(a):
    return a**2

l  =  map(func,[1,2,3,4,5])
for i in l:
    print(i)

l  =  map(lambda a:a**2,[1,2,3,4,5])
for i in l:
    print(i)