socket简介

在编程的过程中，我们需要使用网络编程，这时我们不得不和网络通信的底层基础打交道了.我们必须让自己传输的数据符合网络通信的基本协议，即TCP/IP协议，但是网络通信协议本身很复杂.我们不可能在编程的过程中还自己去对数据进行封包处理，这是便出现了socket帮助我们处理相关的数据传输，在其他语言里也可以使用socket帮我们处理相关问题.

socket本质就是一组接口，是在应用层与TCP/IP协议族通信中间的一个抽象层，庞大复杂的TCP/IP协议族我们便可以不用过多关注，而只需要通过socket提供的接口就可以相互连接.

socke模块中的基本命令

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.recvfrom()        接收UDP数据

s.sendto()          发送UDP数据

s.getpeername()     连接到当前套接字的远端的地址

s.getsockname()     当前套接字的地址

s.getsockopt()      返回指定套接字的参数

s.setsockopt()      设置指定套接字的参数

s.close()           关闭套接字

s.setblocking()     设置套接字的阻塞与非阻塞模式

s.settimeout()      设置阻塞套接字操作的超时时间

s.gettimeout()      得到阻塞套接字操作的超时时间

s.fileno()          套接字的文件描述符

s.makefile()        创建一个与该套接字相关的文件

TCP的服务端和客户端示例

TCP服务端

import socket

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

##网络编程需要调用AF_INET，而SOCK_STREAM代表数据流，即TCP方式

phone.bind(('192.168.1.101',9000))

##绑定IP地址和端口，必须是元组

phone.listen(5)

##设置监听数量

while True:

    conn, addr = phone.accept()

    ##得到内容对象和地址

    while True:

        try:  ##异常处理特殊情况

            feedback = conn.recv(1024)

            ##得到内容对象传来的值，里面规定字节数量

            print(feedback.decode("UTF-8"))

            ##编译，因为只有被编译的字符才能被传输

            msg = input(">>:")

            conn.send(msg.encode("UTF-8"))

            ##发送

        except Exception:

            break

conn.close() ##关闭连接了的对象

phone.close() ##关闭服务器

TCP客户端

import socket

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

phone.connect_ex(('192.168.1.101',9000)) ##连接对象

while True:

    msg = input(">>:")

    phone.send(msg.encode("UTF-8")) ##发送消息

    feedback = phone.recv(1024) ##返回消息

    print(feedback.decode("UTF-8"))

phone.close() ##关闭对象

问题

可能在多次开启关闭服务器的时候，会出现IP地址已经被使用了的情况，我们可以用以下方法解决：

phone = socket(AF_INIT, SOCKET_STREAM)

phone.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)

phone.bind(('192.168.1.101',9000))

UDP的服务端和客户端示例

UDP的服务端

from socket import *

ip_addr = ('192.168.1.101',9000)

buff_size = 1024

udp_server = socket(AF_INET, SOCK_DGRAM)

##SOCK_DGRAM表示UDP方式

udp_server.bind(ip_addr)

##绑定IP地址和端口

while True:

    data, addr = udp_server.recvfrom(buff_size)

    ##受信息

    print(data.decode("utf-8"))

    udp_server.sendto(data.upper(), addr)

    ##发信息

UDP的客户端

from socket import *

ip_addr = ('192.168.1.101',9000)

buff_size = 1024

udp_client = socket(AF_INET, SOCK_DGRAM)

while True:

    msg = input(">>:")

    udp_client.sendto(msg.encode("utf-8"), ip_addr)

    ##不需要绑定，只需要传一个地址

    date, addr = udp_client.recvfrom(buff_size)

    print(date.decode("utf-8"))

subprogress模块

TCP和UDP比较

	TCP	UDP
传输方式	数据流（STREAM）	数据报（DGRAM）
导致问题	粘包	丢包
接待对象	一个	多个
连接	需要连接线	不需要连接线

TCP是以数据流的方式，在数据很多时，会多次地不分内容关联性地传输给对方内核态缓存，当用户态缓存来取数据时，并不知道数据的开头和结尾，那么就出现了粘包现象.因此粘包问题主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的，所以通过TCP方式不能发送空.

然而，UDP方式是以信息为单位传输数据，在数据里面包含了开头和结尾的界限，因此不会出现粘包的现象，但是当传输来的数据被储存在内核态缓存里面时，如果应用态缓存没有一次性的取完数据，那么数据就会被丢弃

解决了粘包现象的远程指令程序

客户端

from socket import *

ip_port = ('127.0.0.1', 9000)

client = socket(AF_INET, SOCK_STREAM)

client.connect_ex(ip_port)

while True:

    command = input(">>:")

    if not command: continue

    client.send(command.encode("utf-8"))

    feedback_of_length = int(client.recv(1024).decode("gbk"))  #先得到数据的长度

    client.send("OK".encode("gbk"))   #并且发送可以传输了的命令

    all_data = b""

    data_length = 0

    while data_length < feedback_of_length:

        all_data += client.recv(1024)  #循环地把数据联结在一起

        data_length = len(all_data)

    last_date = all_data.decode("gbk")  ##最后解码

    print(last_date)

client.close()

服务端

from socket import *

import subprocess

ip_port = ('127.0.0.1', 9000)

buff_size = 5

server = socket(AF_INET, SOCK_STREAM)

server.bind(ip_port)

server.listen(buff_size)

while True:

    conn, addr = server.accept()

    while True:

        try:

            cmd = conn.recv(1024)

            if not cmd: continue

            res = subprocess.Popen(cmd.decode("utf-8"), shell=True,

                                   stderr = subprocess.PIPE,

                                   stdin = subprocess.PIPE,

                                   stdout = subprocess.PIPE

            )

            err = res.stderr.read()

            if not res:

                get_res = "Run Perfectly"

            elif err:

                get_res = err

            else:

                get_res = res.stdout.read()

            length_of_res = len(get_res)  #发送数据长度

            conn.send(str(length_of_res).encode("gbk"))

            last_info = conn.recv(1024)   #得到是否传输的指令

            if last_info.decode("utf-8") == "OK":

                 conn.send(get_res)

        except Exception:

            break

socketserver实现并发

TCP版服务端

import socketserver

class MyServer(socketserver.BaseRequestHandler):  ##必须要继承这个父类

	def handle(self):  ##必须要重新定义这个方法

		while True:

			try:

				data = self.request.recv(1024)  ##recv就相当于conn了

				if not data: break

				print(data.decode("utf-8"), self.client_address) ##只有data和client_address这两个量

				self.request.sendall(data)

			except Exception:

				break

if __name__ == "__main__":

	s = socketserver.ThreadingTCPServer(('192.168.1.101',9001), MyServer)  ##实例化一个对象

	s.serve_forever()  ##永远运行

UDP版服务端

import socketserver

class MyServer(socketserver.BaseRequestHandle):

	def handle(self):

        ##(b'ad', <socket.socket fd=444, family=AddressFamily.AF_INET, type=SocketKind.SOCK_DGRAM, proto=0,

        ##   laddr=('192.168.1.101', 8081)>)  request是一个元组

		print(self.request[0].decode("utf-8"))

		self.request[1].sendto(self.request[0], self.client_address)

if __name__ == "__main__":

	s = socketserver.ThreadingUDPServer(('192.168.1.101',8080), MyServer)

	s.server_forever()