PYTHON自动化Day10-经典类和新式类的区别、重写父类方法、多线程、多进程、数据驱动框架的编写

            #两种情况：
#1.父类的方法子类中完全不需要，子类重新写
#2.父类有这个方法，但功能不够完善，子类想要在父类这个方法的基础上再添加一些新功能
        

            class
             ZLL():
    
            def
             smile(self):
        
            print(‘哈哈哈‘)

class Xz(ZLL):  #继承这个父类def smile(self):  #重写父类的方法
　　　　　#如果想要在子类中执行父类的smile方法
# ZLL().smile()  #调用父类 ，注意ZLL后面有（），因为调用的是实例方法，要实例化后才能调用
        super(Xz,self).smile()   #python2中没有super方法，super方法自动帮我们找到父类，和上面一行方法相同， 注意要写子类的类名，还要写一个self ，如果有多个父类，按顺序找到第一个smile（）执行print(‘hehe‘)

x=Xz()
x.smile()

class My:  #经典类passclass My2(object):  #新式类pass#在python3中没有区别, 都是广度优先
#在python2中，一个深度优先，一个是广度优先
#            经典类深度优先， 新式类是广度优先，  例子：一个类有两个父类，在这个子类中调用一个本身和父类都没有的方法，如果是经典类，在第一个父类没有找到方法的时候，继续找第一个父类的父类中的这个方法，而如果是新式类，在第一个父类没有找到方法的时候，会从第二个父类中找

            import
             threading,time


            #
             def run():
            
#
                 time.sleep(3)
            
#
                 print(‘哈哈哈‘)
            
#
             for i in range(5):   #没有使用多线程，顺序执行需要15秒，串行的
            
#
                 run()
            
#
#
             for i in range(5):   #使用多线程，只需要3秒，并行的
            
#
                 t=threading.Thread(target=run)  #实例化一个线程
            
#
                 t.start()
            
urls = {
    ‘besttest‘:‘http://www.besttest.cn‘,
    ‘niuniu‘:‘http://www.nnzhp.cn‘,
    ‘dsx‘:‘http://www.imdsx.cn‘,
    ‘cc‘:‘http://www.cc-na.cn‘,}

import requests
data={}
def down_html(file_name,url):
    start=time.time()
    res=requests.get(url).content
    open(file_name + ‘.html‘,‘wb‘).write(res)   #因为没有赋给其他变量，所以不需要关闭
    end=time.time()
    data[url]=end-start
    # print(k,"下载时间是：",end-start)    #如果想把它作为返回值返回的话，多线程是没法返回值的，只能在函数外面定义list或者字典来保存结果# #1.串行
# start_time=time.time()
# for k,v in urls.items():
#     down_html(k,v)
# end_time=time.time()
# run_time=end_time-start_time
# print("下载总共用时：",run_time)#2.并行
start_time=time.time()
threads=[]
for k,v in urls.items():
    t=threading.Thread(target=down_html,args=(k,v))  #多线程调用函数传参数要用args    t.start()
    threads.append(t)
for t in threads:
    t.join()
end_time=time.time()
run_time=end_time-start_time  #在没有加join处理前，这样统计的时间是不准确的，只是统计了主线程启动5个子线程的时间for k,v in data.items():
    print(k,v)
print("下载总共用时：",run_time)

            import
             threading,time
num=1

# def run():
#     time.sleep(1)        #如果不加这一行，就是num=51,加上了就是num=1,因为run还没有执行到num+=1，主线程就把所有的线程启动完了，继续执行print(num)了
#     global num
#     num+=1
#
# for i in range(50):
#     t=threading.Thread(target=run)
#     t.start()
#
# print(num)# #例子2
# def run():
#     time.sleep(1)
#     global num
#     num+=1
# ts=[]
# for i in range(50):
#     t=threading.Thread(target=run)
#     t.start()
#     ts.append(t)
# [t.join() for t in ts]            #加入join，num=51,因为主线程等所有子线程结束才结束
#
# print(num)
lock=threading.Lock()  #申请一把锁def run():
    time.sleep(1)
    global num
    lock.acquire()  #加锁    #加锁解锁来锁定一个数据，是为了避免并行操作数据造成数据异常    python3用不到，会自动帮我们加
    num+=1
    lock.release()  #解锁
ts=[]
for i in range(50):
    t=threading.Thread(target=run)
    t.start()
    ts.append(t)
[t.join() for t in ts]            #加入join，num=51,因为主线程等所有子线程结束才结束print(num)
 

            import
             threading,time


            def
             run():
    time.sleep(3)
    print(‘哈哈哈‘)

start_time= time.time()
threads=[]
for i in range(5):
    t=threading.Thread(target=run)      #这里如果加了括号就变成了串行， run()    t.start()
    threads.append(t)
    # t.join() #主线程等待子线程执行结束， 但是如果加在这里就变成串行了，因为主线程要等每一个启动的子线程执行结束再启动下一个子线程for t in threads:
    print(type(t))
    t.join()  #循环等待，等五个子线程都完成之后再往下进行
end_time=time.time()

print(‘run_time..‘,end_time-start_time)

            import
             threading,time


            def
             run():
    time.sleep(3)
    print(‘哈哈哈‘)

for i in range(50):
    t=threading.Thread(target=run)
    t.setDaemon(True) #把子线程设置成为守护线程    如果没有这句话，会完整执行完run,print哈哈哈，加上这句，主线程启动完所有子线程就print done,然后就结束了    t.start()

print(‘done,运行完成。‘)

# time.sleep(3)   #加上这句后，不加守护线程也可以打印了，因为主进程不会立即结束，而是等了3秒，3秒后，子线程都执行完成了

            import
             multiprocessing,threading


            def
             my():
    
            print(‘哈哈哈‘)

def run(num):
    for i in range(num):
        t=threading.Thread(target=my)
        t.start()

if__name__ == ‘__main__‘:
    for i in range(5):
        p=multiprocessing.Process(target=run,args=(6,))  #启动1个进程  args里如果只有一个参数比如在后面加一个逗号，这样会启动5个进程，每个进程启动6个线程
        p.start()