socket

大致上一切网络皆socket(套接字)

socket是应用层与TCP/IP协议的封装，留给使用者一个编程接口(API借口)，用来实现网络上两个进程之间的数据交互,连接的一端称为一个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.close（） 关闭套接字

其它功能:

参数一：地址簇

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

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

参数二：类型

　　socket.SOCK_STREAM　　流式socket , for TCP （默认）
　　socket.SOCK_DGRAM　　 数据报式socket , for UDP

　　socket.SOCK_RAW 原始套接字，普通的套接字无法处理ICMP、IGMP等网络报文，而SOCK_RAW可以；其次，SOCK_RAW也可以处理特殊的IPv4报文；此外，利用原始套接字，可以通过IP_HDRINCL套接字选项由用户构造IP头。
　　socket.SOCK_RDM 是一种可靠的UDP形式，即保证交付数据报但不保证顺序。SOCK_RAM用来提供对原始协议的低级访问，在需要执行某些特殊操作时使用，如发送ICMP报文。SOCK_RAM通常仅限于高级用户或管理员运行的程序使用。
　　socket.SOCK_SEQPACKET 可靠的连续数据包服务

参数三：协议

　　0　　（默认）与特定的地址家族相关的协议,如果是 0 ，则系统就会根据地址格式和套接类别,自动选择一个合适的协议

service端:


import socket
sk = socket.socket()#创建对象
sk.bind(('127.0.0.1',9999,))#绑定地址,内部IP是元祖所以加括号,最好在后面加逗号(表示是元祖)
sk.listen(5)#监听传入连接数最大为5,第6个直接断开
#接收客户端请求

while True:
    conn, address = sk.accept()#接收客户端请求(阻塞),等待连接. conn新的套接字对象接收发送数据,address连接客户端地址
    conn.sendall(bytes("欢迎光临",encoding="utf-8"))#py3需要已字节的形式发送内容,用户连接过来时给他发一条信息
    while True:
        print("正在等待Client输入内容......")
        ret_bytes = conn.recv(1024)#接收客户端发送过来的内容
        ret_str = str(ret_bytes,encoding="utf-8")#转为字符串类型
        print(ret_str)## 输出用户发送过来的内容
        if ret_str == "q":#如果输入q退出
            break
        inp = input("Service请输入要发送的内容>>>")
        conn.sendall(bytes(inp,encoding="utf-8"))#给客户端发送内容
    print(address,conn)


client端:

import socket
obj = socket.socket()
obj.connect(('127.0.0.1',9999,))#连接到address处的套接字
#recv阻塞等待用户发出去
ret_bytes = obj.recv(1024)#接收数据,因为服务端发送过来的是字节,所以需要把字节转换为字符串进行输出,最大接收1024字节(最大接收1024*8,就是8K),超过下次连接
ret_str = str(ret_bytes,encoding="utf-8")
print(ret_str)# 输出内容
while True:
    inp = input("Client请输入要发送的内容>>> ")#当进入连接的时候,提示让用户输入内容
    if inp == "q":#如果输入q则退出
        obj.sendall(bytes(inp,encoding="utf-8"))# 把q发送给服务端
        break#退出当前while

    else:
        obj.sendall(bytes(inp,encoding="utf-8"))#否则就把用户输入的内容发送给用户
        print("正在等待Server输入内容......")#等待服务端回答
        ret = str(obj.recv(1024),encoding="utf-8")#获取服务端发送过来的结果
        print(ret)
obj.close()#连接完成之后关闭链接

 socket上传文件

server:
import socket

sk = socket.socket()
sk.bind(("127.0.0.1",9999,))
sk.listen(5)
while True:
    conn, address = sk.accept()
    conn.sendall(bytes("欢迎登陆老男孩FTP",encoding="utf-8"))
    file_size = str(conn.recv(1024),encoding="utf-8")
    print(file_size)
    total_size = int(file_size)
    has_recv = 0
    f = open("new.jpg","wb")#上传的新文件
    while True:
        if total_size == has_recv:
            break
        data = conn.recv(1024)
        f.write(data)
        has_recv += len(data)
    f.close()


client:

import  socket, os
obj = socket.socket()
obj.connect(("127.0.0.1",9999,))
ret_bytes = obj.recv(1024)
ret_str = str(ret_bytes,encoding="utf-8")
print(ret_str)

size = os.stat("f.jpg").st_size#获取图片的字节大小
obj.sendall(bytes(str(size), encoding="utf-8"))

with open("f.jpg","rb") as f:
    for line in f :
        obj.sendall(line)
obj.close()

粘包:

只有TCP有粘包现象，UDP永远不会粘包。

TCP（传输控制协议）是面向连接,提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的socket,发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样，接收端，就难于分辨出来了，就会粘包

UDP(用户数据报协议）是无连接的，面向消息的，提供高效率服务。不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式.会丢数据，不可靠

 

tcp的协议数据不会丢，没有收完包，下次接收，会继续上次继续接收，己端总是在收到ack时才会清除缓冲区内容。数据是可靠的，但是会粘包。

两种情况下会发生粘包：

1.发送端需要等本机的缓冲区满了以后才发送出去，造成粘包（发送数据时间间隔很端，数据很小，会合在一个起，产生粘包）

2.接收端不及时接收缓冲区的包，造成多个包接受（客户端发送一段数据，服务端只收了一小部分，服务端下次再收的时候还是从缓冲区拿上次遗留的数据 ，就产生粘包）

解决粘包方法:

为字节流加上自定义固定长度报头，报头中包含字节流长度，然后依次send到对端，对端在接受时，先从缓存中取出定长的报头，然后再取真实数据。

　　使用struct模块

　　该模块可以把一个类型，如数字，转成固定长度的bytes字节

　　>>> res=struct.pack('i',1111111111111)  #打包成固定长度的bytes

　　>>> struct.unpack(“I”,res)             #解包

#服务端
import struct   #导入模块
import socket   #导入模块
import json     #导入模块
import subprocess   #导入模块
din=socket.socket(socket.AF_INET,socket.SOCK_STREAM)   #基于网络家族以流的方式创建一个链接路
ip=('127.0.0.1',8080)  #设定服务端唯一的地址
din.bind(ip)  #绑定地址
din.listen(5)  #激活启动，设置链接池最大缓数量
while True:
    conn,addr=din.accept()   #等待接受数据链接
    print('------->>>')
    while True:
        try:   #开始捕捉异常,在windows中使用
            dr=conn.recv(1024)   #接收内容并赋值给dr
            res=subprocess.Popen(dr.decode('utf-8'),shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)   #设置一个管道，把对的内容一个对的管道中，把错误的放进一个错误的管道中。
            dui=res.stdout.read()  #读取标准输出的内容并赋值给dui
            cuo=res.stderr.read()  #读取错误输出的内容并赋值给cuo
            data_lik=len(dui)+len(cuo)  #计算标准输出和错误输出的总长度并赋值给data_lik
            head_dic={'data_lik':data_lik}  #自己顶一个字典 并赋值给head_dic
            head_json=json.dumps(head_dic)  #把自己定义的字典进行一个序列化
            head_bytes=head_json.encode('utf-8')  #把序列化后的内容进行转码 ，因为网络传输都是通过字节进行传输
            head_len=len(head_bytes)  #把转换成字节码的长度拿到 并赋值给head_len
            #发送报头长度
            conn.send(struct.pack('i',head_len))  #发送自己定义的报头长度
            # 发送报头
            conn.send(head_bytes)       #发送自己定义的报头
            #发送真是数据  
            conn.send(dui)              #发送真实的数据
            conn.send(cuo)              #发送真实的数据
        except Exception:               #结束捕捉异常
            break                       #跳出
    conn.close()                        #断开链接
din.close()                             #关闭连接




#客户端
import struct    #导入模块
import socket    #导入模块
import json      #导入模块
din=socket.socket(socket.AF_INET,socket.SOCK_STREAM)   #基于网络家族和流的方式传输 创建连接
ip=('127.0.0.1',8080)     #设置唯一的地址
din.connect(ip)           #绑定地址
while True:  
    run=input('请输入命令：')      #用户交互界面
    if not run:continue           #判断如果run为空就跳出
    din.send(bytes(run,encoding='utf-8'))   #通过字节形式发送用户输入的的内容
    data=din.recv(4)          #接收内容长度为4，并赋值给data
    head_len=struct.unpack('i',data)[0]  #解报头并索引出值赋值给head_len
    head_bytes=din.recv(head_len)      #接收长度为head_len变量中的值，赋值给head_bytes
    head_json=head_bytes.decode('utf-8')   #把刚刚接收的内容进行转换，转换成utf-8
    head_dic=json.loads(head_json)       #在把转换成utf-8的内容 反序列化成字典的形式
    data_lik=head_dic['data_lik']        #在把字典的查找的值赋值给data_lik
    recv_size=0                         #设定变量并赋值为0
    recv_data=b''                      #设定变量并创建一个空字节的
    while recv_size < data_lik:       #如果变量小于字典查找出来的值时，循环为真。
        data=din.recv(1024)          #接收内容赋值给data
        recv_size+=len(data)        #把得到的内容长度加到变量recv_size中，这样就能实现如果没有取完内容就一直取得效果
        recv_data+=data           #把拿到的值加到新创建的字节中
        print(recv_data.decode('gbk'))   #打印以GBK转码的内容
din.close()   #关闭连接

 socket并发(支持多个客户端请求):

#server端
import socketserver
class MyServer(socketserver.BaseRequestHandler):#定义类方法,必须定义这个类,    通讯作用
    def handle(self):#类中必须定义一个handle方法
        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)#MyServer是上面的类名
    server.serve_forever()#通讯循环

#客户端
import socket
obj = socket.socket()
obj.connect(('127.0.0.1',9999,))
ret_bytes = obj.recv(1024)
ret_str = str(ret_bytes,encoding="utf-8")
print(ret_str)
while True:
    inp = input("Client请输入要发送的内容>>> ")
    if inp == "q":
        obj.sendall(bytes(inp,encoding="utf-8"))
        break

    else:
        obj.sendall(bytes(inp,encoding="utf-8"))
        print("正在等待Server输入内容......")
        ret = str(obj.recv(1024),encoding="utf-8")
        print(ret)
obj.close()

 基于tornado(web轻量型框架)简易聊天

基于socket,

浏览器输入127.0.0.1:8888,   返回hello world

import tornado.ioloop
import tornado.web

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write("Hello, world")

def make_app():
    return tornado.web.Application([
        (r"/", MainHandler),
    ])

if __name__ == "__main__":
    app = make_app()
    app.listen(8888)
    tornado.ioloop.IOLoop.current().start()

通过sockserver模块进行多线程式(UDP)

#UDP多并发服务端
import socketserver
ip=('127.0.0.1',8080)
class UDPserver(socketserver.BaseRequestHandler):
    def handle(self):
        print(self)
        print(self.request)  #相当于conn
        de=self.request[0]
        print(de.decode('utf-8'))
        # print(self.request[1])
        cou=input('::::')
        self.request[1].sendto(cou.encode('utf-8'),self.client_address)

if __name__ == '__main__':
    din=socketserver.ThreadingUDPServer(ip,UDPserver)
    din.serve_forever()    #链接循环



#UDP多并发客户端
import socket
din=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
ip=('127.0.0.1',8080)
while True:
    inp=input('>>')
    din.sendto(inp.encode('utf-8'),ip)
    data,addr=din.recvfrom(1024)
    print(data.decode('utf-8'))
    
din.close()

基于UDP的套接字:

# UDP服务端
import socket
din=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
ip=('127.0.0.1',8080)
din.bind(ip)
while True:
    conn,addr=din.recvfrom(1024)
    print(conn.decode('utf-8'))
    print(addr)
    din.sendto(conn.upper(),addr)


# UDP客户端
import socket
din=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
ip=('127.0.0.1',8080)
while True:
    inp=input('>>>')
    din.sendto(inp.encode('utf-8'),ip)
    data,addr=din.recvfrom(1024)
    print(data.decode('utf-8'))