46. Python Socket编程

发布时间：2019-07-15 11:00:30编辑：auto阅读（1543）

复习：消息队列

为了防止消息丢失，或者是调用方，不需一直等待响应方的结果。

# threadtest.py

import codecs
from queue import Queue
from threading import Thread

import time


class Produce(Thread):
    def __init__(self, queue):
        super(Produce, self).__init__()
        self.fileName = "../firstlession/passwd"
        self.fileList = list()
        self.queue = queue
    def run(self):
        with codecs.open(self.fileName) as f:
            self.fileList += f.readlines()
        for line in self.fileList:
            self.queue.put(line)

class Consumer(Thread):
    def __init__(self, queue):
        self.queue = queue
        super(Consumer, self).__init__()
        self.newPasswd = "newpasswd.txt"
        self.fileList = list()
        self.stat = 1
    def run(self):
        while 1:
            if self.queue.empty():
                time.sleep(2)
                self.stat += 1
                if self.stat == 5:
                    break
            else:
                self.stat = 1
                data = self.queue.get()
                self.fileList.append(data)

        with codecs.open(self.newPasswd, 'w') as f:
            f.writelines(self.fileList)




调用

# thread1.py

from queue import Queue
from onlive.secondlesson.threadtest import Produce, Consumer

def main():
    q = Queue()
    produce = Produce(q)
    consumer = Consumer(q)
    produce.start()
    consumer.start()

if __name__ == '__main__':
    main()




socket 简介

TCP的可靠性实现：

（1）校验码

（2）接收方反馈

（3）信息包附带序号




UDP：

（1）快 不需要花费时间建立和关闭连接

（2）快 偶尔丢失一两个消息包无所谓，但是TCP会严格检查

（3）快 UDP的限制是一个信息包不超过64KB的数据




TCP和UDP区别：

UDP不建立连接，只保证数据的完整性，数据传输快，但是不保证数据是否真的被收到，也不保证数据是否只接收一次，也不保证次序。

TCP则相反。

服务端是用来给一个或多个客户端提供服务的，当客户端发起请求，开始等待服务端的返回结果，服务端接受完请求以后，根据自己的逻辑处理请求，并返回给客户端，客户端接收到返回结果以后，关闭和服务端的连接。

[备注]：只要是发送数据的就是"写"，只要是接收数据的就是"读"。

最常用的客户端和服务端有两种模式：C/S模式（mysql） 和   B/S模式（百度、京东、淘宝网站等）




socket流程：

（1）服务端创建完一个socket以后

（2）需要绑定一个IP:PORT

（3）对其进行监听（listen）-->【监听的方法内需要带一个数字，这个数字表示同时有多少个客户端可以来访问服务端】

（4）然后接收请求（accept）--> 【客户端每创建一个连接，调用 "connect函数" 后，服务端就需要生成一个新的socket连接和客户端进行传输，传输完成后关闭客户端连接、关闭服务端；服务端永远要比客户端多一个socket连接，如果说客户端是n个socket连接，那么服务端就要创建n+1个socket连接，因为刚开始启动服务端的时候，服务端就要创建一个socket连接，每当从客户端过来一个连接，服务端就要创建一个socket连接跟客户端进行交互，所以服务端比客户端多一个连接。】






socket常用函数讲解：

创建套接字：

s = socket.socket(address family, socket type)




address family:

socket.AF_INET 默认ipv4

socket.AF_INET6 ipv6

socket.AF_UNIX 只用于单一unix系统间进行通信

socket type:

socket.SOCK_STREAM 流式socket TCP

socket.SOCK_DGRAM 数据报式socket UDP




TCP 方式 socket：

（1）创建socket：

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

（2）绑定地址：

address = ('0.0.0.0', 8009)

s.bind(address) 或者 s.bind((0.0.0.0, 8009)) 两种方式相同；

【注意：address 必须是一个元组，容易错误，address = (host, port)】

【host：服务端ip，字符串类型，如果为0.0.0.0，代表本机的任意一个IP】

【port：服务端提供的端口，×××，0-1024为系统保留（不选这里面的端口）】

（3）监听消息：

s.listen(badklog)

backlog 代表可以同时接受多少个socket连接

（4）接受连接：

conn, addr = s.accept()

接受连接并返回元组(conn,addr)，其中conn是新的套接字对象，每个新的连接就创建一个新的对象。可以用来接受和发送数据，addr是客户端的地址：包含host和port。

（5）发送数据：

s.send(string) 发送字符串到连接的套接字，可能未将指定内容全部发送；

s.sendall(string) 内部递归调用send，将所有内容发送出去，建议使用。

（6）接收数据：

data = s.recv(bufsize)

接收套接字数据，数据以字符串形式返回，bufsize指定最多接收的数据量，可以使用1024， 2048

如果不知道接收的数量有多少，可以能几个字节，可能几兆，一般通过循环接收。




UDP 方式 socket：

s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

s.sendto(string)

data, address = s.recvfrom(bufsize)




客户端：

客户端首先也要创建socket套接字

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)




客户端连接服务端函数：

s.connect(address) #连接到address的套接字

result - connect_ex(address) #成功返回0，失败返回错误码




通用：

s.close() #关闭套接字

s.getsocketname()   #获取套接字的名字

s.settimeout(timeout) #设置套接字超时时间，timeout为float类型，单位秒

s.gettimeout() #获得套接字超时时间

s.setblocking(flag) #flage为bool值

setblocking(True) is equivalent to settimeout(None); #不设置超时时间，一直阻塞在那里

setblocking(False) is equivalent to settimeout(0.0); #设置超时时间为0，如果设置False，accept和recv一旦无数据，则报错。

s.fileno() # 返回套接字的文件描述符（一个小整数）。这对于select.select()是有用的。




socket例子：




写socket工具：

# util.py

import socket
import time


class InitSocketTest(object):
    def __init__(self, host, port, type):
        self.host = host
        self.port = port
        self.address = (host, port)
        self.type = type
        self.s = None
        self.creatsocket()

    def creatsocket(self):
        if self.type.upper() == "TCP":
            self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        elif self.type.upper == "UDP":
            self.s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        else:
            print("you must input the InitSocket(type) is 'UDP|TCP' ")

class SocketServerTest(InitSocketTest):
    def __init__(self, host, port, type,  backlog):
        self.backlog = backlog
        super(SocketServerTest, self).__init__(host, port, type)
        self.clientAddress = None

    def run(self):
        self.s.bind(self.address)
        self.s.listen(self.backlog)
        print("server starting…………")
        conn, self.clientAddress = self.s.accept()
        print("accept connect from {0}".format(self.clientAddress))
        for i in range(1, 10):
            conn.sendall("i = {0}".format(str(i)).encode("utf-8"))
        self.s.close()

class ClientSocketTest(InitSocketTest):
    def run(self):
        self.s.connect(self.address)
        stat = 1
        while 1:
            data = self.s.recv(2048)
            if len(data)>0:
                stat = 1
                print(data.decode("utf-8"))
            else:
                stat += 1
                time.sleep(1)
                if stat == 5:
                    break




# testserver.py

from onlive.sockettest.util import SocketServerTest    
if __name__ == '__main__':    
    socketServer = SocketServerTest(host="0.0.0.0", port=9999, type="tcp", backlog=5)    
    socketServer.run()




# testclient.py

from onlive.sockettest.util import ClientSocketTest    
if __name__ == '__main__':    
    socketClient = ClientSocketTest(host="127.0.0.1", port=9999, type="tcp")    
    socketClient.run()

关键字：