python学习第九天
paramiko模块
ssh 密钥连接连接
import paramiko
private_key =pramiko.RSAKey.from_private_key_file("私钥路径")
ssh =paramiko.SShClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect(hostname=",port=",username=",pkey=private_key)
#ssh.connect(hostname=",port=",username=",password=")
stdin,stdout,stderr =ssh.exec_command("")
result =stdout.read()
ssh.close(0
scp 密钥连接传输
import paramiko
private_key =pramiko.RSAKey.from_private_key_file("私钥路径")
transport =paramiko.Transport("","")
transport.connect(username="",pkey=private_file)
#transport.connect(username="",password="")
sftp =paramiko.SFTPClient.from_transport(transport)
sftp.put("原文件路径","目标文件路径")
sftp.get("目标文件路径","本地路径")
transport.close()
进程：程序调用资源的一个集合
线程：程序指令的集合
进程与线程的区别
主线程创建子线程，线程间相互独立
线程共享内存，进程内存独立
启动线程比进程快
线程可以直接通信，进程需要中间进程
线程可以操控其他线程，进程只能操控子进程
多线程
import threading
import time
def run(n):
print("task",n)
time.sleep(2)
t1 =threading.Thread(target=run,args=("t1",)) 并发执行
t1.start()
t2 =threading.Thread(target=run,args=("t2",))
t2.start()
# run("t1") 串行执行
# run("t2")
多线程的类方法实现
import threading
class MyThread(threading.Thread):
def __init__(self,n):
super(MyThread,self).__init__()
self.n =n
def run(self):
print("runint task",self.n)
t1 =MyThread("t1")
t2 =MyThread("t2")
t1.start()
t2.start()
同时启动多个并发任务并获取每个线程的执行完成
import threading,time
def run(n):
print("task",n)
time.sleep(2)
start_time =time.time()
t_obj =[]
for i in range(50):
t =threading.Thread(target=run,args=("t-%s"%i,))
#t.setDaemon(True)设置守护线程，等待非守护线程结束后该线程就结束
t.start()
t_obj.append(t)
for t in t_obj:
t.join() 等待相应线程的执行完成
print("cost",time.time()-start_time)
各种锁
import threading,time
# num =0
# thread_list =[]
# def run():
# global num
# # lock.acquire()
# num +=1
# print(num)
# # lock.release()
#
#
'''生成全局线程锁'''
# lock = threading.Lock()
# for i in range(5):
# t =threading.Thread(target=run)
# t.start()
# thread_list.append(t)
#
# for j in thread_list:
# j.join()
# def run1():
# lock.acquire()
# global num
# num +=1
# lock.release()
# return num
# def run2():
# lock.acquire()
# global num2
# num2 +=1
# lock.release()
# return num2
# def run3():
# lock.acquire()
# res1 =run1()
# print("-----run1 done-----")
# res2 =run2()
# lock.release()
# print(res1,res2)
#
# if __name__ =="__main__":
# num,num2 =0,0
'''生成递归锁，防止线程锁死'''
# lock =threading.RLock()
# for i in range(5):
# t =threading.Thread(target=run3)
# t.start()
#
# while threading.active_count() !=1:
# print("active_count:",threading.active_count())
# else:
# print("all thread done")
# print(num,num2)
def run(n):
semaphore.acquire()
print("task",n)
time.sleep(2)
semaphore.release()
'''同时只能运行5个子线程'''
semaphore =threading.BoundedSemaphore(5)
for i in range(20):
t =threading.Thread(target=run,args=("%s"%i,))
t.start()
队列
import queue
'''实例化先进先出队列,定义队列最大可存放数据个数'''
q =queue.Queue(maxsize=5)
'''将数据放入队列'''
q.put(1)
q.put(2)
q.put(3)
q.put(4)
q.put(5)
'''在放入数据时，如果队列已满就直接报错返回'''
# q.put_nowait(6)
'''检测队列是否已满'''
print(q.full())
'''检测队列现有数据个数'''
print("queue size:",q.qsize())
'''从队列中取出数据'''
print(q.get())
print(q.get())
print(q.get())
print(q.get())
print(q.get())
'''取数据时如果队列为空就直接报错返回'''
# print(q.get_nowait())
'''block为True时，在取数据时如果队列为空就一直等待新书据存入队列并取出；如果block为False，在取数据时如果队列为空就直接报错返回'''
# print(q.get(block=False))
'''timeout代表取数据的超时时间'''
# print(q.get(timeout=1))
'''检测队列是否为空'''
print(q.empty())
import queue
'''实例化后进先出队列，设置最大存放数据个数'''
q =queue.LifoQueue(maxsize=3)
q.put(1)
q.put(2)
print(q.get())
import queue
'''实例化自定义优先级队列，设置最大可存放数据个数'''
q =queue.PriorityQueue(maxsize=3)
'''以元组形式存入数据，元组第一个元素为优先级，第二个元素为要存入的数据，第一个元素的值越小优先级越高'''
q.put((2,"alex"))
q.put((-1,"jack"))
q.put((1,"tianshuai"))
print(q.get())
print(q.get())
print(q.get())
生产者消费者模型
import threading,queue,time
q =queue.Queue(maxsize=10)
def product(name):
count = 1
while True:
q.put("骨头%d" ,count)
print("[%s]生产了骨头%d"%(name,count))
count +=1
time.sleep(2)
def consumer(name):
while True:
print("[%s]取了骨头[%s]，并吃了它"%(name,q.get()))
time.sleep(1)
t =threading.Thread(target=product,args=("alex",))
t2 =threading.Thread(target=consumer,args=("jack",))
t3 =threading.Thread(target=consumer,args=("wangnima",))
t.start()
t2.start()
t3.start()
event事件
event = threading.Event() 设置时间
event.wait() 等待标志位
event.set() 设置标志位
event.clear() 清空标志位
import threading,time
import random
def light():
'''判断标志位是否被设置'''
if not event.isSet():
'''设置标志位，线程不阻塞'''
event.set() #wait就不阻塞 #绿灯状态
count = 0
while True:
if count < 10:
print('\033[42;1m--green light on---\033[0m')
elif count <13:
print('\033[43;1m--yellow light on---\033[0m')
elif count <20:
if event.isSet():
'''清除标志位，线程阻塞'''
event.clear()
print('\033[41;1m--red light on---\033[0m')
else:
count = 0
event.set() #打开绿灯
time.sleep(1)
count +=1
def car(n):
while 1:
time.sleep(random.randrange(10))
if event.isSet(): #绿灯
print("car [%s] is running.." % n)
else:
print("car [%s] is waiting for the red light.." %n)
if __name__ == '__main__':
event = threading.Event()
Light = threading.Thread(target=light)
Light.start()
for i in range(3):
t = threading.Thread(target=car,args=(i,))
t.start()
import threading
import time
import random
def door():
door_open_time_counter = 0
while True:
if door_swiping_event.is_set():
print("\033[32;1mdoor opening....\033[0m")
door_open_time_counter +=1
else:
print("\033[31;1mdoor closed...., swipe to open.\033[0m")
door_open_time_counter = 0 #清空计时器
door_swiping_event.wait()
if door_open_time_counter > 3:#门开了已经3s了,该关了
door_swiping_event.clear()
time.sleep(0.5)
def staff(n):
print("staff [%s] is comming..." % n )
while True:
if door_swiping_event.is_set():
print("\033[34;1mdoor is opened, passing.....\033[0m")
break
else:
print("staff [%s] sees door got closed, swipping the card....." % n)
print(door_swiping_event.set())
door_swiping_event.set()
print("after set ",door_swiping_event.set())
time.sleep(0.5)
door_swiping_event = threading.Event() #设置事件
door_thread = threading.Thread(target=door)
door_thread.start()
for i in range(5):
p = threading.Thread(target=staff,args=(i,))
time.sleep(random.randrange(3))
p.start()
浙公网安备 33010602011771号