第十二章 网络编程

第十二章 网络编程

网络协议概述

通信协议：
协议即规则，就好比汽车上路要遵守交通规则一样，为了使全世界不同类型的计算机都可以连接起来，所以制定了一套全球通用的通信协议——Internet协议。有了Internet协议，任何私有网络，只要支持这个协议，就可以接入互联网。

Internet协议主要的协议和层次关系：

 
IP:

• IP协议是整个TCP/IP协议族的核心
• IP地址就是互联网上计算机的唯一标识
• 目前的IP地址有两种表示方式，即IPv4和IPv6
• 在命令行下使用 ipconfig 命令可以查看本机的IP地址

TCP协议与UDP协议的区别

TCP:
TCP(Transmission Control Protocol)协议即传输控制协议，是建立在IP协议基础之上的。TCP协议负责两台计算机之间建立可靠连接，保证数据包按顺序发送到。它是一种可靠的、一对一的、面向有连接的通信协议。

TCP是可靠的协议，这源于TCP的三次握手：

UDP:
UDP(User Datagram Protocol)协议即用户数据包协议，它是面向无连接的协议，只要知道对方的IP地址和端口，就可以直接发送数据包，由于是面向无连接的，所以无法保证数据一定会到达接收方。

端口号:

• 区分计算机中运行的应用程序的整数
• 端口号的取值范围是0到65535，一共65536个，其中80这个端口号分配给了HTTP服务，21这个端口号分配给了FTP服务。3306分配给了MySQL数据库，1521分配给了Oracle数据库，1433分配给了SQL Server数据库。

TCP协议与UDP协议的区别：

	TCP协议	UDP协议
连接方面	面向连接的	面向无连接
安全方面	传输消息可靠、不丢失、按顺序到达	无法保证不丢包
传输效率方面	传输效率相对较低	传输效率高
连接对象数量方面	只能是点对点、一对一	支持一对一、一对多、多对多的交互通信

TCP协议：面向连接的、可靠的、不丢失的、按顺序到达的，但传输效率相对较低，只能实现点对点，一对一的数据传输。

UDP协议：面向无连接、无法保证不丢包，但传输效率高，可以实现一对一、一对多、多对多的交互通信。

Socket套接字

前面提到IP协议、TCP协议和UDP协议，那么这些协议如何落实到程序中呢？

在Python中有一个类——socket，要想编写网络通信程序就一定需要用到socket类。

Socket套接字是用于描述IP地址和端口号的。

Socket模块可以实现TCP编程，也可以实现UDP编程。

socket模块中socket类的常用方法：

方法名称	功能描述
bind((ip,port))	绑定IP地址和端口
listen(N)	开始TCP监听，N表示操作系统挂起的最大连接数量，取值范围1-5之间，一般设置为5
accept()	被动接收TCP客户端连接，阻塞式
connect((ip,port))	主动初始化TCP服务器连接
recv(size)	接收TCP数据，返回值为字符串类型，size表示要接收的最大数据量
send(str)	发送TCP数据，返回值是要发送的字节数量
sendall(str)	完整发送TCP数据，将str中的数据发送到连接的套接字，返回之前尝试发送所有数据，如果成功为None，失败抛出异常
recvfrom()	接收UDP数据，返回值为一个元组(data,address),data表示接收的数据，address表示发送数据的套接字地址
sendto(data,(ip,port))	发送UDP数据，返回值是发送的字节数
close()	关闭套接字

TCP服务器端代码的编写

由于TCP协议是点对点的、一对一的，需要建立连接才可以进行交互的通信，所以TCP编程分为客户端编程和TCP服务器端编程。

TCP服务器端编程的步骤：

1. 使用socket类创建一个套接字对象
2. 使用bind((ip,port))方法绑定IP地址和端口号
3. 使用listen()方法开始TCP监听
4. 使用accept()方法等待客户端的连接
5. 使用recv()/send()方法接收/发送数据
6. 使用close()关闭套接字

# 服务器端
from socket import socket, AF_INET, SOCK_STREAM

# 从socket模块中导入socket类
# 参数AF_INET用于Internet之间的进程通信
# 参数SOCK_STREAM表示的是用TCP协议编程
# AF_INET、SOCK_STREAM大写说明这是常量

# (1)创建socket对象
server_socket = socket(AF_INET, SOCK_STREAM)  # AF_INET用于Internet之间的进程通信,SOCK_STREAM表示的是用TCP协议编程
# (2)绑定IP地址和端口
ip = '127.0.0.1'  # 本机的IP地址，等同于 localhost
port = 8888  # 端口号
server_socket.bind((ip, port))

# (3)使用listen()开始监听
server_socket.listen(5)
print('服务器已启动')

# (4)等待客户端的连接
# 客户端发送过来一个socket对象，以及地址。这里用的是系列解包赋值
client_socket, client_addr = server_socket.accept()  # 返回的是一个元组，使用系列解包赋值

# (5)接收来自客户端的数据
data = client_socket.recv(1024)  # recv()接收数据
# 客户端发送过来时需要编码，服务器端接收时要解码
print('客户端发送过来的数据为：', data.decode('utf-8'))  # 解码

# (6) 关闭socket
server_socket.close()

TCP客户端代码的编写

TCP客户端编程的步骤：

1. 使用socket类创建一个套接字对象
2. 使用connect((host,port))设置连接的主机IP和主机设置的端口号
3. 使用recv() / send()方法接收/发送数据
4. 使用close()关闭套接字

这里我们需要新建一个Python项目来代表另一台电脑：

选择New Window打开，这样就会打开两个PyCharm,每一个PyCharm就相当于一台电脑。

 

# 客户端
from socket import socket

# (1)创建Socket对象
client_socket = socket()
# (2)IP地址和主机接口，向服务器端发送连接请求
ip = '127.0.0.1'  # 要连接的主机的IP地址
port = 8888
client_socket.connect((ip, port))
print('----------与服务器连接建立成功------------')

# (3)发送数据
# 客户端发送时需要编码
client_socket.send('Welcome to python world'.encode('utf-8'))

# (4)关闭socket
client_socket.close()
print('发送完毕')

注意：
服务器端和客户端都编写好之后，一定要先启动服务器端，然后启动客户端，服务器端等待客户端发送连接。

当客户端和服务器端的连接建立好后，客户端和服务器端的地位是相等的，谁先发送数据都可以。只不过在上面的例子中是客户端先发送的数据，服务器端接收数据。

TCP编程客户端与服务器端启动运行有先后，先启动运行服务器端再启动运行客户端，连接建立之后双方谁先发送数据均可。

图示TCP通信过程：

TCP多次通信服务器端代码编写

在上面的例子中客户端与服务器端只进行了一次数据交互，事实上两者之间可以进行多次数据交互。

客户端与服务器端进行多次数据交互可以使用循环来实现。首先两者之间交互的次数不知道，所以应使用while循环实现。

# 多次通信。服务器端
# from socket import socket, AF_INET, SOCK_STREAM
import socket  # 这次使用这种导入方式

# 从socket模块中导入socket类
# 参数AF_INET用于Internet之间的进程通信
# 参数SOCK_STREAM表示的是用TCP协议编程
# AF_INET、SOCK_STREAM大写说明这是常量

# (1)创建socket对象
socket_obj = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # AF_INET用于Internet之间的进程通信,SOCK_STREAM表示的是用TCP协议编程
# (2)绑定IP地址和端口
socket_obj.bind(('127.0.0.1', 8888))

# (3)使用listen()开始监听
socket_obj.listen(5)  # 设置最大的连接数量--->5
print('服务器已启动')

# (4)等待客户端的TCP连接
# 客户端发送过来一个socket对象，以及地址(IP地址)。这里用的是系列解包赋值
client_socket, client_addr = socket_obj.accept()  # 返回的是一个元组，使用系列解包赋值

# 服务器端接收/发送数据时用的都是客户端的socket对象(client_socket)
# (5)接收来自客户端的数据
# while循环的四个步骤，info是初始化变量
info = client_socket.recv(1024).decode('utf-8')  # recv()接收数据.客户端发送过来时需要编码，服务器端接收时要解码
while info != 'bye':  # 条件判断，中间的是循环体
    if info != '':
        print('接收到的数据是：', info)
    # 准备发送数据
    data = input('请输入要发送的数据：')
    # 服务器端回复客户端
    client_socket.send(data.encode('utf-8'))
    if data == 'bye':
        break
    info = client_socket.recv(1024).decode('utf-8')  # 改变变量

# (6) 关闭socket对象
client_socket.close()  # 接收到的客户端的socket对象需要关闭
socket_obj.close()  # 服务器端的socket对象需要关闭

注意：
服务器端接收/发送数据时用的都是客户端的socket对象(client_socket)。【见上方循环体】

TCP多次通信客户端代码编写

# 多次通信。客户端
import socket

# (1)创建Socket对象
client_socket = socket.socket()
# (2)主机IP地址和主机接口，向服务器端发送连接请求
client_socket.connect(('127.0.0.1', 8888))
print('----------与服务器连接建立成功------------')

# (3)客户端先发送数据(在我们多次通信的例子中，编写的是服务器端先接收数据)
# while循环的四个步骤
info = ''
while info != 'bye':
    # 准备发送的数据
    send_data = input('请客户端输入要发送的数据：')
    client_socket.send(send_data.encode('utf-8'))
    # 判断
    if send_data == 'bye':
        break  # 退出循环
    # 接收一条数据
    info = client_socket.recv(1024).decode('utf-8')
    print('收到服务器的响应数据：', info)

# (4)关闭socket
client_socket.close()
print('发送完毕')

UDP的一次双向通信

UDP协议是面向无连接的，只需要知道对方的IP地址和端口号就可以发送数据包，但是它不保证数据包能够一定到达。

UDP编程客户端(发送方)步骤：

1. 使用socket类创建一个套接字对象
2. 准备发送的数据
3. 定义接收方的IP地址和端口号
4. 使用sendto()/recvfrom()方法发送/接收数据
5. 关闭socket对象

UDP编程服务器端(接收方)步骤：

1. 使用socket类创建一个套接字对象
2. 使用bind()方法绑定IP地址和端口号
3. 使用sendto()/recvfrom()方法发送/接收数据
4. 关闭socket对象

UDP编程接收方与发送方启动运行无先后，但先启动运行发送方，数据包会丢包，因此一般先启动接收方。

图示UDP通信过程：

UDP客户端(发送端)代码编写

# UDP客户端(发送端)
from socket import socket, AF_INET, SOCK_DGRAM

# 从socket模块中导入socket类
# 参数AF_INET用于Internet之间的进程通信
# 参数SOCK_DGRAM表示的是用UDP协议编程
# AF_INET、SOCK_DGRAM大写说明这是常量

# (1)创建Socket对象
send_socket = socket(AF_INET, SOCK_DGRAM)
# (2)准备发送数据
data = input('请输入要发送的数据：')
# (3)指定接收方的IP地址和端口
ip_port = ('127.0.0.1', 8888)

# (4)发送数据
send_socket.sendto(data.encode('utf-8'), ip_port)

# (5)接收来自接收方的回复数据
# recvfrom()返回的是一个元组-->(接收到的数据，从哪里获得的数据即地址)
recv_data, addr = send_socket.recvfrom(1024)
print('接收到的数据为：', recv_data.decode('utf-8'))

# (4)关闭socket
send_socket.close()
print('发送完毕')

UDP服务器端(接收端)代码编写

# UDP服务器端(接收方)
from socket import socket, AF_INET, SOCK_DGRAM

# 从socket模块中导入socket类
# 参数AF_INET用于Internet之间的进程通信
# 参数SOCK_DGRAM表示的是用UDP协议编程
# AF_INET、SOCK_DGRAM大写说明这是常量

# (1)创建socket对象
recv_socket = socket(AF_INET, SOCK_DGRAM)  # AF_INET用于Internet之间的进程通信,SOCK_DGRAM表示的是用UDP协议编程
# (2)绑定IP地址和端口
recv_socket.bind(('127.0.0.1', 8888))

# (3)接收来自发送方的数据
# recvfrom()返回的是一个元组-->(接收到的数据，从哪里获得的数据即地址)
recv_data, addr = recv_socket.recvfrom(1024)
print('接收到的数据为：', recv_data.decode('utf-8'))

# (4)准备回复对方的数据
data = input('请输入要回复的数据：')

# (5)回复
recv_socket.sendto(data.encode('utf-8'), addr)

# (6) 关闭socket对象
recv_socket.close()

运行效果

UDP模拟客服咨询小程序

聊天软件一般都是使用UDP编程实现的，这里我们使用UDP编程模拟客服咨询。

两者之间交互的次数不知道，所以应使用while循环实现。

客服人员(接收方)

# UDP模拟客服咨询小程序，客服人员(接收方)
from socket import socket, AF_INET, SOCK_DGRAM

# 从socket模块中导入socket类
# 参数AF_INET用于Internet之间的进程通信
# 参数SOCK_DGRAM表示的是用UDP协议编程
# AF_INET、SOCK_DGRAM大写说明这是常量

# (1)创建socket对象
recv_socket = socket(AF_INET, SOCK_DGRAM)  # AF_INET用于Internet之间的进程通信,SOCK_DGRAM表示的是用UDP协议编程
# (2)绑定IP地址和端口
recv_socket.bind(('127.0.0.1', 8888))

while True:
    # (3)接收来自发送方的数据
    # recvfrom()返回的是一个元组-->(接收到的数据，从哪里获得的数据即地址)
    recv_data, addr = recv_socket.recvfrom(1024)
    print('客户说：', recv_data.decode('utf-8'))
    if recv_data.decode('utf-8') == 'bye':
        break
    # (4)准备回复对方的数据
    data = input('客服回复：')
    # (5)回复
    recv_socket.sendto(data.encode('utf-8'), addr)

# (6) 关闭socket对象
recv_socket.close()

客户(发送方)

# UDP模拟客服咨询小程序，客户(发送方)
from socket import socket, AF_INET, SOCK_DGRAM

# 从socket模块中导入socket类
# 参数AF_INET用于Internet之间的进程通信
# 参数SOCK_DGRAM表示的是用UDP协议编程
# AF_INET、SOCK_DGRAM大写说明这是常量

# (1)创建Socket对象
send_socket = socket(AF_INET, SOCK_DGRAM)
while True:
    # (2)准备发送数据
    data = input('客户说：')
    # (3)指定接收方的IP地址和端口
    ip_port = ('127.0.0.1', 8888)
    # (4)发送数据
    send_socket.sendto(data.encode('utf-8'), ip_port)
    if data == 'bye':
        break

    # (5)接收来自接收方的回复数据
    # recvfrom()返回的是一个元组-->(接收到的数据，从哪里获得的数据即地址)
    recv_data, addr = send_socket.recvfrom(1024)
    print('客服回复：', recv_data.decode('utf-8'))

# (4)关闭socket
send_socket.close()
print('发送完毕')

运行效果