1、paramiko模組

1.1、此函式是ssh模組：

import paramiko
def ssh2(ip='127.0.0.1',port=22,username='',passwd='',cmd=''):
 """
 ssh連線伺服器
 :return:
 """
 ssh = paramiko.SSHClient() #建立SSH物件
 ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) #允許連線不在know_hosts檔案中的主機
 ssh.connect(ip,int(port),username,passwd) #連線伺服器
 stdin,stdout,stderr = ssh.exec_command(cmd) #執行命令，標準輸入，輸出，錯誤三個變數中
 result = stdout.read() #獲取命令的結果,輸出是位元組的型別
 print(result.decode("utf-8")) #將位元組的型別轉換為utf-8
 ssh.close()

ssh2("192.168.1.1",22,"root","123456","df")
1.2、sftpclient:
 

import paramiko

transport = paramiko.Transport(('192.168.1.1',22))
transport.connect(username='root', password='123456')

sftp = paramiko.SFTPClient.from_transport(transport)
# 將location.py 上傳至伺服器 /tmp/test.py,其實test.py是更改過的名字
sftp.put('/tmp/location.py', '/tmp/test.py')
# 將remove_path 下載到本地 local_path,local_path也是更改過的名字
sftp.get('remove_path', 'local_path')

transport.close()

2、程序
程序就是所以資源的集合，是程式的一次執行活動，屬於動態概念。
2.1、多程序
第一程序p父程序是主程序，第二個p1的父程序是p，輪詢的啊
 

from multiprocessing import Process
import os

def info(title):
    print(title)
    print('module name:',__name__)
 print('parent process:',os.getppid())
 print('process id:',os.getpid())
 # print('\n')

def f(name):
 info("\033[31;1mcalled from child process function f\033[0m")
 print('hello',name)

if __name__ == '__main__':
 info('\033[32;1mmain process line\033[0m')
 p = Process(target=f,args=('Tom',))
 p.start()
 p1= Process(target=f,args=('bob',))
 p1.start()
2.2、程序間通訊:兩個程序之間的資料傳遞
佇列方式：
 

from multiprocessing import Process,Queue
def f(q):
    q.put([42,None,'hello'])

if __name__ == '__main__':
 q = Queue()
 p = Process(target=f,args=(q,))
 p.start()
 print(q.get()) #父程序拿到了子程序的資料，這就是程序間通訊

中介Pipe方式：

from multiprocessing import Process,Pipe
#相當於在父程序和子程序之間打通了一個虛擬通道，其實通過的是第三方
def f(conn):
    conn.send([42,None,'hello'])
 conn.send([42,None,'hello world'])
 print("from parent:",conn.recv())
 conn.close()

if __name__ == '__main__':
 parent_conn,child_conn = Pipe() #父程序和子程序通過第三方交流
 p = Process(target=f,args=(child_conn,))
 p.start()
 print(parent_conn.recv())
 print(parent_conn.recv())
 parent_conn.send("大家可好")
 p.join()

2.3、程序間處理同一份資料，即共享資料：Manager

from multiprocessing import Process, Manager
import os

def f(d, l):
    d[1] = '1'
 d['2'] = 2
 l.append(os.getpid())
 print(l,d)


if __name__ == '__main__':
 with Manager() as manager:
 d = manager.dict() #建立一個多個程序都可以共享的字典

 l = manager.list(range(5)) #建立一個多程序可以共享的列表

 p_list = []
 for i in range(10): #生成是10個程序處理同一份資料
 p = Process(target=f, args=(d, l)) #函式f
 p.start()
 p_list.append(p)
 for res in p_list:
 res.join() #必須等待程序處理結果，如果不寫後邊執行就有問題，會出現主程序直接關閉了
 l.append("from parent")
 print(d)
 print(l)

2.4、程序池：同時執行執行的程序個數，因為程序太大，所以設定有程序池，其它不執行的就掛起

from multiprocessing import Process,Pool
import os,time

def Foo(i):
    time.sleep(2)
    print("in process",os.getpid())
 return i+100

def Bar(arg):
 print("--->exec done:",arg,os.getpid())

if __name__ == '__main__':
 pool = Pool(processes=3) #只允許3個程序執行，其它都掛起
 print("主程序",os.getpid())
 for i in range(10): #apply_async代表非同步執行
 pool.apply_async(func=Foo,args=(i,),callback=Bar) #callback=回撥,Bar中arg就是Foo返回的資料
 # pool.apply(func=Foo, args=(i,)) #序列
 print('end')
 pool.close()
 pool.join() #程序池中程序執行完畢後再關閉，如果註釋，程式會直接關閉

3、執行緒
執行緒是作業系統能夠進行運算排程的最小單位。一條執行緒指的是程序中一個單一順序的控制流，一個程序中可以併發多個執行緒，每條執行緒並行執行不同的任務
3.1、建立執行緒：

import threading
import time
def sayhi(num):
    print("running on number:%s" %num)
    time.sleep(3)
 print("task done",num)
#執行緒是並行處理的，看是是並行處理，時分處理
if __name__ == '__main__':
 t1 = threading.Thread(target=sayhi,args=(1,)) #建立執行緒，arg是傳入變數，必須是元組格式
 t2 = threading.Thread(target=sayhi,args=(2,))

 t1.start() #啟動執行緒
 t2.start()

 print(t1.getName()) #獲取執行緒名稱
 print(t2.getName())

3.2、建立多個執行緒

import threading
import time
def sayhi(num):
    print("running on number:%s" %num)
    time.sleep(3)
 print("task done",num)
#執行緒是並行處理的，看是是並行處理，時分處理
if __name__ == '__main__':
 t_objs = [] #存執行緒例項
 for i in range(50):
 t = threading.Thread(target=sayhi,args=("t-%s" %i,))
 t.start()
 t.join() #變成序列執行，只有第一個執行完才能執行第二個
 t_objs.append(t)

   for t in t_objs:
       t.join()  #wait等待，保障有序的執行

   print("main thread......")  #函式式執行順序

3.3、繼承式的執行緒方式

import threading
import time
class MyThread(threading.Thread):
    def __init__(self,n,sleep_time):
 super(MyThread,self).__init__()
 self.n = n
 self.sleep_time = sleep_time
 def run(self): #定義每個執行緒要執行的函式
 print("running task",self.n)
 time.sleep(self.sleep_time)
 print("task done",self.n)

t1 = MyThread("t1",2)
t2 = MyThread("t2",4)
t1.start()
t2.start()

t1.join() #wait,保障有序的執行
t2.join()

print("main thread......") #函式式執行順序

3.4、守護程序，隨著主執行緒的結束而結束

import threading
import time

def run(n):
    print("task",n)
    time.sleep(3)
 print("task done",n,threading.current_thread())

start_time = time.time()
t_objs = [] #存執行緒的列表

for i in range(50):
 t = threading.Thread(target=run,args=("t-%s" %i,))
 t.setDaemon(True) #設定為守護執行緒
 t.start()
 t_objs.append(t)

# for t in t_objs:
# t.join() #如果不進行守護程序執行完，就會馬上執行主執行緒，不會等待守護執行緒的是否執行完畢

# time.sleep(2)
#threading.active_count()目前活動的執行緒數
print("-------all threads has finished...",threading.current_thread(),threading.active_count())
print("cost:",time.time() - start_time)

3.5、互斥鎖
一個程序下可以啟動多個執行緒，多個執行緒共享父程序的記憶體，時分複用時，執行緒可以拿到一份資料進行修改，所以導致多個執行緒可以處理同時處理
一個數據，導致處理出來的資料出現錯誤，不過在python3.x中已經解決了

import threading
import time

def run(n):
    lock.acquire()  #變成了並行，時間太長
 global num
 num +=1
 time.sleep(1)
 lock.release()


lock = threading.Lock()
num = 0
t_objs = [] #存執行緒例項
for i in range(5):
 t = threading.Thread(target=run,args=("t-%s" %i ,))
 t.start()
 t_objs.append(t) #為了不阻塞後面執行緒的啟動，不在這裡join，先放到一個列表裡

for t in t_objs: #迴圈執行緒例項列表，等待所有執行緒執行完畢
 t.join()

print("----------all threads has finished...",threading.current_thread(),threading.active_count())

print("num:",num) #需要花費5秒左右才出

3.6、訊號量: 就是同時 執行執行多少個執行緒

import threading,time

def run(n):
    semaphore.acquire()  #這裡必須先獲取
    time.sleep(1)
    print("run the thread: %s\n" %n)
 semaphore.release() #後釋放

t_objs = []
if __name__ == '__main__':
 semaphore = threading.BoundedSemaphore(5) #每次只允許同時執行五個執行緒
 for i in range(50):
 t = threading.Thread(target=run,args=(i,))
 t.start()
 t_objs.append(t)
 for t in t_objs:
 t.join()

while threading.active_count() != 1:
 pass
else:
 print('----all threads done---')


3.6、event事件
event = threading.Event()
event.wait() 等待
event.set() 設定置位為1
event.clear() 清除置位
紅綠燈示例：

import threading,time
import random
event = threading.Event()   #執行緒的事件
def light():
    count = 0
 if not event.is_set():
 event.set() #置為位1
 while True:
 if count > 5 and count < 10:
 event.clear() #清楚置位，就是0
 print("\033[41;1mred light is on....\033[0m")
 elif count >=10:
 event.set() #置位為1
 count = 0
 else:
 print('\033[42;1mgreen light is on...\033[0m')
 time.sleep(1)
 count +=1
def car(name):
 while True:
 time.sleep(random.randrange(10)) #隨即休眠時間
 if event.is_set():
 print("[%s] running..." %name)
 else:
 print("[%s] sees red light,waiting...." %name)
 event.wait()

if __name__ == '__main__':
 light = threading.Thread(target=light)
 light.start()
 for i in range(3): #新建3輛車
 t = threading.Thread(target=car,args=(i,))
 t.start()

3.7、佇列

• class queue.Queue(maxsize=0) #先入先出
• class queue.LifoQueue(maxsize=0) #last in fisrt out 
• class queue.PriorityQueue(maxsize=0) #儲存資料時可設定優先順序的佇列

import queue

q = queue.PriorityQueue()
q.put((-1,"test1"))
q.put((3,"test2"))
q.put((10,"test4"))
q.put((6,"test3"))

for i in range(4):
 print(q.get())

#按照左邊的數字排列，從小到大排列，負數也算

3.8、生產者消費者模型

import threading,time
import queue

q = queue.Queue(maxsize=10)  #佇列裡最多隻能放10個

def Producer(name):
 count = 1
 while True:
 q.put("骨頭%s" %count)
 print("生產了骨頭",name)
 count +=1
 time.sleep(2)

def Consumer(name):
 # while q.qsize()>0: #不能這樣設定，因為第一空的時候，導致跳出迴圈，就再也不會執行了
 while True: #
 print(q.get())
 print("[%s] 取到[%s] 並且吃了它...." %(name,q.get()))
 time.sleep(1)

p = threading.Thread(target=Producer,args=("longlong",))

c = threading.Thread(target=Consumer,args=("Dog_1",))
c1 = threading.Thread(target=Consumer,args=("Dog_2",))

p.start()
c.start()
c1.start()


吃包子：

import time,random
import queue,threading
q = queue.Queue()
def Producer(name):
    count = 0
    while count <20:
 time.sleep(random.randrange(3))
 q.put(count)
 print('Producer %s has produced %s baozi..' %(name,count))
 count +=1
def Consumer(name):
 count = 0
 while count <20:
 time.sleep(random.randrange(4))
 if not q.empty(): #
 data = q.get()
 # print(data)
 print('\033[32;1mConsume %s has eat %s baozi...\033[0m' %(name,data))
 else:
 print("-----no baozi anymore----")
 count +=1
p1 = threading.Thread(target=Producer,args=('A',))
c1 = threading.Thread(target=Consumer,args=('B',))
p1.start()
c1.start()