socket

Posted 2020-07-23

socket 模块 ，

socket：我们俗称套接字, 套接字的基本作用就是让两个端口，服务端及客户端进行网络连接。通过套接字相互发送接收信息

在创建一个服务器套接字后，让它等待连接，这样题就在某个网络地址处（ip地址和一个端口号的组合） 监听， 直到有客户端套接字连接，连接完成 服务端和客户端就可以进行交互了。

socket起源于Unix，而Unix/Linux基本哲学之一就是“一切皆文件”，对于文件用【打开】【读写】【关闭】模式来操作。socket就是 该模式的一个实现，socket即是一种特殊的文件，一些socket函数就是对其进行的操作（读/写IO、打开、关闭）

 

一个套接字就是socket模块中socket类的实例，他的实例化需要3个参数

参数一：地址簇

　　socket.AF_INET IPv4（默认）
　　socket.AF_INET6 IPv6

　　socket.AF_UNIX 只能够用于单一的Unix系统进程间通信

参数二：类型

　　socket.SOCK_STREAM　　流式socket , for TCP （默认）   表示以tcp的方式去连接

流套接字用于提供面向连接、可靠的数据传输服务。该服务将保证数据能够实现无差错、无重复发送，并按顺序接收。流套接字之所以能够实现可靠的数据服务，原因在于其使用了传输控制协议，       即TCP（The Transmission Control Protocol）协议。
　　socket.SOCK_DGRAM　　 数据报式socket , for UDP         表示以utp的方式去连接   数据包套接字提供了一种无连接的服务。该服务并不能保证数据传输的可靠性，数据有可能在传输过程中丢失或出现数据重复，且无法保证顺序地接收到数据。数据包套接字使用UDP（User Datagram Protocol）

协议进行数据的传输。由于数据包套接字不能保证数据传输的可靠性，对于有可能出现的数据丢失情况，需要在程序中做相应的处理

      原始套接字(SOCKET_RAW)允许对较低层次的协议直接访问，比如IP、 ICMP协议，它常用于检验新的协议实现，或者访问现有服务中配置的新设备，因为RAW SOCKET可以自如地控制Windows下的多种协议，
能够对网络底层的传输机制进行控制，所以可以应用原始套接字来操纵网络层和传输层应用。比如，我们可以通过RAW SOCKET来接收发向本机的ICMP、IGMP协议包，或者接收TCP/IP栈不能够处理的IP包，
也可以用来发送一些自定包头或自定协议的IP包。网络监听技术很大程度上依赖于SOCKET_RAW
　　socket.SOCK_RDM 是一种可靠的UDP形式，即保证交付数据报但不保证顺序。SOCK_RAM用来提供对原始协议的低级访问，在需要执行某些特殊操作时使用，如发送ICMP报文。SOCK_RAM通常仅限于高级用户或管理员运行的程序使用。
　　socket.SOCK_SEQPACKET 可靠的连续数据包服务

 

###################服务端：：################
import socket

sk = socket.socket()             #创建对象
sk.bind((\'127.0.0.1\',9999,))   #绑定ip 端口
sk.listen(5)                    #监听最多的次数的限制  接收客户端的请求
#conn 连接 assress 客户端端口（地址信息）
while True:
    conn,address = sk.accept()      # 阻塞
    print(address,conn)            #输出客户端的的信息


##################客户端########################
import socket
import time
obj = socket.socket()
while True:
    time.sleep(10)
    obj = socket.socket()
    obj.connect((\'127.0.0.1\',9999))  connect的方法是连接服务器
    obj.close()

创建 服务端 客户端

sk.bind(address)

　　s.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是连接客户端的地址。

　　接收TCP 客户的连接（阻塞式）等待连接的到来

sk.connect(address)

　　连接到address处的套接字。一般，address的格式为元组（hostname,port）,如果连接出错，返回socket.error错误。

sk.connect_ex(address)

　　同上，只不过会有返回值，连接成功时返回 0 ，连接失败时候返回编码，例如：10061

sk.close()

　　关闭套接字

sk.recv(bufsize[,flag])

　　接受套接字的数据。数据以字符串形式返回，bufsize指定最多可以接收的数量。flag提供有关消息的其他信息，通常可以忽略。

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表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如 client 连接最多等待5s ）

sk.getpeername()

　　返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。

sk.getsockname()

　　返回套接字自己的地址。通常是一个元组(ipaddr,port)

sk.fileno()

　　套接字的文件描述符

方法介绍：：

实例：简单的聊天工具

 

###############服务端#################
import socket
sk = socket.socket()     创建TCP/IP套接字
sk.bind((\'127.0.0.1\',9999))     #绑定服务端的IP和端口
sk.listen(5)                #启动监听，并设置最多可以通知连入连接数
while True:
    conn,address = sk.accept()   #接收客户端的请求(阻塞,一直等待),把接收到客户端的连接和地址信息分别传给连个变量
    # print(conn,address)
    conn.sendall(bytes(\'欢迎光临开心小居\',encoding=\'utf-8\'))
    while True:
        ret_bytes = conn.recv(1024)           #如果有客户端发来请求就每次都只接受1024个字节的内容，注意recv()也是阻塞的
        ret_str = str(ret_bytes,encoding=\'utf-8\')
        if ret_str == \'q\':
            break
        # conn.sendall = sk.accept()
        conn.sendall(bytes(ret_str + \'精干小伙\',encoding=\'utf-8\'))
#################客户端#######################
import socket
obj = socket.socket()       #创建TCP/IP套接字  # 连接发送数据
obj.connect((\'127.0.0.1\',9999))   指定服务端的ip地址和端口号
                                                   # 阻塞   如果服务端 不回消息， 就会一直等待
ret_betys = obj.recv(1024)   #接收消息 接受的是字节
ret_str = str(ret_betys,encoding=\'utf-8\') 获取字节转换的字符串
print(ret_str)
while True:
    inp = input(\'请输入发送的内容：\')
    if inp == \'q\':
        break
    else:
        obj.sendall(bytes(inp,encoding=\'utf-8\')) 给服务端发消息
        ret = str(obj.recv(1024),encoding=\'utf-8\')
        print(ret)
obj.close()
                                                                                                

 套接字 有两个方法 send 和（recv） 用于接收，用于传输数据，可以使用字符串参数调用send比发送数据，用一个所需的（最大）字节来做参数，调用recv来接收数据。

socket 文件上传：

服务端：1、等待连接，连接上以后开始接受文件大小并转成整型

　　　　2、中间来一次交互解决粘包问题

　　　　3、设定一开始接受文件大小为0

　　　　4、利用循环源源不断的接受数据

　　　　5、循环一次计算一次传过来文件的大小（len（xx））

　　　　6、当总文件大小和传过来的文件大小一致时，不在接收数据，退出关闭文件

客户端：1、连接服务端

　　　　2、先计算文件大小并发过去

　　　　3、中间来一次交互解决粘包问题

　　　　4、打开文件并循环文件的每一行并发送文件

import socket
sk = socket.socket()
sk.bind((\'127.0.0.1\',9999))
sk.listen(5)
while True:
    conn,address = sk.accept() # 阻塞 等待客户端的请求，
    conn.sendall(bytes(\'欢迎光临\',encoding=\'utf-8\'))
    xx_size = str(conn.recv(1024),encoding=\'utf-8\')   #接收客户端发送的文件大小
    total_size = int(xx_size)         #将文件大小转为int类型
    has_recv = 0                     #创建文件大小的默认值
    conn.sendall(bytes(\'走开\',encoding=\'utf-8\'))    #给客户端发送消息 解决粘包
    f = open(\'z.png\',\'wb\')       #以wb模式创建文件
    while True:
        if total_size == has_recv:      #判断发送的文件的大小是否等于文件的总大小
            break                       #停止 退出
        data = conn.recv(1024)          #接收客户端的消息
        f.write(data)
        has_recv+=len(data)       #将文件的总大小加上客户端的发送文件大小
    f.close()       #关闭文件

#服务端

import socket
import os

obj = socket.socket()
obj.connect((\'127.0.0.1\',9999))    #连接服务端的ip于端口
ret_bytes = obj.recv(1024)          #接收服务端的字节消息
ret_str = str(ret_bytes,encoding=\'utf-8\')  #将接收到的消息转换为字符串
print(ret_str)                            #输出消息
size = os.stat(\'link.jpg\').st_size       #获取传送文件的总大小
obj.sendall(bytes(str(size),encoding=\'utf-8\'))  #将文件的总大小发送给服务端
print(str(obj.recv(1024),encoding=\'utf-8\'))    #接收服务端返回的信息
with open(\'link.jpg\',\'rb\')as f:   #rb模式打开文件
    for i in f:                    #循环文件全部内容
        obj.sendall(i)           #发送给服务端
obj.close()                    #关闭文件

#客户端

IO多路复用

I/O多路复用指：通过一种机制，可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或者写就绪），能够通知程序进行相应的读写操作。

 ###################服务端######################

#!/usr/bin/env/python
# -*- coding:utf-8 -*-
import socket

sk1 = socket.socket()
sk1.bind((\'127.0.0.1\',8001))
sk1.listen()


sk2 = socket.socket()
sk2.bind((\'127.0.0.1\',8002))
sk2.listen()


sk3 = socket.socket()
sk3.bind((\'127.0.0.1\',8003))
sk3.listen()
inputs =[sk1,sk2,sk3]
outputs = []
message_dict = {}
import select

while True:
    r_list,w_list,e_list = select.select(inputs,outputs,inputs,1)
    print(\'正在监听的socket对象%d\' % len(inputs))
    print(r_list)

    for sk1_or_conn in r_list:
        if sk1_or_conn == sk1:
            conn,address = sk1_or_conn.accept()
            inputs.append(conn)
            message_dict[conn] = []
        else:
            try:
                data_bytes = sk1_or_conn.recv(1024)
            except Exception as ex:
                inputs.remove(sk1_or_conn)
            else:
                data_str = str(data_bytes,encoding=\'utf-8\')
                message_dict[sk1_or_conn].append(data_str)
                outputs.append(sk1_or_conn)
    for conn in w_list:
        recv_str = message_dict[conn][0]
        del message_dict[conn][0]
        conn.sendall(bytes(\'haozzz\',encoding=\'utf-8\'))
        outputs.remove(conn)

    for sk in e_list:
        inputs.remove(sk)


###################客户端11########################

import socket

obj = socket.socket()
obj.connect((\'127.0.0.1\',8001))
while True:
    inp = input("请输入>>>>")
    obj.sendall(bytes(inp,encoding=\'utf-8\'))
    ret = str(obj.recv(1024),encoding =\'utf-8\')
    print(ret)

obj.close()

监听多个

SocketServer 模块：

SocketServer内部使用 IO多路复用 以及 “多线程” 和 “多进程” ，从而实现并发处理多个客户端请求的Socket服务端。即：每个客户端请求连接到服务器时，Socket服务端都会在服务器是创建一个“线程”或者“进 程” 专门负责处理当前客户端的所有请求。

################服务端################
import socketserver

class MyServer(socketserver.BaseRequestHandler):
    def handle(self):
        conn = self.request
        conn.sendall(bytes(\'凯欣欢迎你\',encoding=\'utf-8\'))
        while True:
            ret_bytes = conn.recv(1024)
            ret_str = str(ret_bytes,encoding=\'utf-8\')
            if ret_str == \'q\':
                break
            conn.sendall(bytes(ret_str+\'谢谢\',encoding=\'utf-8\'))

if __name__ == \'__main__\':
    server = socketserver.ThreadingTCPServer((\'127.0.0.1\',9999),MyServer)
    server.serve_forever()

#################客户端######################
import socket

obj = socket.socket()     # 连接发送数据
obj.connect((\'127.0.0.1\',9999))

# 阻塞   如果服务端 不回消息， 就会一直等待
ret_betys = obj.recv(1024)   #接收消息
ret_str = str(ret_betys,encoding=\'utf-8\')
print(ret_str)
while True:
    inp = input(\'请输入发送的内容：\')
    if inp == \'q\':
        break
    else:
        obj.sendall(bytes(inp,encoding=\'utf-8\'))
        ret = str(obj.recv(1024),encoding=\'utf-8\')
        print(ret)
obj.close()

实现连接多个客户端