接口测试学习-python第八课（面向对象第二课）

一、重写父类的方法

重写包含两种定义，其一是父类的方法不可用了，需要完全重新编写；其二是保留父类方法的同时新增一些功能。

首先是全部重写，很好理解，就是将整个方法都修改掉。比如下面的类Zll中，定义了一个smile方法，笑的方式是“哈哈哈”。而继承Zll的子类Dcg，笑的方式并不是这个，那么他就重写smile方法。

class Zll(object):
    def smile(self):
        print('哈哈哈')


class Dcg(object):
    def smile(self):
        print('嘿嘿嘿')

其次是修改父类方法。就是在保留父类方法的基础上进行添加或者部分修改。如果父类只有一个，那么直接在方法中调用父类方法即可。比如：

class Lw(object):
    def smile(self):
        Zll.smile()
        print('啊啊啊啊')

但当子类继承了多个父类时，像这样去调用就非常麻烦了，因为还要分辨这个方法属于哪一个父类。这时候可以用super()方法自动查找父类。当有多个父类时，super()会默认从第一个父类开始查找。

class Xz(Zll, Dcg, Lw):
    def smile(self):
        # Zll().smile()  # 先调用父类的方法，这样可以使用父类的功能
        super(Xz, self).smile()  # 可以帮助子类自动找到其父类
        # 如果子类继承自多个父类，super自动从第一个开始寻找smile方法
        print('呵呵呵呵')  # 重写了父类的方法

二、经典类和新式类

经典类和新式类的区别主要有以下两点：

1、定义时有所不同

class A(object):  # 新式类
    pass


class A1():  # 经典类
    pass

2、多重继承时，查找方法的方式不同

在python2中，经典类的查找方式是深度查找，新式类的查找方式是广度查找。到python3默认所有的类都是新式类，所以都默认为广度查找了。如下面代码中，实例化对象d使用方法smile时，因为其类D继承自C，B，A，都是新式类，所以D也是新式类，其查找smile的方法是广度优先也就是C->B->A的顺序查找的。而d1是D1类的实例化对象，D1继承自C1，B1和A1都是经典类，所以D1也是经典类，d1.smile()时查找方法是深度优先也就是C1->A1->B1。

class A(object):
    pass
class A1():
    pass

class B(A):
    pass
class B1(A1):
    pass

class C(A):
    def smile(self):
        print('哈哈')
class C1(A1)
    def smile(self):
        print('haha')

class D(C,B,A):
    pass
class D1(C1,B1,A1):
    pass

d = D()
d.smile()
d1 = D1()
d1.smile

三，多线程和多进程

一个进程可以有多个线程，进程是资源的合集，线程是进程中的最小执行单元。用很简单的方式来展示一下串行和并行。并行就是实例化线程，然后一起start开始干活。

import threading
import time


def run():
    time.sleep(3)  # 做一件事需要三秒
    print('哈哈哈')

for i in range(5):  # 串行，一个人干完另一个人再干活
    run()

for i in range(5):  # 并行
    t = threading.Thread(target=run)  # 实例化一个线程
    t.start()

如果我们要比较串行和并行的执行时间，串行的可以直接在程序开始时记录当前时间，结束后记录当前时间，然后相减即可。但是并行不行，因为并行记录的是主线程的时间，其实子线程还在运行中，直接这样记录是不准确的。我们可以用下面的方法，记录每次子线程，然后让主线程等待一下子线程

def run():
    time.sleep(3)  # 做一件事需要三秒
    print('哈哈哈')
start_time = time.time()
threads = []
for i in range(5):
    t = threading.Thread(target=run)
    t.start()
    threads.append(t)
    # t.join()  # 这个就是主线程等待子线程执行结束,但是直接这样是不行的因为每次t里面都是不同的线程
#     这样就变成了串行了，一个干完等待，继续下一个，然后等待
for t in threads:  # 主线程先运行了run()然后就继续往下走了，然后启动了子线程，所以此时主线程就已经在等待中了
    t.join()  # 这样就是每个线程都等待一下
end_time = time.time()
run_time = end_time-start_time
print('执行总共花了时间%s' % run_time)

四、线程锁

当所有的线程都在修改同一个数据时，可能出现覆盖的情况，比如一个数不断加1，因为后面的结果数覆盖了前面的数据，导致结果不正确。这个时候就要对这个变量加一个线程锁，让它在正在被修改的时候不会被其他任务修改。其实python3是会自动加锁的，但是我们也需要学习一下这个概念和方法，必须使用python2编程时就要用到了。

import threading, time
num = 1
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]  # 如果不等待，主线程跑太快，上面那个time.sleep()会导致num=1就执行完了
print(num)

五、守护线程

只要主线程结束，立刻结束其他子线程。不论子线程是否运行成功。

import threading,time
def run():
    time.sleep(3)  # 做一件事需要三秒
    print('哈哈哈')

for i in range(5):
    t = threading.Thread(target=run)
    t.setDaemon(True)  # 把子线程设置为守护线程
    t.start()

print('Done,运行完成。')
time.sleep(3)  # 等三秒是可以运行下一个子线程的，但是等1秒的话来不及走子线程主线程就结束了

六、多进程

多进程用于处理CPU密集型任务。多线程用于处理IO密集型任务。其实python是无法使用多核的，原因如下：

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,))  # 启动五个进程，每个进程6个线程
        # 这样就可以利用CPU的多核
        p.start()