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

一、重写父类的方法

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

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

1 class Zll(object):
2     def smile(self):
3         print('哈哈哈')
4 
5 
6 class Dcg(object):
7     def smile(self):
8         print('嘿嘿嘿')

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

1 class Lw(object):
2     def smile(self):
3         Zll.smile()
4         print('啊啊啊啊')

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

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

二、经典类和新式类

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

1、定义时有所不同

1 class A(object):  # 新式类
2     pass
3 
4 
5 class A1():  # 经典类
6     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。

 1 class A(object):
 2     pass
 3 class A1():
 4     pass
 5 
 6 class B(A):
 7     pass
 8 class B1(A1):
 9     pass
10 
11 class C(A):
12     def smile(self):
13         print('哈哈')
14 class C1(A1)
15     def smile(self):
16         print('haha')
17 
18 class D(C,B,A):
19     pass
20 class D1(C1,B1,A1):
21     pass
22 
23 d = D()
24 d.smile()
25 d1 = D1()
26 d1.smile

三，多线程和多进程

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

 1 import threading
 2 import time
 3 
 4 
 5 def run():
 6     time.sleep(3)  # 做一件事需要三秒
 7     print('哈哈哈')
 8 
 9 for i in range(5):  # 串行，一个人干完另一个人再干活
10     run()
11 
12 for i in range(5):  # 并行
13     t = threading.Thread(target=run)  # 实例化一个线程
14     t.start()

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

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

四、线程锁

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

 1 import threading, time
 2 num = 1
 3 lock = threading.Lock()  # 申请一把锁
 4 
 5 def run():
 6     time.sleep(1)
 7     global num
 8     lock.acquire()  # 加上锁，其实python3是会默认加锁的
 9     num += 1
10     lock.release()  # 解锁
11 ts = []
12 for i in range(50):
13     t = threading.Thread(target=run)
14     t.start()
15     ts.append(t)
16 [t.join() for t in ts]  # 如果不等待，主线程跑太快，上面那个time.sleep()会导致num=1就执行完了
17 print(num)

五、守护线程

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

 1 import threading,time
 2 def run():
 3     time.sleep(3)  # 做一件事需要三秒
 4     print('哈哈哈')
 5 
 6 for i in range(5):
 7     t = threading.Thread(target=run)
 8     t.setDaemon(True)  # 把子线程设置为守护线程
 9     t.start()
10 
11 print('Done,运行完成。')
12 time.sleep(3)  # 等三秒是可以运行下一个子线程的，但是等1秒的话来不及走子线程主线程就结束了

六、多进程

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

 

 

 1 import multiprocessing,threading
 2 
 3 def my():
 4     print('哈哈哈')
 5 
 6 
 7 def run(num):
 8     for i in range(num):
 9         t = threading.Thread(target=my)
10         t.start()
11 if __name__ == '__main__':
12     for i in range(5):
13         p = multiprocessing.Process(target=run, args=(6,))  # 启动五个进程，每个进程6个线程
14         # 这样就可以利用CPU的多核
15         p.start()

 

转载于:https://www.cnblogs.com/myyard777/p/9101031.html