关于程序员:python之socket编程

本章内容

　　1、socket

　　2、IO多路复用

　　3、socketserver

Socket

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

基本上，Socket 是任何一种计算机网络通信中最根底的内容。例如当你在浏览器地址栏中输出 http://www.cnblogs.com/ 时，你会关上一个套接字，而后连贯到 http://www.cnblogs.com/ 并读取响应的页面而后而后显示进去。而其余一些聊天客户端如 gtalk 和 skype 也是相似。任何网络通讯都是通过 Socket 来实现的。

Python 官网对于 Socket 的函数请看 http://docs.python.org/library/socket.html

socket和file的区别：

　　1、file模块是针对某个指定文件进行【关上】【读写】【敞开】

　　2、socket模块是针对 服务器端 和 客户端Socket 进行【关上】【读写】【敞开】

那咱们就先来创立一个socket服务端吧

import socketsk = socket.socket()sk.bind(("127.0.0.1",8080))sk.listen(5)conn,address = sk.accept()sk.sendall(bytes("Hello world",encoding="utf-8"))

server

import socketobj = socket.socket()obj.connect(("127.0.0.1",8080))ret = str(obj.recv(1024),encoding="utf-8")print(ret)

View Code

socket更多功能

    def bind(self, address): # real signature unknown; restored from __doc__        """        bind(address)                Bind the socket to a local address.  For IP sockets, the address is a        pair (host, port); the host must refer to the local host. For raw packet        sockets the address is a tuple (ifname, proto [,pkttype [,hatype]])        """'''将套接字绑定到本地地址。是一个IP套接字的地址对(主机、端口),主机必须参考本地主机。'''        pass    def close(self): # real signature unknown; restored from __doc__        """        close()                Close the socket.  It cannot be used after this call.        """        '''敞开socket'''        pass    def connect(self, address): # real signature unknown; restored from __doc__        """        connect(address)                Connect the socket to a remote address.  For IP sockets, the address        is a pair (host, port).        """        '''将套接字连贯到近程地址。IP套接字的地址'''        pass    def connect_ex(self, address): # real signature unknown; restored from __doc__        """        connect_ex(address) -> errno                This is like connect(address), but returns an error code (the errno value)        instead of raising an exception when an error occurs.        """        pass    def detach(self): # real signature unknown; restored from __doc__        """        detach()                Close the socket object without closing the underlying file descriptor.        The object cannot be used after this call, but the file descriptor        can be reused for other purposes.  The file descriptor is returned.        """'''敞开套接字对象没有敞开底层的文件描述符。'''        pass    def fileno(self): # real signature unknown; restored from __doc__        """        fileno() -> integer                Return the integer file descriptor of the socket.        """        '''返回整数的套接字的文件描述符。'''        return 0    def getpeername(self): # real signature unknown; restored from __doc__        """        getpeername() -> address info                Return the address of the remote endpoint.  For IP sockets, the address        info is a pair (hostaddr, port).            """        '''返回近程端点的地址。IP套接字的地址'''        pass    def getsockname(self): # real signature unknown; restored from __doc__        """        getsockname() -> address info                Return the address of the local endpoint.  For IP sockets, the address        info is a pair (hostaddr, port).        """        '''返回近程端点的地址。IP套接字的地址'''        pass    def getsockopt(self, level, option, buffersize=None): # real signature unknown; restored from __doc__        """        getsockopt(level, option[, buffersize]) -> value                Get a socket option.  See the Unix manual for level and option.        If a nonzero buffersize argument is given, the return value is a        string of that length; otherwise it is an integer.        """        '''失去一个套接字选项'''        pass    def gettimeout(self): # real signature unknown; restored from __doc__        """        gettimeout() -> timeout                Returns the timeout in seconds (float) associated with socket         operations. A timeout of None indicates that timeouts on socket         operations are disabled.        """        '''返回的超时秒数(浮动)与套接字相关联'''        return timeout    def ioctl(self, cmd, option): # real signature unknown; restored from __doc__        """        ioctl(cmd, option) -> long                Control the socket with WSAIoctl syscall. Currently supported 'cmd' values are        SIO_RCVALL:  'option' must be one of the socket.RCVALL_* constants.        SIO_KEEPALIVE_VALS:  'option' is a tuple of (onoff, timeout, interval).        """        return 0    def listen(self, backlog=None): # real signature unknown; restored from __doc__        """        listen([backlog])                Enable a server to accept connections.  If backlog is specified, it must be        at least 0 (if it is lower, it is set to 0); it specifies the number of        unaccepted connections that the system will allow before refusing new        connections. If not specified, a default reasonable value is chosen.        """        '''使服务器可能承受连贯。'''        pass    def recv(self, buffersize, flags=None): # real signature unknown; restored from __doc__        """        recv(buffersize[, flags]) -> data                Receive up to buffersize bytes from the socket.  For the optional flags        argument, see the Unix manual.  When no data is available, block until        at least one byte is available or until the remote end is closed.  When        the remote end is closed and all data is read, return the empty string.        """'''当没有数据可用,阻塞,直到至多一个字节是可用的或近程完结之前敞开。'''        pass    def recvfrom(self, buffersize, flags=None): # real signature unknown; restored from __doc__        """        recvfrom(buffersize[, flags]) -> (data, address info)                Like recv(buffersize, flags) but also return the sender's address info.        """        pass    def recvfrom_into(self, buffer, nbytes=None, flags=None): # real signature unknown; restored from __doc__        """        recvfrom_into(buffer[, nbytes[, flags]]) -> (nbytes, address info)                Like recv_into(buffer[, nbytes[, flags]]) but also return the sender's address info.        """        pass    def recv_into(self, buffer, nbytes=None, flags=None): # real signature unknown; restored from __doc__        """        recv_into(buffer, [nbytes[, flags]]) -> nbytes_read                A version of recv() that stores its data into a buffer rather than creating         a new string.  Receive up to buffersize bytes from the socket.  If buffersize         is not specified (or 0), receive up to the size available in the given buffer.                See recv() for documentation about the flags.        """        pass    def send(self, data, flags=None): # real signature unknown; restored from __doc__        """        send(data[, flags]) -> count                Send a data string to the socket.  For the optional flags        argument, see the Unix manual.  Return the number of bytes        sent; this may be less than len(data) if the network is busy.        """        '''发送一个数据字符串到套接字。'''        pass    def sendall(self, data, flags=None): # real signature unknown; restored from __doc__        """        sendall(data[, flags])                Send a data string to the socket.  For the optional flags        argument, see the Unix manual.  This calls send() repeatedly        until all data is sent.  If an error occurs, it's impossible        to tell how much data has been sent.        """        '''发送一个数据字符串到套接字，直到所有数据发送实现'''        pass    def sendto(self, data, flags=None, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__         """        sendto(data[, flags], address) -> count                Like send(data, flags) but allows specifying the destination address.        For IP sockets, the address is a pair (hostaddr, port).        """        pass    def setblocking(self, flag): # real signature unknown; restored from __doc__        """        setblocking(flag)                Set the socket to blocking (flag is true) or non-blocking (false).        setblocking(True) is equivalent to settimeout(None);        setblocking(False) is equivalent to settimeout(0.0).        """'''是否阻塞（默认True），如果设置False，那么accept和recv时一旦无数据，则报错。'''        pass    def setsockopt(self, level, option, value): # real signature unknown; restored from __doc__        """        setsockopt(level, option, value)                Set a socket option.  See the Unix manual for level and option.        The value argument can either be an integer or a string.        """        pass    def settimeout(self, timeout): # real signature unknown; restored from __doc__        """        settimeout(timeout)                Set a timeout on socket operations.  'timeout' can be a float,        giving in seconds, or None.  Setting a timeout of None disables        the timeout feature and is equivalent to setblocking(1).        Setting a timeout of zero is the same as setblocking(0).        """        pass    def share(self, process_id): # real signature unknown; restored from __doc__        """        share(process_id) -> bytes                Share the socket with another process.  The target process id        must be provided and the resulting bytes object passed to the target        process.  There the shared socket can be instantiated by calling        socket.fromshare().        """        return b""    def shutdown(self, flag): # real signature unknown; restored from __doc__        """        shutdown(flag)                Shut down the reading side of the socket (flag == SHUT_RD), the writing side        of the socket (flag == SHUT_WR), or both ends (flag == SHUT_RDWR).        """        pass    def _accept(self): # real signature unknown; restored from __doc__        """        _accept() -> (integer, address info)                Wait for an incoming connection.  Return a new socket file descriptor        representing the connection, and the address of the client.        For IP sockets, the address info is a pair (hostaddr, port).        """        pass    

更多功能

注：撸主晓得大家懒，所以把全副性能的中文标记在每个性能的上面啦。上面撸主列一些常常用到的吧

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()

　　套接字的文件描述符

TCP：

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",8080),Myserver)    server.serve_forever()客户端import socketobj = socket.socket()obj.connect(("127.0.0.1",8080))ret_bytes = obj.recv(1024)ret_str = str(ret_bytes,encoding="utf-8")print(ret_str)while True:    inp = input("你好请问您有什么问题？ \n >>>")    if inp == "q":        obj.sendall(bytes(inp,encoding="utf-8"))        break    else:        obj.sendall(bytes(inp, encoding="utf-8"))        ret_bytes = obj.recv(1024)        ret_str = str(ret_bytes,encoding="utf-8")        print(ret_str)

案例一 机器人聊天

服务端import socketsk = socket.socket()sk.bind(("127.0.0.1",8080))sk.listen(5)while True:    conn,address = sk.accept()    conn.sendall(bytes("欢迎光临我爱我家",encoding="utf-8"))    size = conn.recv(1024)    size_str = str(size,encoding="utf-8")    file_size = int(size_str)    conn.sendall(bytes("开始传送", encoding="utf-8"))    has_size = 0    f = open("db_new.jpg","wb")    while True:        if file_size == has_size:            break        date = conn.recv(1024)        f.write(date)        has_size += len(date)    f.close()客户端import socketimport osobj = socket.socket()obj.connect(("127.0.0.1",8080))ret_bytes = obj.recv(1024)ret_str = str(ret_bytes,encoding="utf-8")print(ret_str)size = os.stat("yan.jpg").st_sizeobj.sendall(bytes(str(size),encoding="utf-8"))obj.recv(1024)with open("yan.jpg","rb") as f:    for line in f:        obj.sendall(line)

案例二 上传文件

UdP

import socketip_port = ('127.0.0.1',9999)sk = socket.socket(socket.AF_INET,socket.SOCK_DGRAM,0)sk.bind(ip_port)while True:    data = sk.recv(1024)    print dataimport socketip_port = ('127.0.0.1',9999)sk = socket.socket(socket.AF_INET,socket.SOCK_DGRAM,0)while True:    inp = input('数据：').strip()    if inp == 'exit':        break    sk.sendto(bytes(inp,encoding = "utf-8"),ip_port)sk.close()

udp传输

WEB服务利用：