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:  #经典类
    pass

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

import logging

# logging.basicConfig(level=logging.DEBUG,#控制台打印的日志级别,debug会打印debug级别以及所有高于debug级别的log，也就是所有log
#                     filename='my.log',
#                     filemode='a',      # w 清空以前的日志，重新写入，a 在文件里追加
#                     format='%(asctime)s - %(pathname)s[line:%(lineno)d] - %(levelname)s: %(message)s'   #日志格式，固定写法
#                     )
# logging.debug('debug级别，最低级别，一般开发人员用来打印一些调试信息')
# logging.info('info级别，正常输出信息，一般用来打印一些正常的操作')
# logging.warning('waring级别，一般用来打印警信息')
# logging.error('error级别，一般用来打印一些错误信息')
#【注意】上面的代码加上文件名之后，log写入了my.log文件中，但是控制台没有显示log，我们想要控制台也输出，如下


import logging
from logging import handlers
#1.办公室
#2.负责往控制台里输出日志的
#3.往日志文件里面写日志的，按天生成日志，清理日志

logger=logging.getLogger()  #先实例化一个logger对象，先创建一个办公室
logger.setLevel(logging.DEBUG)  #设置日志级别

cl=logging.StreamHandler()  #负责往控制台输出的

#普通的写入log文件的方法，不能分割log文件，不能清理log文件：
# fl = logging.FileHandler(filename='a.log',filemode='a',encoding='utf-8')
#按时间生成日志文件
bl=handlers.TimedRotatingFileHandler(filename='a.log',when='S',interval=3,backupCount=5,encoding='utf-8')     #要特别导入一下,按天生成日志，清理日志  when 指定单位：时分秒等 interval=1 几个单位生成一个，backupCount最多保留几个

fmt=logging.Formatter('%(asctime)s - %(pathname)s[line:%(lineno)d] - %(levelname)s: %(message)s') #指定日志的格式
# when 按什么单位
    #S 秒
    #M
    #H
    #D
    #W interval=0时代表每周一

cl.setFormatter(fmt)  #设置控制台输出的日志格式
bl.setFormatter(fmt)  #设置文件里面写入的日志格式

logger.addHandler(cl)  #把两个分工明确的人加入办公室
logger.addHandler(bl)

logger.debug("我是debug..")
logger.warning("我是waring..")

import logging
from logging import handlers
class MyLogger():
    def __init__(self,file_name,level='info',backCount=5,when='D'):
        logger = logging.getLogger()  # 先实例化一个logger对象，先创建一个办公室
        logger.setLevel(self.get_level(level))  # 设置日志级别

        cl = logging.StreamHandler()  # 负责往控制台输出的

        bl = handlers.TimedRotatingFileHandler(filename=file_name, when='D',interval=1,backupCount=5,encoding='utf-8')
        fmt = logging.Formatter('%(asctime)s - %(pathname)s[line:%(lineno)d] - %(levelname)s: %(message)s')  # 指定日志的格式
        cl.setFormatter(fmt)  # 设置控制台输出的日志格式
        bl.setFormatter(fmt)  # 设置文件里面写入的日志格式
        logger.addHandler(cl)  # 把两个分工明确的人加入办公室
        logger.addHandler(bl)
        self.logger=logger  #最后再self，这样好写一点
    def get_level(self,str):
        level={
            'debug':logging.DEBUG,
            'info':logging.INFO,
            'warn':logging.WARNING,
            'error':logging.ERROR,
        }
        str=str.lower()
        return level.get(str)

lw_log=MyLogger('lw.log')
lw_log.logger.warning('hahah')
lw_log.logger.debug('debug')