<--目录-->
1、Socket传文件
2、多线程
3、paramiko
1、Socket传文件
Socket服务端
cat server.py
#!/usr/bin/env python
#coding:utf-8
import SocketServer
import os
class MyServer(SocketServer.BaseRequestHandler):
def handle(self):
base_path = 'g:/index' #存放接收文件的路径,index文件夹必须事先存在
conn = self.request#收到客户端的请求连接
print 'connected...'#输出连接,代表客户端已跟我建立连接
while True:#死循环
pre_data = conn.recv(1024)#每次接收数据1024,收到客户端发送的请求方法、文件名、文件大小的数据
cmd,file_name,file_size = pre_data.split('|') #获取请求方法、文件名、文件大小
recv_size = 0 #已经接收文件的大小,先定义为0
file_dir = os.path.join(base_path,file_name) #上传文件路径拼接,即我本地的文件夹路径拼客户端的文件名
f = file(file_dir,'wb') #对上传的文件有可写权限
Flag = True
while Flag: #死循环
if int(file_size)>recv_size:#未上传完毕,即客户端传过来给我的文件大小大于我接收到的文件大小
data = conn.recv(1024)#最多接收1024,可能接收的小于1024,接收数据
recv_size+=len(data) #将接收的数据加入recv_size
else:#上传完毕,则退出循环
recv_size = 0再次将recv_size定义为0,进行下一次文件的传送接收
Flag = False#定义Flag为False则不再则行死循环
continue#跳出本次循环
f.write(data)#将接收到的数据写入文件
print 'upload successed.'#输出上传成功
f.close()`#关闭文件
instance = SocketServer.ThreadingTCPServer(('127.0.0.1',9999),MyServer) #异步多线程
instance.serve_forever()
Socket客户端
cat client.py
#!/usr/bin/env python
#coding:utf-8
import socket
import sys
import os
ip_port = ('127.0.0.1',9999)
sk = socket.socket()
sk.connect(ip_port)
while True:
input = raw_input('path:') #输入路径
cmd,path = input.split('|') #前面上传命令,随便写,|后面是本地文件路径 如put|g:/test.txt
file_name = os.path.basename(path) #获取文件名字,如test.txt
file_size=os.stat(path).st_size #获取文件大小
sk.send(cmd+"|"+file_name+'|'+str(file_size)) #发送 "上传命令" | "文件名" | "文件大小"
send_size = 0 #定义发送大小刚开始等于0
f= file(path,'rb') #打开文件
Flag = True
while Flag: #死循环
if send_size + 1024 >file_size: #如果发送大小再加+1024则行下面语句,每次发送只能是1024
data = f.read(file_size-send_size) #总文件大小减去-已发送大小=还没发送大小
Flag = False
else: #否则
data = f.read(1024) #读文件1024的数据,然后赋值给data
send_size+=1024 #然后发送了的大小每次累加1024
sk.send(data) #发送读的1024的数据
f.close() #关闭文件
sk.close() #关闭socket
2、多线程开发
start 线程准备就绪,等待CPU调度
setName 为线程设置名称
getName 获取线程名称
setDaemon 设置为后台线程或前台线程(默认)
如果是后台线程,主线程执行过程中,后台线程也在进行,主线程执行完毕后,后台线程不论成功与否,均停止
如果是前台线程,主线程执行过程中,前台线程也在进行,主线程执行完毕后,等待前台线程也执行完成后,程序停止
join 逐个执行每个线程,执行完毕后继续往下执行,该方法使得多线程变得无意义
run 线程被cpu调度后自动执行线程对象的run方法
- thred_demo 包
-index.py 模块文件
1)创建线程,执行线程,守护模式
cat index.py
#!/usr/bin/env python
#coding:utf-8
from threading import Thread
import time
def Foo(arg,v):
for item in range(100):
print item
time.sleep(1)
print 'before'
t1 = Thread(target=Foo,args=('abc',1,)) #与函数建立关系,创建线程
t1.setDaemon(True) #守护模式,只执行主线程,如果主线程一直没有结束,子线程会执行,什么时候主线程结束了,子线程才会跟着一起销毁
t1.start() #执行线程
print
#print t1.isDaemon #子线程执行完了,主线程才中断,这个很少用
print t1.getName() #输出线程名字
print 'after'
print 'after'
print 'after'
print 'after end'
time.sleep(3)
2)join练习
#!/usr/bin/env python
#coding:utf-8
from threading import Thread
import time
def Foo(arg,v):
for item in range(100):
print item
time.sleep(1)
print 'before'
t1 = Thread(target=Foo,args=('abc',1,)) #与函数建立关系
#t1.setDaemon(True) #守护模式,只执行主线程,主线程执行结束了,子线程也会跟着销毁
t1.start() #执行线程
t1.join(5) #只执行到Join这里,下面的内容主线程不再执行,只执行子线程的,最多给你五秒时间,超时则执行下面主线程的内容
print
print t1.getName() #输出线程名字
print 'after'
print 'after'
print 'after'
print 'after end'
time.sleep(10)
3)自定义线程类,run()练习示例
from threading import Thread
import time
class MyThread(Thread): #继承Thread
def run(self):
#time.sleep(10)
print '我是线程'
Thread.run(self) #调用父类的run方法 ,如果没有这句,则不会执行下面函数的print 'bar'
def Bar():
print 'bar'
t1 = MyThread(target=Bar)
t1.start()
print 'over'
4)面向对象实现生产者消费者模型
cat producter_demo.py
#!/usr/bin/env python
#coding:utf-8
from threading import Thread
from Queue import Queue
import time
class Procuder(Thread):
def __init__(self,name,queue):
'''
@param name:生产者的名称
@param queue:容器
'''
self.__Name = name
self.__Queue = queue
super(Procuder,self).__init__() #调用父类的构造函数
def run(self):
while True:
if self.__Queue.full(): #包子满了
time.sleep(1)
else:
self.__Queue.put('baozi')
time.sleep(1)
print '%s 生产了一个包子' %(self.__Name,)
#Thread.run(self)
class Consumer(Thread):
def __init__(self,name,queue):
'''
@param name:生产者的名称
@param queue:容器
'''
self.__Name = name
self.__Queue = queue
super(Consumer,self).__init__() #调用父类的构造函数
def run(self):
while True:
if self.__Queue.empty(): #没有包子了则休息一秒
time.sleep(1)
else:
self.__Queue.get('baozi')
time.sleep(1)
print '%s 消费了一个包子' %(self.__Name,)
#Thread.run(self)
que = Queue(maxsize=100) #创建一个队列,空间大小一百,放包子
baogou1 = Procuder('老王1',que)
baogou1.start()
baogou2 = Procuder('老王2',que)
baogou2.start()
baogou3 = Procuder('老王3',que)
baogou3.start()
for item in range(20):
name = 'chentao%d' %(item,)
temp = Consumer(name,que)
temp.start()
'''
print que.qsize() #查看占用的数据大小为0
que.put('1') #往里面存放数据
que.put('2') #往里面存放数据
print 'empty:',que.empty() #查看是为空,不为空就是有数据也就是False
print que.qsize() #查看占用的数据大小为2
print 'get:',que.get() #取数据1
print 'get:',que.get() #取数据2,取到没有了就不会再取了
print 'empty:',que.empty() #为空没数据为就是True
'''
5)函数式编程实现生产者消费者模型
cat consumer_producer.py
#!/usr/bin/env python
#coding:utf-8
import threading
import time
import Queue
import random
def Proudcer(name,que):
while True:
if que.qsize() < 3:
que.put('baozi')
print '%s:生产一个包子===========================' %name #生产一个包子
time.sleep(random.randrange(4)) #随机睡眠N秒后再生产包子
else:
print U'还有大于或等于3个包子'
def Consumer(name,que):
while True:
try:
que.get_nowait() #取得一个包子,默认先生产的就先取得,如果没有包子,就会报错
except Exception:
print U'没有包子了。。。'
else:
print '%s:买一个包子' %name
time.sleep(random.randrange(3)) #随机睡眠N秒后再买包子
q = Queue.Queue() #定义容器,没定义大小就是无限大
p1 = threading.Thread(target=Proudcer,args=['zhang1',q])
p2 = threading.Thread(target=Proudcer,args=['zhang2',q])
p1.start()
p2.start()
c1 = threading.Thread(target=Consumer,args=['xie1',q])
c2 = threading.Thread(target=Consumer,args=['xie2',q])
c1.start()
c2.start()
进程和线程的区别?
1、进程可以理解为一个应用程序在处理机上的一次执行过程,一个进程包含多个线程
2、进程间相互独立,同一进程的各线程间共享内存,某线程内的线程在其它进程不可见
3、进程不可以共享内存,进程产生子进程,并且子进程继承了对应的父进程的大部分属性
多线程开发之线程锁( threading.Lock() ),一把锁
#!/usr/bin/env python
#coding:utf-8
import threading
import time
num = 0
def run(n):
time.sleep(1)
global num #加上global可以在局部变量改全局变量的值
lock.acquire() #加上锁,单线程执行
num +=1
lock.release() #解锁,加锁了就要解锁
print '%s\n' %num
lock = threading.Lock()
for i in range(100):
t = threading.Thread(target=run,args=(i,))
t.start()
#多把锁实战( threading.RLock() )
#!/usr/bin/env python
#coding:utf-8
import threading
import time
num = 0
num2 = 0
def run(n):
time.sleep(1)
global num #加上global可以在局部变量改全局变量的值
global num2
lock.acquire() #加上锁,单线程执行
num += 1
lock.acquire()
num2 += 2
lock.release()
lock.release() #解锁,加锁了就要解锁
time.sleep(0.01)
print '%s\n' %num
lock = threading.RLock()
for i in range(200):
t = threading.Thread(target=run,args=(i,))
t.start()
设置允许最大连接数、线程数
#!/usr/bin/env python
#coding:utf-8
import threading
import time
num = 0
def run(n):
time.sleep(1)
global num #加上global可以在局部变量改全局变量的值
samp.acquire() #加上锁,4线程同时执行
num += 1
print '%s' %num
samp.release() #解锁
samp = threading.BoundedSemaphore(4) #最大连接数,也就是同时运行的线程数
for i in range(200):
t = threading.Thread(target=run,args=(i,))
t.start()
多线程开发之事件(通过信号来做数据交互)
#!/usr/bin/env python
#coding:utf-8
import threading
import time
def producer():
print u'老蔡:等人来买包子。。。'
event.wait() #等待对方的事件
event.clear() #清空事件,把True变为False
print u"老蔡:你是要来买包子吗"
print u"老蔡:包子就快做好了"
time.sleep(5)
print u'老蔡:你的包子做好了'
event.set() #设置事件,变为True
def consumer():
print u'老王:去买包子。。。'
event.set() #用来设置事件告知对方
time.sleep(2)
print u"老王:等你的包子做好呀"
while True:
if event.isSet(): #用来检测事件变量是否设置,该函数返回的是否布尔值,即true/false
print u"老王:Thanks..."
break
else:
print u"还没做好吗"
time.sleep(1)
event = threading.Event()
p = threading.Thread(target=producer)
c = threading.Thread(target=consumer)
p.start()
c.start()
paramiko详解(第三方模块需要下载)
下载安装
pycrypto-2.6.1.tar.gz
paramiko-1.10.1.tar.gz
yum install gcc python-devel
1、下载安装 pycrypto-2.6.1.tar.gz
解压,进入,python setup.py build【编译】,python setup.py install 【安装】 ----》import Crypto
2、下载安装 paramiko-1.10.1.tar.gz
解压,进入,python setup.py build【编译】,python setup.py install 【安装】---》 import paramiko
#基于密码连接
[root@test1 opt]# cat ssh.py
#!/usr/bin/env python
#coding:utf-8
import paramiko
# 创建SSH对象
ssh = paramiko.SSHClient()
# 允许连接不在know_hosts文件中的主机,平常连接会要你输入YES,有了这句话直接允许不用输入YES
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
# 连接服务器
ssh.connect(hostname='192.168.200.11', port=22, username='root', password='hengtai')
# 执行命令,stdin是输入命令,stdout是输出的结果,stderr是指输出的报错,三个都要写上去,否则执行会报错
stdin,stdout,stderr = ssh.exec_command('df -h')
# 获取命令结果
result_out = stdout.read()
result_err = stderr.read()
print result_out
print result_err
# 关闭连接
ssh.close()
#基于密钥连接
[root@test1 opt]# cat skey.py
#!/usr/bin/env python
#coding:utf-8
import paramiko
private_key_path = '/root/.ssh/id_rsa' #输入Key的路径
key = paramiko.RSAKey.from_private_key_file(private_key_path) #获得key
ssh = paramiko.SSHClient() #获取连接ssh方法
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) #获允许连接不在know_hosts文件中的主机
ssh.connect(hostname='192.168.200.11', port=22, username='root', pkey=key) #连接相关信息
stdin, stdout, stderr = ssh.exec_command('ifconfig') #执行命令
print stdout.read() #输出命令
ssh.close(); #关闭
转载于:https://blog.51cto.com/yht1990/1842116