python 第八天

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()