Python开发Day8（socket）

Posted 2020-07-26

Socket

• socket介绍：

  • socket通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄，应用程序通常通过"套接字"向网络发出请求或者应答网络请求。

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

  • socket和file的区别：

    • file模块是针对某个指定文件进行【打开】【读写】【关闭】

    • socket模块是针对 服务器端 和 客户端Socket 进行【打开】【读写】【关闭】

1. • • 

• socket使用：

  • socket方法：

    • 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()
      
      　　套接字的文件描述符

  • 在客户端向服务器发送任何东西后，服务端给客户端返回用户输入的内容并且加上NoNoNo!!!

    • server端代码:

      

      #!/usr/bin/python
      # -*- coding: utf-8 -*-
      __author__ = ‘WuYongQi‘
      import socket,os
      sk = socket.socket()#创建一个socket对象名为obj
      sk.bind((‘127.0.0.1‘,8080))#创建socket的ip和端口
      sk.listen(5)#监听连接数，连接数为5的时候会让后面的客户端等待，5以后链接的直接断开
      while True:
          conn,ipaddr = sk.accept()#接收客户端的请求，等待客户端来连接，如果有客户端来连接会获取两个值conn(链接)和address(客户端的地址信息)。（在这里会阻塞）
          conn.sendall(bytes(‘hello!‘,encoding=‘utf-8‘))#返回hello的bytes
          print(ipaddr,conn)#输出连接，和客户端链接信息
          while True:
              try:
                  ret_bytes = conn.recv(1024)
                  ret_str = str(ret_bytes,encoding=‘utf-8‘)
                  if ret_str == ‘q‘:
                      print(‘等待其他用户连接‘)
                      break
                  conn.sendall(bytes(ret_str+‘NoNoNo!!!‘,encoding=‘utf-8‘))
              except Exception:
                  print(‘报错了~‘)

      View Code

       

    • cilent代码:

      

      #!/usr/bin/python
      # -*- coding: utf-8 -*-
      __author__ = ‘WuYongQi‘
      import socket
      obj = socket.socket()#创建一个socket对象名为obj
      obj.connect((‘127.0.0.1‘,8080))#创建socket的ip和端口
      ret_bytes = obj.recv(1024)#最多接收1024字节，（阻塞的，等待服务端发消息）
      ret_str = str(ret_bytes,encoding=‘utf-8‘)
      print(ret_str)
      while True:
          inp = input(‘>>>>>>‘)
          if inp == ‘q‘:
              obj.sendall(bytes(inp,encoding=‘utf-8‘))
              break
          else:
              obj.sendall(bytes(inp,encoding=‘utf-8‘))
              ret = str(obj.recv(1024),encoding=‘utf-8‘)#最多接收1024字节，（阻塞的，等待服务端发消息）
              print(ret)
      obj.close()

      View Code

       

  • 使用socket完成断电续传功能：

    • server端:

      

      import socket
      sk = socket.socket()
      sk.bind((‘127.0.0.1‘,8080))#创建socket的ip和端口
      sk.listen(5)#监听连接数，连接数为5的时候会让后面的客户端等待，5以后链接的直接断开
      while True:
          conn,ipaddr = sk.accept()#接收客户端的请求，等待客户端来连接，如果有客户端来连接会获取两个值conn(链接)和address(客户端的地址信息)。（在这里会阻塞）
          conn.sendall(bytes(‘hello!‘,encoding=‘utf-8‘))#返回hello的bytes
          #print(ipaddr,conn)#输出连接，和客户端链接信息
          file_size = int(str(conn.recv(1024),encoding=‘utf-8‘))
          conn.sendall(bytes(‘OK‘,encoding=‘utf-8‘))
          f = open(‘new.8.jpg‘,‘wb‘)
          while True:
              print(‘文件剩余大小为:%d‘%file_size)
              if file_size == 0:
                  break
              data = conn.recv(1024)
              f.write(data)
              file_size -= len(data)
          f.close()

      View Code

    • client端:

      

      #!/usr/bin/python
      # -*- coding: utf-8 -*-
      __author__ = ‘WuYongQi‘
      import socket,os,tornado
      tornado.version
      obj = socket.socket()#创建一个socket对象名为obj
      obj.connect((‘127.0.0.1‘,8080))#创建socket的ip和端口
      ret_bytes = obj.recv(1024)#最多接收1024字节，（阻塞的，等待服务端发消息）
      print(str(ret_bytes,encoding=‘utf-8‘))
      file_size = os.stat(‘8.jpg‘).st_size
      obj.sendall(bytes(str(file_size),encoding=‘utf-8‘))
      data = obj.recv(1024)
      if str(data,encoding=‘utf-8‘) == ‘OK‘:
          f = open(‘8.jpg‘,‘rb‘)
          for i in f:
              obj.sendall(i)
          obj.close()
      obj.close()

      View Code

 

IO多路复用： 

• 介绍：

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

• 使用：

  • Python中有一个select模块，其中提供了：select、poll、epoll三个方法，分别调用系统的 select，poll，epoll 从而实现IO多路复用。

    Windows Python：
        提供： select
    Mac Python：
        提供： select
    Linux Python：
        提供： select、poll、epoll

  • 使用方法:

    句柄列表11, 句柄列表22, 句柄列表33 = select.select(句柄序列1, 句柄序列2, 句柄序列3, 超时时间)
     
    参数： 可接受四个参数（前三个必须）
    返回值：三个列表
     
    select方法用来监视文件句柄，如果句柄发生变化，则获取该句柄。
    1、当 参数1 序列中的句柄发生可读时（accetp和read），则获取发生变化的句柄并添加到 返回值1 序列中
    2、当 参数2 序列中含有句柄时，则将该序列中所有的句柄添加到 返回值2 序列中
    3、当 参数3 序列中的句柄发生错误时，则将该发生错误的句柄添加到 返回值3 序列中
    4、当 超时时间 未设置，则select会一直阻塞，直到监听的句柄发生变化
       当 超时时间 ＝ 1时，那么如果监听的句柄均无任何变化，则select会阻塞 1 秒，之后返回三个空列表，如果监听的句柄有变化，则直接执行。

    • 利用select实现伪同步处理多个Socket客户请求：服务端

      

      #!/usr/bin/env python
      # -*- coding:utf-8 -*-
      
      import socket
      import select
      
      sk1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
      sk1.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
      sk1.bind((‘127.0.0.1‘,8002))
      sk1.listen(5)
      sk1.setblocking(0)
      
      inputs = [sk1,]
      
      while True:
          readable_list, writeable_list, error_list = select.select(inputs, [], inputs, 1)
          for r in readable_list:
              # 当客户端第一次连接服务端时
              if sk1 == r:
                  print ‘accept‘
                  request, address = r.accept()
                  request.setblocking(0)
                  inputs.append(request)
              # 当客户端连接上服务端之后，再次发送数据时
              else:
                  received = r.recv(1024)
                  # 当正常接收客户端发送的数据时
                  if received:
                      print ‘received data:‘, received
                  # 当客户端关闭程序时
                  else:
                      inputs.remove(r)
      
      sk1.close()

      View Code

    • 利用select实现伪同步处理多个Socket客户请求：客户端

      

      #!/usr/bin/env python
      # -*- coding:utf-8 -*-
      import socket
      
      ip_port = (‘127.0.0.1‘,8002)
      sk = socket.socket()
      sk.connect(ip_port)
      
      while True:
          inp = raw_input(‘please input:‘)
          sk.sendall(inp)
      sk.close()

      View Code

  • 基于select实现socket服务端：

    

    #!/usr/bin/env python
    #coding:utf8
    
    ‘‘‘
     服务器的实现 采用select的方式
    ‘‘‘
    
    import select
    import socket
    import sys
    import Queue
    
    #创建套接字并设置该套接字为非阻塞模式
    
    server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    server.setblocking(0)
    
    #绑定套接字
    server_address = (‘localhost‘,10000)
    print >>sys.stderr,‘starting up on %s port %s‘% server_address
    server.bind(server_address)
    
    #将该socket变成服务模式
    #backlog等于5，表示内核已经接到了连接请求，但服务器还没有调用accept进行处理的连接个数最大为5
    #这个值不能无限大，因为要在内核中维护连接队列
    
    server.listen(5)
    
    #初始化读取数据的监听列表,最开始时希望从server这个套接字上读取数据
    inputs = [server]
    
    #初始化写入数据的监听列表，最开始并没有客户端连接进来，所以列表为空
    
    outputs = []
    
    #要发往客户端的数据
    message_queues = {}
    while inputs:
        print >>sys.stderr,‘waiting for the next event‘
        #调用select监听所有监听列表中的套接字，并将准备好的套接字加入到对应的列表中
        readable,writable,exceptional = select.select(inputs,outputs,inputs)#列表中的socket 套接字  如果是文件呢？ 
        #监控文件句柄有某一处发生了变化 可写 可读  异常属于Linux中的网络编程 
        #属于同步I/O操作，属于I/O复用模型的一种
        #rlist--等待到准备好读
        #wlist--等待到准备好写
        #xlist--等待到一种异常
        #处理可读取的套接字
    
        ‘‘‘
            如果server这个套接字可读，则说明有新链接到来
            此时在server套接字上调用accept,生成一个与客户端通讯的套接字
            并将与客户端通讯的套接字加入inputs列表，下一次可以通过select检查连接是否可读
            然后在发往客户端的缓冲中加入一项，键名为:与客户端通讯的套接字，键值为空队列
            select系统调用是用来让我们的程序监视多个文件句柄(file descrīptor)的状态变化的。程序会停在select这里等待，
            直到被监视的文件句柄有某一个或多个发生了状态改变
            ‘‘‘
    
        ‘‘‘
            若可读的套接字不是server套接字,有两种情况:一种是有数据到来，另一种是链接断开
            如果有数据到来,先接收数据,然后将收到的数据填入往客户端的缓存区中的对应位置，最后
            将于客户端通讯的套接字加入到写数据的监听列表:
            如果套接字可读.但没有接收到数据，则说明客户端已经断开。这时需要关闭与客户端连接的套接字
            进行资源清理
            ‘‘‘
            
        for s in readable: 
            if s is server:
                connection,client_address = s.accept()
                print >>sys.stderr,‘connection from‘,client_address
                connection.setblocking(0)#设置非阻塞
                inputs.append(connection)
                message_queues[connection] = Queue.Queue()
            else:
                data = s.recv(1024)
                if data:
                    print >>sys.stderr,‘received "%s" from %s‘%                 (data,s.getpeername())
                    message_queues[s].put(data)
                    if s not in outputs:
                        outputs.append(s)
                else:
                    print >>sys.stderr,‘closing‘,client_address
                    if s in outputs:
                        outputs.remove(s)
                    inputs.remove(s)
                    s.close()
                    del message_queues[s]
                        
        #处理可写的套接字
        ‘‘‘
            在发送缓冲区中取出响应的数据，发往客户端。
            如果没有数据需要写，则将套接字从发送队列中移除，select中不再监视
            ‘‘‘
    
        for s in writable:
            try:
                next_msg = message_queues[s].get_nowait()
    
            except Queue.Empty:
                print >>sys.stderr,‘  ‘,s,getpeername(),‘queue empty‘
                outputs.remove(s)
            else:
                print >>sys.stderr,‘sending "%s" to %s‘%             (next_msg,s.getpeername())
                s.send(next_msg)
    
    
    
        #处理异常情况
    
        for s in exceptional:
            for s in exceptional:
                print >>sys.stderr,‘exception condition on‘,s.getpeername()
                inputs.remove(s)
                if s in outputs:
                    outputs.remove(s)
                s.close()
                del message_queues[s]
    
    基于select实现socket服务端

    View Code

 

socketserver

• 介绍：

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

• 使用：

  • ThreadingTCPServer
    

    • ThreadingTCPServer实现的Soket服务器内部会为每个client创建一个 “线程”，该线程用来和客户端进行交互。

    • 使用ThreadingTCPServer基础：
      • 创建一个继承自 SocketServer.BaseRequestHandler 的类
      • 类中必须定义一个名称为 handle 的方法
      • 启动ThreadingTCPServer

  • socketserver实现服务器端代码：

    

    #!/usr/bin/env python
    # -*- coding:utf-8 -*-
    import SocketServer
    
    class MyServer(SocketServer.BaseRequestHandler):
    
        def handle(self):
            # print self.request,self.client_address,self.server
            conn = self.request
            conn.sendall(‘欢迎致电 ******，请输入1xxx,0转人工服务.‘)
            Flag = True
            while Flag:
                data = conn.recv(1024)
                if data == ‘exit‘:
                    Flag = False
                elif data == ‘0‘:
                    conn.sendall(‘123456789‘)
                else:
                    conn.sendall(‘请重新输入.‘)
    
    
    if __name__ == ‘__main__‘:
        server = SocketServer.ThreadingTCPServer((‘127.0.0.1‘,8009),MyServer)
        server.serve_forever()
    
    SocketServer实现服务器

    View Code

  • 客户端代码：

    

    #!/usr/bin/env python
    # -*- coding:utf-8 -*-
    
    import socket
    
    
    ip_port = (‘127.0.0.1‘,8009)
    sk = socket.socket()
    sk.connect(ip_port)
    sk.settimeout(5)
    
    while True:
        data = sk.recv(1024)
        print ‘receive:‘,data
        inp = raw_input(‘please input:‘)
        sk.sendall(inp)
        if inp == ‘exit‘:
            break
    
    sk.close()

    View Code

 

 

使用Socket实现FTP：下一章出现！！