<--目录-->
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(); #关闭