python接口自动化九--面对对象编程二，搭建测试环境，多线程与多进程

1.面对对象编程

1.1 基本概念

实例方法：在类里面定义的函数都是实例方法，函数内有self变量

类方法：

1. 不可以实例化，直接用类名调用
2. 类方法可以使用类变量，cls.xxx
3. 实例可以通过self.xx使用类方法

4. 类方法里面不能使用实例方法和实例变量

   静态方法：

5. 定义在类里的普通函数
6. 用不了实例方法，实例变量，类方法，类变量

7. 不需要实例化，直接用类名调用

​ 属性方法：

1. 是实例方法
2. 不能有入参
3. 用它的时候，直接m.func,把它当做变量来使用，后面不需要加括号

4. 它是获取函数的返回值

   析构函数：在实例被回收的时候执行，实例在程序结束时被回收

   构造函数：【init】类在实例化的时候，会自动执行

   私有函数：【del】两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类地外部调用

class My:
    def __init__(self):#构造函数，类在实例化的时候，会自动执行
         print('执行构造函数')
    def __del__(self): #析构函数，在实例被销毁的时候会自动执行
          print('执行析构函数')
    def say(self): #入参里面有self的是实例方法，只有通过实例化才可以调用
        print('我是牛奶')
        self.__cry()
    def __cry(self): #私有函数，只能在类里面调用
        print('哇哇哇')
    @classmethod  #类方法，可以实例化调用，通过类名直接调用
    def eat(cls):
        print("吃饭")
    @staticmethod  #静态方法，不需要实例化，直接用类名调用
    def run():
        pass
    @property   #属性方法，是实例方法，使用的时候直接当做变量来用
    def red_pag(self):
        return 100

1.2装饰器：他们是修改其他函数的功能的函数

装饰器小例子

import time,requests
def timer(func):
    def war(*args,**kwargs):
        start = time.time()
        res = func(*args,**kwargs)
        end_time = time.time()
        print('运行的时间是%s'%(end_time-start))
        return res
    return war
@timer
def down_img(name):
    res=requests.get('http://www.nnzhp.cn/wp-content/uploads/2018/07/60f2add20f0659e27d26435f28b8472e.png')
    open('a.png','wb').write(res.content)
    return name+'hhh'

@timer
def eat():
    time.sleep(5)
res = down_img('xxx')
print(res)
eat()

1.3 继承

class Ln:  #父类
    money=2000
    def make_money(self):
         print('挣钱')
class Me(Ln)  #子类继承父类
    def make_money(self):
         print('挣更多的钱’)

2.搭建测试环境

第一次搭建

1. 安装依赖软件mysql,redis,tomcat,nginx,jdk，数据库，中间件等
2. 从SVN，git上获取代码
3. 编译（java，c,c#)
4. 导入基础数据
5. 修改配置文件
6. 启动项目

日常部署

1. 获取最新代码
2. 编译
3. 执行sql文件（如果数据库结构有改变的话）
4. 修改配置文件
5. 重启项目

3.多线程与多进程

进程：一个进程就是一个程序。

线程：线程就是进程里面最小的执行单元。 一个进程里面最少有一个线程，可以有多个线程， 每个线程之间都是互相独立的。

由于python里面的GIL（全局解释器锁）机制，它确保任何时候都只有一个Python线程执行 ，所以python里面的多线程，利用不了多核cpu,只能利用一个核心的cpu。在CPU密集型进程，那多线程并不能带来效率上的提升，相反还可能会因为线程的频繁切换，导致效率下降； 如果是IO密集型进程，多线程进程可以利用IO阻塞等待时的空闲时间执行其他线程，提升效率。

多线程适用于IO密集型任务，多进程适用于CPU密集型任务

import threading,time
all_res=[]
def run():
   time.sleep(5)
   print('%s 哈哈哈'%name)
   all_res.append(name)

threads=[] #存放所有的子线程
for i in range(10) #开10个子线程
   t = threading.Thread(target=run,args=(i,))
   threads.append(t)
   t.start()
   
#方法一：统计当前线程数量判断所有子线程是否运行完成
while threading.active_count()!=1:
       pass    #当while=1,说明子线程已经完成，结束循环，程序向下执行

#方法二：主线程循环等待所有的子线程结束后再结束
for t in threads:
    t.join()#等待子进程运行完以后再运行
print(all_res)

守护线程：当主线程结束后，守护进程也会结束

import threading,time
def run():
   time.sleep(8)
   print('run。。')
for i in range(10):
   t=threading.Thread(target=run)
   t.setDaemon(True) #设置子线程为一个守护进程
   t.start()
  
print('over')
#主线程结束后，子线程就结束了，run函数不会执行

锁

import threading
from threading import Lock
num = 0
Lock = Lock()
def run():
    global num
    lock.acquire() #加锁
    num+=1
    lock.release()  #解锁
    with lock:  #自动加解锁
          num+=1
for i in range(100):
    t=threading.Thread(target=run)
    t.start()
while threading.active_count()!=1:
    pass
print(num)

线程池

可以控制最多允许多少个线程同时进行，超出的部分自动等待。解决了线程运行分配任务不均，比如一个线程还在苦苦工作，而另一个线程已经完成，却无法帮助前一个线程分担的情况 。

import threadpool,pymongo,requests
client = pymongo.MongoClient(host='118.24.3.40',port=27017)
table=client['liken']['qq_group_likun']
all_table=[i.get('qq') for i in table.find()]
url = 'http://q4.qlogo.cn/g?b=qq&nk=%s&s=140'
def down_img(qq_num):
    res=requests.get(url%qq_num).content
    with open('%s.jpg'%qq_num,'wb') as fw:
         fw.write(res)
pool = threadpool.ThreadPool(200) #定义线程池的大小
all_requests=threadpool.makeRequests(down_img,all_qq) #分配数据
for i in all_requests:
       pool,putRequest(r) #发请求
#[pool.putReques(r) for r in all_requests]
pool.wait() #等待所有线程运行完成
print('done!下载完成。')

转载于:https://www.cnblogs.com/tudouxifan/p/9399308.html