【Python】socket通信

一、使用socket实现一对一的简单通信  

socket就是一个开往网络应用必备的功能模块。通过这个模块我们可以自己写程序的server端和client端，可以自己定义server端对外提供服务器的ip地址和端口。学会使用这个模块的之后我们不仅可以开往网络程序，还可以利用socket模块开发出端口扫描的程序。

先看一段创建服务器端的代码

1. # -*- coding: utf-8 -*-
   
2. import socket
   
3. import os
4. 
   
5. #定义服务器端启动后要绑定的ip和端口
   
6. ip_port = ('0.0.0.0',9999)
   
7. # 创建socket对象并指定连接的网络类型和传输协议
   
8. sk=sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
   
9. #绑定ip和端口号
   
10. sk.bind(ip_port)
    
11. #启动监听，并设置最多可以通知连入连接数
    
12. sk.listen(5)
    
13. #用while使程序一直运行
    
14. while True:
    
15.     #print 'server waiting...'
    
16.     """
    
17.     进入accpet阻塞状态来等待客户端的连接请求
    
18.     保存客户端的连接状态和客户端的地址
    
19.     """
    
20.     conn,addr = sk.accept()
    
21.     print addr
    
22.     #如果有客户端发来请求就每次都只接受1024个字节的内容，注意recv()也是阻塞的
    
23.     client_data = conn.recv(10240)
    
24.     #打印从客户端接收到的字符串
    
25.     print client_data                ----客户端ip地址
26.     #向客户端发送字符串
    
27.     conn.sendall("I`m server")
    
28.     #关闭连接
    
29.     conn.close()

客户端代码

1. # -*- coding: utf-8 -*-
   
2. import socket

   #指定server端的ip地址和端口号

   ip_port = ('127.0.0.1',9999)

   #创建socket实例，参数不填的话就采用ipv4协议通过tcp传输

   sk = socket.socket()

   #发起连接到server端

   sk.connect(ip_port)

   #给server端发消息

   sk.sendall("I`m client")

   #发送完成后接收server端的反馈

   server_reply = sk.recv(1024)

   #打印server端反馈的信息

   print server_reply

   #关闭连接

   sk.close()
3. 
   

通过以上两段代码的运行，我们就实现了server端与client端的通信

在server端可以到如下运行结果，接收到客户端请求之后又恢复到了等待状态

1. server waiting...
   
2. I`m client
   
3. server waiting...

在client端也看到了类似的结果，成功接收到了server端的发来的信息之后退出了程序

点击(此处)折叠或打开

1. I`m server

拓展：实时解析客户端的日志文件并发送至服务端保存

server端改写

1. # -*- coding: utf-8 -*-
   
2. import socket
   
3. import os
   
4. 
   
5. def save_to_txt(addr,data):
   
6.                 path='/tmp/'+addr+'/slow.log'
   
7.                 file_path = os.path.split(path)
   
8.                 if not os.path.exists( file_path[0] ):
   
9.                         os.makedirs( file_path[0] )
   
10.                         print '创建目录成功'
    
11.                 if len(data)>0:
    
12.                         try:
    
13.                                 with open( path.encode('utf-8'),'ab' ) as f:
    
14.                                         data = data+"\n"
    
15.                                         f.write( data.encode('utf-8') )
    
16.                                         
    
17.                         except:
    
18.                                 print '数据插入失败'
    
19.                 else:
    
20.                         print '没有数据'
    
21. 
    
22. 
    
23. #定义服务器端启动后要绑定的ip和端口
    
24. ip_port = ('0.0.0.0',9999)
    
25. # 创建socket对象并指定连接的网络类型和传输协议
    
26. sk=sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    
27. #绑定ip和端口号
    
28. sk.bind(ip_port)
    
29. #启动监听，并设置最多可以通知连入连接数
    
30. sk.listen(5)
    
31. #用while使程序一直运行
    
32. while True:
    
33.     #print 'server waiting...'
    
34.     """
    
35.     进入accpet阻塞状态来等待客户端的连接请求
    
36.     保存客户端的连接状态和客户端的地址
    
37.     """
    
38.     conn,addr = sk.accept()
    
39.     print addr
    
40.     #如果有客户端发来请求就每次都只接受1024个字节的内容，注意recv()也是阻塞的
    
41.     client_data = conn.recv(10240)
    
42.     #打印从客户端接收到的字符串
    
43.     print client_data
    
44.     save_to_txt(addr[0],client_data) ----接送并写入日志文件
    
45.     #向客户端发送字符串
    
46.     conn.sendall("I`m server")
    
47.     #关闭连接
    
48.     conn.close()

client改写

# -*- coding: utf-8 -*-
import socket
def sendtxt(line):
    ip_port = ('192.168.2.136',9999)
    #创建socket实例，参数不填的话就采用ipv4协议通过tcp传输
    sk = socket.socket()
    #发起连接到server端
    sk.connect(ip_port)
    #给server端发消息
    sk.sendall(line)
    #发送完成后接收server端的反馈
    server_reply = sk.recv(10240)
    #打印server端反馈的信息
    print server_reply
    #关闭连接
    sk.close()


import fileinput
import time
import os

target_file = 'log.txt'
init_flag = True # 初次加载程序

record_count = 0

while True:
        if init_flag:
            #读取整个文件
            # for eachline in fileinput.input(target_file):
            # print eachline
            # record_count += 1
            total_count = os.popen('wc -l %s' % target_file).read().split()[0]
            total_count = int(total_count)
            record_count = total_count

            init_flag = False
        else:
            #如果总行数小于当前行，那么认为文件更新了，从第一行开始读。
            total_count = os.popen('wc -l %s' % target_file).read().split()[0]
            total_count = int(total_count)
            if total_count < record_count:
                record_count = 0

            for eachline in fileinput.input(target_file):
                line_no = fileinput.filelineno()
                if line_no > record_count:
                   if len(eachline.strip('\n')) > 0:
                       print eachline.strip('\n')
                       sendtxt(eachline.strip('\n')) --发送                        record_count += 1
                   else:
                       sendtxt(' ')
                       record_count += 1

参考：
http://830909.blog.51cto.com/8311014/1723348
http://youzao.blog.51cto.com/3946111/1255882
http://www.cnblogs.com/wowoo1121/p/5381971.html
http://blog.youkuaiyun.com/u012063703/article/details/46007299

来自 “ ITPUB博客 ” ，链接：http://blog.itpub.net/29096438/viewspace-2147022/，如需转载，请注明出处，否则将追究法律责任。

转载于:http://blog.itpub.net/29096438/viewspace-2147022/