Paramiko模块：
paramiko模块导入：cmd-->pip install paramiko
SSHClient密码连接：
import paramiko # 创建SSH对象 ssh = paramiko.SSHClient() # 允许连接不在know_hosts文件中的主机 ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) # 连接服务器 ssh.connect(hostname='c1.salt.com', port=22, username='wupeiqi', password='123') # 执行命令 stdin, stdout, stderr = ssh.exec_command('df')#返回标准输入，标准输出，标准错误 # 获取命令结果 result = stdout.read() # 关闭连接 ssh.close()
ssh密钥：
RSA--非对称密钥验证
分为公钥（public key）和私钥（private key），公钥和私钥成对出现，有私钥的用户可以无密码连接有公钥的用户。
#ssh 秘钥连接，生成秘钥需要在linix系统上 import paramiko private_key = paramiko.RSAKey.from_private_key_file('/home/auto/.ssh/id_rsa')#指定私钥的位置 # 创建SSH对象 ssh = paramiko.SSHClient() # 允许连接不在know_hosts文件中的主机 ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) # 连接服务器 ssh.connect(hostname='c1.salt.com', port=22, username='wupeiqi', pkey=private_key) # 执行命令 stdin, stdout, stderr = ssh.exec_command('df') # 获取命令结果 result = stdout.read() # 关闭连接 ssh.close()
SFTPClient文件上传和下载：
import paramiko # 创建SSH对象 ssh = paramiko.SSHClient() # 允许连接不在know_hosts文件中的主机 ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) # 连接服务器 ssh.connect(hostname='c1.salt.com', port=22, username='wupeiqi', password='123') # 执行命令 stdin, stdout, stderr = ssh.exec_command('df')#返回标准输入，标准输出，标准错误 # 获取命令结果 result = stdout.read() # 关闭连接 ssh.close()
线程与进程：
线程：线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。（一堆指令）
进程：程序要以一个整体的形式暴露给操作系统管理，里面包含对各种资源的调用，内存的管理，网络接口的调用等。对各种资源管理的集合，就可以称为进程。一个程序的执行实例称为一个进程。每一个进程的内存都是独立的，互相不能直接访问。进程要操作cpu必须要先创建一个线程。
启动一个线程比启动一个进程快，线程与进程的运行速度没有可比性，进程是线程的集合，不同线程运行速度看具体情况。
进程与线程的区别：
1、线程之间共享进程创造的内存地址。进程之间的内存空间独立。
2、线程可以直接访问进程里的数据片段。进程有属于自己的数据段，进程之间不能互相访问。
3、线程可以直接和同进程里的线程进行数据交互。两个进程要通信，必须通过一个中间代理来实现。
4、新的线程容易创建。新的进程需要克隆父类进程创建。
5、一个线程可以控制和操作同一个进程里的其他线程。但是进程只能操作子进程。
6、对主线程的修改（取消、修改优先级）可能会影响其他同进程下的线程。对父进程的修改不会影响子进程。
守护线程deamon：
主线程关闭时，守护线程自动关闭，由守护线程启动的其他子线程也会关闭。非守护线程全退出后，程序马上退出。守护线程优先级很低。
线程的调用方式:
#直接调用方式 import threading,time StartTime=time.time() t_obj=[] def run(x,y): time.sleep(2) print(x,y,x+2*y,'当前线程:%s'%threading.current_thread()) t1=threading.Thread(target=run,args=(5,2))#创造线程 t2=threading.Thread(target=run,args=(3,4)) t1.start()#启动线程 t_obj.append(t1) #join(timeout=None),timeout为超时时间，即最大等待时间 #t1.join()#=t1.wait()等待t1线程执行完，才开始执行后面的代码 t2.start() t_obj.append(t2) #t2.join()#=t2.wait()等待t2线程执行完，才开始执行后面的代码 print(t1.getName()) #获取线程名 print(t2.getName()) #t1和t2并发运行，同时进行time.sleep #启动多个线程 for i in range(3,50): t=threading.Thread(target=run,args=(i,2)) t.setDaemon(True)#把线程t设置为主线程的守护线程，必须在start之前设置 t.start() #t_obj.append(t) #主线程与子线程是并行状态 print('活跃的线程个数：',threading.active_count())#打印正在运行的线程个数 for t in t_obj:#等待所有子线程结束 t.join() EndTime=time.time() print('总共运行时间',EndTime-StartTime) print('主线程：',threading.current_thread())#打印当前线程 print('活跃的线程个数：',threading.active_count()) # run(5,2) # run(3,4) # #按顺序运行
#继承时调用,效果与直接调用相同 import threading,time class MyThreading(threading.Thread): def __init__(self,x,y,sleep_time): super(MyThreading, self).__init__() self.x=x self.y=y self.sleep_time=sleep_time def run(self):#函数名必须为run time.sleep(self.sleep_time) print(self.x, self.y, self.x + 2 * self.y) print('task done') t1=MyThreading(5,2,5) t2=MyThreading(3,4,1) t1.start() t2.start()
GIL(Globe Interpreter Lock)：全局解释器锁。即使是多核系统，在同一时间，只会有一个线程在运行。（cpython缺陷）
线程锁（互斥锁Mutex）：保证锁住部分处于一个串行状态。
#线程锁（互斥锁Mutex），保证锁住部分处于一个串行状态 import threading,time numb=0#定义全局变量 def run(): #lock.acquire()#获取一把锁 global numb#访问全局变量 time.sleep(2) numb+=1 #ock.release()#释放锁 t_obj=[] #lock=threading.Lock()#声明lock实例，线程锁，保证锁住部分处于一个串行状态 for i in range(100): t=threading.Thread(target=run,name='threading-%s'%i) t.start() print(t.getName()) t_obj.append(t) for t in t_obj: t.join() print('numb:',numb)
递归锁RLock：当线程锁里还存在线程锁时，需要使用递归锁，否者陷入死循环。
#递归锁Rlock import threading, time def run1(): print("grab the first part data") lock.acquire() global num num += 1 lock.release() return num def run2(): print("grab the second part data") lock.acquire() global num2 num2 += 1 lock.release() return num2 def run3(): lock.acquire() res = run1() print('--------between run1 and run2-----') res2 = run2() lock.release() print(res, res2) if __name__ == '__main__': num, num2 = 10, 10 lock = threading.RLock()#有多层lock时，必须用RLock。 for i in range(10): t = threading.Thread(target=run3) t.start() while threading.active_count() != 1: print(threading.active_count()) else: print('----all threads done---') print(num, num2)
semaphore信号量：
互斥锁同时只允许一个线程更改数据，而Semaphore是同时允许一定数量的线程更改数据，由信号量大小决定。
#semaphpore信号量 #互斥锁 同时只允许一个线程更改数据，而Semaphore是同时允许一定数量的线程更改数据 import threading, time def run(n): semaphore.acquire() time.sleep(1) print("run the thread: %s\n" % n) semaphore.release() if __name__ == '__main__': semaphore = threading.BoundedSemaphore(5) # 最多允许5个线程同时运行，单次最大同时运行为5个，每完成一个，等候的线程接上。 for i in range(20): t = threading.Thread(target=run, args=(i,)) t.start() while threading.active_count() != 1: pass # print threading.active_count() else: print('----all threads done---')
Event标志位使用：
Event事件
event=threading.Event()生成一个Event对象
event.set（）设置变量，服务端线程可以设定标志位
event.clear（）清除，服务端线程可以清除标志位
event.wait（）等待，如果标志位被设定，wait（）不会被堵塞；如果标志位被清空，wait（）会继续堵塞。多个线程可以等待一个event
使用示例（红绿灯程序）：
# Event事件 # event=threading.Event()生成一个Event对象 # event.set（）设置变量，服务端线程可以设定标志位 # event.clear（）清除，服务端线程可以清除标志位 # event.wait（）等待，如果标志位被设定，wait（）不会被堵塞；如果标志位被清空，wait（）会继续堵塞。多个线程可以等待一个event #示例（红绿灯）： import threading,time event=threading.Event() def TrafficLight(): while True: event.set() print('\033[42;1m Green traffic light is on...\033[0m') time.sleep(20) event.clear() print('\033[41;1m Red traffic light is on...\033[0m') time.sleep(10) def car(name): while True: if event.is_set(): print('[%s] Running....'%name) else: print('%s seeing red traffic light .Waitting...'%name) event.wait() print('%s go go go'%name) time.sleep(1) t1=threading.Thread(target=TrafficLight) t1.start() t2=threading.Thread(target=car,args=('aodi',)) t2.start() t3=threading.Thread(target=car,args=('baoma',)) t3.start() t4=threading.Thread(target=car,args=('luhu',)) t4.start()
queue队列：
特性：数据有序，取走后便消失
class queue.Queue(maxsize=0) #先入先出
class queue.LifoQueue(maxsize=0) #last in fisrt out（缩写Lifo）
class queue.PriorityQueue(maxsize=0) #存储数据时可设置优先级的队列
Queue.put(item, block=True, timeout=None)数据放入队列
Queue.get(block=True, timeout=None)从队列中取出数据
Queue.qsize()return队列的大小
Queue.full()如果队列是满的话，return Ture
Queue.empty()如果队列为空，return Ture
Queue.join() block直到queue被消费完毕
#queue队列：数据有序，取走后便消失 # class queue.Queue(maxsize=0) #先入先出 # class queue.LifoQueue(maxsize=0) #last in fisrt out（缩写Lifo） # class queue.PriorityQueue(maxsize=0) #存储数据时可设置优先级的队列 # Queue.put(item, block=True, timeout=None)数据放入队列 # Queue.get(block=True, timeout=None)从队列中取出数据 # Queue.qsize()return队列的大小 # Queue.full()如果队列是满的话，return Ture # Queue.join() block直到queue被消费完毕 import queue q=queue.Queue(maxsize=3)#生成一个queue的对象，maxsize默认不限制大小,maxsize为队列中最大存放数目,maxsize小于等于0，则为无限大 name='wulihui' q.put(name)#放入数据 q.put('list1') q.put('list2') #q.put('list3')#放入数据超过maxsize，程序卡住，直到队列中有数据取出 print(q.full())#队列满了，返回Ture，没满返回False print(q.qsize())#返回队列里项目的个数 print(q.get())#取数据，先入先出，无法改变顺序，取完后数据从队列中消失 print(q.get()) #print(q.get()) #print(q.get())没有数据时会堵塞，一直等数据加入，程序卡住 print(q.get_nowait())#取不到数据，则抛出异常queue.Empty，有数据则会取出 #print(q.get(block=False))效果等于print(q.get_nowait()) print(q.empty())#队列为空返回Ture,否者返回False print('----------------------------PriorityQueue----------------') q2=queue.PriorityQueue()#实例化可设优先级队列 q2.put((5,'zhaoyun'))#传入一个元组，第一个为用来排序的字符，从小到大，第二个为item q2.put((-3,'diaocan')) q2.put((1000,'nvbu')) q2.put((-1800,'baiqi')) print(q2.get()) print(q2.get()) print(q2.get()) print(q2.get())
生产者消费者模型：
生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。
模型示例：
import queue,threading,time,random q=queue.Queue(maxsize=10) def producer(name): numb = 1 while True: q.put('骨头%s'%numb) print('%s 生产了骨头%s'%(name,numb)) numb=numb+1 time.sleep(random.randint(0,2)) def comsumer(name): while True: print('%s has eat the %s...'%(name,q.get())) time.sleep(random.randint(0,4)) p=threading.Thread(target=producer,args=('狗粮1厂',)) c=threading.Thread(target=comsumer,args=('shamoye',)) c2=threading.Thread(target=comsumer,args=('bixiong',)) p.start() c.start() c2.start()
