Python网络（socket）编程

一 C/S、B/S架构简述

C/S 架构即“客户端-服务器” 架构（C = Client, S = Server）。这里的“客户端”可以是有 GUI （图形用户界面）的定制软件，也可以是浏览器，甚至可以是通过 SSH 访问服务器的命令行脚本。只要是客户端通过访问服务器调取计算或者存储资源的，统统都是 C/S 架构。所谓的B/S（ Browser-Server）架构其实是 C/S 架构的一种特殊的实现形式，而不是其对立面。

C/S架构服务器特点：

持续提供服务
绑定一个唯一的地址（IP+port）

C/S架构与socket的关系：

学习socket主要是为了完成C/S架构的开发

二互联网协议

我们知道一台完整的计算机系统是由硬件、操作系统、应用软件三者组成，具备了这三个条件，一台计算机系统就可以自己跟自己玩了（比如：单机游戏）。但如果需要和别人一起玩，就必须进行联网。

何为互联网？

互联网的核心就是由一堆协议组成，协议就是标准，比如全世界人通信的标准是讲英语。

为何学习socket一定要学习互联网协议？

基于socket的编程，主要是为了开发一款自己的C/S架构软件
C/S架构的软件（软件属于应用层）是基于网络进行通信的
网络的核心即一堆协议（标准），你想开发一款基于网络通信的软件，就必须遵循这些标准

总结：想要学习socket的编程，就必须掌握互联网协议。

如需了解详细互联网协议，请参考另外一篇文章：计算机基础之互联网协议

三什么是socket

socket是应用层与TCP/IP协议族通信的中间软件抽象层(如下图所示），它是一组接口。在设计模式中，socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在socket接口后面，对用户来说，一组简单的接口就是全部，让socket去组织数据，以符合指定的协议。所以，我们只需要遵循socket的规定去编程，写出的程序自然就是遵循TCP/UDP标准。

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

其他理解：

也有人将socket说成ip+port（端口），ip是用来标识互联网中的一台主机的位置，而port是用来标识这台机器上的一个应用程序，ip地址是配置到网卡上的，而port是应用程序开启的，ip与port的绑定就标识了互联网中独一无二的一个应用程序，而程序的pid是同一台机器上不同进程或者线程的标识。

四套接字的发展史和分类

套接字起源于 20 世纪 70 年代加利福尼亚大学伯克利分校版本的 Unix，即人们所说的 BSD Unix。因此，有时人们也把套接字称为“伯克利套接字”或“BSD 套接字”。一开始，套接字被设计用在同一台主机上多个应用程序之间的通讯，这也被称进程间通讯或 IPC。套接字有两种（或者称为有两个种族），分别是基于文件型的和基于网络型的。

基于文件类型的套接字家族（AF_UNIX）

unix一切皆文件，基于文件的套接字调用的就是底层的文件系统来取数据，两个套接字进程运行在同一机器，可以通过访问同一个文件系统间接完成通信。

基于网络类型的套接字家族（AF_INET）

还有AF_INET6被用于ipv6，还有一些其他的地址家族，不过，他们要么是只用于某个平台，要么就是已经被废弃，或者是很少被使用，或者是根本没有实现，所有地址家族中，AF_INET是使用最广泛的一个，python支持很多种地址家族，但是由于我们只关心网络编程，所以大部分时候我么只使用AF_INET。

五套接字的工作流程

先从服务器端说起。服务器端先初始化socket，然后与端口绑定(bind)，对端口进行监听(listen)，调用accept阻塞，等待客户端连接。在这时如果有个客户端初始化一个socket，然后连接服务器(connect)，如果连接成功，这时客户端与服务器端的连接就建立了。客户端发送数据请求，服务器端接收请求并处理请求，然后把回应数据发送给客户端，客户端读取数据，最后关闭连接，一次交互结束。

六 socket模块

import socket
# socket.socket(socket_family, socket_type, protocal=0)
# socket_family 可以是 AF_UNIX 或 AF_INET（默认）；socket_type可以是SOCK_STREAM（TCP，默认）或 SOCK_DGRAM（UDP）。protocol 一般不填,默认值为0。

# 获取TCP/IP套接字
# tcp_socket = socket.socket()
tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 获取UDP/IP套接字
udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

# 为了简便，我们可以采用from socket import *，例如：
from socket import *
tcp_socket = socket(AF_INET, SOCK_STREAM)

如何获取socket对象

s.bind()    绑定(主机,端口号)到套接字
s.listen()  开始TCP监听
s.accept()  被动接受TCP客户的连接,(阻塞式)等待连接的到来

服务端套接字函数

s.connect()     主动初始化TCP服务器连接
s.connect_ex()  connect()函数的扩展版本,出错时返回出错码,而不是抛出异常

客户端套接字函数

s.recv()            接收TCP数据
s.send()            发送TCP数据(send在待发送数据量大于己端缓存区剩余空间时,数据丢失,不会发完)
s.sendall()         发送完整的TCP数据(本质就是循环调用send,sendall在待发送数据量大于己端缓存区剩余空间时,数据不丢失,循环调用send直到发完)
s.recvfrom()        接收UDP数据
s.sendto()          发送UDP数据
s.getpeername()     连接到当前套接字的远端的地址
s.getsockname()     当前套接字的地址
s.getsockopt()      返回指定套接字的参数
s.setsockopt()      设置指定套接字的参数
s.close()           关闭套接字

公共用途的套接字函数

s.setblocking()     设置套接字的阻塞与非阻塞模式
s.settimeout()      设置阻塞套接字操作的超时时间
s.gettimeout()      得到阻塞套接字操作的超时时间

面向锁的套接字函数

s.fileno()          套接字的文件描述符
s.makefile()        创建一个与该套接字相关的文件

面向文件的套接字函数

注意：以上s代表套接字对象

七基于TCP的套接字

TCP是基于链接的，必须先启动服务端，然后再启动客户端去链接服务端，话不多说，下面我们创建一组基于TCP的服务端、客户端。

import socket

tcp_server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)   # 创建TCP套接字对象
tcp_server.bind(('127.0.0.1',8080))         # 绑定ip+port
tcp_server.listen(5)                        # 监听，5代表的是最多挂起5个，可以自定义
conn,addr = tcp_server.accept()             # 等待连接

recv_data = conn.recv(1024)                 # 接收消息，1024为收数据大小
print(recv_data.decode('utf8'))             # 打印消息

conn.send('已收到消息'.encode('utf8'))        # 发送消息

conn.close()                                # 关闭此次连接
tcp_server.close()                          # 关闭套接字对象

TCP服务端（基础版）

import socket

tcp_client = socket.socket()                # 创建TCP套接字对象
tcp_client.connect(("127.0.0.1", 8080))     # 连接服务端ip+port

send_data = input(">>:")                          # 客户端输入发送消息内容
tcp_client.send(send_data.encode("utf-8"))        # 发送消息
recv_data = tcp_client.recv(1024)                 # 接收服务端消息，1024为收数据大小
print(recv_data.decode("utf-8"))                  # 打印消息

tcp_client.close()                                # 关闭

TCP客户端（基础版）

import socket

ip_port = ("127.0.0.1", 8080)   # 自定义ip+port
buf_size = 1024                 # 自定义接受数据大小

tcp_socket = socket.socket()    # 创建TCP套接字对象
tcp_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) # 加入此行
tcp_socket.bind(ip_port)        # 绑定ip+port
tcp_socket.listen(5)            # 监听，5代表的是最多挂起5个，可以自定义

while True:                     # 链接循环
    conn,addr = tcp_socket.accept()             # 等待连接
    # print(conn)     # <socket.socket fd=560, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0,
                      # laddr=('127.0.0.1', 8080), raddr=('127.0.0.1', 52889)>
    # print(addr)     # ('127.0.0.1', 52889)
    print('接到来自%s的连接' %addr[0])
    while True:                 # 通信循环
        try:    # 针对win的异常处理，如果不进行try...except，则会报错，因为我们不知道客户端什么时候会断开
            recv_data = conn.recv(buf_size)         # 接收消息，1024为收数据大小
            # if len(recv_data) == 0: break         # 针对Linux，如果不加，那么正在链接的客户端突然断开，recv便不再阻塞，死循环发生
            print(recv_data.decode('utf8'))         # 打印消息
            send_data = input(">>:")                # 输入服务端发送消息内容
            conn.send(send_data.encode('utf8'))     # 发送消息
        except Exception:
            break
    conn.close()                                # 关闭此次连接
tcp_socket.close()                          # 关闭套接字对象

TCP服务端（改进版）

import socket

ip_port = ("127.0.0.1", 8080)   # 自定义ip+port
buf_size = 1024                 # 自定义接受数据大小

tcp_client = socket.socket()    # 创建TCP套接字对象
tcp_client.connect(ip_port)     # 连接服务端

while True:
    send_data = input(">>:").strip()                  # 客户端输入发送消息内容
    if len(send_data) == 0: continue                  # 发送消息为空，则返回继续发送
    tcp_client.send(send_data.encode("utf-8"))        # 发送消息
    recv_data = tcp_client.recv(buf_size)             # 接收服务端消息
    print(recv_data.decode("utf-8"))                  # 打印消息

tcp_client.close()                                # 关闭

TCP客户端（改进版）

改进版主要加入链接循环和通讯循环

注意点：在重启服务端时可能会遇到以下错误信息：

OSError: [WinError 10048] 通常每个套接字地址(协议/网络地址/端口)只允许使用一次。

这是因为服务端仍然存在四次挥手的time_wait状态在占用地址，这时我们可以这样处理：

tcp_server = socket.socket()    # 创建TCP套接字对象
tcp_server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) # 加入此行
tcp_server.bind(ip_port)        # 绑定ip+port

实例应用--基于TCP协议模拟ssh远程执行命令

import socket
import subprocess

ip_port = ("127.0.0.1", 8080)
buf_size = 1024

ssh_server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
ssh_server.bind(ip_port)
ssh_server.listen(5)

print('starting....')
while True:
    conn,addr = ssh_server.accept()
    print('接到来自%s的连接' %addr[0])
    while True:
        try:
            cmd = conn.recv(buf_size)
            if not cmd :break
            print('接收的指令是：%s' %cmd.decode('utf-8'))
            # 处理过程，Popen是执行命令的方法
            ret = subprocess.Popen(cmd.decode('utf-8'), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE )
            stdout = ret.stdout.read()
            stuerr = ret.stderr.read()
            conn.send(stdout+stuerr)
        except Exception:
            break
    conn.close()
ssh_server.close()

服务端

import socket

ip_port = ("127.0.0.1", 8080)
buf_size = 1024

ssh_client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
ssh_client.connect(ip_port)

while True:
    cmd = input('请输入需要执行的指令:>>').strip()
    if not cmd: continue
    ssh_client.send(cmd.encode('utf-8'))
    recv_data = ssh_client.recv(1024)
    print(recv_data.decode('gbk'))      # linux则为utf8
tcp_client.close()

客户端

八基于UDP的套接字

UDP是无链接的，先启动哪一端都不会报错。发送数据用sendto()；接收数据用recvfrom()。

import socket

ip_port = ("127.0.0.1", 8080)
buf_size = 1024

udp_server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
udp_server.bind(ip_port)

print('starting....')
while True:             #  服务器通讯循环
    msg, addr = udp_server.recvfrom(buf_size)        # 接受信息，元组（信息，ip+port）
    print(msg.decode('utf-8'))
    # print(addr)         # ip+port   ('127.0.0.1', 62570)
    send_msg = input('>>:')
    udp_server.sendto(send_msg.encode('utf8'),addr)  # 发送信息，元组（信息，ip+port）
udp_server.close()      #  关闭服务器套接字

UDP服务端

import socket

ip_port = ("127.0.0.1", 8080)
buf_size = 1024

udp_client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)    # 创建客户端套接字

while True:     # 通信循环
    send_msg = input('>>:').strip()
    if not send_msg: continue
    udp_client.sendto(send_msg.encode('utf-8'),ip_port)   # 发消息
    recv_msg,addr = udp_client.recvfrom(buf_size)             # 收消息
    print(recv_msg.decode('utf-8'))      # linux则为utf8
udp_client.close()          # 关闭客户端套接字

UDP客户端

实例应用--模拟聊天软件

import socket

ip_port = ("127.0.0.1", 8080)
buf_size = 1024

udp_server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
udp_server.bind(ip_port)

while True:
    recv_msg, addr = udp_server.recvfrom(buf_size)
    print('来自[%s:%s]的一条消息:%s' % (addr[0], addr[1], recv_msg.decode('utf-8')))
    send_msg = input('请输入回复消息，回车发送：>>').strip()
    if not send_msg:
        continue
    udp_server.sendto(send_msg.encode('utf8'),addr)
udp_socket.close()

UDP服务端

import socket

ip_port = ("127.0.0.1", 8080)
buf_size = 1024

udp_client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)    # 创建客户端套接字

chat_obj_dic = {'张三': ('127.0.0.1', 8080),
                '李四': ('127.0.0.1', 8080),
                '王五': ('127.0.0.1', 8080),
                }
while True:
    print('可供聊天对象如下：%s' %chat_obj_dic)
    chat_obj = input('请输入聊天对象或’q‘退出：>>').strip()
    if chat_obj == 'q' or chat_obj == 'Q':
        break
    if chat_obj not in chat_obj_dic or not chat_obj:
        print('输入对象不在对象列表中，请重新输入！')
        continue
    while True:
        send_msg = input('请输入消息，回车发送：>>').strip()
        if send_msg == 'q' or send_msg == 'Q':
            break
        if not send_msg:
            continue
        udp_client.sendto(send_msg.encode('utf-8'),chat_obj_dic[chat_obj])
        recv_msg,addr = udp_client.recvfrom(buf_size)
        print('来自[%s:%s]的一条消息:%s' % (addr[0], addr[1], recv_msg.decode('utf-8')))
udp_client.close()

UDP客户端

因为udp无连接，所以可以同时多个客户端去跟服务端通信，如下：

九其他补充

9.1 TCP/UDP的不同点

TCP是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住。而udp是基于数据报的，即便是你输入的是空内容（直接回车），那也不是空消息，UDP协议会帮你封装上消息头
TCP的协议数据不会丢，没有收完包，下次接收，会继续上次继续接收，己端总是在收到ack时才会清除缓冲区内容。数据是可靠的，但是会粘包
UDP的recvfrom是阻塞的，一个recvfrom(x)必须对唯一一个sendinto(y)，收完了x个字节的数据就算完成，若是y>x数据就丢失，这意味着udp根本不会粘包，但是会丢数据，不可靠

9.2 为什么TCP是可靠传输，而UDP是不可靠传输

TCP在数据传输时，发送端先把数据发送到自己的缓存中，然后协议控制将缓存中的数据发往对端，对端返回一个ack=1，发送端则清理缓存中的数据，对端返回ack=0，则重新发送数据，所以TCP是可靠的，而UDP发送数据，对端是不会返回确认信息的，因此不可靠

9.3 recv(1024)、send(字节流)及sendall

recv里指定的1024意思是从缓存里一次拿出1024个字节的数据

send的字节流是先放入己端缓存，然后由协议控制将缓存内容发往对端，如果待发送的字节流大小大于缓存剩余空间，那么数据丢失

sendall会循环调用send，数据不会丢失

参考：http://www.cnblogs.com/linhaifeng/articles/6129246.html#_label1

posted @ 2018-07-31 15:30 Joe1991 阅读(156) 评论(0) 收藏举报

刷新页面返回顶部

Joe1991

Python网络（socket）编程

一 C/S、B/S架构简述

二 互联网协议

三 什么是socket

四 套接字的发展史和分类

五 套接字的工作流程