socket模块

合集 - python网络并发(12)

1.CS与BS架构2024-01-162.网络编程TCP UDP2024-01-163.粘包问题2024-01-16

4.socket模块2024-01-16

5.进程2024-01-166.操作系统2024-01-167.多进程操作2024-01-178.僵尸进程和孤儿进程2024-01-179.进程锁(互斥锁)2024-01-1710.守护进程2024-01-1711.线程池和进程池2024-02-1412.协程理论2024-02-14

收起

socket

(1)scoket层在哪

(2)什么是socket

• Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。
  • 在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面
  • 对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。
• 所以，我们无需深入理解tcp/udp协议，socket已经为我们封装好了，我们只需要遵循socket的规定去编程，写出的程序自然就是遵循tcp/udp标准的。
• 也有人将socket说成ip+port
  • ip是用来标识互联网中的一台主机的位置
  • 而port是用来标识这台机器上的一个应用程序
  • ip地址是配置到网卡上的
  • 而port是应用程序开启的
  • ip与port的绑定就标识了互联网中独一无二的一个应用程序
• 而程序的pid是同一台机器上不同进程或者线程的标识

(3)套接字发展史及分类

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

(1)基于文件类型的套接字家族

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

(2)基于网络类型的套接字家族

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

套接字工作流程

• 一个生活中的场景。
  • 你要打电话给一个朋友，先拨号，朋友听到电话铃声后提起电话，这时你和你的朋友就建立起了连接，就可以讲话了。
  • 等交流结束，挂断电话结束此次交谈。 生活中的场景就解释了这工作原理。

(1)服务端流程

• 先从服务器端说起。
  • 服务器端先初始化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 或 SOCK_DGRAM。protocol 一般不填,默认值为 0。
  
 # 获取tcp/ip套接字
  tcpSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  
 # 获取udp/ip套接字
  udpSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
 
 # 由于 socket 模块中有太多的属性，我们在这里使用了'from module import *'语句，把 socket 模块里的所有属性都带到我们的命名空间里了，这样能大幅减短我们的代码。
 #  例如tcpSock = socket(AF_INET, SOCK_STREAM)

(2)服务端套接字函数

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

(3)客户端套接字函数

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

(4)公共用途的套接字函数

• 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() 关闭套接字

(5)面向锁的套接字方法

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

(6)面向文件的套接字的函数

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

基于TCP的套接字

(1)方法简介

• tcp是基于链接的
  • 必须先启动服务端
  • 然后再启动客户端去链接服务端
• tcp服务端

server = socket() #创建服务器套接字
server.bind()      #把地址绑定到套接字
server.listen()      #监听链接
inf_loop:      #服务器无限循环
    conn = server.accept() #接受客户端链接
    comm_loop:         #通讯循环
        conn.recv()/conn.send() #对话(接收与发送)
    conn.close()    #关闭客户端套接字
server.close()        #关闭服务器套接字(可选)

• tcp客户端

client = socket()    # 创建客户套接字
client.connect()    # 尝试连接服务器
comm_loop:        # 通讯循环
    client.send()/client.recv()    # 对话(发送/接收)
client.close()            # 关闭客户套接字

(2)打电话模型

• socket通信流程与打电话流程类似
  • 我们就以打电话为例来实现一个low版的套接字通信

（1）服务端

import socket
 
# 先有电话
server = socket.socket()
 
# 电话要插卡
IP = '127.0.0.1'  # 本地的回环地址 / localhost
PORT = 8888
# ('ip','port')
server.bind((IP, PORT))
 
# 可能会接受到别人的电话
# 半连接池 ：
server.listen(5)
 
# 接电话
conn, addr = server.accept()
# print(conn) # <socket.socket fd=344, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 8888), raddr=('127.0.0.1', 10011)>
# print(addr)  # ('127.0.0.1', 10011)
 
 
# 接收消息
# 这里面可以放参数 参数：接收到的数据的大小
from_to_client_msg = conn.recv(1024)
from_to_client_msg = from_to_client_msg.decode('utf-8')
print(f'from_to_client_msg:>>> {from_to_client_msg}')
# 回复消息
# 传输的数据是二进制格式的数据
send_to_client_msg = f'我是服务端'
send_to_client_msg = send_to_client_msg.encode('utf-8')
conn.send(send_to_client_msg)
 
# 挂断电话
conn.close()
 
# 手机关机
server.close()

（2）客户端

import socket
 
# 有一部手机
client = socket.socket()
 
# 接电话，要知道别人的电话号
IP = '127.0.0.1'
PORT = 8888
client.connect((IP, PORT))
 
# 先发送消息
send_to_server_msg = f'我是客户端'
send_to_server_msg = send_to_server_msg.encode('utf-8')
client.send(send_to_server_msg)
 
# 要接收到服务端发过来的消息
from_server_msg = client.recv(1024)
# 二进制数据解码
from_server_msg = from_server_msg.decode('utf-8')
print(f'from_server_msg: >>>{from_server_msg}')
 
# 挂电话
client.close()

单次模版总结

（1）服务端模版

from socket import socket
 
# 创建socket对象
server = socket()
 
# 监听端口
IP = '127.0.0.1'
PORT = 8080
server.bind((IP, PORT))
 
# 监听连接对象个数
server.listen(5)
 
# 创建连接对象
conn, addr = server.accept()
 
# 通过连接对象接受数据
from_client_msg = conn.recv(1024)
from_client_msg = from_client_msg.decode('utf-8')
print(f'来自客户端的信息 :>>> {from_client_msg}')
 
# 回复数据
send_to_client_msg = '我是服务端'
send_to_client_msg = send_to_client_msg.encode('utf-8')
conn.send(send_to_client_msg)
 
# 关闭连接
conn.close()
 
# 关闭服务端
server.close()

（2）客户端模版

from socket import socket
 
# 创建客户端对象
client = socket()
 
# 监听连接 / 监听端口
IP = '127.0.0.1'
PORT = 9080
client.connect((IP, PORT))
 
# 发送消息
send_to_server_msg = f'我是客户端'
send_to_server_msg = send_to_server_msg.encode('utf-8')
client.send(send_to_server_msg)
 
# 接收消息
from_server_msg = client.recv(1024)
# 二进制数据解码
from_server_msg = from_server_msg.decode('utf-8')
print(f'来自服务端的信息 : >>>{from_server_msg}')

(3)打电话模型持续交互

• 升级版：加上连接循环与通信循环

（1）服务端

import socket
 
# 先有电话
server = socket.socket()
 
# 电话要插卡
IP = '127.0.0.1'  # 本地的回环地址 / localhost
PORT = 8888
# ('ip','port')
server.bind((IP, PORT))
 
# 可能会接受到别人的电话
server.listen(5)
 
while True:
    # 接电话
    conn, addr = server.accept()
 
    # 接收消息
    # 这里面可以放参数 参数：接收到的数据的大小
    from_to_client_msg = conn.recv(1024)
    from_to_client_msg = from_to_client_msg.decode('utf-8')
    print(f'来自客户端:>>> {from_to_client_msg}')
 
    # 回复消息
    # 传输的数据是二进制格式的数据
    while True:
        send_to_client_msg = input(f'请输入发送的消息 :>>>').strip()
        if not send_to_client_msg:
            print(f'当前不能为空!请重新输入!')
            continue
        send_to_client_msg = send_to_client_msg.encode('utf-8')
        conn.send(send_to_client_msg)
        break
 
    # 挂断电话
    conn.close()
# 手机关机
server.close()

（2）客户端

import socket
 
 
while True:
    # 有一部手机
    client = socket.socket()
 
    # 接电话，要知道别人的电话号
    IP = '127.0.0.1'
    PORT = 8888
    client.connect((IP, PORT))
    # 先发送消息
 
    send_to_server_msg = input(f'请输入发送的消息 :>>>').strip()
    if not send_to_server_msg:
        print(f'当前不能为空!请重新输入!')
        continue
    send_to_server_msg = send_to_server_msg.encode('utf-8')
    client.send(send_to_server_msg)
 
    # 要接收到服务端发过来的消息
    from_server_msg = client.recv(1024)
    # 二进制数据解码
    from_server_msg = from_server_msg.decode('utf-8')
    print(f'来自服务端: >>>{from_server_msg}')
 
# 挂电话
client.close()

循环模版总结

（1）服务端模版

from socket import socket
 
# 创建了一个套接字对象 server，默认使用IPv4和TCP协议。这个套接字将用于监听客户端的连接请求。
server = socket()
 
# 绑定服务器的 IP 地址为 '127.0.0.1'（表示本地主机）和端口号为 8888。这是服务器等待客户端连接的地址和端口。
server.bind(('127.0.0.1', 8888))
 
# 开始监听连接请求，参数 5 指定在拒绝连接之前，操作系统可以挂起的最大连接数量。
server.listen(5)
 
while True:
    # 这是一个阻塞操作，等待客户端连接。一旦有客户端连接进来，accept 返回一个新的套接字对象 conn 和客户端的地址信息 addr。
    # conn： 是一个新的套接字对象，它用于与特定客户端进行通信。通过这个新的套接字，服务器和客户端可以进行数据的收发。
    # addr： 是客户端的地址信息，通常是一个包含客户端 IP 地址和端口号的元组。
    # 在之后的代码中，可以使用 conn 对象来发送和接收数据，建立与客户端之间的通信。
    conn, addr = server.accept()
    
    # 通过 recv 方法接收客户端发送的消息，这里假设消息的最大长度为 1024 字节。然后将收到的消息解码为 UTF-8 格式，并打印出来。
    msg = conn.recv(1024)
    print(f'来自客户端:>>> {msg.decode("utf-8")}')
    
    # 通过 input 从控制台获取用户输入的消息，然后使用 send 方法将消息编码为 UTF-8 格式并发送给客户端。 
    while True:
        send_to_client_msg =  input(f'请输入发送的消息 :>>>').strip()
        if not send_to_client_msg:
            print(f'当前内容为空!请重新输入!')
            continue
        conn.send(send_to_client_msg.encode('utf-8'))
        break
        
    # 关闭与客户端的连接。    
    conn.close()
    
# 关闭服务器的监听套接字。
server.close()

（2）客户端模版

from socket import socket
 
while True:
    # 创建了一个套接字对象 client，默认使用IPv4和TCP协议。这个套接字将用于与服务器建立连接。
    client = socket()
 
    # 使用 connect 方法连接到服务器的地址 '127.0.0.1'（本地主机）和端口号 8888。如果服务器正常运行并接受连接，这一步会建立客户端与服务器的连接。
    client.connect(('127.0.0.1', 8888))
    
    # 通过 input 从控制台获取用户输入的消息，然后使用 send 方法将消息编码为 UTF-8 格式并发送给服务器。
    send_to_server_msg = input(f'请输入发送的消息 :>>>').strip()
    if not send_to_server_msg:
        print(f'当前不能为空!请重新输入!')
        continue
    client.send(send_to_server_msg.encode('utf-8'))
    
    # 使用 recv 方法接收服务器发送的消息，这里假设消息的最大长度为 1024 字节。
    from_server_msg = client.recv(1024)
    
    # 将从服务器接收到的二进制数据解码为 UTF-8 格式，并打印出来。
    from_server_msg = from_server_msg.decode('utf-8')
    print(f'来自服务端: >>>{from_server_msg}')
    
    # 关闭客户端的套接字，结束与服务器的连接。
    client.close()

基于UDP的套接字

（1）循环模版

（1）服务端模版

from socket import socket, AF_INET, SOCK_DGRAM
 
# 创建UDP套接字
server = socket(AF_INET, SOCK_DGRAM)
 
# 绑定地址和端口
server_address = ('127.0.0.1', 8888)
server.bind(server_address)
 
while True:
    # 接收数据和客户端地址
    data, client_address = server.recvfrom(1024)
 
    # 处理接收到的数据
    decoded_data = data.decode('utf-8')
    print(f'来自客户端的信息:>>> {decoded_data}')
 
    # 回复客户端
    while True:
        response_msg = input(f'请输入发送的消息 :>>>').strip()
        if not response_msg:
            print(f'当前不能为空!请重新输入!')
            continue
        server.sendto(response_msg.encode('utf-8'), client_address)
        break
 
# 关闭套接字
server.close()

（2）客户端模版

from socket import socket, AF_INET, SOCK_DGRAM
 
# 创建UDP套接字
client = socket(AF_INET, SOCK_DGRAM)
 
# 服务器地址和端口
server_address = ('127.0.0.1', 8888)
 
while True:
    # 获取用户输入的消息
    send_to_server_msg = input(f'请输入发送的消息 :>>>').strip()
    if not send_to_server_msg:
        print(f'当前不能为空!请重新输入!')
        continue
    # 发送消息到服务器
    client.sendto(send_to_server_msg.encode('utf-8'), server_address)
 
    # 接收来自服务器的响应
    data, server_response_address = client.recvfrom(1024)
    decoded_data = data.decode('utf-8')
    print(f'来自服务器的信息:>>> {decoded_data}')
 
# 关闭套接字
client.close()