# 流程描述:
#
# 1. 服务器根据地址类型(ipv4, ipv6), socket类型, 协议创建socket;
#
# 2. 服务器为socket绑定ip地址和端口号;
#
# 3. 服务器socket监听端口号请求,随时准备接收客户端发来的连接,这时候服务器的socket并没有被打开;
#
# 4. 客户端创建socket
#
# 5. 客户端打开socket, 根据服务器ip地址和端口号试图连接服务器socket;
#
# 6. 服务器socket接收到客户端socket请求,被动打开,开始接收客户端请求,直到客户端返回连接信息。这时候socket
# 进入阻塞状态, 所谓阻塞即accept()方法一直等到客户端返回连接信息后才返回,开始接收下一个客户端连接请求。
#
# 7. 客户端连接成功,向服务器发送连接状态信息;
#
# 8. 服务器 accept 方法返回,连接成功;
#
# 9. 客户端向socket写入信息(或服务端向socket写入信息)
#
# 10. 服务器读取信息(或客户端读取信息)
#
# 11. 客户端关闭
# 12. 服务端关闭

1.1 相关方法及参数介绍

import socket
sk = socket.socket()
  • sk.bind(address):将套接字绑定到地址。address地址的格式取决于地址族。在AF_INET下,以元组(host,port)的形式

    表示地址;
  • sk.listen(backlog):开始监听传入的连接。backlog指定在拒绝连接之前,可以挂起的最大连接数量。

    backlog等于5,表示内核已经接到的连接请求,但服务器还没有调用accept进行处理的连接个数最大为5。这个值不可能无限大,因为要在内核中维护连接队列;
  • sk.setblocking(bool): 是否阻塞(默认为True), 如果设置为False, 那么accept和recv时,一旦无数据,则报错;
  • sk.accept(): 接收连接并返回(conn, address), 其中conn是新的套接字对象,可以用来接收和发送数据;address是

    连接客户端的地址;
  • sk.connect(address): 连接到address处的套接字。一般,address的格式为元组(hostname, port),如果连接出错,

    返回socket.error错误;
  • sk.connect_ex(address): 同上,只不过会有返回值,连接成功时,返回0; 连接失败的时候,返回编码,例如: 10061
  • sk.close(): 关闭套接字;
  • sk.recv(bufsize[, flag]): 接受套接字的数据。数据以字符串形式返回,bufsize指定最多可以接收的数量。
  • sk.recvfrom(bufsize[,flag]): 与recv()类似,但返回值是 (data, address), 其中,data是包含接收数据的字符串,

    address 是发送数据的套接字地址;
  • sk.send(string[,flag]): 将string中的数据发送到连接的套接字。返回值是要发送的字节数量,该数量可能小于string的字

    节大小。即: 可能未将指定内容全部发送。
  • sk.sendall(string[,flag]): 将string中的数据发送到连接的套接字,但在返回之前会尝试发送所有数据。成功,返回None;

    失败则抛出异常。内部通过递归调用 send, 将所有内容发送出去。
  • sk.sendto(string[,flag], address): 将数据发送到套接字,address的形式为元组(ipaddr, port)。返回值是发送的

    字节数,该函数主要用于UDP协议;
  • sk.settimeout(timeout):设置套接字操作的超时时长,timeout是一个浮点数,单位是秒。值为None,表示没有超时期。
  • sk.getpeername():返回连接套接字的远程地址。返回值通常是元组(ipaddr, port);
  • sk.getsockname():返回套接字自己的地址,通常是一个元组(ipaddr, port);
  • sk.fileno(): 套接字的文件描述符;
# 示例一: 建立连接
# sever 端
import socket # 创建socket对象
sk = socket.socket() # 绑定ip和端口
address = ('127.0.0.1', 8000)
sk.bind(address) sk.listen(3)
print("waiting......")
conn = sk.accept() # 此时,返回一个包含两个元素的元组
print(conn) # client 端
import socket sk = socket.socket() address = ('127.0.0.1', 8000)
sk.connect(address) # 示例二: 服务端发送,客户端接收
# server 端
import socket sk = socket.socket()
address = ('127.0.0.1', 8000)
sk.bind(address) sk.listen(3)
print('waiting......')
conn, addr = sk.accept() # 发送消息
msg = input('>>>')
# conn.send(msg), 此处会报错: a bytes-like object is required, not 'str'
conn.send(bytes(msg, 'utf8')) # client 端
import socket sk = socket.socket()
address = ('127.0.0.1', 8000)
sk.connect(address) # 接收消息
data = sk.recv(1024) # 此处,客户端会阻塞,等待服务端发送消息
print(str(data, 'utf8')) # 示例三: 客户端发送, 服务端接收
# server 端
import socket sk = socket.socket()
address = ('127.0.0.1', 8000)
sk.bind(address) sk.listen(3)
print('waiting......')
conn, addr = sk.accept() # 接收消息
data = conn.recv(1024) # 注意,服务端使用 conn 来收发数据
print(data)
conn.close() # 关闭连接 # client 端
import socket sk = socket.socket()
address = ('127.0.0.1', 8000)
sk.connect(address) # 发送消息
sk.send(bytes('大家好', 'utf8')) sk.close() # 示例四: 不间断聊天
# server 端
import socket sk = socket.socket()
address = ('127.0.0.1', 8000)
sk.bind(address) sk.listen(3)
print('waiting......')
conn, addr = sk.accept() while True:
data = conn.recv(1024)
if not data:
break
print(str(data, 'utf8'))
msg = input('>>>')
conn.send(bytes(msg, 'utf8')) conn.close() # client 端
import socket sk = socket.socket()
address = ('127.0.0.1', 8000)
sk.connect(address) while True:
msg = input('>>>')
if msg == 'exit':
break
sk.send(bytes(msg, 'utf8'))
data = sk.recv(1024)
print(str(data, 'utf8')) sk.close() # 示例五:
# server 端
import socket sk = socket.socket()
address = ('127.0.0.1', 8000)
sk.bind(address) sk.listen(3)
print('waiting......') while True:
conn, addr = sk.accept() # 某一个客户端关闭后,可以接收另外一个客户端发来的消息
print(addr) while True:
try:
data = conn.recv(1024)
except Exception:
break
if not data:
break
print(str(data, 'utf8'))
msg = input('>>>')
conn.send(bytes(msg, 'utf8')) sk.close() # 示例六: 远程执行命令
# server 端
import socket
import subprocess sk = socket.socket()
address = ('127.0.0.1', 8000)
sk.bind(address)
sk.listen(3)
print('waiting......') while True:
conn, addr = sk.accept()
print(addr)
while True:
data = conn.recv(1024)
if not data:
break
print(str(data, 'utf8')) obj = subprocess.Popen(data, shell=True, stdout=subprocess.PIPE)
cmd_result = obj.stdout.read()
# 只能传输bytes类型数据,int首先转成str,然后转成bytes
result_len = bytes(str(len(cmd_result)), 'utf8') # 获取传输内容的大小
conn.sendall(result_len) conn.recv(1024) # 解决粘包问题 conn.sendall(cmd_result) sk.close() # client 端
import socket sk = socket.socket()
address = ('127.0.0.1', 8000)
sk.connect(address) while True:
msg = input('>>>')
if msg == 'exit':
break
sk.send(bytes(msg, 'utf8')) result_len = int(str(sk.recv(1024), 'utf8')) sk.sendall('ok') data = bytes() # 空字节
while len(data) != result_len:
data += sk.recv(1024) print(str(data, 'utf8')) # 示例七: 上传文件
# server 端
import socket
import os sk = socket.socket()
address = ('127.0.0.1', 8000)
sk.bind(address)
sk.listen(3)
print('waiting......') BASE_DIR = os.path.dirname(os.path.abspath(__file__)) while True:
conn, addr = sk.accept() while True:
data = conn.recv(1024)
cmd, file_name, file_size = str(data, 'utf8').split('|')
path = os.path.join(BASE_DIR, 'a', file_name)
file_size = int(file_size) f = open(path, 'ab')
has_receive = 0
while has_receive != file_size:
data = conn.recv(1024)
f.write(data)
has_receive += len(data)
f.close() sk.close() # client 端
import socket
import os sk = socket.socket()
address = ('127.0.0.1', 8000)
sk.connect(address) BASE_DIR=os.path.dirname(os.path.abspath(__file__)) while True:
msg = input('>>>').strip() # 规定输入格式为: post|a.jpg(命令|路径), strip()去除首尾空格 cmd, path = msg.split('|')
# 路径拼接, 因为传入的path可能为 a/b/a.jpg
path = os.path.join(BASE_DIR, path) # 获取文件名称
filename = os.path.basename(path)
# 获取文件大小
file_size = os.stat(path).st_size file_info = 'post|%s|%s' % (filename,file_size)
# 向服务端发送消息
sk.sendall(bytes(file_info, 'utf8')) # 向服务端发送文件内容
f = open(path, 'rb') # 以bytes的格式读取数据
has_sent = 0
while has_sent != file_size:
data = f.read(1024) # 每次发送1024字节数据
sk.sendall(data)
has_sent += len(data) f.close()
print('上传成功!')

2. socketserver 模块

# 示例一: server端并发聊天
# server 端
import socketserver class MyServer(socketserver.BaseRequestHandler): def handle(self):
print('服务端启动...')
while True:
conn = self.request
print(self.client_address)
while True:
client_data = conn.recv(1024)
print(str(client_data, 'utf8'))
print('waiting......')
conn.sendall(client_data)
conn.close() if __name__ == '__main__':
server = socketserver.ThreadingTCPServer(('127.0.0.1', 8000), MyServer)
server.serve_forever() # client 端
import socket ip_port = ('127.0.0.1', 8000)
sk = socket.socket()
sk.connect(ip_port)
print('客户端启动:') while True:
msg = input('>>>')
sk.sendall(bytes(msg, 'utf8'))
if msg == 'exit':
break
server_response = sk.recv(1024)
print(str(server_response, 'utf8')) sk.close()

参考资料:

Python 之网络编程的更多相关文章

  1. python之网络编程

    本地的进程间通信(IPC)有很多种方式,但可以总结为下面4类: 消息传递(管道.FIFO.消息队列) 同步(互斥量.条件变量.读写锁.文件和写记录锁.信号量) 共享内存(匿名的和具名的) 远程过程调用 ...

  2. Python的网络编程--思维导图

    Python的网络编程--思维导图

  3. Python高级网络编程系列之第一篇

    在上一篇中我们简单的说了一下Python中网络编程的基础知识(相关API就不解释了),其中还有什么细节的知识点没有进行说明,如什么是TCP/IP协议有几种状态,什么是TCP三次握手,什么是TCP四次握 ...

  4. python基础网络编程--转

    python之网络编程 本地的进程间通信(IPC)有很多种方式,但可以总结为下面4类: 消息传递(管道.FIFO.消息队列) 同步(互斥量.条件变量.读写锁.文件和写记录锁.信号量) 共享内存(匿名的 ...

  5. python 基础网络编程2

    python 基础网络编程2 前一篇讲了socketserver.py中BaseServer类, 下面介绍下TCPServer和UDPServer class TCPServer(BaseServer ...

  6. python 基础网络编程1

    python 基础网络编程1 Source code: Lib/socketserver.py lib的主目录下有一个sockserver.py文件, 里面是python基本的网络编程模型 共有一个b ...

  7. python select网络编程详细介绍

    刚看了反应堆模式的原理,特意复习了socket编程,本文主要介绍python的基本socket使用和select使用,主要用于了解socket通信过程 一.socket模块 socket - Low- ...

  8. Python Socket 网络编程

    Socket 是进程间通信的一种方式,它与其他进程间通信的一个主要不同是:它能实现不同主机间的进程间通信,我们网络上各种各样的服务大多都是基于 Socket 来完成通信的,例如我们每天浏览网页.QQ ...

  9. python多线程网络编程

    背景 使用过flask框架后,我对request这个全局实例非常感兴趣.它在客户端发起请求后会保存着所有的客户端数据,例如用户上传的表单或者文件等.那么在很多客户端发起请求时,服务器是怎么去区分不同的 ...

  10. python中网络编程基础

    一:什么是c\s架构 1.c\s即client\server 客户端\服务端架构. 客户端因特定的请求而联系服务器并发送必要的数据等待服务器的回应最后完成请求 服务端:存在的意义就是等待客户端的请求, ...

随机推荐

  1. Flume线上日志采集【模板】

    Flume线上日志采集[模板] 预装软件 Java HDFS Lzo/Lzop 系统版本 Flume 1.5.0-cdh5.4.0 系统流程图 flume-env.sh配置文件 export JAVA ...

  2. [gpio]Linux GPIO简单使用方式2-sysfs

    转自:http://blog.csdn.net/cjyusha/article/details/50418862 在Linux嵌入式设备开发中,对GPIO的操作是最常用的,在一般的情况下,一般都有对应 ...

  3. HTTP Content-Disposition Explanation [ from MDN ]

    在常规的HTTP应答中,Content-Disposition 消息头指示回复的内容该以何种形式展示,是以内联的形式(即网页或者页面的一部分),还是以附件的形式下载并保存到本地. 在multipart ...

  4. ZooKeeper是一个分布式的,开放源码的分布式应用程序协调服务

    ZooKeeper是一个分布式的,开放源码的分布式应用程序协调服务,是Google的Chubby一个开源的实现,是Hadoop和Hbase的重要组件.它是一个为分布式应用提供一致性服务的软件,提供的功 ...

  5. MyBatis 最强大的特性之一就是它的动态语句功能

    MyBatis 最强大的特性之一就是它的动态语句功能.如果您以前有使用JDBC或者类似框架的经历,您就会明白把SQL语句条件连接在一起是多么的痛苦,要确保不能忘记空格或者不要在columns列后面省略 ...

  6. 【BZOJ】1500: [NOI2005]维修数列(splay+变态题)

    http://www.lydsy.com/JudgeOnline/problem.php?id=1500 模板不打熟你确定考场上调试得出来? 首先有非常多的坑点...我遇到的第一个就是,如何pushu ...

  7. superresolution_v_2.0 Application超分辨率程序文档

    SUPERRESOLUTION GRAPHICAL USER INTERFACE DOCUMENTATION Contents 1.- How to use this application. 2.- ...

  8. React Native开发技术

    http://www.lcode.org/react-native-week-issue22/

  9. layui多选框

    多选下拉框:http://sun.faysunshine.com/layui/formSelects-v4/example/example_v4.html 1.下载formSelects-v4.1 2 ...

  10. HDU4081 Qin Shi Huang's National Road System【prim最小生成树+枚举】

    先求出最小生成树,然后枚举树上的边,对于每条边"分别"找出这条割边形成的两个块中点权最大的两个 1.因为结果是A/B.A的变化会引起B的变化,两个制约.无法直接贪心出最大的A/B. ...