python socket学习

在2.几版本中可以bytes或者str都可以，在3.几中要用bytes轉換

什么是 Socket?
Socket又称"套接字"，应用程序通常通过"套接字"向网络发出请求或者应答网络请求，使主机间或者一台计算机上的进程间可以通讯。
網絡通信的要素：地址、端口、協議
socket對象內建方法
服务器端套接字
s.bind() 	绑定地址（host,port）到套接字， 在AF_INET下,以元组（host,port）的形式表示地址。
s.listen() 	开始TCP监听。backlog指定在拒绝连接之前，操作系统可以挂起的最大连接数量。该值至少为1，大部分应用程序设为5就可以了。
s.accept() 	被动接受TCP客户端连接,(阻塞式)等待连接的到来
客户端套接字
s.connect() 	主动初始化TCP服务器连接，。一般address的格式为元组（hostname,port），如果连接出错，返回socket.error错误。
s.connect_ex() 	connect()函数的扩展版本,出错时返回出错码,而不是抛出异常
公共用途的套接字函数
s.recv() 	接收TCP数据，数据以字符串形式返回，bufsize指定要接收的最大数据量。flag提供有关消息的其他信息，通常可以忽略。
s.send() 	发送TCP数据，将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。
s.sendall() 	完整发送TCP数据，完整发送TCP数据。将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。
s.recvfrom() 	接收UDP数据，与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。
s.sendto() 	发送UDP数据，将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。
s.close() 	关闭套接字
s.getpeername() 	返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。
s.getsockname() 	返回套接字自己的地址。通常是一个元组(ipaddr,port)
s.setsockopt(level,optname,value) 	设置给定套接字选项的值。
s.getsockopt(level,optname[.buflen]) 	返回套接字选项的值。
s.settimeout(timeout) 	设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如connect()）
s.gettimeout() 	返回当前超时期的值，单位是秒，如果没有设置超时期，则返回None。
s.fileno() 	返回套接字的文件描述符。
s.setblocking(flag) 	如果flag为0，则将套接字设为非阻塞模式，否则将套接字设为阻塞模式（默认值）。非阻塞模式下，如果调用recv()没有发现任何数据，或send()调用无法立即发送数据，那么将引起socket.error异常。
s.makefile() 	创建一个与该套接字相关连的文件

以下列出了 Python 网络编程的一些重要模块：
协议	功能用处	                        端口号	 Python 模块
HTTP	网页访问	                        80	     httplib, urllib, xmlrpclib
NNTP	阅读和张贴新闻文章，俗称为"帖子"	119	     nntplib
FTP	    文件传输	                        20	     ftplib, urllib
SMTP	发送邮件	                        25	     smtplib
POP3	接收邮件	                        110	     poplib
IMAP4	获取邮件	                        143	     imaplib
Telnet	命令行	                            23	     telnetlib
Gopher	信息查找	                        70	     gopherlib, urllib

import socket  # 导入 socket 模块

s = socket.socket()  # 创建 socket 对象
host = ('127.0.0.1')
# host = socket.gethostname('127.0.0.1')  # 获取本地主机名
port = 12345  # 设置端口
s.bind((host, port))  # 绑定端口

s.listen(5)  # 等待客户端连接
while True:
    c, addr = s.accept()  # 建立客户端连接
    print
    '连接地址：', addr
    c.send('欢迎访问菜鸟教程！')
    c.close()  # 关闭连接

#*************************************************

import socket
# 建立一个服务端
server = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #SOCK_STREAM默認代表TCP協議
server.bind(('localhost',6999)) #绑定要监听的端口
server.listen(5) #开始监听 表示可以使用五个链接排队
while True:# conn就是客户端链接过来而在服务端为期生成的一个链接实例
    conn,addr = server.accept() #等待链接,多个链接的时候就会出现问题,其实返回了两个值
    print(conn,addr)
    while True:
        try:
            data = conn.recv(1024)  #接收数据
            print('recive:',data.decode()) #打印接收到的数据
            conn.send(data.upper()) #然后再发送数据
        except ConnectionResetError as e:
            print('关闭了正在占线的链接！')
            break
    conn.close()


#*****************************************

import socket
server = socket.socket()
address = ('127.0.0.1', 1080)
server.connect(address)
server.listen(5)
while True:
    conn, addr = server.accept()
    print(addr)
    while True:
        data = conn.recv(1024)
        print(str(data, 'utf8'))
        if not data:
            break
        inp = input(">>>")
        conn.send(bytes(inp, 'utf8'))

servrt.close()

大型文件上傳

服务端

import socket

sk = 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 socket
import os

obj = 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_size
obj.sendall(bytes(str(size), encoding="utf-8"))

obj.recv(1024)

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

#**************************************************

粘包現象

产生原因：
1、接收端不知道消息的界限，不知道一次提取多少字节数据
2、TCP为提高传输效率，发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少，
通常TCP会根据优化算法(Nagle算法)把这些数据合成一个TCP段后一次发送出去，这样接收方就收到了粘包数据
产生粘包场景：(1)发送端需要等缓冲区满才发送出去，造成粘包（发送数据时间间隔很短，数据了很小，会合到一起，产生粘包）
(2)接收方不及时接收缓冲区的包，造成多个包接收（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收的时候还是从
缓冲区拿上次遗留的数据，产生粘包）
3 、解决方案
1.为字节流加上自定义固定长度报头，报头中包含字节流长度，然后一次send到对端，对端在接收时，先从缓存中取出定长的报头，
然后再取真实数据

2.可以在兩個send之間加一個隔斷conn.recv(1024)
3.加延時來解決這比較low方法

struct 模块
注：struct 模块 把一个数字类型转化为固定长度的bytes
（struct.pack）打包
（struct.unpack）解包
res=(struct.pack('i',4855524))   #b'x04xe6xe4x02' 打包
print(res)
print(struct .unpack('i',res)[0]) #解包

#服務端
import subprocess
import socket
import struct
import json
phone= socket.socket(socket.AF_INET ,socket.SOCK_STREAM )
phone.bind(('127.0.0.1',8080))
phone.listen(5)
while True :
    conn,client=phone.accept()
    while True :
        try:
            cmd = conn.recv(1024)
            if len(cmd) == 0: break
            # 远程执行命令
            obj = subprocess.Popen(cmd.decode('utf-8'), shell=True,  # 解码
                stdout=subprocess.PIPE,  # 正确信息
                stderr=subprocess.PIPE  # 错误信息
                )
            stdout = obj.stdout.read()
            stderr = obj.stderr.read()
            #先制作报头
            head_dic= {'filename':'a.txt',
             'total_size':len(stdout)+len(stderr),
             'hash':'asdf165485221'
             }
            head_json = json.dumps(head_dic)
            head_bytes= head_json.encode('utf-8')
            #1、先把报头的长度打包成四个bytes,然后发送
            conn.send(struct.pack('i',len(head_bytes)))

            #2、发送报头
            conn.send(head_bytes)
            #3、发送真实数据
            conn.send(stdout )
            conn.send(stderr)
        except ConnectionResetError:
            break
        conn.close()
    phone.close()


#客戶端
import struct
import socket
import json
phone= socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone. connect(('127.0.0.1',8080))
while True :
    msg = input('<<<').strip()
    if msg == 0:continue
    #phone.send(msg.encode('utf-8'))
    phone.send(bytes(msg,encoding='utf-8'))
    #1、先收4个字节，该4个字节包含报头的长度  解包
    header_len=struct .unpack('i',phone.recv(4))[0]
    #2、通过报头长度，再接受报头内容
    header_bytes=phone.recv(header_len) #通过报头长度，拿到bytes内容
    #从报头中解析出想要的内容
    header_json=header_bytes .decode('utf-8')  #报头内容解码得到字符串类型
    header_dic=json .loads(header_json)  #反序列化得到字典
    print(header_dic)
    total_size = header_dic['total_size']
    #3、再收真实的数据
    recv_size =0    #初始值长度
    res=b''  #接收的具体值
    while  recv_size< total_size:
        data= phone.recv(1024)
        res+=data  # 拼接具体的值
        recv_size += len(data)  #累加长度
    print(res.decode('gbk'))   #收到的信息用GBK解码
phone.close()

#**************************************************

 读取文件名
检测文件是否存在
打开文件
检测文件大小
发送文件大小和MD5值给客户端
等客户端确认
开始边读边发数据
MD5验证

# 客户端

import socket
import os
import hashlib

client = socket.socket()  # 生成socket连接对象

ip_port =("localhost", 6969)  # 地址和端口号

client.connect(ip_port)  # 连接

print("服务器已连接")

while True:
    content = input(">>")

    if len(content)==0: continue  # 如果传入空字符会阻塞

    if content.startswith("get"):
        client.send(content.encode("utf-8"))  # 传送和接收都是bytes类型

        # 1.先接收长度，建议8192
        server_response = client.recv(1024)
        file_size = int(server_response.decode("utf-8"))

        print("接收到的大小：", file_size)

        # 2.接收文件内容
        client.send("准备好接收".encode("utf-8"))  # 接收确认
        filename = "new" + content.split(" ")[1]

        f = open(filename, "wb")
        received_size = 0
        m = hashlib.md5()

        while received_size < file_size:
            size = 0  # 准确接收数据大小，解决粘包
            if file_size - received_size > 1024: # 多次接收
                size = 1024
            else:  # 最后一次接收完毕
                size = file_size - received_size

            data = client.recv(size)  # 多次接收内容，接收大数据
            data_len = len(data)
            received_size += data_len
            print("已接收：", int(received_size/file_size*100), "%")

            m.update(data)
            f.write(data)

        f.close()

        print("实际接收的大小:", received_size)  # 解码

        # 3.md5值校验
        md5_sever = client.recv(1024).decode("utf-8")
        md5_client = m.hexdigest()
        print("服务器发来的md5:", md5_sever)
        print("接收文件的md5:", md5_client)
        if md5_sever == md5_client:
            print("MD5值校验成功")
        else:
            print("MD5值校验失败")

client.close()


# 服务器端

import socket
import os
import hashlib

server = socket.socket()

server.bind(("localhost", 6969)) # 绑定监听端口

server.listen(5)  # 监听

print("监听开始..")

while True:
    conn, addr = server.accept()  # 等待连接

    print("conn:", conn, "
addr:", addr)  # conn连接实例

    while True:
        data = conn.recv(1024)  # 接收
        if not data:  # 客户端已断开
            print("客户端断开连接")
            break

        print("收到的命令：", data.decode("utf-8"))
        cmd, filename = data.decode("utf-8").split(" ")
        if cmd =="get":
            if os.path.isfile(filename):  # 判断文件存在

                # 1.先发送文件大小，让客户端准备接收
                size = os.stat(filename).st_size  #获取文件大小
                conn.send(str(size).encode("utf-8"))  # 发送数据长度
                print("发送的大小：", size)

                # 2.发送文件内容
                conn.recv(1024)  # 接收确认

                m = hashlib.md5()
                f = open(filename, "rb")
                for line in f:
                    conn.send(line)  # 发送数据
                    m.update(line)
                f.close()

                # 3.发送md5值进行校验
                md5 = m.hexdigest()
                conn.send(md5.encode("utf-8"))  # 发送md5值
                print("md5:", md5)


server.close()


#**********************************************

 SocketServer简化了网络服务器的编写。在进行socket创建时，使用SocketServer会大大减少创建的步骤，
并且SocketServer使用了select它有5个类：
BaseServer，
TCPServer，负责处理TCP协议
UDPServer，负责处理UDP协议
UnixStreamServer，只适用于类unix平台，不常用
UnixDatagramServer。只适用于类unix平台，不常用
后4个类是同步进行处理的，另外通过ForkingMixIn和ThreadingMixIn类来支持异步。


创建socketserver步骤:
1必须先创建一个请求处理的类，并且这个类要继承BaseRequestHandle,并重写父类中的handle方法
2实例化一个server class,并且传递server ip 和刚创建的请求处理类给server class
3调用server class 对象的 handle_request() 或 server_forever()方法来开始处理请求
4关闭请求
server.handle_request() 只处理一个请求
server.forever() 处理多个请求，一直执行

#创建TCP类型的SocketServer：
import SocketServer
class MyTCPHandler(SocketServer.BaseRequestHandler): #定义request handler类，从BaseRequestHandler类继承

    def handle(self): #复写handle()方法，注意：该方法必须复写，用于处理当前的request
        self.data = self.request.recv(1024).strip() #self.request是和客户端连接的套接字，可直接使用
        print "{} wrote:".format(self.client_address[0])
        print self.data
        self.request.sendall(self.data.upper())

class MyTCPHandler(SocketServer.StreamRequestHandler): #定义request handler类，从StreamRequestHandler类继承

    def handle(self):
        self.data = self.rfile.readline().strip() #self.rfile/self.wfile是文件格式类型的socket，相当于对原始socket的封装，让读写网络数据向读写文件一样容易
        print "{} wrote:".format(self.client_address[0])
        print self.data
        self.wfile.write(self.data.upper())

if __name__ == "__main__":
    HOST, PORT = "localhost", 9999
    server = SocketServer.TCPServer((HOST, PORT), MyTCPHandler) #传入监听地址、端口号和request handler类
    server.serve_forever() #启动监听处理request





#创建UDP类型的SocketServer：
import SocketServer

class MyUDPHandler(SocketServer.BaseRequestHandler):
    def handle(self):
        data = self.request[0].strip()
        socket = self.request[1]
        print "{} wrote:".format(self.client_address[0])
        print data
        socket.sendto(data.upper(), self.client_address)
if __name__ == "__main__":
    HOST, PORT = "localhost", 9999
    server = SocketServer.UDPServer((HOST, PORT), MyUDPHandler)
server.serve_forever()




#创建多线程类型的TCP SocketServer：
import socket
import threading
import SocketServer
class ThreadedTCPRequestHandler(SocketServer.BaseRequestHandler):
    def handle(self):
        data = self.request.recv(1024)
        cur_thread = threading.current_thread()
        response = "{}: {}".format(cur_thread.name, data)
        self.request.sendall(response)

class ThreadedTCPServer(SocketServer.ThreadingMixIn, SocketServer.TCPServer):#继承ThreadingMixIn表示使用多线程处理request，注意这两个类的继承顺序不能变
    pass

    def client(ip, port, message):
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.connect((ip, port))
        try:
            sock.sendall(message)
            response = sock.recv(1024)
            print "Received: {}".format(response)
        finally:
            sock.close()

if __name__ == "__main__":
    HOST, PORT = "localhost", 0
    server = ThreadedTCPServer((HOST, PORT), ThreadedTCPRequestHandler)
    ip, port = server.server_address
    server_thread = threading.Thread(target=server.serve_forever)
    server_thread.daemon = True
    server_thread.start()
    print "Server loop running in thread:", server_thread.name
    client(ip, port, "Hello World 1")
    client(ip, port, "Hello World 2")
    client(ip, port, "Hello World 3")
    server.shutdown()