python学习之网络编程

Posted 2021-03-09

socket编程

本地进程间通信(IPC)
? 队列
? 同步(互斥锁、条件变量等)
? 管道
网络进程间通信
问题: 本地通过进程PID来唯一标识一个进程,在网络中如何唯一标识一个进程?
网络层的“IP地址”可以唯一标识网络中的主机,而传输层的“协议+端口”
可以唯一标识主机中的应用程序(进程)。因此利用IP地址,协议,端口就
可以标识网络的进程。
什么是socket?
socket(简称套接字) 是进程间通信的一种方式, 能实现不同主机间的进程间通信,我们
网络上各种各样的服务大多都是基于 Socket 来完成通信的。
创建socket
在 Python 中 使用socket 模块的函数 socket 就可以完成:
socket.socket(AddressFamily, Type)
1). Address Family:
AF_INET: IPV4用于 Internet 进程间通信
AF_INET6: IPV6用于 Internet 进程间通信
2). Type:套接字类型
SOCK_STREAM: 流式套接字,主要用于 TCP 协议
SOCK_DGRAM: 数据报套接字,主要用于 UDP 协 议

01_socket对象的建立

import socket
#1. 创建socket对象
#family: AF_INET(IPv4)   AF_INET6(IPv6)      ========= 网络层协议
#type: # SOCK_STREAM(TCP)   SOCK_DGRAM(UDP) ========== 传输层协议
#Linux： 可以认为是一个文件；
socketObj = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)
print(socketObj.getsockname())

#2.  关闭socket对象
socketObj.close()

2. socket基本使用
import os
os.system(‘hostname‘)

hostname = socket.gethostname()
print("主机名:", hostname)

print(socket.gethostbyname(‘localhost‘))

UDP介绍
UDP 用户数据报协议,是一个无连接的简单的面向数据报的运输层协议。UDP不提供可靠
性,它只是把应用程序传给IP层的数据报发送出去,但 是并不能保证它们能到达目的地。
由于UDP在传输数据报前不用在客户和服 务器之间建立一个连接,且没有超时重发等机制,
故而传输速度很快
UDP是一种面向无连接的协议,每个数据报都是一个独立的信息,包括完整 的源地址
或目的地址,它在网络上以任何可能的路径传往目的地,因此能否到达目的地,到达
目的地的时间以及内容的正确性都是不能被保证的
UDP特点
UDP是面向无连接的通讯协议,UDP数据包括目的端口号和源端口号信息, 由于通讯不需要连接,
所以可以实现广播发送。 UDP传输数据时有大小限 制,每个被传输的数据报必须限定在64KB之内。
UDP是一个不可靠的协 议,发送方所发送的数据报并不一定以相同的次序到达接收方。
UDP网络程序

udp_server.py

import socket

udpserver = socket.socket(family=socket.AF_INET, type=socket.SOCK_DGRAM)
udpserver.bind((‘0.0.0.0‘, 9999))
print(‘QQ用户A上线.........‘)
while True:
    # 返回的是元组， 一个个元素是客户端发送的信息， 第二个元素是客户端和服务端交互的地址(IP, port)
    recv_data, address = udpserver.recvfrom(1024)
    #print(address)
    print("B:>> ", recv_data.decode(‘utf-8‘))
    if recv_data == b‘quit‘:
        print("聊天结束.......")
        break
    #发送的消息必须是bytes类型
    #bytes -->  str    bytesObj.decode(‘utf-8‘)
    #str   --> bytes   strObj.encode(‘utf-8‘)
    send_data = input(‘A: >> ‘).encode(‘utf-8‘)
    if not send_data:
        continue
    udpserver.sendto(send_data, address)

udpserver.close()

udp_client.py:

import socket

udpclient = socket.socket(family=socket.AF_INET, type=socket.SOCK_DGRAM)

print("QQ用户B上线.........")
while True:
    send_data = input(‘B:>> ‘).encode(‘utf-8‘)
    if not send_data:
        continue
    udpclient.sendto(send_data, (‘172.25.254.197‘, 9999))
    if send_data == b‘quit‘:
        print("聊天结束.....")
        break
    recv_data, address = udpclient.recvfrom(1024)
    print("A:>> ", recv_data.decode(‘utf-8‘))

udpclient.close()

TCP介绍
TCP: 传输控制协议(英语:Transmission Control Protocol,缩写为TCP)是一种面向连
接的、可靠的、基于字节流的传输层通信协议。

TCP介绍
TCP: 传输控制协议(英语:Transmission Control Protocol,缩写为TCP)是一种面向连
接的、可靠的、基于字节流的传输层通信协议。
TCP网络程序

TCP三次握手

? 两个包: 同步序列标号 SYN
确认包 ACK
? 四种状态: SYN_SENT, LISTEN, SYN_RECV, ESTABLISHED
在三次握手中,客户端和服务器端都发送两个包SYN和ACK,只不过服务器端的两个包是一次性
发过来的,客户端的两个包是分两次发送的
TCP数据传输

TCP四次分手
当A端和B端要断开连接时,需要四次握手,这里称为四次挥手。

? 两个包: FIN:Finish, ACK确认序号

tcp_server.py

import socket
#1. 创建服务端socket对象
server = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)

#2. 绑定地址和端口(IP:port)
server.bind((‘0.0.0.0‘, 9998))

#3. 监听是否有客户端连接?listen
server.listen(5)
print(‘server start .........‘)
#4.接收客户端的连接accept
clientSocketObj, clientAddress = server.accept()
#5. 接收客户端发送的消息
recv_data = clientSocketObj.recv(1024).decode(‘utf-8‘)
print("接收到客户端发送的消息:", recv_data)

#6. 给客户端发送消息
send_data = b‘hello client‘
clientSocketObj.send(send_data)
#7. 关闭socket对象
clientSocketObj.close()
server.close()

tcp_client.py

import socket

#1. 创建服务端socket对象
client = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)
#2. 连接服务端
client.connect((‘172.25.254.197‘, 9998))
#3.给服务端发送消息
client.send(b‘hello server‘)
#4. 接收服务端发送的消息
recv_data = client.recv(1024).decode(‘utf-8‘)
print("接收服务端发送的消息:", recv_data)
#5. 关闭socket对象
client.close()

并发服务器
并发服务器是socket应用编程中最常见的应用模型。根据连接方式分为长连接和短连接.
通信方式 具体通信过程
长连接 建立SOCKET连接后不管是否使用都保持连接
短连接 双方有数据交互时,建立TCP连接,数据发送完成后断开连接
并发服务器模型根据处理方式可分为同步方式和异步方式。

单进程服务器
? 同一时刻只能为一个客户进行服务,不能同时为多个客户服务
? 类似于找一个“明星”签字一样,客户需要耐心等待才可以获取到服务
多进程服务器
优点: 通过为每个客户端创建一个进程的方式,能够同时为多个客户端进行服务
缺点: 当客户端不是特别多的时候,这种方式还行,如果有几百上千个,就不 可取了,
因为每次创建进程等过程需要好较大的资源

多进程server.py

#实现多进程的方式:
#1. 实例化对象
#2. 继承子类
#注意: 一定要确定多进程要处理的任务

#任务: 处理客户端请求并为其服务

def dealWithClient(clientSocketObj, clientAddress):
    while True:
        # 5. 接收客户端发送的消息
        recv_data = clientSocketObj.recv(1024).decode(‘utf-8‘)
        print(clientAddress[0] + str(clientAddress[1]) + ‘:> ‘ + recv_data)
        if recv_data == ‘quit‘:
            break
    clientSocketObj.close()

import socket
from multiprocessing import Process

#1. 创建服务端socket对象
server = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

#2. 绑定地址和端口(IP:port)
server.bind((‘0.0.0.0‘, 9997))

#3. 监听是否有客户端连接?listen
server.listen(5)
print(‘server start .........‘)

while True:
    # 4.接收客户端的连接accept
    clientSocketObj, clientAddress = server.accept()
    #dealWithClient(clientSocketObj)
    p = Process(target=dealWithClient, args=(clientSocketObj, clientAddress))
    p.start()

#server.close()

多进程clinet.py

import socket

#1. 创建服务端socket对象
client = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)

#2. 连接服务端
client.connect((‘172.25.254.197‘, 9997))

while True:
    # 3.给服务端发送消息
    send_data = input(‘client: >> ‘).encode(‘utf-8‘)
    if not send_data:
        continue
    client.send(send_data)
    if send_data == ‘quit‘:
        break

#5. 关闭socket对象
client.close()