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!下載完成。‘)

python接口自動化九--面對對象編程二，搭建測試環境，多線程與多進程