码迷,mamicode.com
首页 > 编程语言 > 详细

python 第八天

时间:2019-01-03 12:55:43      阅读:199      评论:0      收藏:0      [点我收藏+]

标签:连接服务器   需要   \n   time()   proc   转换   scn   通讯   ssh2   

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


 

python 第八天

标签:连接服务器   需要   \n   time()   proc   转换   scn   通讯   ssh2   

原文地址:https://www.cnblogs.com/qianyuyu/p/10210470.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!