服务端：

  1. import socket
  2. server = socket.socket()
  3. #绑定要监听的端口
  4. server.bind(('localhost',6969))
  5. #监听
  6. server.listen()
  7. print("等待连接...")
  8. #等待连接，conn就是客户端连过来在服务端为其生成的一个连接实例
  9. conn,addr = server.accept()
  10. print("连接进行中...")
  11. print(conn,addr)
  12.  
  13. data = conn.recv(1024)
  14. print("recv:",data)
  15. conn.send(data.upper())
  16. server.close()

客户端：

  1. import socket
  2.  
  3. #声明socket类型，同时生产socket连接对象
  4. client = socket.socket()
  5. client.connect(('localhost',6969))
  6. client.send(b"hello world!")
  7. data = client.recv(1024)
  8. print("recv:",data)
  9. client.close()

服务端输出：

  1. 等待连接...
  2. 连接进行中...
  3. <socket.socket fd=328, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 6969), raddr=('127.0.0.1', 50248)> ('127.0.0.1', 50248)
  4. recv: b'hello world!'

客户端输出：

  1. recv: b'HELLO WORLD!'

连续发送信息：

服务端：

  1. import socket
  2. client = socket.socket()
  3. client.connect(('localhost',6969))
  4. while True:
  5.     msg = input(">>:").strip()
  6.     client.send(msg.encode("utf-8"))
  7.     data = client.recv(1024)
  8.     print("recv:",data.decode())
  9. client.close()

客户端：

  1. import socket
  2.  
  3. #声明socket类型，同时生产socket连接对象
  4. client = socket.socket()
  5. client.connect(('localhost',6969))
  6. client.send(b"hello world!")
  7. # client.send("我要下载".encode("utf-8"))
  8. data = client.recv(1024)
  9. print("recv:",data)
  10. client.close()

在linux上客户端执行命令

服务端：

  1. [root@test-c2c-console01 oldboy]# cat socket_server.py
  2. #-*-coding:utf-8-*-
  3. #_author_="golden"
  4. #服务端
  5. import socket
  6. import os
  7.  
  8. server = socket.socket()
  9. #绑定要监听的端口
  10. server.bind(('localhost',6969))
  11. #监听，最大连接数
  12. server.listen(5)
  13. print("等待连接...")
  14. while True:
  15.     #conn就是客户端连过来在服务端为其生成的一个连接实例
  16.     conn,addr = server.accept()
  17.     print("连接进行中...")
  18.     print(conn,addr)
  19.     while True:
  20.         data = conn.recv(1024)
  21.         print("recv:",data)
  22.         if not data:
  23.             print("客户端断开！")
  24.             break
  25.         res = os.popen(data).read()
  26.         conn.send(res)
  27. server.close()

客户端：

  1. [root@test-c2c-console01 oldboy]# cat socket_client.py
  2. #-*-coding:utf-8-*-
  3. _author_ = "golden"
  4. #客户端
  5. import socket
  6. #声明socket类型，同时生成socket连接对象
  7. client = socket.socket()
  8. client.connect(('localhost',6969))
  9. while True:
  10.     msg = raw_input(">>:").strip()
  11.     if len(msg) == 0:continue
  12.     client.send(msg.encode("utf-8"))
  13.     data = client.recv(102400)
  14.     print(data.decode())
  15.  
  16. client.close()

linux发送文件

服务端：

  1. [root@test-c2c-console01 oldboy]# cat socket_server.py
  2. #-*-coding:utf-8-*-
  3. #_author_="golden"
  4. #服务端
  5. import socket
  6. import os
  7.  
  8. server = socket.socket()
  9. #绑定要监听的端口
  10. server.bind(('localhost',6969))
  11. #监听，最大连接数
  12. server.listen(5)
  13. print("等待连接...")
  14. while True:
  15.     #conn就是客户端连过来在服务端为其生成的一个连接实例
  16.     conn,addr = server.accept()
  17.     print("连接进行中...")
  18.     print(conn,addr)
  19.     while True:
  20.         data = conn.recv(1024)
  21.         print("recv:",data)
  22.         if not data:
  23.             print("客户端断开！")
  24.             break
  25.         #res = os.popen(data).read()
  26.         #conn.send(res)
  27.         f = open("move.mkv")
  28.         data = f.read()
  29.         conn.send(data)
  30. server.close()

客户端：

  1. [root@test-c2c-console01 oldboy]# cat socket_client.py
  2. #-*-coding:utf-8-*-
  3. _author_ = "golden"
  4. #客户端
  5. import socket
  6. #声明socket类型，同时生成socket连接对象
  7. client = socket.socket()
  8. client.connect(('localhost',6969))
  9. while True:
  10.     msg = raw_input(">>:").strip()
  11.     if len(msg) == 0:continue
  12.     client.send(msg.encode("utf-8"))
  13.     data = client.recv(102400)
  14.     #print(data.decode())
  15.     f = open("video.avi",'wb')
  16.     f.write(data)
  17.     f.close()
  18.  
  19. client.close()

一次最多发送的数据量32768（不同系统有区别）

  1. [root@test-c2c-console01 oldboy]# ll *.avi *.mkv
  2. -rw-r--r-- 1 root root 681790584 Dec 27 19:26 move.mkv
  3. -rw-r--r-- 1 root root 32768 Feb 12 08:47 video.avi

多次发送

服务端：

  1. [root@test-c2c-console01 oldboy]# cat socket_server.py
  2. #-*-coding:utf-8-*-
  3. #_author_="golden"
  4. #服务端
  5. import socket
  6. import os
  7.  
  8. server = socket.socket() #实例化一个socket
  9. #绑定要监听的端口
  10. server.bind(('localhost',6969))
  11. #监听，最大连接数
  12. server.listen(5)
  13. print("等待连接...")
  14. while True:
  15.     #conn就是客户端连过来在服务端为其生成的一个连接实例
  16.     conn,addr = server.accept()
  17.     print("连接进行中...")
  18.     print(conn,addr)
  19.     while True:
  20.         data = conn.recv(1024)
  21.         print("recv:",data)
  22.         if not data:
  23.             print("客户端断开！")
  24.             break
  25.         #res = os.popen(data).read()
  26.         #conn.send(res)
  27.         f = open("move.mkv")
  28.         data = f.read()
  29.         print(len(data))
  30.         conn.send(data)
  31. server.close()

客户端：

  1. [root@test-c2c-console01 oldboy]# cat socket_client.py
  2. #-*-coding:utf-8-*-
  3. _author_ = "golden"
  4. #客户端
  5. import socket
  6. #声明socket类型，同时生成socket连接对象
  7. client = socket.socket()
  8. client.connect(('localhost',6969))
  9. f = open("video.avi",'wb')
  10. while True:
  11.     msg = raw_input(">>:").strip()
  12.     if len(msg) == 0:continue
  13.     client.send(msg.encode("utf-8"))
  14.     data = client.recv(102400)
  15.     #print(data.decode())
  16.     f.write(data)
  17.     f.flush()
  18.  
  19. client.close()

每交互一次文件的变化：

  1. [root@test-c2c-console01 oldboy]# ll
  2. total 665832
  3. -rw-r--r-- 1 root root 681790584 Dec 27 19:26 move.mkv
  4. -rw-r--r-- 1 root root 0 Feb 12 09:08 video.avi
  5. [root@test-c2c-console01 oldboy]# ll
  6. total 665864
  7. -rw-r--r-- 1 root root 681790584 Dec 27 19:26 move.mkv
  8. -rw-r--r-- 1 root root 32768 Feb 12 09:08 video.avi
  9. [root@test-c2c-console01 oldboy]# ll
  10. total 665964
  11. -rw-r--r-- 1 root root 681790584 Dec 27 19:26 move.mkv
  12. -rw-r--r-- 1 root root 135168 Feb 12 09:08 video.avi
  13. [root@test-c2c-console01 oldboy]# ll
  14. total 666164
  15. -rw-r--r-- 1 root root 681790584 Dec 27 19:26 move.mkv
  16. -rw-r--r-- 1 root root 339968 Feb 12 09:09 video.avi
  17. [root@test-c2c-console01 oldboy]# ll
  18. total 666164
  19. -rw-r--r-- 1 root root 681790584 Dec 27 19:26 move.mkv
  20. -rw-r--r-- 1 root root 339968 Feb 12 09:09 video.avi

socket实现简单的ssh

服务端：

  1. import socket,os
  2. server = socket.socket()
  3. server.bind(('localhost',9999))
  4. server.listen()
  5. while True:
  6.     conn,addr = server.accept()
  7.     print("new conn:",addr)
  8.     while True:
  9.         data = conn.recv(1024)
  10.         if not data:
  11.             print("客户端已断开！")
  12.             break
  13.         print("执行指令：",data)
  14.         cmd_res = os.popen(data.decode()).read() #接收字符串，执行结果也是字符串
  15.         print("before send ",len(cmd_res))
  16.         if len(cmd_res) ==0:
  17.             cmd_res = "cmd has no output"
  18.         conn.send(str(len(cmd_res.encode())).encode("utf-8"))#先发大小给客户端
  19.         conn.send(cmd_res.encode("utf-8"))
  20.  
  21. server.close()

客户端：

  1. import socket
  2. client = socket.socket()
  3. client.connect(('localhost',9999))
  4.  
  5. while True:
  6.     cmd = input(">>:").strip()
  7.     if len(cmd) == 0:continue
  8.     client.send(cmd.encode("utf-8"))
  9.     cmd_res_size = client.recv(1024)#接收大小
  10.     print("结果大小：",cmd_res_size)
  11.     received_size = 0
  12.     received_data = b''
  13.     while received_size < int(cmd_res_size.decode()):
  14.         data = client.recv(1024)
  15.         received_size += len(data) #每次收到的有可能小于1024，所以必须用len判断
  16.         # print(data.decode())
  17.         received_data += data
  18.     else:
  19.         print("cmd res receive done...",received_size)
  20.         print(received_data.decode())
  21.  
  22. client.close()

注意socket粘包问题。

方法一：在多个相连的send之间添加sleep。

  1. conn.send(str(len(cmd_res.encode())).encode("utf-8"))#先发大小给客户端
  2. time.sleep(0.5)
  3. conn.send(cmd_res.encode("utf-8"))

方法二：在每次send之后进行一次交互。

服务端：

  1. conn.send(str(len(cmd_res.encode())).encode("utf-8"))#先发大小给客户端client_ack = conn.recv(1024) #wait client to confirm
  2. print(client_ack.decode())
  3. conn.send(cmd_res.encode("utf-8"))

客户端：

  1. cmd_res_size = client.recv(1024)#接收大小
  2. client.send("已准备好接收数据！".encode("utf-8"))

socket实现简单的ftp

ftp server：

1、读取文件名

2、检测文件是否存在

3、打开文件

4、检测文件大小

5、发送文件大小给客户端

6、等待客户端确认

7、开始边读边发数据

8、发送md5

服务端：

  1. import socket,os,hashlib
  2. server = socket.socket()
  3. server.bind(("localhost",9999))
  4. server.listen()
  5. while True:
  6.     conn,addr = server.accept()
  7.     print("new conn:",addr)
  8.     while True:
  9.         print("等待指令...")
  10.         data = conn.recv(1024)
  11.         if not data:
  12.             print("客户端已断开！")
  13.             break
  14.         cmd,filename = data.decode().split()
  15.         print(filename)
  16.         if os.path.isfile(filename):
  17.             f = open(filename,"rb")
  18.             m = hashlib.md5()
  19.             file_size = os.stat(filename).st_size
  20.             conn.send(str(file_size).encode()) #send file size
  21.             conn.recv(1024) #wait for ack
  22.             for line in f:
  23.                 m.update(line)
  24.                 conn.send(line)
  25.             print("file md5",m.hexdigest())
  26.             f.close()
  27.             conn.send(m.hexdigest().encode()) #sed med5
  28.         print("send done")
  29.  
  30. server.close()

客户端：

  1. import socket,hashlib
  2. client = socket.socket()
  3. client.connect(('localhost',9999))
  4. while True:
  5.     cmd = input(">>:").strip()
  6.     if len(cmd) == 0:continue
  7.     if cmd.startswith("get"):
  8.         client.send(cmd.encode())
  9.         server_response = client.recv(1024)
  10.         print("server_response:",server_response)
  11.         client.send(b"read to recv file")
  12.         file_total_size = int(server_response.decode())
  13.         received_size = 0
  14.         filename = cmd.split()[1]
  15.         f = open(filename + ".new","wb")
  16.         m = hashlib.md5()
  17.         while received_size < file_total_size:
  18.             if file_total_size - received_size > 1024:
  19.                 size = 1024
  20.             else:
  21.                 size = file_total_size - received_size
  22.  
  23.             data = client.recv(size)
  24.             received_size += len(data)
  25.             m.update(data)
  26.             f.write(data)
  27.             # print(file_total_size,received_size)
  28.         else:
  29.             new_file_md5 = m.hexdigest()
  30.             print("file recv done",received_size,file_total_size)
  31.             f.close()
  32.         server_file_md5 = client.recv(1024)
  33.         print("server file md5:{0},client file md5:{1}".format(server_file_md5,new_file_md5))
  34. client.close()

SocketServer

实现并发处理。

The socketserver module simplifies the task of writing network servers.

socketserver常用类型

class socketserver.TCPServer(server_address,RequestHandlerClass,bind_and_activate=True)

This uses the Internet TCP protocol,which provides for continuous streams of data between the client and server.

class socketserver.UDPServer(server_address,RequestHandlerClass,bind_and_activate=True)

This uses datagrams,which are discrete packets of information that may arrive out of order or be lost while in transit.The parameters are the same as for TCPServer.

创建一个socketserver至少分一下几步：

1、You mast create a request handler class by subclassing the BaseRequestHandler class and overriding its handle() method;this method will process incoming requests.

创建一个请求处理类继承BaseRequestHandler，并且重写父类handle()。

2、You mast instantiate one of the server classes,passing it the server's address and the request handler class.

实例化TCPServer，并传递server ip和上述创建的请求处理类给这个TCPServer。

3、Then call the handle_request() or server_forever() method of the server object to process one or many requests.

server.handle_request()：只处理一个请求

server.server_forever()：处理多个请求

4、Call server_close() to close the socket.

服务端：

  1. import socketserver
  2.  
  3. class MyTCPHandler(socketserver.BaseRequestHandler):
  4.  
  5.     def handle(self):
  6.         while True:
  7.             try:
  8.                 self.data = self.request.recv(1024).strip()
  9.                 print("{} wrote :".format(self.client_address[0]))
  10.                 print(self.data)
  11.                 self.request.send(self.data.upper())
  12.             except ConnectionResetError as CR:
  13.                 print("err",CR)
  14.                 break
  15.  
  16. if __name__ == "__main__":
  17.     HOST,PORT = "localhost",9999
  18.     # server = socketserver.TCPServer((HOST,PORT),MyTCPHandler) # 单线程
  19.     server = socketserver.ThreadingTCPServer((HOST,PORT),MyTCPHandler) # 多线程，ForkingTCPServer多进程
  20.     server.serve_forever()

客户端：

  1. import socket
  2.  
  3. client = socket.socket()
  4. client.connect(("localhost",9999))
  5. while True:
  6.     msg = input(">>:").strip()
  7.     if len(msg) == 0:continue
  8.     client.send(msg.encode("utf-8"))
  9.     data = client.recv(1024)
  10.     print("recv:",data.decode())
  11. client.close()

开启一个新线程

  1. def process_request(self, request, client_address):
  2.     """Start a new thread to process the request."""
  3.     t = threading.Thread(target = self.process_request_thread,
  4.                          args = (request, client_address))
  5.     t.daemon = self.daemon_threads
  6.     t.start()

 

Python开发【第八篇】：socket网络编程的更多相关文章

  1. 【python自动化第八篇：网络编程】

    一.拾遗 动态导入模块 目的是为了在导入模块的过程中将模块以字符的格式导入. #!/usr/bin/env python # -*- coding:utf-8 -*- #Author:wanghui ...

  2. python面向对象、类、socket网络编程

    类和对象 python3统一了类与类型的概念:类==类型:从一组对象中提取相似的部分就是类:特征与技能的结合体就叫做对象: 类的功能: 初始实例化: 属性引用: 1.数据属性: 2.函数属性: 对于一 ...

  3. python学习之路-9 socket网络编程

    socket基础 socket通常也称作"套接字",用于描述IP地址和端口,是一个通信链的句柄,应用程序通常通过"套接字"向网络发出请求或者应答网络请求. so ...

  4. Java基础篇Socket网络编程中的应用实例

    说到java网络通讯章节的内容,刚入门的学员可能会感到比较头疼,应为Socket通信中一定会伴随有IO流的操作,当然对IO流比较熟练的哥们会觉得这是比较好玩的一章,因为一切都在他们的掌握之中,这样操作 ...

  5. python3.x 基础八：socket网络编程

    Socket socket就是一直以来说的“套接字”,用于描述:ip:端口,是通信链的句柄,客户端通过这个句柄进行请求和响应 普通文件的操作顺序:打开-读写-关闭,针对的是文件 socket是特殊的文 ...

  6. Python之路【第七篇】python基础 之socket网络编程

    本篇文章大部分借鉴 http://www.cnblogs.com/nulige/p/6235531.html python socket  网络编程 一.服务端和客户端 BS架构 (腾讯通软件:ser ...

  7. 从零开始学Python第八周：网络编程基础（socket)

    Socket网络编程 一,Socket编程 (1)Socket方法介绍 Socket是网络编程的一个抽象概念.通常我们用一个Socket表示"打开了一个网络链接",而打开一个Soc ...

  8. python第八周：socket网络编程

    1.socket网络编程 1.1概念: 网络套接字是跨计算机网络的连接的端点.今天,计算机之间的大多数通信都基于互联网协议;因此大多数网络套接字都是Internet套接字.更准确地说,套接字是一个句柄 ...

  9. Python全栈【Socket网络编程】

    Python全栈[socket网络编程] 本章内容: Socket 基于TCP的套接字 基于UDP的套接字 TCP粘包 SocketServer 模块(ThreadingTCPServer源码剖析) ...

  10. python之Socket网络编程

    什么是网络? 网络是由节点和连线构成,表示诸多对象及其相互联系.在数学上,网络是一种图,一般认为专指加权图.网络除了数学定义外,还有具体的物理含义,即网络是从某种相同类型的实际问题中抽象出来的模型.在 ...

随机推荐

  1. PythonStudy——字典的定义 Dictionary definition

    # 空字典 d1 = {} d2 = dict() # 用map映射创建字典 d3 = dict({'a': 1, 'b': 1}) print(d3) # 用关键字赋值方式 d4 = dict(na ...

  2. MVC 模式

    1.MVC 模式简介 MVC 模式代表 Model-View-Controller(模型-视图-控制器) 模式.这种模式用于应用程序的分层开发.Model(模型):模型代表一个存取数据的对象或 JAV ...

  3. php 字符串固定长度，不够补充其他字符串

    <?php $input = '456'; $var= str_pad($input,5,10,STR_PAD_LEFT); w3school手冊:http://www.w3school.com ...

  4. react 在 componentWillMount() 中调用异步函数时，componentWillMount() finishes after render()

    刚开始使用 react,很多属性.方法不是很熟.在此记录下我所遇到的问题及解决方法. 我在 componentWillMount() 中调用了一个异步函数,在返回结果中调用 this.setState ...

  5. JAVA AES CBC 加密 解密

    AES 256 , KEY 的长度为 32字节(32*8=256bit). AES 128 , KEY 的长度为 16字节(16*8=128bit) CBC 模式需要IV, IV的值是固定写死,还是当 ...

  6. 【C++】读取参数的类

    在C++程序中,如果我们把程序中的参数都保存在txt文本中,运行时再去读取.这样的好处是,当我们需要调参的时候,不需要每次都重新编译程序,大大提升了效率. 今日分享一份实现以上功能的代码,代码来源:h ...

  7. reids高可用（灾难备份-持久化）

    java缓存存放到内存之中,当服务器重启以后,内存的数据将丢失,而reids作为缓存,重启reids以后 数据是不是也会丢失,redis服务器重启以后数据也不会丢失,这个是redis提供了持久化的功能 ...

  8. docker内存监控与压测

    一直运行的docker容器显示内存已经耗尽,并且容器内存耗尽也没出现重启情况,通过后台查看发现进程没有占用多少内存.内存的监控使用的是cadvisor,计算方式也是使用cadvisor的页面计算方式, ...

  9. Bootstrap 前端UI框架

    Bootstrap 有哪些优越性? 1.简单灵活的用于搭建WEB页面的HTML,CSS, JavaScript的工具集 2.基于html5, css3, 具有良好特性,友好的学习曲线,卓越的兼容性,1 ...

  10. 使用css实现时间轴

    本文将使用css来实现一个左右交叉布局的时间轴,效果如下: 使用的都是一些常用的css,代码如下: <!DOCTYPE> <html> <head> <tit ...