【Python】socket通訊

小亮520cl發表於2017-11-09

一、使用socket實現一對一的簡單通訊  

socket就是一個開往網路應用必備的功能模組。透過這個模組我們可以自己寫程式的server端和client端,可以自己定義server端對外提供伺服器的ip地址和埠。學會使用這個模組的之後我們不僅可以開往網路程式,還可以利用socket模組開發出埠掃描的程式。

先看一段建立伺服器端的程式碼


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

  4. #定義伺服器端啟動後要繫結的ip和埠
  5. ip_port = ('0.0.0.0',9999)
  6. # 建立socket物件並指定連線的網路型別和傳輸協議
  7. sk=sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  8. #繫結ip和埠號
  9. sk.bind(ip_port)
  10. #啟動監聽,並設定最多可以通知連入連線數
  11. sk.listen(5)
  12. #用while使程式一直執行
  13. while True:
  14.     #print 'server waiting...'
  15.     """
  16.     進入accpet阻塞狀態來等待客戶端的連線請求
  17.     儲存客戶端的連線狀態和客戶端的地址
  18.     """
  19.     conn,addr = sk.accept()
  20.     print addr
  21.     #如果有客戶端發來請求就每次都只接受1024個位元組的內容,注意recv()也是阻塞的
  22.     client_data = conn.recv(10240)
  23.     #列印從客戶端接收到的字串
  24.     print client_data                ----客戶端ip地址
  25.     #向客戶端傳送字串
  26.     conn.sendall("I`m server")
  27.     #關閉連線
  28.     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()

透過以上兩段程式碼的執行,我們就實現了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. def save_to_txt(addr,data):
  5.                 path='/tmp/'+addr+'/slow.log'
  6.                 file_path = os.path.split(path)
  7.                 if not os.path.exists( file_path[0] ):
  8.                         os.makedirs( file_path[0] )
  9.                         print '建立目錄成功'
  10.                 if len(data)>0:
  11.                         try:
  12.                                 with open( path.encode('utf-8'),'ab' ) as f:
  13.                                         data = data+"\n"
  14.                                         f.write( data.encode('utf-8') )
  15.                                         
  16.                         except:
  17.                                 print '資料插入失敗'
  18.                 else:
  19.                         print '沒有資料'


  20. #定義伺服器端啟動後要繫結的ip和埠
  21. ip_port = ('0.0.0.0',9999)
  22. # 建立socket物件並指定連線的網路型別和傳輸協議
  23. sk=sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  24. #繫結ip和埠號
  25. sk.bind(ip_port)
  26. #啟動監聽,並設定最多可以通知連入連線數
  27. sk.listen(5)
  28. #用while使程式一直執行
  29. while True:
  30.     #print 'server waiting...'
  31.     """
  32.     進入accpet阻塞狀態來等待客戶端的連線請求
  33.     儲存客戶端的連線狀態和客戶端的地址
  34.     """
  35.     conn,addr = sk.accept()
  36.     print addr
  37.     #如果有客戶端發來請求就每次都只接受1024個位元組的內容,注意recv()也是阻塞的
  38.     client_data = conn.recv(10240)
  39.     #列印從客戶端接收到的字串
  40.     print client_data
  41.     save_to_txt(addr[0],client_data) ----接送並寫入日誌檔案
  42.     #向客戶端傳送字串
  43.     conn.sendall("I`m server")
  44.     #關閉連線
  45.     conn.close()
client改寫
  1. # -*- coding: utf-8 -*-
  2. import socket
  3. def sendtxt(line):
  4.     ip_port = ('192.168.2.136',9999)
  5.     #建立socket例項,引數不填的話就採用ipv4協議透過tcp傳輸
  6.     sk = socket.socket()
  7.     #發起連線到server端
  8.     sk.connect(ip_port)
  9.     #給server端發訊息
  10.     sk.sendall(line)
  11.     #傳送完成後接收server端的反饋
  12.     server_reply = sk.recv(10240)
  13.     #列印server端反饋的資訊
  14.     print server_reply
  15.     #關閉連線
  16.     sk.close()


  17. import fileinput
  18. import time
  19. import os

  20. target_file = 'log.txt'
  21. init_flag = True # 初次載入程式

  22. record_count = 0

  23. while True:
  24.         if init_flag:
  25.             #讀取整個檔案
  26.             # for eachline in fileinput.input(target_file):
  27.             # print eachline
  28.             # record_count += 1
  29.             total_count = os.popen('wc -l %s' % target_file).read().split()[0]
  30.             total_count = int(total_count)
  31.             record_count = total_count

  32.             init_flag = False
  33.         else:
  34.             #如果總行數小於當前行,那麼認為檔案更新了,從第一行開始讀。
  35.             total_count = os.popen('wc -l %s' % target_file).read().split()[0]
  36.             total_count = int(total_count)
  37.             if total_count < record_count:
  38.                 record_count = 0

  39.             for eachline in fileinput.input(target_file):
  40.                 line_no = fileinput.filelineno()
  41.                 if line_no > record_count:
  42.                    if len(eachline.strip('\n')) > 0:
  43.                        print eachline.strip('\n')
  44.                        sendtxt(eachline.strip('\n')) --傳送
  45.                        record_count += 1
  46.                    else:
  47.                        sendtxt(' ')
  48.                        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.csdn.net/u012063703/article/details/46007299



來自 “ ITPUB部落格 ” ,連結:http://blog.itpub.net/29096438/viewspace-2147022/,如需轉載,請註明出處,否則將追究法律責任。

相關文章